Qué hay de nuevo en Python 2.6
******************************

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

This article explains the new features in Python 2.6, released on
October 1, 2008.  The release schedule is described in **PEP 361**.

El tema principal de Python 2.6 es preparar el camino de migración a
Python 3.0, un importante rediseño del lenguaje. Siempre que sea
posible, Python 2.6 incorpora nuevas características y sintaxis de 3.0
mientras sigue siendo compatible con el código existente al no
eliminar características o sintaxis más antiguas. Cuando no es posible
hacer eso, Python 2.6 intenta hacer lo que puede, agregando funciones
de compatibilidad en el módulo "future_builtins" y un interruptor "-3"
para advertir sobre usos que dejarán de ser compatibles en 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:

* El método "__complex__()" para convertir objetos en un número
  complejo.

* Sintaxis alternativa para detectar excepciones: "except TypeError as
  exc".

* La adición de "functools.reduce()" como sinónimo de la función
  incorporada "reduce()".

Python 3.0 agrega varias funciones integradas nuevas y cambia la
semántica de algunas integradas existentes. Las funciones que son
nuevas en 3.0 como "bin()" simplemente se han agregado a Python 2.6,
pero las funciones existentes no se han cambiado; en cambio, el módulo
"future_builtins" tiene versiones con la nueva semántica 3.0. El
código escrito puede ser compatible con 3.0 haciendo "from
future_builtins import hex, map" según sea necesario.

Un nuevo modificador de línea de comandos, "-3", habilita advertencias
sobre características que se eliminarán en Python 3.0. Puede ejecutar
código con este modificador para ver cuánto trabajo será necesario
para migrar el código a 3.0. El valor de este modificador está
disponible para el código Python como la variable booleana
"sys.py3kwarning", y para el código de extensión C como
"Py_Py3kWarningFlag".

Ver también:

  Las series 3xxx de PEP, que contienen propuestas para Python 3.0.
  **PEP 3000** describe el proceso de desarrollo de Python 3.0.
  Empiece con **PEP 3100** que describe los objetivos generales de
  Python 3.0, y luego explore los PEPS con números más altos 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.

The infrastructure committee of the Python Software Foundation
therefore posted a call for issue trackers, asking volunteers to set
up different products and import some of the bugs and patches from
SourceForge.  Four different trackers were examined: Jira, Launchpad,
Roundup, and Trac. The committee eventually settled on Jira and
Roundup as the two candidates.  Jira is a commercial product that
offers no-cost hosted instances to free-software projects; Roundup is
an open-source project that requires volunteers to administer it and a
server to host it.

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.

Hosting of the Python bug tracker is kindly provided by Upfront
Systems of Stellenbosch, South Africa.  Martin von Löwis put a lot of
effort into importing existing bugs and patches from SourceForge; his
scripts for this import operation are at
"https://svn.python.org/view/tracker/importer/" and may be useful to
other projects wishing to move from SourceForge to 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.

During the 2.6 development cycle, Georg Brandl put a lot of effort
into building a new toolchain for processing the documentation.  The
resulting package is called Sphinx, and is available from 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

La expresión se evalúa y debe dar como resultado un objeto que admita
el protocolo de administración de contexto (es decir, tiene los
métodos "__enter__()" y "__exit__()").

