Qué hay de nuevo en Python 2.4¶

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.

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.

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.

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'

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.

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

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.

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.

>>> 1.1
1.1000000000000001

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

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

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

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

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

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

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

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

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

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.

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.

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)

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.

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)

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

runner.summarize(verbose=1)

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

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

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

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

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

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.