3 Interesting Uses Of Python's Context Managers - KDnuggets

Återutgiven av Platon

anhängare: 0

3 Intressanta användningsområden för Pythons kontexthanterare
Bild av johnstocker on Freepik

För ett tag sedan skrev jag en tutorial om skriva effektiv Python-kod. I den pratade jag om att använda context managers och with statement för att hantera resurser effektivt.

Jag använde ett enkelt filhanteringsexempel för att visa hur filer stängs automatiskt när exekveringen avslutar with-blocket – även om det finns ett undantag.

Även om filhantering är ett bra första exempel kan det snabbt bli tråkigt. Det är därför jag skulle vilja gå igenom andra intressanta användningar av kontexthanterare – utöver filhantering – i den här handledningen. Vi kommer att fokusera på att hantera databasanslutningar, hantera delprocesser och aritmetik med hög precision med flyttal.

Kontexthanterare i Python låter dig skriva renare kod när du arbetar med resurser. De ger en kortfattad syntax för att ställa in och riva resurser genom:

An Till New Earth logik som anropas när exekveringen kommer in i sammanhanget och
An avsluta logic the anropas när exekveringen lämnar sammanhanget

Det enklaste exemplet på detta är filhantering. Här använder vi open() funktion i with uttalande för att få en filhanterare:

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

Detta förvärvar resursen – filobjektet – som används (vi skriver till filen) inom kodblocket. Filen stängs när körningen lämnar sammanhanget; så det finns inga resursläckor.

Du kan skriva den allmänna versionen av detta så här:

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

# resource cleanup is automatic

Låt oss nu gå vidare till de specifika exemplen.

När du bygger Python-applikationer är det ganska vanligt att ansluta till databaser och fråga tabellerna de innehåller. Och arbetsflödet för att göra detta kommer att se ut så här:

Installera databasanslutaren för att fungera med databasen (som psycopg2 för Postgres och mysql-connector-python för MySQL-databaser).
Analysera konfigurationsfilen för att hämta anslutningsparametrarna.
Använd connect() funktion för att upprätta anslutning till databasen.

3 Intressanta användningsområden för Pythons kontexthanterare
Ansluter till db | Bild av författare

När du har anslutit till databasen kan du skapa en databas för att fråga databasen. Kör frågor och hämta resultaten av frågan med metoderna kör och hämta markören.

3 Intressanta användningsområden för Pythons kontexthanterare
Frågar i db | Bild av författare

När du gör det skapar du följande resurser: en databasanslutning och en databasmarkör. Låt oss nu koda ett enkelt generiskt exempel för att se hur vi kan använda anslutningen och markörobjekten som kontexthanterare.

Parsar TOML-filer i Python

Överväg ett exempel på en TOML-fil, säg db_config.toml, som innehåller den information som krävs för att ansluta till databasen:

# db_config.toml

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

Anmärkningar: Du behöver Python 3.11 eller en senare version för att använda tomllib.

Python har en inbyggd tomllib modul (introducerad i Python 3.11) som låter dig analysera TOML-filer. Så du kan öppna filen db_config.toml och analysera dess innehåll så här:

import tomllib

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

Lägg märke till att vi klickar på "databasen" i filen db_config.toml. De load() funktion returnerar en Python-ordbok. Du kan verifiera detta genom att skriva ut innehållet i credentials:

print(credentials)

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

Ansluter till databasen

Säg att du vill ansluta till en Postgres-databas. Du kan installera psychopg2-kontakt använder pip:

pip install psycopg2

Du kan använda både anslutnings- och markörobjekten med satser som visas:

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 den här koden:

Vi använder with för att skapa ett sammanhang för att hantera databasanslutningen.
Inuti detta sammanhang skapar vi ett annat sammanhang för att hantera databasmarkören. Markören stängs automatiskt när du lämnar detta inre sammanhang.
Eftersom anslutningen också stängs när man lämnar det yttre sammanhanget, säkerställer denna konstruktion att både anslutningen och markören hanteras korrekt – vilket minskar risken för resursläckor.

Du kan också använda en liknande konstruktion när du arbetar med SQLite- och MySQL-databaser.

Pythons delprocessmodul ger funktionalitet för att köra externa kommandon i ett Python-skript. De subprocess.Popen() konstruktorn skapar en ny delprocess. Som du kan använda i en with uttalande så här:

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)

Här kör vi kommandot Bash ls -l kommando för att lång lista filerna i den aktuella katalogen:

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

Resurserna som är associerade med underprocessen frigörs när exekveringen lämnar kontexten för with uttalande.

Den inbyggda flytdatatypen i Python är inte lämplig för aritmetik med hög precision med flyttal. Men du behöver hög precision när du arbetar med finansiell data, sensoravläsningar och liknande. För sådana applikationer kan du använda decimal- modul istället.

Smakämnen localcontext() fungera returnerar en kontexthanterare. Så du kan använda localcontext() funktion i with uttalande och ställ in precisionen för det aktuella sammanhanget med hjälp av som visas:

from decimal import Decimal, localcontext

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

Här är utgången:

Output >>>
0.6666666666666666666666666666666666666667

Här är precisionen inställd på 40 decimaler — men bara inom detta with blockera. När exekveringen lämnar det aktuella sammanhanget, återställs precisionen till standardprecisionen (med 28 decimaler).

I den här handledningen lärde vi oss hur kontexthanterare kan användas för att hantera databasanslutningar, hantera delprocesser och sammanhang i högprecisions flyttalsaritmetik.

I nästa handledning kommer vi att se hur vi kan skapa anpassade sammanhangshanterare i Python. Tills dess, glad kodning!

Bala Priya C är en utvecklare och teknisk skribent från Indien. Hon gillar att arbeta i skärningspunkten mellan matematik, programmering, datavetenskap och innehållsskapande. Hennes intresseområden och expertis inkluderar DevOps, datavetenskap och naturlig språkbehandling. Hon tycker om att läsa, skriva, koda och fika! För närvarande arbetar hon med att lära sig och dela sin kunskap med utvecklargemenskapen genom att skriva självstudier, guider, åsiktsartiklar och mer.