# Qué hay de nuevo en Python 2.4

Autor:

  A.M. Kuchling

Este artículo explica las nuevas funcionalidades en Python 2.4.1 lanzadas el 30 de marzo de 2005.

Python 2.4 es un lanzamiento de término medio. Esto significa que no se han introducido grandes cambios como en la versión 2.2 de Python pero si son más significativas que la versión 2.3. Lo más relevante de estas nuevas funcionalidades son los decoradores y generadores de expresiones, la mayor parte del resto de los cambios son a la librería estándar.

De acuerdo al registro de cambios CVS , han sido aplicados 481 parches y 502 bugs han sido corregidos entre las versiones 2.3 y 2.4 de Python. Es posible que ambas cifras no concuerden con la realidad, podrían estar subestimadas.

Este artículo no pretende proveer una especificación completa y detallada de cada funcionalidad nueva, en vez de esto, se provee una breve descripción de las nuevas características. Para obtener más información se debe consultar la documentación oficial de Python 2.4, tal como la librería de referencia de Python y el manual de referencia de Python. Otra fuente de información es PEP (guía de estilo-mejoras de python) para buscar información sobre la implementación y fundamentación del diseño.

## PEP 218: Objetos conjunto integrados

Python 2.3 introduced the `sets` module. C implementations of set data types have now been added to the Python core as two new built-in types, `set(iterable)` and `frozenset(iterable)`. They provide high speed operations for membership testing, for eliminating duplicates from sequences, and for mathematical operations like unions, intersections, differences, and symmetric differences.

    >>> a = set('abracadabra') # formar un conjunto a partir de una cadena
    >>> 'z' en a # prueba rápida de pertenencia
    Falso
    >>> a # letras únicas en a
    set(['a', 'r', 'b', 'c', 'd'])
    >>> ''.join(a) # convertir de nuevo a una cadena
    'arbcd'

    >>> b = set('alacazam') # formar un segundo conjunto
    >>> a - b # letras en a pero no en b
    set(['r', 'd', 'b'])
    >>> a | b # letras en a o b
    set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
    >>> a & b # letras en a y b
    set(['a', 'c'])
    >>> a ^ b # letras en a o b pero no en ambos
    set(['r', 'd', 'b', 'm', 'z', 'l'])

    >>> a.add('z') # agrega un nuevo elemento
    >>> a.update('wxy') # agrega varios elementos nuevos
    >>> a
    set(['a', 'c', 'b', 'd', 'r', 'w', 'y', 'x', 'z'])
    >>> a.remove('x') # saca un elemento
    >>> a
    set(['a', 'c', 'b', 'd', 'r', 'w', 'y', 'z'])

La función de conjuntos integrados `frozenset()` es una versión inmutable de `set()`. Como es inmutable y hashable (su valor no cambia), se puede usar como una llave de diccionario o como parte de otro set.

The `sets` module remains in the standard library, and may be useful if you wish to subclass the `Set` or `ImmutableSet` classes. There are currently no plans to deprecate the module.

Ver también

PEP 218 - Agregando tipo de objeto integrado set

  Originalmente propuesto por Greg Wilson e implementado finalmente por Raymond Hettinger.

## PEP 237: Unificando enteros largos y enteros

El prolongado proceso de transición para este PEP que comenzó en Python 2.2 ha dado un paso más adelante en Python 2.4. En la versión 2.3 ciertas operaciones de enteros podían comportarse diferente después de lanzar la unificación del tipo de dato int-long entregando alertas `FutureWarning` y retornando valores limitados a 32 o 64 bits dependiendo de su plataforma. En la versión 2.4 estas expresiones ya no producen alertas y en vez de eso entrega un resultado diferente que suele ser un entero largo.

Las expresiones problemáticas son principalmente desplazamientos a la izquierda y constantes largas de hexadecimales y octales. Por ejemplo, `2 << 32` entrega una alerta en la versión 2.3 y evalúa 0 en plataformas 32-bit. Ahora en Python 2.4 la expresión retorna la respuesta correcta, 8589934592.

Ver también

PEP 237 - Unificando enteros largos y enteros

  PEP original escrito por Moshe Zadka y GvR. Los cambios a la versión 2.4 fueron implementados por Kalle Svensson.

## PEP 289: Expresiones generadoras

La función de iterador introducida en Python 2.2 y el módulo `itertools` facilitan la escritura de programas que recorren grandes conjuntos de datos sin tener todo el conjunto de datos en la memoria al mismo tiempo. Las listas de comprensión no encajan muy bien en esta imagen porque producen un objeto de lista de Python que contiene todos los elementos. Esto inevitablemente lleva todos los objetos a la memoria, lo que puede ser un problema si su conjunto de datos es muy grande. Al tratar de escribir un programa de estilo funcional, sería natural escribir algo como:

    links = [enlace para enlace en get_all_links() si no es link.followed]
    para enlace en enlaces:
    ...

en vez de

    para el enlace en get_all_links():
    si link.followed:
    continúa
    ...

La primera forma es mas concisa y quizás mas legible pero en caso de trabajar con un gran número largo de objetos podría ser necesario el escribir una segunda línea para evitar tener los objetos enlazados en memoria al mismo tiempo.

Las expresiones generadoras trabajan de forma similar a las listas por comprensión pero no materializan la lista completa, en vez de eso se crea un generador que retornará los elementos uno a uno. El siguiente ejemplo podría ser escrito como:

    links = (enlace para enlace en get_all_links() si no se sigue el enlace)
    para enlace en enlaces:
    ...

Los generadores de expresiones siempre tienen que ser escritos dentro de paréntesis como en el ejemplo descrito arriba. Los paréntesis señalan una llamada a la función que también se puede contar, entonces si se necesita crear un iterador que inmediatamente pasara a una función se podría escribir:

    imprimir suma(obj.count para obj en list_all_objects())

Las expresiones generadoras difieren de las listas de comprensión por pequeñas diferencias. La mas notable es que la variable del loop (obj en el ejemplo de arriba) no es accesible fuera de la expresión generadora. Las listas de comprensión dejan la variable asignada a su último valor, en versiones futuras de Python esto será cambiado en lo que respecta a hacer que las listas de comprensión coincidan con las expresiones de los generadores.

Ver también

PEP 289 - Expresiones generadoras

  Propuesto por Raymond Hettinger e implementada por Jiwon Seo con los primeros esfuerzos dirigidos por Hye-Shik Chang.

## PEP 292: Sustituciones simples de cadenas de caracteres

Algunas nuevas clases en la librería estándar proveen un mecanismo alternativo para sustituir variables dentro de cadenas de caracteres, este estilo de sustituciones puede ser mejor por aplicaciones donde usuarios sin experiencia necesitan editar plantillas.

La manera usual de sustituir variables por el nombre es con el operador `%` :

    >>> '%(page)i: %(title)s' % {'page':2, 'title': 'Lo mejor de los tiempos'}
    '2: Lo mejor de los tiempos'

Cuando se escriben plantillas con cadenas de caracteres puede ser muy fácil olvidar el uso de `i` or `s` después de cerrar paréntesis. Esto no es un problema grande si se está dentro de un módulo de Python pues al correr el código se lanza el siguiente mensaje de error «Unsupported format character» `ValueError` y el problema se resuelve. Sin embargo, tengamos en cuenta una aplicación como Mailman donde una plantilla de caracteres o traducciones son editadas por usuarios que no están familiarizados con Python. La sintaxis de como formatear las cadenas de caracteres es complicada de explicar para ciertos usuarios y si ellos cometen un error es una dificultad el entregar retroalimentación y ayuda.

