Qué hay de nuevo en Python 3.0

Autor

Guido van Rossum

En este artículo se explican las nuevas características de Python 3.0, en comparación con las de 2.6. Python 3.0, también conocido como «Python 3000» o «Py3K». Es la primera versión de Python intencionalmente incompatible hacia atrás. Hay más cambios que en una versión típica y más que son importantes para todos los usuarios de Python. Sin embargo, después de digerir los cambios, se comprobará que Python no ha cambiado tanto realmente – en general, estamos arreglando en su mayoría molestias y defectos bien conocidos, y la eliminación de una gran cantidad de sobras antiguas.

Este artículo no intenta proporcionar una especificación completa de todas las características nuevas, sino que intenta proporcionar una visión general conveniente. Para obtener más información, se debe consultar la documentación de Python 3.0 y/o los muchos PEP a los que se hace referencia en el texto. Si se desea comprender la lógica completa de implementación y diseño para una característica determinada, los PEP suelen tener más detalles que la documentación regular, pero téngase en cuenta que los PEP generalmente no se mantienen actualizados una vez que una característica se ha implementado completamente.

Debido a restricciones de tiempo, este documento no es tan completo como debería haber sido. Como siempre para una nueva versión, el archivo Misc/NEWS en la distribución de origen contiene una gran cantidad de información detallada sobre cada pequeña cosa que se cambió.

Escollos comunes

Esta sección contiene esos pequeños cambios que probablemente generarán tropiezos si se está acostumbrado a Python 2.5.

Vistas e iteradores en lugar de listas

Algunas APIs bien conocidas no retornan más listas:

  • Los métodos dict dict.keys(), dict.items() y dict.values() retornan «vistas» en lugar de listas. Por ejemplo, esto no funciona más: k = d.keys(); k.sort(). Se usa k = sorted(d) en su lugar (esto funciona también en Python 2.5 y es igual de eficiente).

  • Además, los métodos dict.iterkeys(), dict.iteritems() y dict.itervalues() ya no son compatibles.

  • map() y filter() retornan iteradores. Si realmente se necesita una lista y las secuencias de entrada son todas de igual longitud, una solución rápida es envolver map() en list(), por ejemplo list(map(...)), pero una mejor solución es a menudo utilizar una lista por comprensión (especialmente cuando el código original utiliza lambda), o reescribir el código para que no necesite una lista en absoluto. Particularmente complicado es map() invocado para los efectos secundarios de la función; la transformación correcta es usar un bucle for normal (ya que crear una lista sería simplemente un desperdicio).

    Si las secuencias de entrada no tienen la misma longitud, map() se detendrá en la terminación de la más corta de las secuencias. Para una compatibilidad completa con map() de Python 2.x, también se envuelve las secuencias en itertools.zip_longest(), por ejemplo map(func, *sequences) se convierte en list(map(func, itertools.zip_longest(*sequences))).

  • range() ahora se comporta como xrange() solía comportarse, excepto que funciona con valores de tamaño arbitrario. Este último ya no existe.

  • zip() ahora retorna un iterador.

Comparaciones de ordenamiento

Python 3.0 ha simplificado las reglas para las comparaciones de ordenamiento:

  • Los operadores de comparaciones de ordenamiento (<, <,``”>``, >) lanzan una excepción TypeError cuando los operandos no tienen un orden natural significativo. Por lo tanto, expresiones como 1 < '', 0 > None o len <= len ya no son válidas, y por ejemplo Ninguno < Ninguno lanza TypeError en lugar de retornar False. Un corolario es que ordenar una lista heterogénea ya no tiene sentido – todos los elementos deben ser comparables entre sí. Tener en cuenta que esto no se aplica a los operadores == y !=: los objetos de diferentes tipos incomparables siempre se comparan desiguales entre sí.

  • builtin.sorted() y list.sort() ya no aceptan el argumento cmp que proporciona una función de comparación. Utilice el argumento key en su lugar. N.B. los argumentos key y reverse ahora son «argumentos por palabra clave».

  • La función cmp() debe tratarse como quitada, y el método especial __cmp__() ya no es compatible. Utilizar __lt__() para el ordenamiento, __eq__() con __hash__(), y otras comparaciones costosas según sea necesario. (Si realmente se necesita la funcionalidad cmp(), se puede utilizar la expresión (a > b) - (a < b) como el equivalente para cmp(a, b).)

