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

Autor:
   A.M. Kuchling


Introducción
============

Este artículo explica las nuevas características de Python 2.1. Aunque
no hay tantos cambios en 2.1 como en Python 2.0, todavía hay algunas
sorpresas agradables. La versión 2.1 es la primera que se dirige
mediante el uso de Propuestas de Mejora de Python, o PEPs, por lo que
la mayoría de los cambios importantes tienen PEPs adjuntos que
proporcionan una documentación más completa y una justificación de
diseño para el cambio. Este artículo no intenta documentar las nuevas
características por completo, sino que simplemente proporciona una
visión general de las nuevas características para los programadores de
Python. Consulta la documentación de Python 2.1, o el PEP específico,
para obtener más detalles sobre cualquier nueva característica que te
interese particularmente.

Un objetivo reciente del equipo de desarrollo de Python ha sido
acelerar el ritmo de las nuevas versiones, con una nueva versión cada
6 a 9 meses. La versión 2.1 es la primera que sale a este ritmo más
rápido, con la primera alfa que apareció en enero, 3 meses después de
que se publicara la versión final de la 2.0.

La versión final de Python 2.1 se realizó el 17 de abril de 2001.


PEP 227: Ámbitos anidados
=========================

El mayor cambio en Python 2.1 es el de las reglas de alcance de
Python. En Python 2.0, en cualquier momento hay como máximo tres
espacios de nombres utilizados para buscar nombres de variables:
local, a nivel de módulo y el espacio de nombres incorporado. Esto a
menudo sorprendía a la gente porque no coincidía con sus expectativas
intuitivas. Por ejemplo, una definición de función recursiva anidada
no funciona:

   def f():
       ...
       def g(value):
           ...
           return g(value-1) + 1
       ...

The function "g()" will always raise a "NameError" exception, because
the binding of the name "g" isn't in either its local namespace or in
the module-level namespace.  This isn't much of a problem in practice
(how often do you recursively define interior functions like this?),
but this also made using the "lambda" expression clumsier, and this
was a problem in practice. In code which uses "lambda" you can often
find local variables being copied by passing them as the default
values of arguments.

   def find(self, name):
       "Return list of any entries equal to 'name'"
       L = filter(lambda x, name=name: x == name,
                  self.list_attribute)
       return L

La legibilidad del código Python escrito en un estilo fuertemente
funcional sufre mucho como resultado.

El cambio más significativo de Python 2.1 es que se ha añadido al
lenguaje el ámbito estático para solucionar este problema. Como primer
efecto, el argumento por defecto "name=name" es ahora innecesario en
el ejemplo anterior. En pocas palabras, cuando a un nombre de variable
dado no se le asigna un valor dentro de una función (mediante una
asignación, o las sentencias "def", "class", o "import"), las
referencias a la variable se buscarán en el espacio de nombres local
del ámbito que la rodea. Puede encontrar una explicación más detallada
de las reglas y una disección de la implementación en el PEP.

Este cambio puede causar algunos problemas de compatibilidad para el
código en el que el mismo nombre de variable se utiliza tanto a nivel
de módulo como de variable local dentro de una función que contiene
otras definiciones de función. Sin embargo, esto parece bastante
improbable, ya que dicho código habría sido bastante confuso de leer
en primer lugar.

Un efecto secundario del cambio es que las sentencias "from module
import *" y "exec" se han hecho ilegales dentro del ámbito de una
función bajo ciertas condiciones. El manual de referencia de Python ha
dicho todo el tiempo que "from module import *" sólo es legal en el
nivel superior de un módulo, pero el intérprete de CPython nunca ha
aplicado esto antes. Como parte de la implementación de los ámbitos
anidados, el compilador que convierte el código fuente de Python en
bytecodes tiene que generar un código diferente para acceder a las
variables de un ámbito contenedor. Los códigos "from module import *"
y "exec" hacen que el compilador no pueda averiguar esto, porque
añaden nombres al espacio de nombres local que son desconocidos en
tiempo de compilación. Por lo tanto, si una función contiene
definiciones de funciones o expresiones "lambda" con variables libres,
el compilador lo señalará lanzando una excepción "SyntaxError".

Para que la explicación anterior quede un poco más clara, he aquí un
ejemplo:

   x = 1
   def f():
       # The next line is a syntax error
       exec 'x=2'
       def g():
           return x

Line 4 containing the "exec" statement is a syntax error, since "exec"
would define a new local variable named "x" whose value should be
accessed by "g()".

