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

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

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

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

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

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

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


Python 3.0
==========

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

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

* A "__complex__()" method for converting objects to a complex number.

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

* The addition of "functools.reduce()" as a synonym for the built-in
  "reduce()" function.

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

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

Ver también:

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


Cambios en el proceso de desarrollo
===================================

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


Nuevo seguidor de incidentes: Roundup
-------------------------------------

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

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

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

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

Ver también:

  https://bugs.python.org
     El seguidor de errores de Python.

  https://bugs.jython.org:
     El seguidor de errores de Jython.

  https://roundup.sourceforge.io/
     Descargas y documentación de Roundup.

  https://svn.python.org/view/tracker/importer/
     Scripts de conversión de Martin von Löwis.


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

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

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

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

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

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

Ver también:

  Documentando Python
     Describe cómo escribir para la documentación de Python.

  Sphinx
     Documentación y código para la cadena de herramientas Sphinx.

  Docutils
     El analizador sintáctico y el conjunto de herramientas
     *reStructuredText* subyacentes.


PEP 343: La sentencia *'with'*
==============================

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

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

La sentencia '"with"' es una estructura de control de flujo cuya
estructura básica es:

   with expression [as variable]:
       with-block

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

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

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

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

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

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

Nota:

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

Los *locks* y las condiciones variables del módulo "threading" también
admiten la sentencia '"with"':

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

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

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

   from decimal import Decimal, Context, localcontext

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

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


Escribiendo gestores de contexto
--------------------------------

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

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

* La expresión se evalúa y debería dar como resultado un objeto
  llamado "gestor de contexto". El gestor de contexto debe tener los
  métodos "__enter__()" y "__exit__()".

* Se llama al método "__enter__()" del gestor de contexto. El valor
  retornado se asigna a *VAR*. Si no hay una cláusula "as VAR", el
  valor simplemente se descarta.

* Se ejecuta el código en *BLOCK*.

* Si *BLOCK* genera una excepción, se llama al método "__exit__()" del
  administrador de contexto con tres argumentos: los detalles de la
  excepción ("type, value, traceback", los mismos valores devueltos
  por "sys.exc_info()", que también pueden ser "None" si no se produjo
  ninguna excepción). El valor de retorno del método controla si se
  vuelve a generar una excepción: cualquier valor falso vuelve a
  generar la excepción y "True" provocará su supresión. Solo en raras
  ocasiones querrá suprimir la excepción, porque si lo hace, el autor
  del código que contiene la declaración '"with"' nunca se dará cuenta
  de que algo salió mal.

* Si *BLOCK* no lanzó una excepción, el método "__exit__()" continúa
  llamándose, pero *type*, *value* y *traceback* son todos "None".

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

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

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

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

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

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

El método "__enter__()" es bastante sencillo, ya que solo hay que
iniciar una nueva transacción. Para esta aplicación, el objeto cursor
resultante sería un resultado útil, por lo que el método lo devolverá.
El usuario puede entonces añadir "as cursor" a su declaración '"with"'
para vincular el cursor a un nombre de variable.

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

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

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

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


El módulo contextlib
--------------------

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

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

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

   from contextlib import contextmanager

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

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

El módulo "contextlib" también tiene una función "nested(mgr1, mgr2,
...)" que combina varios gestores de contexto para que no necesite
escribir sentencias '"with"' anidadas. En este ejemplo, se utiliza una
única sentencia '"with"' que inicia una transacción de base de datos y
adquiere un bloqueo del hilo:

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

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

   importar urllib, sys
   desde contextlib importar closing

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

Ver también:

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

  La documentación para el módulo "contextlib".


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

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

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

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


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

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

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

* Unix y Mac OS X: "~/.local/"

* Windows: "%APPDATA%/Python"

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

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

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

Ver también:

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


PEP 371: El paquete "multiprocessing"
=====================================

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

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

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

   import time
   from multiprocessing import Process, Queue


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

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

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

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

       N = 5

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

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

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

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

   from multiprocessing import Pool

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

Esto produce la siguiente salida:

   1
   39916800
   51090942171709440000
   8222838654177922817725562880000000
   33452526613163807108170062053440751665152000000000
   ...

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

   import time
   from multiprocessing import Pool, Manager

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

       # Store result in dictionary
       dictionary[N] = fact

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

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

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

       # Wait for tasks to exit
       p.join()

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

Esto producirá la salida:

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

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

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

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

Las llaves se pueden escapar duplicándose:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ver también:

  Format string syntax
     La documentación de referencia para los campos de formato.

  **PEP 3101** - Formato avanzado de cadenas
     PEP escrito por Talin. Implementado por Eric Smith.


PEP 3105: "print" como función
==============================

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

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

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

La firma de la nueva función es:

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

Los parámetros son:

* *args*: argumentos posicionales cuyos valores se imprimirán.

* *sep*: el separador que se imprimirá entre los argumentos.

* *end*: el texto final, que se imprimirá después de que se hayan
  emitido todos los argumentos.

* *archivo*: el objeto archivo al que se enviará la salida.

Ver también:

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


PEP 3110: Cambios en el manejo de excepciones
=============================================

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

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

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

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

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

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

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

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

Ver también:

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


PEP 3112: Literales de bytes
============================

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

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

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

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

   from __future__ import unicode_literals

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

   print len(s)               # 12 Unicode characters

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

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

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

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

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

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

Ver también:

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


PEP 3116: Nueva biblioteca de E/S
=================================

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

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

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

  Python 3.0 tiene implementaciones concretas de esta clase para
  archivos y sockets, pero Python 2.6 no ha reestructurado sus objetos
  archivo y socket de esta manera.

* "BufferedIOBase" is an abstract base class that buffers data in
  memory to reduce the number of system calls used, making I/O
  processing more efficient. It supports all of the methods of
  "RawIOBase", and adds a "raw" attribute holding the underlying raw
  object.

  There are five concrete classes implementing this ABC.
  "BufferedWriter" and "BufferedReader" are for objects that support
  write-only or read-only usage that have a "seek()" method for random
  access.  "BufferedRandom" objects support read and write access upon
  the same underlying stream, and "BufferedRWPair" is for objects such
  as TTYs that have both read and write operations acting upon
  unconnected streams of data. The "BytesIO" class supports reading,
  writing, and seeking over an in-memory buffer.

* "TextIOBase": Provides functions for reading and writing strings
  (remember, strings will be Unicode in Python 3.0), and supporting
  *universal newlines*.  "TextIOBase" defines the "readline()" method
  and supports iteration upon objects.

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

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

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

Ver también:

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


PEP 3118: Protocolo revisado de la memoria intermedia
=====================================================

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

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

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

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

* "PyBUF_WRITABLE" indica que la memoria debe ser grabable.

* "PyBUF_LOCK" requests a read-only or exclusive lock on the memory.

* "PyBUF_C_CONTIGUOUS" y "PyBUF_F_CONTIGUOUS" solicitan una
  disposición de matriz contigua en C (la última dimensión varía más
  rápidamente) o contigua en Fortran (la primera dimensión varía más
  rápidamente).

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

Ver también:

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


PEP 3119: Clases base abstractas
================================

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

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

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

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

   import collections

   class Storage(collections.MutableMapping):
       ...

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

   import collections

   class Storage:
       ...

   collections.MutableMapping.register(Storage)

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

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

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

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

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

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

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

   from abc import ABCMeta, abstractmethod

   class Drawable():
       __metaclass__ = ABCMeta

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

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


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

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

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

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

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

   from abc import abstractproperty
   ...

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

Subclasses must then define a "readonly" property.

Ver también:

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


PEP 3127: Soporte y sintaxis de literales enteros
=================================================

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

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

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

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

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

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

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

Ver también:

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