Enteros

  • PEP 237: Esencialmente, long renombrado a int. Es decir, solo hay un tipo integral incorporado, denominado int; pero se comporta sobre todo como el viejo tipo long.

  • PEP 238: Una expresión como 1/2 retorna un float. Utilizar 1//2 para obtener el comportamiento de truncamiento. (Esta última sintaxis ha existido durante años, al menos desde Python 2.2.)

  • Se eliminó la constante sys.maxint, ya que ya no hay un límite para el valor de los enteros. Sin embargo, sys.maxsize se puede utilizar como un entero mayor que cualquier lista práctica o índice de cadena de caracteres. Se ajusta al tamaño entero «natural» de la implementación y suele ser el mismo que sys.maxint en versiones anteriores de la misma plataforma (suponiendo las mismas opciones de compilación).

  • El repr() de un entero largo ya no incluye la L final, por lo que el código que elimina incondicionalmente ese carácter cortará el último dígito en su lugar. (Utilizar str() en su lugar.)

  • Los literales octales ya no usan la forma 0720; úsese 0o720 en su lugar.

Texto vs. datos en lugar de unicode vs. 8 bits

Todo lo que pensabas saber sobre datos binarios y Unicode ha cambiado.

  • Python 3.0 utiliza los conceptos de text y datos (binarios) en lugar de cadenas de caracteres Unicode y cadenas de caracteres de 8 bits. Todo el texto es Unicode; sin embargo el Unicode codificado se representa como datos binarios. El tipo utilizado para contener texto es str, el tipo utilizado para contener datos es bytes. La mayor diferencia con la situación 2.x es que cualquier intento de mezclar texto y datos en Python 3.0 lanza un TypeError, mientras que si se mezclan cadenas Unicode y de 8 bits en Python 2.x, funcionaría si la cadena de 8 bits contuviera sólo bytes de 7 bits (ASCII), pero se obtendría un UnicodeDecodeError si contenía valores no ASCII. Este comportamiento específico del valor ha causado numerosas caras tristes a lo largo de los años.

  • Como consecuencia de este cambio en la filosofía, prácticamente todo el código que utiliza Unicode, codificaciones o datos binarios muy probablemente tiene que cambiar. El cambio es para mejor, ya que en el mundo 2.x había numerosos errores que tenían que ver con la mezcla de texto codificado y sin codificar. Para estar preparado en Python 2.x, comienza a usar unicode para todo el texto sin codificar, y str solo para datos binarios o codificados. Luego , la herramienta 2to3 hará la mayor parte del trabajo por ti.

  • Ya no se puede utilizar literales u"..." para texto Unicode. Sin embargo, se debe usar literales b"..." para los datos binarios.

  • Como los tipos str y bytes no se pueden mezclar, siempre se deben convertir explícitamente entre ellos. Utilizar str.encode() para pasar de str a bytes, y bytes.decode() para pasar de bytes a str. También se puede utilizar bytes(s, encoding=...) y str(b, encoding=...), respectivamente.

  • Al igual que str, el tipo bytes es inmutable. Hay un tipo mutable independiente para contener datos binarios almacenados en búfer, bytearray. Casi todas las API que aceptan bytes también aceptan bytearray. La API mutable se basa en collections. MutableSequence.

  • Todas las barras invertidas en literales de cadena de caracteres sin formato se interpretan literalmente. Esto significa que los escapes '\U' y '\u' en cadenas de caracteres sin formato no se tratan especialmente. Por ejemplo, r'\u20ac' es una cadena de 6 caracteres en Python 3.0, mientras que en 2.6, ur'\u20ac' era el único carácter «euro». (Por supuesto, este cambio sólo afecta a los literales de cadena de caracteres sin formato; el carácter del euro es '\u20ac' en Python 3.0.)

  • Se eliminó el tipo abstracto basestring incorporado. Se utiliza str en su lugar. Los tipos str y bytes no tienen suficiente funcionalidad en común para garantizar una clase base compartida. La herramienta 2to3 (ver más abajo) reemplaza cada aparición de basestring por str.

  • Los archivos abiertos como archivos de texto (todavía el modo predeterminado para open()) siempre utilizan una codificación para asignar entre cadenas de caracteres(en memoria) y bytes (en disco). Los archivos binarios (abiertos con una b en el argumento modo) siempre utilizan bytes en la memoria. Esto significa que si un archivo se abre utilizando un modo o codificación incorrectos, es probable que la E/S falle ruidosamente, en lugar de producir datos incorrectos de forma silenciosa. También significa que incluso los usuarios de Unix tendrán que especificar el modo correcto (texto o binario) al abrir un archivo. Hay una codificación predeterminada dependiente de la plataforma, que en las plataformas Unix se puede establecer con la variable de entorno LANG (y a veces también con algunas otras variables de entorno relacionadas con la configuración regional específicas de la plataforma). En muchos casos, pero no en todos, el valor predeterminado del sistema es UTF-8; nunca se debe contar con este valor predeterminado. Cualquier aplicación que lea o escriba más que texto ASCII puro probablemente debería tener una manera de invalidar la codificación. Ya no es necesario utilizar las secuencias compatibles con la codificación en el módulo codecs.

  • Los valores iniciales de sys.stdin, sys.stdout y sys.stderr ahora son archivos de texto solo unicode (es decir, son instancias de io.TextIOBase). Para leer y escribir datos de bytes con estas secuencias, se debe usar su atributo io.TextIOBase.buffer.

  • Los nombres de archivos son pasados y retornados de cadenas desde APIs como cadenas de caracteres (Unicode). Esto puede presentar problemas específicos de plataformas porque en algunas plataformas los nombres de archivos son cadenas de caracteres de bytes arbitrarios. (Por otro lado, en Windows los nombres de archivos son almacenados de forma nativa como Unicode.) Como solución alternativa, la mayoría de las APIs (por ejemplo open() y muchas otras funciones en el módulo os) que toman nombres de archivos aceptan tanto objetos bytes como cadenas de caracteres, y algunas APIs tienen una forma de demandar por un valor de retorno bytes. Por lo tanto, os.listdir() retorna una lista de instancias bytes si el argumento es una instancia bytes, y os.getcwdb() retorna el directorio de trabajo actual como una instancia bytes. Tener en cuenta que cuando os.listdir() retorna una lista de cadenas de caracteres, los nombres de archivo que no se pueden decodificar correctamente se omiten en lugar de lanzar UnicodeError.

  • Algunas APIs del sistema como os.environ y sys.argv también pueden presentar problemas cuando los bytes puestos a disposición por el sistema no son interpretables usando la codificación predeterminada. Probablemente el mejor abordaje sea asignando la variable LANG y volviendo a ejecutar el programa.

  • PEP 3138: El repr() de una cadena de caracteres ya no escapa caracteres no ASCII. Sin embargo, todavía escapa caracteres de control caracteres y puntos de código con estado no imprimible en el estándar the Unicode.

  • PEP 3120: La codificación de fuente predeterminada ahora es UTF-8.

  • PEP 3131: Letras no ASCII ahora están permitidas en identificadores. (De todas maneras, la librería estándar permanece como sólo ASCII con la excepción de nombres de colaboradores en comentarios.)

  • Los módulos StringIO and cStringIO ya no están. En su lugar, se importa el módulo the io y se usa io.StringIO o io.BytesIO para texto y datos respectivamente.

  • Ver también CÓMO (HOWTO) Unicode, que fue actualizado para Python 3.0.