Esto no debería ser una gran limitación, ya que "exec" rara vez se
utiliza en la mayoría del código de Python (y cuando se utiliza, a
menudo es un signo de un mal diseño de todos modos).

Los problemas de compatibilidad han llevado a que los ámbitos anidados
se introduzcan gradualmente; en Python 2.1, no están habilitados por
defecto, pero pueden activarse dentro de un módulo utilizando una
sentencia future como se describe en **PEP 236**. (En Python 2.2, los
ámbitos anidados se convertirán en el valor por defecto y no habrá
forma de desactivarlos, pero los usuarios habrán tenido toda la vida
de la versión 2.1 para arreglar cualquier rotura resultante de su
introducción.

Ver también:

  **PEP 227** - Ámbitos anidados estáticamente
     Escrito e implementado por Jeremy Hylton.


PEP 236: Directivas __future__
==============================

La reacción a los ámbitos anidados fue una preocupación generalizada
sobre los peligros de romper el código con la versión 2.1, y fue lo
suficientemente fuerte como para que los Pythonistas adoptaran un
enfoque más conservador. Este enfoque consiste en introducir una
convención para habilitar una funcionalidad opcional en la versión N
que se convertirá en obligatoria en la versión N+1.

La sintaxis utiliza una sentencia "from...import" utilizando el nombre
de módulo reservado "__future__". Los ámbitos anidados pueden
habilitarse mediante la siguiente sentencia:

   from __future__ import nested_scopes

Aunque parece una sentencia "import" normal, no lo es; hay reglas
estrictas sobre dónde se puede poner una sentencia future. Sólo pueden
estar en la parte superior de un módulo, y deben preceder a cualquier
código Python o a las sentencias "import" normales. Esto se debe a que
tales declaraciones pueden afectar a la forma en que el compilador de
código de bytes de Python analiza el código y genera el código de
bytes, por lo que deben preceder a cualquier declaración que dé lugar
a la producción de códigos de bytes.

Ver también:

  **PEP 236** - De vuelta al "__future__"
     Escrito por Tim Peters, y ejecutado principalmente por Jeremy
     Hylton.


PEP 207: Comparaciones Enriquecidas
===================================

In earlier versions, Python's support for implementing comparisons on
user-defined classes and extension types was quite simple. Classes
could implement a "__cmp__()" method that was given two instances of a
class, and could only return 0 if they were equal or +1 or -1 if they
weren't; the method couldn't raise an exception or return anything
other than a Boolean value.  Users of Numeric Python often found this
model too weak and restrictive, because in the number-crunching
programs that numeric Python is used for, it would be more useful to
be able to perform elementwise comparisons of two matrices, returning
a matrix containing the results of a given comparison for each
element.  If the two matrices are of different sizes, then the compare
has to be able to raise an exception to signal the error.

En Python 2.1, se añadieron comparaciones enriquecidas para dar
soporte a esta necesidad. Las clases de Python pueden ahora
sobrecargar individualmente cada una de las operaciones "<", "<=",
">", ">=", "==" y "!=". Los nuevos nombres de métodos mágicos son:

+-------------+--------------------------+
| Operación   | Nombre del método        |
|=============|==========================|
| "<"         | "__lt__()"               |
+-------------+--------------------------+
| "<="        | "__le__()"               |
+-------------+--------------------------+
| ">"         | "__gt__()"               |
+-------------+--------------------------+
| ">="        | "__ge__()"               |
+-------------+--------------------------+
| "=="        | "__eq__()"               |
+-------------+--------------------------+
| "!="        | "__ne__()"               |
+-------------+--------------------------+

(Los métodos mágicos se denominan como los correspondientes operadores
de Fortran ".LT.". ".LE.", &c. Los programadores numéricos están casi
seguramente bastante familiarizados con estos nombres y los
encontrarán fáciles de recordar.)

Cada uno de estos métodos mágicos tiene la forma "method(self,
other)", donde "self" será el objeto que se encuentre en el lado
izquierdo del operador, mientras que "other" será el objeto que se
encuentre en el lado derecho. Por ejemplo, la expresión "A < B" hará
que se llame a "A.__lt__(B)".

Cada uno de estos métodos mágicos puede retornar cualquier cosa: un
booleano, una matriz, una lista o cualquier otro objeto de Python.
También pueden lanzar una excepción si la comparación es imposible,
inconsistente o no tiene sentido.

