Qué hay de nuevo en Python 3.5¶

Editores: Elvis Pranskevichus <elvis@magic.io>, Yury Selivanov <yury@magic.io>

Este artículo explica las nuevas características de Python 3.5, en comparación con 3.4. Python 3.5 se publicó el 13 de septiembre de 2015. Consultar el registro de cambios para una lista completa de cambios.

Ver también

PEP 478 - Python 3.5 Calendario de lanzamiento de Python 3.5

Resumen – Aspectos destacados de la versión¶

Nuevas características de sintaxis:

PEP 492, corrutinas con sintaxis async y await.
PEP 465, un nuevo operador de multiplicación de matrices: a @ b.
PEP 448, generalizaciones de desembalaje adicionales.

Nuevos módulos:

typing: PEP 484 – Indicador de tipos.
zipapp: PEP 441 Mejora de soporte de la aplicación Python ZIP.

Nuevas características integradas:

bytes % args, bytearray % args: PEP 461 – Agrega formato % a bytes y bytearray.
Nuevos métodos bytes.hex(), bytearray.hex() y memoryview.hex(). (Contribución de Arnon Yaari en bpo-9951.)
memoryview ahora admite la indexación de tuplas (incluida la multidimensional). (Contribución de Antoine Pitrou en bpo-23632.)
Los generadores tienen un nuevo atributo gi_yieldfrom, el cual retorna el objeto que está siendo iterado por expresiones yield from. (Contribución de Benno Leslie y Yury Selivanov en bpo-24450.)
Ahora se genera una nueva excepción RecursionError cuando se alcanza la profundidad máxima de recursividad. (Contribución de Georg Brandl en bpo-19235.)

Mejoras en la implementación de CPython:

Cuando la configuración regional LC_TYPE es la configuración regional POSIX (configuración regional C), ahora sys.stdin y sys.stdout usan el controlador de errores surrogateescape, en lugar del controlador de errores strict. (Contribución de Victor Stinner en bpo-19977.)
Los archivos .pyo ya no se utilizan y han sido reemplazados por un esquema más flexible que incluye el nivel de optimización explícitamente en el nombre .pyc. (Consultar la PEP 488 descripción general.)
Ahora los módulos integrados y de extensión son inicializados en un proceso de múltiples fases, que es similar a cómo los módulos de Python son cargados. (Consultar PEP 489 descripción general.)

Mejoras significativas en la biblioteca estándar:

collections.OrderedDict ahora está implementado en C, que lo hace de 4 a 100 veces más rápido.
El módulo ssl adquirió soporte para la memoria BIO, que desacopla el manejo del protocolo SSL de la red de E/S.
La nueva función os.scandir() proporciona una forma mejor y significativamente más rápida de recorrido de directorio.
functools.lru_cache() ha sido principalmente reimplementado en C, produciendo un rendimiento mucho mejor.
La nueva función subprocess.run() proporciona una forma simplificada de ejecutar subprocesos.
El módulo traceback se ha mejorado significativamente para mejorar el rendimiento y la conveniencia del desarrollador.

Mejoras de seguridad:

Ahora SSLv3 está deshabilitado en toda la biblioteca estándar. Aún se puede habilitar creando una instancia de ssl.SSLContext manualmente. (Consultar bpo-22638 para más detalles; este cambio fue respaldado a CPython 3.4 y 2.7.)
Ahora el análisis de cookies HTTP es más estricto, con el fin de proteger contra posibles ataques de entrada. (Contribución de Antoine Pitrou en bpo-22796.)

Mejoras de Windows:

Un nuevo instalador para Windows ha reemplazado al antiguo MSI. Consultar Uso de Python en Windows para más información.
Ahora las compilaciones de Windows usan Microsoft Visual C++ 14.0, y los módulos de extensión deberían utilizar lo mismo.

Por favor sigue leyendo para obtener una lista completa de los cambios que se enfrentan los usuarios, incluidas muchas otras mejoras menores, optimizaciones de CPython, deprecaciones y posibles problemas de portabilidad.

Nuevas características¶

PEP 492 - Corrutinas con sintaxis async y await¶

PEP 492 mejora enormemente el soporte para la programación asíncrona en Python al agregar objetos aguardables, funciones corrutina, iteración asincrónica, y gestores asincrónicos de contexto.

Las funciones corrutina se declaran usando la nueva sintaxis async def:

>>> async def coro():
...     return 'spam'

Dentro de una función corrutina, la nueva expresión await puede ser usada para suspender la ejecución de la corrutina hasta que el resultado esté disponible. Cualquier objeto puede ser awaited, siempre que implemente el protocolo awaitable al definir el método __await__().

PEP 492 también agrega la declaración async for para una iteración conveniente sobre iterables asincrónicas.

Un ejemplo de un cliente rudimentario HTTP escrito con la nueva sintaxis:

import asyncio

async def http_get(domain):
    reader, writer = await asyncio.open_connection(domain, 80)

    writer.write(b'\r\n'.join([
        b'GET / HTTP/1.1',
        b'Host: %b' % domain.encode('latin-1'),
        b'Connection: close',
        b'', b''
    ]))

    async for line in reader:
        print('>>>', line)

    writer.close()

loop = asyncio.get_event_loop()
try:
    loop.run_until_complete(http_get('example.com'))
finally:
    loop.close()

De manera similar a la iteración asincrónica, hay una nueva sintaxis para los gestores asincrónicos de contexto. El siguiente script:

import asyncio

async def coro(name, lock):
    print('coro {}: waiting for lock'.format(name))
    async with lock:
        print('coro {}: holding the lock'.format(name))
        await asyncio.sleep(1)
        print('coro {}: releasing the lock'.format(name))

loop = asyncio.get_event_loop()
lock = asyncio.Lock()
coros = asyncio.gather(coro(1, lock), coro(2, lock))
try:
    loop.run_until_complete(coros)
finally:
    loop.close()

saldrá:

coro 2: waiting for lock
coro 2: holding the lock
coro 1: waiting for lock
coro 2: releasing the lock
coro 1: holding the lock
coro 1: releasing the lock

Ten en cuenta que tanto async for como async with solamente pueden ser utilizadas dentro de una función corrutina declarada con async def.

Las funciones corrutina están destinadas para ser ejecutadas dentro de un bucle de eventos compatible, como asyncio loop.

Nota

Distinto en la versión 3.5.2: A partir de CPython 3.5.2, __aiter__ puede retornar directamente iteradores asincrónicos. Retornar un objeto awaitable resultará en PendingDeprecationWarning.

Consultar más detalles en la sección de la documentación Iteradores asíncronos.

Ver también

PEP 492 – Corrutinas con sintaxis async y await: PEP escrito e implementado por Yury Selivanov.

PEP 465 - Un operador infijo dedicado para la multiplicación de matrices¶

PEP 465 agrega el operador infijo @ para la multiplicación de matrices. Actualmente, ningún tipo de Python incorporado implementa el nuevo operador, sin embargo, puede ser implementado al definir __matmul__(), __rmatmul__(), y __imatmul__() para la multiplicación de matrices regulares, reflejadas e in situ. La semántica de estos métodos es similar a la de los métodos que definen otros operadores infijos aritméticos.

La multiplicación de matrices es una operación notablemente común en muchos campos de las matemáticas, la ciencia, la ingeniería, y la adición de @ permite escribir código más limpio:

S = (H @ beta - r).T @ inv(H @ V @ H.T) @ (H @ beta - r)

en lugar de:

S = dot((dot(H, beta) - r).T,
        dot(inv(dot(dot(H, V), H.T)), dot(H, beta) - r))

NumPy 1.10 tiene soporte para el nuevo operador:

>>> import numpy

>>> x = numpy.ones(3)
>>> x
array([ 1., 1., 1.])

>>> m = numpy.eye(3)
>>> m
array([[ 1., 0., 0.],
       [ 0., 1., 0.],
       [ 0., 0., 1.]])

>>> x @ m
array([ 1., 1., 1.])

Ver también

PEP 465 – Un operador infijo dedicado para la multiplicación de matrices: PEP escrito por Nathaniel J. Smith; implementado por Benjamin Peterson.

PEP 448 - Generalizaciones de desembalaje adicionales¶

PEP 448 extiende los usos permitidos del operador de desembalaje iterable * y del operador de desembalaje del diccionario **. Ahora es posible utilizar un número arbitrario de desembalajes en llamadas a funciones:

>>> print(*[1], *[2], 3, *[4, 5])
1 2 3 4 5

>>> def fn(a, b, c, d):
...     print(a, b, c, d)
...

>>> fn(**{'a': 1, 'c': 3}, **{'b': 2, 'd': 4})
1 2 3 4

De manera similar, las pantallas de tupla, lista, conjunto y diccionario permiten desembalajes múltiples (consultar Listas de expresiones and Despliegues de diccionario):

>>> *range(4), 4
(0, 1, 2, 3, 4)

>>> [*range(4), 4]
[0, 1, 2, 3, 4]

>>> {*range(4), 4, *(5, 6, 7)}
{0, 1, 2, 3, 4, 5, 6, 7}

>>> {'x': 1, **{'y': 2}}
{'x': 1, 'y': 2}

Ver también

PEP 448 – Generalizaciones de desembalaje adicionales: PEP escrito por Joshua Landau; implementado por Neil Girdhar, Thomas Wouters y Joshua Landau.

PEP 461 - soporte de formateo porcentual para bytes y bytearray¶

PEP 461 agrega soporte para el operador de interpolación % a bytes y bytearray.

Si bien la interpolación generalmente se considera una operación de cadena de caracteres, hay casos donde la interpolación en bytes o bytearrays tiene sentido y el trabajo necesario para compensar esta funcionalidad faltante resta valor a la legibilidad general del código. Este problema es particularmente importante cuando se trata con protocolos de formato de cable, que a menudo son una mezcla de texto compatible binario y ASCII.

Ejemplos:

>>> b'Hello %b!' % b'World'
b'Hello World!'

>>> b'x=%i y=%f' % (1, 2.5)
b'x=1 y=2.500000'

Unicode no está permitido para %b, pero es aceptado por %a (equivalente a repr(obj).encode('ascii', 'backslashreplace')):

>>> b'Hello %b!' % 'World'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: %b requires bytes, or an object that implements __bytes__, not 'str'

>>> b'price: %a' % '10€'
b"price: '10\\u20ac'"

Ten en cuenta que los tipos de conversión %s y %r, aunque son compatibles, solo deben usarse en bases de código que necesiten compatibilidad con Python 2.

Ver también