PEP 3129: Decoradores de clase
==============================

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

   @foo
   @bar
   class A:
     pass

Esto equivale a:

   class A:
     pass

   A = foo(bar(A))

Ver también:

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


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

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

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

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

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

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

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

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

Ver también:

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

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

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


El módulo "fractions"
---------------------

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

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

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

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

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

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

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


Otros cambios lingüísticos
==========================

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

* Los directorios y archivos zip que contengan un archivo
  "__main__.py" pueden ahora ejecutarse directamente pasando su nombre
  al intérprete. El directorio o archivo zip se inserta
  automáticamente como la primera entrada en sys.path.  (Sugerencia y
  parche inicial de Andy Chu, revisado posteriormente por Phillip J.
  Eby y Nick Coghlan; bpo-1739468)

* The "hasattr()" function was catching and ignoring all errors, under
  the assumption that they meant a "__getattr__()" method was failing
  somehow and the return value of "hasattr()" would therefore be
  "False".  This logic shouldn't be applied to "KeyboardInterrupt" and
  "SystemExit", however; Python 2.6 will no longer discard such
  exceptions when "hasattr()" encounters them.  (Fixed by Benjamin
  Peterson; bpo-2196.)

* Cuando se llama a una función utilizando la sintaxis "**" para
  proporcionar argumentos de palabras clave, ya no es necesario
  utilizar un diccionario de Python; ahora funcionará cualquier
  asignación:

     >>> def f(**kw):
     ...    print sorted(kw)
     ...
     >>> ud=UserDict.UserDict()
     >>> ud['a'] = 1
     >>> ud['b'] = 'string'
     >>> f(**ud)
     ['a', 'b']

  (Contribución de Alexander Belopolsky; bpo-1686487.)

  También se ha convertido en legal proporcionar argumentos de
  palabras clave después de un argumento "*args" a una llamada de
  función.

     >>> def f(*args, **kw):
     ...     print args, kw
     ...
     >>> f(1,2,3, *(4,5,6), keyword=13)
     (1, 2, 3, 4, 5, 6) {'keyword': 13}

  Anteriormente, esto habría sido un error de sintaxis. (Contribución
  de Amaury Forgeot d'Arc; bpo-3473.)

* Un nuevo builtin, "next(iterator, [default])" devuelve el siguiente
  elemento del iterador especificado.  Si se suministra el argumento
  *default*, se devolverá si *iterador* se ha agotado; en caso
  contrario, se lanzará la excepción "StopIteration".  (Se ha
  modificado en bpo-2719.)

* Tuples now have "index()" and "count()" methods matching the list
  type's "index()" and "count()" methods:

     >>> t = (0,1,2,3,4,0,1,2)
     >>> t.index(3)
     3
     >>> t.count(0)
     2

  (Contribución de Raymond Hettinger)

* Los tipos incorporados tienen ahora un soporte mejorado para la
  sintaxis de corte extendida, aceptando varias combinaciones de
  "(inicio, parada, paso)". Anteriormente, el soporte era parcial y
  algunos casos de esquina no funcionaban. (Implementado por Thomas
  Wouters)

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

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

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

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

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

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

* Several methods of the built-in set types now accept multiple
  iterables: "intersection()", "intersection_update()", "union()",
  "update()", "difference()" and "difference_update()".

     >>> s=set('1234567890')
     >>> s.intersection('abc123', 'cdf246')  # Intersection between all inputs
     set(['2'])
     >>> s.difference('246', '789')
     set(['1', '0', '3', '5'])

  (Contribución de Raymond Hettinger.)

* Se han añadido muchas funciones de punto flotante.  La función
  "float()" ahora convertirá la cadena "nan" en un valor IEEE 754 Not
  A Number, y "+inf" y "-inf" en infinito positivo o negativo.  Esto
  funciona en cualquier plataforma con semántica IEEE 754.
  (Contribución de Christian Heimes; bpo-1635.)

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

  Se han añadido funciones de conversión para convertir números de
  punto flotante en cadenas hexadecimales (bpo-3008).  Estas funciones
  convierten los números flotantes a y desde una representación de
  cadena sin introducir errores de redondeo por la conversión entre
  decimal y binario.  Los flotadores tienen un método "hex()" que
  devuelve una representación de cadena, y el método "float.fromhex()"
  convierte una cadena de nuevo en un número:

     >>> a = 3.75
     >>> a.hex()
     '0x1.e000000000000p+1'
     >>> float.fromhex('0x1.e000000000000p+1')
     3.75
     >>> b=1./3
     >>> b.hex()
     '0x1.5555555555555p-2'

* Un detalle numérico: cuando se crea un número complejo a partir de
  dos flotantes en sistemas que admiten ceros con signo (-0 y +0), el
  constructor "complex()" conserva ahora el signo del cero.
  (Corregido por Mark T. Dickinson; bpo-1507.)

* Classes that inherit a "__hash__()" method from a parent class can
  set "__hash__ = None" to indicate that the class isn't hashable.
  This will make "hash(obj)" raise a "TypeError" and the class will
  not be indicated as implementing the "Hashable" ABC.

  You should do this when you've defined a "__cmp__()" or "__eq__()"
  method that compares objects by their value rather than by identity.
  All objects have a default hash method that uses "id(obj)" as the
  hash value.  There's no tidy way to remove the "__hash__()" method
  inherited from a parent class, so assigning "None" was implemented
  as an override.  At the C level, extensions can set "tp_hash" to
  "PyObject_HashNotImplemented()". (Fixed by Nick Coghlan and Amaury
  Forgeot d'Arc; bpo-2235.)

* La excepción "GeneratorExit" ahora subclasa "BaseException" en lugar
  de "Exception".  Esto significa que un manejador de excepciones que
  haga "except Exception:" no atrapará inadvertidamente
  "GeneratorExit". (Contribuido por Chad Austin; bpo-1537.)

* Generator objects now have a "gi_code" attribute that refers to the
  original code object backing the generator. (Contributed by Collin
  Winter; bpo-1473257.)

* La función incorporada "compile()" ahora acepta argumentos de
  palabras clave así como parámetros posicionales.  (Contribución de
  Thomas Wouters; bpo-1444529.)

* El constructor "complex()" ahora acepta cadenas que contengan
  números complejos entre paréntesis, lo que significa que
  "complex(repr(cplx))" ahora redondeará los valores.  Por ejemplo,
  "complex('(3+4j)')" ahora devuelve el valor (3+4j).  (bpo-1491866)

* The string "translate()" method now accepts "None" as the
  translation table parameter, which is treated as the identity
  transformation.   This makes it easier to carry out operations that
  only delete characters.  (Contributed by Bengt Richter and
  implemented by Raymond Hettinger; bpo-1193128.)

* The built-in "dir()" function now checks for a "__dir__()" method on
  the objects it receives.  This method must return a list of strings
  containing the names of valid attributes for the object, and lets
  the object control the value that "dir()" produces. Objects that
  have "__getattr__()" or "__getattribute__()" methods can use this to
  advertise pseudo-attributes they will honor. (bpo-1591665)

* Los objetos de método de instancia tienen nuevos atributos para el
  objeto y la función que componen el método; el nuevo sinónimo de
  "im_self" es "__self__", y "im_func" también está disponible como
  "__func__". Los nombres antiguos aún se admiten en Python 2.6, pero
  ya no están disponibles en la versión 3.0.

* Un cambio oscuro: cuando se utiliza la función "locals()" dentro de
  una sentencia "class", el diccionario resultante ya no devuelve
  variables libres.  (Las variables libres, en este caso, son
  variables referenciadas en la sentencia "class" que no son atributos
  de la clase)


Optimizaciones
--------------

* El módulo "warnings" ha sido reescrito en C. Esto hace posible
  invocar advertencias desde el analizador sintáctico, y también puede
  hacer que el arranque del intérprete sea más rápido. (Contribuido
  por Neal Norwitz y Brett Cannon; bpo-1631171.)

* Los objetos de tipo tienen ahora una caché de métodos que puede
  reducir el trabajo necesario para encontrar la implementación del
  método correcto para una clase en particular; una vez almacenada en
  la caché, el intérprete no necesita recorrer las clases base para
  averiguar el método correcto a llamar. La caché se borra si una
  clase base o la propia clase se modifica, por lo que la caché
  debería seguir siendo correcta incluso ante la naturaleza dinámica
  de Python. (Optimización original implementada por Armin Rigo,
  actualizada para Python 2.6 por Kevin Jacobs; bpo-1700288.)

  Por defecto, este cambio sólo se aplica a los tipos que se incluyen
  con el núcleo de Python.  Los módulos de extensión no son
  necesariamente compatibles con esta caché, por lo que deben añadir
  explícitamente "Py_TPFLAGS_HAVE_VERSION_TAG" al campo "tp_flags" del
  módulo para habilitar la caché de métodos. (Para ser compatible con
  la caché de métodos, el código del módulo de extensión no debe
  acceder directamente ni modificar el miembro "tp_dict" de ninguno de
  los tipos que implementa.  La mayoría de los módulos no lo hacen,
  pero es imposible que el intérprete de Python lo determine. Ver
  bpo-1878 para una discusión)

* Las llamadas a funciones que utilizan argumentos de palabras clave
  son significativamente más rápidas al hacer una comparación rápida
  de punteros, lo que suele ahorrar el tiempo de una comparación
  completa de cadenas.  (Contribución de Raymond Hettinger, tras una
  implementación inicial de Antoine Pitrou; bpo-1819)

* Todas las funciones del módulo "struct" han sido reescritas en C,
  gracias al trabajo en el sprint de Need For Speed. (Contribución de
  Raymond Hettinger)

* Algunos de los tipos estándar incorporados ahora establecen un bit
  en sus objetos de tipo.  Esto acelera la comprobación de si un
  objeto es una subclase de uno de estos tipos.  (Contribución de Neal
  Norwitz)

* Unicode strings now use faster code for detecting whitespace and
  line breaks; this speeds up the "split()" method by about 25% and
  "splitlines()" by 35%. (Contributed by Antoine Pitrou.)  Memory
  usage is reduced by using pymalloc for the Unicode string's data.

* La declaración "with" ahora almacena el método "__exit__()" en la
  pila, lo que produce una pequeña mejora en la velocidad.
  (Implementado por Jeffrey Yasskin).

* Para reducir el uso de memoria, el recolector de basura ahora
  borrará las listas libres internas cuando recolecte la generación
  más alta de objetos. Esto puede devolver la memoria al sistema
  operativo antes.


Cambios de intérprete
---------------------

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

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

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


Módulos nuevos y mejorados
==========================

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

* Los módulos "asyncore" y "asynchat" están recibiendo mantenimiento
  activo nuevamente y se aplicaron varios parches y correcciones de
  errores. (Mantenimiento a cargo de Josiah Carlson; consulte
  bpo-1736190 para obtener un parche).

* The "bsddb" module also has a new maintainer, Jesús Cea Avión, and
  the package is now available as a standalone package.  The web page
  for the package is www.jcea.es/programacion/pybsddb.htm. The plan is
  to remove the package from the standard library in Python 3.0,
  because its pace of releases is much more frequent than Python's.

  The "bsddb.dbshelve" module now uses the highest pickling protocol
  available, instead of restricting itself to protocol 1. (Contributed
  by W. Barnes.)

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

  The "parse_qs()" and "parse_qsl()" functions have been relocated
  from the "cgi" module to the "urlparse" module. The versions still
  available in the "cgi" module will trigger
  "PendingDeprecationWarning" messages in 2.6 (bpo-600362).

* El módulo "cmath" ha sido objeto de una amplia revisión, a la que
  han contribuido Mark Dickinson y Christian Heimes. Se han añadido
  cinco nuevas funciones:

  * "polar()" converts a complex number to polar form, returning the
    modulus and argument of the complex number.

  * "rect()" does the opposite, turning a modulus, argument pair back
    into the corresponding complex number.

  * "phase()" returns the argument (also called the angle) of a
    complex number.

  * "isnan()" returns True if either the real or imaginary part of its
    argument is a NaN.

  * "isinf()" returns True if either the real or imaginary part of its
    argument is infinite.

  The revisions also improved the numerical soundness of the "cmath"
  module.  For all functions, the real and imaginary parts of the
  results are accurate to within a few units of least precision (ulps)
  whenever possible.  See bpo-1381 for the details.  The branch cuts
  for "asinh()", "atanh()", and "atan()" have also been corrected.

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

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

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

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

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

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

  (Contribución de Raymond Hettinger.)

* Another change to the "collections" module is that the "deque" type
  now supports an optional *maxlen* parameter; if supplied, the
  deque's size will be restricted to no more than *maxlen* items.
  Adding more items to a full deque causes old items to be discarded.

     >>> from collections import deque
     >>> dq=deque(maxlen=3)
     >>> dq
     deque([], maxlen=3)
     >>> dq.append(1); dq.append(2); dq.append(3)
     >>> dq
     deque([1, 2, 3], maxlen=3)
     >>> dq.append(4)
     >>> dq
     deque([2, 3, 4], maxlen=3)

  (Contribución de Raymond Hettinger.)

* Los objetos "Morsel" del módulo "Cookie" ahora admiten un atributo
  "httponly". En algunos navegadores, el código JavaScript no puede
  acceder ni manipular las cookies con este atributo establecido.
  (Contribuido por Arvin Schnell; bpo-1638033).

* A new window method in the "curses" module, "chgat()", changes the
  display attributes for a certain number of characters on a single
  line.  (Contributed by Fabian Kreutz.)

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

  The "Textbox" class in the "curses.textpad" module now supports
  editing in insert mode as well as overwrite mode. Insert mode is
  enabled by supplying a true value for the *insert_mode* parameter
  when creating the "Textbox" instance.

* The "datetime" module's "strftime()" methods now support a "%f"
  format code that expands to the number of microseconds in the
  object, zero-padded on the left to six places.  (Contributed by Skip
  Montanaro; bpo-1158.)

* The "decimal" module was updated to version 1.66 of the General
  Decimal Specification.  New features include some methods for some
  basic mathematical functions such as "exp()" and "log10()":

     >>> Decimal(1).exp()
     Decimal("2.718281828459045235360287471")
     >>> Decimal("2.7182818").ln()
     Decimal("0.9999999895305022877376682436")
     >>> Decimal(1000).log10()
     Decimal("3")

  The "as_tuple()" method of "Decimal" objects now returns a named
  tuple with "sign", "digits", and "exponent" fields.

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

* The "difflib" module's "SequenceMatcher" class now returns named
  tuples representing matches, with "a", "b", and "size" attributes.
  (Contributed by Raymond Hettinger.)

* An optional "timeout" parameter, specifying a timeout measured in
  seconds, was added to the "ftplib.FTP" class constructor as well as
  the "connect()" method.  (Added by Facundo Batista.) Also, the "FTP"
  class's "storbinary()" and "storlines()" now take an optional
  *callback* parameter that will be called with each block of data
  after the data has been sent. (Contributed by Phil Schwartz;
  bpo-1221598.)

* The "reduce()" built-in function is also available in the
  "functools" module.  In Python 3.0, the builtin has been dropped and
  "reduce()" is only available from "functools"; currently there are
  no plans to drop the builtin in the 2.x series. (Patched by
  Christian Heimes; bpo-1739906.)

* Cuando sea posible, el módulo "getpass" utilizará ahora "/dev/tty"
  para imprimir un mensaje de aviso y leer la contraseña,
  retrocediendo al error estándar y a la entrada estándar.  Si la
  contraseña puede ser enviada al terminal, se imprimirá una
  advertencia antes de que se muestre el aviso.  (Contribución de
  Gregory P. Smith)

* La función "glob.glob()" ahora puede devolver nombres de archivo
  Unicode si se ha utilizado una ruta Unicode y se han encontrado
  nombres de archivo Unicode dentro del directorio.  (bpo-1001604)

* Una nueva función en el módulo "heapq", "merge(iter1, iter2, ...)",
  toma cualquier número de iterables que devuelven datos en orden
  ordenado, y devuelve un nuevo generador que devuelve el contenido de
  todos los iteradores, también en ordenado.  Por ejemplo:

     >>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16]))
     [1, 2, 3, 5, 8, 9, 16]

  Another new function, "heappushpop(heap, item)", pushes *item* onto
  *heap*, then pops off and returns the smallest item. This is more
  efficient than making a call to "heappush()" and then "heappop()".

  "heapq" se ha implementado para utilizar únicamente la comparación
  menor que, en lugar de la comparación menor o igual que utilizaba
  anteriormente. Esto hace que el uso de "heapq" de un tipo coincida
  con el método "list.sort()". (Contribución de Raymond Hettinger)