The built-in "cmp(A,B)" function can use the rich comparison
machinery, and now accepts an optional argument specifying which
comparison operation to use; this is given as one of the strings
""<"", ""<="", "">"", "">="", ""=="", or ""!="".  If called without
the optional third argument, "cmp()" will only return -1, 0, or +1 as
in previous versions of Python; otherwise it will call the appropriate
method and can return any Python object.

También hay cambios correspondientes de interés para los programadores
de C; hay una nueva ranura "tp_richcmp" en los objetos de tipo y una
API para realizar una comparación rica determinada. No cubrirá la API
de C aquí, sino que le remitiré a **PEP 207**, o a la documentación de
la API de C de 2.1, para la lista completa de funciones relacionadas.

Ver también:

  **PEP 207** - Comparaciones enriquecidas
     Escrito por Guido van Rossum, basado en gran medida en un trabajo
     anterior de David Ascher, e implementado por Guido van Rossum.


PEP 230: Marco de advertencia
=============================

A lo largo de sus 10 años de existencia, Python ha acumulado un cierto
número de módulos y características obsoletas en el camino. Es difícil
saber cuándo es seguro eliminar una característica, ya que no hay
manera de saber cuánto código la utiliza --- tal vez ningún programa
depende de la característica, o tal vez muchos lo hacen. Para permitir
la eliminación de características antiguas de una manera más
estructurada, se añadió un marco de advertencia. Cuando los
desarrolladores de Python quieran deshacerse de una característica,
primero se activará una advertencia en la siguiente versión de Python.
La siguiente versión de Python puede entonces eliminar la
característica, y los usuarios habrán tenido un ciclo de lanzamiento
completo para eliminar los usos de la antigua característica.

Python 2.1 añade el marco de trabajo de las advertencias para ser
utilizado en este esquema. Añade un módulo "warnings" que proporciona
funciones para emitir advertencias, y para filtrar las advertencias
que no se quieren mostrar. Los módulos de terceros también pueden
utilizar este marco de trabajo para dejar de lado funciones antiguas
que ya no desean soportar.

For example, in Python 2.1 the "regex" module is deprecated, so
importing it causes a warning to be printed:

   >>> import regex
   __main__:1: DeprecationWarning: the regex module
            is deprecated; please use the re module
   >>>

Las advertencias se pueden emitir llamando a la función
"warnings.warn()":

   warnings.warn("feature X no longer supported")

El primer parámetro es el mensaje de advertencia; se pueden utilizar
otros parámetros opcionales para especificar una categoría de
advertencia concreta.

Filters can be added to disable certain warnings; a regular expression
pattern can be applied to the message or to the module name in order
to suppress a warning.  For example, you may have a program that uses
the "regex" module and not want to spare the time to convert it to use
the "re" module right now.  The warning can be suppressed by calling

   import warnings
   warnings.filterwarnings(action = 'ignore',
                           message='.*regex module is deprecated',
                           category=DeprecationWarning,
                           module = '__main__')

This adds a filter that will apply only to warnings of the class
"DeprecationWarning" triggered in the "__main__" module, and applies a
regular expression to only match the message about the "regex" module
being deprecated, and will cause such warnings to be ignored.
Warnings can also be printed only once, printed every time the
offending code is executed, or turned into exceptions that will cause
the program to stop (unless the exceptions are caught in the usual
way, of course).

También se agregaron funciones a la API de C de Python para emitir
advertencias; consulte el PEP 230 o la documentación de la API de
Python para conocer los detalles.

Ver también:

  **PEP 5** - Directrices para la evolución del lenguaje
     Escrito por Paul Prescod, para especificar los procedimientos a
     seguir cuando se eliminan características antiguas de PythonLa
     política descrita en este PEP no ha sido adoptada oficialmente,
     pero la política final probablemente no será muy diferente de la
     propuesta de Prescod.

  **PEP 230** - Marco de advertencia
     Escrito y ejecutado por Guido van Rossum.


PEP 229: Sistema de construcción nuevo
======================================

Al compilar Python, el usuario tenía que entrar y editar el archivo
"Modules/Setup" para habilitar varios módulos adicionales; el conjunto
por defecto es relativamente pequeño y se limita a los módulos que se
compilan en la mayoría de las plataformas Unix. Esto significa que en
plataformas Unix con muchas más características, sobre todo Linux, las
instalaciones de Python no suelen contener todos los módulos útiles
que podrían.