PEP 292 adds a `Template` class to the `string` module that uses `$` to indicate a substitution:

    >>> import string
    >>> t = string.Template('$page: $title')
    >>> t.substitute({'page':2, 'title': 'Lo mejor de los tiempos'})
    '2: Lo mejor de los tiempos'

If a key is missing from the dictionary, the `substitute()` method will raise a `KeyError`. There’s also a `safe_substitute()` method that ignores missing keys:

    >>> t = string.Template('$página: $título')
    >>> t.safe_substitute({'página':3})
    '3: $título'

Ver también

PEP 292 - Sustituciones simples de cadenas de caracteres

  Escrito e implementado por Barry Warsaw.

## PEP 318: Decoradores para funciones y métodos

Python 2.2 extendió el modelo de objeto de Python añadiendo métodos estáticos y métodos de clase pero no se extendió la sintaxis de Python para proveer alguna nueva forma de definir métodos estáticos o de clase. En vez de eso se tenía que escribir la palabra clave `def` de manera usual y pasar el método resultante a la `staticmethod()` o a la `classmethod()` que podía agrupar la función como método de un nuevo tipo. El código podría verse como esto:

    clase C:
    def meth (cls):
    ...

    meth = classmethod(meth) # Volver a vincular el nombre al método de clase encapsulado

Si el método era muy largo, era muy probable el perder o olvidar la invocación `classmethod()` dentro del cuerpo de la función.

La intención era siempre agregar alguna sintaxis que hicieran las definiciones mas entendibles pero al tiempo del lanzamiento de la versión 2.2 una buena sintaxis no era clara. Al día de hoy una buena sintaxis aun no es clara pero los usuarios están preguntando por formas más fáciles de acceder a las características, entonces una nueva funcionalidad sintáctica ha sido añadida para satisfacer esta necesidad.

La nueva característica es llamada decoradores de funciones. El nombre proviene de la idea de que `classmethod()`, `staticmethod()` son amigos y guardan información adicional en un objeto de una función. ellos están decorando funciones con mas detalles.

La notación proviene de Java y usa el `'@'` símbolo arroba como un indicador. Usando la nueva sintaxis el ejemplo descrito arriba podría ser escrito de la siguiente forma:

    clase C:

    @classmethod
    def meth (cls):
    ...

El `@classmethod` es un atajo para `meth=classmethod(meth)`. De forma general si se tiene lo siguiente:

    @A
    @B
    @C
    def f():
    ...

Es el equivalente para el siguiente código de pre decorador:

    definición f(): ...
    f = A(B(C(f)))

Los decoradores deben agregarse en una línea antes de la definición de la función, un decorador por línea y no puede estar en la misma línea donde se usa la palabra def para comenzar una función, por ejemplo `@A def f(): ...` es incorrecto. Solo se puede decorar una definición de función tanto al nivel de módulo o dentro de una clase pero no puedes decorar definiciones de clase.

Un decorador es simplemente una función que toma la función a ser decorada como un argumento y retorna tanto la misma función o un nuevo objeto. El valor de retorno del decorador no necesita ser llamado (como típicamente se cree) si no que los decoradores podrán ser aplicados al resultado. Es fácil escribir sus propios decoradores. El siguiente ejemplo agrega un atributo a la función objetiva:

    >>> def deco(func):
    ... func.attr = 'decorado'
    ... return func
    ...
    >>> @deco
    ... def f(): pass
    ...
    >>> f
    <función f en 0x402ef0d4>
    >>> f.attr
    'decorado'
    >>>

Como un ejemplo un poco mas realista, el siguiente decorador revisa si el argumento entregado es un entero:

    def require_int (función):
    def contenedor (arg):
    assert isinstance(arg, int)
    return func(arg)

    return contenedor

    @require_int
    def p1 (arg):
    print arg

    @require_int
    def p2(arg):
    print arg*2

Un ejemplo en PEP 318 contiene una versión mas elegante de esta idea donde deja que usted elija específicamente el tipo y revisa el tipo de retorno.

Los decoradores de funciones pueden tomar argumentos. Si los argumentos son provistos, el decorador de la función es llamado con solo esos argumentos y retorna un nuevo decorador de función, esta función debe tomar una función sola y retorna una función como previamente se ha descrito. En otras palabras `@A @B @C(args)` comienza:

    def f(): ...
    _deco = C(argumentos)
    f = A(B(_deco(f)))

Conseguir que esto resulte correcto puede ser un acertijo pero tampoco es muy dificultoso.

Un pequeño cambio relacionado hace que el atributo `func_name` de las funciones sea escribible. Este atributo se utiliza para mostrar los nombres de las funciones en los seguimientos, por lo que los decoradores deben cambiar el nombre de cualquier función nueva que se construya y devuelva.

Ver también

PEP 318 Decoradores para funciones, métodos y clases

  Escrito por Kevin D.Smith, Jim Jewett y Skip Montanaro. Varias personas escribieron parches sobre la implementación de los decoradores de funciones, pero el único que fue chequeado fue #979728 por Mark Russell.

https://wiki.python.org/moin/PythonDecoratorLibrary

  Esta pagina de wiki contiene múltiples ejemplos de decoradores.

## PEP 322: Iteración inversa

Una nueva función de conjuntos integrados, `reversed(seq)` toma una secuencia y retorna un iterador que recorre los elementos de la secuencia en orden inverso.:

    >>> para i en reversed(xrange(1,4)):
    ... imprimir i
    ...
    3
    2
    1

Comparado con el uso tradicional de la segmentación tal como `range(1,4)[::-1]` la función `reversed()` es fácil de leer, se ejecuta mas rápido y usa sustancialmente menos memoria.

Señalar que la función `reversed()` solo acepta secuencias, no iteradores arbitrarios. Si se quiere revertir un iterador, primero se debe convertir a una lista usando la función `list()`.:

    >>> input = open('/etc/passwd', 'r')
    >>> for line in reversed(list(input)):
    ... print line
    ...
    root:*:0:0:Administrador del sistema:/var/root:/bin/tcsh
    ...

Ver también

PEP 322 - Iteración inversa

  Escrita e implementada por Raymond Hettinger.

## PEP 324: Nuevo módulo de subproceso

La biblioteca estándar proporciona varias formas de ejecutar un subproceso, ofreciendo distintas funciones y distintos niveles de complejidad. `os.system(command)` es fácil de usar, pero lento (ejecuta un proceso de shell que ejecuta el comando) y peligroso (hay que tener cuidado con el escape de los metacaracteres del shell). El módulo `popen2` ofrece clases que pueden capturar la salida estándar y el error estándar del subproceso, pero la nomenclatura es confusa. El módulo `subprocess` soluciona este problema, proporcionando una interfaz unificada que ofrece todas las funciones que se pueden necesitar.

En vez de `popen2` que es una colección de clases el `subprocess` contiene una sola clase llamada `subprocess.Popen` cuyo constructor soporta un número de diferentes argumentos de palabra clave:

    clase Popen(args, bufsize=0, ejecutable=Ninguno,
    stdin=Ninguno, stdout=Ninguno, stderr=Ninguno,
    preexec_fn=Ninguno, close_fds=False, shell=False,
    cwd=Ninguno, env=Ninguno, universal_newlines=False,
    startupinfo=Ninguno, creationflags=0):

args es comúnmente una secuencia de cadenas de caracteres que podrán ser los argumentos del programa ejecutado como un subproceso. (Si el argumento shell es verdadero, args puede ser una cadena de caracteres que serán pasados directamente a la shell para su interpretación, tal como `os.system()` lo hace.)

stdin, stdout, y stderr especifican que flujos de entrada, salida y error serán utilizados. Se puede proceder un objeto de archivo o un archivo de descripción o se puede usar la constante `subprocess.PIPE` para crear un enlace entre el subproceso y el proceso principal.