* Se agregó un parámetro opcional "timeout" a los constructores de
  clases "httplib.HTTPConnection" y "HTTPSConnection", que especifica
  un tiempo de espera medido en segundos. (Agregado por Facundo
  Batista).

* Most of the "inspect" module's functions, such as "getmoduleinfo()"
  and "getargs()", now return named tuples. In addition to behaving
  like tuples, the elements of the  return value can also be accessed
  as attributes. (Contributed by Raymond Hettinger.)

  Some new functions in the module include "isgenerator()",
  "isgeneratorfunction()", and "isabstract()".

* El módulo "itertools" ha ganado varias funciones nuevas.

  "izip_longest(iter1, iter2, ...[, fillvalue])" hace tuplas de cada
  uno de los elementos; si algunos de los iterables son más cortos que
  otros, los valores que faltan se ponen a *fillvalue*.  Por ejemplo:

     >>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5]))
     ((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))

  "product(iter1, iter2, ..., [repeat=N])" devuelve el producto
  cartesiano de los iterables suministrados, un conjunto de tuplas que
  contiene todas las combinaciones posibles de los elementos devueltos
  de cada iterable.

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

  El argumento opcional de la palabra clave *repeat* se utiliza para
  tomar el producto de un iterable o un conjunto de iterables con
  ellos mismos, repetido *N* veces.  Con un único argumento iterable,
  se devuelven *N*-tuplas:

     >>> list(itertools.product([1,2], repeat=3))
     [(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
      (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]

  Con dos iterables, se devuelven *2N*-tuplas.

     >>> list(itertools.product([1,2], [3,4], repeat=2))
     [(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4),
      (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4),
      (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4),
      (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]

  "combinaciones(iterable, r)" devuelve subsecuencias de longitud *r*
  de los elementos de *iterable*.

     >>> list(itertools.combinations('123', 2))
     [('1', '2'), ('1', '3'), ('2', '3')]
     >>> list(itertools.combinations('123', 3))
     [('1', '2', '3')]
     >>> list(itertools.combinations('1234', 3))
     [('1', '2', '3'), ('1', '2', '4'),
      ('1', '3', '4'), ('2', '3', '4')]

  "permutaciones(iter[, r])" devuelve todas las permutaciones de
  longitud *r* de los elementos del iterable.  Si no se especifica
  *r*, por defecto será el número de elementos producidos por el
  iterable.

     >>> list(itertools.permutations([1,2,3,4], 2))
     [(1, 2), (1, 3), (1, 4),
      (2, 1), (2, 3), (2, 4),
      (3, 1), (3, 2), (3, 4),
      (4, 1), (4, 2), (4, 3)]

  "itertools.chain(*iterables)" is an existing function in "itertools"
  that gained a new constructor in Python 2.6.
  "itertools.chain.from_iterable(iterable)" takes a single iterable
  that should return other iterables.  "chain()" will then return all
  the elements of the first iterable, then all the elements of the
  second, and so on.

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

  (Todo ello aportado por Raymond Hettinger)

* The "logging" module's "FileHandler" class and its subclasses
  "WatchedFileHandler", "RotatingFileHandler", and
  "TimedRotatingFileHandler" now have an optional *delay* parameter to
  their constructors.  If *delay* is true, opening of the log file is
  deferred until the first "emit()" call is made.  (Contributed by
  Vinay Sajip.)

  "TimedRotatingFileHandler" also has a *utc* constructor parameter.
  If the argument is true, UTC time will be used in determining when
  midnight occurs and in generating filenames; otherwise local time
  will be used.

* Se han añadido varias funciones nuevas al módulo "math":

  * "isinf()" y "isnan()" determinan si un flotador dado es un
    infinito (positivo o negativo) o un NaN (Not a Number),
    respectivamente.

  * "copysign()" copia el bit de signo de un número IEEE 754,
    devolviendo el valor absoluto de *x* combinado con el bit de signo
    de *y*.  Por ejemplo, "math.copysign(1, -0.0)" devuelve -1.0.
    (Contribución de Christian Heimes)

  * "factorial()" calcula el factorial de un número. (Contribuido por
    Raymond Hettinger; bpo-2138.)

  * "fsum()" suma el flujo de números de un iterable, y tiene cuidado
    de evitar la pérdida de precisión mediante el uso de sumas
    parciales. (Contribución de Jean Brouwers, Raymond Hettinger y
    Mark Dickinson; bpo-2819)

  * "acosh()", "asinh()" y "atanh()" calculan las funciones
    hiperbólicas inversas.

  * "log1p()" devuelve el logaritmo natural de *1+x* (base *e*).

  * "trunc()" rounds a number toward zero, returning the closest
    "Integral" that's between the function's argument and zero. Added
    as part of the backport of PEP 3141's type hierarchy for numbers.

* El módulo "math" se ha mejorado para ofrecer un comportamiento más
  coherente en todas las plataformas, especialmente en lo que respecta
  al manejo de las excepciones de punto flotante y los valores
  especiales IEEE 754.

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

  (Contribución de Christian Heimes y Mark Dickinson)

* "mmap" objects now have a "rfind()" method that searches for a
  substring beginning at the end of the string and searching
  backwards.  The "find()" method also gained an *end* parameter
  giving an index at which to stop searching. (Contributed by John
  Lenton.)

* The "operator" module gained a "methodcaller()" function that takes
  a name and an optional set of arguments, returning a callable that
  will call the named function on any arguments passed to it.  For
  example:

     >>> # Equivalent to lambda s: s.replace('old', 'new')
     >>> replacer = operator.methodcaller('replace', 'old', 'new')
     >>> replacer('old wine in old bottles')
     'new wine in new bottles'

  (Contribución de Georg Brandl, tras una sugerencia de Gregory
  Petrosyan)

  The "attrgetter()" function now accepts dotted names and performs
  the corresponding attribute lookups:

     >>> inst_name = operator.attrgetter(
     ...        '__class__.__name__')
     >>> inst_name('')
     'str'
     >>> inst_name(help)
     '_Helper'

  (Contribución de Georg Brandl, tras una sugerencia de Barry Warsaw)

* El módulo "os" incluye ahora varias llamadas nuevas al sistema.
  "fchmod(fd, mode)" y "fchown(fd, uid, gid)" cambian el modo y la
  propiedad de un fichero abierto, y "lchmod(path, mode)" cambia el
  modo de un enlace simbólico.  (Contribución de Georg Brandl y
  Christian Heimes)

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

  "os.closerange(low, high)" cierra eficazmente todos los descriptores
  de fichero desde *low* hasta *high*, ignorando cualquier error y sin
  incluir a *high* mismo. Esta función es ahora utilizada por el
  módulo "subprocess" para hacer más rápido el arranque de procesos.
  (Contribuido por Georg Brandl; bpo-1663329.)

* The "os.environ" object's "clear()" method will now unset the
  environment variables using "os.unsetenv()" in addition to clearing
  the object's keys.  (Contributed by Martin Horcicka; bpo-1181.)

* La función "os.walk()" tiene ahora un parámetro "followlinks". Si se
  establece como True, seguirá los enlaces simbólicos que apunten a
  directorios y visitará el contenido del directorio.  Por
  compatibilidad con el pasado, el valor por defecto del parámetro es
  false.  Tenga en cuenta que la función puede caer en una recursión
  infinita si hay un enlace simbólico que apunte a un directorio
  padre.  (bpo-1273829)

* In the "os.path" module, the "splitext()" function has been changed
  to not split on leading period characters. This produces better
  results when operating on Unix's dot-files. For example,
  "os.path.splitext('.ipython')" now returns "('.ipython', '')"
  instead of "('', '.ipython')". (bpo-1115886)

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

  En Windows, "os.path.expandvars()" ahora expandirá las variables de
  entorno dadas en la forma "%var%", y "~user" se expandirá en la ruta
  del directorio personal del usuario.  (Contribución de Josiah
  Carlson; bpo-957650.)

* El depurador de Python proporcionado por el módulo "pdb" ganó un
  nuevo comando: "run" reinicia el programa Python que se está
  depurando y puede tomar opcionalmente nuevos argumentos de línea de
  comandos para el programa. (Contribución de Rocky Bernstein;
  bpo-1393667.)

* La función "pdb.post_mortem()", utilizada para iniciar la depuración
  de un traceback, utilizará ahora el traceback devuelto por
  "sys.exc_info()" si no se suministra ningún traceback.
  (Contribuido por Facundo Batista; bpo-1106316.)

* The "pickletools" module now has an "optimize()" function that takes
  a string containing a pickle and removes some unused opcodes,
  returning a shorter pickle that contains the same data structure.
  (Contributed by Raymond Hettinger.)

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

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

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

* The "pyexpat" module's "Parser" objects now allow setting their
  "buffer_size" attribute to change the size of the buffer used to
  hold character data. (Contributed by Achim Gaedke; bpo-1137.)

* The "queue" module now provides queue variants that retrieve entries
  in different orders.  The "PriorityQueue" class stores queued items
  in a heap and retrieves them in priority order, and "LifoQueue"
  retrieves the most recently added entries first, meaning that it
  behaves like a stack. (Contributed by Raymond Hettinger.)

* The "random" module's "Random" objects can now be pickled on a
  32-bit system and unpickled on a 64-bit system, and vice versa.
  Unfortunately, this change also means that Python 2.6's "Random"
  objects can't be unpickled correctly on earlier versions of Python.
  (Contributed by Shawn Ligocki; bpo-1727780.)

  La nueva función "triangular(low, high, mode)" devuelve números
  aleatorios siguiendo una distribución triangular.   Los valores
  devueltos están entre *bajos* y *altos*, sin incluir los propios
  *altos*, y con *modo* como valor más frecuente en la distribución.
  (Contribución de Wladmir van der Laan y Raymond Hettinger;
  bpo-1681432.)

* Las búsquedas de expresiones regulares largas llevadas a cabo por el
  módulo "re" comprobarán la entrega de señales, por lo que ahora se
  pueden interrumpir las búsquedas que consumen mucho tiempo.
  (Contribución de Josh Hoyt y Ralf Schmitt; bpo-846388.)

  El módulo de expresiones regulares se implementa compilando
  bytecodes para una pequeña máquina virtual específica de regex.  El
  código no fiable podría crear cadenas maliciosas de código de bytes
  directamente y causar caídas, por lo que Python 2.6 incluye un
  verificador para el código de bytes regex. (Contribuido por Guido
  van Rossum del trabajo para Google App Engine; bpo-3487.)

* The "rlcompleter" module's "complete()" method will now ignore
  exceptions triggered while evaluating a name. (Fixed by Lorenz
  Quack; bpo-2250.)

* The "sched" module's "scheduler" instances now have a read-only
  "queue" attribute that returns the contents of the scheduler's
  queue, represented as a list of named tuples with the fields "(time,
  priority, action, argument)". (Contributed by Raymond Hettinger;
  bpo-1861.)

* The "select" module now has wrapper functions for the Linux
  "epoll()" and BSD "kqueue()" system calls. "modify()" method was
  added to the existing "poll" objects; "pollobj.modify(fd,
  eventmask)" takes a file descriptor or file object and an event
  mask, modifying the recorded event mask for that file. (Contributed
  by Christian Heimes; bpo-1657.)

