Qué hay de nuevo en Python 2.6¶

Autor:: A.M. Kuchling (amk arroba amk.ca)

Este artículo explica las nuevas funciones de Python 2.6, publicadas el 1 de octubre de 2008. El programa de publicación se describe en PEP 361.

The major theme of Python 2.6 is preparing the migration path to Python 3.0, a major redesign of the language. Whenever possible, Python 2.6 incorporates new features and syntax from 3.0 while remaining compatible with existing code by not removing older features or syntax. When it’s not possible to do that, Python 2.6 tries to do what it can, adding compatibility functions in a future_builtins module and a -3 switch to warn about usages that will become unsupported in 3.0.

Se han agregado algunos paquetes nuevos importantes a la biblioteca estándar, como los módulos multiprocessing y json, pero no hay muchas características nuevas que no estén relacionadas con Python 3.0 de alguna manera.

Python 2.6 también incluye una serie de mejoras y correcciones de errores en el código fuente. Una búsqueda en los registros de cambios encuentra que se aplicaron 259 parches y se corrigieron 612 errores entre Python 2.5 y 2.6. Es probable que ambas cifras estén subestimadas.

Este artículo no intenta proporcionar una especificación completa de las nuevas características, sino que proporciona una conveniente descripción general. Para obtener detalles completos, debe consultar la documentación de Python 2.6. Si desea comprender la justificación del diseño y la implementación, consulte el PEP de una característica nueva en particular. Siempre que sea posible, «Qué hay de nuevo en Python» enlaza con el elemento de error / parche para cada cambio.

Python 3.0¶

El ciclo de desarrollo de las versiones 2.6 y 3.0 de Python se sincronizó, y las versiones alfa y beta de ambos lanzamientos se realizaron los mismos días. El desarrollo de 3.0 ha influido en muchas características de 2.6.

Python 3.0 es un rediseño de Python de gran alcance que rompe la compatibilidad con la serie 2.x. Esto significa que el código Python existente necesitará alguna conversión para poder ejecutarse en Python 3.0. Sin embargo, no todos los cambios en 3.0 rompen necesariamente la compatibilidad. En los casos en que las nuevas funciones no provoquen la rotura del código existente, se han actualizado a 2.6 y se describen en este documento en el lugar correspondiente. Algunas de las características derivadas de 3.0 son:

A __complex__() method for converting objects to a complex number.
Sintaxis alternativa para detectar excepciones: except TypeError as exc.
The addition of functools.reduce() as a synonym for the built-in reduce() function.

Python 3.0 adds several new built-in functions and changes the semantics of some existing builtins. Functions that are new in 3.0 such as bin() have simply been added to Python 2.6, but existing builtins haven’t been changed; instead, the future_builtins module has versions with the new 3.0 semantics. Code written to be compatible with 3.0 can do from future_builtins import hex, map as necessary.

A new command-line switch, -3, enables warnings about features that will be removed in Python 3.0. You can run code with this switch to see how much work will be necessary to port code to 3.0. The value of this switch is available to Python code as the boolean variable sys.py3kwarning, and to C extension code as Py_Py3kWarningFlag.

Ver también

La serie 3xxx de PEP, que contiene propuestas para Python 3.0. PEP 3000 describe el proceso de desarrollo para Python 3.0. Comience con PEP 3100, que describe los objetivos generales para Python 3.0, y luego explore los PEP de mayor número que proponen características específicas.

Cambios en el proceso de desarrollo¶

Mientras se desarrollaba 2.6, el proceso de desarrollo de Python experimentó dos cambios significativos: cambiamos del seguidor de incidentes (issue tracker) de SourceForge a una instalación personalizada de Roundup, y la documentación se convirtió de LaTeX a reStructuredText.

Nuevo seguidor de incidentes: Roundup¶

Durante mucho tiempo, los desarrolladores de Python estaban cada vez más molestos por el seguidor de errores de SourceForge. La solución alojada en SourceForge no permite mucha personalización; por ejemplo, no fue posible personalizar el ciclo de vida de los problemas.

Por lo tanto, el comité de infraestructura de la Python Software Foundation publicó una convocatoria de rastreadores de problemas, solicitando voluntarios para configurar diferentes productos e importar algunos de los errores y parches de SourceForge. Se examinaron cuatro rastreadores diferentes: Jira, Launchpad, Roundup y Trac. El comité finalmente se decidió por Jira y Roundup como los dos candidatos. Jira es un producto comercial que ofrece instancias alojadas sin costo para proyectos de software libre; Roundup es un proyecto de código abierto que requiere voluntarios para administrarlo y un servidor para alojarlo.

Después de publicar una llamada para voluntarios, se configuró una nueva instalación de Roundup en https://bugs.python.org. Una instalación de Roundup puede alojar varios seguidores, y este servidor ahora también aloja seguidores de problemas para Jython y para el sitio web de Python. Seguramente encontrará otros usos en el futuro. Siempre que sea posible, esta edición de «Qué hay de nuevo en Python» se vincula al elemento de error/parche para cada cambio.

Upfront Systems de Stellenbosch, Sudáfrica, proporciona amablemente el alojamiento del rastreador de errores de Python. Martin von Löwis se esforzó mucho en importar errores y parches existentes desde SourceForge; Sus scripts para esta operación de importación están en https://svn.python.org/view/tracker/importer/ y pueden ser útiles para otros proyectos que deseen pasar de SourceForge a Roundup.

Ver también

https://bugs.python.org: El seguidor de errores de Python.
https://bugs.jython.org:: El seguidor de errores de Jython.
https://roundup.sourceforge.io/: Descargas y documentación de Roundup.
https://svn.python.org/view/tracker/importer/: Scripts de conversión de Martin von Löwis.

Nuevo formato de documentación: texto reestructurado con Sphinx¶

La documentación de Python se escribió usando LaTeX desde que el proyecto comenzó alrededor de 1989. En la década de 1980 y principios de la de 1990, la mayor parte de la documentación se imprimió para su estudio posterior, no se vio en línea. LaTeX fue ampliamente utilizado porque proporcionaba una salida impresa atractiva sin dejar de ser sencillo de escribir una vez que se aprendían las reglas básicas de marcado.

Hoy en día, LaTeX todavía se usa para escribir publicaciones destinadas a la impresión, pero el panorama de las herramientas de programación ha cambiado. Ya no imprimimos montones de documentación; en su lugar, lo navegamos en línea y HTML se ha convertido en el formato más importante para dar soporte. Desafortunadamente, convertir LaTeX a HTML es bastante complicado y Fred L. Drake Jr., el editor de documentación de Python desde hace mucho tiempo, pasó mucho tiempo manteniendo el proceso de conversión. De vez en cuando, la gente sugeriría convertir la documentación a SGML y luego a XML, pero realizar una buena conversión es una tarea importante y nadie comprometió el tiempo necesario para terminar el trabajo.

Durante el ciclo de desarrollo 2.6, Georg Brandl se esforzó mucho en construir una nueva cadena de herramientas para procesar la documentación. El paquete resultante se llama Sphinx y está disponible en https://www.sphinx-doc.org/.

Sphinx se concentra en la salida HTML, produciendo HTML moderno y con un estilo atractivo; la salida impresa todavía se admite mediante la conversión a LaTeX. El formato de entrada es reStructuredText, una sintaxis de marcado que admite extensiones y directivas personalizadas que se usa comúnmente en la comunidad de Python.

Sphinx es un paquete independiente que se puede usar para escribir, y casi dos docenas de otros proyectos (enumerados en el sitio web de Sphinx) han adoptado Sphinx como su herramienta de documentación.

Ver también

Documentando Python: Describe cómo escribir para la documentación de Python.
Sphinx: Documentación y código para la cadena de herramientas Sphinx.
Docutils: El analizador sintáctico y el conjunto de herramientas reStructuredText subyacentes.

PEP 343: La sentencia “with”¶

La versión anterior, Python 2.5, agregó la instrucción “with” como una característica opcional, para ser habilitada por una directiva from __future__ import with_statement. En 2.6, la instrucción ya no necesita estar habilitada especialmente; esto significa que ahora with es siempre una palabra clave. El resto de esta sección es una copia de la sección correspondiente del documento «Qué hay de nuevo en Python 2.5»; si está familiarizado con la declaración “with” de Python 2.5, puede omitir esta sección.

La sentencia “with” resuelve el código que anteriormente usaría bloques try...finally para garantizar que el código de limpieza se ejecute. En esta sección, discutiré como se usará comúnmente la declaración. En la siguiente sección, examinaré los detalles de la implementación y mostraré cómo escribir objetos para usar con esta declaración.

La sentencia “with” es una estructura de control de flujo cuya estructura básica es:

with expression [as variable]:
    with-block

Se evalúa la expresión y debería dar como resultado un objeto que admita el protocolo de gestión de contexto (es decir, que tenga los métodos __enter__() y __exit__()).

El objeto __enter__() se llama antes de que se ejecute with-block y, por lo tanto, puede ejecutar el código de configuración. También puede devolver un valor vinculado al nombre variable, si se proporciona. (Tenga en cuenta que variable es not al que se le asigna el resultado de expression).

Una vez finalizada la ejecución de with-block, se llama al método __exit__() del objeto, incluso si el bloque generó una excepción y, por lo tanto, puede ejecutar código de limpieza.

Algunos objetos estándar de Python ahora admiten el protocolo de administración de contexto y se pueden usar con la sentencia “with”. Los objetos de archivo son un ejemplo:

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

Después de que se haya ejecutado esta sentencia, el objeto de archivo en f se habrá cerrado automáticamente, incluso si el bucle for generó una excepción en la mitad del bloque.

Nota

En este caso, f es el mismo objeto creado por open(), porque __enter__() retorna self.

Los locks y las condiciones variables del módulo threading también admiten la sentencia “with”:

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

El lock se adquiere antes de que se ejecute el bloque y siempre se libera una vez que este se completa.

The localcontext() function in the decimal module makes it easy to save and restore the current decimal context, which encapsulates the desired precision and rounding characteristics for computations:

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()

Escribiendo gestores de contexto¶

Por detrás, la sentencia “with” es bastante complicada. La mayoría de las personas solo usarán “with” en compañía de objetos existentes y no necesitan conocer estos detalles, por lo que puede omitir el resto de esta sección si lo desea. Los autores de nuevos objetos deberán comprender los detalles de la implementación subyacente y deben seguir leyendo.

Una explicación de alto nivel del protocolo de gestor de contexto es:

La expresión se evalúa y debería dar como resultado un objeto llamado «gestor de contexto». El gestor de contexto debe tener los métodos __enter__() y __exit__().
Se llama al método __enter__() del gestor de contexto. El valor retornado se asigna a VAR. Si no hay una cláusula as VAR, el valor simplemente se descarta.
Se ejecuta el código en BLOCK.
Si BLOCK genera una excepción, se llama al método __exit__() del administrador de contexto con tres argumentos: los detalles de la excepción (type, value, traceback, los mismos valores devueltos por sys.exc_info(), que también pueden ser None si no se produjo ninguna excepción). El valor de retorno del método controla si se vuelve a generar una excepción: cualquier valor falso vuelve a generar la excepción y True provocará su supresión. Solo en raras ocasiones querrá suprimir la excepción, porque si lo hace, el autor del código que contiene la declaración “with” nunca se dará cuenta de que algo salió mal.
Si BLOCK no lanzó una excepción, el método __exit__() continúa llamándose, pero type, value y traceback son todos None.

Pensemos en un ejemplo. No presentaré un código detallado, solo bosquejaré los métodos necesarios para una base de datos que admita transacciones.

(Para las personas que no están familiarizadas con la terminología de la base de datos: un conjunto de cambios en la base de datos se agrupa en una transacción. Las transacciones pueden confirmarse, lo que significa que todos los cambios se escriben en la base de datos, o deshacerse, lo que significa que todos los cambios se descartan y la base de datos no ha cambiado. Consulte cualquier libro de texto de base de datos para obtener más información.)

Supongamos que hay un objeto que representa una conexión de base de datos. Nuestro objetivo será permitir que el usuario escriba un código como este:

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

The transaction should be committed if the code in the block runs flawlessly or rolled back if there’s an exception. Here’s the basic interface for DatabaseConnection that I’ll assume:

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 bastante sencillo, ya que solo hay que iniciar una nueva transacción. Para esta aplicación, el objeto cursor resultante sería un resultado útil, por lo que el método lo devolverá. El usuario puede entonces añadir as cursor a su declaración “with” para vincular el cursor a un nombre de variable.

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

El método __exit__() es el más complicado porque es donde se debe realizar la mayor parte del trabajo. El método debe verificar si se produjo una excepción. Si no hubo excepción, se confirma la transacción. Si hubo una excepción, se revierte la transacción.

En el siguiente código, la ejecución simplemente caerá al final de la función, retornando el valor predeterminado None. None es falso, por lo que la excepción se volverá a lanzar automáticamente. Si lo desea, puede ser más explícito y agregar una sentencia return en la ubicación marcada.

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¶

El módulo contextlib proporciona algunas funciones y un decorador que son útiles al escribir objetos para usar con la sentencia “with”.

The decorator is called @~contextlib.contextmanager, and lets you write a single generator function instead of defining a new class. The generator should yield exactly one value. The code up to the yield will be executed as the __enter__() method, and the value yielded will be the method’s return value that will get bound to the variable in the “with” statement’s as clause, if any. The code after the yield will be executed in the __exit__() method. Any exception raised in the block will be raised by the yield statement.

Usando este decorador, nuestro ejemplo de base de datos de la sección anterior podría escribirse como:

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 tiene una función nested(mgr1, mgr2, ...) que combina varios gestores de contexto para que no necesite escribir sentencias “with” anidadas. En este ejemplo, se utiliza una única sentencia “with” que inicia una transacción de base de datos y adquiere un bloqueo del hilo:

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

Finally, the closing() function returns its argument so that it can be bound to a variable, and calls the argument’s .close() method at the end of the block.

importar urllib, sys
desde contextlib importar closing

con closing(urllib.urlopen('http://www.yahoo.com')) como f:
para línea en f:
sys.stdout.write(line)

Ver también

