3 usos interesantes de los administradores de contexto de Python - KDnuggets

Reeditado por Platón

seguidores: 0

3 usos interesantes de los administradores de contexto de Python
Imagen de johnstocker en Freepik

Hace un tiempo escribí un tutorial sobre escribir código Python eficiente. En él, hablé sobre el uso de administradores de contexto y la declaración with para administrar recursos de manera eficiente.

Utilicé un ejemplo simple de manejo de archivos para mostrar cómo los archivos se cierran automáticamente cuando la ejecución sale del bloque with, incluso si hay una excepción.

Si bien el manejo de archivos es un buen primer ejemplo, puede volverse aburrido rápidamente. Es por eso que me gustaría repasar otros usos interesantes de los administradores de contexto (más allá del manejo de archivos) en este tutorial. Nos centraremos en el manejo de conexiones de bases de datos, la gestión de subprocesos y la aritmética de punto flotante de alta precisión.

Los administradores de contexto en Python le permiten escribir código más limpio cuando trabaja con recursos. Proporcionan una sintaxis concisa para configurar y eliminar recursos a través de:

An entrar lógica que se llama cuando la ejecución ingresa al contexto y
An salida lógica que se llama cuando la ejecución sale del contexto

El ejemplo más sencillo de esto es el manejo de archivos. Aquí utilizamos el open() en función de la with declaración para obtener un controlador de archivos:

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

Esto adquiere el recurso (el objeto de archivo) que se utiliza (escribimos en el archivo) dentro del bloque de código. El archivo se cierra una vez que la ejecución sale del contexto; por lo que no hay fugas de recursos.

Puedes escribir la versión genérica de esto así:

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

# resource cleanup is automatic

Ahora pasemos a los ejemplos específicos.

Cuando creas aplicaciones Python, es bastante común conectarse a bases de datos y consultar las tablas que contienen. Y el flujo de trabajo para hacer esto se verá así:

Instale el conector de la base de datos para trabajar con la base de datos (como psycopg2 para Postgres y mysql-connector-python para bases de datos MySQL).
Analice el archivo de configuración para recuperar los parámetros de conexión.
Ingrese al connect() Función para establecer conexión con la base de datos.

3 usos interesantes de los administradores de contexto de Python
Conexión a la base de datos | Imagen por autor

Una vez que se haya conectado a la base de datos, puede crear una base de datos para consultarla. Ejecute consultas y obtenga los resultados de la consulta utilizando los métodos de ejecución y recuperación del cursor.

3 usos interesantes de los administradores de contexto de Python
Consultando la base de datos | Imagen por autor

Al hacerlo, crea los siguientes recursos: una conexión de base de datos y un cursor de base de datos. Ahora codifiquemos un ejemplo genérico simple para ver cómo podemos usar la conexión y los objetos del cursor como administradores de contexto.

Análisis de archivos TOML en Python

Considere un archivo TOML de muestra, por ejemplo db_config.toml, que contiene la información necesaria para conectarse a la base de datos:

# db_config.toml

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

Note: Necesitas Python 3.11 o una versión posterior para usar tomlib.

Python tiene una función tomlib módulo (introducido en Python 3.11) que le permite analizar archivos TOML. Entonces puedes abrir el archivo db_config.toml y analizar su contenido de esta manera:

import tomllib

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

Observe que accedemos a la sección "base de datos" del archivo db_config.toml. El load() La función devuelve un diccionario de Python. Puede verificar esto imprimiendo el contenido de credentials:

print(credentials)

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

Conectarse a la base de datos

Supongamos que desea conectarse a una base de datos de Postgres. Puedes instalar el conector psycopg2 usando pipa:

pip install psycopg2

Puede utilizar tanto los objetos de conexión como los de cursor con declaraciones como se muestra:

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)

En este código:

Usamos la with declaración para crear un contexto para administrar la conexión de la base de datos.
Dentro de este contexto, creamos otro contexto para administrar el cursor de la base de datos. El cursor se cierra automáticamente al salir de este contexto interno.
Debido a que la conexión también se cierra al salir del contexto externo, esta construcción garantiza que tanto la conexión como el cursor se administren adecuadamente, lo que reduce la posibilidad de fugas de recursos.

También puede utilizar una construcción similar cuando trabaje con bases de datos SQLite y MySQL.

El módulo de subproceso de Python proporciona funcionalidad para ejecutar comandos externos dentro de un script de Python. El subprocess.Popen() El constructor crea un nuevo subproceso. Que puedes usar en un with declaración así:

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)

Aquí ejecutamos el comando Bash. ls -l comando para enumerar los archivos en el directorio actual:

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

Los recursos asociados con el subproceso se liberan una vez que la ejecución sale del contexto del with .

El tipo de datos flotante incorporado en Python no es adecuado para la aritmética de punto flotante de alta precisión. Pero sí se necesita alta precisión cuando se trabaja con datos financieros, lecturas de sensores y similares. Para tales aplicaciones, puede utilizar el decimal módulo en su lugar.

La localcontext() función devuelve un administrador de contexto. Entonces puedes usar el localcontext() en función de la with declaración y establezca la precisión para el contexto actual usando como se muestra:

from decimal import Decimal, localcontext

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

Aquí está la salida:

Output >>>
0.6666666666666666666666666666666666666667

Aquí, la precisión se establece en 40 decimales, pero sólo dentro de este with bloquear. Cuando la ejecución sale del contexto actual, la precisión se restaura a la precisión predeterminada (de 28 decimales).

En este tutorial, aprendimos cómo se pueden usar los administradores de contexto para manejar conexiones de bases de datos, administrar subprocesos y contextos en aritmética de punto flotante de alta precisión.

En el siguiente tutorial, veremos cómo podemos crear administradores de contexto personalizados en Python. Hasta entonces, ¡feliz codificación!

Bala Priya C. es un desarrollador y escritor técnico de la India. Le gusta trabajar en la intersección de matemáticas, programación, ciencia de datos y creación de contenido. Sus áreas de interés y experiencia incluyen DevOps, ciencia de datos y procesamiento de lenguaje natural. ¡Le gusta leer, escribir, codificar y tomar café! Actualmente, está trabajando para aprender y compartir su conocimiento con la comunidad de desarrolladores mediante la creación de tutoriales, guías prácticas, artículos de opinión y más.