Python 2.0 añadió los Distutils, un conjunto de módulos para
distribuir e instalar extensiones. En Python 2.1, los Distutils se
utilizan para compilar gran parte de la biblioteca estándar de módulos
de extensión, autodetectando cuáles son compatibles con la máquina
actual Se espera que esto haga que las instalaciones de Python sean
más fáciles y tengan más funciones.

En lugar de tener que editar el archivo "Modules/Setup" para habilitar
los módulos, un script "setup.py" en el directorio superior de la
distribución de fuentes de Python se ejecuta en el momento de la
compilación, e intenta descubrir qué módulos pueden ser habilitados
examinando los módulos y archivos de cabecera en el sistema. Si un
módulo está configurado en "Modules/Setup", el script "setup.py" no
intentará compilar ese módulo y se remitirá al contenido del archivo
"Modules/Setup". Esto proporciona una manera de especificar cualquier
flag de línea de comandos extraña o bibliotecas que se requieren para
una plataforma específica.

En otro cambio de gran alcance en el mecanismo de construcción, Neil
Schemenauer reestructuró las cosas para que Python ahora utilice un
único makefile que no es recursivo, en lugar de makefiles en el
directorio superior y en cada uno de los subdirectorios "Python/",
"Parser/", "Objects/", y "Modules/". Esto hace que la construcción de
Python sea más rápida y también hace que el hackeo de los Makefiles
sea más claro y sencillo.

Ver también:

  **PEP 229** - Uso de Distutils para construir Python
     Escrito y ejecutado por A.M. Kuchling.


PEP 205: Referencias débiles
============================

Las referencias débiles, disponibles a través del módulo "weakref",
son un nuevo tipo de datos menor pero útil en la caja de herramientas
del programador de Python.

Almacenar una referencia a un objeto (por ejemplo, en un diccionario o
una lista) tiene el efecto secundario de mantener ese objeto vivo para
siempre. Hay algunos casos específicos en los que este comportamiento
es indeseable, siendo las cachés de objetos el más común, y otro son
las referencias circulares en estructuras de datos como los árboles.

Por ejemplo, considere una función de memoización que almacena en
caché los resultados de otra función "f(x)" almacenando el argumento
de la función y su resultado en un diccionario:

   _cache = {}
   def memoize(x):
       if _cache.has_key(x):
           return _cache[x]

       retval = f(x)

       # Cache the returned object
       _cache[x] = retval

       return retval

This version works for simple things such as integers, but it has a
side effect; the "_cache" dictionary holds a reference to the return
values, so they'll never be deallocated until the Python process exits
and cleans up. This isn't very noticeable for integers, but if "f()"
returns an object, or a data structure that takes up a lot of memory,
this can be a problem.

Las referencias débiles proporcionan una forma de implementar una
caché que no mantendrá los objetos vivos más allá de su tiempo. Si un
objeto sólo es accesible a través de referencias débiles, el objeto
será desasignado y las referencias débiles indicarán ahora que el
objeto al que se refería ya no existe. Una referencia débil a un
objeto *obj* se crea llamando "wr = weakref.ref(obj)". El objeto al
que se hace referencia se retorna llamando a la referencia débil como
si fuera una función: "wr()" retornará el objeto referenciado, o
"None" si el objeto ya no existe.

This makes it possible to write a "memoize()" function whose cache
doesn't keep objects alive, by storing weak references in the cache.

   _cache = {}
   def memoize(x):
       if _cache.has_key(x):
           obj = _cache[x]()
           # If weak reference object still exists,
           # return it
           if obj is not None: return obj

       retval = f(x)

       # Cache a weak reference
       _cache[x] = weakref.ref(retval)

       return retval

The "weakref" module also allows creating proxy objects which behave
like weak references --- an object referenced only by proxy objects is
deallocated -- but instead of requiring an explicit call to retrieve
the object, the proxy transparently forwards all operations to the
object as long as the object still exists.  If the object is
deallocated, attempting to use a proxy will cause a
"weakref.ReferenceError" exception to be raised.

   proxy = weakref.proxy(obj)
   proxy.attr   # Equivalent to obj.attr
   proxy.meth() # Equivalent to obj.meth()
   del obj
   proxy.attr   # raises weakref.ReferenceError

Ver también:

  **PEP 205** - Referencias débiles
     Escrito e implementado por Fred L. Drake, Jr.


PEP 232: Atributos de la función
================================