* La función "shutil.copytree()" tiene ahora un argumento opcional
  *ignore* que toma un objeto callable.  Esta llamada recibirá cada
  ruta de directorio y una lista del contenido del directorio, y
  devuelve una lista de nombres que serán ignorados, no copiados.

  The "shutil" module also provides an "ignore_patterns()" function
  for use with this new parameter.  "ignore_patterns()" takes an
  arbitrary number of glob-style patterns and returns a callable that
  will ignore any files and directories that match any of these
  patterns.  The following example copies a directory tree, but skips
  both ".svn" directories and Emacs backup files, which have names
  ending with '~':

     shutil.copytree('Doc/library', '/tmp/library',
                     ignore=shutil.ignore_patterns('*~', '.svn'))

  (Contribución de Tarek Ziadé; bpo-2663.)

* Integrar el manejo de señales con los bucles de eventos de manejo de
  la interfaz gráfica de usuario (GUI), como los utilizados por
  Tkinter o GTk+, ha sido durante mucho tiempo un problema; la mayoría
  del software acaba sondeando, despertando cada fracción de segundo
  para comprobar si se ha producido algún evento de la GUI. El módulo
  "signal" puede ahora hacer esto más eficiente. Llamando a
  "signal.set_wakeup_fd(fd)" se establece un descriptor de fichero a
  utilizar; cuando se recibe una señal, se escribe un byte en ese
  descriptor de fichero.  También hay una función en C,
  "PySignal_SetWakeupFd()", para establecer el descriptor.

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

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

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

  The "setitimer()" and "getitimer()" functions have also been added
  (where they're available).  "setitimer()" allows setting interval
  timers that will cause a signal to be delivered to the process after
  a specified time, measured in wall-clock time, consumed process
  time, or combined process+system time.  (Contributed by Guilherme
  Polo; bpo-2240.)

* The "smtplib" module now supports SMTP over SSL thanks to the
  addition of the "SMTP_SSL" class. This class supports an interface
  identical to the existing "SMTP" class. (Contributed by Monty
  Taylor.)  Both class constructors also have an optional "timeout"
  parameter that specifies a timeout for the initial connection
  attempt, measured in seconds.  (Contributed by Facundo Batista.)

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

  "smtplib.SMTP.starttls()" now complies with **RFC 3207** and forgets
  any knowledge obtained from the server not obtained from the TLS
  negotiation itself.  (Patch contributed by Bill Fenner; bpo-829951.)

* El módulo "socket" soporta ahora TIPC
  (http://tipc.sourceforge.net/), un protocolo de alto rendimiento no
  basado en IP y diseñado para su uso en entornos agrupados.  Las
  direcciones TIPC son de 4 o 5 tuplas. (Contribución de Alberto
  Bertogli; bpo-1646.)

  A new function, "create_connection()", takes an address and connects
  to it using an optional timeout value, returning the connected
  socket object.  This function also looks up the address's type and
  connects to it using IPv4 or IPv6 as appropriate.  Changing your
  code to use "create_connection()" instead of "socket(socket.AF_INET,
  ...)" may be all that's required to make your code work with IPv6.

* Las clases base del módulo "SocketServer" ahora admiten la llamada a
  un método "handle_timeout()" después de un período de inactividad
  especificado por el atributo "timeout" del servidor. (Contribuido
  por Michael Pomraning.) El método "serve_forever()" ahora utiliza un
  intervalo de sondeo opcional medido en segundos, que controla la
  frecuencia con la que el servidor comprobará si hay una solicitud de
  apagado. (Contribuido por Pedro Werneck y Jeffrey Yasskin;
  bpo-742598, bpo-1193577.)

* El módulo "sqlite3", mantenido por Gerhard Häring, ha sido
  actualizado de la versión 2.3.2 en Python 2.5 a la versión 2.4.1.

* El módulo "struct" ahora admite el tipo C99 _Bool, utilizando el
  carácter de formato "'?'". (Aportado por David Remahl.)

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

* A new variable in the "sys" module, "float_info", is an object
  containing information derived from the "float.h" file about the
  platform's floating-point support.  Attributes of this object
  include "mant_dig" (number of digits in the mantissa), "epsilon"
  (smallest difference between 1.0 and the next largest value
  representable), and several others.  (Contributed by Christian
  Heimes; bpo-1534.)

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

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

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

  Ahora es posible determinar las funciones actuales del perfilador y
  del trazador llamando a "sys.getprofile()" y "sys.gettrace()".
  (Contribuido por Georg Brandl; bpo-1648.)

* El módulo "tarfile" soporta ahora archivos tar POSIX.1-2001 (pax)
  además de los formatos POSIX.1-1988 (ustar) y GNU tar que ya estaban
  soportados.  El formato por defecto es GNU tar; especifique el
  parámetro "format" para abrir un archivo con un formato diferente:

     tar = tarfile.open("output.tar", "w",
                        format=tarfile.PAX_FORMAT)

  Los nuevos parámetros "encoding" y "errors" especifican una
  codificación y un esquema de manejo de errores para las conversiones
  de caracteres.  "'strict'", "'ignore'", y "'replace'" son las tres
  formas estándar en las que Python puede manejar los errores;
  "'utf-8'" es un valor especial que reemplaza los caracteres erróneos
  con su representación UTF-8.  (Las conversiones de caracteres
  ocurren porque el formato PAX soporta nombres de archivo Unicode,
  por defecto con codificación UTF-8)

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

  (Todos los cambios han sido aportados por Lars Gustäbel).

* Se agregó un parámetro opcional "timeout" al constructor de la clase
  "telnetlib.Telnet", que especifica un tiempo de espera medido en
  segundos. (Agregado por Facundo Batista).

* La clase "tempfile.NamedTemporaryFile" suele borrar el archivo
  temporal que ha creado cuando se cierra el archivo.  Este
  comportamiento se puede cambiar pasando "delete=False" al
  constructor.  (Contribución de Damien Miller; bpo-1537850.)

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

  The "NamedTemporaryFile" and "SpooledTemporaryFile" classes both
  work as context managers, so you can write "with
  tempfile.NamedTemporaryFile() as tmp: ...". (Contributed by
  Alexander Belopolsky; bpo-2021.)

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

  Another context manager, "TransientResource", can surround calls to
  resources that may or may not be available; it will catch and ignore
  a specified list of exceptions.  For example, a network test may
  ignore certain failures when connecting to an external web site:

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

  Finally, "check_warnings()" resets the "warnings" module's warning
  filters and returns an object that will record all warning messages
  triggered (bpo-3781):

     with test_support.check_warnings() as wrec:
         warnings.simplefilter("always")
         # ... code that triggers a warning ...
         assert str(wrec.message) == "function is outdated"
         assert len(wrec.warnings) == 1, "Multiple warnings raised"

  (Contribución de Brett Cannon.)

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

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

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

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

  The "threading" module's "Thread" objects gained an "ident" property
  that returns the thread's identifier, a nonzero integer.
  (Contributed by Gregory P. Smith; bpo-2871.)