PEP 343 - La sentencia «with»: PEP escrito por Guido van Rossum y Nick Coghlan; implementado por Mike Bland, Guido van Rossum y Neal Norwitz. El PEP muestra el código generado para una sentencia “with”, que puede ser útil para aprender cómo la sentencia funciona.

La documentación para el módulo contextlib.

PEP 366: Importaciones relativas explícitas desde un módulo principal¶

El modificador de Python -m permite ejecutar un módulo como un script. Cuando ejecutabas un módulo que estaba ubicado dentro de un paquete, las importaciones relativas no funcionaban correctamente.

The fix for Python 2.6 adds a module.__package__ attribute. When this attribute is present, relative imports will be relative to the value of this attribute instead of the __name__ attribute.

PEP 302-style importers can then set __package__ as necessary. The runpy module that implements the -m switch now does this, so relative imports will now work correctly in scripts running from inside a package.

PEP 370: Directorio de `site-packages` por usuario¶

Cuando ejecuta Python, la ruta de búsqueda del módulo sys.path generalmente incluye un directorio cuya ruta termina en "site-packages". Este directorio está destinado a contener paquetes instalados localmente disponibles para todos los usuarios que utilizan una máquina o un sitio de instalación en particular.

Python 2.6 introduce una convención para directorios de sitios específicos del usuario. El directorio varía según la plataforma:

Unix y Mac OS X: ~/.local/
Windows: %APPDATA%/Python

Dentro de este directorio, habrá subdirectorios específicos de versión, como lib/python2.6/site-packages en Unix/Mac OS y Python26/site-packages en Windows.

If you don’t like the default directory, it can be overridden by an environment variable. PYTHONUSERBASE sets the root directory used for all Python versions supporting this feature. On Windows, the directory for application-specific data can be changed by setting the APPDATA environment variable. You can also modify the site.py file for your Python installation.

La característica se puede desactivar por completo ejecutando Python con la opción -s o seteando la variable de entorno PYTHONNOUSERSITE.

Ver también

PEP 370: Directorio de site-packages por usuario: PEP escrito e implementado por Christian Heimes.

PEP 371: El paquete `multiprocessing`¶

El nuevo paquete multiprocessing permite a los programas de Python crear nuevos procesos que realizarán un cálculo y retornaran un resultado al padre. Los procesos padre e hijo pueden comunicarse mediante colas (queues) y tuberías (pipes), sincronizar sus operaciones mediante bloqueos y semáforos, y pueden compartir matrices simples de datos.

The multiprocessing module started out as an exact emulation of the threading module using processes instead of threads. That goal was discarded along the path to Python 2.6, but the general approach of the module is still similar. The fundamental class is the Process, which is passed a callable object and a collection of arguments. The start() method sets the callable running in a subprocess, after which you can call the is_alive() method to check whether the subprocess is still running and the join() method to wait for the process to exit.

Aquí hay un ejemplo simple donde el subproceso calculará un factorial. La función que realiza el cálculo está escrita de forma extraña, por lo que lleva mucho más tiempo cuando el argumento de entrada es un múltiplo de 4.

import time
from multiprocessing import Process, Queue


def factorial(queue, N):
    "Compute a factorial."
    # If N is a multiple of 4, this function will take much longer.
    if (N % 4) == 0:
        time.sleep(.05 * N/4)

    # Calculate the result
    fact = 1L
    for i in range(1, N+1):
        fact = fact * i

    # Put the result on the queue
    queue.put(fact)

if __name__ == '__main__':
    queue = Queue()

    N = 5

    p = Process(target=factorial, args=(queue, N))
    p.start()
    p.join()

    result = queue.get()
    print 'Factorial', N, '=', result

Un Queue se usa para comunicar el resultado del factorial. El objeto Queue se almacena en una variable global. El proceso hijo usará el valor de la variable cuando se creó el hijo; porque es una Queue, padre e hijo pueden usar el objeto para comunicarse. (Si el padre cambiara el valor de la variable global, el valor del hijo no se vería afectado y viceversa).

Two other classes, Pool and Manager, provide higher-level interfaces. Pool will create a fixed number of worker processes, and requests can then be distributed to the workers by calling apply() or apply_async() to add a single request, and map() or map_async() to add a number of requests. The following code uses a Pool to spread requests across 5 worker processes and retrieve a list of results:

from multiprocessing import Pool

def factorial(N, dictionary):
    "Compute a factorial."
    ...
p = Pool(5)
result = p.map(factorial, range(1, 1000, 10))
for v in result:
    print v

Esto produce la siguiente salida:

1
39916800
51090942171709440000
8222838654177922817725562880000000
33452526613163807108170062053440751665152000000000
...

The other high-level interface, the Manager class, creates a separate server process that can hold master copies of Python data structures. Other processes can then access and modify these data structures using proxy objects. The following example creates a shared dictionary by calling the dict() method; the worker processes then insert values into the dictionary. (Locking is not done for you automatically, which doesn’t matter in this example. Manager’s methods also include Lock(), RLock(), and Semaphore() to create shared locks.)

import time
from multiprocessing import Pool, Manager

def factorial(N, dictionary):
    "Compute a factorial."
    # Calculate the result
    fact = 1L
    for i in range(1, N+1):
        fact = fact * i

    # Store result in dictionary
    dictionary[N] = fact

if __name__ == '__main__':
    p = Pool(5)
    mgr = Manager()
    d = mgr.dict()         # Create shared dictionary

    # Run tasks using the pool
    for N in range(1, 1000, 10):
        p.apply_async(factorial, (N, d))

    # Mark pool as closed -- no more tasks can be added.
    p.close()

    # Wait for tasks to exit
    p.join()

    # Output results
    for k, v in sorted(d.items()):
        print k, v

Esto producirá la salida:

1
39916800
51090942171709440000
8222838654177922817725562880000000
33452526613163807108170062053440751665152000000000
15511187532873822802242430164693032110632597200169861120000...

Ver también

La documentación del módulo multiprocessing.

PEP 371 - Adición del paquete de multiprocesamiento: PEP escrito por Jesse Noller y Richard Oudkerk; implementado por Richard Oudkerk y Jesse Noller.

PEP 3101: Formateo avanzado de cadena de caracteres¶

En Python 3.0, el operador % se complementa con un método de formato de cadena más potente, format(). La compatibilidad con el método str.format() se ha retroalimentado a Python 2.6.

En 2.6, tanto las cadenas de 8 bits como las Unicode tienen un método .format() que trata la cadena como una plantilla y toma los argumentos para formatear. La plantilla de formato utiliza llaves ({, }) como caracteres especiales:

>>> # Substitute positional argument 0 into the string.
>>> "User ID: {0}".format("root")
'User ID: root'
>>> # Use the named keyword arguments
>>> "User ID: {uid}   Last seen: {last_login}".format(
...    uid="root",
...    last_login = "5 Mar 2008 07:20")
'User ID: root   Last seen: 5 Mar 2008 07:20'

Las llaves se pueden escapar duplicándose:

>>> "Empty dict: {{}}".format()
"Empty dict: {}"

Los nombres de campo pueden ser números enteros que indican argumentos posicionales, como {0}, {1}, etc. o nombres de argumentos de palabras clave. También puede proporcionar nombres de campos compuestos que lean atributos o accedan a claves de diccionario:

>>> import sys
>>> print 'Platform: {0.platform}\nPython version: {0.version}'.format(sys)
Platform: darwin
Python version: 2.6a1+ (trunk:61261M, Mar  5 2008, 20:29:41)
[GCC 4.0.1 (Apple Computer, Inc. build 5367)]'

>>> import mimetypes
>>> 'Content-type: {0[.mp4]}'.format(mimetypes.types_map)
'Content-type: video/mp4'

Tenga en cuenta que cuando utilice una notación de estilo diccionario como [.mp4], no es necesario poner comillas alrededor de la cadena; se buscará el valor usando .mp4 como clave. Las cadenas de caracteres que comienzan con un número se convertirán en entero. No puede escribir expresiones más complicadas dentro de una cadena de formato.

Hasta ahora hemos mostrado cómo especificar qué campo sustituir en la cadena resultante. El formato preciso utilizado también se puede controlar agregando dos puntos seguidos de un especificador de formato. Por ejemplo:

>>> # Field 0: left justify, pad to 15 characters
>>> # Field 1: right justify, pad to 6 characters
>>> fmt = '{0:15} ${1:>6}'
>>> fmt.format('Registration', 35)
'Registration    $    35'
>>> fmt.format('Tutorial', 50)
'Tutorial        $    50'
>>> fmt.format('Banquet', 125)
'Banquet         $   125'

Los especificadores de formato pueden hacer referencia a otros campos a través del anidamiento:

>>> fmt = '{0:{1}}'
>>> width = 15
>>> fmt.format('Invoice #1234', width)
'Invoice #1234  '
>>> width = 35
>>> fmt.format('Invoice #1234', width)
'Invoice #1234                      '

Se puede especificar la alineación de un campo dentro del ancho deseado:

Carácter	Efecto
< (por defecto)	Alinear a la izquierda
>	Alinear a la derecha
^	Centrado
=	(Solo para tipos numéricos) Relleno después del signo.

Los especificadores de formato también pueden incluir un tipo de presentación, que controla cómo se formatea el valor. Por ejemplo, los números de punto flotante pueden formatearse como un número general o en notación exponencial:

>>> '{0:g}'.format(3.75)
'3.75'
>>> '{0:e}'.format(3.75)
'3.750000e+00'

Hay una variedad de tipos de presentación disponibles. Consulte la documentación 2.6 para obtener una lista completa; aquí hay un ejemplo:

`b`	Binario. Emite el número en base 2.
`c`	Carácter. Convierte el número entero en el carácter Unicode correspondiente antes de imprimirlo.
`d`	Entero Decimal. Muestra el número en base 10.
`o`	Formato octal. Da salida al número en base 8.
`x`	Formato hexadecimal. Muestra el número en base 16, utilizando letras minúsculas para los dígitos superiores a 9.
`e`	Notación de exponente. Imprime el número en notación científica utilizando la letra “e” para indicar el exponente.
`g`	Formato general. Esto imprime el número como un número de punto fijo, a menos que el número sea demasiado grande, en cuyo caso cambia a la notación de exponente “e”.
`n`	Número. Es lo mismo que “g” (para flotantes) o “d” (para enteros), salvo que utiliza la configuración regional actual para insertar los caracteres separadores de números adecuados.
`%`	Porcentaje. Multiplica el número por 100 y lo muestra en formato fijo (“f”), seguido de un signo de porcentaje.

Classes and types can define a __format__() method to control how they’re formatted. It receives a single argument, the format specifier:

def __format__(self, format_spec):
    if isinstance(format_spec, unicode):
        return unicode(str(self))
    else:
        return str(self)

There’s also a format() builtin that will format a single value. It calls the type’s __format__() method with the provided specifier:

>>> format(75.6564, '.2f')
'75.66'

Ver también

Format string syntax: La documentación de referencia para los campos de formato.
PEP 3101 - Formato avanzado de cadenas: PEP escrito por Talin. Implementado por Eric Smith.

PEP 3105: `print` como función¶

La sentencia print se convierte en la función print() en Python 3.0. Hacer de print() una función hace posible reemplazar la función haciendo def print(...) o importando una nueva función desde otro lugar.

Python 2.6 tiene una importación __future__ que elimina print como sintaxis del lenguaje, permitiéndote usar la forma funcional en su lugar. Por ejemplo:

>>> from __future__ import print_function
>>> print('# de entradas', len(diccionario), file=sys.stderr)

La firma de la nueva función es:

def print(*args, sep=' ', end='\n', file=None)

Los parámetros son:

args: argumentos posicionales cuyos valores se imprimirán.
sep: el separador que se imprimirá entre los argumentos.
end: el texto final, que se imprimirá después de que se hayan emitido todos los argumentos.
archivo: el objeto archivo al que se enviará la salida.

Ver también

PEP 3105 - Hacer de la impresión una función: PEP escrito por Georg Brandl.

PEP 3110: Cambios en el manejo de excepciones¶

Un error que ocasionalmente cometen los programadores de Python es escribir el siguiente código:

La firma de la nueva función es::try:
    ...
except TypeError, ValueError:  # ¡Incorrecto!
    ...

El autor probablemente está tratando de atrapar ambas excepciones TypeError y ValueError, pero este código en realidad hace algo diferente: atrapará TypeError y vinculará el objeto de excepción resultante al nombre local "ValueError". La excepción ValueError no será capturada en absoluto. El código correcto especifica una tupla de excepciones:

try:
    ...
except (TypeError, ValueError):
    ...

Este error se produce porque el uso de la coma aquí es ambiguo: ¿indica dos nodos diferentes en el árbol de análisis sintáctico, o un único nodo que es una tupla?

Python 3.0 hace que esto sea inequívoco al sustituir la coma por la palabra «as». Para atrapar una excepción y almacenar el objeto de excepción en la variable exc, debes escribir:

try:
    ...
except TypeError as exc:
    ...

Python 3.0 sólo soporta el uso de «as», y por lo tanto interpreta el primer ejemplo como la captura de dos excepciones diferentes. Python 2.6 soporta tanto la coma como «as», por lo que el código existente seguirá funcionando. Por lo tanto, sugerimos utilizar «as» cuando se escriba nuevo código Python que sólo se ejecutará con la versión 2.6.

Ver también

PEP 3110 - Captura de excepciones en Python 3000: PEP escrito y ejecutado por Collin Winter.

PEP 3112: Literales de bytes¶

Python 3.0 adopta Unicode como el tipo de cadena fundamental del lenguaje y denota los literales de 8 bits de forma diferente, ya sea como b'string o utilizando un constructor bytes. Por compatibilidad futura, Python 2.6 añade bytes como sinónimo del tipo str, y también soporta la notación b''.

El tipo str de la versión 2.6 difiere del tipo bytes de la versión 3.0 en varios aspectos; el más notable es que el constructor es completamente diferente. En la 3.0, bytes([65, 66, 67]) tiene 3 elementos, que contienen los bytes que representan ABC; en la 2.6, bytes([65, 66, 67]) devuelve la cadena de 12 bytes que representa el str() de la lista.

