El objetivo de la nueva sentencia with es ser utilizada cuando queremos garantizar que un determinado código, normalmente responsable de hacer las operaciones de limpieza, sea ejecutado, sean cuales sean las circunstancias. Se suele usar un bloque try...finally para conseguir el mismo objetivo, pero el nuevo sistema ofrece algunas ventajas. Los detalles de esta mejora se pueden consultar en la PEP 343.

¿Cómo es y para que sirve?

La sentencia with es una nueva estructura de control cuya formulación básica es la siguiente:

with expresión:
    with-block

Y funciona así:

Se evalúa la expresión, y el resultado debe ser un objeto que soporte el protocolo de gestión de contextos (context management protocol). El objeto devuelto por la expresión ejecutará un código de inicialización y preparación, que será anterior al del bloque interno y, de igual manera, ejecutará código inmediatamente después de la finalización del bloque, permitiendo asi realizar operaciones de limpieza y finalización. Este código de finalización se ejecutará incluso en caso de una excepción.

Hay una segunda forma de uso, que sería la siguiente:

with expresión as var:
    with-block

En este caso, el objeto devuelto por la expresión puede retornar un valor, que se almacena en variable var. Obsérvese que en var NO se almacena el objeto resultado de la expresión, sino un valor retornado por dicho objeto.

La opción de uso de with está por defecto deshabilitada en Python 2.5, de forma que hay que añadir la siguiente directiva para habilitarla:

from __future__ import with_statement

Si, en Python podemos importar funcionalidades del futuro. Mola mogollón.

Esta sentencia pasará a estar habilitada por defecto en la siguiente versión, Python 2.6.

Ejemplo de uso

Algunos de los objetos estándar de Python soportan el protocolo de gestión de contextos, lo que significa que pueden ser usados con las expresiones with. Los objetos de tipo archivo (file) son un ejemplo:

with open('/etc/passwd', 'r') as f:
    for line in f:
        print line
        ... more processing code ...

Después de la ejecución del código anterior, el fichero abierto en f será cerrado automáticamente, incluso en el caso de que dentro del bucle for se produjera una excepción.

De igual manera, las variables condicionales (Condition) o de bloqueo (lock) definidas en el módulo threading también pueden usarse con la sentencia with.

lock = threading.Lock()
with lock:
    # Critical section of code
    ...

El bloqueo es automáticamente adquirido antes de la ejecución del bloque, y liberado una vez que el bloque haya finalizado.

En el módulo decimal también hay una nueva función, localcontext(), que facilita salvar y recuperar el contexto decimal actual. El contexto (un objeto de la clase decimal.Context) encapsula la precisión y caraterísticas de redondeo deseadas para los cálculos decimales.

from decimal import Decimal, Context, localcontext

# Displays with default precision of 28 digits
v = Decimal('578')
print v.sqrt()

with localcontext(Context(prec=16)):
    # All code in this block uses a precision of 16 digits.
    # The original context is restored on exiting the block.
    print v.sqrt()

Cómo crear nuestros propios gestores de contexto

Aunque su uso es muy sencillo, los mecanismos internos de la sentencia with son más complicados. La mayoría de la gente sólo usará la sentencia with con objetos ya existentes y preparados para ello; si este fuera su caso, puede saltarse tranquilamente el resto del texto. Para los demás, daremos un repaso con mayor detalle a la implementación, que será necesario si queremos declarar clases aptas para ser usadas con with.

A vista de pájaro, el protocolo de gestión de contexto es el siguiente:

• Se evalúa la expresión que sigue al with , y el resultado debe de ser un objeto que llamaremos gestor del contexto, o gestor para abreviar. El gestor debe tener dos métodos: __enter__() y __exit__().
  
  
• Se ejecuta el método __enter__ del gestor. El valor retornado, si lo hubiera, es asignado a la variable indicada con la expresión as variable. En caso de que no exista la expresión as, el valor se ignora.
  
  
• Se ejecuta el código del bloque interno.
  
  
• Si durante la ejecución del bloque interno se produjera una excepción, se llama al método __exit__(type, value, traceback) con los valores de la excepción (type es el tipo de excepción, value la excepción propiamente dicha y traceback la traza del programa hasta el momento del error). El valor retornado por el método __exit__ indica si la excepción debe elevarse de nuevo o no. Cualquier valor False eleva de nuevo la excepción, mientras que un resultado de True la suprime. Suprimir la excepción es, en principio, muy poco recomendable, porque privamos al autor del código contenido dentro del with de tratar el mismo la excepción. Las funciones y métodos en python retornan None si no tienen una cláusula return específica, y None es equivalente a False, así que lo habitual es que no haya clausula return.
  
  
• Si no se produjera ninguna excepción, se sigue llamando al método __exit__, pero los parámetros type, value y traceback se pasarán con el valor None.
  
  

Veamos un ejemplo: El esqueleto necesario para gestionar una base de datos con soporte para transacciones.

Para los que no quieran pinchar en los enlaces: Una transacción es un conjunto de cambios en la base de datos, agrupados como una unidad indivisible o atómica. Las transacciones se pueden confirmar (commit), lo que significa que todos los cambios se aplican a la base de datos, o rechazar (roll back), lo que significa que todos los cambios son descartados (incluso los que ya hubieran sido aplicados).

Supongamos que disponemos de un objeto que representa la conexión con la base de datos. Nuestro objetivo es escribir código como el siguiente:

db_connection = DatabaseConnection()
with db_connection as cursor:
    cursor.execute('insert into ...')
    cursor.execute('delete from ...')
    # ... more operations ...

La transacción se confirmará (commit) si el código en el bloque interno se ejecuta sin errores, y se rechazará (roll back) si se produjera alguna excepción en el mismo. Supondremos que la conexión a la base de datos implementa la siguiente interfaz:

class DatabaseConnection:
    # Database interface
    def cursor (self):
        "Returns a cursor object and starts a new transaction"
    def commit (self):
        "Commits current transaction"
    def rollback (self):
        "Rolls back current transaction"

El método __enter__() es muy fácil, simplemente tenemos que empezar la transacción. En este caso, el objeto de tipo cursor constituye un resultado muy útil, así que el método __enter__() lo retorna como resultado de su ejecución. El programador usuario podrá hacer uso del mismo en la sentencia with asociandolo a una variable con la sentencia as, como ya se ha visto.

class DatabaseConnection:
    ...
    def __enter__ (self):
        # Code to start a new transaction
        cursor = self.cursor()
        return cursor

El método __exit__() es más complicado, porque es el encargado de realizar casi todo el trabajo. En primer lugar, debe comprobar si se ha producido alguna excepción. Si no se hubiera producido ninguna, la transacción es confirmada. En caso contrario, es rechazada.

class DatabaseConnection:
    ...
    def __exit__ (self, type, value, tb):
        if tb is None:
            # No exception, so commit
            self.commit()
        else:
            # Exception occurred, so rollback.
            self.rollback()
            # return False

El módulo contextlib

Este módulo proporciona algunas funciones y un decorador que simplifican la creación de nuevos gestores de contexto.

El decorador se llama contextmanager, y permite definir un nuevo gestor simplemente escribiendo una función generadora, en vez de una clase (Aquí hay una explicación de lo que son las funciones generadoras en Python).

La función generadora retornará un único valor, usando la sentencia yield. El código hasta la llamada a yield consistirá en el código de inicialización, equivalente al método __enter__ que vimos antes, y el valor retornado equivaldrá al resultado de dicho método. El codigo posterior al yield equivaldrá al método __exit__; cualquier excepción elevada en el código del bloque interno será elevada antes en el yield.

El ejemplo de base de datos que vimos anteriormente se podría escribir, por tanto, como una función generadora:

from contextlib import contextmanager

@contextmanager
def db_transaction (connection):
    cursor = connection.cursor()
    try:
        yield cursor
    except:
        connection.rollback()
        raise
    else:
        connection.commit()

db = DatabaseConnection()
with db_transaction(db) as cursor:
    ...