Descripción general de los cambios de sintaxis

Esta sección brinda una descripción general breve de cada cambio sintáctico en Python 3.0.

Nueva sintaxis

  • PEP 3107: Argumento de función y anotaciones de valor retornado. Esto proporciona una forma estandarizada de anotar los parámetros y el valor retornado de una función. No hay semántica asociada a estas anotaciones, excepto que se pueden introspeccionar en tiempo de ejecución mediante el atributo __annotations__. La intención es fomentar la experimentación a través de metaclases, decoradores o frameworks.

  • PEP 3102: Argumentos de sólo palabra clave. Los parámetros con nombre que se producen después de *args en la lista de parámetros deben especificarse mediante la sintaxis de palabra clave en la llamada. También puede usarse apenas un``*`` sólo en la lista de parámetros para indicar que no se acepta una lista de argumentos de longitud variable, pero se tiene argumentos de sólo palabra clave.

  • Los argumentos de palabra clave se permiten después de la lista de clases base en una definición de clase. Esto lo usa la nueva convención para especificar una metaclase (consultar la sección siguiente), pero también se puede usar para otros fines, siempre y cuando la metaclase la admita.

  • PEP 3104: Declaración nonlocal. Utilizando nonlocal x ahora se puede asignar directamente a una variable en un entorno externo (pero no global). nonlocal es una nueva palabra reservada.

  • PEP 3132: Desempaque iterable extendido. Ahora se puede escribir cosas como a, b, *rest = some_sequence. E incluso *rest, a = cosas. El objeto rest es siempre una lista (posiblemente vacía); el lado derecho puede ser cualquier iterable. Ejemplo:

    (a, *rest, b) = range(5)
    

    Esto asigna a a 0, b a 4, y rest a [1, 2, 3].

  • Comprensiones por diccionario: {k: v for k, v in cosas} significa lo mismo que dict(cosas), pero es más flexible. (Esto es PEP 274 reivindicado. :-)

  • Asignar los literales, por ejemplo, {1, 2}. Tener en cuenta que {} es un diccionario vacío; utilizar set() para un conjunto vacío. También se admiten las comprensiones de conjunto; por ejemplo, x for x in cosas significa lo mismo que set(cosas), pero es más flexible.

  • Nuevos octales literales, por ejemplo, 0o720 (ya en 2.6). Los octales literales viejos (0720) se eliminaron.

  • Nuevos literales binarios, por ejemplo, 0b1010 (ya en 2.6), y hay una nueva función incorporada correspondiente, bin().

  • Los literales de bytes se introducen con un b o B delantero, y hay una nueva función incorporada correspondiente, bytes().