El uso principal de bytes en 2.6 será escribir pruebas de tipo de objeto como isinstance(x, bytes). Esto ayudará al convertidor de 2 a 3, que no puede decir si el código de 2.x pretende que las cadenas contengan caracteres o bytes de 8 bits; ahora puede utilizar bytes o str para representar su intención exactamente, y el código resultante también será correcto en Python 3.0.

También hay una importación __future__ que hace que todos los literales de cadena se conviertan en cadenas Unicode. Esto significa que las secuencias de escape u pueden ser utilizadas para incluir caracteres Unicode:

from __future__ import unicode_literals

s = ('\u751f\u3080\u304e\u3000\u751f\u3054'
     '\u3081\u3000\u751f\u305f\u307e\u3054')

print len(s)               # 12 Unicode characters

A nivel de C, Python 3.0 renombrará el tipo de cadena de 8 bits existente, llamado PyStringObject en Python 2.x, a PyBytesObject. Python 2.6 utiliza #define para soportar el uso de los nombres PyBytesObject(), PyBytes_Check(), PyBytes_FromStringAndSize(), y todas las demás funciones y macros utilizadas con cadenas.

Las instancias del tipo bytes son inmutables al igual que las cadenas. Un nuevo tipo bytearray almacena una secuencia mutable de bytes:

>>> bytearray([65, 66, 67])
bytearray(b'ABC')
>>> b = bytearray(u'\u21ef\u3244', 'utf-8')
>>> b
bytearray(b'\xe2\x87\xaf\xe3\x89\x84')
>>> b[0] = '\xe3'
>>> b
bytearray(b'\xe3\x87\xaf\xe3\x89\x84')
>>> unicode(str(b), 'utf-8')
u'\u31ef \u3244'

Byte arrays support most of the methods of string types, such as startswith()/endswith(), find()/rfind(), and some of the methods of lists, such as append(), pop(), and reverse().

>>> b = bytearray('ABC')
>>> b.append('d')
>>> b.append(ord('e'))
>>> b
bytearray(b'ABCde')

También existe la correspondiente API en C, con PyByteArray_FromObject(), PyByteArray_FromStringAndSize(), y varias otras funciones.

Ver también

PEP 3112 - Literales de bytes en Python 3000: PEP escrito por Jason Orendorff; retroalimentado a 2.6 por Christian Heimes.

PEP 3116: Nueva biblioteca de E/S¶

Python’s built-in file objects support a number of methods, but file-like objects don’t necessarily support all of them. Objects that imitate files usually support read() and write(), but they may not support readline(), for example. Python 3.0 introduces a layered I/O library in the io module that separates buffering and text-handling features from the fundamental read and write operations.

Existen tres niveles de clases base abstractas proporcionadas por el módulo io:

RawIOBase defines raw I/O operations: read(), readinto(), write(), seek(), tell(), truncate(), and close(). Most of the methods of this class will often map to a single system call. There are also readable(), writable(), and seekable() methods for determining what operations a given object will allow.

Python 3.0 tiene implementaciones concretas de esta clase para archivos y sockets, pero Python 2.6 no ha reestructurado sus objetos archivo y socket de esta manera.
BufferedIOBase is an abstract base class that buffers data in memory to reduce the number of system calls used, making I/O processing more efficient. It supports all of the methods of RawIOBase, and adds a raw attribute holding the underlying raw object.

There are five concrete classes implementing this ABC. BufferedWriter and BufferedReader are for objects that support write-only or read-only usage that have a seek() method for random access. BufferedRandom objects support read and write access upon the same underlying stream, and BufferedRWPair is for objects such as TTYs that have both read and write operations acting upon unconnected streams of data. The BytesIO class supports reading, writing, and seeking over an in-memory buffer.
TextIOBase: Provides functions for reading and writing strings (remember, strings will be Unicode in Python 3.0), and supporting universal newlines. TextIOBase defines the readline() method and supports iteration upon objects.

There are two concrete implementations. TextIOWrapper wraps a buffered I/O object, supporting all of the methods for text I/O and adding a buffer attribute for access to the underlying object. StringIO simply buffers everything in memory without ever writing anything to disk.

(En Python 2.6, io.StringIO se implementa en Python puro, por lo que es bastante lento. Por lo tanto, debe quedarse con el módulo StringIO o cStringIO existente por ahora. En algún momento, el módulo io de Python 3.0 se reescribirá en C para mayor velocidad, y tal vez la implementación de C se incorpore a las versiones 2.x).

En Python 2.6, las implementaciones subyacentes no han sido reestructuradas para construir sobre las clases del módulo io. El módulo se proporciona para facilitar la escritura de código compatible con la versión 3.0, y para ahorrar a los desarrolladores el esfuerzo de escribir sus propias implementaciones de búfer y E/S de texto.

Ver también

PEP 3116 - Nueva E/S: PEP escrito por Daniel Stutzbach, Mike Verdone y Guido van Rossum. Código de Guido van Rossum, Georg Brandl, Walter Doerwald, Jeremy Hylton, Martin von Löwis, Tony Lownds y otros.

PEP 3118: Protocolo revisado de la memoria intermedia¶

El protocolo de búferes es una API de nivel C que permite a los tipos de Python intercambiar punteros a sus representaciones internas. Un archivo mapeado en memoria puede ser visto como un buffer de caracteres, por ejemplo, y esto permite que otro módulo como re trate los archivos mapeados en memoria como una cadena de caracteres a buscar.

Los principales usuarios del protocolo de búferes son los paquetes de procesamiento numérico como NumPy, que exponen la representación interna de los arrays para que los invocadores puedan escribir datos directamente en un array en lugar de pasar por una API más lenta. Este PEP actualiza el protocolo de búfer a la luz de la experiencia del desarrollo de NumPy, añadiendo una serie de nuevas características como la indicación de la forma de un array o el bloqueo de una región de memoria.

La nueva función más importante de la API en C es PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags), que toma un objeto y un conjunto de flags, y rellena la estructura Py_buffer con información sobre la representación en memoria del objeto. Los objetos pueden utilizar esta operación para bloquear la memoria en su lugar mientras un llamador externo podría estar modificando el contenido, por lo que hay un correspondiente PyBuffer_Release(Py_buffer *view) para indicar que el llamador externo ha terminado.

El argumento flags de PyObject_GetBuffer() especifica las restricciones de la memoria devuelta. Algunos ejemplos son:

PyBUF_WRITABLE indica que la memoria debe ser grabable.
PyBUF_LOCK requests a read-only or exclusive lock on the memory.
PyBUF_C_CONTIGUOUS y PyBUF_F_CONTIGUOUS solicitan una disposición de matriz contigua en C (la última dimensión varía más rápidamente) o contigua en Fortran (la primera dimensión varía más rápidamente).

Dos nuevos códigos de argumento para PyArg_ParseTuple(), s* y z*, devuelven objetos buffer bloqueados para un parámetro.

Ver también

PEP 3118 - Revisión del protocolo del buffer: PEP escrito por Travis Oliphant y Carl Banks; implementado por Travis Oliphant.

PEP 3119: Clases base abstractas¶

Some object-oriented languages such as Java support interfaces, declaring that a class has a given set of methods or supports a given access protocol. Abstract Base Classes (or ABCs) are an equivalent feature for Python. The ABC support consists of an abc module containing a metaclass called ABCMeta, special handling of this metaclass by the isinstance() and issubclass() builtins, and a collection of basic ABCs that the Python developers think will be widely useful. Future versions of Python will probably add more ABCs.

Let’s say you have a particular class and wish to know whether it supports dictionary-style access. The phrase «dictionary-style» is vague, however. It probably means that accessing items with obj[1] works. Does it imply that setting items with obj[2] = value works? Or that the object will have keys(), values(), and items() methods? What about the iterative variants such as iterkeys()? copy`and :meth:()!update`? Iterating over the object with iter()?

The Python 2.6 collections module includes a number of different ABCs that represent these distinctions. Iterable indicates that a class defines __iter__(), and Container means the class defines a __contains__() method and therefore supports x in y expressions. The basic dictionary interface of getting items, setting items, and keys(), values(), and items(), is defined by the MutableMapping ABC.

Puedes derivar tus propias clases de un ABC particular para indicar que soportan la interfaz de ese ABC:

import collections

class Storage(collections.MutableMapping):
    ...

Alternatively, you could write the class without deriving from the desired ABC and instead register the class by calling the ABC’s register() method:

import collections

class Storage:
    ...

collections.MutableMapping.register(Storage)

For classes that you write, deriving from the ABC is probably clearer. The register() method is useful when you’ve written a new ABC that can describe an existing type or class, or if you want to declare that some third-party class implements an ABC. For example, if you defined a PrintableType ABC, it’s legal to do:

# Register Python's types
PrintableType.register(int)
PrintableType.register(float)
PrintableType.register(str)

Las clases deben obedecer la semántica especificada por un ABC, pero Python no puede comprobarlo; depende del autor de la clase entender los requisitos del ABC e implementar el código en consecuencia.

Para comprobar si un objeto es compatible con una determinada interfaz, ahora se puede escribir:

def func(d):
    if not isinstance(d, collections.MutableMapping):
        raise ValueError("Mapping object expected, not %r" % d)

No sientas que ahora debes empezar a escribir muchas comprobaciones como en el ejemplo anterior. Python tiene una fuerte tradición de «duck-typing», donde la comprobación explícita de tipos nunca se hace y el código simplemente llama a los métodos de un objeto, confiando en que esos métodos estarán ahí y lanzando una excepción si no lo están. Sea juicioso al comprobar el ABC y hágalo sólo cuando sea absolutamente necesario.

Puedes escribir tu propio ABC utilizando abc.ABCMeta como metaclase en una definición de clase:

from abc import ABCMeta, abstractmethod

class Drawable():
    __metaclass__ = ABCMeta

    @abstractmethod
    def draw(self, x, y, scale=1.0):
        pass

    def draw_doubled(self, x, y):
        self.draw(x, y, scale=2.0)


class Square(Drawable):
    def draw(self, x, y, scale):
        ...

In the Drawable ABC above, the draw_doubled() method renders the object at twice its size and can be implemented in terms of other methods described in Drawable. Classes implementing this ABC therefore don’t need to provide their own implementation of draw_doubled(), though they can do so. An implementation of draw() is necessary, though; the ABC can’t provide a useful generic implementation.

You can apply the @~abc.abstractmethod decorator to methods such as draw() that must be implemented; Python will then raise an exception for classes that don’t define the method. Note that the exception is only raised when you actually try to create an instance of a subclass lacking the method:

>>> class Circle(Drawable):
...     pass
...
>>> c = Circle()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Circle with abstract methods draw
>>>

Los atributos de datos abstractos pueden declararse utilizando el decorador @abstractproperty:

from abc import abstractproperty
...

@abstractproperty
def readonly(self):
   return self._x

Subclasses must then define a readonly property.

Ver también

PEP 3119 - Presentación de las clases base abstractas: PEP escrito por Guido van Rossum y Talin. Implementado por Guido van Rossum. Adaptado a la versión 2.6 por Benjamin Aranguren, con Alex Martelli.

PEP 3127: Soporte y sintaxis de literales enteros¶

Python 3.0 cambia la sintaxis de los literales enteros octales (base-8), prefijándolos con «0o» o «0O» en lugar de un cero inicial, y añade soporte para los literales enteros binarios (base-2), señalados con un prefijo «0b» o «0B».

Python 2.6 no elimina el soporte para el 0 inicial que señala un número octal, pero sí añade soporte para «0o» y «0b»:

>>> 0o21, 2*8 + 1
(17, 17)
>>> 0b101111
47

La función oct() sigue devolviendo números prefijados con un cero a la izquierda, y la nueva función bin() devuelve la representación binaria de un número:

>>> oct(42)
'052'
>>> future_builtins.oct(42)
'0o52'
>>> bin(173)
'0b10101101'

The int() and long() builtins will now accept the «0o» and «0b» prefixes when base-8 or base-2 are requested, or when the base argument is zero (signalling that the base used should be determined from the string):

>>> int ('0o52', 0)
42
>>> int('1101', 2)
13
>>> int('0b1101', 2)
13
>>> int('0b1101', 0)
13

Ver también

PEP 3127 - Soporte y sintaxis de literales enteros: PEP escrito por Patrick Maupin; retroalimentado a 2.6 por Eric Smith.

PEP 3129: Decoradores de clase¶

Los decoradores se han ampliado de funciones a clases. Ahora es legal escribir:

@foo
@bar
class A:
  pass

Esto equivale a:

class A:
  pass

A = foo(bar(A))

Ver también

PEP 3129 - Decoradores de clase: PEP escrito por Collin Winter.

PEP 3141: Una jerarquía de tipos para los números¶

Python 3.0 añade varias clases base abstractas para tipos numéricos inspiradas en la torre numérica de Scheme. Estas clases fueron retrocedidas a la versión 2.6 como el módulo numbers.

The most general ABC is Number. It defines no operations at all, and only exists to allow checking if an object is a number by doing isinstance(obj, Number).

Complex is a subclass of Number. Complex numbers can undergo the basic operations of addition, subtraction, multiplication, division, and exponentiation, and you can retrieve the real and imaginary parts and obtain a number’s conjugate. Python’s built-in complex type is an implementation of Complex.

Real further derives from Complex, and adds operations that only work on real numbers: floor(), trunc(), rounding, taking the remainder mod N, floor division, and comparisons.

Rational numbers derive from Real, have numerator and denominator properties, and can be converted to floats. Python 2.6 adds a simple rational-number class, Fraction, in the fractions module. (It’s called Fraction instead of Rational to avoid a name clash with numbers.Rational.)

Integral numbers derive from Rational, and can be shifted left and right with << and >>, combined using bitwise operations such as & and |, and can be used as array indexes and slice boundaries.

In Python 3.0, the PEP slightly redefines the existing builtins round(), math.floor(), math.ceil(), and adds a new one, math.trunc(), that’s been backported to Python 2.6. math.trunc() rounds toward zero, returning the closest Integral that’s between the function’s argument and zero.

Ver también

PEP 3141 - Una jerarquía de tipos para los números: PEP escrito por Jeffrey Yasskin.

