Uso de contextlib para la gestión de contextos en Python

La seguridad del código es una parte cada vez más importante a la hora de escoger una tecnología. En Python, uno de los mecanismos que facilitan la escritura de código seguro, al mismo tiempo que lo hacen eficiente, son los context managers. Mediante el cual se hace más sencilla la gestión de los recursos. Con este mecanismo se puede garantizar la liberación adecuada de los recursos después de ser utilizados, como los archivos o las conexiones a red, incluso si ocurre un error durante su uso. Las herramientas para trabajar con context managers se encuentran en el módulo contextlib. En esta entrada se explicará qué son los context managers y cómo se puede usar el módulo contextlib para manejo de contextos en Python.

¿Qué son los Context Managers de Python?

Un context manager es una estructura que controla el inicio y el final de un bloque de código, asegurando que los recursos se gestionen de forma adecuada. El uso más común de un context manager es mediante el uso de la palabra clave with. Por ejemplo, para abrir un archivo como en el siguiente ejemplo.

with open('archivo.txt', 'r') as archivo:
    contenido = archivo.read()

En este bloque de código se abre el archivo archivo.txt en modo lectura con la función open() almacenado la conexión en la variable archivo. Dentro del contexto se lee el contenido y se guarda en la variable contenido. Finalmente, el archivo se cierra automáticamente al salir del bloque with, incluso si ocurre una excepción. Básicamente hace lo mismo que el siguiente código:

En Analytics Lane

Faker en Python: qué es, para qué sirve y cómo generar datos sintéticos realistas

archivo = open('archivo.txt', 'r')
contenido = archivo.read()
archivo.close()

Pero, en ese caso, si se produce una excepción antes de cerrar el archivo este se mantendrá abierto, cosa que no sucede cuando se usa el bloque with.

Acceder a los recursos mediante el uso de context manager es clave en aplicaciones que dependen de recursos externos, como archivos, conexiones a bases de datos o sockets de red, ya que garantiza que los recursos se liberen correctamente. Evitando de este modo problemas como fugas de memoria o bloqueos de archivos.

Funcionamiento interno de los context managers de Python

En Python, los context managers se pueden crear implementado dos métodos especiales de las clases, uno que se ejecuta inicio del bloque y otro al final:

• __enter__: Este método es llamado al inicio del bloque with, donde se pueden iniciar los recursos.
• __exit__: Este método es llamado al final del bloque with, ya sea que el bloque haya terminado con éxito o debido a una excepción. Por lo que se puede usar para cerrar las conexiones que se han abierto en el método __enter__

En el siguiente ejemplo se puede claramente el funcionamiento de estos métodos en un bloque with.

class MiContextManager:
    def __enter__(self):
        print("Entrando al contexto")
        return self

    def __exit__(self, tipo, valor, traza):
        print("Saliendo del contexto")


with MiContextManager():
    print("Dentro del bloque")

Al ejecutar esta código se obtiene una salida como la siguiente:

Entrando al contexto
Dentro del bloque
Saliendo del contexto

En la salida, se puede ver que primero se ejecuta el método __enter__, posteriormente el código del bloque with y, finalmente, el método __exit__. El método __exit__ se ejecuta incluso cuando se lanza una excepción dentro del bloque.

with MiContextManager():
    raise ValueError("Dentro del bloque")

Ahora, la salida que se obtiene al ejecutar el código será como la que se muestra a continuación:

Entrando al contexto
Saliendo del contexto
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[2], line 2
      1 with MiContextManager():
----> 2     raise ValueError("Dentro del bloque")

ValueError: Dentro del bloque

Este patrón es útil, pero implementar los métodos __enter__ y __exit__ para cada context manager puede resultar algo tedioso. Siendo este el punto donde el módulo contextlib puede ser utilizado para simplificar el proceso.

Creación de context managers con contextlib

El módulo contextlib permite crear context managers de manera mucho más sencilla utilizando decoradores que hacen el código más legible y sencillo.

@contextmanager: Creación de context managers mediante decoradores

Uno de los decoradores más útiles del módulo contextlib es @contextmanager. Mediante el que se puede convertir una función en un context manager sin la necesidad de crear una clase e implementar los métodos __enter__ y __exit__ . Esto es lo que se muestra en el siguiente ejemplo:

from contextlib import contextmanager


@contextmanager
def mi_contexto():
    print("Inicio del contexto")
    yield
    print("Final del contexto")


with mi_contexto():
    print("Dentro del bloque")