Sintaxis modificada

  • PEP 3109 y PEP 3134: Nueva sintaxis de la instrucción raise: raise [expr [from expr]]. Ver a continuación.

  • as y with ahora son palabras reservadas. (Desde 2.6, de hecho.)

  • True, False y None son palabras reservadas. (2.6 parcialmente estableció restricciones ya en None.)

  • Cambio de except exc, var a except exc as var.Ver PEP 3110.

  • PEP 3115: Nueva sintaxis de metaclase. En lugar de:

    class C:
        __metaclass__ = M
        ...
    

    ahora se debe usar:

    class C(metaclass=M):
        ...
    

    Ya no se admite la variable de módulo global __metaclass__. (Era una muleta para facilitar al valor predeterminado a las clases de estilo nuevo sin derivar todas las clases de object.)

  • Las listas por comprensión ya no admiten la forma sintáctica [... for var in item1, item2, ...]. Utilizar [... forvar in (item1, item2, ...)] en su lugar. También tener en cuenta que las listas por comprensión tienen semántica diferente: están más cerca del azúcar sintáctico para una expresión de generador dentro de un constructor list() y, en particular, las variables de control de bucle ya no se filtran en el ámbito circundante.

  • La elipsis (...) puede ser utilizada como una expresión atómica en cualquier lugar. (Previamente sólo estaba permitida en segmentos.) Asimismo, esto ahora debe ser escrito como .... (Anteriormente, también podía ser escrito como . . ., por un mero accidente de la gramática.)