* The "timeit" module now accepts callables as well as strings for the
  statement being timed and for the setup code. Two convenience
  functions were added for creating "Timer" instances: "repeat(stmt,
  setup, time, repeat, number)" and "timeit(stmt, setup, time,
  number)" create an instance and call the corresponding method.
  (Contributed by Erik Demaine; bpo-1533909.)

* The "tkinter" module now accepts lists and tuples for options,
  separating the elements by spaces before passing the resulting value
  to Tcl/Tk. (Contributed by Guilherme Polo; bpo-2906.)

* El módulo "turtle" para los gráficos de tortugas ha sido muy
  mejorado por Gregor Lingl.  Las nuevas características del módulo
  incluyen:

  * Mejor animación del movimiento y la rotación de la tortuga.

  * Control over turtle movement using the new "delay()", "tracer()",
    and "speed()" methods.

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

  * Turtles now have an "undo()" method that can roll back actions.

  * Soporte sencillo para reaccionar a eventos de entrada como la
    actividad del ratón y del teclado, lo que permite escribir juegos
    sencillos.

  * Se puede utilizar un archivo "turtle.cfg" para personalizar la
    apariencia inicial de la pantalla de la tortuga.

  * Los docstrings del módulo pueden ser sustituidos por nuevos
    docstrings traducidos a otro idioma.

  (bpo-1513695)