Torre numérica del esquema, del manual de Guile.

Scheme’s number datatypes de la especificación del esquema R5RS.

El módulo `fractions`¶

Para completar la jerarquía de tipos numéricos, el módulo fractions proporciona una clase de números racionales. Los números racionales almacenan sus valores como un numerador y un denominador que forman una fracción, y pueden representar exactamente números como 2/3 que los números de punto flotante sólo pueden aproximar.

The Fraction constructor takes two Integral values that will be the numerator and denominator of the resulting fraction.

>>> from fractions import Fraction
>>> a = Fraction(2, 3)
>>> b = Fraction(2, 5)
>>> float(a), float(b)
(0.66666666666666663, 0.40000000000000002)
>>> a+b
Fraction(16, 15)
>>> a/b
Fraction(5, 3)

For converting floating-point numbers to rationals, the float type now has an as_integer_ratio() method that returns the numerator and denominator for a fraction that evaluates to the same floating-point value:

>>> (2.5) .as_integer_ratio()
(5, 2)
>>> (3.1415) .as_integer_ratio()
(7074029114692207L, 2251799813685248L)
>>> (1./3) .as_integer_ratio()
(6004799503160661L, 18014398509481984L)

Tenga en cuenta que los valores que sólo pueden ser aproximados por números de punto flotante, como 1,/3, no se simplifican al número que se está aproximando; la fracción intenta coincidir con el valor de punto flotante exactamente.

El módulo fractions se basa en una implementación de Sjoerd Mullender que estuvo en el directorio Demo/classes/ de Python durante mucho tiempo. Esta implementación fue significativamente actualizada por Jeffrey Yasskin.

Otros cambios lingüísticos¶

Algunos de los cambios más pequeños realizados en el núcleo del lenguaje Python son:

Los directorios y archivos zip que contengan un archivo __main__.py pueden ahora ejecutarse directamente pasando su nombre al intérprete. El directorio o archivo zip se inserta automáticamente como la primera entrada en sys.path. (Sugerencia y parche inicial de Andy Chu, revisado posteriormente por Phillip J. Eby y Nick Coghlan; bpo-1739468)
The hasattr() function was catching and ignoring all errors, under the assumption that they meant a __getattr__() method was failing somehow and the return value of hasattr() would therefore be False. This logic shouldn’t be applied to KeyboardInterrupt and SystemExit, however; Python 2.6 will no longer discard such exceptions when hasattr() encounters them. (Fixed by Benjamin Peterson; bpo-2196.)
Cuando se llama a una función utilizando la sintaxis ** para proporcionar argumentos de palabras clave, ya no es necesario utilizar un diccionario de Python; ahora funcionará cualquier asignación:
```
>>> def f(**kw):
...    print sorted(kw)
...
>>> ud=UserDict.UserDict()
>>> ud['a'] = 1
>>> ud['b'] = 'string'
>>> f(**ud)
['a', 'b']
```
(Contribución de Alexander Belopolsky; bpo-1686487.)

También se ha convertido en legal proporcionar argumentos de palabras clave después de un argumento *args a una llamada de función.
```
>>> def f(*args, **kw):
...     print args, kw
...
>>> f(1,2,3, *(4,5,6), keyword=13)
(1, 2, 3, 4, 5, 6) {'keyword': 13}
```
Anteriormente, esto habría sido un error de sintaxis. (Contribución de Amaury Forgeot d’Arc; bpo-3473.)
Un nuevo builtin, next(iterator, [default]) devuelve el siguiente elemento del iterador especificado. Si se suministra el argumento default, se devolverá si iterador se ha agotado; en caso contrario, se lanzará la excepción StopIteration. (Se ha modificado en bpo-2719.)
Tuples now have index() and count() methods matching the list type’s index() and count() methods:
```
>>> t = (0,1,2,3,4,0,1,2)
>>> t.index(3)
3
>>> t.count(0)
2
```
(Contribución de Raymond Hettinger)
Los tipos incorporados tienen ahora un soporte mejorado para la sintaxis de corte extendida, aceptando varias combinaciones de (inicio, parada, paso). Anteriormente, el soporte era parcial y algunos casos de esquina no funcionaban. (Implementado por Thomas Wouters)

Properties now have three decorators, @~property.getter, @~property.setter and @~property.deleter, that are decorators providing useful shortcuts for adding a getter, setter or deleter function to an existing property. You would use them like this:

class C(object):
    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

class D(C):
    @C.x.getter
    def x(self):
        return self._x * 2

    @x.setter
    def x(self, value):
        self._x = value / 2

Several methods of the built-in set types now accept multiple iterables: intersection(), intersection_update(), union(), update(), difference() and difference_update().
```
>>> s=set('1234567890')
>>> s.intersection('abc123', 'cdf246')  # Intersection between all inputs
set(['2'])
>>> s.difference('246', '789')
set(['1', '0', '3', '5'])
```
(Contribución de Raymond Hettinger.)
Se han añadido muchas funciones de punto flotante. La función float() ahora convertirá la cadena nan en un valor IEEE 754 Not A Number, y +inf y -inf en infinito positivo o negativo. Esto funciona en cualquier plataforma con semántica IEEE 754. (Contribución de Christian Heimes; bpo-1635.)

Other functions in the math module, isinf() and isnan(), return true if their floating-point argument is infinite or Not A Number. (bpo-1640)

Se han añadido funciones de conversión para convertir números de punto flotante en cadenas hexadecimales (bpo-3008). Estas funciones convierten los números flotantes a y desde una representación de cadena sin introducir errores de redondeo por la conversión entre decimal y binario. Los flotadores tienen un método hex() que devuelve una representación de cadena, y el método float.fromhex() convierte una cadena de nuevo en un número:
```
>>> a = 3.75
>>> a.hex()
'0x1.e000000000000p+1'
>>> float.fromhex('0x1.e000000000000p+1')
3.75
>>> b=1./3
>>> b.hex()
'0x1.5555555555555p-2'
```
Un detalle numérico: cuando se crea un número complejo a partir de dos flotantes en sistemas que admiten ceros con signo (-0 y +0), el constructor complex() conserva ahora el signo del cero. (Corregido por Mark T. Dickinson; bpo-1507.)
Classes that inherit a __hash__() method from a parent class can set __hash__ = None to indicate that the class isn’t hashable. This will make hash(obj) raise a TypeError and the class will not be indicated as implementing the Hashable ABC.

You should do this when you’ve defined a __cmp__() or __eq__() method that compares objects by their value rather than by identity. All objects have a default hash method that uses id(obj) as the hash value. There’s no tidy way to remove the __hash__() method inherited from a parent class, so assigning None was implemented as an override. At the C level, extensions can set tp_hash to PyObject_HashNotImplemented(). (Fixed by Nick Coghlan and Amaury Forgeot d’Arc; bpo-2235.)
La excepción GeneratorExit ahora subclasa BaseException en lugar de Exception. Esto significa que un manejador de excepciones que haga except Exception: no atrapará inadvertidamente GeneratorExit. (Contribuido por Chad Austin; bpo-1537.)
Generator objects now have a gi_code attribute that refers to the original code object backing the generator. (Contributed by Collin Winter; bpo-1473257.)
La función incorporada compile() ahora acepta argumentos de palabras clave así como parámetros posicionales. (Contribución de Thomas Wouters; bpo-1444529.)
El constructor complex() ahora acepta cadenas que contengan números complejos entre paréntesis, lo que significa que complex(repr(cplx)) ahora redondeará los valores. Por ejemplo, complex('(3+4j)') ahora devuelve el valor (3+4j). (bpo-1491866)
The string translate() method now accepts None as the translation table parameter, which is treated as the identity transformation. This makes it easier to carry out operations that only delete characters. (Contributed by Bengt Richter and implemented by Raymond Hettinger; bpo-1193128.)
The built-in dir() function now checks for a __dir__() method on the objects it receives. This method must return a list of strings containing the names of valid attributes for the object, and lets the object control the value that dir() produces. Objects that have __getattr__() or __getattribute__() methods can use this to advertise pseudo-attributes they will honor. (bpo-1591665)
Los objetos de método de instancia tienen nuevos atributos para el objeto y la función que componen el método; el nuevo sinónimo de im_self es __self__, y im_func también está disponible como __func__. Los nombres antiguos aún se admiten en Python 2.6, pero ya no están disponibles en la versión 3.0.
Un cambio oscuro: cuando se utiliza la función locals() dentro de una sentencia class, el diccionario resultante ya no devuelve variables libres. (Las variables libres, en este caso, son variables referenciadas en la sentencia class que no son atributos de la clase)

Optimizaciones¶

El módulo warnings ha sido reescrito en C. Esto hace posible invocar advertencias desde el analizador sintáctico, y también puede hacer que el arranque del intérprete sea más rápido. (Contribuido por Neal Norwitz y Brett Cannon; bpo-1631171.)
Los objetos de tipo tienen ahora una caché de métodos que puede reducir el trabajo necesario para encontrar la implementación del método correcto para una clase en particular; una vez almacenada en la caché, el intérprete no necesita recorrer las clases base para averiguar el método correcto a llamar. La caché se borra si una clase base o la propia clase se modifica, por lo que la caché debería seguir siendo correcta incluso ante la naturaleza dinámica de Python. (Optimización original implementada por Armin Rigo, actualizada para Python 2.6 por Kevin Jacobs; bpo-1700288.)

Por defecto, este cambio sólo se aplica a los tipos que se incluyen con el núcleo de Python. Los módulos de extensión no son necesariamente compatibles con esta caché, por lo que deben añadir explícitamente Py_TPFLAGS_HAVE_VERSION_TAG al campo tp_flags del módulo para habilitar la caché de métodos. (Para ser compatible con la caché de métodos, el código del módulo de extensión no debe acceder directamente ni modificar el miembro tp_dict de ninguno de los tipos que implementa. La mayoría de los módulos no lo hacen, pero es imposible que el intérprete de Python lo determine. Ver bpo-1878 para una discusión)
Las llamadas a funciones que utilizan argumentos de palabras clave son significativamente más rápidas al hacer una comparación rápida de punteros, lo que suele ahorrar el tiempo de una comparación completa de cadenas. (Contribución de Raymond Hettinger, tras una implementación inicial de Antoine Pitrou; bpo-1819)
Todas las funciones del módulo struct han sido reescritas en C, gracias al trabajo en el sprint de Need For Speed. (Contribución de Raymond Hettinger)
Algunos de los tipos estándar incorporados ahora establecen un bit en sus objetos de tipo. Esto acelera la comprobación de si un objeto es una subclase de uno de estos tipos. (Contribución de Neal Norwitz)
Unicode strings now use faster code for detecting whitespace and line breaks; this speeds up the split() method by about 25% and splitlines() by 35%. (Contributed by Antoine Pitrou.) Memory usage is reduced by using pymalloc for the Unicode string’s data.
La declaración with ahora almacena el método __exit__() en la pila, lo que produce una pequeña mejora en la velocidad. (Implementado por Jeffrey Yasskin).
Para reducir el uso de memoria, el recolector de basura ahora borrará las listas libres internas cuando recolecte la generación más alta de objetos. Esto puede devolver la memoria al sistema operativo antes.

Cambios de intérprete¶

Two command-line options have been reserved for use by other Python implementations. The -J switch has been reserved for use by Jython for Jython-specific options, such as switches that are passed to the underlying JVM. -X has been reserved for options specific to a particular implementation of Python such as CPython, Jython, or IronPython. If either option is used with Python 2.6, the interpreter will report that the option isn’t currently used.

Ahora se puede evitar que Python escriba archivos .pyc o .pyo proporcionando el modificador -B al intérprete de Python, o estableciendo la variable de entorno PYTHONDONTWRITEBYTECODE antes de ejecutar el intérprete. Esta configuración está disponible para los programas de Python como la variable sys.dont_write_bytecode, y el código de Python puede cambiar el valor para modificar el comportamiento del intérprete. (Contribución de Neal Norwitz y Georg Brandl)

La codificación utilizada para la entrada, la salida y el error estándar puede especificarse estableciendo la variable de entorno PYTHONIOENCODING antes de ejecutar el intérprete. El valor debe ser una cadena de la forma <encoding> o <encoding>:<errorhandler>. La parte encoding especifica el nombre de la codificación, por ejemplo utf-8 o latin-1; la parte opcional errorhandler especifica qué hacer con los caracteres que no pueden ser manejados por la codificación, y debe ser una de las opciones «error», «ignorar» o «reemplazar». (Contribución de Martin von Löwis)</errorhandler></encoding></encoding>

Módulos nuevos y mejorados¶

Como en cada versión, la biblioteca estándar de Python ha recibido una serie de mejoras y correcciones de errores. Aquí hay una lista parcial de los cambios más notables, ordenados alfabéticamente por nombre de módulo. Consulta el archivo Misc/NEWS en el árbol de fuentes para una lista más completa de cambios, o mira los registros de Subversion para todos los detalles.

Los módulos asyncore y asynchat están recibiendo mantenimiento activo nuevamente y se aplicaron varios parches y correcciones de errores. (Mantenimiento a cargo de Josiah Carlson; consulte bpo-1736190 para obtener un parche).
The bsddb module also has a new maintainer, Jesús Cea Avión, and the package is now available as a standalone package. The web page for the package is www.jcea.es/programacion/pybsddb.htm. The plan is to remove the package from the standard library in Python 3.0, because its pace of releases is much more frequent than Python’s.

The bsddb.dbshelve module now uses the highest pickling protocol available, instead of restricting itself to protocol 1. (Contributed by W. Barnes.)
El módulo cgi ahora leerá variables de la cadena de consulta de una solicitud HTTP POST. Esto permite utilizar acciones de formulario con URL que incluyen cadenas de consulta como «/cgi-bin/add.py?category=1». (Contribuido por Alexandre Fiori y Nubis; bpo-1817).