PEP 461 – Agrega formato % a bytes y bytearray: PEP escrito por Ethan Furman; implementado por Neil Schemenauer y Ethan Furman.

PEP 484 - Indicador de tipos¶

La sintaxis de anotaciones de funciones ha sido una característica de Python desde la versión 3.0 (PEP 3107), sin embargo, la semántica de anotaciones se ha dejado indefinida.

La experiencia ha mostrado que la mayoría de los usos de las anotaciones de funciones eran para proporcionar el indicador de tipos para los parámetros de función y los valores de retorno. Se hizo evidente que sería beneficioso para los usuarios de Python, si la biblioteca estándar incluyera las definiciones y las herramientas base para las anotaciones de tipo.

PEP 484 introduce un módulo provisional para proporcionar estas definiciones y herramientas estándar, junto con algunas convenciones para situaciones en la que las anotaciones no están disponibles.

Por ejemplo, aquí hay una función simple cuyo argumento y tipo de retorno se declaran en las anotaciones:

def greeting(name: str) -> str:
    return 'Hello ' + name

Si bien estas anotaciones están disponibles en tiempo de ejecución a través del atributo habitual __annotations__, no se realiza ninguna verificación de tipos automática en tiempo de ejecución. En su lugar, se asume que se utilizará un verificador de tipos fuera de línea independiente (p. ej. mypy) para el análisis de código fuente bajo demanda.

El sistema de tipos admite uniones, tipos genéricos y un tipo especial llamado Any el cual es consistente con (esto es asignable desde y hacia) todos los tipos.

Ver también

typing documentación del módulo
PEP 484 – Indicador de tipos
PEP escrito por Guido van Rossum, Jukka Lehtosalo y Łukasz Langa; implementado por Guido van Rossum.
PEP 483 – La teoría del indicador de tipos
PEP escrito por Guido van Rossum

PEP 471 - Función os.scandir() – un iterador de directorio mejor y más rápido¶

PEP 471 agrega una nueva función de iteración de directorio, os.scandir(), a la biblioteca estándar. Adicionalmente, ahora os.walk() se implementa utilizando scandir, lo que lo hace de 3 a 5 veces más rápido en sistemas POSIX y de 7 a 20 veces más rápido en sistemas Windows. Esto se logra en gran medida al reducir enormemente el número de llamadas necesarias de os.stat() para recorrer un árbol de directorios.

También scandir retorna un iterador, en lugar de retornar una lista de nombres de archivos, lo que mejora la eficiencia de la memoria cuando se itera sobre directorios muy grandes.

El siguiente ejemplo presenta un uso simple de os.scandir() para mostrar todos los archivos (excluyendo directorios) en el path dado que no comienzan con '.'. La llamada a entry.is_file() generalmente no hará una llamada adicional al sistema:

for entry in os.scandir(path):
    if not entry.name.startswith('.') and entry.is_file():
        print(entry.name)

Ver también

PEP 471 – Función os.scandir() – un iterador de directorio mejor y más rápido: PEP escrito e implementado por Ben Hoyt con la ayuda de Victor Stinner.

PEP 475: Reintentar las llamadas al sistema que fallan con EINTR¶

Se retorna un código de error errno.EINTR siempre que una llamada al sistema, que está esperando E/S, es interrumpida por una señal. Anteriormente, Python generaría InterruptedError en tales casos. Esto significaba que, al escribir una aplicación en Python, el desarrollador tenía dos opciones:

Ignorar el InterruptedError.
Manejar el InterruptedError y probar reiniciar la llamada interrumpida al sistema en cada sitio de llamada.

La primera opción hace que una aplicación falle intermitentemente. La segunda opción agrega una gran cantidad de código repetitivo que hace que el código sea casi ilegible. Compara:

print("Hello World")

y:

while True:
    try:
        print("Hello World")
        break
    except InterruptedError:
        continue

PEP 475 implementa el reintento automático de las llamadas al sistema en EINTR. Esto elimina la carga de lidiar con EINTR o la excepción InterruptedError en el código de usuario en la mayoría de las situaciones y hace que los programas de Python, incluida la biblioteca estándar, sean más robustos. Ten en cuenta que la llamada al sistema sólo se reintenta si el gestor de señales no lanza una excepción.

A continuación se muestra una lista de funciones que ahora se reintentan cuando son interrumpidas por una señal:

open() y io.open();
funciones del módulo faulthandler;
funciones del módulo os: fchdir(), fchmod(), fchown(), fdatasync(), fstat(), fstatvfs(), fsync(), ftruncate(), mkfifo(), mknod(), open(), posix_fadvise(), posix_fallocate(), pread(), pwrite(), read(), readv(), sendfile(), wait3(), wait4(), wait(), waitid(), waitpid(), write(), writev();
casos especiales: ahora os.close() y os.dup2() ignoran errores EINTR; no se reintenta la llamada al sistema (consultar la PEP para la justificación);
funciones del módulo select: devpoll.poll(), epoll.poll(), kqueue.control(), poll.poll(), select();
métodos de la clase socket: accept(), connect() (excepto para sockets sin bloqueo), recv(), recvfrom(), recvmsg(), send(), sendall(), sendmsg(), sendto();
signal.sigtimedwait() y signal.sigwaitinfo();
time.sleep().

Ver también

PEP 475 – Reintentar las llamadas al sistema que fallan con EINTR: PEP e implementación escrita por Charles-François Natali y Victor Stinner, con la ayuda de Antoine Pitrou (la conexión francesa).

PEP 479: Cambiar el gestor de StopIteration dentro de generadores¶

La interacción de los generadores y StopIteration en las versiones de Python 3.4 y anteriores a veces fue sorprendente y podría ocultar bugs oscuros. Anteriormente, el StopIteration lanzado accidentalmente dentro de una función de generadores se interpretó como el final de la iteración por la construcción de bucle que impulsa el generador.

PEP 479 cambia el comportamiento de los generadores: cuando se lanza una excepción StopIteration dentro de un generador, se reemplaza con una excepción RuntimeError antes de que salga del marco del generador. El objetivo principal de este cambio es facilitar la depuración en la situación en la que una llamada desprotegida a la función next() lanza una excepción StopIteration y hace que la iteración controlada por el generador termine silenciosamente. Esto es particularmente pernicioso en combinación con la construcción yield from.

Este es un cambio incompatible hacia atrás, así que para habilitar el nuevo comportamiento, es necesario importar __future__:

>>> from __future__ import generator_stop

>>> def gen():
...     next(iter([]))
...     yield
...
>>> next(gen())
Traceback (most recent call last):
  File "<stdin>", line 2, in gen
StopIteration

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: generator raised StopIteration

Si no se importa __future__, se lanzará la excepción PendingDeprecationWarning siempre que se lance una excepción StopIteration dentro de un generador.

Ver también

PEP 479 – Cambiar el gestor de StopIteration dentro de generadores: PEP escrito por Chris Angelico y Guido van Rossum. Implementado por Chris Angelico, Yury Selivanov y Nick Coghlan.

PEP 485: Una función para probar la igualdad aproximada¶

PEP 485 agrega las funciones math.isclose() y cmath.isclose() que indican si dos valores son aproximadamente iguales o «cercanos» entre sí. Si dos valores se consideran cercanos o no, se determina conforme con las tolerancias absolutas y relativas dadas. La tolerancia relativa es la diferencia máxima permitida entre los argumentos isclose, en relación con el valor absoluto mayor:

>>> import math
>>> a = 5.0
>>> b = 4.99998
>>> math.isclose(a, b, rel_tol=1e-5)
True
>>> math.isclose(a, b, rel_tol=1e-6)
False

También es posible comparar dos valores usando una tolerancia absoluta, que debe ser un valor no negativo:

>>> import math
>>> a = 5.0
>>> b = 4.99998
>>> math.isclose(a, b, abs_tol=0.00003)
True
>>> math.isclose(a, b, abs_tol=0.00001)
False

Ver también

PEP 485 – Una función para probar la igualdad aproximada: PEP escrito por Christopher Barker; implementado por Chris Barker y Tal Einat.

PEP 486: Hacer que el launcher de Python sea consciente de los entornos virtuales¶

PEP 486 hace que el launcher de Windows (consultar PEP 397) sea consciente de un entorno virtual activo. Cuando se usa el intérprete predeterminado y se establece la variable de entorno VIRTUAL_ENV está configurado, se utilizará el intérprete en el entorno virtual.

Ver también

PEP 486 – Hacer que el launcher de Python sea consciente de los entornos virtuales: PEP escrito e implementado por Paul Moore.

PEP 488: Eliminación de archivos PYO¶

PEP 488 elimina el concepto de archivos .pyo. Esto significa que los archivos .pyc representan tanto bytecode optimizado y sin optimizar. Para evitar la necesidad de regenerar constantemente archivos bytecode, ahora los archivos .pyc tienen una etiqueta opcional opt- en su nombre cuando se optimiza el bytecode. Esto tiene el efecto secundario de que no habrá más conflictos de nombres de archivos de bytecode cuando se ejecuta bajo -O o -OO. Por consiguiente, ahora los archivos bytecode generados a partir de -O y -OO pueden existir simultáneamente. importlib.util.cache_from_source() tiene una API actualizada para ayudar con este cambio.

Ver también

PEP 488 – Eliminación de archivos PYO: PEP escrito e implementado por Brett Cannon.

PEP 489: Inicialización del módulo de extensión multifase¶

PEP 489 actualiza la inicialización del módulo de extensión para aprovechar el mecanismo de carga del módulo de dos pasos introducido por PEP 451 en Python 3.4.

Este cambio acerca la semántica de importación de los módulos de extensión que optan por usar el mecanismo nuevo a la de los módulos fuente y de bytecode de Python, incluida la capacidad de utilizar cualquier identificador válido como un nombre de módulo, en lugar de estar restringido a ASCII.

Ver también

PEP 489 – Inicialización del módulo de extensión multifase: PEP escrito por Petr Viktorin, Stefan Behnel y Nick Coghlan; implementado por Petr Viktorin.

Otros cambios en el lenguaje¶

Algunos cambios más pequeños que se hicieron en el lenguaje central de Python son:

Se agregaron los gestores de error "namereplace". Ahora los gestores de error "backslashreplace" funcionan con decodificación y traducción. (Contribución de Serhiy Storchaka en bpo-19676 y bpo-22286.)
Ahora la opción -b afecta comparaciones de bytes con int. (Contribución de Serhiy Storchaka en bpo-23681.)
Nuevos códecs Kazakh kz1048 y Tajik koi8_t. (Contribución de Serhiy Storchaka en bpo-22682 y bpo-22681.)
Ahora las docstrings de propiedad se pueden escribir. Esto es especialmente útil para las docstrings collections.namedtuple(). (Contribución de Berker Peksag en bpo-24064.)
Ahora se admiten las importaciones circulares que involucran importaciones relativas. (Contribución de Brett Cannon y Antoine Pitrou en bpo-17636.)