* An optional "timeout" parameter was added to the "urllib.urlopen"
  function and the "urllib.ftpwrapper" class constructor, as well as
  the "urllib2.urlopen" function.  The parameter specifies a timeout
  measured in seconds.   For example:

     >>> u = urllib2.urlopen("http://slow.example.com",
                             timeout=3)
     Traceback (most recent call last):
       ...
     urllib2.URLError: <urlopen error timed out>
     >>>

  (Añadido por Facundo Batista.)

* La base de datos Unicode proporcionada por el módulo "unicodedata"
  ha sido actualizada a la versión 5.1.0.  (Actualizado por Martin von
  Löwis; bpo-3811.)

* The "warnings" module's "formatwarning()" and "showwarning()" gained
  an optional *line* argument that can be used to supply the line of
  source code.  (Added as part of bpo-1631171, which re-implemented
  part of the "warnings" module in C code.)

  A new function, "catch_warnings()", is a context manager intended
  for testing purposes that lets you temporarily modify the warning
  filters and then restore their original values (bpo-3781).

* The XML-RPC "SimpleXMLRPCServer" and "DocXMLRPCServer" classes can
  now be prevented from immediately opening and binding to their
  socket by passing "False" as the *bind_and_activate* constructor
  parameter.  This can be used to modify the instance's
  "allow_reuse_address" attribute before calling the "server_bind()"
  and "server_activate()" methods to open the socket and begin
  listening for connections. (Contributed by Peter Parente;
  bpo-1599845.)

  "SimpleXMLRPCServer" also has a "_send_traceback_header" attribute;
  if true, the exception and formatted traceback are returned as HTTP
  headers "X-Exception" and "X-Traceback".  This feature is for
  debugging purposes only and should not be used on production servers
  because the tracebacks might reveal passwords or other sensitive
  information.  (Contributed by Alan McIntyre as part of his project
  for Google's Summer of Code 2007.)

* The "xmlrpclib" module no longer automatically converts
  "datetime.date" and "datetime.time" to the "xmlrpclib.DateTime"
  type; the conversion semantics were not necessarily correct for all
  applications.  Code using "xmlrpclib" should convert "date" and
  "time" instances. (bpo-1330538)  The code can also handle dates
  before 1900 (contributed by Ralf Schmitt; bpo-2014) and 64-bit
  integers represented by using "<i8>" in XML-RPC responses
  (contributed by Riku Lindblad; bpo-2985).

* The "zipfile" module's "ZipFile" class now has "extract()" and
  "extractall()" methods that will unpack a single file or all the
  files in the archive to the current directory, or to a specified
  directory:

     z = zipfile.ZipFile('python-251.zip')

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

     # Unpack all the files in the archive.
     z.extractall()

  (Contribución de Alan McIntyre; bpo-467924.)

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

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


El módulo "ast"
---------------

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

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

   import ast

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

Esto produce un árbol profundamente anidado:

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

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

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

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


The "future_builtins" module
----------------------------

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

Las funciones de este módulo incluyen actualmente:

* "ascii(obj)": equivalente a "repr()".  En Python 3.0, "repr()"
  devolverá una cadena Unicode, mientras que "ascii()" devolverá una
  cadena de bytes ASCII pura.

* "filtro(predicado, iterable)", "map(func, iterable1, ...)": las
  versiones 3.0 devuelven iteradores, a diferencia de las funciones
  integradas 2.x que devuelven listas.

* "hex(value)", "oct(value)": instead of calling the "__hex__()" or
  "__oct__()" methods, these versions will call the "__index__()"
  method and convert the result to hexadecimal or octal.  "oct()" will
  use the new "0o" notation for its result.


El módulo "json": Notación de objetos de JavaScript
---------------------------------------------------

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

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

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

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

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


El módulo "plistlib": Un analizador de listas de propiedades
------------------------------------------------------------

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

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

El uso del módulo es sencillo:

   import sys
   import plistlib
   import datetime as dt

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

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

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

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


mejoras en ctypes
-----------------

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

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

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

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

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

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

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

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


Mejora de la compatibilidad con SSL
-----------------------------------

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

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

Ver también: La documentación del módulo "ssl".


Cancelaciones y eliminaciones
=============================

* Se han eliminado las excepciones de cadena.  Al intentar utilizarlas
  se produce un "TypeError".

* Se siguen realizando cambios en la interfaz "Exception" según lo
  dictado por **PEP 352**. En la versión 2.6, el atributo "message" se
  está reemplazando por el atributo "args".

* (modo 3.0-warning) Python 3.0 presentará una biblioteca estándar
  reorganizada que eliminará muchos módulos obsoletos y renombrará
  otros. Python 2.6 funcionando en modo 3.0-warning avisará de estos
  módulos cuando se importen.

  La lista de módulos obsoletos es: "audiodev", "bgenlocations",
  "buildtools", "bundlebuilder", "Canvas", "compiler", "dircache",
  "dl", "fpformat", "gensuitemodule", "ihooks", "imageop", "imgfile",
  "linuxaudiodev", "mhlib", "mimetools", "multifile", "new", "pure",
  "statvfs", "sunaudiodev", "test.testall" y "toaiff".

* El módulo "gopherlib" ha sido eliminado.

* El módulo "MimeWriter" y el módulo "mimify" han quedado obsoletos;
  utilice en su lugar el paquete "email".

* El módulo "md5" ha quedado obsoleto; utilice en su lugar el módulo
  "hashlib".

* El módulo "posixfile" ha quedado obsoleto; "fcntl.lockf()"
  proporciona un mejor bloqueo.

* El módulo "popen2" ha quedado obsoleto; utilice el módulo
  "subprocess".

* Se ha eliminado el módulo "rgbimg".

* El módulo "sets" ha quedado obsoleto; es mejor utilizar los tipos
  incorporados "set" y "frozenset".

* El módulo "sha" ha quedado obsoleto; utilice en su lugar el módulo
  "hashlib".


Cambios en la API de construcción y C
=====================================

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

* Python ahora debe ser compilado con compiladores C89 (¡después de 19
  años!).  Esto significa que el árbol de fuentes de Python ha
  abandonado sus propias implementaciones de "memmove()" y
  "strerror()", que están en la biblioteca estándar de C89.

* Python 2.6 puede ser construido con Microsoft Visual Studio 2008
  (versión 9.0), y este es el nuevo compilador por defecto.  Ver el
  directorio "PCbuild" para los archivos de construcción.
  (Implementado por Christian Heimes)

* En Mac OS X, Python 2.6 puede ser compilado como una construcción
  universal de 4 vías. El script **configure** puede tomar una opción
  :*!--with-universal-archs=[32-bit|64-bit|all]*, controlando si los
  binarios se construyen para arquitecturas de 32 bits (x86, PowerPC),
  64 bits (x86-64 y PPC-64), o ambas. (Contribución de Ronald
  Oussoren)

* Una nueva función agregada en Python 2.6.6, "PySys_SetArgvEx()",
  establece el valor de "sys.argv" y opcionalmente puede actualizar
  "sys.path" para incluir el directorio que contiene el script
  nombrado por "sys.argv[0]" dependiendo del valor de un parámetro
  *updatepath*.

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

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

  Problema de seguridad informado como **CVE 2008-5983**; discutido en
  gh-50003 y solucionado por Antoine Pitrou.

* The BerkeleyDB module now has a C API object, available as
  "bsddb.db.api".   This object can be used by other C extensions that
  wish to use the "bsddb" module for their own purposes. (Contributed
  by Duncan Grisby.)

* La nueva interfaz del buffer, descrita previamente en la sección PEP
  3118, añade "PyObject_GetBuffer()" y "PyBuffer_Release()", así como
  algunas otras funciones.

* El uso que hace Python de la biblioteca stdio de C es ahora seguro
  para los hilos, o al menos tan seguro como la biblioteca subyacente.
  Un error potencial de larga data ocurría si un hilo cerraba un
  objeto de archivo mientras otro hilo estaba leyendo o escribiendo en
  el objeto.  En la versión 2.6 los objetos archivo tienen un contador
  de referencias, manipulado por las funciones "PyFile_IncUseCount()"
  y "PyFile_DecUseCount()".  Los objetos de archivo no pueden cerrarse
  a menos que el recuento de referencias sea cero.
  "PyFile_IncUseCount()" debe llamarse mientras se mantiene el GIL,
  antes de realizar una operación de E/S utilizando el puntero "FILE
  *", y "PyFile_DecUseCount()" debe llamarse inmediatamente después de
  recuperar el GIL. (Contribución de Antoine Pitrou y Gregory P.
  Smith)

* Importing modules simultaneously in two different threads no longer
  deadlocks; it will now raise an "ImportError".  A new API function,
  "PyImport_ImportModuleNoBlock()", will look for a module in
  "sys.modules" first, then try to import it after acquiring an import
  lock.  If the import lock is held by another thread, an
  "ImportError" is raised. (Contributed by Christian Heimes.)

* Varias funciones devuelven información sobre la compatibilidad de
  punto flotante de la plataforma. "PyFloat_GetMax()" devuelve el
  valor máximo representable de punto flotante y "PyFloat_GetMin()"
  devuelve el valor positivo mínimo. "PyFloat_GetInfo()" devuelve un
  objeto que contiene más información del archivo "float.h", como
  ""mant_dig"" (número de dígitos en la mantisa), ""epsilon""
  (diferencia más pequeña entre 1.0 y el siguiente valor más grande
  representable) y varios otros. (Contribuido por Christian Heimes;
  bpo-1534.)

* C functions and methods that use "PyComplex_AsCComplex()" will now
  accept arguments that have a "__complex__()" method.  In particular,
  the functions in the "cmath" module will now accept objects with
  this method. This is a backport of a Python 3.0 change. (Contributed
  by Mark Dickinson; bpo-1675423.)

* La API de C de Python incluye ahora dos funciones para comparar
  cadenas sin distinción de mayúsculas y minúsculas,
  "PyOS_stricmp(char*, char*)" y "PyOS_strnicmp(char*, char*,
  Py_ssize_t)". (Contribución de Christian Heimes; bpo-1635.)