In Python 2.1, functions can now have arbitrary information attached
to them. People were often using docstrings to hold information about
functions and methods, because the "__doc__" attribute was the only
way of attaching any information to a function.  For example, in the
Zope web application server, functions are marked as safe for public
access by having a docstring, and in John Aycock's SPARK parsing
framework, docstrings hold parts of the BNF grammar to be parsed.
This overloading is unfortunate, since docstrings are really intended
to hold a function's documentation; for example, it means you can't
properly document functions intended for private use in Zope.

Ahora se pueden establecer y recuperar atributos arbitrarios en las
funciones utilizando la sintaxis normal de Python:

   def f(): pass

   f.publish = 1
   f.secure = 1
   f.grammar = "A ::= B (C D)*"

The dictionary containing attributes can be accessed as the function's
"__dict__". Unlike the "__dict__" attribute of class instances, in
functions you can actually assign a new dictionary to "__dict__",
though the new value is restricted to a regular Python dictionary; you
*can't* be tricky and set it to a "UserDict" instance, or any other
random object that behaves like a mapping.

Ver también:

  **PEP 232** - Atributos de la función
     Escrito y ejecutado por Barry Warsaw.


PEP 235: Importación de módulos en plataformas que no distinguen entre mayúsculas y minúsculas
==============================================================================================

Algunos sistemas operativos tienen sistemas de archivos que no
distinguen entre mayúsculas y minúsculas, siendo MacOS y Windows los
principales ejemplos; en estos sistemas, es imposible distinguir los
nombres de archivo "FILE.PY" y "file.py", aunque almacenan el nombre
del archivo en su caso original (también preservan las mayúsculas).

En Python 2.1, la sentencia "import" funcionará para simular la
distinción entre mayúsculas y minúsculas en plataformas que no las
distinguen. Python buscará ahora la primera coincidencia entre
mayúsculas y minúsculas por defecto, lanzando un "ImportError" si no
se encuentra dicho fichero, por lo que "import file" no importará un
módulo llamado "FILE.PY". La coincidencia insensible a mayúsculas y
minúsculas puede solicitarse estableciendo la variable de entorno
"PYTHONCASEOK" antes de iniciar el intérprete de Python.


PEP 217: Gancho de pantalla interactivo
=======================================

Cuando se utiliza el intérprete de Python de forma interactiva, la
salida de los comandos se muestra utilizando la función incorporada
"repr()". En Python 2.1, la variable "sys.displayhook()" puede
establecerse a un objeto invocable que será llamado en lugar de
"repr()". Por ejemplo, puede establecerla a una función especial de
impresión bonita:

   >>> # Create a recursive data structure
   ... L = [1,2,3]
   >>> L.append(L)
   >>> L # Show Python's default output
   [1, 2, 3, [...]]
   >>> # Use pprint.pprint() as the display function
   ... import sys, pprint
   >>> sys.displayhook = pprint.pprint
   >>> L
   [1, 2, 3,  <Recursion on list with id=135143996>]
   >>>

Ver también:

  **PEP 217** - Gancho de visualización para uso interactivo
     Escrito y ejecutado por Moshe Zadka.


PEP 208: Nuevo modelo de coerción
=================================

Se ha modificado significativamente la forma en que se realiza la
coerción numérica a nivel de C. Esto sólo afectará a los autores de
las extensiones de C a Python, permitiéndoles más flexibilidad a la
hora de escribir tipos de extensión que soporten operaciones
numéricas.