Sintaxis eliminada

  • PEP 3113: Desempaque de parámetros de tupla eliminados. Ya no se puede escribir def foo(a, (b, c)): .... Utilizar def foo(a, b_c): b, c = b_c en su lugar.

  • Comillas invertidas eliminadas (usar repr() en su lugar).

  • Eliminados <> (usar != en su lugar).

  • Palabra clave eliminada: exec() ya no es una palabra clave; continúa siendo una función. (Afortunadamente la sintaxis de la función también era aceptada en 2.x.) Asimismo, nótese que la exec() ya no toma un argumento de flujo; en lugar de exec(f) se puede utilizar exec(f.read()).

  • Literales enteros no admiten más l o L finales.

  • Literales de cadena de caracteres no admiten más u or U iniciales.

  • La sintaxis from module import * solo se permite en el nivel de módulo, ya no dentro de las funciones.

  • La única sintaxis aceptable para imports relativos es from .[module] import name. Todos los formularios import que no comienzan con . son interpretados como imports absolutos

  • Se eliminaron las clases clásicas.

Cambios ya presentes en Python 2.6

Dado que es de suponer que muchos usuarios saltan directamente de Python 2.5 a Python 3.0, esta sección recuerda al lector nuevas características que se diseñaron originalmente para Python 3.0 pero que fueron llevadas hacia atrás a Python 2.6. Las secciones correspondientes en What’s New in Python 2.6 deberían ser consultadas para descripciones más largas.

Cambios de biblioteca

Debido a las limitaciones de tiempo, este documento no cubre exhaustivamente los muy extensos cambios en la biblioteca estándar. PEP 3108 es la referencia para los principales cambios en la biblioteca. Aquí hay una revisión de cápsula:

  • Se eliminaron muchos módulos antiguos. Algunos, como gopherlib (ya no se usa) y md5 (reemplazado por hashlib), ya estaban en desuso por PEP 4. Otros fueron eliminados como resultado de la eliminación de soporte para varias plataformas como Irix, BeOS y Mac OS 9 (ver PEP 11). Algunos módulos también fueron seleccionados para su eliminación en Python 3.0 debido a la falta de uso o porque existe un mejor reemplazo. Consultar PEP 3108 para obtener una lista exhaustiva.

  • El paquete bsddb3 fue eliminado porque su presencia en la biblioteca estándar principal ha demostrado con el tiempo ser una particular carga para los desarrolladores principales, debido a la inestabilidad de las pruebas y la programación del lanzamiento de Berkeley DB. Sin embargo, el paquete está vivo y bien, mantenido externamente en https://www.jcea.es/programacion/pybsddb.htm.

  • Algunos módulos fueron renombrados porque su antiguo nombre desobedeció PEP 8, o por varias otras razones. Aquí está la lista:

    Nombre anterior

    Nombre nuevo

    _winreg

    winreg

    ConfigParser

    configparser

    copy_reg

    copyreg

    Queue

    queue

    SocketServer

    socketserver

    markupbase

    _markupbase

    repr

    reprlib

    test.test_support

    test.support

  • Un patrón común en Python 2.x es tener una versión de un módulo implementado en Python puro, con una versión acelerada opcional implementada como una extensión C; por ejemplo, pickle y cPickle. Esto coloca la carga de importar la versión acelerada y volver a caer en la versión de Python pura en cada usuario de estos módulos. En Python 3.0, las versiones aceleradas se consideran detalles de implementación de las versiones puras de Python. Los usuarios siempre deberían importar la versión estándar, que intenta importar la versión acelerada y vuelve a la versión de Python pura. El par pickle / cPickle recibió este tratamiento. El módulo profile está en la lista para 3.1. El módulo StringIO se ha convertido en una clase en el módulo io.

  • Algunos módulos relacionados se han agrupado en paquetes y, por lo general, los nombres de submódulo se han simplificado. Los nuevos paquetes resultantes son:

    • dbm (anydbm, dbhash, dbm, dumbdbm, gdbm, whichdb).

    • html (HTMLParser, htmlentitydefs).

    • http (httplib, BaseHTTPServer, CGIHTTPServer, SimpleHTTPServer, Cookie, cookielib).

    • tkinter (todos los módulos relacionados con Tkinter excepto turtle). Al público objetivo de turtle no le interesa realmente tkinter. También tener en cuenta que a partir de Python 2.6, la funcionalidad de turtle se ha mejorado considerablemente.

    • urllib (urllib, urllib2, urlparse, robotparse).

    • xmlrpc (xmlrpclib, DocXMLRPCServer, SimpleXMLRPCServer).

