# 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:

1. Ignorar el `InterruptedError`.

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

Ahora la función `what()` reconoce el formato OpenEXR (contribución de Martin Vignali y Claudiu Popa en bpo-20295) y el formato WebP (contribución de Fabrice Aneche y Claudiu Popa en 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

Ahora el módulo `unicodedata` usa datos de 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`:

- `PyMem_RawCalloc()`,

- `PyMem_Calloc()`,

- `PyObject_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 generará 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 eliminó los archivos `.pyo` de Python e introdujo la etiqueta opcional `opt-` en los nombres de archivo `.pyc`. La función `importlib.util.cache_from_source()` ganó un parámetro optimization para ayudar a controlar la etiqueta `opt-`. Debido a esto, ahora el parámetro debug_override de la función está obsoleto. También los archivos .pyo ya no se admiten como un argumento de archivo para el intérprete de Python, y por lo tanto, no tienen ningún propósito cuando se distribuyen por sí mismos (es decir, distribución de código sin fuente). Debido al hecho de que el número mágico para bytecode se cambió en Python 3.5, todos los archivos antiguos .pyo de versiones anteriores de Python no son válidos independientemente de este 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.