11 Otros cambios del lenguaje

He aquí todos los cambios del núcleo de Python en su versión 2.4.

Se añadieron los decoradores de funciones y métodos (PEP 318).

Se añadieron los tipos internos set y frozenset (PEP 218). Otra función interna nueva es reversed(seq) (PEP 322).

Se añadieron las expresiones generadoras (PEP 289).

Ciertas expresiones numéricas ya no devuelven valores restringidos a 32 o 64 bits (PEP 237).

Es posible encerrar entre paréntesis la lista de nombres de una sentencia from module import names (PEP 328).

El método dict.update() ya acepta las mismas combinaciones de argumentos que el constructor de dict. Esto incluye cualquier correspondencia, cualquier iterable de parejas clave/valor y argumentos por clave (contribución de Raymond Hettinger).

Los métodos de cadena ljust(), rjust() y center() ahora toman un argumento opcional para especificar un carácter de relleno diferente de un espacio (contribución de Raymond Hettinger).

Las cadenas estrenan un método rsplit() que funciona como el método split() pero trocea partiendo del final de la cadena (contribución de Raymond Hettinger).

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

Se añadieron tres parámetros por nombre cmp, key y reverse al método sort() de las listas. Estos parámetros simplifican algunos usos comunes de sort(). Todos estos parámetros son opcionales.

En el caso del parámetro cmp, el valor debe ser una función de comparación que tome dos parámetros y devuelva -1, 0 o +1 dependiendo del resultado de comparar los parámetros. Esta función es el criterio que se utilizará para ordenar la lista. Antes, éste era el único parámetro que se podía proporcionar a sort().

key (clave) debe ser una función de un solo parámetro que tome un elemento de la lista y devuelva una clave de comparación para el elemento. Esta lista se ordena entonces usando las claves de comparación. El siguiente ejemplo ordena una lista sin tener en cuenta las mayúsculas y las minúsculas:

>>> L = ['A', 'b', 'c', 'D']
>>> L.sort()                 # Ordenación, mayúsculas primero
>>> 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']
>>> # A la antigua
>>> L.sort(cmp=lambda x,y: cmp(x.lower(), y.lower()))
>>> L
['A', 'b', 'c', 'D']

Este último ejemplo, que usa el parámetro cmp, es el antiguo método de realizar una ordenación sin tener en cuenta mayúsculas. Funciona, pero es más lento que utilizar un parámetro key. Al usar key se llama al método lower() una vez por elemento de la lista, mientras que si se usa cmp, se llamará dos veces por comparación. En resumen, al usar key ahorra llamadas al método lower().

En el caso de las funciones de clave y comparación simples, suele poderse evitar una expresión lambda utilizando un método sin enlazar en su lugar. Por ejemplo, la ordenación anterior tiene una mejor escritura de este modo:

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

Por último, el parámetro reverse toma un valor booleano. Si el valor es verdadero, la lista se ordenará en orden inverso. En lugar de L.sort() ; L.reverse(), ahora se puede escribir L.sort(reverse=True).

Ahora se garantiza que los resultados de la ordenación son estables. Esto significa que los elementos con claves de ordenación iguales se devolverán en el mismo orden de entrada. Por ejemplo, se puede ordenar una lista por nombre y luego por edad. El resultado estará ordenado edad, y dentro de la misma edad ordenado por nombre.

(Todos los cambios de sort() contribución de Raymond Hettinger.)

Hay una nueva función interna sorted(iterable) que funciona como el método list.sort() que modifica la propia lista, pero que es utilizable en expresiones. Las diferencias son:

la entrada puede ser cualquier iterable;
se genera una copia nueva ordenada, dejando la original intacta; y
la expresión devuelve la nueva copia ordenada