Nuevos módulos¶

typing¶

El módulo nuevo provisional typing proporciona definiciones y herramientas estándar para anotaciones de tipos de funciones. Consultar Indicador de tipos para más información.

zipapp¶

El módulo nuevo zipapp (especificado en PEP 441) proporciona una API y una herramienta de línea de comandos para crear aplicaciones Python Zip ejecutables, las cuales se introdujeron en la versión de Python 2.6 en bpo-1739468, pero no se publicitaron bien, ni en ese momento ni desde entonces.

Con el módulo nuevo, empaquetar tu aplicación es tan simple como colocar todos los archivos, incluido un archivo __main__.py en un directorio myapp y ejecutar:

$ python -m zipapp myapp
$ python myapp.pyz

La implementación del módulo ha sido contribución de Paul Moore en bpo-23491.

Ver también

PEP 441 – Mejora de soporte de la aplicación Python ZIP

Módulos mejorados¶

argparse¶

Ahora la clase ArgumentParser permite deshabilitar el uso abreviado de opciones largas al establecer allow_abbrev en False. (Contribución de Jonathan Paugh, Steven Bethard, paul j3 y Daniel Eriksson en bpo-14910.)

asyncio¶

Ya que el módulo asyncio es provisional, todos los cambios que se introdujeron en Python 3.5 también se han actualizado en Python 3.4.x.

Cambios notables en el módulo asyncio desde Python 3.4.0:

Nuevas API de depuración: métodos loop.set_debug() y loop.get_debug(). (Contribución de Victor Stinner.)
Ahora el ciclo de eventos proactor es compatible con SSL. (Contribución de Antoine Pitrou y Victor Stinner en bpo-22560.)
Un nuevo método loop.is_closed() para comprobar si el ciclo de eventos está cerrado. (Contribución de Victor Stinner en bpo-21326.)
Un nuevo método loop.create_task() para crear y programar convenientemente una nueva clase Task para una corrutina. El método create_task también se usa para todas las funciones asyncio que contengan corrutinas en tareas, tales como asyncio.wait(), asyncio.gather(), etc. (Contribución de Victor Stinner.)
Un nuevo método transport.get_write_buffer_limits() para consultar los límites high- (superior) y low- (inferior) del control de flujo. (Contribución de Victor Stinner.)
La función async() está obsoleta en favor de la función ensure_future(). (Contribución de Yury Selivanov.)
Nuevos métodos loop.set_task_factory() y loop.get_task_factory() para personalizar la fábrica de tareas que el método loop.create_task() usa. (Contribución de Yury Selivanov.)
Nuevos métodos de cola Queue.join() y Queue.task_done(). (Contribución de Victor Stinner.)
Se eliminó la clase JoinableQueue, en favor de la clase asyncio.Queue. (Contribución de Victor Stinner.)

Actualizaciones en 3.5.1:

La función ensure_future() y todas las funciones que la utilizan, como el método loop.run_until_complete(), ahora acepta todo tipo de objetos aguardables. (Contribución de Yury Selivanov.)
Nueva función run_coroutine_threadsafe() para enviar corrutinas a bucles de eventos de otros hilos. (Contribución de Vincent Michel.)
Nuevo método Transport.is_closing() para comprobar si el transporte se está cerrando o ya está cerrado. (Contribución de Yury Selivanov.)
Ahora el método loop.create_server() puede aceptar una lista de hosts. (Contribución de Yann Sionneau.)

Actualizaciones en 3.5.2:

Nuevo método loop.create_future() para crear objetos Future. Esto permite implementaciones alternativas de bucles de eventos, como uvloop, para proporcionar una implementación más rápida de asyncio.Future. (Contribución de Yury Selivanov.)
Nuevo método loop.get_exception_handler() para obtener el gestor de excepciones actual. (Contribución de Yury Selivanov.)
Nuevo método StreamReader.readuntil() para leer datos de la secuencia hasta que aparezca una secuencia de separador de bytes. (Contribución de Mark Korenberg.)
Se optimizaron los métodos loop.create_connection() y loop.create_server() para evitar llamar al sistema la función getaddrinfo si la dirección ya está resuelta. (Contribución de A. Jesse Jiryu Davis.)
El método loop.sock_connect(sock, address) ya no requiere address para que se resuelva antes de la llamada. (Contribución de A. Jesse Jiryu Davis.)

bz2¶

Ahora el método BZ2Decompressor.decompress acepta un argumento opcional max_length para limitar el tamaño máximo de datos descomprimidos. (Contribución de Nikolaus Rath en bpo-15955.)

cgi¶

Ahora la clase FieldStorage admite el protocolo context manager. (Contribución de Berker Peksag en bpo-20289.)

cmath¶

Una nueva función isclose() proporciona una forma de probar la igualdad aproximada. (Contribución de Chris Barker y Tal Einat en bpo-24270.)

code¶

Ahora el método InteractiveInterpreter.showtraceback() imprime el rastreo encadenado completo, al igual que el interprete interactivo. (Contribución de Claudiu Popa en bpo-17442.)

collections¶

Ahora la clase OrderedDict está implementada en C, lo que la hace de 4 a 100 veces más rápida. (Contribución de Eric Snow en bpo-16991.)

OrderedDict.items(), OrderedDict.keys(), OrderedDict.values() ahora soportan la iteración reversed(). (Contribución de Serhiy Storchaka en bpo-19505.)

Ahora la clase deque define index(), insert() y copy(), y soporta los operadores + y *. Esto permite que las deques sean reconocidas como MutableSequence y mejora su sustituibilidad por listas. (Contribución de Raymond Hettinger en bpo-23704.)

Ahora las docstrings producidas por namedtuple() se pueden actualizar:

Point = namedtuple('Point', ['x', 'y'])
Point.__doc__ += ': Cartesian coodinate'
Point.x.__doc__ = 'abscissa'
Point.y.__doc__ = 'ordinate'

(Contribución de Berker Peksag en bpo-24064.)

Ahora la clase UserString implementa los métodos __getnewargs__(), __rmod__(), casefold(), format_map(), isprintable() y maketrans() para que coincidan con los métodos correspondientes de str. (Contribución de Joe Jevnik en bpo-22189.)

collections.abc¶

Ahora el método Sequence.index() acepta los argumentos start y stop para que coincidan con los métodos correspondientes de tuple, list, etc. (Contribución de Devin Jeanpierre en bpo-23086.)

Una nueva clase de base abstracta Generator. (Contribución de Stefan Behnel en bpo-24018.)

Nuevas clases de base abstracta Awaitable, Coroutine, AsyncIterator y AsyncIterable. (Contribución de Yury Selivanov en bpo-24184.)

Para versiones anteriores de Python, un backport del nuevo ABC está disponible en un paquete PyPI externo.

compileall¶

Una nueva opción compileall, -j N, permite ejecutar N workers simultáneamente para realizar la compilación de bytecode en paralelo. La función compile_dir() tiene un parámetro workers correspondiente. (Contribución de Claudiu Popa en bpo-16104.)

Otra nueva opción, -r, permite controlar el nivel máximo de recursividad de los subdirectorios. (Contribución de Claudiu Popa en bpo-19628.)

Ahora la opción de línea de comando -q se puede especificar más de una vez, en cuyo caso todas las salidas, incluyendo errores, se suprimirán. Ahora el parámetro quiet correspondiente en compile_dir(), compile_file() y compile_path() puede aceptar un valor entero que indica el nivel de supresión de salida. (Contribución de Thomas Kluyver en bpo-21338.)

concurrent.futures¶

Ahora el método Executor.map() acepta un argumento chunksize para permitir el procesamiento por lotes de tareas para mejorar el desempeño cuando se usa ProcessPoolExecutor(). (Contribución de Dan O’Reilly en bpo-11271.)

Ahora el número de workers en el constructor ThreadPoolExecutor es opcional. El valor predeterminado es 5 veces el número de CPUs. (Contribución de Claudiu Popa en bpo-21527.)

configparser¶

Ahora configparser proporciona una forma de personalizar la conversión de valores al especificar un diccionario de convertidores en el constructor ConfigParser o al definirlos como métodos en las subclases ConfigParser. Los convertidores definidos en una instancia de analizador se heredan por sus proxies de sección.

Ejemplo:

>>> import configparser
>>> conv = {}
>>> conv['list'] = lambda v: [e.strip() for e in v.split() if e.strip()]
>>> cfg = configparser.ConfigParser(converters=conv)
>>> cfg.read_string("""
... [s]
... list = a b c d e f g
... """)
>>> cfg.get('s', 'list')
'a b c d e f g'
>>> cfg.getlist('s', 'list')
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> section = cfg['s']
>>> section.getlist('list')
['a', 'b', 'c', 'd', 'e', 'f', 'g']

(Contribución de Łukasz Langa en bpo-18159.)

contextlib¶

El nuevo context manager redirect_stderr() (similar a redirect_stdout()) facilita que los scripts de utilidad manejen APIs inflexibles que escriben su salida a sys.stderr y no proporcionen ninguna opción para redirigirlo:

>>> import contextlib, io, logging
>>> f = io.StringIO()
>>> with contextlib.redirect_stderr(f):
...     logging.warning('warning')
...
>>> f.getvalue()
'WARNING:root:warning\n'

(Contribución de Berker Peksag en bpo-22389.)

csv¶

Ahora el método writerow() admite iterables arbitrarios, no sólo secuencias. (Contribución de Serhiy Storchaka en bpo-23171.)

curses¶

La nueva función update_lines_cols() actualiza las variables de entorno LINES y COLS. Esto es útil para detectar el cambio de tamaño manual de la pantalla. (Contribución de Arnon Yaari en bpo-4254.)

dbm¶

dumb.open siempre crea una nueva base de datos cuando la bandera tiene el valor "n". (Contribución de Claudiu Popa en bpo-18039.)

difflib¶

Ahora el juego de caracteres de los documentos HTML generado por HtmlDiff.make_file() se puede personalizar usando un nuevo argumento de solo palabras clave charset. El juego de caracteres predeterminado del documento HTML cambió de "ISO-8859-1" a "utf-8". (Contribución de Berker Peksag en bpo-2052.)