Algunos otros cambios a los módulos de la biblioteca estándar, no cubiertos por PEP 3108:

  • Quitado sets. Usar la clase incorporada set().

  • Limpiado el módulo sys: quitado sys.exitfunc(), sys.exc_clear(), sys.exc_type, sys.exc_value, sys.exc_traceback. (Notar que sys.last_type etc. permanece.)

  • Limpiado del tipo array.array: los métodos read() y write() ya no están; usar fromfile() y tofile() en su lugar. Asimismo, the el código de tipo 'c' para arreglo ya no está– utilizar o bien 'b' para bytes o 'u' para caracteres Unicode.

  • Limpieza del módulo operator: quitados sequenceIncludes() y isCallable().

  • Limpieza del módulo thread: acquire_lock() y release_lock() ya no están; utilizar acquire() y release() en su lugar.

  • Limpieza del módulo random: quitada la API jumpahead().

  • El módulo new ya no está.

  • Las funciones os.tmpnam(), os.tempnam() y os.tmpfile() se han eliminado en favor del módulo tempfile.

  • El módulo tokenize se ha cambiado para trabajar con bytes. El punto de entrada principal es ahora tokenize.tokenize(), en lugar de generate_tokens.

  • string.letters y sus amigos (string.lowercase and string.uppercase) han sido eliminadas. Utilizar string.ascii_letters etc. en su lugar. (La razón para la eliminación es que string.letters y sus amigos tenían un comportamiento específico de lugar, que es una mala idea para tales «constantes» nombradas atractivamente globales.)

  • Renombrado el módulo __builtin__ a builtins (quitando los guiones bajos, agregando una “s”). La variable __builtins__ encontrada en la mayoría de los espacios de nombres globales no tiene cambios. Para modificar un builtin, Se debería usar builtins, no __builtins__!

PEP 3101: Un nuevo enfoque al formateo de cadena de caracteres

  • Un nuevo sistema para operaciones de formateo de cadenas de caracteres incorporadas reemplaza el operador de formato de cadena de caracteres %. (De todas maneras, el operador % sigue siento soportado; será obsoleto en Python 3.1 y quitado del lenguaje en algún momento más adelante.) Leer PEP 3101 para la primicia completa.

Cambios a excepciones

Las APIs para lanzar y capturar excepciones se limpiaron y se agregaron nuevas características poderosas:

  • PEP 352: Todas las excepciones deben derivarse (directa o indirectamente) de BaseException. Esta es la raíz de la jerarquía de excepciones. Esto no es nuevo como recomendación, pero el requisito de heredar de BaseException es nuevo. (Python 2.6 aún permitía que las clases clásicas se lanzaran, y no ponía ninguna restricción en lo que se podía capturar.) Como consecuencia, las excepciones de cadena de caracteres finalmente están verdaderamente y completamente muertas.

  • Casi todas las excepciones deberían de hecho derivarse de Exception; BaseException sólo debe utilizarse como clase base para las excepciones que solo deben controlarse en el nivel superior, como SystemExit o KeyboardInterrupt. El modismo recomendado para controlar todas las excepciones excepto esta última categoría es usar except Exception.

  • StandardError fue eliminado.

  • Las excepciones ya no se comportan como secuencias. Utilizar el atributo args en su lugar.

  • PEP 3109: Lanzando excepciones. Ahora se debe usar raise Exception(args) en lugar de raise Exception, args. Adicionalmente, ya no se puede especificar explícitamente un traceback; en su lugar, si se debe hacer esto, se puede asignar directamente al atributo __traceback__ (ver debajo).

  • PEP 3110: Atrapando excepciones. Ahora se debe usar except AlgunaExcepcion como variable en lugar de except AlgunaExcepcion, variable. Además, la variable es específicamente eliminada cuando el bloque except se deja.

  • PEP 3134: Encadenamiento de excepciones. Hay dos casos: encadenamiento implícito y encadenamiento explícito. El encadenamiento implícito se produce cuando se lanza una excepción en un bloque de controlador except o finally. Esto suele ocurrir debido a un error en el bloque de controlador; llamamos a esto una excepción secundaria. En este caso, la excepción original (que se estaba controlando) se guarda como el atributo __context__ de la excepción secundaria. El encadenamiento explícito se invoca con esta sintaxis:

    raise SecondaryException() from primary_exception
    

    (donde primary_exception es cualquier expresión que produce un objeto de excepción, probablemente una excepción que se detectó anteriormente). En este caso, la excepción principal se almacena en el atributo __cause__ de la excepción secundaria. El traceback impreso recorre la cadena de atributos __cause__ y __context__ cuando se produce una excepción no controlada e imprime un traceback independiente para cada componente de la cadena, con la excepción principal en la parte superior. (Los usuarios de Java pueden reconocer este comportamiento.)

  • PEP 3134: Los objetos de excepción ahora almacenan su traceback como el atributo __traceback__. Esto significa que un objeto de excepción ahora contiene toda la información relativa a una excepción y hay menos razones para usar sys.exc_info() (aunque este último no se quita).

  • Algunos mensajes de excepción se mejoraron cuando Windows falla al cargar un módulo de extensión. Por ejemplo, error code 193 ahora es %1 is not a valid Win32 application. Las cadenas de caracteres ahora tratan con configuraciones regionales no inglesas.