>>> L = [9,7,8,3,2,4,1,6,5]
>>> [10+i for i in sorted(L)]       # utilizable en una lista autodefinida
[11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> L                               # No se modifica el original
[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']

>>> # Enumerar el contenido de un dict ordenado por el valor de sus claves
>>> mapa_colores = dict(rojo=1, azul=2, verde=3, negro=4, amarillo=5)
>>> for k, v in sorted(mapa_colores.iteritems()):
...     print k, v
...
negro 4
azul 2
verde 3
rojo 1
amarillo 5

(Contribución de Raymond Hettinger.)

Las operaciones con enteros ya no lanzarán OverflowWarning. La advertencia OverflowWarning desaparecerá en Python 2.5.

Aparece un nuevo indicador para el intérprete, -m, que toma un nombre, busca el módulo correspondiente en sys.path y ejecuta el módulo como guion. Por ejemplo, se puede ejecutar el perfilador de Python con python -m profile. (Contribución de Nick Coghlan.)

Las funciones eval(expr, globals, locals), execfile(filename, globals, locals) y la sentencia exec ya aceptan cualquier tipo correspondencia en el parámetro locals. Antes sólo aceptaban diccionarios propiamente dichos. (Contribución de Raymond Hettinger.)

Las funciones internas zip() e itertools.izip() ahora devuelven una lista vacía si se les llama sin argumentos. Antes lanzaban una excepción TypeError. Esto las hace más adecuadas para usarlas con listas de argumentos de longitud variable:

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

(Contribución de Raymond Hettinger.)

Si se encuentra un fallo al importar un módulo, ya no se queda un módulo iniciado a medias en sys.modules. El objeto módulo incompleto estropeaba nuevas importaciones del mismo módulo, llevando a confusión. (Arreglo de Tim Peters.)

Ahora None es una constante; el código que asigne un valor nuevo al nombre "None" es ahora un error de sintaxis. (Contribución de Raymond Hettinger.)

11.1 Optimizaciones

Se han optimizado los bucles internos para hacer cortes de listas y tuplas, y ahora se ejecutan cerca de un terció más rápido. También se han optimizado los bucles internos de los diccionarios, consiguiéndose mejoras de rendimiento en keys(), values(), items(), iterkeys(), itervalues() y iteritems(). (Contribución de Raymond Hettinger.)

Se ha optimizado la maquinaria de crecer y menguar las listas en cuanto a velocidad y ocupación. Añadir y tomar elementos del extremo de las listas es más rápido gracias a caminos de código más eficientes y al uso reducido de la función de sistema realloc() subyacente. También se han beneficiado de esto las listas autodefinidas. Se ha optimizado list.extend(); ya no convierte sus argumentos a una lista temporal antes de extender la lista base. (Contribución de Raymond Hettinger.)

list(), tuple(), map(), filter() y zip() ahora son varias veces más rápidas con argumentos no secuenciales que proporcionan un método __len__(). (Contribución de Raymond Hettinger.)

Los métodos list.__getitem__(), dict.__getitem__() y dict.__contains__() ahora se implementan como objetos method_descriptor en lugar de objetos wrapper_descriptor. Esta forma de acceso duplica su rendimiento y los hace más adecuados para la programación funcional: "map(midict.__getitem__, listaclaves)". (Contribución de Raymond Hettinger.)

Se ha añadido un nuevo ``opcode'', LIST_APPEND, que simplifica el ``bytecode'' generado para las listas autodefinidas y aumenta su velocidad en 1/3. (Contribución de Raymond Hettinger.)

El microoptimizador de ``bytecode'' se ha mejorado para producir ``bytecode'' más breve y más rápido; además, el código resultante es más legible. (Mejorado por Raymond Hettinger.)

Las concatenaciones de cadenas de la forma

s = s +
"bla"

y s += "bla" se realizan de una manera más eficaz en ciertas condiciones. Esta optimización aún no estará presente en otras implementaciones, como en Jython, por lo que no conviene fiarse de esto; aún se recomienda el uso del método join() de las cadenas cuando se desee empalmar una gran cantidad de cadenas. (Contribución de Armin Rigo.)

El resultado neto de las optimizaciones es que Python 2.4 ejecuta el banco de pruebas pystone alrededor de 5% más rápido que 2.3 y 35% más rápido que Python 2.2 (pystone no es un banco de pruebas especialmente bueno, pero es el más utilizado para medir el rendimiento de Python. Las aplicaciones concretas pueden beneficiarse en mayor o menor grado de Python 2.4).

Consultar en Acerca de este documento... información para sugerir cambios.