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.