* Muchas extensiones de C definen su propia macro para añadir enteros
  y cadenas al diccionario del módulo en la función "init*".  Python
  2.6 finalmente define macros estándar para añadir valores a un
  módulo, "PyModule_AddStringMacro" y "PyModule_AddIntMacro()".
  (Contribución de Christian Heimes.)

* Algunas macros han sido renombradas tanto en la 3.0 como en la 2.6
  para dejar más claro que son macros y no funciones. "Py_Size()" se
  convierte en "Py_SIZE()", "Py_Type()" se convierte en "Py_TYPE()", y
  "Py_Refcnt()" se convierte en "Py_REFCNT()". Las macros de
  mayúsculas y minúsculas siguen estando disponibles en Python 2.6 por
  compatibilidad con versiones anteriores. (bpo-1629)

* Distutils ahora coloca las extensiones C que construye en un
  directorio diferente cuando se ejecuta en una versión de depuración
  de Python. (Contribución de Collin Winter; bpo-1530959.)

* Varios tipos de datos básicos, como los enteros y las cadenas,
  mantienen listas internas de objetos libres que pueden reutilizarse.
  Las estructuras de datos para estas listas libres siguen ahora una
  convención de nomenclatura: la variable se llama siempre
  "free_list", el contador se llama siempre "numfree", y siempre se
  define una macro "Py<typename>_MAXFREELIST"

