3 interessante anvendelser af Pythons Context Managers - KDnuggets

Genudgivet af Platon

Abonnenter: 0

3 Interessante anvendelser af Pythons Context Managers
Billede af johnstocker på Freepik

For et stykke tid siden skrev jeg en tutorial om at skrive effektiv Python-kode. I den talte jeg om at bruge kontekstledere og with statement til at styre ressourcer effektivt.

Jeg brugte et simpelt filhåndteringseksempel til at vise, hvordan filer automatisk lukkes, når udførelsen afslutter med-blokken - også selvom der er en undtagelse.

Selvom filhåndtering er et godt første eksempel, kan det hurtigt blive kedeligt. Derfor vil jeg gerne gennemgå andre interessante anvendelser af kontekstadministratorer – ud over filhåndtering – i denne tutorial. Vi vil fokusere på håndtering af databaseforbindelser, styring af underprocesser og højpræcision flydende kommaaritmetik.

Context managers i Python giver dig mulighed for at skrive renere kode, når du arbejder med ressourcer. De giver en kortfattet syntaks til at opsætte og rive ned ressourcer gennem:

An indtaste logik, der bliver kaldt, når udførelsen kommer ind i konteksten og
An frakørsel logic the bliver kaldt, når udførelsen forlader konteksten

Det enkleste eksempel på dette er i filhåndtering. Her bruger vi open() funktion i with sætning for at få en filbehandler:

with open('filename.txt', 'w') as file:
    file.write('Something random')

Dette erhverver ressourcen - filobjektet - der bruges (vi skriver til filen) i kodeblokken. Filen lukkes, når udførelsen afslutter konteksten; så der er ingen ressourcelækager.

Du kan skrive den generiske version af dette sådan:

with some_context() as ctx:
    # do something useful on the resource!

# resource cleanup is automatic

Lad os nu gå videre til de specifikke eksempler.

Når du bygger Python-applikationer, er det ret almindeligt at oprette forbindelse til databaser og forespørge på de tabeller, de indeholder. Og arbejdsgangen til at gøre dette vil se sådan ud:

Installer databaseforbindelsen for at arbejde med databasen (såsom psycopg2 for Postgres og mysql-connector-python til MySQL-databaser).
Parse konfigurationsfilen for at hente forbindelsesparametrene.
Brug connect() funktion til at etablere forbindelse til databasen.

3 Interessante anvendelser af Pythons Context Managers
Tilslutning til db | Billede af forfatter

Når du har oprettet forbindelse til databasen, kan du oprette en database for at forespørge databasen. Kør forespørgsler, og hent resultaterne af forespørgslen ved hjælp af metoderne kør og hent markør.

3 Interessante anvendelser af Pythons Context Managers
Forespørger på db | Billede af forfatter

Når du gør det, opretter du følgende ressourcer: en databaseforbindelse og en databasemarkør. Lad os nu kode et simpelt generisk eksempel for at se, hvordan vi kan bruge forbindelsen og markørobjekterne som kontekstadministratorer.

Parsing af TOML-filer i Python

Overvej et eksempel på en TOML-fil, f.eks. db_config.toml, der indeholder de nødvendige oplysninger for at oprette forbindelse til databasen:

# db_config.toml

[database]
host = "localhost"
port = 5432
database_name = "your_database_name"
user = "your_username"
password = "your_password"

Bemærk: Du skal bruge Python 3.11 eller en nyere version for at bruge tomllib.

Python har en indbygget tomllib modul (introduceret i Python 3.11), der lader dig parse TOML-filer. Så du kan åbne filen db_config.toml og analysere dens indhold sådan:

import tomllib

with open('db_config.toml','rb') as file:
	credentials = tomllib.load(file)['database']

Bemærk, at vi trykker ind i 'database'-sektionen i filen db_config.toml. Det load() funktion returnerer en Python-ordbog. Du kan verificere dette ved at udskrive indholdet af credentials:

print(credentials)