The parse_qs() and parse_qsl() functions have been relocated from the cgi module to the urlparse module. The versions still available in the cgi module will trigger PendingDeprecationWarning messages in 2.6 (bpo-600362).
El módulo cmath ha sido objeto de una amplia revisión, a la que han contribuido Mark Dickinson y Christian Heimes. Se han añadido cinco nuevas funciones:
- polar() converts a complex number to polar form, returning the modulus and argument of the complex number.
- rect() does the opposite, turning a modulus, argument pair back into the corresponding complex number.
- phase() returns the argument (also called the angle) of a complex number.
- isnan() returns True if either the real or imaginary part of its argument is a NaN.
- isinf() returns True if either the real or imaginary part of its argument is infinite.
The revisions also improved the numerical soundness of the cmath module. For all functions, the real and imaginary parts of the results are accurate to within a few units of least precision (ulps) whenever possible. See bpo-1381 for the details. The branch cuts for asinh(), atanh(), and atan() have also been corrected.

Las pruebas del módulo se han ampliado considerablemente; casi 2000 nuevos casos de prueba ejercitan las funciones algebraicas.

En las plataformas IEEE 754, el módulo cmath maneja ahora los valores especiales IEEE 754 y las excepciones de punto flotante de forma consistente con el Anexo “G” del estándar C99.

Un nuevo tipo de datos en el módulo collections: namedtuple(typename, fieldnames) es una función de fábrica que crea subclases de la tupla estándar cuyos campos son accesibles tanto por nombre como por índice. Por ejemplo:

>>> var_type = collections.namedtuple('variable',
...             'id name type size')
>>> # Names are separated by spaces or commas.
>>> # 'id, name, type, size' would also work.
>>> var_type._fields
('id', 'name', 'type', 'size')

>>> var = var_type(1, 'frequency', 'int', 4)
>>> print var[0], var.id    # Equivalent
1 1
>>> print var[2], var.type  # Equivalent
int int
>>> var._asdict()
{'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'}
>>> v2 = var._replace(name='amplitude')
>>> v2
variable(id=1, name='amplitude', type='int', size=4)

Several places in the standard library that returned tuples have been modified to return namedtuple() instances. For example, the decimal.Decimal.as_tuple() method now returns a named tuple with sign, digits, and exponent fields.

(Contribución de Raymond Hettinger.)

Another change to the collections module is that the deque type now supports an optional maxlen parameter; if supplied, the deque’s size will be restricted to no more than maxlen items. Adding more items to a full deque causes old items to be discarded.
```
>>> from collections import deque
>>> dq=deque(maxlen=3)
>>> dq
deque([], maxlen=3)
>>> dq.append(1); dq.append(2); dq.append(3)
>>> dq
deque([1, 2, 3], maxlen=3)
>>> dq.append(4)
>>> dq
deque([2, 3, 4], maxlen=3)
```
(Contribución de Raymond Hettinger.)
Los objetos Morsel del módulo Cookie ahora admiten un atributo httponly. En algunos navegadores, el código JavaScript no puede acceder ni manipular las cookies con este atributo establecido. (Contribuido por Arvin Schnell; bpo-1638033).
A new window method in the curses module, chgat(), changes the display attributes for a certain number of characters on a single line. (Contributed by Fabian Kreutz.)
```
# Boldface text starting at y=0,x=21
# and affecting the rest of the line.
stdscr.chgat(0, 21, curses.A_BOLD)
```
The Textbox class in the curses.textpad module now supports editing in insert mode as well as overwrite mode. Insert mode is enabled by supplying a true value for the insert_mode parameter when creating the Textbox instance.
The datetime module’s strftime() methods now support a %f format code that expands to the number of microseconds in the object, zero-padded on the left to six places. (Contributed by Skip Montanaro; bpo-1158.)
The decimal module was updated to version 1.66 of the General Decimal Specification. New features include some methods for some basic mathematical functions such as exp() and log10():
```
>>> Decimal(1).exp()
Decimal("2.718281828459045235360287471")
>>> Decimal("2.7182818").ln()
Decimal("0.9999999895305022877376682436")
>>> Decimal(1000).log10()
Decimal("3")
```
The as_tuple() method of Decimal objects now returns a named tuple with sign, digits, and exponent fields.

(Implementado por Facundo Batista y Mark Dickinson. Soporte de tuplas con nombre añadido por Raymond Hettinger)
The difflib module’s SequenceMatcher class now returns named tuples representing matches, with a, b, and size attributes. (Contributed by Raymond Hettinger.)
An optional timeout parameter, specifying a timeout measured in seconds, was added to the ftplib.FTP class constructor as well as the connect() method. (Added by Facundo Batista.) Also, the FTP class’s storbinary() and storlines() now take an optional callback parameter that will be called with each block of data after the data has been sent. (Contributed by Phil Schwartz; bpo-1221598.)
The reduce() built-in function is also available in the functools module. In Python 3.0, the builtin has been dropped and reduce() is only available from functools; currently there are no plans to drop the builtin in the 2.x series. (Patched by Christian Heimes; bpo-1739906.)
Cuando sea posible, el módulo getpass utilizará ahora /dev/tty para imprimir un mensaje de aviso y leer la contraseña, retrocediendo al error estándar y a la entrada estándar. Si la contraseña puede ser enviada al terminal, se imprimirá una advertencia antes de que se muestre el aviso. (Contribución de Gregory P. Smith)
La función glob.glob() ahora puede devolver nombres de archivo Unicode si se ha utilizado una ruta Unicode y se han encontrado nombres de archivo Unicode dentro del directorio. (bpo-1001604)
Una nueva función en el módulo heapq, merge(iter1, iter2, ...), toma cualquier número de iterables que devuelven datos en orden ordenado, y devuelve un nuevo generador que devuelve el contenido de todos los iteradores, también en ordenado. Por ejemplo:
```
>>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16]))
[1, 2, 3, 5, 8, 9, 16]
```
Another new function, heappushpop(heap, item), pushes item onto heap, then pops off and returns the smallest item. This is more efficient than making a call to heappush() and then heappop().

heapq se ha implementado para utilizar únicamente la comparación menor que, en lugar de la comparación menor o igual que utilizaba anteriormente. Esto hace que el uso de heapq de un tipo coincida con el método list.sort(). (Contribución de Raymond Hettinger)
Se agregó un parámetro opcional timeout a los constructores de clases httplib.HTTPConnection y HTTPSConnection, que especifica un tiempo de espera medido en segundos. (Agregado por Facundo Batista).
Most of the inspect module’s functions, such as getmoduleinfo() and getargs(), now return named tuples. In addition to behaving like tuples, the elements of the return value can also be accessed as attributes. (Contributed by Raymond Hettinger.)

Some new functions in the module include isgenerator(), isgeneratorfunction(), and isabstract().
El módulo itertools ha ganado varias funciones nuevas.

izip_longest(iter1, iter2, ...[, fillvalue]) hace tuplas de cada uno de los elementos; si algunos de los iterables son más cortos que otros, los valores que faltan se ponen a fillvalue. Por ejemplo:
```
>>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5]))
((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))
```
product(iter1, iter2, ..., [repeat=N]) devuelve el producto cartesiano de los iterables suministrados, un conjunto de tuplas que contiene todas las combinaciones posibles de los elementos devueltos de cada iterable.
```
>>> list(itertools.product([1,2,3], [4,5,6]))
[(1, 4), (1, 5), (1, 6),
 (2, 4), (2, 5), (2, 6),
 (3, 4), (3, 5), (3, 6)]
```
El argumento opcional de la palabra clave repeat se utiliza para tomar el producto de un iterable o un conjunto de iterables con ellos mismos, repetido N veces. Con un único argumento iterable, se devuelven N-tuplas:
```
>>> list(itertools.product([1,2], repeat=3))
[(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
 (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]
```
Con dos iterables, se devuelven 2N-tuplas.
```
>>> list(itertools.product([1,2], [3,4], repeat=2))
[(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4),
 (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4),
 (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4),
 (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]
```
combinaciones(iterable, r) devuelve subsecuencias de longitud r de los elementos de iterable.
```
>>> list(itertools.combinations('123', 2))
[('1', '2'), ('1', '3'), ('2', '3')]
>>> list(itertools.combinations('123', 3))
[('1', '2', '3')]
>>> list(itertools.combinations('1234', 3))
[('1', '2', '3'), ('1', '2', '4'),
 ('1', '3', '4'), ('2', '3', '4')]
```
permutaciones(iter[, r]) devuelve todas las permutaciones de longitud r de los elementos del iterable. Si no se especifica r, por defecto será el número de elementos producidos por el iterable.
```
>>> list(itertools.permutations([1,2,3,4], 2))
[(1, 2), (1, 3), (1, 4),
 (2, 1), (2, 3), (2, 4),
 (3, 1), (3, 2), (3, 4),
 (4, 1), (4, 2), (4, 3)]
```
itertools.chain(*iterables) is an existing function in itertools that gained a new constructor in Python 2.6. itertools.chain.from_iterable(iterable) takes a single iterable that should return other iterables. chain() will then return all the elements of the first iterable, then all the elements of the second, and so on.
```
>>> list(itertools.chain.from_iterable([[1,2,3], [4,5,6]]))
[1, 2, 3, 4, 5, 6]
```
(Todo ello aportado por Raymond Hettinger)
The logging module’s FileHandler class and its subclasses WatchedFileHandler, RotatingFileHandler, and TimedRotatingFileHandler now have an optional delay parameter to their constructors. If delay is true, opening of the log file is deferred until the first emit() call is made. (Contributed by Vinay Sajip.)

TimedRotatingFileHandler also has a utc constructor parameter. If the argument is true, UTC time will be used in determining when midnight occurs and in generating filenames; otherwise local time will be used.
Se han añadido varias funciones nuevas al módulo math:
- isinf() y isnan() determinan si un flotador dado es un infinito (positivo o negativo) o un NaN (Not a Number), respectivamente.
- copysign() copia el bit de signo de un número IEEE 754, devolviendo el valor absoluto de x combinado con el bit de signo de y. Por ejemplo, math.copysign(1, -0.0) devuelve -1.0. (Contribución de Christian Heimes)
- factorial() calcula el factorial de un número. (Contribuido por Raymond Hettinger; bpo-2138.)
- fsum() suma el flujo de números de un iterable, y tiene cuidado de evitar la pérdida de precisión mediante el uso de sumas parciales. (Contribución de Jean Brouwers, Raymond Hettinger y Mark Dickinson; bpo-2819)
- acosh(), asinh() y atanh() calculan las funciones hiperbólicas inversas.
- log1p() devuelve el logaritmo natural de 1+x (base e).
- trunc() rounds a number toward zero, returning the closest Integral that’s between the function’s argument and zero. Added as part of the backport of PEP 3141’s type hierarchy for numbers.
El módulo math se ha mejorado para ofrecer un comportamiento más coherente en todas las plataformas, especialmente en lo que respecta al manejo de las excepciones de punto flotante y los valores especiales IEEE 754.

Siempre que es posible, el módulo sigue las recomendaciones del estándar C99 sobre los valores especiales de 754. Por ejemplo, sqrt(-1.) debería dar ahora un ValueError en casi todas las plataformas, mientras que sqrt(float('NaN')) debería devolver un NaN en todas las plataformas IEEE 754. Cuando el Anexo “F” del estándar C99 recomiende señalar “dividir por cero” o “inválido”, Python lanzará ValueError. Cuando el Anexo “F” del estándar C99 recomiende señalar “desbordamiento”, Python lanzará OverflowError. (Ver bpo-711019 y bpo-1640)

(Contribución de Christian Heimes y Mark Dickinson)
mmap objects now have a rfind() method that searches for a substring beginning at the end of the string and searching backwards. The find() method also gained an end parameter giving an index at which to stop searching. (Contributed by John Lenton.)
The operator module gained a methodcaller() function that takes a name and an optional set of arguments, returning a callable that will call the named function on any arguments passed to it. For example:
```
>>> # Equivalent to lambda s: s.replace('old', 'new')
>>> replacer = operator.methodcaller('replace', 'old', 'new')
>>> replacer('old wine in old bottles')
'new wine in new bottles'
```
(Contribución de Georg Brandl, tras una sugerencia de Gregory Petrosyan)

The attrgetter() function now accepts dotted names and performs the corresponding attribute lookups:
```
>>> inst_name = operator.attrgetter(
...        '__class__.__name__')
>>> inst_name('')
'str'
>>> inst_name(help)
'_Helper'
```
(Contribución de Georg Brandl, tras una sugerencia de Barry Warsaw)
El módulo os incluye ahora varias llamadas nuevas al sistema. fchmod(fd, mode) y fchown(fd, uid, gid) cambian el modo y la propiedad de un fichero abierto, y lchmod(path, mode) cambia el modo de un enlace simbólico. (Contribución de Georg Brandl y Christian Heimes)

chflags() and lchflags() are wrappers for the corresponding system calls (where they’re available), changing the flags set on a file. Constants for the flag values are defined in the stat module; some possible values include UF_IMMUTABLE to signal the file may not be changed and UF_APPEND to indicate that data can only be appended to the file. (Contributed by M. Levinson.)

os.closerange(low, high) cierra eficazmente todos los descriptores de fichero desde low hasta high, ignorando cualquier error y sin incluir a high mismo. Esta función es ahora utilizada por el módulo subprocess para hacer más rápido el arranque de procesos. (Contribuido por Georg Brandl; bpo-1663329.)
The os.environ object’s clear() method will now unset the environment variables using os.unsetenv() in addition to clearing the object’s keys. (Contributed by Martin Horcicka; bpo-1181.)
La función os.walk() tiene ahora un parámetro followlinks. Si se establece como True, seguirá los enlaces simbólicos que apunten a directorios y visitará el contenido del directorio. Por compatibilidad con el pasado, el valor por defecto del parámetro es false. Tenga en cuenta que la función puede caer en una recursión infinita si hay un enlace simbólico que apunte a un directorio padre. (bpo-1273829)
In the os.path module, the splitext() function has been changed to not split on leading period characters. This produces better results when operating on Unix’s dot-files. For example, os.path.splitext('.ipython') now returns ('.ipython', '') instead of ('', '.ipython'). (bpo-1115886)

Una nueva función, os.path.relpath(path, start='.'), devuelve una ruta relativa desde la ruta start, si se suministra, o desde el directorio de trabajo actual hasta el destino path. (Contribución de Richard Barran; bpo-1339796.)