El constructor tiene un número de opciones útiles:

- close_fds requiere que todos los descriptores de archivos sean cerrados antes de correr el subproceso.

- cwd especifica el directorio operativo donde el subproceso será ejecutado (por defecto, cualquiera que sea el directorio principal)

- env es un diccionario donde se especifican las variables de entorno.

- preexec_fn es una función que es llamada antes de que el proceso hijo sea llamado.

- universal_newlines abre el flujo de entrada y salida del hijo usando la característica de Python universal newlines .

Once you’ve created the `Popen` instance, you can call its `wait()` method to pause until the subprocess has exited, `poll()` to check if it’s exited without pausing, or `communicate(data)` to send the string data to the subprocess’s standard input. `communicate(data)` then reads any data that the subprocess has sent to its standard output or standard error, returning a tuple `(stdout_data, stderr_data)`.

`call()` is a shortcut that passes its arguments along to the `Popen` constructor, waits for the command to complete, and returns the status code of the subprocess. It can serve as a safer analog to `os.system()`:

    sts = subprocess.call(['dpkg', '-i', '/tmp/new-package.deb'])
    if sts == 0:
    # Éxito
    ...
    else:
    # dpkg devolvió un error
    ...

El comando es invocado sin el uso del interprete de comandos. Si se desea usar el intérprete se puede agregar `shell=True` como un argumento de palabra clave y proveer una cadena de caracteres en vez de una secuencia:

    sts = subproceso.call('dpkg -i /tmp/nuevo-paquete.deb', shell=True)

La guía de estilo de Python toma varios ejemplos de línea de comandos y código python y muestra como estos son traducidos en el código python `subprocess`. Leer esta sección de la guía de estilo es altamente recomendado.

Ver también

PEP 324 - subprocess - Nuevo módulo de procesos

  Escrito e implementado por Peter Åstrand, con asistencia de Frederik Lundh y otros.

## PEP 327: Tipo de dato decimal

Python has always supported floating-point (FP) numbers, based on the underlying C double type, as a data type. However, while most programming languages provide a floating-point type, many people (even programmers) are unaware that floating-point numbers don’t represent certain decimal fractions accurately. The new `Decimal` type can represent these fractions accurately, up to a user-specified precision limit.

### ¿Por qué se necesita Decimal?

Las limitaciones surgen de la representación usada para los números de punto flotante. Los números de punto flotante están hechos de tres componentes:

- El signo, el cual es positivo o negativo.

- El significando o mantisa el cual es el un dígito binario seguido de su parte fraccional. Por ejemplo, `1.01` en notación base 2 es `1 + 0/2 + 1/4` o 1.25 en notación decimal.

- El exponente, que indica dónde se encuentra el punto decimal en el número representado.