Los tipos de extensión pueden ahora establecer el indicador de tipo
"Py_TPFLAGS_CHECKTYPES" en su estructura "PyTypeObject" para indicar
que soportan el nuevo modelo de coerción. En tales tipos de extensión,
las funciones numéricas de ranura ya no pueden asumir que se les
pasarán dos argumentos del mismo tipo; en su lugar, se les pueden
pasar dos argumentos de tipos diferentes, y entonces pueden realizar
su propia coerción interna. Si a la función de ranura se le pasa un
tipo que no puede manejar, puede indicar el fallo retornando una
referencia al valor singleton "Py_NotImplemented". Las funciones
numéricas del otro tipo serán entonces probadas, y quizás puedan
manejar la operación; si el otro tipo también retorna
"Py_NotImplemented", entonces se levantará un "TypeError`Los métodos
numéricos escritos en Python también pueden retornar
``Py_NotImplemented`", haciendo que el intérprete actúe como si el
método no existiera (tal vez lanzando un "TypeError", tal vez probando
los métodos numéricos de otro objeto).

Ver también:

  **PEP 208** - Reformulación del modelo de coerción
     Escrito e implementado por Neil Schemenauer, basado en gran
     medida en el trabajo anterior de Marc-André Lemburg. Léalo para
     entender los puntos finos de cómo las operaciones numéricas serán
     ahora procesadas en el nivel C.


PEP 241: Metadatos en paquetes de Python
========================================

Una queja común de los usuarios de Python es que no existe un solo
catálogo de todos los módulos de Python existentes.  T. Middleton's
Vault of Parnassus en "www.vex.net/parnassus/" (borrado en febrero de
2009, disponible en Internet Archive Wayback Machine) fue uno de los
mayores catálogos de módulos de Python, pero registrar software en los
archivos es opcional, y a mucha gente no le importó.

Como primer pequeño paso para solucionar el problema, el software de
Python empaquetado con el comando **sdist** de Distutils incluirá un
archivo llamado "PKG-INFO" que contiene información sobre el paquete,
como su nombre, versión y autor (metadatos, en terminología de
catalogación). **PEP 241** contiene la lista completa de campos que
pueden estar presentes en el archivo "PKG-INFO`A medida que la gente
empiece a empaquetar su software usando Python 2.1, más y más paquetes
incluirán metadatos, haciendo posible construir sistemas de
catalogación automatizados y experimentar con ellosCon la experiencia
resultante, tal vez sea posible diseñar un catálogo realmente bueno y
luego construir soporte para él en Python 2.2. Por ejemplo, los
comandos Distutils :command:`sdist" y **bdist_*** podrían soportar una
opción "upload" que subiera automáticamente tu paquete a un servidor
de catálogos.

Puedes empezar a crear paquetes que contengan "PKG-INFO" incluso si no
estás usando Python 2.1, ya que se hará una nueva versión de las
Distutils para los usuarios de versiones anteriores de PythonLa
versión 1.0.2 de las Distutils incluye los cambios descritos en **PEP
241**, así como varias correcciones de errores y mejoras. Estará
disponible en el SIG de Distutils en
https://www.python.org/community/sigs/current/distutils-sig/.

Ver también:

  **PEP 241** - Metadatos para paquetes de software de Python
     Escrito y ejecutado por A.M. Kuchling.

  **PEP 243** - Mecanismo de carga del repositorio de módulos
     Escrito por Sean Reifschneider, este borrador de PEP describe un
     mecanismo propuesto para subir paquetes de Python a un servidor
     central.


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

* Ka-Ping Yee contributed two new modules: "inspect.py", a module for
  getting information about live Python code, and "pydoc.py", a module
  for interactively converting docstrings to HTML or text.  As a
  bonus, "Tools/scripts/pydoc", which is now automatically installed,
  uses "pydoc.py" to display documentation given a Python module,
  package, or class name.  For example, "pydoc xml.dom" displays the
  following:

     Python Library Documentation: package xml.dom in xml

     NAME
         xml.dom - W3C Document Object Model implementation for Python.

     FILE
         /usr/local/lib/python2.1/xml/dom/__init__.pyc

     DESCRIPTION
         The Python mapping of the Document Object Model is documented in the
         Python Library Reference in the section on the xml.dom package.

         This package contains the following modules:
           ...

  "pydoc" también incluye un navegador de ayuda interactiva basado en
  Tk. "pydoc" se vuelve rápidamente adictivo; ¡pruébalo!

* Two different modules for unit testing were added to the standard
  library. The "doctest" module, contributed by Tim Peters, provides a
  testing framework based on running embedded examples in docstrings
  and comparing the results against the expected output.  PyUnit,
  contributed by Steve Purcell, is a unit testing framework inspired
  by JUnit, which was in turn an adaptation of Kent Beck's Smalltalk
  testing framework.  See https://pyunit.sourceforge.net/ for more
  information about PyUnit.

* The "difflib" module contains a class, "SequenceMatcher", which
  compares two sequences and computes the changes required to
  transform one sequence into the other.  For example, this module can
  be used to write a tool similar to the Unix **diff** program, and in
  fact the sample program "Tools/scripts/ndiff.py" demonstrates how to
  write such a script.

* "curses.panel", una envoltura para la biblioteca de paneles, parte
  de ncurses y de curses SYSV, fue contribuida por Thomas Gellekum. La
  biblioteca de paneles proporciona ventanas con la característica
  adicional de la profundidad. Las ventanas pueden ser movidas más
  arriba o más abajo en el ordenamiento de la profundidad, y la
  librería de paneles calcula dónde se superponen los paneles y qué
  secciones son visibles.

* The PyXML package has gone through a few releases since Python 2.0,
  and Python 2.1 includes an updated version of the "xml" package.
  Some of the noteworthy changes include support for Expat 1.2 and
  later versions, the ability for Expat parsers to handle files in any
  encoding supported by Python, and various bugfixes for SAX, DOM, and
  the "minidom" module.

* Ping también contribuyó con otro gancho para manejar excepciones no
  detectadas. "sys.excepthook()" se puede configurar como un objeto
  invocable. Cuando una excepción no es detectada por ningún bloque
  "try"..."except", la excepción se pasará a "sys.excepthook()", que
  puede hacer lo que quiera. En la Novena Conferencia de Python, Ping
  demostró una aplicación para este gancho: imprimir un rastreo
  extendido que no solo enumera los marcos de la pila, sino que
  también enumera los argumentos de la función y las variables locales
  para cada marco.

* Various functions in the "time" module, such as "asctime()" and
  "localtime()", require a floating point argument containing the time
  in seconds since the epoch.  The most common use of these functions
  is to work with the current time, so the floating point argument has
  been made optional; when a value isn't provided, the current time
  will be used.  For example, log file entries usually need a string
  containing the current time; in Python 2.1, "time.asctime()" can be
  used, instead of the lengthier
  "time.asctime(time.localtime(time.time()))" that was previously
  required.

  Este cambio fue propuesto y aplicado por Thomas Wouters.

* El módulo "ftplib" ahora recupera por defecto los ficheros en modo
  pasivo, porque es más probable que el modo pasivo funcione desde
  detrás de un cortafuegos. Esta petición vino del sistema de
  seguimiento de errores de Debian, ya que otros paquetes de Debian
  utilizan "ftplib" para recuperar archivos y entonces no funcionan
  desde detrás de un cortafuegos. Se considera poco probable que esto
  cause problemas a nadie, porque Netscape utiliza por defecto el modo
  pasivo y poca gente se queja, pero si el modo pasivo no es adecuado
  para su aplicación o configuración de red, llame a "set_pasv(0)" en
  los objetos FTP para desactivar el modo pasivo.

* Se ha añadido soporte para el acceso a sockets sin procesar en el
  módulo "socket", aportado por Grant Edwards.

* El módulo "pstats" contiene ahora un sencillo navegador de
  estadísticas interactivo para mostrar los perfiles de tiempo de los
  programas de Python, invocado cuando el módulo se ejecuta como un
  script. Contribuido por Eric S. Raymond.

* Se ha agregado una nueva función dependiente de la implementación,
  "sys._getframe([depth])", para devolver un objeto de marco
  determinado de la pila de llamadas actual. "sys._getframe()"
  devuelve el marco en la parte superior de la pila de llamadas; si el
  argumento de entero opcional *depth* is supplied, the function
  returns the frame that is *depth* llama debajo de la parte superior
  de la pila. Por ejemplo, "sys._getframe(1)" devuelve el objeto de
  trama de la persona que llama.

  Esta función sólo está presente en CPython, no en Jython ni en la
  implementación de .NET. Utilízala para depurar, y resiste la
  tentación de ponerla en el código de producción.


Otros cambios y correcciones
============================

En Python 2.1 se hicieron relativamente pocos cambios pequeños debido
al ciclo de publicación más corto. Una búsqueda en los registros de
cambios de CVS muestra 117 parches aplicados y 136 errores corregidos;
es probable que ambas cifras estén subestimadas. Algunos de los
cambios más notables son:

* A specialized object allocator is now optionally available, that
  should be faster than the system "malloc()" and have less memory
  overhead.  The allocator uses C's "malloc()" function to get large
  pools of memory, and then fulfills smaller memory requests from
  these pools.  It can be enabled by providing the "--with-pymalloc"
  option to the **configure** script; see "Objects/obmalloc.c" for the
  implementation details.

  Authors of C extension modules should test their code with the
  object allocator enabled, because some incorrect code may break,
  causing core dumps at runtime. There are a bunch of memory
  allocation functions in Python's C API that have previously been
  just aliases for the C library's "malloc()" and "free()", meaning
  that if you accidentally called mismatched functions, the error
  wouldn't be noticeable.  When the object allocator is enabled, these
  functions aren't aliases of "malloc()" and "free()" any more, and
  calling the wrong function to free memory will get you a core dump.
  For example, if memory was allocated using "PyMem_New", it has to be
  freed using "PyMem_Del()", not "free()".  A few modules included
  with Python fell afoul of this and had to be fixed; doubtless there
  are more third-party modules that will have the same problem.

  El asignador de objetos fue aportado por Vladimir Marangozov.

* The speed of line-oriented file I/O has been improved because people
  often complain about its lack of speed, and because it's often been
  used as a naïve benchmark.  The "readline()" method of file objects
  has therefore been rewritten to be much faster.  The exact amount of
  the speedup will vary from platform to platform depending on how
  slow the C library's "getc()" was, but is around 66%, and
  potentially much faster on some particular operating systems. Tim
  Peters did much of the benchmarking and coding for this change,
  motivated by a discussion in comp.lang.python.

  A new module and method for file objects was also added, contributed
  by Jeff Epler. The new method, "xreadlines()", is similar to the
  existing "xrange()" built-in.  "xreadlines()" returns an opaque
  sequence object that only supports being iterated over, reading a
  line on every iteration but not reading the entire file into memory
  as the existing "readlines()" method does. You'd use it like this:

     for line in sys.stdin.xreadlines():
         # ... do something for each line ...
         ...

  Para una discusión más completa de los cambios en la línea de E/S,
  véase el resumen de python-dev del 1 al 15 de enero de 2001 en
  https://mail.python.org/pipermail/python-dev/2001-January/.

* A new method, "popitem()", was added to dictionaries to enable
  destructively iterating through the contents of a dictionary; this
  can be faster for large dictionaries because there's no need to
  construct a list containing all the keys or values. "D.popitem()"
  removes a random "(key, value)" pair from the dictionary "D" and
  returns it as a 2-tuple.  This was implemented mostly by Tim Peters
  and Guido van Rossum, after a suggestion and preliminary patch by
  Moshe Zadka.

* Ahora los módulos pueden controlar qué nombres se importan cuando se
  utiliza "from module import *", definiendo un atributo "__all__" que
  contiene una lista de nombres que se importarán. Una queja común es
  que si el módulo importa otros módulos como "sys" o "string", "from
  module import *" los añadirá al espacio de nombres del módulo
  importador. Para arreglar esto, simplemente liste los nombres
  públicos en "__all__":

     # List public names
     __all__ = ['Database', 'open']

  Una versión más estricta de este parche fue primero sugerida e
  implementada por Ben Wolfson, pero después de algunas discusiones de
  python-dev, una versión final más débil fue revisada.

* Al aplicar "repr()" a las cadenas, antes se utilizaban escapes
  octales para los caracteres no imprimibles; por ejemplo, una nueva
  línea era "'\012'". Esto era un vestigio de la ascendencia de Python
  en C, pero hoy en día el octal tiene muy poco uso práctico. Ka-Ping
  Yee sugirió usar escapes hexadecimales en lugar de octales, y usar
  los escapes "\n", "\t", "\r" para los caracteres apropiados, e
  implementó este nuevo formato.

* Los errores de sintaxis detectados en tiempo de compilación pueden
  ahora lanzar excepciones que contienen el nombre del archivo y el
  número de línea del error, un agradable efecto secundario de la
  reorganización del compilador realizada por Jeremy Hylton.

* C extensions which import other modules have been changed to use
  "PyImport_ImportModule()", which means that they will use any import
  hooks that have been installed.  This is also encouraged for third-
  party extensions that need to import some other module from C code.

* El tamaño de la base de datos de caracteres Unicode se redujo en
  otros 340K gracias a Fredrik Lundh.

* Se han aportado algunos puertos nuevos: MacOS X (por Steven
  Majewski), Cygwin (por Jason Tishler); RISCOS (por Dietmar
  Schwertberger); Unixware 7 (por Billy G. Allie).

Y hay la lista habitual de correcciones de errores menores, fugas de
memoria menores, ediciones de docstrings, y otros ajustes, demasiado
largos para que valga la pena detallarlos; vea los registros de CVS
para los detalles completos si los quiere.


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

El autor desea agradecer a las siguientes personas sus sugerencias
sobre varios borradores de este artículo: Graeme Cross, David Goodger,
Jay Graves, Michael Hudson, Marc-André Lemburg, Fredrik Lundh, Neil
Schemenauer, Thomas Wouters.
