Administradores de contexto

Introducción

Los programadores a menudo trabajan con recursos externos como bases de datos, archivos, conexiones, etc. Dado que estas operaciones son tan comunes, Python tiene herramientas integradas llamadas administradores de contexto que permiten a los programadores manejar fuentes externas de manera eficiente. Las funciones integradas del administrador de contexto pueden ser útiles, pero todavía hay muchos casos en los que necesitará administradores de contexto personalizados.

Bajo el capó, los administradores de contexto realizan tareas para limpiar las conexiones o los recursos usados para que estén listos para más adelante. Un caso de uso común que puede haber visto es un administrador de contexto que abre un archivo y lo cierra después de que se realiza alguna operación:

Este es el patrón más común para usar administradores de contexto, pero también hay muchos otros:

Cuando se encuentre en una de estas situaciones, encontrará que no hay muchas funciones integradas que vengan en su ayuda. Afortunadamente, ¡puedes construir uno tú mismo!

Cómo crear un administrador de contexto personalizado

Hay dos formas de crear administradores de contexto definidos por el usuario:

• basado en clases
• basado en funciones

Dado que la primera forma es un poco más compleja y algunos lectores pueden no estar familiarizados con los conceptos de POO en Python, elegiremos un método basado en funciones igualmente poderoso.

En este método, hay 5 pasos para implementar sus propios administradores de contexto:

1. Defina una función.
2. (opcional) Escriba cualquier código de configuración que necesite su contexto.
3. Utilice la palabra clave de yield.
4. (opcional) Escriba cualquier código de desmontaje que necesite su contexto.
5. Agrega el decorador @contextlib.contextmanager.

Creemos una función simple:

Creamos un administrador de contexto muy simple que imprime Bienvenido cada vez que abrimos el contexto y tan pronto como estamos fuera del contexto, imprime Adiós. Usémoslo antes de explicarlo más:

En primer lugar, para convertir una función en un administrador de contexto, necesitamos importar el módulo contextlib y agregar el decorador  @contextlib.contextmanager justo antes de la definición de la función. No es necesario que sepa qué son los decoradores para el alcance de este artículo, pero aquí hay un enlace a una buena fuente si desea saber más.

El segundo paso más importante es agregar una palabra clave de  yield. El código que escribe antes de yield se llama configuración. En la configuración, debe escribir toda la lógica que debe ejecutarse dentro del contexto, como conectarse a una base de datos, abrir un archivo, etc.

Lo que viene después de  yield siempre se ejecuta tan pronto como se sale del contexto. Dado que Python usa sangrías para bloques de código, escribir una sola declaración sin sangría le indica a Python que estamos fuera del contexto. El código que viene después de  yield también se llama código de desmontaje. En el desmontaje, realiza operaciones como cerrar conexiones, borrar recursos, etc.

Para llevar el punto a casa, implementemos un temporizador de uso común:

Python inicia el temporizador cada vez que el intérprete ve with timer(): y lo finaliza (ejecuta yield y lo que viene después) tan pronto como se escribe una nueva declaración sin sangría (print('Done!')))

Crear administradores de contexto que acepten argumentos

A veces, necesitaremos administradores de contexto que acepten argumentos y realicen operaciones con ellos en la sección de configuración. Para el primer ejemplo, implementemos el administrador de contexto de la función abierta incorporada, pero solo con la funcionalidad de solo lectura:

La mayoría de las veces, cuando los administradores de contexto aceptan argumentos, producen los resultados del código de configuración. Cuando un contexto produce un resultado, se puede acceder a la palabra clave  as como lo estamos haciendo en la función read_only anterior.

Aquí hay otro ejemplo que se conecta a una base de datos postgreSQL y devuelve la conexión:

Manejo de errores

Siempre es una buena práctica implementar el manejo de errores en su código. Los administradores de contexto no son una excepción.

Imagine que en nuestra función postgres_connect, el usuario genera un error antes de que el contexto alcance el desmontaje. Si esto sucede alguna vez, la conexión creada a la base de datos con sus credenciales permanecerá abierta y ya no podrá volver a conectarse. Para evitar esto, insertaremos declaraciones try-except que cierran la conexión independientemente de si hay un error o no:

Después de las declaraciones try-except, agregar el bloque  finally asegura que el código interno  finally se ejecute sin importar lo que suceda. Esta función es particularmente útil para los administradores de contexto.

Ahora, considere este ejemplo:

El administrador anterior cambia temporalmente el directorio de trabajo que le permitirá realizar operaciones dentro del contexto:

Por supuesto, el bloque de código anterior podría haberse ejecutado sin un administrador de contexto, pero entiendes la idea. Si cometimos algún error dentro del contexto, se generaría el error pero el directorio de trabajo volvería a donde estaba.

Conclusión

Creo que al leer este artículo, puede agregar administradores de contexto a la enorme pila de “Las razones por las que amo Python”. Son soluciones elegantes para muchas operaciones comunes que involucran recursos externos. Siempre que vea uno de estos patrones, asegúrese de usar un administrador de contexto o ¡cree uno para usted!