* Un nuevo objetivo de Makefile, "make patchcheck", prepara el árbol
  de fuentes de Python para hacer un parche: corrige los espacios en
  blanco al final de todos los archivos ".py" modificados, comprueba
  si la documentación ha sido cambiada, e informa si los archivos
  "Misc/ACKS" y "Misc/NEWS" han sido actualizados. (Contribuido por
  Brett Cannon.)

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


Cambios específicos en los puertos: Windows
-------------------------------------------

* Se ha eliminado el soporte para Windows 95, 98, ME y NT4. Python 2.6
  requiere al menos Windows 2000 SP4.

* El nuevo compilador por defecto en Windows es Visual Studio 2008
  (versión 9.0). Los directorios de compilación para Visual Studio
  2003 (versión 7.1) y 2005 (versión 8.0) se han trasladado al
  directorio PC/. El nuevo directorio "PCbuild" admite la compilación
  cruzada para X64, las compilaciones de depuración y la optimización
  guiada por perfil (PGO). Las compilaciones PGO son aproximadamente
  un 10% f más rápidas que las normales.  (Contribuido por Christian
  Heimes con la ayuda de Amaury Forgeot d'Arc y Martin von Löwis)

* El módulo "msvcrt" ahora admite las variantes de caracteres normales
  y anchos de la API de E/S de la consola. La función "getwch()" lee
  una pulsación de tecla y devuelve un valor Unicode, al igual que la
  función "getwche()". La función "putwch()" toma un carácter Unicode
  y lo escribe en la consola. (Contribuido por Christian Heimes).

* "os.path.expandvars()" ahora expandirá las variables de entorno de
  la forma "%var%", y "~user" se expandirá en la ruta del directorio
  personal del usuario.  (Contribución de Josiah Carlson; bpo-957650.)

* The "socket" module's socket objects now have an "ioctl()" method
  that provides a limited interface to the "WSAIoctl()" system
  interface.

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

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

* El objeto "Record" del módulo "msilib" obtuvo los métodos
  "GetInteger()" y "GetString()" que devuelven valores de campo como
  un entero o una cadena. (Contribuido por Floris Bruynooghe;
  bpo-2125).


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

* Cuando se compila una estructura de Python, ahora se puede
  especificar el nombre de la estructura que se utilizará
  proporcionando la opción "--with-framework-name=" al script
  **configure**.

* Se ha eliminado el módulo "macfs". Esto a su vez requirió que se
  eliminara la función "macostools.touched()" porque dependía del
  módulo "macfs". (bpo-1490190)

* Muchos otros módulos de Mac OS han quedado obsoletos y se eliminarán
  en Python 3.0: "_builtinSuites", "aepack", "aetools", "aetypes",
  "applesingle", "appletrawmain", "appletrunner", "argvemulator",
  "Audio_mac", "autoGIL", "Carbon", "cfmfile", "CodeWarrior",
  "ColorPicker", "EasyDialogs", "Explorer", "Finder", "FrameWork",
  "findertools", "ic", "icglue", "icopen", "macerrors", "MacOS",
  "macfs", "macostools", "macresource", "MiniAEFrame", "Nav",
  "Netscape", "OSATerminology", "pimp", "PixMapWrapper", "StdSuites",
  "SystemEvents", "Terminal" y "terminalcommand".


Cambios específicos en los puertos: IRIX
----------------------------------------

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


Adaptación a Python 2.6
=======================

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

* Las clases que no se supone que son hashable deben establecer
  "__hash__ = None" en sus definiciones para indicar el hecho.

* Se han eliminado las excepciones de cadena.  Al intentar utilizarlas
  se produce un "TypeError".

* The "__init__()" method of "collections.deque" now clears any
  existing contents of the deque before adding elements from the
  iterable.  This change makes the behavior match "list.__init__()".

* "object.__init__()" previously accepted arbitrary arguments and
  keyword arguments, ignoring them.  In Python 2.6, this is no longer
  allowed and will result in a "TypeError".  This will affect
  "__init__()" methods that end up calling the corresponding method on
  "object" (perhaps through using "super()"). See bpo-1683368 for
  discussion.

* The "Decimal" constructor now accepts leading and trailing
  whitespace when passed a string.  Previously it would raise an
  "InvalidOperation" exception.  On the other hand, the
  "create_decimal()" method of "Context" objects now explicitly
  disallows extra whitespace, raising a "ConversionSyntax" exception.

* Debido a un accidente de implementación, si se pasaba una ruta de
  archivo a la función incorporada "__import__()", ésta importaría
  realmente el archivo especificado.  Sin embargo, nunca se pretendió
  que esto funcionara, y la implementación ahora comprueba
  explícitamente este caso y lanza un "ImportError".

* API C: las funciones "PyImport_Import()" y "PyImport_ImportModule()"
  ahora se ajustan por defecto a importaciones absolutas, no a
  importaciones relativas. Esto afectará a las extensiones de C que
  importen otros módulos.

* API C: los tipos de datos de extensión que no deben ser hashable
  deben definir su ranura "tp_hash" a "PyObject_HashNotImplemented()".

* The "socket" module exception "socket.error" now inherits from
  "IOError".  Previously it wasn't a subclass of "StandardError" but
  now it is, through "IOError". (Implemented by Gregory P. Smith;
  bpo-1706815.)

* The "xmlrpclib" module no longer automatically converts
  "datetime.date" and "datetime.time" to the "xmlrpclib.DateTime"
  type; the conversion semantics were not necessarily correct for all
  applications.  Code using "xmlrpclib" should convert "date" and
  "time" instances. (bpo-1330538)

* (Modo de advertencia 3.0) La clase "Exception" ahora advierte cuando
  se accede utilizando el acceso a la rebanada o al índice; tener
  "Exception" se comporta como una tupla está siendo eliminado.

* (modo de advertencia 3.0) las comparaciones de desigualdad entre dos
  diccionarios o dos objetos que no implementan métodos de comparación
  se reportan como advertencias.  "dict1 == dict2" sigue funcionando,
  pero "dict1 < dict2" está siendo eliminado.

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

Para aplicaciones que incorporan Python:

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


Agradecimientos
===============

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