Ahora la función diff_bytes() puede comparar listas de bytes de cadenas de caracteres. Esto arregla una regresión de Python 2. (Contribución de Terry J. Reedy y Greg Ward en bpo-17445.)

distutils¶

Ahora los comandos build y build_ext aceptan una opción -j para habilitar la construcción paralela de módulos de extensión. (Contribución de Antoine Pitrou en bpo-5309.)

Ahora el módulo distutils admite la compresión xz y se puede habilitar pasando xztar como un argumento a bdist --format. (Contribución de Serhiy Storchaka en bpo-16314.)

doctest¶

La función DocTestSuite() retorna una clase unittest.TestSuite vacía si module no contiene docstrings, en lugar de lanzar ValueError. (Contribución de Glenn Jones en bpo-15916.)

email¶

Una nueva opción de directiva Policy.mangle_from_ controla si las líneas que empiecen o no con "From " en los cuerpos del correo electrónico tienen el prefijo de un caracter ">" por generadores. El valor predeterminado es True para compat32 y False para todas las demás directivas. (Contribución de Milan Oberkirch en bpo-20098.)

Un nuevo método Message.get_content_disposition() proporciona fácil acceso a un valor canónico para el encabezado Content-Disposition. (Contribución de Abhilash Raj en bpo-21083.)

Una nueva opción de directiva EmailPolicy.utf8 se puede configurar en True para codificar los encabezados de correo electrónico usando el juego de caracteres UTF-8 en lugar de utilizar palabras codificadas. Esto permite formatear Messages de acuerdo a RFC 6532 y usarlos con un servidor SMTP que admita la extensión RFC 6531 SMTPUTF8. (Contribución de R. David Murray en bpo-24211.)

Ahora el constructor mime.text.MIMEText admite una instancia de charset.Charset. (Contribución de Claude Paroz y Berker Peksag en bpo-16324.)

enum¶

La clase invocable Enum tiene un nuevo parámetro start para especificar el número inicial de los valores de enumeración si solo se proporcionan names:

>>> Animal = enum.Enum('Animal', 'cat dog', start=10)
>>> Animal.cat
<Animal.cat: 10>
>>> Animal.dog
<Animal.dog: 11>

(Contribución de Ethan Furman en bpo-21706.)

faulthandler¶

Ahora las funciones enable(), register(), dump_traceback() y dump_traceback_later() aceptan descriptores de archivo además de objetos similares a archivos. (Contribución de Wei Wu en bpo-23566.)

functools¶

Ahora la mayoría de la maquinaria de lru_cache() se implementa en C, lo que la hace significativamente más rápida. (Contribución de Matt Joiner, Alexey Kachayev y Serhiy Storchaka en bpo-14373.)

glob¶

Ahora las funciones iglob() y glob() admiten búsquedas recursivas en subdirectorios usando el patrón "**". (Contribución de Serhiy Storchaka en bpo-13968.)

gzip¶

Ahora el argumento mode del constructor de GzipFile acepta "x" para solicitar la creación exclusiva. (Contribución de Tim Heaney en bpo-19222.)

heapq¶

Ahora la comparación de elementos en merge() se puede personalizar pasando una key function en un nuevo argumento de palabra clave opcional key, y un nuevo argumento de palabra clave opcional reverse se puede usar para revertir la comparación de elementos:

>>> import heapq
>>> a = ['9', '777', '55555']
>>> b = ['88', '6666']
>>> list(heapq.merge(a, b, key=len))
['9', '88', '777', '6666', '55555']
>>> list(heapq.merge(reversed(a), reversed(b), key=len, reverse=True))
['55555', '6666', '777', '88', '9']

(Contribución de Raymond Hettinger en bpo-13742.)

http¶

Una nueva enumeración HTTPStatus que define un conjunto de códigos de estado HTTP, frases de motivo y descripciones largas escritas en inglés. (Contribución de Demian Brecht en bpo-21793.)

http.client¶

Ahora HTTPConnection.getresponse() lanza una excepción RemoteDisconnected cuando una conexión de servidor remoto se cierra inesperadamente. Además, si se lanza una excepción ConnectionError (del cual RemoteDisconnected es una subclase), ahora el socket del cliente se cierra automáticamente y se reconectará en la siguiente solicitud:

import http.client
conn = http.client.HTTPConnection('www.python.org')
for retries in range(3):
    try:
        conn.request('GET', '/')
        resp = conn.getresponse()
    except http.client.RemoteDisconnected:
        pass

(Contribución de Martin Panter en bpo-3566.)

idlelib e IDLE¶

Desde que idlelib implementa el shell y el editor IDLE y no se destina para ser importado por otros programas, obtiene mejoras con cada versión. Consultar Lib/idlelib/NEWS.txt para una lista acumulativa de cambios desde la 3.4.0, así como los cambios realizados en futuras versiones 3.5.x. Este archivo también está disponible en IDLE Help ‣ About IDLE.

imaplib¶

Ahora la clase IMAP4 admite el protocolo context manager. Cuando se utiliza en una declaración with, el comando IMAP4 LOGOUT se llamará automáticamente al final del bloque. (Contribución de Tarek Ziadé y Serhiy Storchaka en bpo-4972.)

Ahora el módulo imaplib admite RFC 5161 (extensión ENABLE) y RFC 6855 (soporte UTF-8) a través del método IMAP4.enable(). Un nuevo atributo IMAP4.utf8_enabled rastrea si el soporte con RFC 6855 está habilitado o no. (Contribución de Milan Oberkirch, R. David Murray y Maciej Szulik en bpo-21800.)

Ahora el módulo imaplib codifica automáticamente nombres de usuario y contraseñas de cadenas de caracteres no ASCII usando UTF-8, como recomiendan las RFCs. (Contribución de Milan Oberkirch en bpo-21800.)

imghdr¶

The what() function now recognizes the OpenEXR format (contributed by Martin Vignali and Claudiu Popa in bpo-20295), and the WebP format (contributed by Fabrice Aneche and Claudiu Popa in bpo-20197.)

importlib¶

La clase util.LazyLoader permite la carga lenta de módulos en aplicaciones donde el tiempo de inicio es importante. (Contribución de Brett Cannon en bpo-17621.)

Ahora el método es abc.InspectLoader.source_to_code() es un método estático. Esto hace más fácil la inicialización de un objeto de módulo con código compilado a partir de una cadena de caracteres ejecutando exec(code, module.__dict__). (Contribución de Brett Cannon en bpo-21156.)

Ahora la nueva función util.module_from_spec() es la forma preferida para crear un nuevo módulo. A diferencia de crear directamente una instancia types.ModuleType, esta nueva función configurará varios atributos controlados por importación basados en el objeto de especificación pasado. (Contribución de Brett Cannon en bpo-20383.)

inspect¶

Ahora las clases Signature y Parameter se pueden seleccionar y manipular. (Contribución de Yury Selivanov en bpo-20726 y bpo-20334.)

Un nuevo método BoundArguments.apply_defaults() proporciona una forma de establecer valores predeterminados para los argumentos faltantes:

>>> def foo(a, b='ham', *args): pass
>>> ba = inspect.signature(foo).bind('spam')
>>> ba.apply_defaults()
>>> ba.arguments
OrderedDict([('a', 'spam'), ('b', 'ham'), ('args', ())])

(Contribución de Yury Selivanov en bpo-24190.)

Un nuevo método de clase Signature.from_callable() facilita la subclasificación de Signature. (Contribución de Yury Selivanov y Eric Snow en bpo-17373.)

Ahora la función signature() acepta un argumento de palabra clave opcional follow_wrapped, el cual, cuando se establece en False, deshabilita el seguimiento automático de enlaces __wrapped__. (Contribución de Yury Selivanov en bpo-20691.)

Se ha agregado un conjunto de nuevas funciones para inspeccionar funciones corrutina y objetos corrutina: iscoroutine(), iscoroutinefunction(), isawaitable(), getcoroutinelocals() y getcoroutinestate(). (Contribución de Yury Selivanov en bpo-24017 y bpo-24400.)

Ahora las funciones stack(), trace(), getouterframes() y getinnerframes() retornan una lista de tuplas con nombre. (Contribución de Daniel Shahaf en bpo-16808.)

io¶

Un nuevo método BufferedIOBase.readinto1(), que usa como mucho una llamada al flujo sin procesar subyacente de los métodos RawIOBase.read() o RawIOBase.readinto(). (Contribución de Nikolaus Rath en bpo-20578.)

ipaddress¶

Ahora las clases IPv4Network y IPv6Network aceptan un argumento de tupla (address, netmask), para construir fácilmente objetos de red a partir de direcciones existentes:

>>> import ipaddress
>>> ipaddress.IPv4Network(('127.0.0.0', 8))
IPv4Network('127.0.0.0/8')
>>> ipaddress.IPv4Network(('127.0.0.0', '255.0.0.0'))
IPv4Network('127.0.0.0/8')

(Contribución de Peter Moody y Antoine Pitrou en bpo-16531.)

Un nuevo atributo reverse_pointer para las clases IPv4Network y IPv6Network retorna el nombre del registro DNS PTR inverso:

>>> import ipaddress
>>> addr = ipaddress.IPv4Address('127.0.0.1')
>>> addr.reverse_pointer
'1.0.0.127.in-addr.arpa'
>>> addr6 = ipaddress.IPv6Address('::1')
>>> addr6.reverse_pointer
'1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa'

(Contribución de Leon Weber en bpo-20480.)

json¶

Ahora la interfaz de la línea de comandos json.tool conserva el orden de los nombres en los objetos JSON pasados en la entrada. La nueva opción --sort-keys se puede usar para ordenar los nombres alfabéticamente. (Contribución de Berker Peksag en bpo-21650.)

Ahora el decodificador JSON lanza JSONDecodeError en lugar de ValueError para proporcionar una mejor información de contexto sobre el error. (Contribución de Serhiy Storchaka en bpo-19361.)

linecache¶

Una nueva función lazycache() se puede usar para capturar información sobre un módulo no basado en archivos para permitir obtener sus líneas más tarde a través de getline(). Esto evita hacer E/S hasta que una línea sea realmente necesaria, sin tener que llevar los módulos globales indefinidamente. (Contribución de Robert Collins en bpo-17911.)

locale¶

Una nueva función delocalize() se puede usar para convertir una cadena de caracteres en una cadena numérica normalizada, teniendo la configuración LC_NUMERIC en cuenta:

>>> import locale
>>> locale.setlocale(locale.LC_NUMERIC, 'de_DE.UTF-8')
'de_DE.UTF-8'
>>> locale.delocalize('1.234,56')
'1234.56'
>>> locale.setlocale(locale.LC_NUMERIC, 'en_US.UTF-8')
'en_US.UTF-8'
>>> locale.delocalize('1,234.56')
'1234.56'

(Contribución de Cédric Krier en bpo-13918.)

logging¶

Ahora todos los métodos del módulo logging (Logger log(), exception(), critical(), debug(), etc.), aceptan instancias de excepción como un argumento exc_info, además de valores booleanos y tuplas de excepción:

>>> import logging
>>> try:
...     1/0
... except ZeroDivisionError as ex:
...     logging.error('exception', exc_info=ex)
ERROR:root:exception

(Contribución de Yury Selivanov en bpo-20537.)

Ahora la clase handlers.HTTPHandler acepta una instancia opcional ssl.SSLContext para establecer la configuración SSL usada en una conexión HTTP. (Contribución de Alex Gaynor en bpo-22788.)

Ahora la clase handlers.QueueListener toma un argumento de palabra clave respect_handler_level, el cual, si se establece en True, pasará mensajes a gestores teniendo en cuenta los gestores de niveles. (Contribución de Vinay Sajip.)

lzma¶

Ahora el método LZMADecompressor.decompress() acepta un argumento opcional max_length para limitar el tamaño máximo de datos descomprimidos. (Contribución de Martin Panter en bpo-15955.)

math¶

Se agregaron dos nuevas contantes en el módulo math: inf y nan. (Contribución de Mark Dickinson en bpo-23185.)

Una nueva función isclose() proporciona una forma de comprobar la igualdad aproximada. (Contribución de Chris Barker y Tal Einat en bpo-24270.)

Se agregó una nueva función gcd(). Ahora la función fractions.gcd() está obsoleta. (Contribución de Mark Dickinson y Serhiy Storchaka en bpo-22486.)

multiprocessing¶

Ahora los objetos sharedctypes.synchronized() admiten el protocolo context manager. (Contribución de Charles-François Natali en bpo-21565.)

operator¶

Ahora los objetos attrgetter(), itemgetter() y methodcaller() admiten pickling. (Contribución de Josh Rosenberg y Serhiy Storchaka en bpo-22955.)

Las nuevas funciones matmul() y imatmul() para realizar multiplicación de matrices. (Contribución de Benjamin Peterson en bpo-21176.)

os¶

Se agregó la nueva función scandir() que retorna un iterador de DirEntry. Si es posible, scandir() extrae los atributos del archivo mientras escanea un directorio, eliminando la necesidad de realizar llamadas posteriores al sistema para determinar el tipo de archivo o los atributos, lo que puede mejorar significativamente el rendimiento. (Contribución de Ben Hoyt con la ayuda de Victor Stinner en bpo-22524.)

En Windows, ahora un nuevo atributo stat_result.st_file_attributes está disponible. Corresponde al miembro dwFileAttributes de la estructura BY_HANDLE_FILE_INFORMATION retornado por GetFileInformationByHandle(). (Contribución de Ben Hoyt en bpo-21719.)

Ahora la función urandom() usa la llamada al sistema getrandom() en Linux 3.17 o versiones más recientes, y getentropy() en OpenBSD 5.6 y versiones más recientes, eliminando la necesidad de utilizar /dev/urandom y evitando fallas debido al posible agotamiento del descriptor de archivo. (Contribución de Victor Stinner en bpo-22181.)

Las nuevas funciones get_blocking() y set_blocking() permiten obtener y establecer un modo de bloqueo del descriptor (O_NONBLOCK.) (Contribución de Victor Stinner en bpo-22054.)

Ahora las funciones truncate() y ftruncate() se admiten en Windows. (Contribución de Steve Dower en bpo-23668.)

Hay una nueva función os.path.commonpath() que retorna la sub-ruta común más larga de cada nombre de ruta pasado. A diferencia de la función os.path.commonprefix(), siempre retorna una ruta válida:

>>> os.path.commonprefix(['/usr/lib', '/usr/local/lib'])
'/usr/l'

>>> os.path.commonpath(['/usr/lib', '/usr/local/lib'])
'/usr'

(Contribución de Rafik Draoui y Serhiy Storchaka en bpo-10395.)

pathlib¶

El nuevo método Path.samefile() se puede usar para verificar si la ruta apunta al mismo archivo que otra ruta, el cual puede ser otro objeto Path o una cadena de caracteres:

>>> import pathlib
>>> p1 = pathlib.Path('/etc/hosts')
>>> p2 = pathlib.Path('/etc/../etc/hosts')
>>> p1.samefile(p2)
True

(Contribución de Vajrasky Kok y Antoine Pitrou en bpo-19775.)

Ahora el método Path.mkdir() acepta un nuevo argumento opcional exist_ok para que coincida con la funcionalidad mkdir -p y os.makedirs(). (Contribución de Berker Peksag en bpo-21539.)

Hay un nuevo método Path.expanduser() para expandir los prefijos ~ y ~user. (Contribución de Serhiy Storchaka y Claudiu Popa en bpo-19776.)

Una nueva clase de método Path.home() se puede usar para obtener una instancia Path que representa el directorio de inicio del usuario. (Contribución de Victor Salgado y Mayank Tripathi en bpo-19777.)

Los nuevos métodos Path.write_text(), Path.read_text(), Path.write_bytes(), Path.read_bytes() para simplificar la lectura/escritura de operaciones en los archivos.

El siguiente fragmento de código creará o reescribirá el archivo existente ~/spam42:

>>> import pathlib
>>> p = pathlib.Path('~/spam42')
>>> p.expanduser().write_text('ham')
3

(Contribución de Christopher Welborn en bpo-20218.)

pickle¶

Ahora los objetos anidados, como los métodos independientes o las clases anidadas, se pueden serializar con pickle usando protocolos pickle anteriores al protocolo de la versión 4. El protocolo de la versión 4 ya admite estos casos. (Contribución de Serhiy Storchaka en bpo-23611.)

poplib¶

Un nuevo comando POP3.utf8() habilita el soporte (correo electrónico internacionalizado) RFC 6856, si un servidor POP lo admite. (Contribución de Milan Oberkirch en bpo-21804.)

re¶

Ahora las referencias y referencias condicionales a grupos con longitud fija se permiten en afirmaciones retrospectivas:

>>> import re
>>> pat = re.compile(r'(a|b).(?<=\1)c')
>>> pat.match('aac')
<_sre.SRE_Match object; span=(0, 3), match='aac'>
>>> pat.match('bbc')
<_sre.SRE_Match object; span=(0, 3), match='bbc'>

(Contribución de Serhiy Storchaka en bpo-9179.)

El número de captura de grupos en expresiones regulares ya no se limita a 100. (Contribución de Serhiy Storchaka en bpo-22437.)

Ahora las funciones sub() y subn() reemplazan grupos que no coinciden con cadenas de caracteres vacías en lugar de lanzar una excepción. (Contribución de Serhiy Storchaka en bpo-1519638.)

Las excepciones re.error tienen nuevos atributos, msg, pattern, pos, lineno y colno, que proporcionan una mejor información de contexto sobre el error:

>>> re.compile("""
...     (?x)
...     .++
... """)
Traceback (most recent call last):
   ...
sre_constants.error: multiple repeat at position 16 (line 3, column 7)

(Contribución de Serhiy Storchaka en bpo-22578.)

readline¶

Una nueva función append_history_file() se puede usar para adjuntar el número especificado de los elementos finales en el historial al archivo dado. (Contribución de Bruno Cauet en bpo-22940.)

selectors¶

La nueva clase DevpollSelector admite sondeos eficientes /dev/poll en Solaris. (Contribución de Giampaolo Rodola” en bpo-18931.)

shutil¶

Ahora la función move() acepta un argumento copy_function, permitiendo, por ejemplo, que se use la función copy() en lugar de la predeterminada copy2() si es necesario ignorar metadatos de archivo al moverlo. (Contribución de Claudiu Popa en bpo-19840.)

Ahora la función make_archive() admite el formato xztar. (Contribución de Serhiy Storchaka en bpo-5411.)

signal¶

En Windows, ahora la función set_wakeup_fd() también admite identificadores de socket. (Contribución de Victor Stinner en bpo-22018.)

Varias constantes SIG* en el módulo signal se convirtieron en Enums. Esto permite que los nombres significativos se impriman durante la depuración en lugar de «números mágicos» enteros. (Contribución de Giampaolo Rodola” en bpo-21076.)

smtpd¶

Ahora las clases SMTPServer y SMTPChannel aceptan un argumento de palabra clave decode_data para determinar si la porción DATA de la transacción SMTP se decodifica usando el códec "utf-8" o en su lugar se proporciona al método SMTPServer.process_message() como un byte de cadena de caracteres. El valor predeterminado es True por razones de compatibilidad con versiones anteriores, pero se cambiará a False en Python 3.6. Si decode_data se establece en False, el método process_message se debe preparar para aceptar argumentos de palabra clave. (Contribución de Maciej Szulik en bpo-19662.)

Ahora la clase SMTPServer anuncia la extensión 8BITMIME (RFC 6152) si decode_data se establece como True. Si el cliente especifica BODY=8BITMIME en el comando MAIL, se pasa al método SMTPServer.process_message() a través de la palabra clave mail_options. (Contribución de Milan Oberkirch y R. David Murray en bpo-21795.)

Ahora la clase SMTPServer también admite la extensión SMTPUTF8 (RFC 6531: correo electrónico internacionalizado). Si el cliente especificó SMTPUTF8 BODY=8BITMIME en el comando MAIL, se pasan al método SMTPServer.process_message() a través de la palabra clave mail_options. Es responsabilidad del método process_message manejar correctamente los datos SMTPUTF8. (Contribución de Milan Oberkirch en bpo-21725.)

Ahora es posible proporcionar, directamente o mediante resolución de nombres, direcciones IPv6 en el constructor SMTPServer, y hacer que se conecte correctamente. (Contribución de Milan Oberkirch en bpo-14758.)

smtplib¶

Un nuevo método SMTP.auth() proporciona una forma conveniente de implementar mecanismos de autenticación personalizados. (Contribución de Milan Oberkirch en bpo-15014.)

Ahora el método SMTP.set_debuglevel() acepta un nivel de depuración adicional (2), el cual habilita las marcas de tiempo en los mensajes de depuración. (Contribución de Gavin Chappell y Maciej Szulik en bpo-16914.)

Ahora los métodos SMTP.sendmail() y SMTP.send_message() admiten RFC 6531 (SMTPUTF8). (Contribución de Milan Oberkirch y R. David Murray en bpo-22027.)