Otros cambios diversos

Operadores y métodos especiales

  • != ahora retorna lo opuesto de ==, salvo que == retorne NotImplemented.

  • El concepto de «métodos independientes» fue quitado del lenguaje. Cuando se refiere a un método como atributo de clase, ahora se obtiene un objeto de función simple.

  • __getslice__(), __setslice__() y __delslice__() se quitaron. La sintaxis``a[i:j]`` ahora se traduce a a.__getitem__(slice(i, j)) (o __setitem__() o __delitem__(), cuando se utiliza como destino de asignación o eliminación, respectivamente).

  • PEP 3114: El método estándar next() se ha renombrado como __next__().

  • Los métodos especiales __oct__() y __hex__() se quitaron – oct() y hex() utilizan __index__() ahora para convertir el argumento a un entero.

  • Soporte eliminado para __members__ y __methods__.

  • Se ha cambiado el nombre de los atributos de función denominados func_X para utilizar el formulario __X__, liberando estos nombres en el espacio de nombres de atributo de función para los atributos definidos por el usuario. Es decir, func_closure, func_code, func_defaults, func_dict, func_doc, func_globals, func_name se renombraron a __closure__, __code__, __defaults__, __dict__, __doc__, __globals__, __name__, respectivamente.

  • __nonzero__() ahora es __bool__().

Incorporados

  • PEP 3135: Nuevo super(). Ahora se puede invocar super() sin argumentos y (suponiendo que se encuentra en un método de instancia normal definido dentro de una declaración class) se elegirá automáticamente la clase y la instancia correctas. Con argumentos, el comportamiento de super() no cambia.

  • PEP 3111: raw_input() se renombró a input(). Es decir, la nueva función input() lee una línea de sys.stdin y la retorna con la línea final despojada. Lanza EOFError si la entrada se termina prematuramente. Para obtener el comportamiento anterior de input(), utilice eval(input()).

  • Se añadió una nueva función incorporada next() para llamar al método __next__() sobre un objeto.

  • La estrategia de redondeo de la función round() y el tipo de retorno han cambiado. Los casos exactamente a mitad de camino ahora se redondean al resultado par más cercano en lugar de alejarse de cero. (Por ejemplo, round(2.5) ahora retorna “”2”” en lugar de 3.) round(x[, n]) ahora delega en x.__round__([n]) en lugar de retornar siempre un float. Por lo general, retorna un entero cuando se llama con un único argumento y un valor del mismo tipo que x cuando se llama con dos argumentos.

  • Se movió intern() a sys.intern().

  • Se eliminó: apply(). En lugar de apply(f, args) se utiliza f(*args).

  • Se eliminó callable(). En lugar de callable(f) se puede utilizar isinstance(f, collections.Callable). La función operator.isCallable() también se quitó.

  • Se eliminó coerce(). Esta función ya no sirve para nada ahora que las clases clásicas se han quitado.

  • Se eliminó execfile(). En lugar de execfile(fn) utilizar exec(open(fn).read()).

  • Se eliminó el tipo file. Se utiliza open(). Ahora hay varios tipos diferentes de secuencias que se abren y pueden retornar en el módulo io.

  • Se eliminó reduce(). Se puede utilizar functools.reduce() si es realmente necesario; de todas maneras, 99 por ciento del tiempo un bucle for explícito es más legible.

  • Se eliminó reload(). Se utiliza imp.reload().

  • Se eliminó dict.has_key() – se utiliza el operador in en su lugar.