El objeto "__enter__()" se llama antes de que se ejecute *with-block*
y, por lo tanto, se puede ejecutar código de configuración. También,
si se proporciona, puede retornar un valor que esté vinculado al
nombre *variable*. (Tenga en cuenta que a la *variable* *no* se le
asigna el resultado de la *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
  "file.__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.

La función "localcontext()" en el módulo "decimal" facilita guardar y
restaurar el contexto decimal actual, que encapsula la precisión
deseada y las características de redondeo para los cálculos:

   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* lanza una excepción, se llama al método "__exit__()" del
  gestor de contexto con tres argumentos, los detalles de la excepción
  ("type, value, traceback", los mismos valores retornados por
  "sys.exc_info()", que también puede 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 *false* vuelve a
  lanzar la excepción, y "True" resultará en inhibirla. Rara vez
  querrá suprimir la excepción, porque si lo hace, el autor del código
  que contenga la sentencia '"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 ...

La transacción debe confirmarse si el código del bloque se ejecuta sin
problemas o revertirse si hay una excepción. Aquí está la interfaz
básica para "DatabaseConnection" que asumiré:

   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 fácil, ya que solo tiene 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 retornará.
Luego, el usuario puede agregar "as cursor" a su sentencia '"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
ocurrió una excepción. Si no hubo excepción, la transacción se
confirma. La transacción se revierte si hubo una excepció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"'.

El decorador se llama "contextmanager()", y te permite escribir una
única función generadora en lugar de definir una clase nueva. El
generador debería producir exactamente un valor. El código hasta
"yield" se ejecutará como el método "__enter__()", y el valor obtenido
será el valor de retorno del método que se vinculará a la variable en
la clausula "as" (si la hay) de la sentencia '"with"'. El código
después de "yield" se ejecutará en el método "__exit__()" . Cualquier
excepción lanzada en el bloque será generada por la sentencia "yield".

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):
       ...

Por último, la función "close()" retorna su argumento para que pueda
vincularse a una variable, y llama al método ".close()" del argumento
al final del bloque.

   import urllib, sys
   from contextlib import closing

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

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.

La corrección para Python 2.6 agrega un atributo "__package__" a los
módulos. Cuando este atributo está presente, las importaciones
relativas serán relativas al valor de este atributo en lugar del
atributo "__name__".

Las importaciones de estilo PEP 302 pueden configurar "__package__"
según sea necesario. El módulo "runpy" que implementa el modificador
"-m" ahora hace esto, por lo que las importaciones relativas ahora
funcionarán correctamente en los scripts que se ejecutan desde el
interior de un paquete.


PEP 370: Directorio de "site-packages" por usuario
==================================================

When you run Python, the module search path "sys.path" usually
includes a directory whose path ends in ""site-packages"".  This
directory is intended to hold locally installed packages available to
all users using a machine or a particular site installation.

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.

Si no le gusta el directorio predeterminado, puede sobrescribirlo
mediante una variable de entorno. "PYTHONUSERBASE" establece el
directorio raíz utilizado para todas las versiones de Python que
admiten esta función. En Windows, el directorio de datos específicos
de la aplicación se puede cambiar configurando la variable de entorno
"APPDATA". También puede modificar el archivo "site.py" para su
instalación de Python.

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.

El módulo "multiprocessing" comenzó como una emulación exacta del
módulo "threading" usando procesos en lugar de hilos. Ese objetivo se
descartó en el camino a Python 2.6, pero el enfoque general del módulo
sigue siendo similar. La clase fundamental es "Process", a la que se
le pasa un objeto invocable y una colección de argumentos. El método
"start()" establece el invocable ejecutándose en un subproceso,
después de lo cual se puede llamar al método "is_alive()" para
verificar si el subproceso aún se está ejecutando y al método "join()"
para esperar al proceso para salir.

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

Otras dos clases, "Pool" y "Manager", proporcionan interfaces de nivel
superior. "Pool" creará un número fijo de procesos de trabajo, y las
solicitudes se pueden distribuir a los trabajadores llamando a
"apply()" o "apply_async()" para agregar una sola solicitud, y "map()"
o "map_async()" para agregar una serie de solicitudes. El siguiente
código usa "Pool" para distribuir las solicitudes en 5 procesos de
trabajo y recuperar una lista de resultados:

   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
   ...

La otra interfaz de alto nivel, la clase "Manager", crea un proceso de
servidor separado que puede contener copias maestras de las
estructuras de datos de Python. Luego, otros procesos pueden acceder y
modificar estas estructuras de datos utilizando objetos proxy. El
siguiente ejemplo crea un diccionario compartido llamando al método
"dict()"; los procesos de trabajo luego insertan valores en el
diccionario. (El bloqueo no se realiza automáticamente, lo cual no
importa en este ejemplo. Los métodos de "Manager" también incluyen
"Lock()", "RLock()", y "Semaphore()" para crear bloqueos compartidos.)

   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 1
   11 39916800
   21 51090942171709440000
   31 8222838654177922817725562880000000
   41 33452526613163807108170062053440751665152000000000
   51 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
===================================================

In Python 3.0, the "%" operator is supplemented by a more powerful
string formatting method, "format()".  Support for the "str.format()"
method has been backported to Python 2.6.

In 2.6, both 8-bit and Unicode strings have a ".format()" method that
treats the string as a template and takes the arguments to be
formatted. The formatting template uses curly brackets ("{", "}") as
special characters:

   >>> # 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.                                |
+-------+--------------------------------------------------------------------------+

Las clases y los tipos pueden definir un método "__format__()" para
controlar cómo se formatean.  Recibe un único argumento, el
especificador de formato:

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

También hay un builtin "format()" que formateará un solo valor.  Llama
al método "__format__()" del tipo con el especificador proporcionado:

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

Ver también:

  Sintaxis de formateo de cadena
     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('# of entries', len(dictionary), 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:

   try:
       ...
   except TypeError, ValueError:  # Wrong!
       ...

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'

Las matrices de bytes admiten la mayoría de los métodos de los tipos
de cadena, como "startswith()"/"endswith()", "find()"/"rfind()", y
algunos de los métodos de las listas, como "append()", "pop()" y
"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
=================================

Los objetos de archivo incorporados en Python soportan una serie de
métodos, pero los objetos que imitan a los archivos no necesariamente
los soportan todos.  Los objetos que imitan a los archivos normalmente
soportan "read()" y "write()", pero pueden no soportar "readline()",
por ejemplo.  Python 3.0 introduce una biblioteca de E/S por capas en
el módulo "io" que separa las funciones de almacenamiento en búfer y
manejo de texto de las operaciones fundamentales de lectura y
escritura.

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

* "RawIOBase" define las operaciones de E/S en bruto: "read()",
  "readinto()", "write()", "seek()", "tell()", "truncate()", y
  "close()". La mayoría de los métodos de esta clase suelen
  corresponder a una única llamada al sistema. También hay métodos
  "readable()", "writable()" y "seekable()" para determinar qué
  operaciones permite un objeto dado.

  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" es una clase base abstracta que almacena los datos
  en la memoria para reducir el número de llamadas al sistema,
  haciendo más eficiente el procesamiento de E/S. Soporta todos los
  métodos de "RawIOBase", y añade un atributo "raw" que contiene el
  objeto crudo subyacente.

  Hay cinco clases concretas que implementan este ABC.
  "BufferedWriter" y "BufferedReader" son para objetos que soportan el
  uso de sólo escritura o de sólo lectura que tienen un método
  "seek()" para el acceso aleatorio. Los objetos "BufferedRandom"
  soportan el acceso de lectura y escritura sobre el mismo flujo
  subyacente, y "BufferedRWPair" es para objetos como los TTYs que
  tienen operaciones de lectura y escritura actuando sobre flujos de
  datos desconectados. La clase "BytesIO" permite leer, escribir y
  buscar sobre un buffer en memoria.

* "TextIOBase": Proporciona funciones para leer y escribir cadenas
  (recuerde que las cadenas serán Unicode en Python 3.0), y soporta
  *universal newlines*. "TextIOBase" define el método "readline()" y
  soporta la iteración sobre objetos.

  Hay dos implementaciones concretas. "TextIOWrapper" envuelve un
  objeto de E/S con buffer, soportando todos los métodos de E/S de
  texto y añadiendo un atributo "buffer" para acceder al objeto
  subyacente. "StringIO" simplemente almacena todo en memoria sin
  escribir nunca nada en el disco.

  (En Python 2.6, "io.StringIO" está implementado en Python puro, por
  lo que es bastante lento.   Por lo tanto, deberías seguir con el
  módulo "StringIO" existente o con "cStringIO" por ahora.  En algún
  momento el módulo "io" de Python 3.0 será reescrito en C para
  aumentar la velocidad, y quizás la implementación en C será
  retroalimentada 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 escribible.

   * "PyBUF_LOCK" solicita un bloqueo de sólo lectura o exclusivo en
     la memoria.

   * "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
================================

Algunos lenguajes orientados a objetos, como Java, admiten interfaces,
que declaran que una clase tiene un determinado conjunto de métodos o
admite un determinado protocolo de acceso.  Las clases base abstractas
(o ABC) son una característica equivalente para Python. El soporte de
ABC consiste en un módulo "abc" que contiene una metaclase llamada
"ABCMeta", un manejo especial de esta metaclase por parte de los
builtins "isinstance()" y "issubclass()", y una colección de ABCs
básicas que los desarrolladores de Python creen que serán ampliamente
útiles.  Las futuras versiones de Python probablemente añadirán más
ABCs.

Supongamos que tiene una clase concreta y desea saber si admite el
acceso tipo diccionario.  Sin embargo, la frase "estilo diccionario"
es vaga. Probablemente significa que el acceso a los elementos con
"obj[1]" funciona. ¿Implica que el establecimiento de elementos con
"obj[2] = valor" funciona? ¿O que el objeto tendrá métodos "keys()",
"values()" y "items()"?  ¿Qué pasa con las variantes iterativas como
"iterkeys()"? "copy()" y "update()"?  ¿Iterar sobre el objeto con
"iter()"?

El módulo "collections" de Python 2.6 incluye un número de ABCs
diferentes que representan estas distinciones. "Iterable" indica que
una clase define "__iter__()", y "Container" significa que la clase
define un método "__contains__()" y por lo tanto soporta expresiones
"x in y".  La interfaz básica del diccionario para obtener elementos,
establecer elementos, y "llaves()", "valores()", y "elementos()", está
definida por el "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):
       ...

Alternativamente, puede escribir la clase sin derivar del ABC deseado
y en su lugar registrar la clase llamando al método "register()" del
ABC:

   import collections

   class Storage:
       ...

   collections.MutableMapping.register(Storage)

Para las clases que usted escribe, derivar del ABC es probablemente
más claro. El método "register()" es útil cuando has escrito un nuevo
ABC que puede describir un tipo o clase existente, o si quieres
declarar que alguna clase de terceros implementa un ABC. Por ejemplo,
si has definido un "PrintableType" ABC, es legal hacer:

   # 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):
           ...

En el ABC de "Drawable" anterior, el método "draw_doubled()" renderiza
el objeto al doble de su tamaño y puede ser implementado en términos
de otros métodos descritos en "Drawable".  Las clases que implementan
este ABC no necesitan proporcionar su propia implementación de
"draw_doubled()", aunque pueden hacerlo.  Sin embargo, es necesaria
una implementación de "draw()"; el ABC no puede proporcionar una
implementación genérica útil.

Puedes aplicar el decorador "@abstractmethod" a métodos como "draw()"
que deben ser implementados; Python lanzará una excepción para las
clases que no definan el método. Ten en cuenta que la excepción sólo
se produce cuando intentas crear una instancia de una subclase que
carece del método:

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

Las subclases deben definir una propiedad "readonly()".

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'

Las funciones built-in "int()" y "long()" aceptarán ahora los prefijos
"0o" y "0b" cuando se solicite base-8 o base-2, o cuando el argumento
*base* sea cero (indicando que la base utilizada debe determinarse a
partir de la cadena):

   >>> 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".

El ABC más general es "Number".  No define ninguna operación, y sólo
existe para permitir comprobar si un objeto es un número haciendo
"isinstance(obj, Number)".

"Complex" es una subclase de "Number".  Los números complejos pueden
someterse a las operaciones básicas de suma, resta, multiplicación,
división y exponenciación, y se pueden recuperar las partes real e
imaginaria y obtener el conjugado de un número.  El tipo complejo
incorporado en Python es una implementación de "Complex".

"Real" deriva a su vez de "Complex", y añade operaciones que sólo
funcionan con números reales: "floor()", "trunc()", redondeo, toma del
resto mod N, división por defecto y comparaciones.

Los números "Rational" derivan de "Real", tienen las propiedades
"numerator" y "denominator", y se pueden convertir en flotantes.
Python 2.6 añade una clase simple de números racionales, "Fraction",
en el módulo "fractions".  (Se llama "Fraction" en lugar de "Rational"
para evitar un choque de nombres con "numbers.Rational")

Los números de "Integral" derivan de "Rational", y pueden desplazarse
a la izquierda y a la derecha con "<" y ">`", combinarse utilizando
operaciones de bits como "&" y "|", y pueden utilizarse como índices
de matrices y límites de cortes.

En Python 3.0, el PEP redefine ligeramente las funciones integradas
existentes "round()", "math.floor()", "math.ceil()", y añade uno
nuevo, "math.trunc()", que ha sido retrocedido a Python 2.6.
"math.trunc()" redondea hacia cero, devolviendo el "Integral" más
cercano que esté entre el argumento de la función y cero.

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 from the R5RS Scheme specification.


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.

El constructor "Fraction" toma dos valores "Integral" que serán el
numerador y el denominador de la fracción resultante.

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

Para convertir números de punto flotante en racionales, el tipo float
tiene ahora un método "as_integer_ratio()" que devuelve el numerador y
el denominador de una fracción que se evalúa al mismo valor de punto
flotante:

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

* La función "hasattr()" estaba capturando e ignorando todos los
  errores, bajo la suposición de que significaban que un método
  "__getattr__()" estaba fallando de alguna manera y que el valor de
  retorno de "hasattr()" sería por tanto "False".  Esta lógica no
  debería aplicarse a "KeyboardInterrupt" y "SystemExit", sin embargo;
  Python 2.6 ya no descartará tales excepciones cuando "hasattr()" las
  encuentre.  (Corregido por 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.)

* Las tuplas tienen ahora métodos "index()" y "count()" que coinciden
  con los métodos "index()" y "count()" del tipo lista:

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

* Las propiedades tienen ahora tres atributos, "getter", "setter" y
  "deleter", que son decoradores que proporcionan atajos útiles para
  añadir una función getter, setter o deleter a una propiedad
  existente. Los usarás así:

     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

* Varios métodos de los tipos de conjuntos incorporados aceptan ahora
  múltiples iterables: "intersection()", "intersection_update()",
  "union()", "update()", "difference()" y "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.)

  Otras funciones del módulo "math", "isinf()" y "isnan()", devuelven
  true si su argumento en coma flotante es infinito o No es un número.
  (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.)

* Las clases que heredan un método "__hash__()" de una clase padre
  pueden establecer "__hash__ = None" para indicar que la clase no es
  hashable.  Esto hará que "hash(obj)" lance un "TypeError" y la clase
  no será indicada como implementando el ABC de "Hashable".

  Debes hacer esto cuando hayas definido un método "__cmp__()" o
  "__eq__()" que compare objetos por su valor en lugar de por su
  identidad.  Todos los objetos tienen un método hash por defecto que
  utiliza "id(obj)" como valor hash.  No hay una forma ordenada de
  eliminar el método "__hash__()" heredado de una clase padre, por lo
  que la asignación de "None" fue implementada como una
  sobreescritura.  A nivel de C, las extensiones pueden establecer
  "tp_hash" a "PyObject_HashNotImplemented()". (Corregido por Nick
  Coghlan y 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.)

* Los objetos generadores tienen ahora un atributo "gi_code" que hace
  referencia al objeto de código original que respalda al generador.
  (Contribución de 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)

* El método string "translate()" acepta ahora "None" como parámetro de
  la tabla de traducción, que se trata como la transformación de
  identidad.   Esto facilita la realización de operaciones que sólo
  eliminan caracteres.  (Contribuido por Bengt Richter e implementado
  por Raymond Hettinger; bpo-1193128)

* La función incorporada "dir()" ahora comprueba si existe un método
  "__dir__()" en los objetos que recibe.  Este método debe devolver
  una lista de cadenas que contengan los nombres de los atributos
  válidos para el objeto, y permite al objeto controlar el valor que
  "dir()" produce. Los objetos que tienen métodos "__getattr__()" o
  "__getattribute__()" pueden usar esto para anunciar los pseudo-
  atributos que respetarán. (bpo-1591665)

* Los objetos de método de instancia tienen nuevos atributos para el
  objeto y la función que comprende el método; el nuevo sinónimo de
  "im_self" es "__self__", y "im_func" también está disponible como
  "__func__". Los nombres antiguos todavía se soportan en Python 2.6,
  pero han desaparecido en la 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)

* Las cadenas Unicode utilizan ahora un código más rápido para
  detectar los espacios en blanco y los saltos de línea; esto acelera
  el método "split()" en un 25% a y "splitlines()" en un 35%.
  (Contribuido por Antoine Pitrou.) El uso de la memoria se reduce
  utilizando pymalloc para los datos de la cadena Unicode.

* La sentencia "with" ahora almacena el método "__exit__()" en la
  pila, produciendo un pequeño aumento de 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
---------------------

Se han reservado dos opciones de la línea de comandos para su uso por
otras implementaciones de Python.  La opción "-J" se ha reservado para
su uso por parte de Jython para las opciones específicas de Jython,
como los interruptores que se pasan a la JVM subyacente. "-X" se ha
reservado para las opciones específicas de una implementación
particular de Python como CPython, Jython o IronPython.  Si cualquiera
de estas opciones se utiliza con Python 2.6, el intérprete informará
de que la opción no se utiliza actualmente.

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 siendo mantenidos
  activamente de nuevo, y se han aplicado varios parches y
  correcciones de errores.  (Mantenido por Josiah Carlson; véase
  bpo-1736190 para un parche)

* El módulo "bsddb" también tiene un nuevo mantenedor, Jesús Cea
  Avión, y el paquete está ahora disponible como paquete
  independiente.  La página web del paquete es
  www.jcea.es/programacion/pybsddb.htm. El plan es eliminar el paquete
  de la biblioteca estándar en Python 3.0, porque su ritmo de
  lanzamientos es mucho más frecuente que el de Python.

  El módulo "bsddb.dbshelve" utiliza ahora el protocolo de decapado
  más alto disponible, en lugar de limitarse al protocolo 1.
  (Contribución de W. Barnes.)

* El módulo "cgi" leerá ahora las variables de la cadena de consulta
  de una petición HTTP POST.  Esto permite utilizar acciones de
  formulario con URLs que incluyen cadenas de consulta como "/cgi-
  bin/add.py?category=1".  (Contribución de Alexandre Fiori y Nubis;
  bpo-1817.)

  Las funciones "parse_qs()" y "parse_qsl()" han sido reubicadas del
  módulo "cgi" al módulo "urlparse". Las versiones aún disponibles en
  el módulo "cgi" activarán los mensajes "PendingDeprecationWarning"
  en la versión 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()" convierte un número complejo en forma polar, devolviendo
    el módulo y el argumento del número complejo.

  * "rect()" hace lo contrario, convirtiendo un par de módulos y
    argumentos en el correspondiente número complejo.

  * "phase()" devuelve el argumento (también llamado ángulo) de un
    número complejo.

  * "isnan()" devuelve True si la parte real o imaginaria de su
    argumento es un NaN.

  * "isinf()" devuelve True si la parte real o imaginaria de su
    argumento es infinita.

  Las revisiones también han mejorado la solidez numérica del módulo
  "cmath".  Para todas las funciones, las partes real e imaginaria de
  los resultados son exactas con unas pocas unidades de precisión
  mínima (ulps) siempre que sea posible.  Véase bpo-1381 para los
  detalles.  También se han corregido los cortes de rama para
  "asinh()", "atanh()": y "atan()".

  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)

  Varios lugares de la biblioteca estándar que devolvían tuplas han
  sido modificados para devolver instancias de "namedtuple".  Por
  ejemplo, el método "Decimal.as_tuple()" ahora devuelve una tupla con
  nombre con los campos "signo", "dígitos" y "exponente".

  (Contribución de Raymond Hettinger.)