sndhdr¶

Ahora las funciones what() y whathdr() retornan una namedtuple(). (Contribución de Claudiu Popa en bpo-18615.)

socket¶

Ahora las funciones con tiempo de espera usan un reloj monótono en lugar de un reloj del sistema. (Contribución de Victor Stinner en bpo-22043.)

Un nuevo método socket.sendfile() permite enviar un archivo a través de un socket usando la función de alto rendimiento os.sendfile() en UNIX, lo que hace que las cargas sean de 2 a 3 veces más rápido que cuando se usa el método simple socket.send(). (Contribución de Giampaolo Rodola” en bpo-17552.)

El método socket.sendall() ya no reinicia el tiempo de espera del socket cada vez que se reciben o se envían bytes. Ahora el tiempo de espera del socket es la duración total máxima para enviar todos los datos. (Contribución de Victor Stinner en bpo-23853.)

Ahora el argumento backlog del método socket.listen() es opcional. De forma predeterminada, se establece en SOMAXCONN o en 128, lo que sea menor. (Contribución de Charles-François Natali en bpo-21455.)

ssl¶

Soporte de memoria BIO¶

(Contribución de Geert Jansen en bpo-21965.)

Se ha agregado la nueva clase SSLObject para proporcionar soporte del protocolo SSL para los casos en que las capacidades de E/S de red de SSLSocket no son necesarias o no son óptimas. SSLObject representa una instancia del protocolo SSL pero no implementa ningún método de E/S de red y, en su lugar, proporciona una interfaz de búfer de memoria. La nueva clase MemoryBIO se puede usar para pasar datos entre Python y una instancia del protocolo SSL.

El soporte de la memoria BIO SSL está destinado principalmente para ser usado en frameworks que implementan E/S asíncronas para las cuales el modelo de preparación («select/poll») de SSLSocket es ineficiente.

Un nuevo método SSLContext.wrap_bio() se puede usar para crear una nueva instancia SSLObject.

Soporte de negociación de protocolo de capa de aplicación¶

(Contribución de Benjamin Peterson en bpo-20188.)

Donde está presente el soporte de OpenSSL, ahora el módulo ssl implementa la extensión TLS Application-Layer Protocol Negotiation como se describe en RFC 7301.

El nuevo método SSLContext.set_alpn_protocols() se puede usar para especificar qué protocolos deben anunciar un socket durante el protocolo de enlace TLS.

El nuevo método SSLSocket.selected_alpn_protocol() retorna el protocolo que se seleccionó durante el protocolo de enlace TLS. La bandera HAS_ALPN indica si el soporte ALPN está presente.

Otros cambios¶

Hay un nuevo método SSLSocket.version() para consultar la versión actual del protocolo en uso. (Contribución de Antoine Pitrou en bpo-20421.)

Ahora la clase SSLSocket implementa un método SSLSocket.sendfile(). (Contribución de Giampaolo Rodola” en bpo-17552.)

Ahora el método SSLSocket.send() lanza la excepción ssl.SSLWantReadError o ssl.SSLWantWriteError en un socket sin bloqueo si la operación se bloquearía. Anteriormente, retornaría 0. (Contribución de Nikolaus Rath en bpo-20951.)

Ahora la función cert_time_to_seconds() interpreta la hora de entrada como UTC y no como hora local, por RFC 5280. Además, el valor de retorno siempre es un int. (Contribución de Akira Li en bpo-19940.)

Los nuevos métodos SSLObject.shared_ciphers() y SSLSocket.shared_ciphers() retornan la lista de cifrados enviados por el cliente durante el protocolo de enlace. (Contribución de Benjamin Peterson en bpo-23186.)

Los métodos SSLSocket.do_handshake(), SSLSocket.read(), SSLSocket.shutdown() y SSLSocket.write() de la clase SSLSocket ya no reinician el tiempo de espera del socket cada vez que se reciben o se envían bytes. Ahora el tiempo de espera del socket es la duración total máxima del método. (Contribución de Victor Stinner en bpo-23853.)

Ahora la función match_hostname() admite la coincidencia de direcciones IP. (Contribución de Antoine Pitrou en bpo-23239.)

sqlite3¶

Ahora la clase Row admite totalmente el protocolo de secuencia, en particular la iteración reversed() y la indexación segmentada. (Contribución de Claudiu Popa en bpo-10203; de Lucas Sinclair, Jessica McKellar, y Serhiy Storchaka en bpo-13583.)

subprocess¶

Se agregó la nueva función run(). Ejecuta el comando especificado y retorna un objeto CompletedProcess, el cual describe un proceso terminado. La nueva API es más consistente y es el enfoque recomendado para invocar subprocesos en código Python que no necesita mantener la compatibilidad con versiones anteriores de Python. (Contribución de Thomas Kluyver en bpo-23342.)

Ejemplos:

>>> subprocess.run(["ls", "-l"])  # doesn't capture output
CompletedProcess(args=['ls', '-l'], returncode=0)

>>> subprocess.run("exit 1", shell=True, check=True)
Traceback (most recent call last):
  ...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1

>>> subprocess.run(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE)
CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,
stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\n')

sys¶

Una nueva función set_coroutine_wrapper() permite configurar un enlace global que será llamado siempre que un objeto corrutina sea creado por una función async def. Una función correspondiente get_coroutine_wrapper() se puede usar para obtener un contenedor configurado actualmente. Ambas funciones son provisionales y se destinan solo para propósitos de depuración. (Contribución de Yury Selivanov en bpo-24017.)

Una nueva función is_finalizing() se puede usar para verificar si el intérprete de Python se está apagando. (Contribución de Antoine Pitrou en bpo-22696.)

sysconfig¶

Ahora el nombre del directorio de los scripts del usuario en Windows incluye los dos primeros componentes de la versión de Python. (Contribución de Paul Moore en bpo-23437.)

tarfile¶

Ahora el argumento mode de la función open() acepta "x" para solicitar una creación exclusiva. (Contribución de Berker Peksag en bpo-21717.)

Ahora los métodos TarFile.extractall() y TarFile.extract() toman un argumento de palabra clave numeric_owner. Si se establece como True, los archivos y directorios extraídos serán propiedad de los números uid y gid del archivo tar. Si se establece como False (el valor predeterminado y el comportamiento en versiones anteriores a la 3.5), serán propiedad del usuario y el grupo nombrados en el archivo tar. (Contribución de Michael Vogt y Eric Smith en bpo-23193.)

Ahora TarFile.list() acepta un argumento de palabra clave opcional members que se puede establecer en un subconjunto de la lista retornada por TarFile.getmembers(). (Contribución de Serhiy Storchaka en bpo-21549.)

threading¶

Ahora los métodos Lock.acquire() y RLock.acquire() usan un reloj monótono para la administración del tiempo de espera. (Contribución de Victor Stinner en bpo-22043.)

time¶

Ahora la función monotonic() siempre está disponible. (Contribución de Victor Stinner en bpo-22043.)

timeit¶

Una nueva opción de línea de comando -u o --unit=U se puede usar para especificar la unidad de tiempo para la salida del temporizador. Las opciones que se admiten son usec, msec o sec. (Contribución de Julian Gindi en bpo-18983.)

La función timeit() tiene un nuevo parámetro globals para especificar el espacio de nombres donde el código se ejecutará. (Contribución de Ben Roberts en bpo-2527.)

tkinter¶

El módulo tkinter._fix que se usaba para configurar el entorno Tcl/Tk en Windows se reemplazó por una función privada en el módulo _tkinter que no hace cambios permanentes en las variables de entorno. (Contribución de Zachary Ware en bpo-20035.)

traceback¶

Las nuevas funciones walk_stack() y walk_tb() atraviesan convenientemente objetos de marco y rastreo. (Contribución de Robert Collins en bpo-17911.)

Nuevas clases ligeras: TracebackException, StackSummary y FrameSummary. (Contribución de Robert Collins en bpo-17911.)

Ahora las funciones print_tb() y print_stack() admiten valores negativos para el argumento limit. (Contribución de Dmitry Kazakov en bpo-22619.)

types¶

Una nueva función coroutine() para transformar un iterador generador y objetos generator-like en aguardables. (Contribución de Yury Selivanov en bpo-24017.)

Un nuevo tipo llamado CoroutineType, el cual se usa para objetos coroutine creados por funciones async def. (Contribución de Yury Selivanov en bpo-24400.)

unicodedata¶

The unicodedata module now uses data from Unicode 8.0.0.

unittest¶

Ahora el método TestLoader.loadTestsFromModule() acepta un solo argumento de palabra clave pattern que se pasa a load_tests como el tercer argumento. Ahora los paquetes encontrados se verifican en busca de load_tests independientemente de si su ruta coincide con pattern, porque es imposible que el nombre de un paquete coincida con el modelo predeterminado. (Contribución de Robert Collins y Barry A. Warsaw en bpo-16662.)

Ahora los errores de descubrimiento de unittest se exponen en el atributo TestLoader.errors de la instancia TestLoader. (Contribución de Robert Collins en bpo-19746.)

Una nueva opción de línea de comando --locals muestra variables locales en rastreo. (Contribución de Robert Collins en bpo-22936.)

unittest.mock¶

La clase Mock tiene las siguientes mejoras:

El constructor de la clase tiene un nuevo parámetro unsafe, que hace que los objetos simulados lancen AttributeError en los nombres de atributo que comienzan con "assert". (Contribución de Kushal Das en bpo-21238.)
Un nuevo método Mock.assert_not_called() para verificar si se llamó el objeto simulado. (Contribución de Kushal Das en bpo-21262.)

Ahora la clase MagicMock admite los operadores __truediv__(), __divmod__() y __matmul__(). (Contribución de Johannes Baiter en bpo-20968 y de Håkan Lövdahl en bpo-23581 y bpo-23568.)

Ya no es necesario pasar explícitamente create=True a la función patch() cuando se parchean los nombres incorporados. (Contribución de Kushal Das en bpo-17660.)

urllib¶

Una nueva clase request.HTTPPasswordMgrWithPriorAuth permite que se administren las credenciales de autenticación básica HTTP para eliminar el manejo innecesario de respuestas 401 o enviar credenciales incondicionalmente en la primera solicitud para comunicarse con los servidores que retornen una respuesta 404 en lugar de un 401 si el encabezado Authorization no se envía. (Contribución de Matej Cepl en bpo-19494 y de Akshit Khurana en bpo-7159.)