El módulo contextlib también proporciona una función, nested(), cuyo objetivo es combinar una serie de gestores de contexto de forma que no sea necesario anidar las sentencias with. Por ejemplo, si quisiéramos empezar una transacción a la base de datos a la vez que adquirimos un bloqueo, podríamos hacerlo así:

lock = threading.Lock()
with db_transaction(db) as cursor:
    with threading.Lock() as locked:
        ...

pero usando la función nested, quedaría así:

lock = threading.Lock()
with nested (db_transaction(db), lock) as (cursor, locked):
    ...

Por último, la función closing(object) retorna el objeto que se le pasa como resultado, permitiendo así que se vincule a una variable con la expresión as, y llama al método object.close() cuando se termina de ejecutar el bloque de código interno. ¿Para quá sirve eso? Se entiende mejor con un ejemplo:

import urllib, sys
from contextlib import closing

with closing(urllib.urlopen('http://www.yahoo.com')) as f:
    for line in f:
        sys.stdout.write(line)

Esto permite usar el objeto urllib.urlopen dentro de una cláusula with, aunque no sea un gestor de contexto.

---

Más información sobre las novedades en Python 2.5

---

Actualización (16/Oct/2006)
Se me ha ocurrido otro ejemplo:

from __future__ import with_statement

class Html(object):
    def __init__(self, titulo):
        self.Titulo = titulo
    def __enter__(self):
        print '<html>\n<head>'
        print '<title>%s</title>' % self.Titulo
        print '</head>\n<body>'
    def __exit__(self, tipo, valor, traza):
        print '</Body>\n</html>'

with Html('Este es el título'):
    print '<p>Hola, mundo.</p>'

Que produciría el siguiente resultado:

<html>
<head>
<title>Este es el título</title>
</head>
<body>
<p>Hola, mundo.</p>
</Body>
</html>

De antemano, y citando a Pascal, les pido disculpas por la longitud de este comentario. No he tenido tiempo de hacerlo más corto.

Generadores e Iteradores

Python 2.5 añade la posibilidad de pasar valores a un generador. Pero antes, recordemos qué es, y para qué sirve, un generador. Los generadores están con nosotros desde Python 2.3 y, básicamente, son funciones cuyo resultado es un iterador.

¿Y qué es, y para qué sirve, un iterador, se preguntará el astuto lector?

Los iteradores son contenedores, capaces de devolver sus elementos de uno en uno. Los iteradores se pueden usar en un bucle for y en otros lugares donde se necesite una secuencia, como por ejemplo, en las funciones zip(), map() o lambda() reduce(). Son iteradores todos los tipos de secuencia (como list, str y tuple), algunos otros tipos, como dict y file, y cualquier objeto cuya clase defina los métodos __iter__() y __getitem__().

El generador, decíamos, es como una función normal, solo que retorna un iterador. La única diferencia aparente entre una función normal y un generador es que se usa la palabra reservada yield en vez de return. Las funciones generadoras suelen contener uno o más bucles que devuelven (yield) elementos al llamante. La ejecución de la función se para en la palabra clave yield (devolviendo el resultado) y se reanuda cuando se solicita el siguiente elemento llamando al método next() del iterador devuelto.

Los generadores son, por tanto, una herramienta simple y potente para crear iteradores. Cada vez que se quiere obtener un nuevo elemento, el generador reanuda la ejecución donde se quedó (recordando todos los valores de los datos y la última sentencia en ejecutarse). Este ejemplo muestra lo fácil que es crear generadores:

def delreves(data):
    for indice in range(len(data)-1, -1, -1):
        yield data[indice]
 
>>> for car in delreves('Wanda'):
...     print car
...
a
d
n
a
W

Cualquier cosa que se pueda hacer con generadores se puede hacer también definiendo una clase iterador. Lo único que aportan los generadores es que su métodos __iter__() y next() se crean automáticamente. Además, como las variables locales y el estado de ejecución se guardan automáticamente entre llamadas, la función generadora es más fácil de escribir y no requiere utilizar variables de instancia como self.indice o self.datos. Cuando los generadores terminan su ejecución, hacen saltar la excepción StopIteration automáticamente. La combinación de estas características hace que la creación de iteradores sea tan sencilla como la de una función normal.