Por ejemplo, el número 1.25 tiene un signo positivo, una mantisa de valor 1.01 (en binario) y un exponente de 0 (el punto decimal no necesita ser desplazado. El números 5 tiene el mismo signo y significando pero, el exponente es 2 porque el significando es multiplicado por 4 (2 elevado a la potencia del exponente 2), 1.25 * 4 es igual a 5.

Los sistemas modernos generalmente brindan soporte de coma flotante que se ajusta a un estándar llamado IEEE 754. El tipo double de C generalmente se implementa como un número IEEE 754 de 64 bits, que usa 52 bits de espacio para la mantisa. Esto significa que los números solo se pueden especificar con 52 bits de precisión. Si está tratando de representar números cuya expansión se repite sin cesar, la expansión se corta después de 52 bits. Desafortunadamente, la mayoría del software necesita producir resultados en base 10, y las fracciones comunes en base 10 a menudo son decimales repetidos en binario. Por ejemplo, 1.1 decimal es binario `1.0001100110011 ...`; .1 = 1/16 + 1/32 + 1/256 más un número infinito de términos adicionales. IEEE 754 tiene que cortar ese decimal repetido infinitamente después de 52 dígitos, por lo que la representación es un poco inexacta.

Algunas veces se puede ver esta inexactitud cuando el número es impreso por pantalla:

    >>> 1.1
    1.1000000000000001

La inexactitud no siempre es visible cuando se imprime el número porque el punto flotante a decimal y conversión a cadena de texto es entregada por la librería C y la mayoría de las librerías C tratan de producir una salida sensible. Incluso si no es mostrado, la inexactitud sigue ahí y las operaciones subsecuentes pueden agrandar el error.

Para muchas aplicaciones esto no importa. Si estoy trazando puntos y mostrándolos en el monitor la diferencia entre 1.1 y 1.1000000000000001 es muy pequeña para ser visible. Los reportes a menudo limitan la salida de un cierto número de decimales y si se redondea el número a dos o tres e incluso a 8 decimales, el error nunca aparece. Sin embargo, para las aplicaciones donde esto importa, es una cantidad de trabajo importante el personalizar los cálculos aritméticos.

Hence, the `Decimal` type was created.

### The `Decimal` type

A new module, `decimal`, was added to Python’s standard library. It contains two classes, `Decimal` and `Context`. `Decimal` instances represent numbers, and `Context` instances are used to wrap up various settings such as the precision and default rounding mode.

`Decimal` instances are immutable, like regular Python integers and FP numbers; once it’s been created, you can’t change the value an instance represents. `Decimal` instances can be created from integers or strings:

    >>> importar decimal
    >>> decimal.Decimal(1972)
    Decimal("1972")
    >>> decimal.Decimal("1.1")
    Decimal("1.1")

También se pueden proveer tuplas que contentan el signo, la mantisa representada como una tupla de números decimales y el exponente:

    >>> decimal.Decimal((1, (1, 4, 7, 5), -2))
    Decimal("-14,75")

Precaución: El signo bit es un valor booleano entonces 0 es positivo y 1 es negativo.

Converting from floating-point numbers poses a bit of a problem: should the FP number representing 1.1 turn into the decimal number for exactly 1.1, or for 1.1 plus whatever inaccuracies are introduced? The decision was to dodge the issue and leave such a conversion out of the API. Instead, you should convert the floating-point number into a string using the desired precision and pass the string to the `Decimal` constructor:

    >>> f = 1,1
    >>> decimal.Decimal(str(f))
    Decimal("1,1")
    >>> decimal.Decimal('%.12f' % f)
    Decimal("1,100000000000")

Once you have `Decimal` instances, you can perform the usual mathematical operations on them. One limitation: exponentiation requires an integer exponent:

    >>> a = decimal.Decimal('35,72')
    >>> b = decimal.Decimal('1,73')
    >>> a+b
    Decimal("37,45")
    >>> a-b
    Decimal("33,99")
    >>> a*b
    Decimal("61.7956")
    >>> a/b
    Decimal("20.64739884393063583815028902")
    >>> a XASDF00b
    Traceback (most recent call last):
      ...
    decimal.InvalidOperation: x ** (no entero)

You can combine `Decimal` instances with integers, but not with floating-point numbers:

    >>> a + 4
    Decimal("39.72")
    >>> a + 4.5
    Traceback (última llamada más reciente):
    ...
    TypeError: Solo puede interactuar con Decimal con tipos de datos int, long o Decimal.
    >>>

`Decimal` numbers can be used with the `math` and `cmath` modules, but note that they’ll be immediately converted to floating-point numbers before the operation is performed, resulting in a possible loss of precision and accuracy. You’ll also get back a regular floating-point number and not a `Decimal`.

    >>> importar matemáticas, cmath
    >>> d = decimal.Decimal('123456789012.345')
    >>> matemáticas.sqrt(d)
    351364.18288201344
    >>> cmath.sqrt(-d)
    351364.18288201344j

`Decimal` instances have a `sqrt()` method that returns a `Decimal`, but if you need other things such as trigonometric functions you’ll have to implement them.

    >>> d.sqrt()
    Decimal("351364.1828820134592177245001")

### The `Context` type

Instances of the `Context` class encapsulate several settings for decimal operations:

- `prec` is the precision, the number of decimal places.

- `rounding` specifies the rounding mode. The `decimal` module has constants for the various possibilities: `ROUND_DOWN`, `ROUND_CEILING`, `ROUND_HALF_EVEN`, and various others.

- `traps` is a dictionary specifying what happens on encountering certain error conditions: either an exception is raised or a value is returned. Some examples of error conditions are division by zero, loss of precision, and overflow.

There’s a thread-local default context available by calling `getcontext()`; you can change the properties of this context to alter the default precision, rounding, or trap handling. The following example shows the effect of changing the precision of the default context:

    >>> decimal.getcontext().prec
    28
    >>> decimal.Decimal(1) / decimal.Decimal(7)
    Decimal("0,1428571428571428571428571429")
    >>> decimal.getcontext().prec = 9
    >>> decimal.Decimal(1) / decimal.Decimal(7)
    Decimal("0,142857143")

Las acciones por defecto para condiciones de error se puede seleccionar, ya sea que el módulo pueda retornar un valor especial como un infinito o un valor no numérico NaN o se pueden lanzar excepciones:

    >>> decimal.Decimal(1) / decimal.Decimal(0)
    Traceback (última llamada más reciente):
    ...
    decimal.DivisionByZero: x / 0
    >>> decimal.getcontext().traps[decimal.DivisionByZero] = False
    >>> decimal.Decimal(1) / decimal.Decimal(0)
    Decimal("Infinito")
    >>>

The `Context` instance also has various methods for formatting numbers such as `to_eng_string()` and `to_sci_string()`.

Para mas información, revisar la documentación para el módulo `decimal` el cual incluye un tutoría de inicio rápido y una referencia.

Ver también

PEP 327 - Tipo de dato decimal

  Escrito por Facundo Batista e implementado por Facundo Batista, Eric Price, Raymond Hettinger, Aahz y Tim Peters.

http://www.lahey.com/float.htm

  El articulo usa código Fortran para ilustrar varios de los problemas que la inexactitud de los puntos flotantes pueden causar.

https://speleotrove.com/decimal/

  Una descripción de una representación basada en decimales. Esta representación ha sido propuesta como un estándar y subyace al nuevo tipo de dato decimal en Python. La mayor parte de este material fue escrita por Mike Cowlishaw, diseñador del lenguaje Rexx.

## PEP 328: Importaciones multilínea

Un pequeño cambio en el lenguaje ha sido una modificación a una sintaxis confusa que ha sido cambiada para hacer mas fácil el agregar varios nombres en un módulo. En una declaración `from module import names`, names es una secuencia de nombres separados por comas. Si la sentencia es muy larga, se puede ya sea escribir múltiples sentencias import desde el mismo módulo o se pueden usar barras invertidas para escapar de los términos de línea como esto:

    de SimpleXMLRPCServer importar SimpleXMLRPCServer,\
    SimpleXMLRPCRequestHandler,\
    CGIXMLRPCRequestHandler,\
    resolve_dotted_attribute

La sintaxis cambió en Python 2.4 y es simplemente el permitir poner los nombres dentro de paréntesis. Python ignora nuevas líneas dentro de una expresión entre paréntesis por lo que las barras invertidas ya no se necesitan:

    from SimpleXMLRPCServer import (SimpleXMLRPCServer,
                                    SimpleXMLRPCRequestHandler,
                                    CGIXMLRPCRequestHandler,
                                    resolve_dotted_attribute)

La convención de estilo también propone que todas las declaraciones usando `import` son importaciones absolutas, con el siguiente carácter `.` indica una importación relativa. Esta parte de la convención de estilo no fue implementada para Python 2.4 pero fue completada para la versión 2.5.

Ver también

PEP 328 - Importaciones multi línea y absolutas/relativas

  Escrita por Aahz. Importaciones multi línea fueron implementadas por Dima Dorfman.

## PEP 331: Conversiones locales-independientes números flotantes/cadenas de texto

The `locale` modules lets Python software select various conversions and display conventions that are localized to a particular country or language. However, the module was careful to not change the numeric locale because various functions in Python’s implementation required that the numeric locale remain set to the `'C'` locale. Often this was because the code was using the C library’s `atof()` function.

No configurar la configuración regional numérica causaba problemas para las extensiones que usaban librerías externas de C, sin embargo, porque no configuraban la correcta configuración. El ejemplo mas patente fue GTK+, cuya interfaz de usuario no mostraba números en la ubicación actual.

La solución descrita en la convención de estilo es añadir tres nuevas funciones a la API de python que ejecuta solo conversiones a ASCII, ignorando las configuraciones locales:

- `PyOS_ascii_strtod(str, ptr)` y `PyOS_ascii_atof(str, ptr)` convierten una cadena en C double.

- `PyOS_ascii_formatd(buffer, buf_len, format, d)` convierte un double en una cadena ASCII.

El código para estas funciones proviene de la biblioteca GLib (https://developer-old.gnome.org/glib/2.26/), cuyos desarrolladores amablemente renovaron la licencia de las funciones relevantes y las donaron a la Python Software Foundation. El módulo `locale` ahora puede cambiar la configuración regional numérica, lo que permite que extensiones como GTK+ produzcan los resultados correctos.

Ver también

PEP 331 Conversiones Local-Independiente flotante/cadena de texto

  Escrito por Christian R. Reis, e implementado por Gustavo Carneiro.

## Otros cambios en el lenguaje

Aquí están todos los cambios que Python 2.4 ha hecho al core del lenguaje Python.

- Fueron añadidos decoraciones para funciones (PEP 318).

- Funciones de conjuntos integrados `set()` y `frozenset()` fueron añadidas (PEP 218). Otras nuevas funciones de conjuntos integrados incluyen la función `reversed(seq)` (PEP 322).

- Generador de expresiones fueron añadidas (PEP 289).

- Algunas expresiones numéricas ya no retornan valores restringidos a 32 o 64 bits (PEP 237).

- Se puede poner entre paréntesis una lista de nombres en la declaración `from module import names` (PEP 328).

- El método `dict.update()` ahora acepta el mismo argumento que el constructor de la `dict`. Esto incluye cualquier tipo de mapeo, iterable pares de clave/valor y argumentos de palabra clave. (Contribución de Raymond Hettinger)

- The string methods `ljust()`, `rjust()`, and `center()` now take an optional argument for specifying a fill character other than a space. (Contributed by Raymond Hettinger.)

- Strings also gained an `rsplit()` method that works like the `split()` method but splits from the end of the string. (Contributed by Sean Reifschneider.)

      >>> 'www.python.org'.split('.', 1)
      ['www', 'python.org']
      'www.python.org'.rsplit('.', 1)
      ['www.python', 'org']

- Three keyword parameters, cmp, key, and reverse, were added to the `sort()` method of lists. These parameters make some common usages of `sort()` simpler. All of these parameters are optional.

  For the cmp parameter, the value should be a comparison function that takes two parameters and returns -1, 0, or +1 depending on how the parameters compare. This function will then be used to sort the list. Previously this was the only parameter that could be provided to `sort()`.

  key debe ser una función con un solo parámetro que toma un elemento de la lista y retorna una llave de comparación para el elemento. Entonces la lista es ordenado usando las claves de comparación. El siguiente ejemplo ordena una lista sin distinción de mayúsculas ni minúsculas:

      >>> L = ['A', 'b', 'c', 'D']
      >>> L.sort() # Ordenación que distingue entre mayúsculas y minúsculas
      >>> L
      ['A', 'D', 'b', 'c']
      >>> # Uso del parámetro 'key' para ordenar la lista
      >>> L.sort(key=lambda x: x.lower())
      >>> L
      ['A', 'b', 'c', 'D']
      >>> # Método tradicional
      >>> L.sort(cmp=lambda x,y: cmp(x.lower(), y.lower()))
      >>> L
      ['A', 'b', 'c', 'D']

  The last example, which uses the cmp parameter, is the old way to perform a case-insensitive sort. It works but is slower than using a key parameter. Using key calls `lower()` method once for each element in the list while using cmp will call it twice for each comparison, so using key saves on invocations of the `lower()` method.

  Para funciones de clave sencillas y comparativas es a menudo posible el obviar la palabra clave `lambda` usando un método sin ligar en reemplazo. El siguiente ejemplo de orden sin importar mayúsculas ni minúsculas es mejor escrito como se muestra:

      >>> L.sort(key=str.lower)
      >>> L
      ['A', 'b', 'c', 'D']

  Finalmente el parámetro reverse toma un valor de tipo booleano. Si el valor es verdadero la lista será ordenada de forma inversa. En vez de `L.sort(); L.reverse()` ahora se puede escribir `L.sort(reverse=True)`.

  Los resultados del ordenamiento ahora están garantizados que son estables. Esto significa que dos entradas con iguales claves serán retiradas en el mismo orden en que fueron ingresadas. Por ejemplo se puede ordenar una lista de personas por el nombre y entonces ordenarla por edad, resultando en una lista ordenada donde las personas con la misma edad están en el mismo orden por nombre.

  (All changes to `sort()` contributed by Raymond Hettinger.)

- Se tiene una nueva función incorporada `sorted(iterable)` que trabaja como el método in situ `list.sort()` que se puede usar en expresiones. Las diferencias son:

- el dato de entrada puede ser algún iterable;

- se ordena una copia recién formada, manteniendo el original intacto y

- la expresión retorna una nueva copia ordenada

      >>> L = [9,7,8,3,2,4,1,6,5]
      >>> [10+i for i in sorted(L)] # utilizable en una comprensión de lista
      [11, 12, 13, 14, 15, 16, 17, 18, 19]
      >>> L # el original no se modifica
      [9,7,8,3,2,4,1,6,5]
      >>> sorted('Monty Python') # cualquier iterable puede ser una entrada
      [' ', 'M', 'P', 'h', 'n', 'n', 'o', 'o', 't', 't', 'y', 'y']

      >>> # Lista el contenido de un diccionario ordenado por valores clave
      >>> colormap = dict(red=1, blue=2, green=3, black=4, yellow=5)
      >>> for k, v en sorted(colormap.iteritems()):
      ... imprimir k, v
      ...
      negro 4
      azul 2
      verde 3
      rojo 1
      amarillo 5

  (Contribución de Raymond Hettinger.)

- Integer operations will no longer trigger an `OverflowWarning`. The `OverflowWarning` warning will disappear in Python 2.5.

- Se añadió al interprete una nueva opción de cambio `-m` la cual toma un nombre, busca el módulo correspondiente en `sys.path` y corre el módulo como script. Ahora por ejemplo se puede correr el perfilador de Python con `python -m profile`. (Contribución de Nick Coghlan)

- La expresión `eval(expr, globals, locals)` la función `execfile(filename, globals, locals)` y la sentencia `exec` ahora aceptan cualquier tipo de mapeo para parámetros locales. Previamente esto era parte de un diccionario de Python. (Contribución de Raymond Hettinger.)

- The `zip()` built-in function and `itertools.izip()` now return an empty list if called with no arguments. Previously they raised a `TypeError` exception. This makes them more suitable for use with variable length argument lists:

      >>> def transpose(matriz):
      ... return zip(*matriz)
      ...
      >>> transpose([(1,2,3), (4,5,6)])
      [(1, 4), (2, 5), (3, 6)]
      >>> transpose([])
      []

  (Contribución de Raymond Hettinger.)

- Encontrar un error al importar un módulo ya no deja un objeto de módulo parcialmente inicializado en `sys.modules`. El objeto de módulo incompleto que se deja atrás engañaría a las importaciones posteriores del mismo módulo para que tuvieran éxito, lo que generaría errores confusos. (Reparado por Tim Peters.)

- `None`es ahora una constante, el código que une un nuevo valor con el nombre :const:`None` es ahora un error de sintaxis (Contribución de Raymond Hettinger)

### Optimizaciones

- The inner loops for list and tuple slicing were optimized and now run about one-third faster. The inner loops for dictionaries were also optimized, resulting in performance boosts for `keys()`, `values()`, `items()`, `iterkeys()`, `itervalues()`, and `iteritems()`. (Contributed by Raymond Hettinger.)

- El mecanismo para mejorar y contraer listas fue optimizada para efectos de velocidad y eficiencia en la utilización de recursos. Anexar y quitar elementos de una lista es ahora mas rápido debido al código mas eficiente y al menos frecuente uso de la función subyacente `realloc()`. Las listas por comprensión también son beneficiadas, el método `list.extend()` fue también optimizado y ya no convierte mas el argumento en una lista temporal antes de extender la lista base. (Contribución de Raymond Hettinger)

- `list()`, `tuple()`, `map()`, `filter()`, and `zip()` now run several times faster with non-sequence arguments that supply a `__len__()` method. (Contributed by Raymond Hettinger.)

- The methods `list.__getitem__()`, `dict.__getitem__()`, and `dict.__contains__()` are now implemented as `method_descriptor` objects rather than `wrapper_descriptor` objects. This form of access doubles their performance and makes them more suitable for use as arguments to functionals: `map(mydict.__getitem__, keylist)`. (Contributed by Raymond Hettinger.)

- Adicionalmente se ha agregado a un nuevo código de operación `LIST_APPEND` esto simplifica la generación de código a nivel de byte para las listas por comprensión y las agiliza en aproximadamente un tercio.

- El optimizador de código a nivel de byte ha sido mejorado para producir código a nivel de byte mas corto y rápido. Esto resulta en código mas legible. (Contribución de Raymond Hettinger)

- String concatenations in statements of the form `s = s + "abc"` and `s += "abc"` are now performed more efficiently in certain circumstances. This optimization won’t be present in other Python implementations such as Jython, so you shouldn’t rely on it; using the `join()` method of strings is still recommended when you want to efficiently glue a large number of strings together. (Contributed by Armin Rigo.)

El resultado de las optimizaciones de la versión 2.4 es que tomando Python 2.4 como punto de referencia corre alrededor de un 5% mas rápido que Python 2.3 y un 35% mas rápido que Python 2.2 (pystone no es particularmente un buen punto de referencia pero es el mas usado para medir rendimiento en Python. Sus propias aplicaciones pueden mostrar beneficios mas grandes o mínimos desde Python 2.4)

## Módulos nuevos, mejorados y obsoletos

Como es usual, la librería estándar de Python recibió un número de mejoras y corrección de errores. Aquí hay una lista parcial de los cambios mas notables, ordenados alfabéticamente por nombre de módulo. Consulte el archivo `Misc/NEWS` en la estructura del directorio para una completa lista de los cambios o se puede buscar a través del registro CVS para obtener todos los detalles.

- La función `loop()` del módulo `asyncore` ahora tiene un parámetro count que le permite realizar una cantidad limitada de pasadas a través del bucle de sondeo. El valor predeterminado sigue siendo el bucle indefinidamente.

- El módulo `base64` ahora tiene un soporte mas completo RFC 3548 para Base64, Base32 y Base16 para codificación y descodificación, incluyendo procesos de convertir caracteres a minúsculas y alfabetos alternativos. (Contribución de Barry Warsaw)

- El módulo `bisect` ahora tiene una implementación C subyacente para mejorar el rendimiento. (Contribuido por Dmitry Vasiliev.)

- Las colecciones CJKCodecs de códecs de Asia oriental, mantenidas por Hye-Shik Chang, se integraron en 2.4. Las nuevas codificaciones son:

- Chino (PRC): gb2312, gbk, gb18030, big5hkscs, hz

- Chino (República de China): big5, cp950

- Japonés: cp932, euc-jis-2004, euc-jp, euc-jisx0213, iso-2022-jp,

    iso-2022-jp-1, iso-2022-jp-2, iso-2022-jp-3, iso-2022-jp-ext, iso-2022-jp-2004, shift-jis, shift-jisx0213, shift- jis-2004

- Coreano: cp949, euc-kr, johab, iso-2022-kr

- Se agregaron algunas otras codificaciones nuevas: HP Roman8, ISO_8859-11, ISO_8859-16, PCTP-154 y TIS-620.

- The UTF-8 and UTF-16 codecs now cope better with receiving partial input. Previously the `StreamReader` class would try to read more data, making it impossible to resume decoding from the stream. The `read()` method will now return as much data as it can and future calls will resume decoding where previous ones left off. (Implemented by Walter Dörwald.)

- There is a new `collections` module for various specialized collection datatypes. Currently it contains just one type, `deque`, a double-ended queue that supports efficiently adding and removing elements from either end:

      >>> from collections import deque
      >>> d = deque('ghi') # crea un nuevo deque con tres elementos
      >>> d.append('j') # agrega una nueva entrada al lado derecho
      >>> d.appendleft('f') # agrega una nueva entrada al lado izquierdo
      >>> d # muestra la representación del deque
      deque(['f', 'g', 'h', 'i', 'j'])
      >>> d.pop() # devuelve y elimina el elemento más a la derecha
      'j'
      >>> d.popleft() # devuelve y elimina el elemento más a la izquierda
      'f'
      >>> list(d) # lista el contenido del deque
      ['g', 'h', 'i']
      >>> 'h' in d # busca el deque
      True

  Several modules, such as the `queue` and `threading` modules, now take advantage of `collections.deque` for improved performance. (Contributed by Raymond Hettinger.)

- Las clases `ConfigParser` se han mejorado ligeramente. El método `read()` ahora devuelve una lista de los archivos que se analizaron correctamente y el método `set()` genera `TypeError` si se le pasa un argumento value que no sea una cadena. (Contribuido por John Belmonte y David Goodger).

- The `curses` module now supports the ncurses extension `use_default_colors()`. On platforms where the terminal supports transparency, this makes it possible to use a transparent background. (Contributed by Jörg Lehmann.)

- The `difflib` module now includes an `HtmlDiff` class that creates an HTML table showing a side by side comparison of two versions of a text. (Contributed by Dan Gass.)

- The `email` package was updated to version 3.0, which dropped various deprecated APIs and removes support for Python versions earlier than 2.3. The 3.0 version of the package uses a new incremental parser for MIME messages, available in the `email.FeedParser` module. The new parser doesn’t require reading the entire message into memory, and doesn’t raise exceptions if a message is malformed; instead it records any problems in the `defect` attribute of the message. (Developed by Anthony Baxter, Barry Warsaw, Thomas Wouters, and others.)

- The `heapq` module has been converted to C. The resulting tenfold improvement in speed makes the module suitable for handling high volumes of data. In addition, the module has two new functions `nlargest()` and `nsmallest()` that use heaps to find the N largest or smallest values in a dataset without the expense of a full sort. (Contributed by Raymond Hettinger.)

- The `httplib` module now contains constants for HTTP status codes defined in various HTTP-related RFC documents. Constants have names such as `OK`, `CREATED`, `CONTINUE`, and `MOVED_PERMANENTLY`; use pydoc to get a full list. (Contributed by Andrew Eland.)

- The `imaplib` module now supports IMAP’s THREAD command (contributed by Yves Dionne) and new `deleteacl()` and `myrights()` methods (contributed by Arnaud Mazin).

- The `itertools` module gained a `groupby(iterable[, *func*])` function. iterable is something that can be iterated over to return a stream of elements, and the optional func parameter is a function that takes an element and returns a key value; if omitted, the key is simply the element itself. `groupby()` then groups the elements into subsequences which have matching values of the key, and returns a series of 2-tuples containing the key value and an iterator over the subsequence.

  Here’s an example to make this clearer. The key function simply returns whether a number is even or odd, so the result of `groupby()` is to return consecutive runs of odd or even numbers.

      >>> importar itertools
      >>> L = [2, 4, 6, 7, 8, 9, 11, 12, 14]
      >>> para key_val, it en itertools.groupby(L, lambda x: x % 2):
      ... imprimir key_val, list(it)
      ...
      0 [2, 4, 6]
      1 [7]
      0 [8]
      1 [9, 11]
      0 [12, 14]
      >>>

  `groupby()` is typically used with sorted input. The logic for `groupby()` is similar to the Unix `uniq` filter which makes it handy for eliminating, counting, or identifying duplicate elements:

      >>> palabra = 'abracadabra'
      >>> letras = sorted(palabra) # Convierte una cadena en una lista ordenada de letras
      >>> letras
      ['a', 'a', 'a', 'a', 'a', 'b', 'b', 'c', 'd', 'r', 'r']
      >>> for k, g in itertools.groupby(letters):
      ... print k, list(g)
      ...
      a ['a', 'a', 'a', 'a', 'a']
      b ['b', 'b']
      c ['c']
      d ['d']
      r ['r', 'r']
      >>> # Lista de letras únicas
      >>> [k for k, g in groupby(letters)]
      ['a', 'b', 'c', 'd', 'r']
      >>> # Cuenta las ocurrencias de las letras
      >>> [(k, len(lista(g))) para k, g en groupby(letras)]
      [('a', 5), ('b', 2), ('c', 1), ('d', 1), ('r', 2)]

  (Contribuido por Hye-Shik Chang.)

- `itertools` también obtuvo una función denominada `tee(iterator, N)` que devuelve N independent iterators that replicate iterator. If N se omite, el valor predeterminado es 2.

      >>> L = [1,2,3]
      >>> i1, i2 = itertools.tee(L)
      >>> i1,i2
      (<itertools.tee object at 0x402c2080>, <itertools.tee object at 0x402c2090>)
      >>> list(i1) # Ejecuta el primer iterador hasta el agotamiento
      [1, 2, 3]
      >>> list(i2) # Ejecuta el segundo iterador hasta el agotamiento
      [1, 2, 3]

  Note that `tee()` has to keep copies of the values returned by the iterator; in the worst case, it may need to keep all of them. This should therefore be used carefully if the leading iterator can run far ahead of the trailing iterator in a long stream of inputs. If the separation is large, then you might as well use `list()` instead. When the iterators track closely with one another, `tee()` is ideal. Possible applications include bookmarking, windowing, or lookahead iterators. (Contributed by Raymond Hettinger.)

- A number of functions were added to the `locale` module, such as `bind_textdomain_codeset()` to specify a particular encoding and a family of `l*gettext()` functions that return messages in the chosen encoding. (Contributed by Gustavo Niemeyer.)

- Some keyword arguments were added to the `logging` package’s `basicConfig()` function to simplify log configuration. The default behavior is to log messages to standard error, but various keyword arguments can be specified to log to a particular file, change the logging format, or set the logging level. For example:

      importar registro
      logging.basicConfig(filename='/var/log/application.log',
      level=0, # Registrar todos los mensajes
      format='%(levelname):%(process):%(thread):%(message)')

  Other additions to the `logging` package include a `log(level, msg)` convenience method, as well as a `TimedRotatingFileHandler` class that rotates its log files at a timed interval. The module already had `RotatingFileHandler`, which rotated logs once the file exceeded a certain size. Both classes derive from a new `BaseRotatingHandler` class that can be used to implement other rotating handlers.

  (Cambios implementados por Vinay Sajip.)

- El módulo `marshal` ahora comparte cadenas internas al desempaquetar una estructura de datos. Esto puede reducir el tamaño de ciertas cadenas de pickle, pero el efecto principal es hacer que los archivos `.pyc` sean significativamente más pequeños. (Contribución de Martin von Löwis.)

- The `nntplib` module’s `NNTP` class gained `description()` and `descriptions()` methods to retrieve newsgroup descriptions for a single group or for a range of groups. (Contributed by Jürgen A. Erhard.)

- Se agregaron dos nuevas funciones al módulo `operator`, `attrgetter(attr)` y `itemgetter(index)`. Ambas funciones devuelven invocables que toman un solo argumento y devuelven el atributo o elemento correspondiente; estos llamables son excelentes extractores de datos cuando se utilizan con `map()` o `sorted()`. Por ejemplo:

      >>> L = [('c', 2), ('d', 1), ('a', 4), ('b', 3)]
      >>> map(operator.itemgetter(0), L)
      ['c', 'd', 'a', 'b']
      >>> map(operator.itemgetter(1), L)
      [2, 1, 4, 3]
      >>> sorted(L, key=operator.itemgetter(1)) # Ordenar la lista por el segundo elemento de la tupla
      [('d', 1), ('c', 2), ('b', 3), ('a', 4)]

  (Contribución de Raymond Hettinger.)

- El módulo `optparse` se actualizó de varias formas. El módulo ahora pasa sus mensajes a través de `gettext.gettext()`, lo que permite internacionalizar los mensajes de error y ayuda de Optik. Los mensajes de ayuda para las opciones ahora pueden incluir la cadena `'%default'`, que será reemplazada por el valor predeterminado de la opción. (Contribuido por Greg Ward.)

- El plan a largo plazo es dejar obsoleto el módulo `rfc822` en alguna versión futura de Python a favor del paquete `email`. Con este fin, se ha modificado la función `email.Utils.formatdate` para que pueda utilizarse como reemplazo de `rfc822.formatdate()`. Es posible que desee escribir un nuevo código de procesamiento de correo electrónico teniendo esto en cuenta. (Cambio implementado por Anthony Baxter).

- Se agregó una nueva función `urandom(n)` al módulo `os`, que devuelve una cadena que contiene n bytes de datos aleatorios. Esta función proporciona acceso a fuentes de aleatoriedad específicas de la plataforma, como `/dev/urandom` en Linux o Windows CryptoAPI. (Contribuido por Trevor Perrin.)

- Otra función nueva: `os.path.lexists(path)` devuelve verdadero si el archivo especificado por path exists, whether or not it’s a symbolic link. This differs from the existing ASDF01 function, which returns false if path es un enlace simbólico que apunta a un destino que no existe. (Contribuido por Beni Cherniavsky.)

- A new `getsid()` function was added to the `posix` module that underlies the `os` module. (Contributed by J. Raynor.)

- El módulo `poplib` ahora admite POP sobre SSL. (Contribuido por Héctor Urtubia.)

- El módulo `profile` ahora puede perfilar funciones de extensión C. (Contribuido por Nick Bastin.)

- The `random` module has a new method called `getrandbits(N)` that returns a long integer N bits in length. The existing `randrange()` method now uses `getrandbits()` where appropriate, making generation of arbitrarily large random numbers more efficient. (Contributed by Raymond Hettinger.)

- El lenguaje de expresiones regulares aceptado por el módulo `re` se amplió con expresiones condicionales simples, escritas como `(?(group)A|B)`. En su lugar, se utilizará group is either a numeric group ID or a group name defined with ASDF02 earlier in the expression. If the specified group matched, the regular expression pattern A will be tested against the string; if the group didn’t match, the pattern B. (Contribución de Gustavo Niemeyer.)

- El módulo `re` ya no es recursivo, gracias a la enorme cantidad de trabajo de Gustavo Niemeyer. En un motor de expresión regular recursivo, ciertos patrones dan como resultado que se consuma una gran cantidad de espacio de pila de C y es posible desbordar la pila. Por ejemplo, si comparó una cadena de 30000 bytes de caracteres `a` con la expresión `(a|b)+`, se consumió un marco de pila por carácter. Python 2.3 intentó verificar el desbordamiento de la pila y generar una excepción `RuntimeError`, pero ciertos patrones podrían eludir la verificación y, si no tuvo suerte, Python podría segregar. El motor de expresiones regulares de Python 2.4 puede coincidir con este patrón sin problemas.

- The `signal` module now performs tighter error-checking on the parameters to the `signal.signal()` function. For example, you can’t set a handler on the `SIGKILL` signal; previous versions of Python would quietly accept this, but 2.4 will raise a `RuntimeError` exception.

- Two new functions were added to the `socket` module. `socketpair()` returns a pair of connected sockets and `getservbyport(port)` looks up the service name for a given port number. (Contributed by Dave Cole and Barry Warsaw.)

- The `sys.exitfunc()` function has been deprecated. Code should be using the existing `atexit` module, which correctly handles calling multiple exit functions. Eventually `sys.exitfunc()` will become a purely internal interface, accessed only by `atexit`.

- El módulo `tarfile` ahora genera archivos tar en formato GNU de forma predeterminada. (Contribución de Lars Gustäbel.)

- The `threading` module now has an elegantly simple way to support thread-local data. The module contains a `local` class whose attribute values are local to different threads.

      importar subprocesos

      datos = threading.local()
      datos.number = 42
      datos.url = ('www.python.org', 80)

  Other threads can assign and retrieve their own values for the `number` and `url` attributes. You can subclass `local` to initialize attributes or to add methods. (Contributed by Jim Fulton.)

- El módulo `timeit` ahora deshabilita automáticamente la recolección de basura periódica durante el ciclo de temporización. Este cambio hace que los tiempos consecutivos sean más comparables. (Contribuido por Raymond Hettinger.)

- El módulo `weakref` ahora admite una variedad más amplia de objetos, incluidas funciones de Python, instancias de clases, conjuntos, frozensets, deques, matrices, archivos, sockets y objetos de patrones de expresión regular. (Contribuido por Raymond Hettinger.)

- El módulo `xmlrpclib` ahora admite una extensión de múltiples llamadas para transmitir múltiples llamadas XML-RPC en una sola operación HTTP. (Contribuido por Brian Quinlan).

- The `mpz`, `rotor`, and `xreadlines` modules have been removed.

### cookielib

La biblioteca `cookielib` admite el manejo de cookies HTTP por parte del cliente, lo que refleja la compatibilidad con cookies del lado del servidor del módulo `Cookie`. Las cookies se almacenan en contenedores de cookies; la biblioteca almacena de forma transparente las cookies ofrecidas por el servidor web en el contenedor de cookies y recupera la cookie del contenedor cuando se conecta al servidor. Al igual que en los navegadores web, los objetos de política controlan si se aceptan o no las cookies.

Para almacenar cookies entre sesiones, se proporcionan dos implementaciones de tarros de cookies: una que almacena cookies en formato Netscape para que las aplicaciones puedan usar los archivos de cookies de Mozilla o Lynx, y otra que almacena cookies en el mismo formato que la biblioteca libwww de Perl.

`urllib2` has been changed to interact with `cookielib`: `HTTPCookieProcessor` manages a cookie jar that is used when accessing URLs.

Este módulo fue una contribución de John J. Lee.

### doctest

El módulo `doctest` se sometió a una refactorización considerable gracias a Edward Loper y Tim Peters. Las pruebas pueden ser tan simples como ejecutar `doctest.testmod()`, pero las refactorizaciones permiten personalizar el funcionamiento del módulo de varias formas.

The new `DocTestFinder` class extracts the tests from a given object’s docstrings:

    def f (x, y):
    """>>> f(2,2)
    4
    >>> f(3,2)
    6
    """
    return x*y

    finder = doctest.DocTestFinder()

    # Obtener la lista de instancias de DocTest
    tests = finder.find(f)

The new `DocTestRunner` class then runs individual tests and can produce a summary of the results:

    runner = doctest.DocTestRunner()
    para t en pruebas:
    intentado, fallido = runner.run(t)

    runner.summarize(verbose=1)

El ejemplo anterior produce la siguiente salida:

    1 ítems pasaron todas las pruebas:
    2 pruebas en f
    2 pruebas en 1 ítem.
    2 pasaron y 0 reprobaron.
    Prueba aprobada.

`DocTestRunner` uses an instance of the `OutputChecker` class to compare the expected output with the actual output. This class takes a number of different flags that customize its behaviour; ambitious users can also write a completely new subclass of `OutputChecker`.

El comprobador de salida predeterminado proporciona una serie de funciones útiles. Por ejemplo, con el indicador de opción `doctest.ELLIPSIS`, una elipsis (`...`) en la salida esperada coincide con cualquier subcadena, lo que facilita la adaptación de salidas que varían en formas menores:

    def o (n):
        """>>> o(1)
    <__main__.C instance at 0x...>
    >>>
    """

Otra cadena especial, `<BLANKLINE>`, coincide con una línea en blanco:

    def p (n):
        """>>> p(1)
    <BLANKLINE>
    >>>
    """

Otra nueva capacidad es producir una visualización de estilo diff de la salida especificando `doctest.REPORT_UDIFF` (diferencias unificadas), `doctest.REPORT_CDIFF` (diferencias de contexto), o `doctest.REPORT_NDIFF` Indicadores de opción (estilo delta). Por ejemplo:

    def g (n):
        """>>> g(4)
    here
    is
    a
    lengthy
    >>>"""
        L = 'here is a rather lengthy list of words'.split()
        for word in L[:n]:
            print word

Al ejecutar las pruebas de la función anterior con `doctest.REPORT_UDIFF` especificado, obtiene el siguiente resultado:

    **********************************************************************
    File "t.py", line 15, in g
    Failed example:
        g(4)
    Differences (unified diff with -expected +actual):
        @@ -2,3 +2,3 @@
         is
         a
        -lengthy
        +rather
    **********************************************************************

## Cambios en la API de Build y C

Algunos de los cambios en el proceso de compilación de Python y en la API de C son:

- Se agregaron tres nuevas macros de conveniencia para valores de retorno comunes de funciones de extensión: `Py_RETURN_NONE`, `Py_RETURN_TRUE`, y `Py_RETURN_FALSE`. (Contribuido por Brett Cannon.)

- Otra macro nueva, `Py_CLEAR`, reduce el recuento de referencias de obj y establece obj en el puntero nulo. (Aportado por Jim Fulton.)

- Una nueva función, `PyTuple_Pack(N, obj1, obj2, ..., objN)`, construye tuplas a partir de una lista de argumentos de longitud variable de objetos Python. (Contribuido por Raymond Hettinger.)

- Una nueva función, `PyDict_Contains(d, k)`, implementa búsquedas rápidas de diccionarios sin enmascarar las excepciones que surgen durante el proceso de búsqueda. (Contribuido por Raymond Hettinger.)

- The `Py_IS_NAN` macro returns 1 if its float or double argument X is a NaN. (Contributed by Tim Peters.)

- El código C puede evitar el bloqueo innecesario mediante el uso de la nueva función `PyEval_ThreadsInitialized()` para saber si se ha realizado alguna operación de subproceso. Si esta función devuelve falso, no se necesitan operaciones de bloqueo. (Contribuido por Nick Coghlan.)

- Una nueva función, `PyArg_VaParseTupleAndKeywords()`, es la misma que `PyArg_ParseTupleAndKeywords()` pero toma un `va_list` en lugar de varios argumentos. (Contribuido por Greg Chapman.)

- A new method flag, `METH_COEXIST`, allows a function defined in slots to co-exist with a `PyCFunction` having the same name. This can halve the access time for a method such as `set.__contains__()`. (Contributed by Raymond Hettinger.)

- Python ahora se puede construir con perfiles adicionales para el intérprete en sí, con la intención de ayudar a las personas que desarrollan el núcleo de Python. Proporcionar `- enable-profiling` al configure script le permitirá perfilar el intérprete con gprof, y proporcionar el `- with-tsc` switch permite la creación de perfiles utilizando el registro de contador de marcas de tiempo del Pentium. Tenga en cuenta que el conmutador `- with-tsc` tiene un nombre ligeramente incorrecto, porque la función de creación de perfiles también funciona en la plataforma PowerPC, aunque la arquitectura del procesador no llama a ese registro» el registro TSC «. (Contribuido por Jeremy Hylton.)

- The `tracebackobject` type has been renamed to `PyTracebackObject`.

### Cambios específicos del puerto

- El puerto de Windows ahora se construye bajo MSVC ++ 7.1 y también con la versión 6. (Contribuido por Martin von Löwis).

## Portar a Python 2.4

Esta sección enumera los cambios descritos anteriormente que pueden requerir cambios en su código:

- Los desplazamientos a la izquierda y las constantes hexadecimales / octales que son demasiado grandes ya no activan un `FutureWarning` y devuelven un valor limitado a 32 o 64 bits; en su lugar, devuelven un entero largo.

- Integer operations will no longer trigger an `OverflowWarning`. The `OverflowWarning` warning will disappear in Python 2.5.

- The `zip()` built-in function and `itertools.izip()` now return an empty list instead of raising a `TypeError` exception if called with no arguments.

- You can no longer compare the `date` and `datetime` instances provided by the `datetime` module. Two instances of different classes will now always be unequal, and relative comparisons (`<`, `>`) will raise a `TypeError`.

- `dircache.listdir()` ahora pasa excepciones a la persona que llama en lugar de devolver listas vacías.

- `LexicalHandler.startDTD` used to receive the public and system IDs in the wrong order. This has been corrected; applications relying on the wrong order need to be fixed.

- `fcntl.ioctl()` ahora advierte si el argumento mutate se omite y es relevante.

- El módulo `tarfile` ahora genera archivos de GNU tar-formato por defecto.

- Encontrar un error al importar un módulo ya no deja un objeto de módulo parcialmente inicializado en `sys.modules`.

- `None` ahora es una constante; El código que une un nuevo valor al nombre `None` ahora es un error de sintaxis.

- The `signal.signal()` function now raises a `RuntimeError` exception for certain illegal values; previously these errors would pass silently. For example, you can no longer set a handler on the `SIGKILL` signal.

## Agradecimientos

El autor desea agradecer a las siguientes personas por ofrecer sugerencias, correcciones y ayuda con varios borradores de este artículo: Koray Can, Hye-Shik Chang, Michael Dyck, Raymond Hettinger, Brian Hurt, Hamish Lawson, Fredrik Lundh, Sean Reifschneider, Sadruddin Rejeb.