Un nuevo argumento quote_via para la función parse.urlencode() proporciona una forma de controlar la codificación de las partes de la consulta si es necesario. (Contribución de Samwyse y Arnon Yaari en bpo-13866.)

La función request.urlopen() acepta un objeto ssl.SSLContext como un argumento context, el cual se usará para la conexión HTTPS. (Contribución de Alex Gaynor en bpo-22366.)

Se actualizó parse.urljoin() para usar la semántica RFC 3986 para la resolución de URL relativas, en lugar de RFC 1808 y RFC 2396. (Contribución de Demian Brecht y Senthil Kumaran en bpo-22118.)

wsgiref¶

Ahora el argumento headers del constructor de la clase headers.Headers es opcional. (Contribución de Pablo Torres Navarrete y SilentGhost en bpo-5800.)

xmlrpc¶

Ahora la clase client.ServerProxy admite el protocolo context manager. (Contribución de Claudiu Popa en bpo-20627.)

Ahora el constructor de client.ServerProxy acepta una instancia opcional ssl.SSLContext. (Contribución de Alex Gaynor en bpo-22960.)

xml.sax¶

Ahora los analizadores SAX admiten un flujo de caracteres del objeto xmlreader.InputSource. (Contribución de Serhiy Storchaka en bpo-2175.)

Ahora parseString() acepta una instancia str. (Contribución de Serhiy Storchaka en bpo-10590.)

zipfile¶

Ahora la salida ZIP se puede escribir en flujos inescrutables. (Contribución de Serhiy Storchaka en bpo-23252.)

Ahora el argumento mode del método ZipFile.open() acepta "x" para solicitar una creación exclusiva. (Contribución de Serhiy Storchaka en bpo-21717.)

Otros cambios a nivel de módulo¶

Ahora muchas funciones en los módulos mmap, ossaudiodev, socket, ssl y codecs aceptan objetos de tipo bytes que se pueden escribir. (Contribución de Serhiy Storchaka en bpo-23001.)

Optimizaciones¶

La función os.walk() se aceleró de 3 a 5 veces en los sistemas POSIX y de 7 a 20 veces en Windows. Esto se hizo usando la nueva función os.scandir(), el cual expone la información del archivo de las llamadas al sistema readdir o FindFirstFile/FindNextFile. (Contribución de Ben Hoyt con ayuda de Victor Stinner en bpo-23605.)

La construcción de bytes(int) (llenado con cero bytes) es más rápida y usa menos memoria para objetos grandes. Se usa calloc() en lugar de malloc() para asignar memoria para estos objetos. (Contribución de Victor Stinner en bpo-21233.)

Algunas operaciones en ipaddress IPv4Network y IPv6Network se aceleraron masivamente, tal como subnets(), supernet(), summarize_address_range(), collapse_addresses(). La velocidad puede variar de 3 a 15 veces. (Contribución de Antoine Pitrou, Michel Albert y Markus en bpo-21486, bpo-21487, bpo-20826, bpo-23266.)

Se optimizó pickling de objetos ipaddress para producir una salida significativamente menor. (Contribución de Serhiy Storchaka en bpo-23133.)

Ahora muchas operaciones en io.BytesIO son de 50% a 100% más rápidas. (Contribución de Serhiy Storchaka en bpo-15381 y de David Wilson en bpo-22003.)

Ahora la función marshal.dumps() es más rápida: 65–85% en las versiones 3 y 4, 20–25% en las versiones 0 a 2 con datos típicos, y hasta 5 veces en el mejor de los casos. (Contribución de Serhiy Storchaka en bpo-20416 y bpo-23344.)

Ahora el codificador UTF-32 es de 3 a 7 veces más rápido. (Contribución de Serhiy Storchaka en bpo-15027.)

Ahora las expresiones regulares se analizan hasta un 10% más rápido. (Contribución de Serhiy Storchaka en bpo-19380.)

Se optimizó la función json.dumps() para ejecutarse con ensure_ascii=False tan rápido como con ensure_ascii=True. (Contribución de Naoki Inada en bpo-23206.)

Las funciones PyObject_IsInstance() y PyObject_IsSubclass() se aceleraron en el caso común de que el segundo argumento tenga type como su metaclase. (Contribución de Georg Brandl en bpo-22540.)

Se mejoró ligeramente el almacenamiento en caché del método, lo que arrojó una mejora del rendimiento de hasta un 5% en algunos puntos de referencia. (Contribución de Antoine Pitrou en bpo-22847.)

Ahora los objetos del módulo random usan un 50% menos de memoria en compilaciones de 64 bits. (Contribución de Serhiy Storchaka en bpo-23488.)

Las llamadas getter de property() son hasta un 25% más rápidas. (Contribución de Joe Jevnik en bpo-23910.)

Ahora la instanciación de fractions.Fraction es hasta un 30% más rápida. (Contribución de Stefan Behnel en bpo-22464.)

Ahora los métodos de cadena de caracteres find(), rfind(), split(), partition() y el operador in son significativamente más rápidos para buscar subcadenas de 1 carácter. (Contribución de Serhiy Storchaka en bpo-23573.)

Cambios en la compilación y la API de C¶

Se agregaron las nuevas funciones calloc:

(Contribución de Victor Stinner en bpo-21233.)

Nuevas funciones auxiliares de codificación/decodificación:

Py_DecodeLocale() (reemplazó _Py_char2wchar()),
Py_EncodeLocale() (reemplazó _Py_wchar2char()).

(Contribución de Victor Stinner en bpo-18395.)

Una nueva función PyCodec_NameReplaceErrors() para reemplazar el error de codificación unicode con \N{...} escapes. (Contribución de Serhiy Storchaka en bpo-19676.)

Una nueva función PyErr_FormatV() similar a PyErr_Format(), pero acepta un argumento va_list. (Contribución de Antoine Pitrou en bpo-18711.)

Una nueva excepción PyExc_RecursionError. (Contribución de Georg Brandl en bpo-19235.)

Se introdujeron las nuevas funciones PyModule_FromDefAndSpec(), PyModule_FromDefAndSpec2() y PyModule_ExecDef() por PEP 489 – inicialización del módulo de extensión multifase. (Contribución de Petr Viktorin en bpo-24268.)

Nuevas funciones PyNumber_MatrixMultiply() y PyNumber_InPlaceMatrixMultiply() para realizar la multiplicación de matrices. (Contribución de Benjamin Peterson en bpo-21176. Consultar también PEP 465 para más detalles.)

Ahora el espacio PyTypeObject.tp_finalize es parte de la ABI estable.

Ahora las compilaciones de Windows requieren Microsoft Visual C++ 14.0, que está disponible como parte de Visual Studio 2015.

Ahora los módulos de extensión incluyen una etiqueta de información de la plataforma en su nombre de archivo en algunas plataformas (la etiqueta es opcional y CPython importará las extensiones sin ella, aunque si la etiqueta está presente y no coincide, no se cargará la extensión):

En Linux, los nombres de archivo del módulo de extensión termina con .cpython-<major><minor>m-<architecture>-<os>.pyd:
- <major> es el número principal de la versión de Python; para Python 3.5 este es 3.
- <minor> es el número menor de la versión de Python; para Python 3.5 este es 5.
- <architecture> es la arquitectura de hardware para la que se construyó el módulo de extensión. Es más común i386 para plataformas Intel de 32 bits o x86_64 para plataformas Intel (y AMD) de 64 bits.
- <os> siempre es linux-gnu, excepto para las extensiones que se crearon para comunicarse con la ABI de 32 bits en plataformas de 64 bits, en cuyo caso es linux-gnu32 (y <architecture> será x86_64).
En Windows, los nombres de archivo del módulo de extensión termina con <debug>.cp<major><minor>-<platform>.pyd:
- <major> es el número principal de la versión de Python; para Python 3.5 este es 3.
- <minor> es el número menor de la versión de Python; para Python 3.5 este es 5.
- <platform> es la plataforma para la que se construyó el módulo de extensión, ya sea win32 para Win32, win_amd64 para Win64, win_ia64 para Windows Itanium 64 y win_arm para Windows con ARM.
- Si está integrado en el modo de depuración, <debug> será _d, de lo contrario estará en blanco.
En plataformas OS X, ahora los nombres de archivo del módulo de extensión terminan con -darwin.so.
En todas las demás plataformas, los nombres de archivo del módulo de extensión son los mismos que en Python 3.4.

Obsoleto¶

Nuevas palabras clave¶

No se recomienda usarse async y await como nombres de variable, clase, función o módulo. Se introdujo por PEP 492 en Python 3.5, se convertirán en palabras clave adecuadas en Python 3.7.

Comportamiento obsoleto de Python¶

Al lanzar la excepción StopIteration dentro de un generador ahora se lanzará un PendingDeprecationWarning silencioso, el cual se convertirá en una advertencia de deprecación no silenciosa en Python 3.6 y activará un RuntimeError en Python 3.7. Consultar PEP 479: Cambiar el gestor de StopIteration dentro de generadores para más detalles.

Sistemas operativos no compatibles¶

Windows XP ya no es compatible con Microsoft, por lo tanto, según PEP 11, CPython 3.5 oficialmente ya no es compatible con este sistema operativo.

Módulos, funciones y métodos obsoletos de Python¶

Ahora el módulo formatter se ha graduado a su deprecación completa y aún está programada para su eliminación en Python 3.6.

La función asyncio.async() es obsoleta en favor de ensure_future().

En el pasado, el módulo smtpd siempre ha decodificado la porción DATA de los mensajes de correo electrónico usando el códec utf-8. Ahora esto se puede controlar con la nueva palabra clave decode_data en SMTPServer. El valor predeterminado es True, pero éste está obsoleto. Especificar la palabra clave decode_data con un valor apropiado para evitar la advertencia de deprecación.

Está obsoleto asignar valores directamente en key, value y coded_value en los objetos de http.cookies.Morsel. Usar en su lugar el método set(). Además, el parámetro no documentado LegalChars de set() está obsoleto y ahora se ignora.

Pasar una cadena de caracteres de formato como argumento de palabra clave format_string al método format() de la clase string.Formatter se ha quedado obsoleto. (Contribución de Serhiy Storchaka en bpo-23671.)

Ahora las funciones platform.dist() y platform.linux_distribution() están obsoletas. Las distribuciones de Linux usan demasiadas formas diferentes de describirse a sí mismas, así que la funcionalidad se deja a un paquete. (Contribución de Vajrasky Kok y Berker Peksag en bpo-1322.)

Los métodos from_function y from_builtin previamente no documentados de inspect.Signature están obsoletos. Utilizar en su lugar el nuevo método Signature.from_callable(). (Contribución de Yury Selivanov en bpo-24248.)