En fin, más información, y más detallada sobre estos temas, se puede consultar aquí: Iteradores y aquí: Generadores.

Nuevas posibilidades

Los generadores antes de Python 2.5 sólo producían salidas; una vez realizada la primera llamada, (momento en el cual se crea el iterador), no hay forma de añadir nueva información a la función generadora. En determinados casos, la posibilidad de alterar el comportamiento de la función de una determinada manera durante la secuencia de llamadas puede ser útil. Algunas soluciones para este problema en el momento actual incluyen utilizar variables globales (¡Aurghhh!) o pasarle a la función un objeto mutable, que pueda ser modificado por el llamador de la función.

Veamos como podremos hacerlo a partir de Python 2.5 con un ejemplo. Supongamos el siguiente generador:

def counter (maximum):
    i = 0
    while i < maximum:
        yield i
        i += 1

En este punto, debería estar claro que una llamada a counter(9), por ejemplo, devolvería consecutivamente los valores desde 0 hasta 9.

A partir de Python 2.5, yield pasa de ser una sentencia a ser una expresión; en otras palabras, yield puede retornar un valor, que puede ser utilizado o asignado a una variable.

val = (yield i)

Nota: Es recomendable rodear con paréntesis la expresión yield, siempre que se utiliza para algo, como en el ejemplo anterior en que es asignado a una variable. No son siempre necesarios, pero es más fácil añadirlos siempre que aprenderse los casos especiales en que no son necesarios (De todas formas, si se es lo suficientemente aguerrido, las reglas exactas están explicadas en el PEP 342 - Coroutines via Enhanced Generators)

Los valores son enviados al generador llamando al método send(value) del generador (Recordemos que en Python, casi todo es un objeto, incluyendo las funciones). Cuando se llama a send, se continua con la ejecución del código del generador, y la expresión yield retorna el valor especificado. Si se llama al método normal, next(), yield retorna None.

En el siguiente ejemplo, modificamos el código para permitirnos cambiar el valor del contador en medio de las sucesivas llamadas.

def counter (maximum):
    i = 0
    while i < maximum:
        val = (yield i)
        # If value provided, change counter
        if val is not None:
            i = val
        else:
            i += 1

Con lo cual podriamos hacer lo siguiente:

>>> it = counter(10)
>>> print it.next()
0
>>> print it.next()
1
>>> print it.send(8)
8
>>> print it.next()
9
>>> print it.next()
Traceback (most recent call last):
  File ``t.py'', line 15, in ?
    print it.next()
StopIteration

Además de send(value), hay dos nuevos métodos en los generadores:

• throw(type, value=None, traceback=None) se puede utilizar para elevar una excepción dentro del cuerpo del generador. La expresión yield elevará la excepción en la siguiente ejecución. Podemos utilizar esta llamada y pasarle la interrupción StopIteration, para forzar el fin del generador, pero para eso, mejor usar el siguiente método.



• close() eleva una excepción de tipo GeneratorExit que obliga a finalizar el generador. Es invocada por el recolector de basura de Python justo antes de liberar el generador. Esto significa que el código del generador obtiene una última oportunidad de ser ejecutado antes de terminar. De esta forma se garantiza que las sentencias try...finally sean ejecutadas. De esta forma se elimina una restricción semántica que se había impuesto en la versión anterior, que impedía mezclar el uso de yield con try...finally. Era necesario eliminar esta restricción para poder implementar la sentencia with, descrita en el PEP 343 - The "with" Statement.

Ejercicio para el lector

Modificar el ejemplo del generador counter() para permitirnos modificar el límite máximo, en vez del contador. Las respuestas, en los comentarios. Los que consigan terminar el ejercicio serán obsequiados con una impresión de honda satisfaccion por el trabajo bien realizado.

---

Más información sobre las novedades en Python 2.5