En Windows, os.path.expandvars() ahora expandirá las variables de entorno dadas en la forma «%var%», y «~user» se expandirá en la ruta del directorio personal del usuario. (Contribución de Josiah Carlson; bpo-957650.)
El depurador de Python proporcionado por el módulo pdb ganó un nuevo comando: «run» reinicia el programa Python que se está depurando y puede tomar opcionalmente nuevos argumentos de línea de comandos para el programa. (Contribución de Rocky Bernstein; bpo-1393667.)
La función pdb.post_mortem(), utilizada para iniciar la depuración de un traceback, utilizará ahora el traceback devuelto por sys.exc_info() si no se suministra ningún traceback. (Contribuido por Facundo Batista; bpo-1106316.)
The pickletools module now has an optimize() function that takes a string containing a pickle and removes some unused opcodes, returning a shorter pickle that contains the same data structure. (Contributed by Raymond Hettinger.)

A get_data() function was added to the pkgutil module that returns the contents of resource files included with an installed Python package. For example:

>>> import pkgutil
>>> print pkgutil.get_data('test', 'exception_hierarchy.txt')
BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StandardError
 ...

(Contribución de Paul Moore; bpo-2439.)

The pyexpat module’s Parser objects now allow setting their buffer_size attribute to change the size of the buffer used to hold character data. (Contributed by Achim Gaedke; bpo-1137.)
The queue module now provides queue variants that retrieve entries in different orders. The PriorityQueue class stores queued items in a heap and retrieves them in priority order, and LifoQueue retrieves the most recently added entries first, meaning that it behaves like a stack. (Contributed by Raymond Hettinger.)
The random module’s Random objects can now be pickled on a 32-bit system and unpickled on a 64-bit system, and vice versa. Unfortunately, this change also means that Python 2.6’s Random objects can’t be unpickled correctly on earlier versions of Python. (Contributed by Shawn Ligocki; bpo-1727780.)

La nueva función triangular(low, high, mode) devuelve números aleatorios siguiendo una distribución triangular. Los valores devueltos están entre bajos y altos, sin incluir los propios altos, y con modo como valor más frecuente en la distribución. (Contribución de Wladmir van der Laan y Raymond Hettinger; bpo-1681432.)
Las búsquedas de expresiones regulares largas llevadas a cabo por el módulo re comprobarán la entrega de señales, por lo que ahora se pueden interrumpir las búsquedas que consumen mucho tiempo. (Contribución de Josh Hoyt y Ralf Schmitt; bpo-846388.)

El módulo de expresiones regulares se implementa compilando bytecodes para una pequeña máquina virtual específica de regex. El código no fiable podría crear cadenas maliciosas de código de bytes directamente y causar caídas, por lo que Python 2.6 incluye un verificador para el código de bytes regex. (Contribuido por Guido van Rossum del trabajo para Google App Engine; bpo-3487.)
The rlcompleter module’s complete() method will now ignore exceptions triggered while evaluating a name. (Fixed by Lorenz Quack; bpo-2250.)
The sched module’s scheduler instances now have a read-only queue attribute that returns the contents of the scheduler’s queue, represented as a list of named tuples with the fields (time, priority, action, argument). (Contributed by Raymond Hettinger; bpo-1861.)
The select module now has wrapper functions for the Linux epoll() and BSD kqueue() system calls. modify() method was added to the existing poll objects; pollobj.modify(fd, eventmask) takes a file descriptor or file object and an event mask, modifying the recorded event mask for that file. (Contributed by Christian Heimes; bpo-1657.)
La función shutil.copytree() tiene ahora un argumento opcional ignore que toma un objeto callable. Esta llamada recibirá cada ruta de directorio y una lista del contenido del directorio, y devuelve una lista de nombres que serán ignorados, no copiados.

The shutil module also provides an ignore_patterns() function for use with this new parameter. ignore_patterns() takes an arbitrary number of glob-style patterns and returns a callable that will ignore any files and directories that match any of these patterns. The following example copies a directory tree, but skips both .svn directories and Emacs backup files, which have names ending with “~”:
```
shutil.copytree('Doc/library', '/tmp/library',
                ignore=shutil.ignore_patterns('*~', '.svn'))
```
(Contribución de Tarek Ziadé; bpo-2663.)
Integrar el manejo de señales con los bucles de eventos de manejo de la interfaz gráfica de usuario (GUI), como los utilizados por Tkinter o GTk+, ha sido durante mucho tiempo un problema; la mayoría del software acaba sondeando, despertando cada fracción de segundo para comprobar si se ha producido algún evento de la GUI. El módulo signal puede ahora hacer esto más eficiente. Llamando a signal.set_wakeup_fd(fd) se establece un descriptor de fichero a utilizar; cuando se recibe una señal, se escribe un byte en ese descriptor de fichero. También hay una función en C, PySignal_SetWakeupFd(), para establecer el descriptor.

Event loops will use this by opening a pipe to create two descriptors, one for reading and one for writing. The writable descriptor will be passed to set_wakeup_fd(), and the readable descriptor will be added to the list of descriptors monitored by the event loop via select() or poll(). On receiving a signal, a byte will be written and the main event loop will be woken up, avoiding the need to poll.

(Contribución de Adam Olsen; bpo-1583.)

The siginterrupt() function is now available from Python code, and allows changing whether signals can interrupt system calls or not. (Contributed by Ralf Schmitt.)

The setitimer() and getitimer() functions have also been added (where they’re available). setitimer() allows setting interval timers that will cause a signal to be delivered to the process after a specified time, measured in wall-clock time, consumed process time, or combined process+system time. (Contributed by Guilherme Polo; bpo-2240.)
The smtplib module now supports SMTP over SSL thanks to the addition of the SMTP_SSL class. This class supports an interface identical to the existing SMTP class. (Contributed by Monty Taylor.) Both class constructors also have an optional timeout parameter that specifies a timeout for the initial connection attempt, measured in seconds. (Contributed by Facundo Batista.)

También se ha añadido al módulo una implementación del protocolo LMTP (RFC 2033). LMTP se utiliza en lugar de SMTP cuando se transfiere correo electrónico entre agentes que no gestionan una cola de correo. (LMTP implementado por Leif Hedstrom; bpo-957003.)