La función inspect.getargspec() está obsoleta y programada para ser eliminada en Python 3.6. (Consultar bpo-20438 para más detalles.)

Las funciones inspect getfullargspec(), getcallargs() y formatargspec() están obsoletas en favor de la API inspect.signature(). (Contribución de Yury Selivanov en bpo-20438.)

Las funciones getargvalues() y formatargvalues() se marcaron inadvertidamente como obsoletas con el lanzamiento de Python 3.5.0.

Ahora el uso de la bandera re.LOCALE con patrones str o re.ASCII está obsoleto. (Contribución de Serhiy Storchaka en bpo-22407.)

El uso de secuencias especiales no reconocidas que consisten en '\' y una letra ASCII en patrones de expresión regular y patrones de reemplazo ahora lanza una advertencia de deprecación y estará prohibido en Python 3.6. (Contribución de Serhiy Storchaka en bpo-23622.)

Ahora el argumento predeterminado no documentado y no oficial use_load_tests del método unittest.TestLoader.loadTestsFromModule() está obsoleto e ignorado. (Contribución de Robert Collins y Barry A. Warsaw en bpo-16662.)

Eliminado¶

APIs y características eliminadas¶

Se eliminaron las siguientes APIs y características obsoletas y anteriormente obsoletas:

Se eliminó el atributo __version__ del paquete de correo electrónico. No se envió el código de correo electrónico por separado de stdlib durante mucho tiempo, y la cadena de caracteres __version__ no se actualizó en las últimas versiones.
La clase interna Netrc en el módulo ftplib quedó obsoleta en la versión 3.4 y ahora se eliminó. (Contribución de Matt Chaput en bpo-6623.)
Se eliminó el concepto de los archivos .pyo.
La clase JoinableQueue en el módulo provisional asyncio quedó obsoleto en la versión 3.4.4 y ahora se eliminó. (Contribución de A. Jesse Jiryu Davis en bpo-23464.)

Portando a Python 3.5¶

Esta sección enumera cambios descritos anteriormente y otras correcciones de errores que pueden requerir cambios en tu código.

Cambios en el comportamiento de Python¶

Debido a un descuido, erróneamente en anteriores versiones de Python aceptaron la siguiente sintaxis:
```
f(1 for x in [1], *args)
f(1 for x in [1], **kwargs)
```
Ahora Python 3.5 lanza correctamente un SyntaxError, ya que las expresiones generadoras deben ponerse entre paréntesis si no son el único argumento de una función.

Cambios en la API de Python¶

PEP 475: Ahora se reintentan las llamadas al sistema cuando se interrumpen por una señal en lugar de lanzar InterruptedError si el gestor de señales de Python no lanza una excepción.
Antes de Python 3.5, se consideraba falso un objeto datetime.time si representaba la medianoche en UTC. Este comportamiento se consideraba oscuro y propenso a errores y se eliminó en Python 3.5. Consultar bpo-13936 para más detalles.
Ahora el método ssl.SSLSocket.send() lanza ya sea ssl.SSLWantReadError o ssl.SSLWantWriteError en un socket sin bloqueo si la operación se bloqueara. Anteriormente, retornaría 0. (Contribución de Nikolaus Rath en bpo-20951.)
Ahora el atributo __name__ de los generadores se establece desde el nombre de la función en lugar de establecerse desde el nombre del código. Usar gen.gi_code.co_name para recuperar el nombre del código. También los generadores tienen un nuevo atributo __qualname__, el nombre calificado, el cual se utiliza ahora para la representación de un generador (repr(gen)). (Contribución de Victor Stinner en bpo-21205.)
Se eliminaron el argumento y modo obsoleto «strict» de HTMLParser, HTMLParser.error() y la excepción HTMLParserError. (Contribución de Ezio Melotti en bpo-15114.) Ahora el argumento convert_charrefs de HTMLParser es True como valor predeterminado. (Contribución de Berker Peksag en bpo-21047.)
Aunque no es parte formalmente de la API, vale la pena señalar con fines de portabilidad (es decir: pruebas de reparación) que ahora los mensajes de error que anteriormente tenían el formato «“sometype” no es compatible con el protocolo búfer» son del formato «se requiere bytes-like object, no “sometype”». (Contribución de Ezio Melotti en bpo-16518.)
Si el directorio actual se establece en un directorio que ya no existe entonces ya no se lanzará FileNotFoundError y en su lugar find_spec() retornará None sin almacenamiento en caché None en sys.path_importer_cache, el cual es diferente al caso típico (bpo-22834).
El código de estado HTTP y los mensajes de http.client y http.server se refactorizaron en una enumeración HTTPStatus. Los valores en http.client y http.server permanecen disponibles para compatibilidad con versiones anteriores. (Contribución de Demian Brecht en bpo-21793.)
Cuando un cargador de importación define importlib.machinery.Loader.exec_module(), ahora se espera que también defina create_module() (ahora lanza un DeprecationWarning, será un error en Python 3.6). Si el cargador hereda de importlib.abc.Loader entonces no hay nada que hacer, de lo contrario simplemente defina create_module() para retornar None. (Contribución de Brett Cannon en bpo-23014.)
La función re.split() siempre ignoraba las coincidencias de patrones vacías, así que el patrón "x*" funcionaba igual que "x+" y el patrón "\b" nunca funcionó. Ahora re.split() lanza una advertencia si el patrón puede coincidir con una cadena de caracteres vacía. Para compatibilidad, usar patrones que nunca coincidan con una cadena vacía (p. ej. "x+" en lugar de "x*"). Ahora los patrones que solo pueden coincidir con una cadena vacía (como "\b") lanzan un error. (Contribución de Serhiy Storchaka en bpo-22818.)
La interfaz similar a diccionarios http.cookies.Morsel se ha hecho autoconsistente: ahora la comparación de morsel toma en cuenta key y value, ahora copy() da como resultado en una instancia Morsel en lugar de un dict, y ahora update() lanzará una excepción si alguna de las claves del diccionario de actualización no es válida. Además, el parámetro no documentado LegalChars de set() está obsoleto y ahora se ignora. (Contribución de Demian Brecht en bpo-2211.)
PEP 488 has removed .pyo files from Python and introduced the optional opt- tag in .pyc file names. The importlib.util.cache_from_source() has gained an optimization parameter to help control the opt- tag. Because of this, the debug_override parameter of the function is now deprecated. .pyo files are also no longer supported as a file argument to the Python interpreter and thus serve no purpose when distributed on their own (i.e. sourceless code distribution). Due to the fact that the magic number for bytecode has changed in Python 3.5, all old .pyo files from previous versions of Python are invalid regardless of this PEP.
Ahora el módulo socket exporta la constante CAN_RAW_FD_FRAMES en Linux 3.6 y versiones superiores.
Ahora la función ssl.cert_time_to_seconds() interpreta la hora de entrada como UTC y no como hora local, por RFC 5280. Además, el valor de retorno siempre es un int. (Contribución de Akira Li en bpo-19940.)
Ahora la herramienta pygettext.py usa el formato estándar +NNNN para zonas horarias en el encabezado POT-Creation-Date.
Ahora el módulo smtplib usa sys.stderr en lugar de la variable anterior de nivel de módulo stderr para la salida de depuración. Si tu programa (de prueba) depende de parchear la variable de nivel de mundo para capturar la salida de depuración, necesitarás actualizarlo para capturar sys.stderr en su lugar.
Los métodos str.startswith() y str.endswith() ya no retornan True cuando encuentran la cadena de caracteres vacía y los índices están completamente fuera de rango. (Contribución de Serhiy Storchaka en bpo-24284.)
Ahora la función inspect.getdoc() retorna cadenas de documentación que se heredaron de clases base. Ya no es necesario duplicar las cadenas de documentación si la documentación que se heredó es apropiada. Para suprimir una cadena que se heredó, se debe especificar una cadena vacía (o se puede completar la documentación). Este cambio afecta la salida del módulo pydoc y la función help(). (Contribución de Serhiy Storchaka en bpo-15582.)
Ahora las llamadas anidadas functools.partial() se aplanan. Si se confiaba en el comportamiento anterior, ahora se puede agregar un atributo a un objeto functools.partial() o se puede crear una subclase de functools.partial(). (Contribución de Alexander Belopolsky en bpo-7830.)

Cambios en la API de C¶

Se eliminó el miembro no documentado format de la estructura (no pública) PyMemoryViewObject. Todas las extensiones que se basan en las partes relevantes en memoryobject.h se debe recompilar.
La estructura PyMemAllocator se renombró a PyMemAllocatorEx y se agregó un nuevo campo calloc.
Se eliminó la macro no documentada PyObject_REPR que filtró referencias. Usar el carácter de formato %R en funciones similares a PyUnicode_FromFormat() para formatear repr() del objeto. (Contribución de Serhiy Storchaka en bpo-22453.)
Debido a que la falta del atributo __module__ rompe pickling y la introspección, ahora se lanza una advertencia de deprecación para los tipos integrados sin el atributo __module__. Este sería un AttributeError en el futuro. (Contribución de Serhiy Storchaka en bpo-20204.)
Como parte de la implementación de PEP 492, el espacio tp_reserved de PyTypeObject se reemplazó con un espacio tp_as_async. Consultar Objetos corrutina para nuevos tipos, estructuras y funciones.

Cambios notables en Python 3.5.4¶

Nuevo objetivo de compilación `make regen-all`¶

Para simplificar la compilación cruzada y asegurar que CPython se pueda compilar de manera confiable sin requerir que una versión existente de Python ya esté disponible, el sistema de compilación basado en herramientas automáticas ya no intenta volver a compilar implícitamente los archivos generados en función de los tiempos de modificación de los archivos.

En su lugar, se agregó un nuevo comando make regen-all para forzar la regeneración de estos archivos cuando se desee (p. ej. después de que ya se haya creado una versión inicial de Python basada en las versiones pregeneradas).

También se definen objetivos de regeneración más selectivos - consultar Makefile.pre.in para más detalles.

(Contribución de Victor Stinner en bpo-23404.)

Nuevo en la versión 3.5.4.

Eliminación del objetivo de compilación `make touch`¶

Se eliminó el objetivo de compilación make touch que anteriormente se usaba para solicitar la regeneración implícita de los archivos generados mediante la actualización de sus tiempos de modificación.

Se reemplazó por el nuevo objetivo make regen-all.

(Contribución de Victor Stinner en bpo-23404.)

Distinto en la versión 3.5.4.