Nota
¡Ayúdanos a traducir la documentación oficial de Python al Español! Puedes encontrar más información en Como contribuir. Ayuda a acercar Python a más personas de habla hispana.
Qué hay de nuevo en Python 2.6¶
- Autor:
A.M. Kuchling (amk arroba amk.ca)
Este artículo explica las nuevas funciones de Python 2.6, publicadas el 1 de octubre de 2008. El programa de publicación se describe en PEP 361.
El tema principal de Python 2.6 es preparar el camino de migración a Python 3.0, un importante rediseño del lenguaje. Siempre que sea posible, Python 2.6 incorpora nuevas características y sintaxis de 3.0 mientras sigue siendo compatible con el código existente al no eliminar características o sintaxis más antiguas. Cuando no es posible hacer eso, Python 2.6 intenta hacer lo que puede, agregando funciones de compatibilidad en el módulo future_builtins
y un interruptor -3
para advertir sobre usos que dejarán de ser compatibles en 3.0 .
Se han agregado algunos paquetes nuevos importantes a la biblioteca estándar, como los módulos multiprocessing
y json
, pero no hay muchas características nuevas que no estén relacionadas con Python 3.0 de alguna manera.
Python 2.6 también incluye una serie de mejoras y correcciones de errores en el código fuente. Una búsqueda en los registros de cambios encuentra que se aplicaron 259 parches y se corrigieron 612 errores entre Python 2.5 y 2.6. Es probable que ambas cifras estén subestimadas.
Este artículo no intenta proporcionar una especificación completa de las nuevas características, sino que proporciona una conveniente descripción general. Para obtener detalles completos, debe consultar la documentación de Python 2.6. Si desea comprender la justificación del diseño y la implementación, consulte el PEP de una característica nueva en particular. Siempre que sea posible, «Qué hay de nuevo en Python» enlaza con el elemento de error / parche para cada cambio.
Python 3.0¶
El ciclo de desarrollo de las versiones 2.6 y 3.0 de Python se sincronizó, y las versiones alfa y beta de ambos lanzamientos se realizaron los mismos días. El desarrollo de 3.0 ha influido en muchas características de 2.6.
Python 3.0 es un rediseño de Python de gran alcance que rompe la compatibilidad con la serie 2.x. Esto significa que el código Python existente necesitará alguna conversión para poder ejecutarse en Python 3.0. Sin embargo, no todos los cambios en 3.0 rompen necesariamente la compatibilidad. En los casos en que las nuevas funciones no provoquen la rotura del código existente, se han actualizado a 2.6 y se describen en este documento en el lugar correspondiente. Algunas de las características derivadas de 3.0 son:
El método
__complex__()
para convertir objetos en un número complejo.Sintaxis alternativa para detectar excepciones:
except TypeError as exc
.La adición de
functools.reduce()
como sinónimo de la función incorporadareduce()
.
Python 3.0 agrega varias funciones integradas nuevas y cambia la semántica de algunas integradas existentes. Las funciones que son nuevas en 3.0 como bin()
simplemente se han agregado a Python 2.6, pero las funciones existentes no se han cambiado; en cambio, el módulo future_builtins
tiene versiones con la nueva semántica 3.0. El código escrito puede ser compatible con 3.0 haciendo from future_builtins import hex, map
según sea necesario.
Un nuevo modificador de línea de comandos, -3
, habilita advertencias sobre características que se eliminarán en Python 3.0. Puede ejecutar código con este modificador para ver cuánto trabajo será necesario para migrar el código a 3.0. El valor de este modificador está disponible para el código Python como la variable booleana sys.py3kwarning
, y para el código de extensión C como Py_Py3kWarningFlag
.
Cambios en el proceso de desarrollo¶
Mientras se desarrollaba 2.6, el proceso de desarrollo de Python experimentó dos cambios significativos: cambiamos del seguidor de incidentes (issue tracker) de SourceForge a una instalación personalizada de Roundup, y la documentación se convirtió de LaTeX a reStructuredText.
Nuevo seguidor de incidentes: Roundup¶
Durante mucho tiempo, los desarrolladores de Python estaban cada vez más molestos por el seguidor de errores de SourceForge. La solución alojada en SourceForge no permite mucha personalización; por ejemplo, no fue posible personalizar el ciclo de vida de los problemas.
Por lo tanto, el comité de infraestructura de la Python Software Foundation publicó una convocatoria de rastreadores de problemas, solicitando voluntarios para configurar diferentes productos e importar algunos de los errores y parches de SourceForge. Se examinaron cuatro rastreadores diferentes: Jira, Launchpad, Roundup y Trac. El comité finalmente se decidió por Jira y Roundup como los dos candidatos. Jira es un producto comercial que ofrece instancias alojadas sin costo para proyectos de software libre; Roundup es un proyecto de código abierto que requiere voluntarios para administrarlo y un servidor para alojarlo.
Después de publicar una llamada para voluntarios, se configuró una nueva instalación de Roundup en https://bugs.python.org. Una instalación de Roundup puede alojar varios seguidores, y este servidor ahora también aloja seguidores de problemas para Jython y para el sitio web de Python. Seguramente encontrará otros usos en el futuro. Siempre que sea posible, esta edición de «Qué hay de nuevo en Python» se vincula al elemento de error/parche para cada cambio.
Upfront Systems de Stellenbosch, Sudáfrica, proporciona amablemente el alojamiento del rastreador de errores de Python. Martin von Löwis se esforzó mucho en importar errores y parches existentes desde SourceForge; Sus scripts para esta operación de importación están en https://svn.python.org/view/tracker/importer/
y pueden ser útiles para otros proyectos que deseen pasar de SourceForge a Roundup.
Ver también
- https://bugs.python.org
El seguidor de errores de Python.
- https://bugs.jython.org:
El seguidor de errores de Jython.
- https://roundup.sourceforge.io/
Descargas y documentación de Roundup.
- https://svn.python.org/view/tracker/importer/
Scripts de conversión de Martin von Löwis.
Nuevo formato de documentación: texto reestructurado con Sphinx¶
La documentación de Python se escribió usando LaTeX desde que el proyecto comenzó alrededor de 1989. En la década de 1980 y principios de la de 1990, la mayor parte de la documentación se imprimió para su estudio posterior, no se vio en línea. LaTeX fue ampliamente utilizado porque proporcionaba una salida impresa atractiva sin dejar de ser sencillo de escribir una vez que se aprendían las reglas básicas de marcado.
Hoy en día, LaTeX todavía se usa para escribir publicaciones destinadas a la impresión, pero el panorama de las herramientas de programación ha cambiado. Ya no imprimimos montones de documentación; en su lugar, lo navegamos en línea y HTML se ha convertido en el formato más importante para dar soporte. Desafortunadamente, convertir LaTeX a HTML es bastante complicado y Fred L. Drake Jr., el editor de documentación de Python desde hace mucho tiempo, pasó mucho tiempo manteniendo el proceso de conversión. De vez en cuando, la gente sugeriría convertir la documentación a SGML y luego a XML, pero realizar una buena conversión es una tarea importante y nadie comprometió el tiempo necesario para terminar el trabajo.
Durante el ciclo de desarrollo 2.6, Georg Brandl se esforzó mucho en construir una nueva cadena de herramientas para procesar la documentación. El paquete resultante se llama Sphinx y está disponible en https://www.sphinx-doc.org/.
Sphinx se concentra en la salida HTML, produciendo HTML moderno y con un estilo atractivo; la salida impresa todavía se admite mediante la conversión a LaTeX. El formato de entrada es reStructuredText, una sintaxis de marcado que admite extensiones y directivas personalizadas que se usa comúnmente en la comunidad de Python.
Sphinx es un paquete independiente que se puede usar para escribir, y casi dos docenas de otros proyectos (enumerados en el sitio web de Sphinx) han adoptado Sphinx como su herramienta de documentación.
Ver también
- Documentando Python
Describe cómo escribir para la documentación de Python.
- Sphinx
Documentación y código para la cadena de herramientas Sphinx.
- Docutils
El analizador sintáctico y el conjunto de herramientas reStructuredText subyacentes.
PEP 343: La sentencia “with”¶
La versión anterior, Python 2.5, agregó la instrucción “with
” como una característica opcional, para ser habilitada por una directiva from __future__ import with_statement
. En 2.6, la instrucción ya no necesita estar habilitada especialmente; esto significa que ahora with
es siempre una palabra clave. El resto de esta sección es una copia de la sección correspondiente del documento «Qué hay de nuevo en Python 2.5»; si está familiarizado con la declaración “with
” de Python 2.5, puede omitir esta sección.
La sentencia “with
” resuelve el código que anteriormente usaría bloques try...finally
para garantizar que el código de limpieza se ejecute. En esta sección, discutiré como se usará comúnmente la declaración. En la siguiente sección, examinaré los detalles de la implementación y mostraré cómo escribir objetos para usar con esta declaración.
La sentencia “with
” es una estructura de control de flujo cuya estructura básica es:
with expression [as variable]:
with-block
La expresión se evalúa y debe dar como resultado un objeto que admita el protocolo de administración de contexto (es decir, tiene los métodos __enter__()
y __exit__()
).
El objeto __enter__()
se llama antes de que se ejecute with-block y, por lo tanto, se puede ejecutar código de configuración. También, si se proporciona, puede retornar un valor que esté vinculado al nombre variable. (Tenga en cuenta que a la variable no se le asigna el resultado de la expression).
Una vez finalizada la ejecución de with-block, se llama al método __exit__()
del objeto, incluso si el bloque generó una excepción y, por lo tanto, puede ejecutar código de limpieza.
Algunos objetos estándar de Python ahora admiten el protocolo de administración de contexto y se pueden usar con la sentencia “with
”. Los objetos de archivo son un ejemplo:
with open('/etc/passwd', 'r') as f:
for line in f:
print line
... more processing code ...
Después de que se haya ejecutado esta sentencia, el objeto de archivo en f se habrá cerrado automáticamente, incluso si el bucle for
generó una excepción en la mitad del bloque.
Nota
En este caso, f es el mismo objeto creado por open()
, porque file.__enter__()
retorna self.
Los locks y las condiciones variables del módulo threading
también admiten la sentencia “with
”:
lock = threading.Lock()
with lock:
# Critical section of code
...
El lock se adquiere antes de que se ejecute el bloque y siempre se libera una vez que este se completa.
La función localcontext()
en el módulo decimal
facilita guardar y restaurar el contexto decimal actual, que encapsula la precisión deseada y las características de redondeo para los cálculos:
from decimal import Decimal, Context, localcontext
# Displays with default precision of 28 digits
v = Decimal('578')
print v.sqrt()
with localcontext(Context(prec=16)):
# All code in this block uses a precision of 16 digits.
# The original context is restored on exiting the block.
print v.sqrt()
Escribiendo gestores de contexto¶
Por detrás, la sentencia “with
” es bastante complicada. La mayoría de las personas solo usarán “with
” en compañía de objetos existentes y no necesitan conocer estos detalles, por lo que puede omitir el resto de esta sección si lo desea. Los autores de nuevos objetos deberán comprender los detalles de la implementación subyacente y deben seguir leyendo.
Una explicación de alto nivel del protocolo de gestor de contexto es:
La expresión se evalúa y debería dar como resultado un objeto llamado «gestor de contexto». El gestor de contexto debe tener los métodos
__enter__()
y__exit__()
.Se llama al método
__enter__()
del gestor de contexto. El valor retornado se asigna a VAR. Si no hay una cláusulaas VAR
, el valor simplemente se descarta.Se ejecuta el código en BLOCK.
Si BLOCK lanza una excepción, se llama al método
__exit__()
del gestor de contexto con tres argumentos, los detalles de la excepción (type, value, traceback
, los mismos valores retornados porsys.exc_info()
, que también puede serNone
si no se produjo ninguna excepción). El valor de retorno del método controla si se vuelve a generar una excepción: cualquier valor false vuelve a lanzar la excepción, yTrue
resultará en inhibirla. Rara vez querrá suprimir la excepción, porque si lo hace, el autor del código que contenga la sentencia “with
” nunca se dará cuenta de que algo salió mal.Si BLOCK no lanzó una excepción, el método
__exit__()
continúa llamándose, pero type, value y traceback son todosNone
.
Pensemos en un ejemplo. No presentaré un código detallado, solo bosquejaré los métodos necesarios para una base de datos que admita transacciones.
(Para las personas que no están familiarizadas con la terminología de la base de datos: un conjunto de cambios en la base de datos se agrupa en una transacción. Las transacciones pueden confirmarse, lo que significa que todos los cambios se escriben en la base de datos, o deshacerse, lo que significa que todos los cambios se descartan y la base de datos no ha cambiado. Consulte cualquier libro de texto de base de datos para obtener más información.)
Supongamos que hay un objeto que representa una conexión de base de datos. Nuestro objetivo será permitir que el usuario escriba un código como este:
db_connection = DatabaseConnection()
with db_connection as cursor:
cursor.execute('insert into ...')
cursor.execute('delete from ...')
# ... more operations ...
La transacción debe confirmarse si el código del bloque se ejecuta sin problemas o revertirse si hay una excepción. Aquí está la interfaz básica para DatabaseConnection
que asumiré:
class DatabaseConnection:
# Database interface
def cursor(self):
"Returns a cursor object and starts a new transaction"
def commit(self):
"Commits current transaction"
def rollback(self):
"Rolls back current transaction"
El método __enter__()
es bastante fácil, ya que solo tiene que iniciar una nueva transacción. Para esta aplicación, el objeto cursor resultante sería un resultado útil, por lo que el método lo retornará. Luego, el usuario puede agregar as cursor
a su sentencia “with
” para vincular el cursor a un nombre de variable.
class DatabaseConnection:
...
def __enter__(self):
# Code to start a new transaction
cursor = self.cursor()
return cursor
El método __exit__()
es el más complicado porque es donde se debe realizar la mayor parte del trabajo. El método debe verificar si ocurrió una excepción. Si no hubo excepción, la transacción se confirma. La transacción se revierte si hubo una excepción.
En el siguiente código, la ejecución simplemente caerá al final de la función, retornando el valor predeterminado None
. None
es falso, por lo que la excepción se volverá a lanzar automáticamente. Si lo desea, puede ser más explícito y agregar una sentencia return
en la ubicación marcada.
class DatabaseConnection:
...
def __exit__(self, type, value, tb):
if tb is None:
# No exception, so commit
self.commit()
else:
# Exception occurred, so rollback.
self.rollback()
# return False
El módulo contextlib¶
El módulo contextlib
proporciona algunas funciones y un decorador que son útiles al escribir objetos para usar con la sentencia “with
”.
El decorador se llama contextmanager()
, y te permite escribir una única función generadora en lugar de definir una clase nueva. El generador debería producir exactamente un valor. El código hasta yield
se ejecutará como el método __enter__()
, y el valor obtenido será el valor de retorno del método que se vinculará a la variable en la clausula as
(si la hay) de la sentencia “with
”. El código después de yield
se ejecutará en el método __exit__()
. Cualquier excepción lanzada en el bloque será generada por la sentencia yield
.
Usando este decorador, nuestro ejemplo de base de datos de la sección anterior podría escribirse como:
from contextlib import contextmanager
@contextmanager
def db_transaction(connection):
cursor = connection.cursor()
try:
yield cursor
except:
connection.rollback()
raise
else:
connection.commit()
db = DatabaseConnection()
with db_transaction(db) as cursor:
...
El módulo contextlib
también tiene una función nested(mgr1, mgr2, ...)
que combina varios gestores de contexto para que no necesite escribir sentencias “with
” anidadas. En este ejemplo, se utiliza una única sentencia “with
” que inicia una transacción de base de datos y adquiere un bloqueo del hilo:
lock = threading.Lock()
with nested (db_transaction(db), lock) as (cursor, locked):
...
Por último, la función close()
retorna su argumento para que pueda vincularse a una variable, y llama al método .close()
del argumento al final del bloque.
import urllib, sys
from contextlib import closing
with closing(urllib.urlopen('http://www.yahoo.com')) as f:
for line in f:
sys.stdout.write(line)
Ver también
- PEP 343 - La sentencia «with»
PEP escrito por Guido van Rossum y Nick Coghlan; implementado por Mike Bland, Guido van Rossum y Neal Norwitz. El PEP muestra el código generado para una sentencia “
with
”, que puede ser útil para aprender cómo la sentencia funciona.
La documentación para el módulo contextlib
.
PEP 366: Importaciones relativas explícitas desde un módulo principal¶
El modificador de Python -m
permite ejecutar un módulo como un script. Cuando ejecutabas un módulo que estaba ubicado dentro de un paquete, las importaciones relativas no funcionaban correctamente.
La corrección para Python 2.6 agrega un atributo __package__
a los módulos. Cuando este atributo está presente, las importaciones relativas serán relativas al valor de este atributo en lugar del atributo __name__
.
Las importaciones de estilo PEP 302 pueden configurar __package__
según sea necesario. El módulo runpy
que implementa el modificador -m
ahora hace esto, por lo que las importaciones relativas ahora funcionarán correctamente en los scripts que se ejecutan desde el interior de un paquete.
PEP 370: Directorio de site-packages
por usuario¶
Cuando ejecuta Python, la ruta de búsqueda del módulo sys.path
generalmente incluye un directorio cuya ruta termina en "site-packages"
. Este directorio está destinado a contener paquetes instalados localmente disponibles para todos los usuarios que utilizan una máquina o un sitio de instalación en particular.
Python 2.6 introduce una convención para directorios de sitios específicos del usuario. El directorio varía según la plataforma:
Unix y Mac OS X:
~/.local/
Windows:
%APPDATA%/Python
Dentro de este directorio, habrá subdirectorios específicos de versión, como lib/python2.6/site-packages
en Unix/Mac OS y Python26/site-packages
en Windows.
Si no le gusta el directorio predeterminado, puede sobrescribirlo mediante una variable de entorno. PYTHONUSERBASE
establece el directorio raíz utilizado para todas las versiones de Python que admiten esta función. En Windows, el directorio de datos específicos de la aplicación se puede cambiar configurando la variable de entorno APPDATA
. También puede modificar el archivo site.py
para su instalación de Python.
La característica se puede desactivar por completo ejecutando Python con la opción -s
o seteando la variable de entorno PYTHONNOUSERSITE
.
Ver también
- PEP 370: Directorio de
site-packages
por usuario PEP escrito e implementado por Christian Heimes.
PEP 371: El paquete multiprocessing
¶
El nuevo paquete multiprocessing
permite a los programas de Python crear nuevos procesos que realizarán un cálculo y retornaran un resultado al padre. Los procesos padre e hijo pueden comunicarse mediante colas (queues) y tuberías (pipes), sincronizar sus operaciones mediante bloqueos y semáforos, y pueden compartir matrices simples de datos.
El módulo multiprocessing
comenzó como una emulación exacta del módulo threading
usando procesos en lugar de hilos. Ese objetivo se descartó en el camino a Python 2.6, pero el enfoque general del módulo sigue siendo similar. La clase fundamental es Process
, a la que se le pasa un objeto invocable y una colección de argumentos. El método start()
establece el invocable ejecutándose en un subproceso, después de lo cual se puede llamar al método is_alive()
para verificar si el subproceso aún se está ejecutando y al método join()
para esperar al proceso para salir.
Aquí hay un ejemplo simple donde el subproceso calculará un factorial. La función que realiza el cálculo está escrita de forma extraña, por lo que lleva mucho más tiempo cuando el argumento de entrada es un múltiplo de 4.
import time
from multiprocessing import Process, Queue
def factorial(queue, N):
"Compute a factorial."
# If N is a multiple of 4, this function will take much longer.
if (N % 4) == 0:
time.sleep(.05 * N/4)
# Calculate the result
fact = 1L
for i in range(1, N+1):
fact = fact * i
# Put the result on the queue
queue.put(fact)
if __name__ == '__main__':
queue = Queue()
N = 5
p = Process(target=factorial, args=(queue, N))
p.start()
p.join()
result = queue.get()
print 'Factorial', N, '=', result
Un Queue
se usa para comunicar el resultado del factorial. El objeto Queue
se almacena en una variable global. El proceso hijo usará el valor de la variable cuando se creó el hijo; porque es una Queue
, padre e hijo pueden usar el objeto para comunicarse. (Si el padre cambiara el valor de la variable global, el valor del hijo no se vería afectado y viceversa).
Otras dos clases, Pool
y Manager
, proporcionan interfaces de nivel superior. Pool
creará un número fijo de procesos de trabajo, y las solicitudes se pueden distribuir a los trabajadores llamando a apply()
o apply_async()
para agregar una sola solicitud, y map()
o map_async()
para agregar una serie de solicitudes. El siguiente código usa Pool
para distribuir las solicitudes en 5 procesos de trabajo y recuperar una lista de resultados:
from multiprocessing import Pool
def factorial(N, dictionary):
"Compute a factorial."
...
p = Pool(5)
result = p.map(factorial, range(1, 1000, 10))
for v in result:
print v
Esto produce la siguiente salida:
1
39916800
51090942171709440000
8222838654177922817725562880000000
33452526613163807108170062053440751665152000000000
...
La otra interfaz de alto nivel, la clase Manager
, crea un proceso de servidor separado que puede contener copias maestras de las estructuras de datos de Python. Luego, otros procesos pueden acceder y modificar estas estructuras de datos utilizando objetos proxy. El siguiente ejemplo crea un diccionario compartido llamando al método dict()
; los procesos de trabajo luego insertan valores en el diccionario. (El bloqueo no se realiza automáticamente, lo cual no importa en este ejemplo. Los métodos de Manager
también incluyen Lock()
, RLock()
, y Semaphore()
para crear bloqueos compartidos.)
import time
from multiprocessing import Pool, Manager
def factorial(N, dictionary):
"Compute a factorial."
# Calculate the result
fact = 1L
for i in range(1, N+1):
fact = fact * i
# Store result in dictionary
dictionary[N] = fact
if __name__ == '__main__':
p = Pool(5)
mgr = Manager()
d = mgr.dict() # Create shared dictionary
# Run tasks using the pool
for N in range(1, 1000, 10):
p.apply_async(factorial, (N, d))
# Mark pool as closed -- no more tasks can be added.
p.close()
# Wait for tasks to exit
p.join()
# Output results
for k, v in sorted(d.items()):
print k, v
Esto producirá la salida:
1 1
11 39916800
21 51090942171709440000
31 8222838654177922817725562880000000
41 33452526613163807108170062053440751665152000000000
51 15511187532873822802242430164693032110632597200169861120000...
Ver también
La documentación del módulo multiprocessing
.
- PEP 371 - Adición del paquete de multiprocesamiento
PEP escrito por Jesse Noller y Richard Oudkerk; implementado por Richard Oudkerk y Jesse Noller.
PEP 3101: Formateo avanzado de cadena de caracteres¶
En Python 3.0, el operador %
se complementa con un método de formato de cadena más potente, format()
. La compatibilidad con el método str.format()
se ha retroalimentado a Python 2.6.
En 2.6, tanto las cadenas de 8 bits como las Unicode tienen un método .format()
que trata la cadena como una plantilla y toma los argumentos para formatear. La plantilla de formato utiliza llaves ({
, }
) como caracteres especiales:
>>> # Substitute positional argument 0 into the string.
>>> "User ID: {0}".format("root")
'User ID: root'
>>> # Use the named keyword arguments
>>> "User ID: {uid} Last seen: {last_login}".format(
... uid="root",
... last_login = "5 Mar 2008 07:20")
'User ID: root Last seen: 5 Mar 2008 07:20'
Las llaves se pueden escapar duplicándose:
>>> "Empty dict: {{}}".format()
"Empty dict: {}"
Los nombres de campo pueden ser números enteros que indican argumentos posicionales, como {0}
, {1}
, etc. o nombres de argumentos de palabras clave. También puede proporcionar nombres de campos compuestos que lean atributos o accedan a claves de diccionario:
>>> import sys
>>> print 'Platform: {0.platform}\nPython version: {0.version}'.format(sys)
Platform: darwin
Python version: 2.6a1+ (trunk:61261M, Mar 5 2008, 20:29:41)
[GCC 4.0.1 (Apple Computer, Inc. build 5367)]'
>>> import mimetypes
>>> 'Content-type: {0[.mp4]}'.format(mimetypes.types_map)
'Content-type: video/mp4'
Tenga en cuenta que cuando utilice una notación de estilo diccionario como [.mp4]
, no es necesario poner comillas alrededor de la cadena; se buscará el valor usando .mp4
como clave. Las cadenas de caracteres que comienzan con un número se convertirán en entero. No puede escribir expresiones más complicadas dentro de una cadena de formato.
Hasta ahora hemos mostrado cómo especificar qué campo sustituir en la cadena resultante. El formato preciso utilizado también se puede controlar agregando dos puntos seguidos de un especificador de formato. Por ejemplo:
>>> # Field 0: left justify, pad to 15 characters
>>> # Field 1: right justify, pad to 6 characters
>>> fmt = '{0:15} ${1:>6}'
>>> fmt.format('Registration', 35)
'Registration $ 35'
>>> fmt.format('Tutorial', 50)
'Tutorial $ 50'
>>> fmt.format('Banquet', 125)
'Banquet $ 125'
Los especificadores de formato pueden hacer referencia a otros campos a través del anidamiento:
>>> fmt = '{0:{1}}'
>>> width = 15
>>> fmt.format('Invoice #1234', width)
'Invoice #1234 '
>>> width = 35
>>> fmt.format('Invoice #1234', width)
'Invoice #1234 '
Se puede especificar la alineación de un campo dentro del ancho deseado:
Carácter |
Efecto |
---|---|
< (por defecto) |
Alinear a la izquierda |
> |
Alinear a la derecha |
^ |
Centrado |
= |
(Solo para tipos numéricos) Relleno después del signo. |
Los especificadores de formato también pueden incluir un tipo de presentación, que controla cómo se formatea el valor. Por ejemplo, los números de punto flotante pueden formatearse como un número general o en notación exponencial:
>>> '{0:g}'.format(3.75)
'3.75'
>>> '{0:e}'.format(3.75)
'3.750000e+00'
Hay una variedad de tipos de presentación disponibles. Consulte la documentación 2.6 para obtener una lista completa; aquí hay un ejemplo:
|
Binario. Emite el número en base 2. |
|
Carácter. Convierte el número entero en el carácter Unicode correspondiente antes de imprimirlo. |
|
Entero Decimal. Muestra el número en base 10. |
|
Formato octal. Da salida al número en base 8. |
|
Formato hexadecimal. Muestra el número en base 16, utilizando letras minúsculas para los dígitos superiores a 9. |
|
Notación de exponente. Imprime el número en notación científica utilizando la letra “e” para indicar el exponente. |
|
Formato general. Esto imprime el número como un número de punto fijo, a menos que el número sea demasiado grande, en cuyo caso cambia a la notación de exponente “e”. |
|
Número. Es lo mismo que “g” (para flotantes) o “d” (para enteros), salvo que utiliza la configuración regional actual para insertar los caracteres separadores de números adecuados. |
|
Porcentaje. Multiplica el número por 100 y lo muestra en formato fijo (“f”), seguido de un signo de porcentaje. |
Las clases y los tipos pueden definir un método __format__()
para controlar cómo se formatean. Recibe un único argumento, el especificador de formato:
def __format__(self, format_spec):
if isinstance(format_spec, unicode):
return unicode(str(self))
else:
return str(self)
También hay un builtin format()
que formateará un solo valor. Llama al método __format__()
del tipo con el especificador proporcionado:
>>> format(75.6564, '.2f')
'75.66'
Ver también
- Sintaxis de formateo de cadena
La documentación de referencia para los campos de formato.
- PEP 3101 - Formato avanzado de cadenas
PEP escrito por Talin. Implementado por Eric Smith.
PEP 3105: print
como función¶
La sentencia print
se convierte en la función print()
en Python 3.0. Hacer de print()
una función hace posible reemplazar la función haciendo def print(...)
o importando una nueva función desde otro lugar.
Python 2.6 tiene una importación __future__
que elimina print
como sintaxis del lenguaje, permitiéndote usar la forma funcional en su lugar. Por ejemplo:
>>> from __future__ import print_function
>>> print('# of entries', len(dictionary), file=sys.stderr)
La firma de la nueva función es:
def print(*args, sep=' ', end='\n', file=None)
Los parámetros son:
args: argumentos posicionales cuyos valores se imprimirán.
sep: el separador que se imprimirá entre los argumentos.
end: el texto final, que se imprimirá después de que se hayan emitido todos los argumentos.
archivo: el objeto archivo al que se enviará la salida.
Ver también
- PEP 3105 - Hacer de la impresión una función
PEP escrito por Georg Brandl.
PEP 3110: Cambios en el manejo de excepciones¶
Un error que ocasionalmente cometen los programadores de Python es escribir el siguiente código:
try:
...
except TypeError, ValueError: # Wrong!
...
El autor probablemente está tratando de atrapar ambas excepciones TypeError
y ValueError
, pero este código en realidad hace algo diferente: atrapará TypeError
y vinculará el objeto de excepción resultante al nombre local "ValueError"
. La excepción ValueError
no será capturada en absoluto. El código correcto especifica una tupla de excepciones:
try:
...
except (TypeError, ValueError):
...
Este error se produce porque el uso de la coma aquí es ambiguo: ¿indica dos nodos diferentes en el árbol de análisis sintáctico, o un único nodo que es una tupla?
Python 3.0 hace que esto sea inequívoco al sustituir la coma por la palabra «as». Para atrapar una excepción y almacenar el objeto de excepción en la variable exc
, debes escribir:
try:
...
except TypeError as exc:
...
Python 3.0 sólo soporta el uso de «as», y por lo tanto interpreta el primer ejemplo como la captura de dos excepciones diferentes. Python 2.6 soporta tanto la coma como «as», por lo que el código existente seguirá funcionando. Por lo tanto, sugerimos utilizar «as» cuando se escriba nuevo código Python que sólo se ejecutará con la versión 2.6.
Ver también
- PEP 3110 - Captura de excepciones en Python 3000
PEP escrito y ejecutado por Collin Winter.
PEP 3112: Literales de bytes¶
Python 3.0 adopta Unicode como el tipo de cadena fundamental del lenguaje y denota los literales de 8 bits de forma diferente, ya sea como b'string
o utilizando un constructor bytes
. Por compatibilidad futura, Python 2.6 añade bytes
como sinónimo del tipo str
, y también soporta la notación b''
.
El tipo str
de la versión 2.6 difiere del tipo bytes
de la versión 3.0 en varios aspectos; el más notable es que el constructor es completamente diferente. En la 3.0, bytes([65, 66, 67])
tiene 3 elementos, que contienen los bytes que representan ABC
; en la 2.6, bytes([65, 66, 67])
devuelve la cadena de 12 bytes que representa el str()
de la lista.
El uso principal de bytes
en 2.6 será escribir pruebas de tipo de objeto como isinstance(x, bytes)
. Esto ayudará al convertidor de 2 a 3, que no puede decir si el código de 2.x pretende que las cadenas contengan caracteres o bytes de 8 bits; ahora puede utilizar bytes
o str
para representar su intención exactamente, y el código resultante también será correcto en Python 3.0.
También hay una importación __future__
que hace que todos los literales de cadena se conviertan en cadenas Unicode. Esto significa que las secuencias de escape u
pueden ser utilizadas para incluir caracteres Unicode:
from __future__ import unicode_literals
s = ('\u751f\u3080\u304e\u3000\u751f\u3054'
'\u3081\u3000\u751f\u305f\u307e\u3054')
print len(s) # 12 Unicode characters
A nivel de C, Python 3.0 renombrará el tipo de cadena de 8 bits existente, llamado PyStringObject
en Python 2.x, a PyBytesObject
. Python 2.6 utiliza #define
para soportar el uso de los nombres PyBytesObject()
, PyBytes_Check()
, PyBytes_FromStringAndSize()
, y todas las demás funciones y macros utilizadas con cadenas.
Las instancias del tipo bytes
son inmutables al igual que las cadenas. Un nuevo tipo bytearray
almacena una secuencia mutable de bytes:
>>> bytearray([65, 66, 67])
bytearray(b'ABC')
>>> b = bytearray(u'\u21ef\u3244', 'utf-8')
>>> b
bytearray(b'\xe2\x87\xaf\xe3\x89\x84')
>>> b[0] = '\xe3'
>>> b
bytearray(b'\xe3\x87\xaf\xe3\x89\x84')
>>> unicode(str(b), 'utf-8')
u'\u31ef \u3244'
Las matrices de bytes admiten la mayoría de los métodos de los tipos de cadena, como startswith()
/endswith()
, find()
/rfind()
, y algunos de los métodos de las listas, como append()
, pop()
y reverse()
.
>>> b = bytearray('ABC')
>>> b.append('d')
>>> b.append(ord('e'))
>>> b
bytearray(b'ABCde')
También existe la correspondiente API en C, con PyByteArray_FromObject()
, PyByteArray_FromStringAndSize()
, y varias otras funciones.
Ver también
- PEP 3112 - Literales de bytes en Python 3000
PEP escrito por Jason Orendorff; retroalimentado a 2.6 por Christian Heimes.
PEP 3116: Nueva biblioteca de E/S¶
Los objetos de archivo incorporados en Python soportan una serie de métodos, pero los objetos que imitan a los archivos no necesariamente los soportan todos. Los objetos que imitan a los archivos normalmente soportan read()
y write()
, pero pueden no soportar readline()
, por ejemplo. Python 3.0 introduce una biblioteca de E/S por capas en el módulo io
que separa las funciones de almacenamiento en búfer y manejo de texto de las operaciones fundamentales de lectura y escritura.
Existen tres niveles de clases base abstractas proporcionadas por el módulo io
:
RawIOBase
define las operaciones de E/S en bruto:read()
,readinto()
,write()
,seek()
,tell()
,truncate()
, yclose()
. La mayoría de los métodos de esta clase suelen corresponder a una única llamada al sistema. También hay métodosreadable()
,writable()
yseekable()
para determinar qué operaciones permite un objeto dado.Python 3.0 tiene implementaciones concretas de esta clase para archivos y sockets, pero Python 2.6 no ha reestructurado sus objetos archivo y socket de esta manera.
BufferedIOBase
es una clase base abstracta que almacena los datos en la memoria para reducir el número de llamadas al sistema, haciendo más eficiente el procesamiento de E/S. Soporta todos los métodos deRawIOBase
, y añade un atributoraw
que contiene el objeto crudo subyacente.Hay cinco clases concretas que implementan este ABC.
BufferedWriter
yBufferedReader
son para objetos que soportan el uso de sólo escritura o de sólo lectura que tienen un métodoseek()
para el acceso aleatorio. Los objetosBufferedRandom
soportan el acceso de lectura y escritura sobre el mismo flujo subyacente, yBufferedRWPair
es para objetos como los TTYs que tienen operaciones de lectura y escritura actuando sobre flujos de datos desconectados. La claseBytesIO
permite leer, escribir y buscar sobre un buffer en memoria.TextIOBase
: Proporciona funciones para leer y escribir cadenas (recuerde que las cadenas serán Unicode en Python 3.0), y soporta universal newlines.TextIOBase
define el métodoreadline()
y soporta la iteración sobre objetos.Hay dos implementaciones concretas.
TextIOWrapper
envuelve un objeto de E/S con buffer, soportando todos los métodos de E/S de texto y añadiendo un atributobuffer
para acceder al objeto subyacente.StringIO
simplemente almacena todo en memoria sin escribir nunca nada en el disco.(En Python 2.6,
io.StringIO
está implementado en Python puro, por lo que es bastante lento. Por lo tanto, deberías seguir con el móduloStringIO
existente o concStringIO
por ahora. En algún momento el móduloio
de Python 3.0 será reescrito en C para aumentar la velocidad, y quizás la implementación en C será retroalimentada a las versiones 2.x)
En Python 2.6, las implementaciones subyacentes no han sido reestructuradas para construir sobre las clases del módulo io
. El módulo se proporciona para facilitar la escritura de código compatible con la versión 3.0, y para ahorrar a los desarrolladores el esfuerzo de escribir sus propias implementaciones de búfer y E/S de texto.
Ver también
- PEP 3116 - Nueva E/S
PEP escrito por Daniel Stutzbach, Mike Verdone y Guido van Rossum. Código de Guido van Rossum, Georg Brandl, Walter Doerwald, Jeremy Hylton, Martin von Löwis, Tony Lownds y otros.
PEP 3118: Protocolo revisado de la memoria intermedia¶
El protocolo de búferes es una API de nivel C que permite a los tipos de Python intercambiar punteros a sus representaciones internas. Un archivo mapeado en memoria puede ser visto como un buffer de caracteres, por ejemplo, y esto permite que otro módulo como re
trate los archivos mapeados en memoria como una cadena de caracteres a buscar.
Los principales usuarios del protocolo de búferes son los paquetes de procesamiento numérico como NumPy, que exponen la representación interna de los arrays para que los invocadores puedan escribir datos directamente en un array en lugar de pasar por una API más lenta. Este PEP actualiza el protocolo de búfer a la luz de la experiencia del desarrollo de NumPy, añadiendo una serie de nuevas características como la indicación de la forma de un array o el bloqueo de una región de memoria.
La nueva función más importante de la API en C es PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
, que toma un objeto y un conjunto de flags, y rellena la estructura Py_buffer
con información sobre la representación en memoria del objeto. Los objetos pueden utilizar esta operación para bloquear la memoria en su lugar mientras un llamador externo podría estar modificando el contenido, por lo que hay un correspondiente PyBuffer_Release(Py_buffer *view)
para indicar que el llamador externo ha terminado.
El argumento flags de PyObject_GetBuffer()
especifica las restricciones de la memoria devuelta. Algunos ejemplos son:
PyBUF_WRITABLE
indica que la memoria debe ser grabable.
PyBUF_LOCK
solicita un bloqueo de sólo lectura o exclusivo en la memoria.
PyBUF_C_CONTIGUOUS
yPyBUF_F_CONTIGUOUS
solicitan una disposición de matriz contigua en C (la última dimensión varía más rápidamente) o contigua en Fortran (la primera dimensión varía más rápidamente).
Dos nuevos códigos de argumento para PyArg_ParseTuple()
, s*
y z*
, devuelven objetos buffer bloqueados para un parámetro.
Ver también
- PEP 3118 - Revisión del protocolo del buffer
PEP escrito por Travis Oliphant y Carl Banks; implementado por Travis Oliphant.
PEP 3119: Clases base abstractas¶
Algunos lenguajes orientados a objetos, como Java, admiten interfaces, que declaran que una clase tiene un determinado conjunto de métodos o admite un determinado protocolo de acceso. Las clases base abstractas (o ABC) son una característica equivalente para Python. El soporte de ABC consiste en un módulo abc
que contiene una metaclase llamada ABCMeta
, un manejo especial de esta metaclase por parte de los builtins isinstance()
y issubclass()
, y una colección de ABCs básicas que los desarrolladores de Python creen que serán ampliamente útiles. Las futuras versiones de Python probablemente añadirán más ABCs.
Supongamos que tiene una clase concreta y desea saber si admite el acceso tipo diccionario. Sin embargo, la frase «estilo diccionario» es vaga. Probablemente significa que el acceso a los elementos con obj[1]
funciona. ¿Implica que el establecimiento de elementos con obj[2] = valor
funciona? ¿O que el objeto tendrá métodos keys()
, values()
y items()
? ¿Qué pasa con las variantes iterativas como iterkeys()
? copy()
y update()
? ¿Iterar sobre el objeto con iter()
?
El módulo collections
de Python 2.6 incluye un número de ABCs diferentes que representan estas distinciones. Iterable
indica que una clase define __iter__()
, y Container
significa que la clase define un método __contains__()
y por lo tanto soporta expresiones x in y
. La interfaz básica del diccionario para obtener elementos, establecer elementos, y llaves()
, valores()
, y elementos()
, está definida por el MutableMapping
ABC.
Puedes derivar tus propias clases de un ABC particular para indicar que soportan la interfaz de ese ABC:
import collections
class Storage(collections.MutableMapping):
...
Alternativamente, puede escribir la clase sin derivar del ABC deseado y en su lugar registrar la clase llamando al método register()
del ABC:
import collections
class Storage:
...
collections.MutableMapping.register(Storage)
Para las clases que usted escribe, derivar del ABC es probablemente más claro. El método register()
es útil cuando has escrito un nuevo ABC que puede describir un tipo o clase existente, o si quieres declarar que alguna clase de terceros implementa un ABC. Por ejemplo, si has definido un PrintableType
ABC, es legal hacer:
# Register Python's types
PrintableType.register(int)
PrintableType.register(float)
PrintableType.register(str)
Las clases deben obedecer la semántica especificada por un ABC, pero Python no puede comprobarlo; depende del autor de la clase entender los requisitos del ABC e implementar el código en consecuencia.
Para comprobar si un objeto es compatible con una determinada interfaz, ahora se puede escribir:
def func(d):
if not isinstance(d, collections.MutableMapping):
raise ValueError("Mapping object expected, not %r" % d)
No sientas que ahora debes empezar a escribir muchas comprobaciones como en el ejemplo anterior. Python tiene una fuerte tradición de «duck-typing», donde la comprobación explícita de tipos nunca se hace y el código simplemente llama a los métodos de un objeto, confiando en que esos métodos estarán ahí y lanzando una excepción si no lo están. Sea juicioso al comprobar el ABC y hágalo sólo cuando sea absolutamente necesario.
Puedes escribir tu propio ABC utilizando abc.ABCMeta
como metaclase en una definición de clase:
from abc import ABCMeta, abstractmethod
class Drawable():
__metaclass__ = ABCMeta
@abstractmethod
def draw(self, x, y, scale=1.0):
pass
def draw_doubled(self, x, y):
self.draw(x, y, scale=2.0)
class Square(Drawable):
def draw(self, x, y, scale):
...
En el ABC de Drawable
anterior, el método draw_doubled()
renderiza el objeto al doble de su tamaño y puede ser implementado en términos de otros métodos descritos en Drawable
. Las clases que implementan este ABC no necesitan proporcionar su propia implementación de draw_doubled()
, aunque pueden hacerlo. Sin embargo, es necesaria una implementación de draw()
; el ABC no puede proporcionar una implementación genérica útil.
Puedes aplicar el decorador @abstractmethod
a métodos como draw()
que deben ser implementados; Python lanzará una excepción para las clases que no definan el método. Ten en cuenta que la excepción sólo se produce cuando intentas crear una instancia de una subclase que carece del método:
>>> class Circle(Drawable):
... pass
...
>>> c = Circle()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Circle with abstract methods draw
>>>
Los atributos de datos abstractos pueden declararse utilizando el decorador @abstractproperty
:
from abc import abstractproperty
...
@abstractproperty
def readonly(self):
return self._x
Las subclases deben definir una propiedad readonly()
.
Ver también
- PEP 3119 - Presentación de las clases base abstractas
PEP escrito por Guido van Rossum y Talin. Implementado por Guido van Rossum. Adaptado a la versión 2.6 por Benjamin Aranguren, con Alex Martelli.
PEP 3127: Soporte y sintaxis de literales enteros¶
Python 3.0 cambia la sintaxis de los literales enteros octales (base-8), prefijándolos con «0o» o «0O» en lugar de un cero inicial, y añade soporte para los literales enteros binarios (base-2), señalados con un prefijo «0b» o «0B».
Python 2.6 no elimina el soporte para el 0 inicial que señala un número octal, pero sí añade soporte para «0o» y «0b»:
>>> 0o21, 2*8 + 1
(17, 17)
>>> 0b101111
47
La función oct()
sigue devolviendo números prefijados con un cero a la izquierda, y la nueva función bin()
devuelve la representación binaria de un número:
>>> oct(42)
'052'
>>> future_builtins.oct(42)
'0o52'
>>> bin(173)
'0b10101101'
Las funciones built-in int()
y long()
aceptarán ahora los prefijos «0o» y «0b» cuando se solicite base-8 o base-2, o cuando el argumento base sea cero (indicando que la base utilizada debe determinarse a partir de la cadena):
>>> int ('0o52', 0)
42
>>> int('1101', 2)
13
>>> int('0b1101', 2)
13
>>> int('0b1101', 0)
13
Ver también
- PEP 3127 - Soporte y sintaxis de literales enteros
PEP escrito por Patrick Maupin; retroalimentado a 2.6 por Eric Smith.
PEP 3129: Decoradores de clase¶
Los decoradores se han ampliado de funciones a clases. Ahora es legal escribir:
@foo
@bar
class A:
pass
Esto equivale a:
class A:
pass
A = foo(bar(A))
Ver también
- PEP 3129 - Decoradores de clase
PEP escrito por Collin Winter.
PEP 3141: Una jerarquía de tipos para los números¶
Python 3.0 añade varias clases base abstractas para tipos numéricos inspiradas en la torre numérica de Scheme. Estas clases fueron retrocedidas a la versión 2.6 como el módulo numbers
.
El ABC más general es Number
. No define ninguna operación, y sólo existe para permitir comprobar si un objeto es un número haciendo isinstance(obj, Number)
.
Complex
es una subclase de Number
. Los números complejos pueden someterse a las operaciones básicas de suma, resta, multiplicación, división y exponenciación, y se pueden recuperar las partes real e imaginaria y obtener el conjugado de un número. El tipo complejo incorporado en Python es una implementación de Complex
.
Real
deriva a su vez de Complex
, y añade operaciones que sólo funcionan con números reales: floor()
, trunc()
, redondeo, toma del resto mod N, división entera a la baja y comparaciones.
Los números Rational
derivan de Real
, tienen las propiedades numerator
y denominator
, y se pueden convertir en flotantes. Python 2.6 añade una clase simple de números racionales, Fraction
, en el módulo fractions
. (Se llama Fraction
en lugar de Rational
para evitar un choque de nombres con numbers.Rational
)
Los números de Integral
derivan de Rational
, y pueden desplazarse a la izquierda y a la derecha con <
y >`
, combinarse utilizando operaciones de bits como &
y |
, y pueden utilizarse como índices de matrices y límites de cortes.
En Python 3.0, el PEP redefine ligeramente las funciones integradas existentes round()
, math.floor()
, math.ceil()
, y añade uno nuevo, math.trunc()
, que ha sido retrocedido a Python 2.6. math.trunc()
redondea hacia cero, devolviendo el Integral
más cercano que esté entre el argumento de la función y cero.
Ver también
- PEP 3141 - Una jerarquía de tipos para los números
PEP escrito por Jeffrey Yasskin.
Torre numérica del esquema, del manual de Guile.
Scheme’s number datatypes de la especificación del esquema R5RS.
El módulo fractions
¶
Para completar la jerarquía de tipos numéricos, el módulo fractions
proporciona una clase de números racionales. Los números racionales almacenan sus valores como un numerador y un denominador que forman una fracción, y pueden representar exactamente números como 2/3
que los números de punto flotante sólo pueden aproximar.
El constructor Fraction
toma dos valores Integral
que serán el numerador y el denominador de la fracción resultante.
>>> from fractions import Fraction
>>> a = Fraction(2, 3)
>>> b = Fraction(2, 5)
>>> float(a), float(b)
(0.66666666666666663, 0.40000000000000002)
>>> a+b
Fraction(16, 15)
>>> a/b
Fraction(5, 3)
Para convertir números de punto flotante en racionales, el tipo float tiene ahora un método as_integer_ratio()
que devuelve el numerador y el denominador de una fracción que se evalúa al mismo valor de punto flotante:
>>> (2.5) .as_integer_ratio()
(5, 2)
>>> (3.1415) .as_integer_ratio()
(7074029114692207L, 2251799813685248L)
>>> (1./3) .as_integer_ratio()
(6004799503160661L, 18014398509481984L)
Tenga en cuenta que los valores que sólo pueden ser aproximados por números de punto flotante, como 1,/3, no se simplifican al número que se está aproximando; la fracción intenta coincidir con el valor de punto flotante exactamente.
El módulo fractions
se basa en una implementación de Sjoerd Mullender que estuvo en el directorio Demo/classes/
de Python durante mucho tiempo. Esta implementación fue significativamente actualizada por Jeffrey Yasskin.
Otros cambios lingüísticos¶
Algunos de los cambios más pequeños realizados en el núcleo del lenguaje Python son:
Los directorios y archivos zip que contengan un archivo
__main__.py
pueden ahora ejecutarse directamente pasando su nombre al intérprete. El directorio o archivo zip se inserta automáticamente como la primera entrada en sys.path. (Sugerencia y parche inicial de Andy Chu, revisado posteriormente por Phillip J. Eby y Nick Coghlan; bpo-1739468)La función
hasattr()
estaba capturando e ignorando todos los errores, bajo la suposición de que significaban que un método__getattr__()
estaba fallando de alguna manera y que el valor de retorno dehasattr()
sería por tantoFalse
. Esta lógica no debería aplicarse aKeyboardInterrupt
ySystemExit
, sin embargo; Python 2.6 ya no descartará tales excepciones cuandohasattr()
las encuentre. (Corregido por Benjamin Peterson; bpo-2196.)Cuando se llama a una función utilizando la sintaxis
**
para proporcionar argumentos de palabras clave, ya no es necesario utilizar un diccionario de Python; ahora funcionará cualquier asignación:>>> def f(**kw): ... print sorted(kw) ... >>> ud=UserDict.UserDict() >>> ud['a'] = 1 >>> ud['b'] = 'string' >>> f(**ud) ['a', 'b']
(Contribución de Alexander Belopolsky; bpo-1686487.)
También se ha convertido en legal proporcionar argumentos de palabras clave después de un argumento
*args
a una llamada de función.>>> def f(*args, **kw): ... print args, kw ... >>> f(1,2,3, *(4,5,6), keyword=13) (1, 2, 3, 4, 5, 6) {'keyword': 13}
Anteriormente, esto habría sido un error de sintaxis. (Contribución de Amaury Forgeot d’Arc; bpo-3473.)
Un nuevo builtin,
next(iterator, [default])
devuelve el siguiente elemento del iterador especificado. Si se suministra el argumento default, se devolverá si iterador se ha agotado; en caso contrario, se lanzará la excepciónStopIteration
. (Se ha modificado en bpo-2719.)Las tuplas tienen ahora métodos
index()
ycount()
que coinciden con los métodosindex()
ycount()
del tipo lista:>>> t = (0,1,2,3,4,0,1,2) >>> t.index(3) 3 >>> t.count(0) 2
(Contribución de Raymond Hettinger)
Los tipos incorporados tienen ahora un soporte mejorado para la sintaxis de corte extendida, aceptando varias combinaciones de
(inicio, parada, paso)
. Anteriormente, el soporte era parcial y algunos casos de esquina no funcionaban. (Implementado por Thomas Wouters)Las propiedades tienen ahora tres atributos,
getter
,setter
ydeleter
, que son decoradores que proporcionan atajos útiles para añadir una función getter, setter o deleter a una propiedad existente. Los usarás así:class C(object): @property def x(self): return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x class D(C): @C.x.getter def x(self): return self._x * 2 @x.setter def x(self, value): self._x = value / 2
Varios métodos de los tipos de conjuntos incorporados aceptan ahora múltiples iterables:
intersection()
,intersection_update()
,union()
,update()
,difference()
ydifference_update()
.>>> s=set('1234567890') >>> s.intersection('abc123', 'cdf246') # Intersection between all inputs set(['2']) >>> s.difference('246', '789') set(['1', '0', '3', '5'])
(Contribución de Raymond Hettinger.)
Se han añadido muchas funciones de punto flotante. La función
float()
ahora convertirá la cadenanan
en un valor IEEE 754 Not A Number, y+inf
y-inf
en infinito positivo o negativo. Esto funciona en cualquier plataforma con semántica IEEE 754. (Contribución de Christian Heimes; bpo-1635.)Otras funciones del módulo
math
,isinf()
yisnan()
, devuelven true si su argumento en coma flotante es infinito o No es un número. (bpo-1640)Se han añadido funciones de conversión para convertir números de punto flotante en cadenas hexadecimales (bpo-3008). Estas funciones convierten los números flotantes a y desde una representación de cadena sin introducir errores de redondeo por la conversión entre decimal y binario. Los flotadores tienen un método
hex()
que devuelve una representación de cadena, y el métodofloat.fromhex()
convierte una cadena de nuevo en un número:>>> a = 3.75 >>> a.hex() '0x1.e000000000000p+1' >>> float.fromhex('0x1.e000000000000p+1') 3.75 >>> b=1./3 >>> b.hex() '0x1.5555555555555p-2'
Un detalle numérico: cuando se crea un número complejo a partir de dos flotantes en sistemas que admiten ceros con signo (-0 y +0), el constructor
complex()
conserva ahora el signo del cero. (Corregido por Mark T. Dickinson; bpo-1507.)Las clases que heredan un método
__hash__()
de una clase padre pueden establecer__hash__ = None
para indicar que la clase no es hashable. Esto hará quehash(obj)
lance unTypeError
y la clase no será indicada como implementando el ABC deHashable
.Debes hacer esto cuando hayas definido un método
__cmp__()
o__eq__()
que compare objetos por su valor en lugar de por su identidad. Todos los objetos tienen un método hash por defecto que utilizaid(obj)
como valor hash. No hay una forma ordenada de eliminar el método__hash__()
heredado de una clase padre, por lo que la asignación deNone
fue implementada como una sobreescritura. A nivel de C, las extensiones pueden establecertp_hash
aPyObject_HashNotImplemented()
. (Corregido por Nick Coghlan y Amaury Forgeot d’Arc; bpo-2235.)La excepción
GeneratorExit
ahora subclasaBaseException
en lugar deException
. Esto significa que un manejador de excepciones que hagaexcept Exception:
no atrapará inadvertidamenteGeneratorExit
. (Contribuido por Chad Austin; bpo-1537.)Los objetos generadores tienen ahora un atributo
gi_code
que hace referencia al objeto de código original que respalda al generador. (Contribución de Collin Winter; bpo-1473257.)La función incorporada
compile()
ahora acepta argumentos de palabras clave así como parámetros posicionales. (Contribución de Thomas Wouters; bpo-1444529.)El constructor
complex()
ahora acepta cadenas que contengan números complejos entre paréntesis, lo que significa quecomplex(repr(cplx))
ahora redondeará los valores. Por ejemplo,complex('(3+4j)')
ahora devuelve el valor (3+4j). (bpo-1491866)El método string
translate()
acepta ahoraNone
como parámetro de la tabla de traducción, que se trata como la transformación de identidad. Esto facilita la realización de operaciones que sólo eliminan caracteres. (Contribuido por Bengt Richter e implementado por Raymond Hettinger; bpo-1193128)La función incorporada
dir()
ahora comprueba si existe un método__dir__()
en los objetos que recibe. Este método debe devolver una lista de cadenas que contengan los nombres de los atributos válidos para el objeto, y permite al objeto controlar el valor quedir()
produce. Los objetos que tienen métodos__getattr__()
o__getattribute__()
pueden usar esto para anunciar los pseudo-atributos que respetarán. (bpo-1591665)Los objetos de método de instancia tienen nuevos atributos para el objeto y la función que comprende el método; el nuevo sinónimo de
im_self
es__self__
, yim_func
también está disponible como__func__
. Los nombres antiguos todavía se soportan en Python 2.6, pero han desaparecido en la 3.0.Un cambio oscuro: cuando se utiliza la función
locals()
dentro de una sentenciaclass
, el diccionario resultante ya no devuelve variables libres. (Las variables libres, en este caso, son variables referenciadas en la sentenciaclass
que no son atributos de la clase)
Optimizaciones¶
El módulo
warnings
ha sido reescrito en C. Esto hace posible invocar advertencias desde el analizador sintáctico, y también puede hacer que el arranque del intérprete sea más rápido. (Contribuido por Neal Norwitz y Brett Cannon; bpo-1631171.)Los objetos de tipo tienen ahora una caché de métodos que puede reducir el trabajo necesario para encontrar la implementación del método correcto para una clase en particular; una vez almacenada en la caché, el intérprete no necesita recorrer las clases base para averiguar el método correcto a llamar. La caché se borra si una clase base o la propia clase se modifica, por lo que la caché debería seguir siendo correcta incluso ante la naturaleza dinámica de Python. (Optimización original implementada por Armin Rigo, actualizada para Python 2.6 por Kevin Jacobs; bpo-1700288.)
Por defecto, este cambio sólo se aplica a los tipos que se incluyen con el núcleo de Python. Los módulos de extensión no son necesariamente compatibles con esta caché, por lo que deben añadir explícitamente
Py_TPFLAGS_HAVE_VERSION_TAG
al campotp_flags
del módulo para habilitar la caché de métodos. (Para ser compatible con la caché de métodos, el código del módulo de extensión no debe acceder directamente ni modificar el miembrotp_dict
de ninguno de los tipos que implementa. La mayoría de los módulos no lo hacen, pero es imposible que el intérprete de Python lo determine. Ver bpo-1878 para una discusión)Las llamadas a funciones que utilizan argumentos de palabras clave son significativamente más rápidas al hacer una comparación rápida de punteros, lo que suele ahorrar el tiempo de una comparación completa de cadenas. (Contribución de Raymond Hettinger, tras una implementación inicial de Antoine Pitrou; bpo-1819)
Todas las funciones del módulo
struct
han sido reescritas en C, gracias al trabajo en el sprint de Need For Speed. (Contribución de Raymond Hettinger)Algunos de los tipos estándar incorporados ahora establecen un bit en sus objetos de tipo. Esto acelera la comprobación de si un objeto es una subclase de uno de estos tipos. (Contribución de Neal Norwitz)
Las cadenas Unicode utilizan ahora un código más rápido para detectar los espacios en blanco y los saltos de línea; esto acelera el método
split()
en un 25% a ysplitlines()
en un 35%. (Contribuido por Antoine Pitrou.) El uso de la memoria se reduce utilizando pymalloc para los datos de la cadena Unicode.La sentencia
with
ahora almacena el método__exit__()
en la pila, produciendo un pequeño aumento de velocidad. (Implementado por Jeffrey Yasskin)Para reducir el uso de memoria, el recolector de basura ahora borrará las listas libres internas cuando recolecte la generación más alta de objetos. Esto puede devolver la memoria al sistema operativo antes.
Cambios de intérprete¶
Se han reservado dos opciones de la línea de comandos para su uso por otras implementaciones de Python. La opción -J
se ha reservado para su uso por parte de Jython para las opciones específicas de Jython, como los interruptores que se pasan a la JVM subyacente. -X
se ha reservado para las opciones específicas de una implementación particular de Python como CPython, Jython o IronPython. Si cualquiera de estas opciones se utiliza con Python 2.6, el intérprete informará de que la opción no se utiliza actualmente.
Ahora se puede evitar que Python escriba archivos .pyc
o .pyo
proporcionando el modificador -B
al intérprete de Python, o estableciendo la variable de entorno PYTHONDONTWRITEBYTECODE
antes de ejecutar el intérprete. Esta configuración está disponible para los programas de Python como la variable sys.dont_write_bytecode
, y el código de Python puede cambiar el valor para modificar el comportamiento del intérprete. (Contribución de Neal Norwitz y Georg Brandl)
La codificación utilizada para la entrada, la salida y el error estándar puede especificarse estableciendo la variable de entorno PYTHONIOENCODING
antes de ejecutar el intérprete. El valor debe ser una cadena de la forma <encoding>
o <encoding>:<errorhandler>
. La parte encoding especifica el nombre de la codificación, por ejemplo utf-8
o latin-1
; la parte opcional errorhandler especifica qué hacer con los caracteres que no pueden ser manejados por la codificación, y debe ser una de las opciones «error», «ignorar» o «reemplazar». (Contribución de Martin von Löwis)</errorhandler></encoding></encoding>
Módulos nuevos y mejorados¶
Como en cada versión, la biblioteca estándar de Python ha recibido una serie de mejoras y correcciones de errores. Aquí hay una lista parcial de los cambios más notables, ordenados alfabéticamente por nombre de módulo. Consulta el archivo Misc/NEWS
en el árbol de fuentes para una lista más completa de cambios, o mira los registros de Subversion para todos los detalles.
Los módulos
asyncore
yasynchat
están siendo mantenidos activamente de nuevo, y se han aplicado varios parches y correcciones de errores. (Mantenido por Josiah Carlson; véase bpo-1736190 para un parche)El módulo
bsddb
también tiene un nuevo mantenedor, Jesús Cea Avión, y el paquete está ahora disponible como paquete independiente. La página web del paquete es www.jcea.es/programacion/pybsddb.htm. El plan es eliminar el paquete de la biblioteca estándar en Python 3.0, porque su ritmo de lanzamientos es mucho más frecuente que el de Python.El módulo
bsddb.dbshelve
utiliza ahora el protocolo de decapado más alto disponible, en lugar de limitarse al protocolo 1. (Contribución de W. Barnes.)El módulo
cgi
leerá ahora las variables de la cadena de consulta de una petición HTTP POST. Esto permite utilizar acciones de formulario con URLs que incluyen cadenas de consulta como «/cgi-bin/add.py?category=1». (Contribución de Alexandre Fiori y Nubis; bpo-1817.)Las funciones
parse_qs()
yparse_qsl()
han sido reubicadas del módulocgi
al módulourlparse
. Las versiones aún disponibles en el módulocgi
activarán los mensajesPendingDeprecationWarning
en la versión 2.6 (bpo-600362).El módulo
cmath
ha sido objeto de una amplia revisión, a la que han contribuido Mark Dickinson y Christian Heimes. Se han añadido cinco nuevas funciones:polar()
convierte un número complejo en forma polar, devolviendo el módulo y el argumento del número complejo.rect()
hace lo contrario, convirtiendo un par de módulos y argumentos en el correspondiente número complejo.phase()
devuelve el argumento (también llamado ángulo) de un número complejo.isnan()
devuelve True si la parte real o imaginaria de su argumento es un NaN.isinf()
devuelve True si la parte real o imaginaria de su argumento es infinita.
Las revisiones también han mejorado la solidez numérica del módulo
cmath
. Para todas las funciones, las partes real e imaginaria de los resultados son exactas con unas pocas unidades de precisión mínima (ulps) siempre que sea posible. Véase bpo-1381 para los detalles. También se han corregido los cortes de rama paraasinh()
,atanh()
: yatan()
.Las pruebas del módulo se han ampliado considerablemente; casi 2000 nuevos casos de prueba ejercitan las funciones algebraicas.
En las plataformas IEEE 754, el módulo
cmath
maneja ahora los valores especiales IEEE 754 y las excepciones de punto flotante de forma consistente con el Anexo “G” del estándar C99.Un nuevo tipo de datos en el módulo
collections
:namedtuple(typename, fieldnames)
es una función de fábrica que crea subclases de la tupla estándar cuyos campos son accesibles tanto por nombre como por índice. Por ejemplo:>>> var_type = collections.namedtuple('variable', ... 'id name type size') >>> # Names are separated by spaces or commas. >>> # 'id, name, type, size' would also work. >>> var_type._fields ('id', 'name', 'type', 'size') >>> var = var_type(1, 'frequency', 'int', 4) >>> print var[0], var.id # Equivalent 1 1 >>> print var[2], var.type # Equivalent int int >>> var._asdict() {'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'} >>> v2 = var._replace(name='amplitude') >>> v2 variable(id=1, name='amplitude', type='int', size=4)
Varios lugares de la biblioteca estándar que devolvían tuplas han sido modificados para devolver instancias de
namedtuple()
. Por ejemplo, el métodoDecimal.as_tuple()
ahora devuelve una tupla con nombre con los campossign
,digits
yexponent
.(Contribución de Raymond Hettinger.)
Otro cambio en el módulo
collections
es que el tipodeque
admite ahora un parámetro opcional maxlen; si se suministra, el tamaño del deque estará restringido a no más de maxlen elementos. Si se añaden más elementos a un deque lleno, se descartan los elementos antiguos.>>> from collections import deque >>> dq=deque(maxlen=3) >>> dq deque([], maxlen=3) >>> dq.append(1); dq.append(2); dq.append(3) >>> dq deque([1, 2, 3], maxlen=3) >>> dq.append(4) >>> dq deque([2, 3, 4], maxlen=3)
(Contribución de Raymond Hettinger.)
Los objetos
Cookie
del móduloMorsel
soportan ahora un atributohttponly
. En algunos navegadores, las cookies con este atributo no pueden ser accedidas o manipuladas por el código JavaScript. (Contribución de Arvin Schnell; bpo-1638033.)Un nuevo método de ventana en el módulo
curses
,chgat()
, cambia los atributos de visualización para un determinado número de caracteres en una sola línea. (Contribución de Fabian Kreutz)# Boldface text starting at y=0,x=21 # and affecting the rest of the line. stdscr.chgat(0, 21, curses.A_BOLD)
La clase
Textbox
del módulocurses.textpad
soporta ahora la edición en modo de inserción así como en modo de sobrescritura. El modo de inserción se activa proporcionando un valor verdadero para el parámetro insert_mode al crear la instancia deTextbox
.Los métodos
strftime()
del módulodatetime
soportan ahora un código de formato%f
que se expande al número de microsegundos en el objeto, rellenado de cero a la izquierda hasta seis lugares. (Contribución de Skip Montanaro; bpo-1158.)El módulo
decimal
se actualizó a la versión 1.66 de the General Decimal Specification. Las nuevas características incluyen algunos métodos para algunas funciones matemáticas básicas comoexp()
ylog10()
:>>> Decimal(1).exp() Decimal("2.718281828459045235360287471") >>> Decimal("2.7182818").ln() Decimal("0.9999999895305022877376682436") >>> Decimal(1000).log10() Decimal("3")
El método
as_tuple()
de los objetosDecimal
devuelve ahora una tupla con nombre con los campossigno
,dígitos
yexponente
.(Implementado por Facundo Batista y Mark Dickinson. Soporte de tuplas con nombre añadido por Raymond Hettinger)
La clase
difflib
del móduloSequenceMatcher
devuelve ahora tuplas con nombre que representan coincidencias, con atributosa
,b
ysize
. (Contribución de Raymond Hettinger)Se ha añadido un parámetro opcional
timeout
, que especifica un tiempo de espera medido en segundos, al constructor de la claseftplib.FTP
así como al métodoconnect()
. (Añadido por Facundo Batista.) Además, los métodosstorbinary()
ystorlines()
de la claseFTP
ahora toman un parámetro opcional callback que será llamado con cada bloque de datos después de que los datos hayan sido enviados. (Contribuido por Phil Schwartz; bpo-1221598.)La función incorporada
reduce()
también está disponible en el módulofunctools
. En Python 3.0, la función incorporada se ha eliminado yreduce()
sólo está disponible enfunctools
; actualmente no hay planes para eliminar la función incorporada en la serie 2.x. (Parcheado por Christian Heimes; bpo-1739906.)Cuando sea posible, el módulo
getpass
utilizará ahora/dev/tty
para imprimir un mensaje de aviso y leer la contraseña, retrocediendo al error estándar y a la entrada estándar. Si la contraseña puede ser enviada al terminal, se imprimirá una advertencia antes de que se muestre el aviso. (Contribución de Gregory P. Smith)La función
glob.glob()
ahora puede devolver nombres de archivo Unicode si se ha utilizado una ruta Unicode y se han encontrado nombres de archivo Unicode dentro del directorio. (bpo-1001604)Una nueva función en el módulo
heapq
,merge(iter1, iter2, ...)
, toma cualquier número de iterables que devuelven datos en orden ordenado, y devuelve un nuevo generador que devuelve el contenido de todos los iteradores, también en ordenado. Por ejemplo:>>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16])) [1, 2, 3, 5, 8, 9, 16]
Otra nueva función,
heappushpop(heap, item)
, empuja item a heap, luego lo saca y devuelve el elemento más pequeño. Esto es más eficiente que hacer una llamada aheappush()
y luego aheappop()
.heapq
se ha implementado para utilizar únicamente la comparación menor que, en lugar de la comparación menor o igual que utilizaba anteriormente. Esto hace que el uso deheapq
de un tipo coincida con el métodolist.sort()
. (Contribución de Raymond Hettinger)Se ha añadido un parámetro opcional
timeout
, que especifica un tiempo de espera medido en segundos, a los constructores de las claseshttplib.HTTPConnection
yHTTPSConnection
. (Añadido por Facundo Batista)La mayoría de las funciones del módulo
inspect
, comogetmoduleinfo()
ygetargs()
, ahora devuelven tuplas con nombre. Además de comportarse como tuplas, también se puede acceder a los elementos del valor devuelto como atributos. (Contribución de Raymond Hettinger)Algunas de las nuevas funciones del módulo son
isgenerator()
,isgeneratorfunction()
yisabstract()
.El módulo
itertools
ha ganado varias funciones nuevas.izip_longest(iter1, iter2, ...[, fillvalue])
hace tuplas de cada uno de los elementos; si algunos de los iterables son más cortos que otros, los valores que faltan se ponen a fillvalue. Por ejemplo:>>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5])) ((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))
product(iter1, iter2, ..., [repeat=N])
devuelve el producto cartesiano de los iterables suministrados, un conjunto de tuplas que contiene todas las combinaciones posibles de los elementos devueltos de cada iterable.>>> list(itertools.product([1,2,3], [4,5,6])) [(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]
El argumento opcional de la palabra clave repeat se utiliza para tomar el producto de un iterable o un conjunto de iterables con ellos mismos, repetido N veces. Con un único argumento iterable, se devuelven N-tuplas:
>>> list(itertools.product([1,2], repeat=3)) [(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2), (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]
Con dos iterables, se devuelven 2N-tuplas.
>>> list(itertools.product([1,2], [3,4], repeat=2)) [(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4), (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4), (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4), (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]
combinaciones(iterable, r)
devuelve subsecuencias de longitud r de los elementos de iterable.>>> list(itertools.combinations('123', 2)) [('1', '2'), ('1', '3'), ('2', '3')] >>> list(itertools.combinations('123', 3)) [('1', '2', '3')] >>> list(itertools.combinations('1234', 3)) [('1', '2', '3'), ('1', '2', '4'), ('1', '3', '4'), ('2', '3', '4')]
permutaciones(iter[, r])
devuelve todas las permutaciones de longitud r de los elementos del iterable. Si no se especifica r, por defecto será el número de elementos producidos por el iterable.>>> list(itertools.permutations([1,2,3,4], 2)) [(1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (3, 1), (3, 2), (3, 4), (4, 1), (4, 2), (4, 3)]
itertools.chain(*iterables)
es una función existente enitertools
que obtuvo un nuevo constructor en Python 2.6.itertools.chain.from_iterable(iterable)
toma un único iterable que debe devolver otros iterables.chain()
devolverá entonces todos los elementos del primer iterable, luego todos los elementos del segundo, y así sucesivamente.>>> list(itertools.chain.from_iterable([[1,2,3], [4,5,6]])) [1, 2, 3, 4, 5, 6]
(Todo ello aportado por Raymond Hettinger)
La clase
logging
del móduloFileHandler
y sus subclasesWatchedFileHandler
,RotatingFileHandler
yTimedRotatingFileHandler
tienen ahora un parámetro opcional delay en sus constructores. Si retraso es verdadero, la apertura del fichero de registro se retrasa hasta que se realice la primera llamadaemit()
. (Contribuido por Vinay Sajip.)TimedRotatingFileHandler
también tiene un parámetro constructor utc. Si el argumento es verdadero, se utilizará la hora UTC para determinar cuándo ocurre la medianoche y para generar los nombres de los archivos; en caso contrario, se utilizará la hora local.Se han añadido varias funciones nuevas al módulo
math
:isinf()
yisnan()
determinan si un flotador dado es un infinito (positivo o negativo) o un NaN (Not a Number), respectivamente.copysign()
copia el bit de signo de un número IEEE 754, devolviendo el valor absoluto de x combinado con el bit de signo de y. Por ejemplo,math.copysign(1, -0.0)
devuelve -1.0. (Contribución de Christian Heimes)factorial()
calcula el factorial de un número. (Contribuido por Raymond Hettinger; bpo-2138.)fsum()
suma el flujo de números de un iterable, y tiene cuidado de evitar la pérdida de precisión mediante el uso de sumas parciales. (Contribución de Jean Brouwers, Raymond Hettinger y Mark Dickinson; bpo-2819)acosh()
,asinh()
yatanh()
calculan las funciones hiperbólicas inversas.log1p()
devuelve el logaritmo natural de 1+x (base e).trunc()
redondea un número hacia cero, devolviendo elIntegral
más cercano que esté entre el argumento de la función y el cero. Añadido como parte del backport de la jerarquía de tipos de números de PEP 3141.
El módulo
math
se ha mejorado para ofrecer un comportamiento más coherente en todas las plataformas, especialmente en lo que respecta al manejo de las excepciones de punto flotante y los valores especiales IEEE 754.Siempre que es posible, el módulo sigue las recomendaciones del estándar C99 sobre los valores especiales de 754. Por ejemplo,
sqrt(-1.)
debería dar ahora unValueError
en casi todas las plataformas, mientras quesqrt(float('NaN'))
debería devolver un NaN en todas las plataformas IEEE 754. Cuando el Anexo “F” del estándar C99 recomiende señalar “dividir por cero” o “inválido”, Python lanzaráValueError
. Cuando el Anexo “F” del estándar C99 recomiende señalar “desbordamiento”, Python lanzaráOverflowError
. (Ver bpo-711019 y bpo-1640)(Contribución de Christian Heimes y Mark Dickinson)
Los objetos
mmap
tienen ahora un métodorfind()
que busca una subcadena empezando por el final de la cadena y buscando hacia atrás. El métodofind()
también ha ganado un parámetro end que da un índice en el que parar la búsqueda. (Contribución de John Lenton)El módulo
operator
ganó una funciónmethodcaller()
que toma un nombre y un conjunto opcional de argumentos, devolviendo un callable que llamará a la función nombrada en cualquier argumento que se le pase. Por ejemplo:>>> # Equivalent to lambda s: s.replace('old', 'new') >>> replacer = operator.methodcaller('replace', 'old', 'new') >>> replacer('old wine in old bottles') 'new wine in new bottles'
(Contribución de Georg Brandl, tras una sugerencia de Gregory Petrosyan)
La función
attrgetter()
acepta ahora nombres con puntos y realiza las correspondientes búsquedas de atributos:>>> inst_name = operator.attrgetter( ... '__class__.__name__') >>> inst_name('') 'str' >>> inst_name(help) '_Helper'
(Contribución de Georg Brandl, tras una sugerencia de Barry Warsaw)
El módulo
os
incluye ahora varias llamadas nuevas al sistema.fchmod(fd, mode)
yfchown(fd, uid, gid)
cambian el modo y la propiedad de un fichero abierto, ylchmod(path, mode)
cambia el modo de un enlace simbólico. (Contribución de Georg Brandl y Christian Heimes)chflags()
ylchflags()
son envoltorios para las correspondientes llamadas al sistema (cuando están disponibles), que cambian las banderas establecidas en un archivo. Las constantes para los valores de las banderas se definen en el módulostat
; algunos valores posibles sonUF_IMMUTABLE
para indicar que el fichero no puede ser modificado yUF_APPEND
para indicar que sólo se pueden añadir datos al fichero. (Contribución de M. Levinson)os.closerange(low, high)
cierra eficazmente todos los descriptores de fichero desde low hasta high, ignorando cualquier error y sin incluir a high mismo. Esta función es ahora utilizada por el módulosubprocess
para hacer más rápido el arranque de procesos. (Contribuido por Georg Brandl; bpo-1663329.)El método
clear()
del objetoos.environ
ahora desajustará las variables de entorno utilizandoos.unsetenv()
además de borrar las claves del objeto. (Contribuido por Martin Horcicka; bpo-1181.)La función
os.walk()
tiene ahora un parámetrofollowlinks
. Si se establece como True, seguirá los enlaces simbólicos que apunten a directorios y visitará el contenido del directorio. Por compatibilidad con el pasado, el valor por defecto del parámetro es false. Tenga en cuenta que la función puede caer en una recursión infinita si hay un enlace simbólico que apunte a un directorio padre. (bpo-1273829)En el módulo
os.path
, la funciónsplitext()
ha sido modificada para no dividir los caracteres de punto inicial. Esto produce mejores resultados cuando se opera con archivos de puntos de Unix. Por ejemplo,os.path.splitext('.ipython')
ahora devuelve('.ipython', '')
en lugar de('', '.ipython')
. (bpo-1115886)Una nueva función,
os.path.relpath(path, start='.')
, devuelve una ruta relativa desde la rutastart
, si se suministra, o desde el directorio de trabajo actual hasta el destinopath
. (Contribución de Richard Barran; bpo-1339796.)En Windows,
os.path.expandvars()
ahora expandirá las variables de entorno dadas en la forma «%var%», y «~user» se expandirá en la ruta del directorio personal del usuario. (Contribución de Josiah Carlson; bpo-957650.)El depurador de Python proporcionado por el módulo
pdb
ganó un nuevo comando: «run» reinicia el programa Python que se está depurando y puede tomar opcionalmente nuevos argumentos de línea de comandos para el programa. (Contribución de Rocky Bernstein; bpo-1393667.)La función
pdb.post_mortem()
, utilizada para iniciar la depuración de un traceback, utilizará ahora el traceback devuelto porsys.exc_info()
si no se suministra ningún traceback. (Contribuido por Facundo Batista; bpo-1106316.)El módulo
pickletools
tiene ahora una funciónoptimize()
que toma una cadena que contiene un pickle y elimina algunos opcodes no utilizados, devolviendo un pickle más corto que contiene la misma estructura de datos. (Contribución de Raymond Hettinger)Se ha añadido una función
get_data()
al módulopkgutil
que devuelve el contenido de los archivos de recursos incluidos con un paquete Python instalado. Por ejemplo:>>> import pkgutil >>> print pkgutil.get_data('test', 'exception_hierarchy.txt') BaseException +-- SystemExit +-- KeyboardInterrupt +-- GeneratorExit +-- Exception +-- StopIteration +-- StandardError ...
(Contribución de Paul Moore; bpo-2439.)
Los objetos
pyexpat
del móduloParser
permiten ahora establecer su atributobuffer_size
para cambiar el tamaño del buffer utilizado para mantener los datos de caracteres. (Contribución de Achim Gaedke; bpo-1137.)El módulo
Queue
proporciona ahora variantes de colas que recuperan las entradas en diferentes órdenes. La clasePriorityQueue
almacena los elementos en cola en un montón y los recupera en orden de prioridad, yLifoQueue
recupera primero las entradas añadidas más recientemente, lo que significa que se comporta como una pila. (Contribución de Raymond Hettinger)Los objetos
Random
del módulorandom
ahora pueden ser decapados en un sistema de 32 bits y desempaquetados en un sistema de 64 bits, y viceversa. Desafortunadamente, este cambio también significa que los objetosRandom
de Python 2.6 no pueden ser desempaquetados correctamente en versiones anteriores de Python. (Contribuido por Shawn Ligocki; bpo-1727780.)La nueva función
triangular(low, high, mode)
devuelve números aleatorios siguiendo una distribución triangular. Los valores devueltos están entre bajos y altos, sin incluir los propios altos, y con modo como valor más frecuente en la distribución. (Contribución de Wladmir van der Laan y Raymond Hettinger; bpo-1681432.)Las búsquedas de expresiones regulares largas llevadas a cabo por el módulo
re
comprobarán la entrega de señales, por lo que ahora se pueden interrumpir las búsquedas que consumen mucho tiempo. (Contribución de Josh Hoyt y Ralf Schmitt; bpo-846388.)El módulo de expresiones regulares se implementa compilando bytecodes para una pequeña máquina virtual específica de regex. El código no fiable podría crear cadenas maliciosas de código de bytes directamente y causar caídas, por lo que Python 2.6 incluye un verificador para el código de bytes regex. (Contribuido por Guido van Rossum del trabajo para Google App Engine; bpo-3487.)
El método
Completer.complete()
del módulorlcompleter
ahora ignorará las excepciones que se produzcan al evaluar un nombre. (Corregido por Lorenz Quack; bpo-2250.)Las instancias
sched
del móduloscheduler
tienen ahora un atributoqueue
de sólo lectura que devuelve el contenido de la cola del planificador, representado como una lista de tuplas con nombre con los campos(tiempo, prioridad, acción, argumento)
. (Contribución de Raymond Hettinger; bpo-1861.)El módulo
select
tiene ahora funciones de envoltura para las llamadas al sistema Linuxepoll()
y BSDkqueue()
. Se ha añadido el métodomodify()
a los objetospoll
existentes;pollobj.modify(fd, eventmask)
toma un descriptor de fichero o un objeto de fichero y una máscara de evento, modificando la máscara de evento registrada para ese fichero. (Contribución de Christian Heimes; bpo-1657.)La función
shutil.copytree()
tiene ahora un argumento opcional ignore que toma un objeto callable. Esta llamada recibirá cada ruta de directorio y una lista del contenido del directorio, y devuelve una lista de nombres que serán ignorados, no copiados.El módulo
shutil
también proporciona una funciónignore_patterns()
para su uso con este nuevo parámetro.ignore_patterns()
toma un número arbitrario de patrones de estilo glob y devuelve una llamada que ignorará cualquier archivo o directorio que coincida con cualquiera de estos patrones. El siguiente ejemplo copia un árbol de directorios, pero omite los directorios.svn
y los ficheros de copia de seguridad de Emacs, que tienen nombres que terminan en “~”:shutil.copytree('Doc/library', '/tmp/library', ignore=shutil.ignore_patterns('*~', '.svn'))
(Contribución de Tarek Ziadé; bpo-2663.)
Integrar el manejo de señales con los bucles de eventos de manejo de la interfaz gráfica de usuario (GUI), como los utilizados por Tkinter o GTk+, ha sido durante mucho tiempo un problema; la mayoría del software acaba sondeando, despertando cada fracción de segundo para comprobar si se ha producido algún evento de la GUI. El módulo
signal
puede ahora hacer esto más eficiente. Llamando asignal.set_wakeup_fd(fd)
se establece un descriptor de fichero a utilizar; cuando se recibe una señal, se escribe un byte en ese descriptor de fichero. También hay una función en C,PySignal_SetWakeupFd()
, para establecer el descriptor.Los bucles de eventos utilizarán esto abriendo una tubería para crear dos descriptores, uno de lectura y otro de escritura. El descriptor de escritura se pasará a
set_wakeup_fd()
, y el descriptor de lectura se añadirá a la lista de descriptores monitorizados por el bucle de eventos medianteselect()
opoll()
. Al recibir una señal, se escribirá un byte y se despertará el bucle de eventos principal, evitando la necesidad de hacer un sondeo.(Contribución de Adam Olsen; bpo-1583.)
La función
siginterrupt()
está ahora disponible desde el código Python, y permite cambiar si las señales pueden interrumpir las llamadas al sistema o no. (Contribución de Ralf Schmitt)También se han añadido las funciones
setitimer()
ygetitimer()
(cuando están disponibles).setitimer()
permite establecer temporizadores de intervalo que harán que se entregue una señal al proceso después de un tiempo especificado, medido en tiempo de reloj de pared, tiempo de proceso consumido, o tiempo combinado de proceso+sistema. (Contribuido por Guilherme Polo; bpo-2240.)El módulo
smtplib
ahora soporta SMTP sobre SSL gracias a la adición de la claseSMTP_SSL
. Esta clase soporta una interfaz idéntica a la claseSMTP
existente. (Contribuido por Monty Taylor.) Ambos constructores de la clase también tienen un parámetro opcionaltimeout
que especifica un tiempo de espera para el intento de conexión inicial, medido en segundos. (Contribuido por Facundo Batista.)También se ha añadido al módulo una implementación del protocolo LMTP (RFC 2033). LMTP se utiliza en lugar de SMTP cuando se transfiere correo electrónico entre agentes que no gestionan una cola de correo. (LMTP implementado por Leif Hedstrom; bpo-957003.)
SMTP.starttls()
ahora cumple con RFC 3207 y olvida cualquier conocimiento obtenido del servidor que no se haya obtenido de la propia negociación TLS. (Parche aportado por Bill Fenner; bpo-829951.)El módulo
socket
soporta ahora TIPC (http://tipc.sourceforge.net/), un protocolo de alto rendimiento no basado en IP y diseñado para su uso en entornos agrupados. Las direcciones TIPC son de 4 o 5 tuplas. (Contribución de Alberto Bertogli; bpo-1646.)Una nueva función,
create_connection()
, toma una dirección y se conecta a ella utilizando un valor opcional de tiempo de espera, devolviendo el objeto socket conectado. Esta función también busca el tipo de dirección y se conecta a ella usando IPv4 o IPv6 según sea el caso. Cambiar su código para usarcreate_connection()
en lugar desocket(socket.AF_INET, ...)
puede ser todo lo que se necesita para que su código funcione con IPv6.Las clases base del módulo
SocketServer
ahora soportan la llamada a un métodohandle_timeout()
después de un periodo de inactividad especificado por el atributotimeout
del servidor. (Contribuido por Michael Pomraning.) El métodoserve_forever()
ahora toma un intervalo de sondeo opcional medido en segundos, controlando la frecuencia con la que el servidor comprobará si hay una solicitud de cierre. (Contribuido por Pedro Werneck y Jeffrey Yasskin; bpo-742598, bpo-1193577.)El módulo
sqlite3
, mantenido por Gerhard Häring, ha sido actualizado de la versión 2.3.2 en Python 2.5 a la versión 2.4.1.El módulo
struct
ahora admite el tipo C99 _Bool, utilizando el carácter de formato'?'
. (Aportado por David Remahl.)Los objetos
Popen
proporcionados por el módulosubprocess
tienen ahora métodosterminate()
,kill()
ysend_signal()
. En Windows,send_signal()
sólo soporta la señalSIGTERM
, y todos estos métodos son alias de la función de la API Win32TerminateProcess()
. (Contribuido por Christian Heimes.)Una nueva variable en el módulo
sys
,float_info
, es un objeto que contiene información derivada del archivofloat.h
sobre el soporte de punto flotante de la plataforma. Los atributos de este objeto incluyenmant_dig
(número de dígitos en la mantisa),epsilon
(diferencia más pequeña entre 1.0 y el siguiente valor más grande representable), y varios otros. (Contribuido por Christian Heimes; bpo-1534.)Otra nueva variable,
dont_write_bytecode
, controla si Python escribe algún archivo.pyc
o.pyo
al importar un módulo. Si esta variable es verdadera, los archivos compilados no se escriben. La variable se establece inicialmente al iniciar el intérprete de Python con la opción-B
, o estableciendo la variable de entornoPYTHONDONTWRITEBYTECODE
antes de ejecutar el intérprete. El código de Python puede cambiar posteriormente el valor de esta variable para controlar si los archivos de código de bytes se escriben o no. (Contribución de Neal Norwitz y Georg Brandl)La información sobre los argumentos de la línea de comandos suministrados al intérprete de Python está disponible leyendo los atributos de una tupla con nombre disponible como
sys.flags
. Por ejemplo, el atributoverbose
es verdadero si Python fue ejecutado en modo verbose,debug
es verdadero en modo debugging, etc. Todos estos atributos son de sólo lectura. (Contribución de Christian Heimes)Una nueva función,
getsizeof()
, toma un objeto Python y devuelve la cantidad de memoria utilizada por el objeto, medida en bytes. Los objetos incorporados devuelven resultados correctos; las extensiones de terceros pueden no hacerlo, pero pueden definir un método__sizeof__()
para devolver el tamaño del objeto. (Contribución de Robert Schuppenies; bpo-2898.)Ahora es posible determinar las funciones actuales del perfilador y del trazador llamando a
sys.getprofile()
ysys.gettrace()
. (Contribuido por Georg Brandl; bpo-1648.)El módulo
tarfile
soporta ahora archivos tar POSIX.1-2001 (pax) además de los formatos POSIX.1-1988 (ustar) y GNU tar que ya estaban soportados. El formato por defecto es GNU tar; especifique el parámetroformat
para abrir un archivo con un formato diferente:tar = tarfile.open("output.tar", "w", format=tarfile.PAX_FORMAT)
Los nuevos parámetros
encoding
yerrors
especifican una codificación y un esquema de manejo de errores para las conversiones de caracteres.'strict'
,'ignore'
, y'replace'
son las tres formas estándar en las que Python puede manejar los errores;'utf-8'
es un valor especial que reemplaza los caracteres erróneos con su representación UTF-8. (Las conversiones de caracteres ocurren porque el formato PAX soporta nombres de archivo Unicode, por defecto con codificación UTF-8)El método
TarFile.add()
ahora acepta un argumentoexclude
que es una función que se puede usar para excluir ciertos nombres de archivo de un archivo. La función debe tomar un nombre de archivo y retornar verdadero si el archivo debe excluirse o falso si debe archivarse. La función se aplica tanto al nombre pasado inicialmente aadd()
como a los nombres de los archivos en los directorios agregados recursivamente.(Todos los cambios han sido aportados por Lars Gustäbel).
Se agregó un parámetro opcional
timeout
al constructor de la clasetelnetlib.Telnet
, especificando un tiempo de espera medido en segundos. (Añadido por Facundo Batista)La clase
tempfile.NamedTemporaryFile
suele borrar el archivo temporal que ha creado cuando se cierra el archivo. Este comportamiento se puede cambiar pasandodelete=False
al constructor. (Contribución de Damien Miller; bpo-1537850.)Una nueva clase,
SpooledTemporaryFile
, se comporta como un archivo temporal pero almacena sus datos en memoria hasta que se supera un tamaño máximo. Al llegar a ese límite, el contenido se escribirá en un archivo temporal en el disco. (Contribución de Dustin J. Mitchell)Las clases
NamedTemporaryFile
ySpooledTemporaryFile
funcionan como gestores de contexto, por lo que puedes escribircon tempfile.NamedTemporaryFile() como tmp: ...
. (Contribuido por Alexander Belopolsky; bpo-2021.)El módulo
test.test_support
obtuvo una serie de gestores de contexto útiles para escribir pruebas.EnvironmentVarGuard()
es un gestor de contexto que cambia temporalmente las variables de entorno y las restaura automáticamente a sus valores anteriores.Otro gestor de contexto,
TransientResource
, puede rodear las llamadas a recursos que pueden o no estar disponibles; atrapará e ignorará una lista especificada de excepciones. Por ejemplo, una prueba de red puede ignorar ciertos fallos al conectarse a un sitio web externo:with test_support.TransientResource(IOError, errno=errno.ETIMEDOUT): f = urllib.urlopen('https://sf.net') ...
Por último,
check_warnings()
restablece los filtros de advertencia del módulowarning
y devuelve un objeto que registrará todos los mensajes de advertencia activados (bpo-3781):with test_support.check_warnings() as wrec: warnings.simplefilter("always") # ... code that triggers a warning ... assert str(wrec.message) == "function is outdated" assert len(wrec.warnings) == 1, "Multiple warnings raised"
(Contribución de Brett Cannon.)
El módulo
textwrap
ahora puede conservar los espacios en blanco existentes al principio y al final de las líneas recién creadas especificandodrop_whitespace=False
como argumento:>>> S = """This sentence has a bunch of ... extra whitespace.""" >>> print textwrap.fill(S, width=15) This sentence has a bunch of extra whitespace. >>> print textwrap.fill(S, drop_whitespace=False, width=15) This sentence has a bunch of extra whitespace. >>>
(Contribución de Dwayne Bailey; bpo-1581073.)
La API del módulo
threading
se ha cambiado para utilizar propiedades comodaemon
en lugar de los métodossetDaemon()
yisDaemon()
, y algunos métodos se han renombrado para utilizar guiones bajos en lugar de mayúsculas; por ejemplo, el métodoactiveCount()
se ha renombrado aactive_count()
. Tanto la versión 2.6 como la 3.0 del módulo soportan las mismas propiedades y métodos renombrados, pero no eliminan los métodos antiguos. No se ha fijado una fecha para la eliminación de las antiguas APIs en Python 3.x; las antiguas APIs no se eliminarán en ninguna versión 2.x. (Llevado a cabo por varias personas, sobre todo por Benjamin Peterson)Los objetos
threading
del móduloThread
han ganado una propiedadident
que devuelve el identificador del hilo, un entero no nulo. (Contribución de Gregory P. Smith; bpo-2871.)El módulo
timeit
acepta ahora callables así como cadenas para la sentencia que se está cronometrando y para el código de configuración. Se han añadido dos funciones para crear instancias deTimer
:repeat(stmt, setup, time, repeat, number)
ytimeit(stmt, setup, time, number)
crean una instancia y llaman al método correspondiente. (Contribución de Erik Demaine; bpo-1533909.)El módulo
Tkinter
ahora acepta listas y tuplas para las opciones, separando los elementos por espacios antes de pasar el valor resultante a Tcl/Tk. (Contribuido por Guilherme Polo; bpo-2906.)El módulo
turtle
para los gráficos de tortugas ha sido muy mejorado por Gregor Lingl. Las nuevas características del módulo incluyen:Mejor animación del movimiento y la rotación de la tortuga.
Control del movimiento de las tortugas mediante los nuevos métodos
retraso()
,tracer()
yvelocidad()
.La posibilidad de establecer nuevas formas para la tortuga y de definir un nuevo sistema de coordenadas.
Las tortugas ahora tienen un método
undo()
que puede revertir las acciones.Soporte sencillo para reaccionar a eventos de entrada como la actividad del ratón y del teclado, lo que permite escribir juegos sencillos.
Se puede utilizar un archivo
turtle.cfg
para personalizar la apariencia inicial de la pantalla de la tortuga.Los docstrings del módulo pueden ser sustituidos por nuevos docstrings traducidos a otro idioma.
Se ha añadido un parámetro opcional
timeout
a la funciónurllib.urlopen()
y al constructor de la claseurllib.ftpwrapper
, así como a la funciónurllib2.urlopen()
. El parámetro especifica un tiempo de espera medido en segundos. Por ejemplo:>>> u = urllib2.urlopen("http://slow.example.com", timeout=3) Traceback (most recent call last): ... urllib2.URLError: <urlopen error timed out> >>>
(Añadido por Facundo Batista.)
La base de datos Unicode proporcionada por el módulo
unicodedata
ha sido actualizada a la versión 5.1.0. (Actualizado por Martin von Löwis; bpo-3811.)Las funciones
warnings
del móduloformatwarning()
yshowwarning()
han ganado un argumento opcional line que puede utilizarse para proporcionar la línea de código fuente. (Añadido como parte de bpo-1631171, que reimplementaba parte del módulowarnings
en código C)Una nueva función,
catch_warnings()
, es un gestor de contexto destinado a la realización de pruebas que permite modificar temporalmente los filtros de advertencia y luego restaurar sus valores originales (bpo-3781).Las clases XML-RPC
SimpleXMLRPCServer
yDocXMLRPCServer
pueden ahora evitar que se abran inmediatamente y se vinculen a su socket pasandoFalse
como parámetro del constructor bind_and_activate. Esto puede usarse para modificar el atributoallow_reuse_address
de la instancia antes de llamar a los métodosserver_bind()
yserver_activate()
para abrir el socket y comenzar a escuchar conexiones. (Contribuido por Peter Parente; bpo-1599845.)SimpleXMLRPCServer
también tiene un atributo_send_traceback_header
; si es true, la excepción y el traceback formateado se devuelven como cabeceras HTTP «X-Exception» y «X-Traceback». Esta característica es sólo para propósitos de depuración y no debe ser usada en servidores de producción porque los trazos pueden revelar contraseñas u otra información sensible. (Contribuido por Alan McIntyre como parte de su proyecto para el Summer of Code 2007 de Google)El módulo
xmlrpclib
ya no convierte automáticamente las instanciasdatetime.date
ydatetime.time
al tipoxmlrpclib.DateTime
; la semántica de conversión no era necesariamente correcta para todas las aplicaciones. El código que utilizaxmlrpclib
debe convertir las instanciasdate
ytime
. (bpo-1330538) El código también puede manejar fechas anteriores a 1900 (contribución de Ralf Schmitt; bpo-2014) y enteros de 64 bits representados mediante el uso de<i8>
en las respuestas XML-RPC (contribución de Riku Lindblad; bpo-2985).La clase
zipfile
del móduloZipFile
tiene ahora los métodosextract()
yextractall()
que desempaquetarán un solo fichero o todos los ficheros del archivo en el directorio actual, o en un directorio especificado:z = zipfile.ZipFile('python-251.zip') # Unpack a single file, writing it relative # to the /tmp directory. z.extract('Python/sysmodule.c', '/tmp') # Unpack all the files in the archive. z.extractall()
(Contribución de Alan McIntyre; bpo-467924.)
Los métodos
open()
,read()
yextract()
ahora pueden tomar un nombre de archivo o un objetoZipInfo
. Esto es útil cuando un archivo contiene accidentalmente un nombre de archivo duplicado. (Contribución de Graham Horler; bpo-1775025.)Por último,
zipfile
soporta ahora el uso de nombres de archivo Unicode para los ficheros archivados. (Contribución de Alexey Borzenkov; bpo-1734346.)
El módulo ast
¶
El módulo ast
proporciona una representación de árbol de sintaxis abstracta del código Python, y Armin Ronacher ha contribuido con un conjunto de funciones de ayuda que realizan una variedad de tareas comunes. Éstas serán útiles para paquetes de plantillas HTML, analizadores de código y herramientas similares que procesan código Python.
La función parse()
toma una expresión y devuelve un AST. La función dump()
devuelve una representación de un árbol, adecuada para la depuración:
import ast
t = ast.parse("""
d = {}
for i in 'abcdefghijklm':
d[i + i] = ord(i) - ord('a') + 1
print d
""")
print ast.dump(t)
Esto produce un árbol profundamente anidado:
Module(body=[
Assign(targets=[
Name(id='d', ctx=Store())
], value=Dict(keys=[], values=[]))
For(target=Name(id='i', ctx=Store()),
iter=Str(s='abcdefghijklm'), body=[
Assign(targets=[
Subscript(value=
Name(id='d', ctx=Load()),
slice=
Index(value=
BinOp(left=Name(id='i', ctx=Load()), op=Add(),
right=Name(id='i', ctx=Load()))), ctx=Store())
], value=
BinOp(left=
BinOp(left=
Call(func=
Name(id='ord', ctx=Load()), args=[
Name(id='i', ctx=Load())
], keywords=[], starargs=None, kwargs=None),
op=Sub(), right=Call(func=
Name(id='ord', ctx=Load()), args=[
Str(s='a')
], keywords=[], starargs=None, kwargs=None)),
op=Add(), right=Num(n=1)))
], orelse=[])
Print(dest=None, values=[
Name(id='d', ctx=Load())
], nl=True)
])
El método literal_eval()
toma una cadena o un AST que representa una expresión literal, la analiza y evalúa, y devuelve el valor resultante. Una expresión literal es una expresión de Python que sólo contiene cadenas, números, diccionarios, etc. pero no declaraciones o llamadas a funciones. Si necesita evaluar una expresión pero no puede aceptar el riesgo de seguridad que supone utilizar una llamada a eval()
, literal_eval()
lo hará de forma segura:
>>> literal = '("a", "b", {2:4, 3:8, 1:2})'
>>> print ast.literal_eval(literal)
('a', 'b', {1: 2, 2: 4, 3: 8})
>>> print ast.literal_eval('"a" + "b"')
Traceback (most recent call last):
...
ValueError: malformed string
El módulo también incluye las clases NodeVisitor
y NodeTransformer
para recorrer y modificar un AST, y funciones para transformaciones comunes como el cambio de números de línea.
El módulo future_builtins
¶
Python 3.0 introduce muchos cambios en el repertorio de funciones incorporadas, y la mayoría de los cambios no pueden introducirse en la serie Python 2.x porque romperían la compatibilidad. El módulo future_builtins
proporciona versiones de estas funciones incorporadas que pueden importarse al escribir código compatible con la versión 3.0.
Las funciones de este módulo incluyen actualmente:
ascii(obj)
: equivalente arepr()
. En Python 3.0,repr()
devolverá una cadena Unicode, mientras queascii()
devolverá una cadena de bytes ASCII pura.filtro(predicado, iterable)
,map(func, iterable1, ...)
: las versiones 3.0 devuelven iteradores, a diferencia de las funciones integradas 2.x que devuelven listas.hex(valor)
,oct(valor)
: en lugar de llamar a los métodos__hex__()
o__oct__()
, estas versiones llamarán al método__index__()
y convertirán el resultado a hexadecimal u octal.oct()
utilizará la nueva notación0o
para su resultado.
El módulo json
: Notación de objetos de JavaScript¶
El nuevo módulo json
soporta la codificación y decodificación de tipos Python en JSON (Javascript Object Notation). JSON es un formato de intercambio ligero que se utiliza a menudo en las aplicaciones web. Para más información sobre JSON, consulte http://www.json.org.
json
viene con soporte para decodificar y codificar la mayoría de los tipos incorporados de Python. El siguiente ejemplo codifica y decodifica un diccionario:
>>> import json
>>> data = {"spam": "foo", "parrot": 42}
>>> in_json = json.dumps(data) # Encode the data
>>> in_json
'{"parrot": 42, "spam": "foo"}'
>>> json.loads(in_json) # Decode into a Python object
{"spam": "foo", "parrot": 42}
También es posible escribir tus propios decodificadores y codificadores para soportar más tipos. También se admite la impresión bonita de las cadenas JSON.
json
(originalmente llamado simplejson) fue escrito por Bob Ippolito.
El módulo plistlib
: Un analizador de listas de propiedades¶
El formato .plist
se utiliza habitualmente en Mac OS X para almacenar tipos de datos básicos (números, cadenas, listas y diccionarios) serializándolos en un formato basado en XML. Se asemeja a la serialización XML-RPC de los tipos de datos.
A pesar de ser utilizado principalmente en Mac OS X, el formato no tiene nada de específico para Mac y la implementación de Python funciona en cualquier plataforma que soporte Python, por lo que el módulo plistlib
ha sido promovido a la biblioteca estándar.
El uso del módulo es sencillo:
import sys
import plistlib
import datetime
# Create data structure
data_struct = dict(lastAccessed=datetime.datetime.now(),
version=1,
categories=('Personal','Shared','Private'))
# Create string containing XML.
plist_str = plistlib.writePlistToString(data_struct)
new_struct = plistlib.readPlistFromString(plist_str)
print data_struct
print new_struct
# Write data structure to a file and read it back.
plistlib.writePlist(data_struct, '/tmp/customizations.plist')
new_struct = plistlib.readPlist('/tmp/customizations.plist')
# read/writePlist accepts file-like objects as well as paths.
plistlib.writePlist(data_struct, sys.stdout)
mejoras en ctypes¶
Thomas Heller siguió manteniendo y mejorando el módulo ctypes
.
ctypes
soporta ahora un tipo de datos c_bool
que representa el tipo C99 bool
. (Contribución de David Remahl; bpo-1649190.)
Los tipos de cadena, buffer y array de ctypes
han mejorado el soporte para la sintaxis de corte extendida, donde se suministran varias combinaciones de (start, stop, step)
. (Implementado por Thomas Wouters)
Todos los tipos de datos ctypes
soportan ahora los métodos from_buffer()
y from_buffer_copy()
que crean una instancia de ctypes basada en un objeto buffer proporcionado. from_buffer_copy()
copia el contenido del objeto, mientras que from_buffer()
compartirá la misma área de memoria.
Una nueva convención de llamada indica a ctypes
que borre las variables errno
o Win32 LastError al inicio de cada llamada envuelta. (Implementado por Thomas Heller; bpo-1798.)
Ahora puede recuperar la variable Unix errno
después de una llamada a una función. Al crear una función envuelta, puede suministrar use_errno=True
como parámetro de palabra clave a la función DLL()
y luego llamar a los métodos de nivel de módulo set_errno()
y get_errno()
para establecer y recuperar el valor del error.
La variable Win32 LastError es soportada de forma similar por las funciones DLL()
, OleDLL()
, y WinDLL()
. Se suministra use_last_error=True
como parámetro de palabra clave y luego se llaman los métodos a nivel de módulo set_last_error()
y get_last_error()
.
La función byref()
, utilizada para recuperar un puntero a una instancia de ctypes, tiene ahora un parámetro opcional offset que es un recuento de bytes que se añadirá al puntero devuelto.
Mejora de la compatibilidad con SSL¶
Bill Janssen ha realizado amplias mejoras en el soporte de Python 2.6 para la Capa de Conexión Segura añadiendo un nuevo módulo, ssl
, que está construido sobre la biblioteca OpenSSL. Este nuevo módulo proporciona más control sobre el protocolo negociado, los certificados X.509 utilizados, y tiene un mejor soporte para escribir servidores SSL (a diferencia de los clientes) en Python. El soporte SSL existente en el módulo socket
no ha sido eliminado y sigue funcionando, aunque será eliminado en Python 3.0.
Para utilizar el nuevo módulo, primero hay que crear una conexión TCP de la forma habitual y luego pasarla a la función ssl.wrap_socket()
. Es posible especificar si se requiere un certificado, y obtener información sobre el mismo llamando al método getpeercert()
.
Ver también
La documentación del módulo ssl
.
Cancelaciones y eliminaciones¶
Se han eliminado las excepciones de cadena. Al intentar utilizarlas se produce un
TypeError
.Los cambios en la interfaz
Exception
dictados por PEP 352 siguen realizándose. En la versión 2.6, el atributomessage
queda obsoleto en favor del atributoargs
.(modo 3.0-warning) Python 3.0 presentará una biblioteca estándar reorganizada que eliminará muchos módulos obsoletos y renombrará otros. Python 2.6 funcionando en modo 3.0-warning avisará de estos módulos cuando se importen.
La lista de módulos obsoletos es:
audiodev
,bgenlocations
,buildtools
,bundlebuilder
,Canvas
,compiler
,dircache
,dl
,fpformat
,gensuitemodule
,ihooks
,imageop
,imgfile
,linuxaudiodev
,mhlib
,mimetools
,multifile
,new
,pure
,statvfs
,sunaudiodev
,test.testall
, ytoaiff
.El módulo
gopherlib
ha sido eliminado.El módulo
MimeWriter
y el módulomimify
han quedado obsoletos; utilice en su lugar el paqueteemail
.El módulo
md5
ha quedado obsoleto; utilice en su lugar el módulohashlib
.El módulo
posixfile
ha quedado obsoleto;fcntl.lockf()
proporciona un mejor bloqueo.El módulo
popen2
ha quedado obsoleto; utilice el módulosubprocess
.Se ha eliminado el módulo
rgbimg
.El módulo
sets
ha quedado obsoleto; es mejor utilizar los tipos incorporadosset
yfrozenset
.El módulo
sha
ha quedado obsoleto; utilice en su lugar el módulohashlib
.
Cambios en la API de construcción y C¶
Los cambios en el proceso de construcción de Python y en la API de C incluyen:
Python ahora debe ser compilado con compiladores C89 (¡después de 19 años!). Esto significa que el árbol de fuentes de Python ha abandonado sus propias implementaciones de
memmove()
ystrerror()
, que están en la biblioteca estándar de C89.Python 2.6 puede ser construido con Microsoft Visual Studio 2008 (versión 9.0), y este es el nuevo compilador por defecto. Ver el directorio
PCbuild
para los archivos de construcción. (Implementado por Christian Heimes)En Mac OS X, Python 2.6 puede ser compilado como una construcción universal de 4 vías. El script configure puede tomar una opción :!–with-universal-archs=[32-bit|64-bit|all], controlando si los binarios se construyen para arquitecturas de 32 bits (x86, PowerPC), 64 bits (x86-64 y PPC-64), o ambas. (Contribución de Ronald Oussoren)
El módulo BerkeleyDB tiene ahora un objeto C API, disponible como
bsddb.db.api
. Este objeto puede ser utilizado por otras extensiones de C que deseen utilizar el módulobsddb
para sus propios fines. (Contribución de Duncan Grisby)La nueva interfaz del buffer, descrita previamente en la sección PEP 3118, añade
PyObject_GetBuffer()
yPyBuffer_Release()
, así como algunas otras funciones.El uso que hace Python de la biblioteca stdio de C es ahora seguro para los hilos, o al menos tan seguro como la biblioteca subyacente. Un error potencial de larga data ocurría si un hilo cerraba un objeto de archivo mientras otro hilo estaba leyendo o escribiendo en el objeto. En la versión 2.6 los objetos archivo tienen un contador de referencias, manipulado por las funciones
PyFile_IncUseCount()
yPyFile_DecUseCount()
. Los objetos de archivo no pueden cerrarse a menos que el recuento de referencias sea cero.PyFile_IncUseCount()
debe llamarse mientras se mantiene el GIL, antes de realizar una operación de E/S utilizando el punteroFILE *
, yPyFile_DecUseCount()
debe llamarse inmediatamente después de recuperar el GIL. (Contribución de Antoine Pitrou y Gregory P. Smith)Importar módulos simultáneamente en dos hilos diferentes ya no se bloquea; ahora lanzará un
ImportError
. Una nueva función de la API,PyImport_ImportModuleNoBlock()
, buscará un módulo ensys.modules
primero, y luego intentará importarlo después de adquirir un bloqueo de importación. Si el bloqueo de importación está en manos de otro hilo, se genera unImportError
. (Contribuido por Christian Heimes.)Varias funciones devuelven información sobre el soporte de punto flotante de la plataforma.
PyFloat_GetMax()
devuelve el máximo valor de punto flotante representable, yPyFloat_GetMin()
devuelve el mínimo valor positivo.PyFloat_GetInfo()
devuelve un objeto que contiene más información del ficherofloat.h
, como"mant_dig"
(número de dígitos en la mantisa),"epsilon"
(diferencia más pequeña entre 1.0 y el siguiente valor más grande representable), y varios otros. (Contribución de Christian Heimes; bpo-1534.)Las funciones y métodos de C que utilizan
PyComplex_AsCComplex()
ahora aceptarán argumentos que tengan un método__complex__()
. En particular, las funciones del módulocmath
ahora aceptarán objetos con este método. Este es un retroceso de un cambio en Python 3.0. (Contribuido por Mark Dickinson; bpo-1675423.)La API de C de Python incluye ahora dos funciones para comparar cadenas sin distinción de mayúsculas y minúsculas,
PyOS_stricmp(char*, char*)
yPyOS_strnicmp(char*, char*, Py_ssize_t)
. (Contribución de Christian Heimes; bpo-1635.)Muchas extensiones de C definen su propia macro para añadir enteros y cadenas al diccionario del módulo en la función
init*
. Python 2.6 finalmente define macros estándar para añadir valores a un módulo,PyModule_AddStringMacro
yPyModule_AddIntMacro()
. (Contribución de Christian Heimes.)Algunas macros han sido renombradas tanto en la 3.0 como en la 2.6 para dejar más claro que son macros y no funciones.
Py_Size()
se convierte enPy_SIZE()
,Py_Type()
se convierte enPy_TYPE()
, yPy_Refcnt()
se convierte enPy_REFCNT()
. Las macros de mayúsculas y minúsculas siguen estando disponibles en Python 2.6 por compatibilidad con versiones anteriores. (bpo-1629)Distutils ahora coloca las extensiones C que construye en un directorio diferente cuando se ejecuta en una versión de depuración de Python. (Contribución de Collin Winter; bpo-1530959.)
Varios tipos de datos básicos, como los enteros y las cadenas, mantienen listas internas de objetos libres que pueden reutilizarse. Las estructuras de datos para estas listas libres siguen ahora una convención de nomenclatura: la variable se llama siempre
free_list
, el contador se llama siemprenumfree
, y siempre se define una macroPy<typename>_MAXFREELIST
Un nuevo objetivo de Makefile, «make patchcheck», prepara el árbol de fuentes de Python para hacer un parche: corrige los espacios en blanco al final de todos los archivos
.py
modificados, comprueba si la documentación ha sido cambiada, e informa si los archivosMisc/ACKS
yMisc/NEWS
han sido actualizados. (Contribuido por Brett Cannon.)Otro nuevo objetivo, «make profile-opt», compila un binario de Python utilizando la optimización guiada por perfiles de GCC. Compila Python con el perfil habilitado, ejecuta el conjunto de pruebas para obtener un conjunto de resultados de perfil, y luego compila usando estos resultados para la optimización. (Contribución de Gregory P. Smith)
Cambios específicos en los puertos: Windows¶
Se ha eliminado el soporte para Windows 95, 98, ME y NT4. Python 2.6 requiere al menos Windows 2000 SP4.
El nuevo compilador por defecto en Windows es Visual Studio 2008 (versión 9.0). Los directorios de compilación para Visual Studio 2003 (versión 7.1) y 2005 (versión 8.0) se han trasladado al directorio PC/. El nuevo directorio
PCbuild
admite la compilación cruzada para X64, las compilaciones de depuración y la optimización guiada por perfil (PGO). Las compilaciones PGO son aproximadamente un 10% f más rápidas que las normales. (Contribuido por Christian Heimes con la ayuda de Amaury Forgeot d’Arc y Martin von Löwis)El módulo
msvcrt
soporta ahora las variantes normal y wide char de la API de E/S de la consola. La funcióngetwch()
lee una pulsación de tecla y devuelve un valor Unicode, al igual que la funcióngetwche()
. La funciónputwch()
toma un carácter Unicode y lo escribe en la consola. (Contribución de Christian Heimes)os.path.expandvars()
ahora expandirá las variables de entorno de la forma «%var%», y «~user» se expandirá en la ruta del directorio personal del usuario. (Contribución de Josiah Carlson; bpo-957650.)Los objetos socket del módulo
socket
tienen ahora un métodoioctl()
que proporciona una interfaz limitada a la interfaz del sistemaWSAIoctl()
.El módulo
_winreg
tiene ahora una función,ExpandEnvironmentStrings()
, que expande las referencias a variables de entorno como%NAME%
en una cadena de entrada. Los objetos handle proporcionados por este módulo ahora soportan el protocolo de contexto, por lo que pueden ser utilizados en sentenciaswith
. (Contribuido por Christian Heimes.)_winreg
también tiene un mejor soporte para los sistemas x64, exponiendo las funcionesDisableReflectionKey()
,EnableReflectionKey()
, yQueryReflectionKey()
, que habilitan y deshabilitan la reflexión del registro para los procesos de 32 bits que se ejecutan en sistemas de 64 bits. (bpo-1753245)El objeto
Record
del módulomsilib
ha ganado los métodosGetInteger()
yGetString()
que devuelven los valores de los campos como un entero o una cadena. (Contribución de Floris Bruynooghe; bpo-2125.)
Cambios específicos en los puertos: Mac OS X¶
Cuando se compila una estructura de Python, ahora se puede especificar el nombre de la estructura que se utilizará proporcionando la opción
--with-framework-name=
al script configure.Se ha eliminado el módulo
macfs
. Esto, a su vez, ha requerido la eliminación de la funciónmacostools.touched()
porque dependía del módulomacfs
. (bpo-1490190)Muchos otros módulos de Mac OS han quedado obsoletos y serán eliminados en Python 3.0:
_builtinSuites
,aepack
,aetools
,aetypes
,applesingle
,appletrawmain
,appletrunner
,argvemulator
,Audio_mac
,autoGIL
,Carbon
,cfmfile
,CodeWarrior
,ColorPicker
,EasyDialogs
,Explorer
,Finder
,FrameWork
,findertools
,ic
,icglue
,icopen
,macerrors
,MacOS
,macfs
,macostools
,macresource
,MiniAEFrame
,Nav
,Netscape
,OSATerminology
,pimp
,PixMapWrapper
,StdSuites
,SystemEvents
,Terminal
, yterminalcommand
.
Cambios específicos en los puertos: IRIX¶
Una serie de antiguos módulos específicos de IRIX fueron obsoletos y serán eliminados en Python 3.0: al
y AL
, cd
, cddb
, cdplayer
, CL
y cl
, DEVICE
, ERRNO
, FILE
, FL
y fl
, flp
, fm
, GET
, GLWS
, GL
y gl
, IN
, IOCTL
, jpeg
, panelparser
, readcd
, SV
y sv
, torgb
, videoreader
y WAIT
.
Adaptación a Python 2.6¶
Esta sección enumera los cambios descritos anteriormente y otras correcciones de errores que pueden requerir cambios en su código:
Las clases que no se supone que son hashable deben establecer
__hash__ = None
en sus definiciones para indicar el hecho.Se han eliminado las excepciones de cadena. Al intentar utilizarlas se produce un
TypeError
.El método
__init__()
decollections.deque
ahora borra cualquier contenido existente del deque antes de añadir elementos del iterable. Este cambio hace que el comportamiento coincida conlist.__init__()
.object.__init__()
anteriormente aceptaba argumentos arbitrarios y argumentos de palabras clave, ignorándolos. En Python 2.6, esto ya no está permitido y resultará en unTypeError
. Esto afectará a los métodos__init__()
que acaben llamando al método correspondiente enobject
(quizás mediante el uso desuper()
). Ver bpo-1683368 para su discusión.El constructor
Decimal
ahora acepta los espacios en blanco iniciales y finales cuando se le pasa una cadena. Antes lanzaba una excepciónInvalidOperation
. Por otro lado, el métodocreate_decimal()
de los objetosContext
ahora desestima explícitamente los espacios en blanco adicionales, lanzando una excepciónConversionSyntax
.Debido a un accidente de implementación, si se pasaba una ruta de archivo a la función incorporada
__import__()
, ésta importaría realmente el archivo especificado. Sin embargo, nunca se pretendió que esto funcionara, y la implementación ahora comprueba explícitamente este caso y lanza unImportError
.API C: las funciones
PyImport_Import()
yPyImport_ImportModule()
ahora se ajustan por defecto a importaciones absolutas, no a importaciones relativas. Esto afectará a las extensiones de C que importen otros módulos.API C: los tipos de datos de extensión que no deben ser hashable deben definir su ranura
tp_hash
aPyObject_HashNotImplemented()
.La excepción del módulo
socket
socket.error
ahora hereda deIOError
. Anteriormente no era una subclase deStandardError
pero ahora lo es, a través deIOError
. (Implementado por Gregory P. Smith; bpo-1706815.)El módulo
xmlrpclib
ya no convierte automáticamente las instanciasdatetime.date
ydatetime.time
al tipoxmlrpclib.DateTime
; la semántica de conversión no era necesariamente correcta para todas las aplicaciones. El código que utilizaxmlrpclib
debe convertir las instanciasdate
ytime
. (bpo-1330538)(Modo de advertencia 3.0) La clase
Exception
ahora advierte cuando se accede utilizando el acceso a la rebanada o al índice; tenerException
se comporta como una tupla está siendo eliminado.(modo de advertencia 3.0) las comparaciones de desigualdad entre dos diccionarios o dos objetos que no implementan métodos de comparación se reportan como advertencias.
dict1 == dict2
sigue funcionando, perodict1 < dict2
está siendo eliminado.Las comparaciones entre celdas, que son un detalle de implementación de las reglas de alcance de Python, también causan advertencias porque tales comparaciones están prohibidas por completo en 3.0.
Agradecimientos¶
El autor desea agradecer a las siguientes personas sus sugerencias, correcciones y ayuda en varios borradores de este artículo: Georg Brandl, Steve Brown, Nick Coghlan, Ralph Corderoy, Jim Jewett, Kent Johnson, Chris Lambacher, Martin Michlmayr, Antoine Pitrou, Brian Warner.