smtplib.SMTP.starttls() now complies with RFC 3207 and forgets any knowledge obtained from the server not obtained from the TLS negotiation itself. (Patch contributed by Bill Fenner; bpo-829951.)
El módulo socket soporta ahora TIPC (http://tipc.sourceforge.net/), un protocolo de alto rendimiento no basado en IP y diseñado para su uso en entornos agrupados. Las direcciones TIPC son de 4 o 5 tuplas. (Contribución de Alberto Bertogli; bpo-1646.)

A new function, create_connection(), takes an address and connects to it using an optional timeout value, returning the connected socket object. This function also looks up the address’s type and connects to it using IPv4 or IPv6 as appropriate. Changing your code to use create_connection() instead of socket(socket.AF_INET, ...) may be all that’s required to make your code work with IPv6.
Las clases base del módulo SocketServer ahora admiten la llamada a un método handle_timeout() después de un período de inactividad especificado por el atributo timeout del servidor. (Contribuido por Michael Pomraning.) El método serve_forever() ahora utiliza un intervalo de sondeo opcional medido en segundos, que controla la frecuencia con la que el servidor comprobará si hay una solicitud de apagado. (Contribuido por Pedro Werneck y Jeffrey Yasskin; bpo-742598, bpo-1193577.)
El módulo sqlite3, mantenido por Gerhard Häring, ha sido actualizado de la versión 2.3.2 en Python 2.5 a la versión 2.4.1.
El módulo struct ahora admite el tipo C99 _Bool, utilizando el carácter de formato '?'. (Aportado por David Remahl.)
Los objetos Popen proporcionados por el módulo subprocess ahora tienen los métodos terminate(), kill() y send_signal(). En Windows, send_signal() solo admite la señal SIGTERM y todos estos métodos son alias de la función API Win32 TerminateProcess(). (Contribuido por Christian Heimes).
A new variable in the sys module, float_info, is an object containing information derived from the float.h file about the platform’s floating-point support. Attributes of this object include mant_dig (number of digits in the mantissa), epsilon (smallest difference between 1.0 and the next largest value representable), and several others. (Contributed by Christian Heimes; bpo-1534.)

Another new variable, dont_write_bytecode, controls whether Python writes any .pyc or .pyo files on importing a module. If this variable is true, the compiled files are not written. The variable is initially set on start-up by supplying the -B switch to the Python interpreter, or by setting the PYTHONDONTWRITEBYTECODE environment variable before running the interpreter. Python code can subsequently change the value of this variable to control whether bytecode files are written or not. (Contributed by Neal Norwitz and Georg Brandl.)

Information about the command-line arguments supplied to the Python interpreter is available by reading attributes of a named tuple available as sys.flags. For example, the verbose attribute is true if Python was executed in verbose mode, debug is true in debugging mode, etc. These attributes are all read-only. (Contributed by Christian Heimes.)

A new function, getsizeof(), takes a Python object and returns the amount of memory used by the object, measured in bytes. Built-in objects return correct results; third-party extensions may not, but can define a __sizeof__() method to return the object’s size. (Contributed by Robert Schuppenies; bpo-2898.)

Ahora es posible determinar las funciones actuales del perfilador y del trazador llamando a sys.getprofile() y sys.gettrace(). (Contribuido por Georg Brandl; bpo-1648.)
El módulo tarfile soporta ahora archivos tar POSIX.1-2001 (pax) además de los formatos POSIX.1-1988 (ustar) y GNU tar que ya estaban soportados. El formato por defecto es GNU tar; especifique el parámetro format para abrir un archivo con un formato diferente:
```
tar = tarfile.open("output.tar", "w",
                   format=tarfile.PAX_FORMAT)
```
Los nuevos parámetros encoding y errors especifican una codificación y un esquema de manejo de errores para las conversiones de caracteres. 'strict', 'ignore', y 'replace' son las tres formas estándar en las que Python puede manejar los errores; 'utf-8' es un valor especial que reemplaza los caracteres erróneos con su representación UTF-8. (Las conversiones de caracteres ocurren porque el formato PAX soporta nombres de archivo Unicode, por defecto con codificación UTF-8)

The tarfile.TarFile.add() method now accepts an exclude argument that’s a function that can be used to exclude certain filenames from an archive. The function must take a filename and return true if the file should be excluded or false if it should be archived. The function is applied to both the name initially passed to add() and to the names of files in recursively added directories.

(Todos los cambios han sido aportados por Lars Gustäbel).
Se agregó un parámetro opcional timeout al constructor de la clase telnetlib.Telnet, que especifica un tiempo de espera medido en segundos. (Agregado por Facundo Batista).
La clase tempfile.NamedTemporaryFile suele borrar el archivo temporal que ha creado cuando se cierra el archivo. Este comportamiento se puede cambiar pasando delete=False al constructor. (Contribución de Damien Miller; bpo-1537850.)

A new class, SpooledTemporaryFile, behaves like a temporary file but stores its data in memory until a maximum size is exceeded. On reaching that limit, the contents will be written to an on-disk temporary file. (Contributed by Dustin J. Mitchell.)

The NamedTemporaryFile and SpooledTemporaryFile classes both work as context managers, so you can write with tempfile.NamedTemporaryFile() as tmp: .... (Contributed by Alexander Belopolsky; bpo-2021.)
El módulo test.test_support ha incorporado una serie de administradores de contexto útiles para escribir pruebas. EnvironmentVarGuard() es un administrador de contexto que cambia temporalmente las variables de entorno y las restaura automáticamente a sus valores anteriores.

Another context manager, TransientResource, can surround calls to resources that may or may not be available; it will catch and ignore a specified list of exceptions. For example, a network test may ignore certain failures when connecting to an external web site:
```
with test_support.TransientResource(IOError,
                                errno=errno.ETIMEDOUT):
    f = urllib.urlopen('https://sf.net')
    ...
```
Finally, check_warnings() resets the warnings module’s warning filters and returns an object that will record all warning messages triggered (bpo-3781):
```
with test_support.check_warnings() as wrec:
    warnings.simplefilter("always")
    # ... code that triggers a warning ...
    assert str(wrec.message) == "function is outdated"
    assert len(wrec.warnings) == 1, "Multiple warnings raised"
```
(Contribución de Brett Cannon.)

El módulo textwrap ahora puede conservar los espacios en blanco existentes al principio y al final de las líneas recién creadas especificando drop_whitespace=False como argumento:

>>> S = """This  sentence  has a bunch   of
...   extra   whitespace."""
>>> print textwrap.fill(S, width=15)
This  sentence
has a bunch
of    extra
whitespace.
>>> print textwrap.fill(S, drop_whitespace=False, width=15)
This  sentence
  has a bunch
   of    extra
   whitespace.
>>>

(Contribución de Dwayne Bailey; bpo-1581073.)

The threading module API is being changed to use properties such as daemon instead of setDaemon() and isDaemon() methods, and some methods have been renamed to use underscores instead of camel-case; for example, the activeCount() method is renamed to active_count(). Both the 2.6 and 3.0 versions of the module support the same properties and renamed methods, but don’t remove the old methods. No date has been set for the deprecation of the old APIs in Python 3.x; the old APIs won’t be removed in any 2.x version. (Carried out by several people, most notably Benjamin Peterson.)

The threading module’s Thread objects gained an ident property that returns the thread’s identifier, a nonzero integer. (Contributed by Gregory P. Smith; bpo-2871.)
The timeit module now accepts callables as well as strings for the statement being timed and for the setup code. Two convenience functions were added for creating Timer instances: repeat(stmt, setup, time, repeat, number) and timeit(stmt, setup, time, number) create an instance and call the corresponding method. (Contributed by Erik Demaine; bpo-1533909.)
The tkinter module now accepts lists and tuples for options, separating the elements by spaces before passing the resulting value to Tcl/Tk. (Contributed by Guilherme Polo; bpo-2906.)
El módulo turtle para los gráficos de tortugas ha sido muy mejorado por Gregor Lingl. Las nuevas características del módulo incluyen:
- Mejor animación del movimiento y la rotación de la tortuga.
- Control over turtle movement using the new delay(), tracer(), and speed() methods.
- La posibilidad de establecer nuevas formas para la tortuga y de definir un nuevo sistema de coordenadas.
- Turtles now have an undo() method that can roll back actions.
- Soporte sencillo para reaccionar a eventos de entrada como la actividad del ratón y del teclado, lo que permite escribir juegos sencillos.
- Se puede utilizar un archivo turtle.cfg para personalizar la apariencia inicial de la pantalla de la tortuga.
- Los docstrings del módulo pueden ser sustituidos por nuevos docstrings traducidos a otro idioma.
(bpo-1513695)
An optional timeout parameter was added to the urllib.urlopen function and the urllib.ftpwrapper class constructor, as well as the urllib2.urlopen function. The parameter specifies a timeout measured in seconds. For example:
```
>>> u = urllib2.urlopen("http://slow.example.com",
                        timeout=3)
Traceback (most recent call last):
  ...
urllib2.URLError: <urlopen error timed out>
>>>
```
(Añadido por Facundo Batista.)
La base de datos Unicode proporcionada por el módulo unicodedata ha sido actualizada a la versión 5.1.0. (Actualizado por Martin von Löwis; bpo-3811.)
The warnings module’s formatwarning() and showwarning() gained an optional line argument that can be used to supply the line of source code. (Added as part of bpo-1631171, which re-implemented part of the warnings module in C code.)

A new function, catch_warnings(), is a context manager intended for testing purposes that lets you temporarily modify the warning filters and then restore their original values (bpo-3781).
The XML-RPC SimpleXMLRPCServer and DocXMLRPCServer classes can now be prevented from immediately opening and binding to their socket by passing False as the bind_and_activate constructor parameter. This can be used to modify the instance’s allow_reuse_address attribute before calling the server_bind() and server_activate() methods to open the socket and begin listening for connections. (Contributed by Peter Parente; bpo-1599845.)

SimpleXMLRPCServer also has a _send_traceback_header attribute; if true, the exception and formatted traceback are returned as HTTP headers «X-Exception» and «X-Traceback». This feature is for debugging purposes only and should not be used on production servers because the tracebacks might reveal passwords or other sensitive information. (Contributed by Alan McIntyre as part of his project for Google’s Summer of Code 2007.)
The xmlrpclib module no longer automatically converts datetime.date and datetime.time to the xmlrpclib.DateTime type; the conversion semantics were not necessarily correct for all applications. Code using xmlrpclib should convert date and time instances. (bpo-1330538) The code can also handle dates before 1900 (contributed by Ralf Schmitt; bpo-2014) and 64-bit integers represented by using <i8> in XML-RPC responses (contributed by Riku Lindblad; bpo-2985).
The zipfile module’s ZipFile class now has extract() and extractall() methods that will unpack a single file or all the files in the archive to the current directory, or to a specified directory:
```
z = zipfile.ZipFile('python-251.zip')

# Unpack a single file, writing it relative
# to the /tmp directory.
z.extract('Python/sysmodule.c', '/tmp')

# Unpack all the files in the archive.
z.extractall()
```
(Contribución de Alan McIntyre; bpo-467924.)

The open(), read() and extract() methods can now take either a filename or a ZipInfo object. This is useful when an archive accidentally contains a duplicated filename. (Contributed by Graham Horler; bpo-1775025.)

Por último, zipfile soporta ahora el uso de nombres de archivo Unicode para los ficheros archivados. (Contribución de Alexey Borzenkov; bpo-1734346.)

El módulo `ast`¶

El módulo ast proporciona una representación de árbol de sintaxis abstracta del código Python, y Armin Ronacher ha contribuido con un conjunto de funciones de ayuda que realizan una variedad de tareas comunes. Éstas serán útiles para paquetes de plantillas HTML, analizadores de código y herramientas similares que procesan código Python.

The parse() function takes an expression and returns an AST. The dump() function outputs a representation of a tree, suitable for debugging:

import ast

t = ast.parse("""
d = {}
for i in 'abcdefghijklm':
    d[i + i] = ord(i) - ord('a') + 1
print d
""")
print ast.dump(t)

Esto produce un árbol profundamente anidado:

Module(body=[
  Assign(targets=[
    Name(id='d', ctx=Store())
   ], value=Dict(keys=[], values=[]))
  For(target=Name(id='i', ctx=Store()),
      iter=Str(s='abcdefghijklm'), body=[
    Assign(targets=[
      Subscript(value=
        Name(id='d', ctx=Load()),
          slice=
          Index(value=
            BinOp(left=Name(id='i', ctx=Load()), op=Add(),
             right=Name(id='i', ctx=Load()))), ctx=Store())
     ], value=
     BinOp(left=
      BinOp(left=
       Call(func=
        Name(id='ord', ctx=Load()), args=[
          Name(id='i', ctx=Load())
         ], keywords=[], starargs=None, kwargs=None),
       op=Sub(), right=Call(func=
        Name(id='ord', ctx=Load()), args=[
          Str(s='a')
         ], keywords=[], starargs=None, kwargs=None)),
       op=Add(), right=Num(n=1)))
    ], orelse=[])
   Print(dest=None, values=[
     Name(id='d', ctx=Load())
   ], nl=True)
 ])

The literal_eval() method takes a string or an AST representing a literal expression, parses and evaluates it, and returns the resulting value. A literal expression is a Python expression containing only strings, numbers, dictionaries, etc. but no statements or function calls. If you need to evaluate an expression but cannot accept the security risk of using an eval() call, literal_eval() will handle it safely:

>>> literal = '("a", "b", {2:4, 3:8, 1:2})'
>>> print ast.literal_eval(literal)
('a', 'b', {1: 2, 2: 4, 3: 8})
>>> print ast.literal_eval('"a" + "b"')
Traceback (most recent call last):
  ...
ValueError: malformed string

The module also includes NodeVisitor and NodeTransformer classes for traversing and modifying an AST, and functions for common transformations such as changing line numbers.

The `future_builtins` module¶

Python 3.0 makes many changes to the repertoire of built-in functions, and most of the changes can’t be introduced in the Python 2.x series because they would break compatibility. The future_builtins module provides versions of these built-in functions that can be imported when writing 3.0-compatible code.

Las funciones de este módulo incluyen actualmente:

ascii(obj): equivalente a repr(). En Python 3.0, repr() devolverá una cadena Unicode, mientras que ascii() devolverá una cadena de bytes ASCII pura.
filtro(predicado, iterable), map(func, iterable1, ...): las versiones 3.0 devuelven iteradores, a diferencia de las funciones integradas 2.x que devuelven listas.
hex(value), oct(value): instead of calling the __hex__() or __oct__() methods, these versions will call the __index__() method and convert the result to hexadecimal or octal. oct() will use the new 0o notation for its result.

El módulo `json`: Notación de objetos de JavaScript¶

El nuevo módulo json soporta la codificación y decodificación de tipos Python en JSON (Javascript Object Notation). JSON es un formato de intercambio ligero que se utiliza a menudo en las aplicaciones web. Para más información sobre JSON, consulte http://www.json.org.

json viene con soporte para decodificar y codificar la mayoría de los tipos incorporados de Python. El siguiente ejemplo codifica y decodifica un diccionario:

>>> import json
>>> data = {"spam": "foo", "parrot": 42}
>>> in_json = json.dumps(data) # Encode the data
>>> in_json
'{"parrot": 42, "spam": "foo"}'
>>> json.loads(in_json) # Decode into a Python object
{"spam": "foo", "parrot": 42}

También es posible escribir tus propios decodificadores y codificadores para soportar más tipos. También se admite la impresión bonita de las cadenas JSON.

json (originalmente llamado simplejson) fue escrito por Bob Ippolito.

El módulo `plistlib`: Un analizador de listas de propiedades¶

El formato .plist se utiliza habitualmente en Mac OS X para almacenar tipos de datos básicos (números, cadenas, listas y diccionarios) serializándolos en un formato basado en XML. Se asemeja a la serialización XML-RPC de los tipos de datos.

A pesar de ser utilizado principalmente en Mac OS X, el formato no tiene nada de específico para Mac y la implementación de Python funciona en cualquier plataforma que soporte Python, por lo que el módulo plistlib ha sido promovido a la biblioteca estándar.

El uso del módulo es sencillo:

import sys
import plistlib
import datetime as dt

# Create data structure
data_struct = dict(lastAccessed=dt.datetime.now(),
                   version=1,
                   categories=('Personal','Shared','Private'))

# Create string containing XML.
plist_str = plistlib.writePlistToString(data_struct)
new_struct = plistlib.readPlistFromString(plist_str)
print data_struct
print new_struct

# Write data structure to a file and read it back.
plistlib.writePlist(data_struct, '/tmp/customizations.plist')
new_struct = plistlib.readPlist('/tmp/customizations.plist')

# read/writePlist accepts file-like objects as well as paths.
plistlib.writePlist(data_struct, sys.stdout)

mejoras en ctypes¶

Thomas Heller siguió manteniendo y mejorando el módulo ctypes.

ctypes now supports a c_bool datatype that represents the C99 bool type. (Contributed by David Remahl; bpo-1649190.)

Los tipos de cadena, buffer y array de ctypes han mejorado el soporte para la sintaxis de corte extendida, donde se suministran varias combinaciones de (start, stop, step). (Implementado por Thomas Wouters)

All ctypes data types now support from_buffer() and from_buffer_copy() methods that create a ctypes instance based on a provided buffer object. from_buffer_copy() copies the contents of the object, while from_buffer() will share the same memory area.

Una nueva convención de llamada indica a ctypes que borre las variables errno o Win32 LastError al inicio de cada llamada envuelta. (Implementado por Thomas Heller; bpo-1798.)

You can now retrieve the Unix errno variable after a function call. When creating a wrapped function, you can supply use_errno=True as a keyword parameter to the DLL function and then call the module-level methods set_errno() and get_errno() to set and retrieve the error value.

The Win32 LastError variable is similarly supported by the DLL, OleDLL(), and WinDLL() functions. You supply use_last_error=True as a keyword parameter and then call the module-level methods set_last_error() and get_last_error().

The byref() function, used to retrieve a pointer to a ctypes instance, now has an optional offset parameter that is a byte count that will be added to the returned pointer.

Mejora de la compatibilidad con SSL¶

Bill Janssen ha realizado amplias mejoras en el soporte de Python 2.6 para la Capa de Conexión Segura añadiendo un nuevo módulo, ssl, que está construido sobre la biblioteca OpenSSL. Este nuevo módulo proporciona más control sobre el protocolo negociado, los certificados X.509 utilizados, y tiene un mejor soporte para escribir servidores SSL (a diferencia de los clientes) en Python. El soporte SSL existente en el módulo socket no ha sido eliminado y sigue funcionando, aunque será eliminado en Python 3.0.

To use the new module, you must first create a TCP connection in the usual way and then pass it to the ssl.wrap_socket() function. It’s possible to specify whether a certificate is required, and to obtain certificate info by calling the getpeercert() method.

Ver también

La documentación del módulo ssl.

Cancelaciones y eliminaciones¶

Se han eliminado las excepciones de cadena. Al intentar utilizarlas se produce un TypeError.
Se siguen realizando cambios en la interfaz Exception según lo dictado por PEP 352. En la versión 2.6, el atributo message se está reemplazando por el atributo args.
(modo 3.0-warning) Python 3.0 presentará una biblioteca estándar reorganizada que eliminará muchos módulos obsoletos y renombrará otros. Python 2.6 funcionando en modo 3.0-warning avisará de estos módulos cuando se importen.

La lista de módulos obsoletos es: audiodev, bgenlocations, buildtools, bundlebuilder, Canvas, compiler, dircache, dl, fpformat, gensuitemodule, ihooks, imageop, imgfile, linuxaudiodev, mhlib, mimetools, multifile, new, pure, statvfs, sunaudiodev, test.testall y toaiff.
El módulo gopherlib ha sido eliminado.
El módulo MimeWriter y el módulo mimify han quedado obsoletos; utilice en su lugar el paquete email.
El módulo md5 ha quedado obsoleto; utilice en su lugar el módulo hashlib.
El módulo posixfile ha quedado obsoleto; fcntl.lockf() proporciona un mejor bloqueo.
El módulo popen2 ha quedado obsoleto; utilice el módulo subprocess.
Se ha eliminado el módulo rgbimg.
El módulo sets ha quedado obsoleto; es mejor utilizar los tipos incorporados set y frozenset.
El módulo sha ha quedado obsoleto; utilice en su lugar el módulo hashlib.

Cambios en la API de construcción y C¶

Los cambios en el proceso de construcción de Python y en la API de C incluyen:

Python ahora debe ser compilado con compiladores C89 (¡después de 19 años!). Esto significa que el árbol de fuentes de Python ha abandonado sus propias implementaciones de memmove() y strerror(), que están en la biblioteca estándar de C89.
Python 2.6 puede ser construido con Microsoft Visual Studio 2008 (versión 9.0), y este es el nuevo compilador por defecto. Ver el directorio PCbuild para los archivos de construcción. (Implementado por Christian Heimes)
En Mac OS X, Python 2.6 puede ser compilado como una construcción universal de 4 vías. El script configure puede tomar una opción :!–with-universal-archs=[32-bit|64-bit|all], controlando si los binarios se construyen para arquitecturas de 32 bits (x86, PowerPC), 64 bits (x86-64 y PPC-64), o ambas. (Contribución de Ronald Oussoren)
Una nueva función agregada en Python 2.6.6, PySys_SetArgvEx(), establece el valor de sys.argv y opcionalmente puede actualizar sys.path para incluir el directorio que contiene el script nombrado por sys.argv[0] dependiendo del valor de un parámetro updatepath.

Esta función se agregó para cerrar un agujero de seguridad en las aplicaciones que incorporan Python. La función anterior, PySys_SetArgv(), siempre actualizaba sys.path y, a veces, añadía el directorio actual. Esto significaba que, si ejecutaba una aplicación que incorporaba Python en un directorio controlado por otra persona, los atacantes podían colocar un módulo troyano en el directorio (por ejemplo, un archivo llamado os.py) que su aplicación luego importaría y ejecutaría.

Si mantiene una aplicación C/C++ que incorpora Python, verifique si está llamando a PySys_SetArgv() y considere cuidadosamente si la aplicación debería usar PySys_SetArgvEx() con updatepath configurado como falso. Tenga en cuenta que el uso de esta función romperá la compatibilidad con las versiones 2.6.5 y anteriores de Python; si tiene que continuar trabajando con versiones anteriores, puede dejar la llamada a PySys_SetArgv() y llamar a PyRun_SimpleString("sys.path.pop(0)\n") después para descartar el primer componente sys.path.

Problema de seguridad informado como CVE 2008-5983; discutido en gh-50003 y solucionado por Antoine Pitrou.
The BerkeleyDB module now has a C API object, available as bsddb.db.api. This object can be used by other C extensions that wish to use the bsddb module for their own purposes. (Contributed by Duncan Grisby.)
La nueva interfaz del buffer, descrita previamente en la sección PEP 3118, añade PyObject_GetBuffer() y PyBuffer_Release(), así como algunas otras funciones.
El uso que hace Python de la biblioteca stdio de C es ahora seguro para los hilos, o al menos tan seguro como la biblioteca subyacente. Un error potencial de larga data ocurría si un hilo cerraba un objeto de archivo mientras otro hilo estaba leyendo o escribiendo en el objeto. En la versión 2.6 los objetos archivo tienen un contador de referencias, manipulado por las funciones PyFile_IncUseCount() y PyFile_DecUseCount(). Los objetos de archivo no pueden cerrarse a menos que el recuento de referencias sea cero. PyFile_IncUseCount() debe llamarse mientras se mantiene el GIL, antes de realizar una operación de E/S utilizando el puntero FILE *, y PyFile_DecUseCount() debe llamarse inmediatamente después de recuperar el GIL. (Contribución de Antoine Pitrou y Gregory P. Smith)
Importar módulos simultáneamente en dos hilos diferentes ya no se bloquea; ahora lanzará un ImportError. Una nueva función de la API, PyImport_ImportModuleNoBlock(), buscará un módulo en sys.modules primero, y luego intentará importarlo después de adquirir un bloqueo de importación. Si el bloqueo de importación está en manos de otro hilo, se genera un ImportError. (Contribuido por Christian Heimes.)
Varias funciones devuelven información sobre la compatibilidad de punto flotante de la plataforma. PyFloat_GetMax() devuelve el valor máximo representable de punto flotante y PyFloat_GetMin() devuelve el valor positivo mínimo. PyFloat_GetInfo() devuelve un objeto que contiene más información del archivo float.h, como "mant_dig" (número de dígitos en la mantisa), "epsilon" (diferencia más pequeña entre 1.0 y el siguiente valor más grande representable) y varios otros. (Contribuido por Christian Heimes; bpo-1534.)
C functions and methods that use PyComplex_AsCComplex() will now accept arguments that have a __complex__() method. In particular, the functions in the cmath module will now accept objects with this method. This is a backport of a Python 3.0 change. (Contributed by Mark Dickinson; bpo-1675423.)
La API de C de Python incluye ahora dos funciones para comparar cadenas sin distinción de mayúsculas y minúsculas, PyOS_stricmp(char*, char*) y PyOS_strnicmp(char*, char*, Py_ssize_t). (Contribución de Christian Heimes; bpo-1635.)
Muchas extensiones de C definen su propia macro para añadir enteros y cadenas al diccionario del módulo en la función init*. Python 2.6 finalmente define macros estándar para añadir valores a un módulo, PyModule_AddStringMacro y PyModule_AddIntMacro(). (Contribución de Christian Heimes.)
Algunas macros han sido renombradas tanto en la 3.0 como en la 2.6 para dejar más claro que son macros y no funciones. Py_Size() se convierte en Py_SIZE(), Py_Type() se convierte en Py_TYPE(), y Py_Refcnt() se convierte en Py_REFCNT(). Las macros de mayúsculas y minúsculas siguen estando disponibles en Python 2.6 por compatibilidad con versiones anteriores. (bpo-1629)
Distutils ahora coloca las extensiones C que construye en un directorio diferente cuando se ejecuta en una versión de depuración de Python. (Contribución de Collin Winter; bpo-1530959.)
Varios tipos de datos básicos, como los enteros y las cadenas, mantienen listas internas de objetos libres que pueden reutilizarse. Las estructuras de datos para estas listas libres siguen ahora una convención de nomenclatura: la variable se llama siempre free_list, el contador se llama siempre numfree, y siempre se define una macro Py<typename>_MAXFREELIST
Un nuevo objetivo de Makefile, «make patchcheck», prepara el árbol de fuentes de Python para hacer un parche: corrige los espacios en blanco al final de todos los archivos .py modificados, comprueba si la documentación ha sido cambiada, e informa si los archivos Misc/ACKS y Misc/NEWS han sido actualizados. (Contribuido por Brett Cannon.)

Otro nuevo objetivo, «make profile-opt», compila un binario de Python utilizando la optimización guiada por perfiles de GCC. Compila Python con el perfil habilitado, ejecuta el conjunto de pruebas para obtener un conjunto de resultados de perfil, y luego compila usando estos resultados para la optimización. (Contribución de Gregory P. Smith)

Cambios específicos en los puertos: Windows¶

Se ha eliminado el soporte para Windows 95, 98, ME y NT4. Python 2.6 requiere al menos Windows 2000 SP4.
El nuevo compilador por defecto en Windows es Visual Studio 2008 (versión 9.0). Los directorios de compilación para Visual Studio 2003 (versión 7.1) y 2005 (versión 8.0) se han trasladado al directorio PC/. El nuevo directorio PCbuild admite la compilación cruzada para X64, las compilaciones de depuración y la optimización guiada por perfil (PGO). Las compilaciones PGO son aproximadamente un 10% f más rápidas que las normales. (Contribuido por Christian Heimes con la ayuda de Amaury Forgeot d’Arc y Martin von Löwis)
El módulo msvcrt ahora admite las variantes de caracteres normales y anchos de la API de E/S de la consola. La función getwch() lee una pulsación de tecla y devuelve un valor Unicode, al igual que la función getwche(). La función putwch() toma un carácter Unicode y lo escribe en la consola. (Contribuido por Christian Heimes).
os.path.expandvars() ahora expandirá las variables de entorno de la forma «%var%», y «~user» se expandirá en la ruta del directorio personal del usuario. (Contribución de Josiah Carlson; bpo-957650.)
The socket module’s socket objects now have an ioctl() method that provides a limited interface to the WSAIoctl() system interface.
El módulo _winreg ahora tiene una función, ExpandEnvironmentStrings(), que expande las referencias de variables de entorno como %NAME% en una cadena de entrada. Los objetos de control proporcionados por este módulo ahora admiten el protocolo de contexto, por lo que se pueden utilizar en instrucciones with. (Contribuido por Christian Heimes).

_winreg también tiene un mejor soporte para sistemas x64, exponiendo las funciones DisableReflectionKey(), EnableReflectionKey() y QueryReflectionKey(), que habilitan y deshabilitan la reflexión del registro para procesos de 32 bits que se ejecutan en sistemas de 64 bits. (bpo-1753245)
El objeto Record del módulo msilib obtuvo los métodos GetInteger() y GetString() que devuelven valores de campo como un entero o una cadena. (Contribuido por Floris Bruynooghe; bpo-2125).

Cambios específicos en los puertos: Mac OS X¶

Cuando se compila una estructura de Python, ahora se puede especificar el nombre de la estructura que se utilizará proporcionando la opción --with-framework-name= al script configure.
Se ha eliminado el módulo macfs. Esto a su vez requirió que se eliminara la función macostools.touched() porque dependía del módulo macfs. (bpo-1490190)
Muchos otros módulos de Mac OS han quedado obsoletos y se eliminarán en Python 3.0: _builtinSuites, aepack, aetools, aetypes, applesingle, appletrawmain, appletrunner, argvemulator, Audio_mac, autoGIL, Carbon, cfmfile, CodeWarrior, ColorPicker, EasyDialogs, Explorer, Finder, FrameWork, findertools, ic, icglue, icopen, macerrors, MacOS, macfs, macostools, macresource, MiniAEFrame, Nav, Netscape, OSATerminology, pimp, PixMapWrapper, StdSuites, SystemEvents, Terminal y terminalcommand.

Cambios específicos en los puertos: IRIX¶

Varios módulos antiguos específicos de IRIX quedaron obsoletos y se eliminarán en Python 3.0: al y AL, cd, cddb, cdplayer, CL y cl, DEVICE, ERRNO, FILE, FL y fl, flp, fm, GET, GLWS, GL y gl, IN, IOCTL, jpeg, panelparser, readcd, SV y sv, torgb, videoreader y WAIT.

Adaptación a Python 2.6¶

Esta sección enumera los cambios descritos anteriormente y otras correcciones de errores que pueden requerir cambios en su código:

Las clases que no se supone que son hashable deben establecer __hash__ = None en sus definiciones para indicar el hecho.
Se han eliminado las excepciones de cadena. Al intentar utilizarlas se produce un TypeError.
The __init__() method of collections.deque now clears any existing contents of the deque before adding elements from the iterable. This change makes the behavior match list.__init__().
object.__init__() previously accepted arbitrary arguments and keyword arguments, ignoring them. In Python 2.6, this is no longer allowed and will result in a TypeError. This will affect __init__() methods that end up calling the corresponding method on object (perhaps through using super()). See bpo-1683368 for discussion.
The Decimal constructor now accepts leading and trailing whitespace when passed a string. Previously it would raise an InvalidOperation exception. On the other hand, the create_decimal() method of Context objects now explicitly disallows extra whitespace, raising a ConversionSyntax exception.
Debido a un accidente de implementación, si se pasaba una ruta de archivo a la función incorporada __import__(), ésta importaría realmente el archivo especificado. Sin embargo, nunca se pretendió que esto funcionara, y la implementación ahora comprueba explícitamente este caso y lanza un ImportError.
API C: las funciones PyImport_Import() y PyImport_ImportModule() ahora se ajustan por defecto a importaciones absolutas, no a importaciones relativas. Esto afectará a las extensiones de C que importen otros módulos.
API C: los tipos de datos de extensión que no deben ser hashable deben definir su ranura tp_hash a PyObject_HashNotImplemented().
The socket module exception socket.error now inherits from IOError. Previously it wasn’t a subclass of StandardError but now it is, through IOError. (Implemented by Gregory P. Smith; bpo-1706815.)
The xmlrpclib module no longer automatically converts datetime.date and datetime.time to the xmlrpclib.DateTime type; the conversion semantics were not necessarily correct for all applications. Code using xmlrpclib should convert date and time instances. (bpo-1330538)
(Modo de advertencia 3.0) La clase Exception ahora advierte cuando se accede utilizando el acceso a la rebanada o al índice; tener Exception se comporta como una tupla está siendo eliminado.
(modo de advertencia 3.0) las comparaciones de desigualdad entre dos diccionarios o dos objetos que no implementan métodos de comparación se reportan como advertencias. dict1 == dict2 sigue funcionando, pero dict1 < dict2 está siendo eliminado.

Las comparaciones entre celdas, que son un detalle de implementación de las reglas de alcance de Python, también causan advertencias porque tales comparaciones están prohibidas por completo en 3.0.

Para aplicaciones que incorporan Python:

La función PySys_SetArgvEx() se agregó en Python 2.6.6, lo que permite que las aplicaciones cierren un agujero de seguridad cuando se usa la función PySys_SetArgv() existente. Verifique si está llamando a PySys_SetArgv() y considere cuidadosamente si la aplicación debería usar PySys_SetArgvEx() con updatepath configurado como falso.

Agradecimientos¶

El autor desea agradecer a las siguientes personas sus sugerencias, correcciones y ayuda en varios borradores de este artículo: Georg Brandl, Steve Brown, Nick Coghlan, Ralph Corderoy, Jim Jewett, Kent Johnson, Chris Lambacher, Martin Michlmayr, Antoine Pitrou, Brian Warner.

Qué hay de nuevo en Python 2.6¶

Python 3.0¶

Cambios en el proceso de desarrollo¶

Nuevo seguidor de incidentes: Roundup¶

Nuevo formato de documentación: texto reestructurado con Sphinx¶

PEP 343: La sentencia “with”¶

Escribiendo gestores de contexto¶

El módulo contextlib¶

PEP 366: Importaciones relativas explícitas desde un módulo principal¶

PEP 370: Directorio de site-packages por usuario¶

PEP 371: El paquete multiprocessing¶

PEP 3101: Formateo avanzado de cadena de caracteres¶

PEP 3105: print como función¶

PEP 3110: Cambios en el manejo de excepciones¶

PEP 3112: Literales de bytes¶

PEP 3116: Nueva biblioteca de E/S¶

PEP 3118: Protocolo revisado de la memoria intermedia¶

PEP 3119: Clases base abstractas¶

PEP 3127: Soporte y sintaxis de literales enteros¶

PEP 3129: Decoradores de clase¶

PEP 3141: Una jerarquía de tipos para los números¶

El módulo fractions¶

Otros cambios lingüísticos¶

Optimizaciones¶

Cambios de intérprete¶

Módulos nuevos y mejorados¶

El módulo ast¶

The future_builtins module¶

El módulo json: Notación de objetos de JavaScript¶

El módulo plistlib: Un analizador de listas de propiedades¶

mejoras en ctypes¶

Mejora de la compatibilidad con SSL¶

Cancelaciones y eliminaciones¶

Cambios en la API de construcción y C¶

Cambios específicos en los puertos: Windows¶

Cambios específicos en los puertos: Mac OS X¶

Cambios específicos en los puertos: IRIX¶

Adaptación a Python 2.6¶

Agradecimientos¶

PEP 370: Directorio de `site-packages` por usuario¶

PEP 371: El paquete `multiprocessing`¶

PEP 3105: `print` como función¶

El módulo `fractions`¶

El módulo `ast`¶

The `future_builtins` module¶

El módulo `json`: Notación de objetos de JavaScript¶

El módulo `plistlib`: Un analizador de listas de propiedades¶