Construcción y cambios a la API de C

Debido a restricciones de tiempo, aquí hay una muy incompleta lista de cambios a la API de C.

  • Se ha eliminado el soporte para varias plataformas, incluyendo pero no limitado a Mac OS 9, BeOS, RISCOS, Irix y Tru64.

  • PEP 3118: Nueva API de búfer.

  • PEP 3121: Inicialización y finalización de módulos de extensión.

  • PEP 3123: Haciendo PyObject_HEAD conforme al estándar C.

  • No más compatibilidad con API C para ejecución restringida.

  • Las API C PyNumber_Coerce(), PyNumber_CoerceEx(), PyMember_Get(), y PyMember_Set() se eliminan.

  • La nueva API C PyImport_ImportModuleNoBlock(), trabaja como PyImport_ImportModule() pero no bloqueará en el bloqueo de importación (en su lugar, retornará un error).

  • Se renombró la conversión booleana de ranura de nivel C y el método: nb_nonzero ahora es nb_bool.

  • Se eliminó METH_OLDARGS y WITH_CYCLE_GC de la API C.

Rendimiento

El resultado neto de las generalizaciones 3.0 es que Python 3.0 ejecuta el punto de referencia pystone alrededor de 10% más lenta que Python 2.5. Lo más probable es que la mayor causa sea la eliminación de mayúsculas y minúsculas especiales para enteros pequeños. Hay margen de mejora, ¡pero sucederá después de que se publique 3.0!

Migración a Python 3.0

Para migrar código Python 2.5 o 2.6 existente a Python 3.0, la mejor estrategia es la siguiente:

  1. (Prerrequisito:) Comenzar con excelente cobertura de test.

  2. Migrar a Python 2.6. Esto no debería representar más trabajo que la migración promedio de Python 2.x a Python 2.(x+1). Asegurarse que todos los test pasen.

  3. (Todavía utilizando 2.6:) Activar el modificador de línea de comandos -3. Esto habilita las advertencias sobre las características que se eliminarán (o cambiarán) en 3.0. Ejecutar el conjunto de pruebas de nuevo y corregir el código sobre el que se recibe advertencias hasta que no queden advertencias y todas las pruebas sigan pasando.

  4. Ejecutar el traductor de origen a origen 2to3 sobre el árbol de código fuente. (Consultar 2to3 - Traducción de código Python 2 a 3 para obtener más información sobre esta herramienta.) Ejecutar el resultado de la traducción en Python 3.0. Corregir manualmente los problemas restantes, solucionando problemas hasta que todos las pruebas vuelvan a pasar.

No se recomienda intentar escribir código fuente que se ejecute sin cambios en Python 2.6 y 3.0; se tendría que usar un estilo de codificación muy contorsionado, por ejemplo, evitando las sentencias print, metaclases y mucho más. Si se mantiene una biblioteca que necesita soportar Python 2.6 y Python 3.0, el mejor enfoque es modificar el paso 3 anterior editando la versión 2.6 del código fuente y ejecutando el traductor 2to3 de nuevo, en lugar de editar la versión 3.0 del código fuente.

Para migrar las extensiones C a Python 3.0, por favor ver Portar módulos de extensión a Python 3.