Output >>>
{'host': 'localhost', 'port': 5432, 'database_name': 'your_database_name', 'user': 'your_username', 'password': 'your_password'}

Tilslutning til databasen

Lad os sige, at du vil oprette forbindelse til en Postgres-database. Du kan installere psychopg2 stik bruger pip:

pip install psycopg2

Du kan bruge både forbindelses- og markørobjekterne med udsagn som vist:

import psycopg2

# Connect to the database
with psycopg2.connect(**credentials) as conn:
	# Inside this context, the connection is open and managed

	with conn.cursor() as cur:
    	# Inside this context, the cursor is open and managed

    	cur.execute('SELECT * FROM my_table')
    	result = cur.fetchall()
            print(result)

I denne kode:

Vi bruger with sætning for at skabe en kontekst til styring af databaseforbindelsen.
Inde i denne kontekst opretter vi en anden kontekst til at styre databasemarkøren. Markøren lukkes automatisk, når denne indre kontekst forlades.
Fordi forbindelsen også er lukket, når den forlader den ydre kontekst, sikrer denne konstruktion, at både forbindelsen og markøren administreres korrekt - hvilket reducerer chancen for ressourcelækage.

Du kan også bruge en lignende konstruktion, når du arbejder med SQLite- og MySQL-databaser.

Pythons underprocesmodul giver funktionalitet til at køre eksterne kommandoer inde i et Python-script. Det subprocess.Popen() konstruktør opretter en ny underproces. Som du kan bruge i en with udsagn som sådan:

import subprocess

# Run an external command and capture its output
with subprocess.Popen(['ls', '-l'], stdout=subprocess.PIPE, text=True) as process:
	output, _ = process.communicate()
	print(output)

Her kører vi Bash-kommandoen ls -l kommando til lang liste over filerne i den aktuelle mappe:

Output >>>

total 4
-rw-rw-r-- 1 balapriya balapriya   0 Jan  5 18:31 db_info.toml
-rw-rw-r-- 1 balapriya balapriya 267 Jan  5 18:32 main.py

De ressourcer, der er knyttet til underprocessen, frigives, når eksekveringen forlader konteksten af with udmelding.

Den indbyggede flydende datatype i Python er ikke egnet til flydende aritmetik med høj præcision. Men du har brug for høj præcision, når du arbejder med økonomiske data, sensoraflæsninger og lignende. Til sådanne applikationer kan du bruge decimal modul i stedet for.

localcontext() funktion returnerer en kontekstmanager. Så du kan bruge localcontext() funktion i with sætning, og indstil præcisionen for den aktuelle kontekst ved at bruge som vist:

from decimal import Decimal, localcontext

with localcontext() as cur_context:
    cur_context.prec = 40
    a = Decimal(2)
    b = Decimal(3)
    print(a/b)

Her er output:

Output >>>
0.6666666666666666666666666666666666666667

Her er præcisionen sat til 40 decimaler - men kun indenfor dette with blok. Når udførelsen forlader den aktuelle kontekst, gendannes præcisionen til standardpræcisionen (på 28 decimaler).

I denne tutorial lærte vi, hvordan kontekstadministratorer kan bruges til at håndtere databaseforbindelser, administrere underprocesser og kontekster i højpræcision flydende kommaaritmetik.

I den næste vejledning vil vi se, hvordan vi kan oprette brugerdefinerede kontekstadministratorer i Python. Indtil da, glad kodning!

Bala Priya C er en udvikler og teknisk skribent fra Indien. Hun kan lide at arbejde i krydsfeltet mellem matematik, programmering, datavidenskab og indholdsskabelse. Hendes interesseområder og ekspertise omfatter DevOps, datavidenskab og naturlig sprogbehandling. Hun nyder at læse, skrive, kode og kaffe! I øjeblikket arbejder hun på at lære og dele sin viden med udviklerfællesskabet ved at skrive selvstudier, vejledninger, meningsindlæg og mere.