Al ejecutar esta código se obtiene una salida como la siguiente:

Inicio del contexto
Dentro del bloque
Final del contexto

En este ejemplo, el decorador @contextmanager maneja tanto la entrada como la salida del contexto:

• El código antes de la palabra reservada yield se ejecuta al entrar al contexto.
• El código después de yield se ejecuta al salir del contexto.

Manejo de excepciones dentro del context manager

Una de las grandes ventajas de los context managers es que permiten manejar excepciones de manera eficiente, asegurando que los recursos se liberen incluso cuando ocurre un error. Si se ha creado una función con el decorador @contextmanager, la gestión de los errores se puede realizar con un bloque try-except-finally dentro de la función. Por ejemplo, en la función anterior se puede crear un bloque para cuando se lanza una excepción dentro del bloque with.

@contextmanager
def manejar_errores():
    try:
        print("Entrando al contexto")
        yield
    except Exception as e:
        print(f"Ocurrió un error: {e}")
    finally:
        print("Saliendo del contexto")


with manejar_errores():
    raise ValueError("Algo salió mal")

Con lo que se obtiene una salida como la siguiente:

Entrando al contexto
Ocurrió un error: Algo salió mal
Saliendo del contexto

En este ejemplo se puede ver cómo es posible capturar las excepciones dentro del contexto, evitando que se propaguen sin control, pero asegurando siempre que el bloque final se ejecute para liberar recursos.

ExitStack: Manejo de múltiples context managers

La forma más directa para gestionar múltiples context managers es anidar varios bloques with. Pero esta es una forma poco eficiente de hacerlo, ya que el código se vuelve difícil de leer y mantener a medida que se anidan más bloques. Para resolver este problema, contextlib ofrece ExitStack. Una clase que permite combinar varios context managers en un solo bloque, facilitando la gestión de múltiples recursos de forma dinámica. Un ejemplo básico del uso de esta clase es la que se muestra en el siguiente código.

from contextlib import ExitStack


with ExitStack() as stack:
    archivo1 = stack.enter_context(open('archivo1.txt', 'r'))
    archivo2 = stack.enter_context(open('archivo2.txt', 'r'))
    # Aquí puedes operar con ambos archivos

En este ejemplo, ExitStack permite usar tantos context managers como recursos sean necesarios, incluso cuando el número de estos son dinámicos. Dentro del bloque with, solamente se debe usar el método stack.enter_context() para la creación de un nuevo context manager. Garantizando que, al salir del bloque, todos los recursos serán liberados correctamente.

Ignorar las excepciones con contextlib.suppress

A veces, puede ser necesario ignorar ciertas excepciones que podrían surgir en un bloque de código. Para estas situaciones, contextlib ofrece suppress, una función que permite ignorar las excepciones dentro de un bloque with. El siguiente ejemplo muestra cómo se puede hacer esto.

from contextlib import suppress


with suppress(FileNotFoundError):
    open('archivo_que_no_existe.txt')

En este caso, si el archivo no existe, en lugar de lanzar una excepción, el bloque de código simplemente continuará ejecutándose sin interrumpir el programa.

Redirección de salida con contextlib.redirect_stdout y redirect_stderr

Otra funcionalidad interesante del módulo contextlib es la posibilidad de redirigir tanto la salida estándar (stdout) como los errores estándar (stderr). Algo que es útil si se desean enviar estos a un archivo de log. Por ejemplo, en el siguiente código se muestra cómo redirigir la salida estándar a un objeto StringIO.

from contextlib import redirect_stdout
import io


f = io.StringIO()
with redirect_stdout(f):
    print("Este mensaje será redirigido")


contenido = f.getvalue()
print(f"Contenido redirigido: {contenido}")

Código que, en la salida estándar, mostrará solamente un mensaje como el que se muestra a continuación:

Contenido redirigido: Este mensaje será redirigido

Conclusiones

Si en un programa Python es necesario acceder a recursos externos como archivos o conexiones de red los context managers son claves para que el código sea robusto y eficiente. Aunque se pueden crear context managers sin el módulo contextlib, su uso hace que la gestión de estos sea más fácil. Proporcionando herramientas tan útiles como:

• @contextmanager para convertir funciones generadoras en context managers.
• ExitStack para manejar múltiples context managers en un solo bloque.
• suppress para suprimir excepciones específicas de forma segura.
• redirect_stdout y redirect_stderr para redirigir flujos de salida.

Nota: La imagen de este artículo fue generada utilizando un modelo de inteligencia artificial.