* Otro cambio en el módulo "collections" es que el tipo "deque" admite
  ahora un parámetro opcional *maxlen*; si se suministra, el tamaño
  del deque estará restringido a no más de *maxlen* elementos.  Si se
  añaden más elementos a un deque lleno, se descartan los elementos
  antiguos.

     >>> 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 "Cookie" del módulo "Morsel" soportan ahora un atributo
  "httponly".  En algunos navegadores, las cookies con este atributo
  no pueden ser accedidas o manipuladas por el código JavaScript.
  (Contribución de Arvin Schnell; bpo-1638033.)

* Un nuevo método de ventana en el módulo "curses", "chgat()", cambia
  los atributos de visualización para un determinado número de
  caracteres en una sola línea.  (Contribución de Fabian Kreutz)

     # Boldface text starting at y=0,x=21
     # and affecting the rest of the line.
     stdscr.chgat(0, 21, curses.A_BOLD)

  La clase "Textbox" del módulo "curses.textpad" soporta ahora la
  edición en modo de inserción así como en modo de sobrescritura. El
  modo de inserción se activa proporcionando un valor verdadero para
  el parámetro *insert_mode* al crear la instancia de "Textbox".

* Los métodos "strftime()" del módulo "datetime" soportan ahora un
  código de formato "%f" que se expande al número de microsegundos en
  el objeto, rellenado de cero a la izquierda hasta seis lugares.
  (Contribución de 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")

  El método "as_tuple()" de los objetos "Decimal" devuelve ahora una
  tupla con nombre con los campos "signo", "dígitos" y "exponente".

  (Implementado por Facundo Batista y Mark Dickinson.  Soporte de
  tuplas con nombre añadido por Raymond Hettinger)

* La clase "difflib" del módulo "SequenceMatcher" devuelve ahora
  tuplas con nombre que representan coincidencias, con atributos "a",
  "b" y "size". (Contribución de Raymond Hettinger)

* Se ha añadido un parámetro opcional "timeout", que especifica un
  tiempo de espera medido en segundos, al constructor de la clase
  "ftplib.FTP" así como al método "connect()".  (Añadido por Facundo
  Batista.) Además, los métodos "storbinary()" y "storlines()" de la
  clase "FTP" ahora toman un parámetro opcional *callback* que será
  llamado con cada bloque de datos después de que los datos hayan sido
  enviados. (Contribuido por Phil Schwartz; bpo-1221598.)

* La función incorporada "reduce()" también está disponible en el
  módulo "functools".  En Python 3.0, la función incorporada se ha
  eliminado y "reduce()" sólo está disponible en "functools";
  actualmente no hay planes para eliminar la función incorporada en la
  serie 2.x. (Parcheado por 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]

  Otra nueva función, "heappushpop(heap, item)", empuja *item* a
  *heap*, luego lo saca y devuelve el elemento más pequeño. Esto es
  más eficiente que hacer una llamada a "heappush()" y luego a
  "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 ha añadido un parámetro opcional "timeout", que especifica un
  tiempo de espera medido en segundos, a los constructores de las
  clases "httplib.HTTPConnection" y "HTTPSConnection".  (Añadido por
  Facundo Batista)

* La mayoría de las funciones del módulo "inspect", como
  "getmoduleinfo()" y "getargs()", ahora devuelven tuplas con nombre.
  Además de comportarse como tuplas, también se puede acceder a los
  elementos del valor devuelto como atributos. (Contribución de
  Raymond Hettinger)

  Algunas de las nuevas funciones del módulo son "isgenerator()",
  "isgeneratorfunction()" y "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)" es una función existente en
  "itertools" que obtuvo un nuevo constructor en Python 2.6.
  "itertools.chain.from_iterable(iterable)" toma un único iterable que
  debe devolver otros iterables. "chain()" devolverá entonces todos
  los elementos del primer iterable, luego todos los elementos del
  segundo, y así sucesivamente.

     >>> list(itertools.chain.from_iterable([[1,2,3], [4,5,6]]))
     [1, 2, 3, 4, 5, 6]

  (Todo ello aportado por Raymond Hettinger)

* La clase "logging" del módulo "FileHandler" y sus subclases
  "WatchedFileHandler", "RotatingFileHandler" y
  "TimedRotatingFileHandler" tienen ahora un parámetro opcional
  *delay* en sus constructores.  Si *retraso* es verdadero, la
  apertura del fichero de registro se retrasa hasta que se realice la
  primera llamada "emit()".  (Contribuido por Vinay Sajip.)

  "TimedRotatingFileHandler" también tiene un parámetro constructor
  *utc*.  Si el argumento es verdadero, se utilizará la hora UTC para
  determinar cuándo ocurre la medianoche y para generar los nombres de
  los archivos; en caso contrario, se utilizará la hora local.

* 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()" redondea un número hacia cero, devolviendo el "Integral"
    más cercano que esté entre el argumento de la función y el cero.
    Añadido como parte del backport de la jerarquía de tipos de
    números de PEP 3141.

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

* Los objetos "mmap" tienen ahora un método "rfind()" que busca una
  subcadena empezando por el final de la cadena y buscando hacia
  atrás.  El método "find()" también ha ganado un parámetro *end* que
  da un índice en el que parar la búsqueda. (Contribución de John
  Lenton)

* El módulo "operator" ganó una función "methodcaller()" que toma un
  nombre y un conjunto opcional de argumentos, devolviendo un callable
  que llamará a la función nombrada en cualquier argumento que se le
  pase.  Por ejemplo:

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

  La función "attrgetter()" acepta ahora nombres con puntos y realiza
  las correspondientes búsquedas de atributos:

     >>> 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()" y "lchflags()" son envoltorios para las correspondientes
  llamadas al sistema (cuando están disponibles), que cambian las
  banderas establecidas en un archivo.  Las constantes para los
  valores de las banderas se definen en el módulo "stat"; algunos
  valores posibles son "UF_IMMUTABLE" para indicar que el fichero no
  puede ser modificado y "UF_APPEND" para indicar que sólo se pueden
  añadir datos al fichero.  (Contribución de 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.)

* El método "clear()" del objeto "os.environ" ahora desajustará las
  variables de entorno utilizando "os.unsetenv()" además de borrar las
  claves del objeto.  (Contribuido por 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)

* En el módulo "os.path", la función "splitext()" ha sido modificada
  para no dividir los caracteres de punto inicial. Esto produce
  mejores resultados cuando se opera con archivos de puntos de Unix.
  Por ejemplo, "os.path.splitext('.ipython')" ahora devuelve
  "('.ipython', '')" en lugar de "('', '.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.)

* El módulo "pickletools" tiene ahora una función "optimize()" que
  toma una cadena que contiene un pickle y elimina algunos opcodes no
  utilizados, devolviendo un pickle más corto que contiene la misma
  estructura de datos. (Contribución de Raymond Hettinger)

* Se ha añadido una función "get_data()" al módulo "pkgutil" que
  devuelve el contenido de los archivos de recursos incluidos con un
  paquete Python instalado.  Por ejemplo:

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

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

* Los objetos "pyexpat" del módulo "Parser" permiten ahora establecer
  su atributo "buffer_size" para cambiar el tamaño del buffer
  utilizado para mantener los datos de caracteres. (Contribución de
  Achim Gaedke; bpo-1137.)

* El módulo "Queue" proporciona ahora variantes de colas que recuperan
  las entradas en diferentes órdenes.  La clase "PriorityQueue"
  almacena los elementos en cola en un montón y los recupera en orden
  de prioridad, y "LifoQueue" recupera primero las entradas añadidas
  más recientemente, lo que significa que se comporta como una pila.
  (Contribución de Raymond Hettinger)

* Los objetos "Random" del módulo "random" ahora pueden ser decapados
  en un sistema de 32 bits y desempaquetados en un sistema de 64 bits,
  y viceversa.  Desafortunadamente, este cambio también significa que
  los objetos "Random" de Python 2.6 no pueden ser desempaquetados
  correctamente en versiones anteriores de Python. (Contribuido por
  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.)

* El método "Completer.complete()" del módulo "rlcompleter" ahora
  ignorará las excepciones que se produzcan al evaluar un nombre.
  (Corregido por Lorenz Quack; bpo-2250.)

* Las instancias "sched" del módulo "scheduler" tienen ahora un
  atributo "queue" de sólo lectura que devuelve el contenido de la
  cola del planificador, representado como una lista de tuplas con
  nombre con los campos "(tiempo, prioridad, acción, argumento)".
  (Contribución de Raymond Hettinger; bpo-1861.)

* El módulo "select" tiene ahora funciones de envoltura para las
  llamadas al sistema Linux "epoll()" y BSD "kqueue()". Se ha añadido
  el método "modify()" a los objetos "poll" existentes;
  "pollobj.modify(fd, eventmask)" toma un descriptor de fichero o un
  objeto de fichero y una máscara de evento, modificando la máscara de
  evento registrada para ese fichero. (Contribución de 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.

  El módulo "shutil" también proporciona una función
  "ignore_patterns()" para su uso con este nuevo parámetro.
  "ignore_patterns()" toma un número arbitrario de patrones de estilo
  glob y devuelve una llamada que ignorará cualquier archivo o
  directorio que coincida con cualquiera de estos patrones.  El
  siguiente ejemplo copia un árbol de directorios, pero omite los
  directorios ".svn" y los ficheros de copia de seguridad de Emacs,
  que tienen nombres que terminan en '~':

     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.

  Los bucles de eventos utilizarán esto abriendo una tubería para
  crear dos descriptores, uno de lectura y otro de escritura.  El
  descriptor de escritura se pasará a "set_wakeup_fd()", y el
  descriptor de lectura se añadirá a la lista de descriptores
  monitorizados por el bucle de eventos mediante "select()" o
  "poll()". Al recibir una señal, se escribirá un byte y se despertará
  el bucle de eventos principal, evitando la necesidad de hacer un
  sondeo.

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

  La función "siginterrupt()" está ahora disponible desde el código
  Python, y permite cambiar si las señales pueden interrumpir las
  llamadas al sistema o no. (Contribución de Ralf Schmitt)

  También se han añadido las funciones "setitimer()" y "getitimer()"
  (cuando están disponibles). "setitimer()" permite establecer
  temporizadores de intervalo que harán que se entregue una señal al
  proceso después de un tiempo especificado, medido en tiempo de reloj
  de pared, tiempo de proceso consumido, o tiempo combinado de
  proceso+sistema.  (Contribuido por Guilherme Polo; bpo-2240.)

* El módulo "smtplib" ahora soporta SMTP sobre SSL gracias a la
  adición de la clase "SMTP_SSL". Esta clase soporta una interfaz
  idéntica a la clase "SMTP" existente. (Contribuido por Monty
  Taylor.) Ambos constructores de la clase también tienen un parámetro
  opcional "timeout" que especifica un tiempo de espera para el
  intento de conexión inicial, medido en segundos.  (Contribuido por
  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.)

  "SMTP.starttls()" ahora cumple con **RFC 3207** y olvida cualquier
  conocimiento obtenido del servidor que no se haya obtenido de la
  propia negociación TLS.  (Parche aportado por 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.)

  Una nueva función, "create_connection()", toma una dirección y se
  conecta a ella utilizando un valor opcional de tiempo de espera,
  devolviendo el objeto socket conectado.  Esta función también busca
  el tipo de dirección y se conecta a ella usando IPv4 o IPv6 según
  sea el caso.  Cambiar su código para usar "create_connection()" en
  lugar de "socket(socket.AF_INET, ...)" puede ser todo lo que se
  necesita para que su código funcione con IPv6.

* Las clases base del módulo "SocketServer" ahora soportan la llamada
  a un método "handle_timeout()" después de un periodo de inactividad
  especificado por el atributo "timeout" del servidor.  (Contribuido
  por Michael Pomraning.) El método "serve_forever()" ahora toma un
  intervalo de sondeo opcional medido en segundos, controlando la
  frecuencia con la que el servidor comprobará si hay una solicitud de
  cierre. (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.

* The "struct" module now supports the C99 "_Bool" type, using the
  format character "'?'". (Contributed by David Remahl.)

* Los objetos "Popen" proporcionados por el módulo "subprocess" tienen
  ahora métodos "terminate()", "kill()" y "send_signal()". En Windows,
  "send_signal()" sólo soporta la señal "SIGTERM", y todos estos
  métodos son alias de la función de la API Win32
  "TerminateProcess()". (Contribuido por Christian Heimes.)

* Una nueva variable en el módulo "sys", "float_info", es un objeto
  que contiene información derivada del archivo "float.h" sobre el
  soporte de punto flotante de la plataforma.  Los atributos de este
  objeto incluyen "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.)

  Otra nueva variable, "dont_write_bytecode", controla si Python
  escribe algún archivo ".pyc" o ".pyo" al importar un módulo. Si esta
  variable es verdadera, los archivos compilados no se escriben.  La
  variable se establece inicialmente al iniciar el intérprete de
  Python con la opción "-B", o estableciendo la variable de entorno
  "PYTHONDONTWRITEBYTECODE" antes de ejecutar el intérprete.  El
  código de Python puede cambiar posteriormente el valor de esta
  variable para controlar si los archivos de código de bytes se
  escriben o no. (Contribución de Neal Norwitz y Georg Brandl)

  La información sobre los argumentos de la línea de comandos
  suministrados al intérprete de Python está disponible leyendo los
  atributos de una tupla con nombre disponible como "sys.flags".  Por
  ejemplo, el atributo "verbose" es verdadero si Python fue ejecutado
  en modo verbose, "debug" es verdadero en modo debugging, etc. Todos
  estos atributos son de sólo lectura. (Contribución de Christian
  Heimes)

  Una nueva función, "getsizeof()", toma un objeto Python y devuelve
  la cantidad de memoria utilizada por el objeto, medida en bytes.
  Los objetos incorporados devuelven resultados correctos; las
  extensiones de terceros pueden no hacerlo, pero pueden definir un
  método "__sizeof__()" para devolver el tamaño del objeto.
  (Contribución de 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.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", especificando un tiempo de espera medido en
  segundos.  (Añadido 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.)

  Una nueva clase, "SpooledTemporaryFile", se comporta como un archivo
  temporal pero almacena sus datos en memoria hasta que se supera un
  tamaño máximo.  Al llegar a ese límite, el contenido se escribirá en
  un archivo temporal en el disco.  (Contribución de Dustin J.
  Mitchell)

  Las clases "NamedTemporaryFile" y "SpooledTemporaryFile" funcionan
  como gestores de contexto, por lo que puedes escribir "con
  tempfile.NamedTemporaryFile() como tmp: ...". (Contribuido por
  Alexander Belopolsky; bpo-2021.)

* El módulo "test.test_support" obtuvo una serie de gestores de
  contexto útiles para escribir pruebas. "EnvironmentVarGuard()" es un
  gestor de contexto que cambia temporalmente las variables de entorno
  y las restaura automáticamente a sus valores anteriores.

  Otro gestor de contexto, "TransientResource", puede rodear las
  llamadas a recursos que pueden o no estar disponibles; atrapará e
  ignorará una lista especificada de excepciones.  Por ejemplo, una
  prueba de red puede ignorar ciertos fallos al conectarse a un sitio
  web externo:

     with test_support.TransientResource(IOError,
                                     errno=errno.ETIMEDOUT):
         f = urllib.urlopen('https://sf.net')
         ...

  Por último, "check_warnings()" restablece los filtros de advertencia
  del módulo "warning" y devuelve un objeto que registrará todos los
  mensajes de advertencia activados (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.)

* The "textwrap" module can now preserve existing whitespace at the
  beginnings and ends of the newly created lines by specifying
  "drop_whitespace=False" as an argument:

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

* La API del módulo "threading" se ha cambiado para utilizar
  propiedades como "daemon" en lugar de los métodos "setDaemon()" y
  "isDaemon()", y algunos métodos se han renombrado para utilizar
  guiones bajos en lugar de mayúsculas; por ejemplo, el método
  "activeCount()" se ha renombrado a "active_count()".  Tanto la
  versión 2.6 como la 3.0 del módulo soportan las mismas propiedades y
  métodos renombrados, pero no eliminan los métodos antiguos.  No se
  ha fijado una fecha para la eliminación de las antiguas APIs en
  Python 3.x; las antiguas APIs no se eliminarán en ninguna versión
  2.x. (Llevado a cabo por varias personas, sobre todo por Benjamin
  Peterson)

  Los objetos "threading" del módulo "Thread" han ganado una propiedad
  "ident" que devuelve el identificador del hilo, un entero no nulo.
  (Contribución de Gregory P. Smith; bpo-2871.)

* El módulo "timeit" acepta ahora callables así como cadenas para la
  sentencia que se está cronometrando y para el código de
  configuración. Se han añadido dos funciones para crear instancias de
  "Timer": "repeat(stmt, setup, time, repeat, number)" y "timeit(stmt,
  setup, time, number)" crean una instancia y llaman al método
  correspondiente. (Contribución de Erik Demaine; bpo-1533909.)

* El módulo "Tkinter" ahora acepta listas y tuplas para las opciones,
  separando los elementos por espacios antes de pasar el valor
  resultante a Tcl/Tk. (Contribuido por 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 del movimiento de las tortugas mediante los nuevos métodos
    "retraso()", "tracer()" y "velocidad()".

  * La posibilidad de establecer nuevas formas para la tortuga y de
    definir un nuevo sistema de coordenadas.

  * Las tortugas ahora tienen un método "undo()" que puede revertir
    las acciones.

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

* Se ha añadido un parámetro opcional "timeout" a la función
  "urllib.urlopen()" y al constructor de la clase "urllib.ftpwrapper",
  así como a la función "urllib2.urlopen()".  El parámetro especifica
  un tiempo de espera medido en segundos.   Por ejemplo:

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

* Las funciones "warnings" del módulo "formatwarning()" y
  "showwarning()" han ganado un argumento opcional *line* que puede
  utilizarse para proporcionar la línea de código fuente.  (Añadido
  como parte de bpo-1631171, que reimplementaba parte del módulo
  "warnings" en código C)

  Una nueva función, "catch_warnings()", es un gestor de contexto
  destinado a la realización de pruebas que permite modificar
  temporalmente los filtros de advertencia y luego restaurar sus
  valores originales (bpo-3781).

* Las clases XML-RPC "SimpleXMLRPCServer" y "DocXMLRPCServer" pueden
  ahora evitar que se abran inmediatamente y se vinculen a su socket
  pasando "False" como parámetro del constructor *bind_and_activate*.
  Esto puede usarse para modificar el atributo "allow_reuse_address"
  de la instancia antes de llamar a los métodos "server_bind()" y
  "server_activate()" para abrir el socket y comenzar a escuchar
  conexiones. (Contribuido por Peter Parente; bpo-1599845.)

  "SimpleXMLRPCServer" también tiene un atributo
  "_send_traceback_header"; si es true, la excepción y el traceback
  formateado se devuelven como cabeceras HTTP "X-Exception" y
  "X-Traceback".  Esta característica es sólo para propósitos de
  depuración y no debe ser usada en servidores de producción porque
  los trazos pueden revelar contraseñas u otra información sensible.
  (Contribuido por Alan McIntyre como parte de su proyecto para el
  Summer of Code 2007 de Google)

* El módulo "xmlrpclib" ya no convierte automáticamente las instancias
  "datetime.date" y "datetime.time" al tipo "xmlrpclib.DateTime"; la
  semántica de conversión no era necesariamente correcta para todas
  las aplicaciones.  El código que utiliza "xmlrpclib" debe convertir
  las instancias "date" y "time". (bpo-1330538) El código también
  puede manejar fechas anteriores a 1900 (contribución de Ralf
  Schmitt;<i8>:issue</i8>:*2014*) y enteros de 64 bits representados
  mediante el uso de<i8>```` en las respuestas XML-RPC (contribución
  de Riku Lindblad; bpo-2985).</i8>

* La clase "zipfile" del módulo "ZipFile" tiene ahora los métodos
  "extract()" y "extractall()" que desempaquetarán un solo fichero o
  todos los ficheros del archivo en el directorio actual, o en un
  directorio especificado:

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

  Los métodos "open()", "read()" y "extract()" ahora pueden tomar un
  nombre de archivo o un objeto "ZipInfo".  Esto es útil cuando un
  archivo contiene accidentalmente un nombre de archivo duplicado.
  (Contribución de 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.

La función "parse()" toma una expresión y devuelve un AST. La función
"dump()" devuelve una representación de un árbol, adecuada para la
depuración:

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

El método "literal_eval()" toma una cadena o un AST que representa una
expresión literal, la analiza y evalúa, y devuelve el valor
resultante.  Una expresión literal es una expresión de Python que sólo
contiene cadenas, números, diccionarios, etc. pero no declaraciones o
llamadas a funciones.  Si necesita evaluar una expresión pero no puede
aceptar el riesgo de seguridad que supone utilizar una llamada a
"eval()", "literal_eval()" lo hará de forma segura:

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

El módulo también incluye las clases "NodeVisitor" y "NodeTransformer"
para recorrer y modificar un AST, y funciones para transformaciones
comunes como el cambio de números de línea.


El módulo "future_builtins"
---------------------------

Python 3.0 introduce muchos cambios en el repertorio de funciones
incorporadas, y la mayoría de los cambios no pueden introducirse en la
serie Python 2.x porque romperían la compatibilidad. El módulo
"future_builtins" proporciona versiones de estas funciones
incorporadas que pueden importarse al escribir código compatible con
la versión 3.0.

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(valor)", "oct(valor)": en lugar de llamar a los métodos
  "__hex__()" o "__oct__()", estas versiones llamarán al método
  "__index__()" y convertirán el resultado a hexadecimal u octal.
  "oct()" utilizará la nueva notación "0o" para su resultado.


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

   # Create data structure
   data_struct = dict(lastAccessed=datetime.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" soporta ahora un tipo de datos "c_bool" que representa el
tipo C99 "bool".  (Contribución de 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)

Todos los tipos de datos "ctypes" soportan ahora los métodos
"from_buffer()" y "from_buffer_copy()" que crean una instancia de
ctypes basada en un objeto buffer proporcionado. "from_buffer_copy()"
copia el contenido del objeto, mientras que "from_buffer()" compartirá
la misma área de memoria.

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

Ahora puede recuperar la variable Unix "errno" después de una llamada
a una función.  Al crear una función envuelta, puede suministrar
"use_errno=True" como parámetro de palabra clave a la función "DLL()"
y luego llamar a los métodos de nivel de módulo "set_errno()" y
"get_errno()" para establecer y recuperar el valor del error.

La variable Win32 LastError es soportada de forma similar por las
funciones "DLL()", "OleDLL()", y "WinDLL()". Se suministra
"use_last_error=True" como parámetro de palabra clave y luego se
llaman los métodos a nivel de módulo "set_last_error()" y
"get_last_error()".

La función "byref()", utilizada para recuperar un puntero a una
instancia de ctypes, tiene ahora un parámetro opcional *offset* que es
un recuento de bytes que se añadirá al puntero devuelto.


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.

Para utilizar el nuevo módulo, primero hay que crear una conexión TCP
de la forma habitual y luego pasarla a la función "ssl.wrap_socket()".
Es posible especificar si se requiere un certificado, y obtener
información sobre el mismo llamando al método "getpeercert()".

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".

* Los cambios en la interfaz "Exception" dictados por **PEP 352**
  siguen realizándose.  En la versión 2.6, el atributo "message" queda
  obsoleto en favor del 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)

* El módulo BerkeleyDB tiene ahora un objeto C API, disponible como
  "bsddb.db.api".   Este objeto puede ser utilizado por otras
  extensiones de C que deseen utilizar el módulo "bsddb" para sus
  propios fines. (Contribución de 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 el soporte de punto
  flotante de la plataforma. "PyFloat_GetMax()" devuelve el máximo
  valor de punto flotante representable, y "PyFloat_GetMin()" devuelve
  el mínimo valor positivo.  "PyFloat_GetInfo()" devuelve un objeto
  que contiene más información del fichero "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. (Contribución de Christian Heimes;
  bpo-1534.)

* Las funciones y métodos de C que utilizan "PyComplex_AsCComplex()"
  ahora aceptarán argumentos que tengan un método "__complex__()".  En
  particular, las funciones del módulo "cmath" ahora aceptarán objetos
  con este método. Este es un retroceso de un cambio en Python 3.0.
  (Contribuido por 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" soporta ahora las variantes normal y wide char 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. (Contribución de 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.)

* Los objetos socket del módulo "socket" tienen ahora un método
  "ioctl()" que proporciona una interfaz limitada a la interfaz del
  sistema "WSAIoctl()".

* El módulo "_winreg" tiene ahora una función,
  "ExpandEnvironmentStrings()", que expande las referencias a
  variables de entorno como "%NAME%" en una cadena de entrada.  Los
  objetos handle proporcionados por este módulo ahora soportan el
  protocolo de contexto, por lo que pueden ser utilizados en
  sentencias "with". (Contribuido por Christian Heimes.)

  "_winreg" también tiene un mejor soporte para los sistemas x64,
  exponiendo las funciones "DisableReflectionKey()",
  "EnableReflectionKey()", y "QueryReflectionKey()", que habilitan y
  deshabilitan la reflexión del registro para los procesos de 32 bits
  que se ejecutan en sistemas de 64 bits. (bpo-1753245)

* El objeto "Record" del módulo "msilib" ha ganado los métodos
  "GetInteger()" y "GetString()" que devuelven los valores de los
  campos como un entero o una cadena. (Contribución de 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, ha requerido la
  eliminación de 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 serán
  eliminados 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
----------------------------------------

Una serie de antiguos módulos específicos de IRIX fueron obsoletos y
serán eliminados 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".

* El método "__init__()" de "collections.deque" ahora borra cualquier
  contenido existente del deque antes de añadir elementos del
  iterable.  Este cambio hace que el comportamiento coincida con
  "list.__init__()".

* "object.__init__()" anteriormente aceptaba argumentos arbitrarios y
  argumentos de palabras clave, ignorándolos.  En Python 2.6, esto ya
  no está permitido y resultará en un "TypeError".  Esto afectará a
  los métodos "__init__()" que acaben llamando al método
  correspondiente en "object" (quizás mediante el uso de "super()").
  Ver bpo-1683368 para su discusión.

* El constructor "Decimal" ahora acepta los espacios en blanco
  iniciales y finales cuando se le pasa una cadena.  Antes lanzaba una
  excepción "InvalidOperation".  Por otro lado, el método
  "create_decimal()" de los objetos "Context" ahora desestima
  explícitamente los espacios en blanco adicionales, lanzando una
  excepción "ConversionSyntax".

* 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()".

* La excepción del módulo "socket" "socket.error" ahora hereda de
  "IOError".  Anteriormente no era una subclase de "StandardError"
  pero ahora lo es, a través de "IOError". (Implementado por Gregory
  P. Smith; bpo-1706815.)

* El módulo "xmlrpclib" ya no convierte automáticamente las instancias
  "datetime.date" y "datetime.time" al tipo "xmlrpclib.DateTime"; la
  semántica de conversión no era necesariamente correcta para todas
  las aplicaciones.  El código que utiliza "xmlrpclib" debe convertir
  las instancias "date" y "time". (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.


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.
