# Que novedades hay en python 3.3

Éste artículo explica las nuevas características en python 3.3, en comparación con la versión 3.2. Python 3.3 se lanzó el 29 de septiembre de 2012. Para más detalles, ver el log de cambios en la dirección <https://docs.python.org/3.3/whatsnew/changelog.html>.

Ver también

PEP 398 - Calendario de Publicación Python 3.3

## Resumen – Aspectos destacados de la versión

Nuevas características de sintaxis:

- Nueva expresión `yield from` para delegación de generadores.

- La sintaxis `u'unicode'` se acepta de nuevo para los objetos `str`.

Nuevos módulos de biblioteca:

- `faulthandler` (ayuda a depurar bloqueos de bajo nivel)

- `ipaddress` (Objetos de alto nivel que representan direcciones IP y máscaras)

- `lzma` (comprime datos usando el algoritmo XZ / LZMA)

- `unittest.mock` (Utiliza objetos que simulen partes de tu sistema en ambiente de pruebas)

- `venv` (Python entornos virtuales, como en el paquete original Virtualenv)

Nuevas características incorporadas:

- Se reformula la Jerarquía de excepción I/O .

Mejoras de implementación:

- Se reescribe Maquinaria de importación con base en `importlib`.

- cadenas de caracteres unicode más compactas.

- diccionarios de atributos más compactos.

Módulos de biblioteca con mejoras significativas:

- Acelerador de C para el módulo decimal .

- Mejor gestión de unicode en el módulo email (provisional).

Mejoras de seguridad:

- La aleatoriedad en los hash está habilitada de forma predeterminada.

Por favor continúa leyendo para obtener una lista completa de los cambios de cara al usuario.

## PEP 405: Entornos virtuales

Virtual environments help create separate Python setups while sharing a system-wide base install, for ease of maintenance. Virtual environments have their own set of private site packages (i.e. locally installed libraries), and are optionally segregated from the system-wide site packages. Their concept and implementation are inspired by the popular `virtualenv` third-party package, but benefit from tighter integration with the interpreter core.

Este PEP agrega el módulo `venv` para acceso programático, y el script `pyvenv` para administración y acceso a través de línea de comandos. El intérprete de python busca un archivo llamado `pyvenv.cfg`, cuya existencia señala la base de un árbol de directorios en el entorno virtual.

Ver también

PEP 405 - Entornos virtuales en python

  PEP escrito por Carl Meyer; implementación por Carl Meyer y Vinay Sajip

## PEP 420: Paquetes para espacios de nombres implícitos

Soporte nativo para directorios de paquetes que no requieran el archivo `__init.py__` y puedan abarcar automáticamente múltiples segmentos de rutas de acceso (Inspirado en varios enfoques de terceros para espacios de nombres de paquetes, tal como está especificado en PEP 420)

Ver también

PEP 420 - Paquetes de espacio de nombres implícitos

  PEP escrito por Eric V. Smith; implementación por Eric V. Smith y Barry Warsaw

## PEP 3118: Nueva implementación de vista de memoria y en la documentación del protocolo del buffer

La implementación del PEP 3118 ha tenido mejoras significativas.

La nueva implementación de la vista de memoria corrige exhaustivamente todos los problemas de propiedad y duración de los campos asignados dinámicamente en la estructura de Py_buffer que ha dado lugar a varios informes de bloqueo. Además, se han corregido varias funciones que se bloquearon o retornaron resultados incorrectos para entradas no contigua o multidimensional.

El objeto de vista de memoria dispone ahora de PEP-3118 que obedece a getbufferproc(), el cual verifica el tipo de petición del cliente. Se han agregado nuevas características, la mayoría de ellas funcionan generalmente para arrays no contiguos y arrays con subindices.

La documentación se ha actualizado y se han establecido claramente las responsabilidades tanto para los exportadores como para los consumidores. Los indicadores de solicitud de buffer se agrupan en indicadores básicos y compuestos. Se explica el diseño de memoria de matrices de estilo NumPy no contiguas y multidimensionales.

### Características

- Ahora se admiten todos los especificadores nativos de formato de un solo carácter en la sintaxis del módulo de estructura (opcionalmente con el prefijo “@”).

- Con algunas reestricciones, el método cast() permite cambiar el formato y forma de los arrays contiguos.

- La representación de listas multidimensionales es aceptada por cualquier tipo de array.

- Se admiten comparaciones multidimensionales para cualquier tipo de array.

- Los objetos de vista de memoria unidimensionales de tipo hash con formatos B, b, o c ahora son hashables (Contribución por Antoine Pitrou en el issue 13411.)

- Se admite el corte arbitrario de cualquier tipo de array unidimensional. Por ejemplo, ahora es posible revertir una vista de memoria en O(1) utilizando un valor negativo para el índice STEP.

### Cambios en la API

- Oficialmente, se limita el número máximo de dimensiones a 64.

- Las formas vacías, pasos, y subíndices ahora son representados por una tupla vacía, en vez de `None`.

- El acceso al elemento de una vista de memoria con formato “B” (bytes sin signo) ahora retorna un entero (de acuerdo con la sintaxis del módulo de estructura). Para retornar un objeto bytes, primero la vista debe ser convertida a «C».

- las comparaciones de la vista de memoria ahora utilizan la estructura lógica de los operandos y comparan todos los elementos de array por valor. Se admiten todos los formatos strings en la sintaxis del módulo de estructura. Aún se admiten las vistas con strings que tengan un formato no reconocido, pero siempre se compararan como desiguales, independientemente del contenido de la vista.

- Para más cambios, consulte Compilación y cambios en la API de C y Portabilidad del código C.

(Contribución por Stefan Krah en el issue 10181 .)

Ver también

PEP 3118 - Revisando el protocolo de buffer

## PEP 393: Representación flexible de cadenas de caracteres

El tipo de cadena Unicode es modificado para admitir múltiples representaciones internas, dependiendo del caracter con el ordinal Unicode más grande (1, 2 o 4 bytes) en la cadena representada. Esto permite una representación que ahorra espacio en casos comunes, pero da acceso a UCS-4 completo en todos los sistemas. Para compatibilidad con APIS existentes, pueden existir varias representaciones en paralelo; con el tiempo, esta compatibilidad debería eliminarse gradualmente.

Por parte de Python, no debería haber inconvenientes por éste cambio.

Por parte de la API de C, PEP 393 es totalmente compatible con versiones anteriores. La API antigua debería quedar disponible al menos por cinco años. Las aplicaciones que usan la API antigua no saldrán beneficiadas por la reducción de memoria, o -peor- podrían usar un bit más de memoria, debido a que python necesitaría mantener dos versiones de cada cadena de caracteres (en el formato antiguo y en el nuevo almacenamiento)

### Funcionalidad

Los cambios introducidos en el PEP 393 son los siguientes:

- Ahora python admite siempre el rango completo de códigos Unicode, incluyendo los que no son BMP (es decir, `U+0000` to `U+10FFFF`). La distinción entre ancho y angosto ya no existe, y python se comporta ahora como una compilación amplia, incluso en sistemas windows.

- Con la eliminación de las construcciones estrechas, han sido solucionados también los problemas específicos referentes a este tipo de construcciones, por ejemplo:

  - `len()` Ahora siempre retorna 1 para los caracteres que no son BMP, de modo que `len('\U0010FFFF') == 1`;

  - los pares sustitutos no se recombinan en cadenas literales, de modo que `'\uDBFF\uDFFF' != '\U0010FFFF'`;

  - la indexación o el corte de caracteres que no son BMP, retorna el valor esperado, de modo que `'\U0010FFFF'[0]` ahora retorna `'\U0010FFFF'` y no `'\uDBFF'`;

  - todas las demás funciones en la librería estándar ahora gestionan de forma correcta los puntos de código que no son BMP.

- El valor de `sys.maxunicode` ahora siempre es `1114111` (`0x10FFFF` en hexadecimal). La función `PyUnicode_GetMax()` aún retorna el valor `0xFFFF` o el valor `0x10FFFF` para compatibilidad con versiones anteriores, y no debe usarse con la nueva API Unicode (ver bpo-13054).

- Se ha eliminado el indicador :file:”./configure” “”–with-wide-unicode””.

### Rendimiento y uso de recursos

El almacenamiento de las cadenas Unicode ahora depende del punto de código más alto en la cadena:

- las cadenas de caracteres en ASCII puro y Latin1 (`U+0000-U+00FF`) usan 1 byte por punto de código;

- Las cadenas de caracteres BMP (`U+0000-U+FFFF`) usan 2 bytes por punto de código;

- las cadenas de caracteres que no son BMP (`U+10000-U+10FFFF`) usan 4 bytes por punto de código.

El efecto neto es que para la mayoría de las aplicaciones, el uso de memoria del almacenamiento de cadenas de caracteres debería disminuir significativamente, especialmente en comparación con las construcciones unicode anchas, ya que, en muchos casos, las cadenas serán ASCII puro incluso en contextos internacionales (porque muchas cadenas almacenan datos en lenguaje no humano, tal como fragmentos XML, encabezados HTTP, datos codificados en JSON, etc.). También esperamos que, por las mismas razones, aumente la eficiencia de la caché de la CPU en aplicaciones no triviales. El uso de memoria de Python 3.3 es dos o tres veces más pequeño que Python 3.2, y un poco mejor que Python 2.7, en un punto de referencia de Django (consulte el PEP para obtener más detalles).

Ver también

PEP:393 - Representación flexible de cadenas de caracteres

  PEP escrito por Martin von Lowis; implementado por Torsten Becker y Martin von Lowis.

## PEP 397: Lanzador de python para windows

El instalador de Python 3.3 para windows ahora incluye una aplicación lanzadora `py` que puede ser utilizada para ejecutar aplicaciones python de forma independiente de la versión.

Este lanzador se invoca de forma implícita cuando haces doble click en archivos `*.py`. Si el sistema tiene instalada una única versión de python, ésta versión será usada para ejecutar el archivo. Si hay múltiples versiones instaladas en el sistema, se utilizara por defecto la versión más reciente pero ésto puede ser anulado incluyendo una «línea shebang» estilo Unix en el script de Python.

El lanzador también se puede usar explícitamente desde la línea de comando como la aplicación `` py “”. La ejecución de `` py “” sigue las mismas reglas de selección de versión que la ejecución implícita de scripts, pero se puede seleccionar una versión más específica pasando los argumentos apropiados (como `` -3 “” para solicitar Python 3 cuando Python 2 también está instalado, o `` -2.6 “” para solicitar específicamente una versión anterior de Python cuando se instala una versión más reciente).

Además del lanzador, el instalador de Windows ahora incluye una opción para agregar el Python recién instalado al PATH del sistema. (Contribución de Brian Curtin en bpo-3561.)

Ver también

PEP 397 - Python Launcher for Windows

  PEP escrito por Mark Hammond y Martin v. Löwis; implementado por Vinay Sajip.

Documentación del lanzador: Lanzador de Python para Windows

Modificación de la ruta del instalador: Encontrar el ejecutable de Python

## PEP 3151: Reelaborando de la jerarquía de excepciones de IO y OS

La jerarquía de excepciones generada por errores del sistema operativo ahora está simplificada y es más detallada.

No tienes que preocuparte más por cómo elegir el tipo de excepción adecuado entre `OSError`, `IOError`, `EnvironmentError`, `WindowsError`, `mmap.error`, `socket.error` or `select.error`. Todos estos tipos de excepción son ahora una sola: `OSError`. Los otros nombres se mantienen como alias por razones de compatibilidad.

Además, ahora es más fácil detectar una condición de error específica. En lugar de inspeccionar el atributo `errno` (o `args[0]`) para una constante particular del módulo `errno`, puede seleccionar la subclase `OSError` adecuada. Las subclases disponibles son las siguientes:

- `BlockingIOError`

- `ChildProcessError`

- `ConnectionError`

- `FileExistsError`

- `FileNotFoundError`

- `InterruptedError`

- `IsADirectoryError`

- `NotADirectoryError`

- `PermissionError`

- `ProcessLookupError`

- `TimeoutError`

Y el mismo `ConnectionError` tiene subclases más detalladas:

- `BrokenPipeError`

- `ConnectionAbortedError`

- `ConnectionRefusedError`

- `ConnectionResetError`

Gracias a las nuevas excepciones, los usos comunes de `errno` ahora se pueden evitar. Por ejemplo, el siguiente código escrito para Python 3.2:

    from errno import ENOENT, EACCES, EPERM

    try:
        with open("document.txt") as f:
            content = f.read()
    except IOError as err:
        if err.errno == ENOENT:
            print("document.txt file is missing")
        elif err.errno in (EACCES, EPERM):
            print("You are not allowed to read document.txt")
        else:
            raise

ahora se pueden escribir sin la importación de `errno` y sin la inspección manual de atributos de excepción:

    try:
        with open("document.txt") as f:
            content = f.read()
    except FileNotFoundError:
        print("document.txt file is missing")
    except PermissionError:
        print("You are not allowed to read document.txt")

Ver también

PEP 3151 - Re elaboración de la jerarquía de excepciones de IO y OS

  PEP escrito e implementado por Antoine Pitrou

## PEP 380: Sintaxis para delegar en un subgenerador

PEP 380 agrega la expresión `yield from`, permitiendo que un generator delegue parte de sus operaciones a otro generador. Esto permite tomar en consideración una sección de código que contenga la palabra `yield` y ubicarla en otro generador. Además, el subgenerador puede regresar con un valor y el valor se pone a disposición del generador que delega.

Aunque está diseñada principalmente para su uso en la delegación a un subgenerador, la expresión `yield from` en realidad permite la delegación a subiteradores arbitrarios.

Para iteradores simples, `yield from iterable` es esencialmente una forma abreviada de `for item in iterable: yield item`:

    >>> def g(x):
    ...     yield from range(x, 0, -1)
    ...     yield from range(x)
    ...
    >>> list(g(5))
    [5, 4, 3, 2, 1, 0, 1, 2, 3, 4]

Sin embargo, a diferencia de un ciclo ordinario, `yield from` permite que los subgeneradores reciban valores enviados y lanzados directamente desde el ámbito de la llamada y retornen un valor final al generador externo:

    >>> def accumulate():
    ...     tally = 0
    ...     while 1:
    ...         next = yield
    ...         if next is None:
    ...             return tally
    ...         tally += next
    ...
    >>> def gather_tallies(tallies):
    ...     while 1:
    ...         tally = yield from accumulate()
    ...         tallies.append(tally)
    ...
    >>> tallies = []
    >>> acc = gather_tallies(tallies)
    >>> next(acc)  # Ensure the accumulator is ready to accept values
    >>> for i in range(4):
    ...     acc.send(i)
    ...
    >>> acc.send(None)  # Finish the first tally
    >>> for i in range(5):
    ...     acc.send(i)
    ...
    >>> acc.send(None)  # Finish the second tally
    >>> tallies
    [6, 10]

Lo más importante de éste cambio es permitir que incluso los generadores que están diseñados para ser usados con los métodos `send` y `throw` sean separados en múltiples subgeneradores tan fácilmente como las funciones grandes se pueden dividir en varias subfunciones.

Ver también

PEP 380 - Sintaxis para delegar a un subgenerador

  PEP escrito por Greg Ewing; implementación por Greg Ewing, integrado en 3.3 por Renaud Blanch, Ryan Kelly y Nick Coghlan; documentación de Zbigniew Jędrzejewski-Szmek y Nick Coghlan

## PEP 409: Suprimir el contexto de excepción

PEP 409 introduce una nueva sintaxis que permite deshabilitar la visualización del contexto de excepción encadenado. Esto permite mensajes de error más limpios en aplicaciones que convierten entre tipos de excepción:

    >>> class D:
    ...     def __init__(self, extra):
    ...         self._extra_attributes = extra
    ...     def __getattr__(self, attr):
    ...         try:
    ...             return self._extra_attributes[attr]
    ...         except KeyError:
    ...             raise AttributeError(attr) from None
    ...
    >>> D({}).x
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<stdin>", line 8, in __getattr__
    AttributeError: x

Sin el sufijo `from None` para suprimir la causa, la excepción original se mostraría de forma predeterminada:

    >>> class C:
    ...     def __init__(self, extra):
    ...         self._extra_attributes = extra
    ...     def __getattr__(self, attr):
    ...         try:
    ...             return self._extra_attributes[attr]
    ...         except KeyError:
    ...             raise AttributeError(attr)
    ...
    >>> C({}).x
    Traceback (most recent call last):
      File "<stdin>", line 6, in __getattr__
    KeyError: 'x'

    During handling of the above exception, another exception occurred:

    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<stdin>", line 8, in __getattr__
    AttributeError: x

No se pierde ninguna capacidad de depuración, ya que el contexto de la excepción original permanece disponible en caso de ser necesario (por ejemplo, si una biblioteca suprime detalles importantes y valiosos de forma incorrecta)

    >>> try:
    ...     D({}).x
    ... except AttributeError as exc:
    ...     print(repr(exc.__context__))
    ...
    KeyError('x',)

Ver también

PEP 409 - Supresión del contexto de excepción

  PEP escrito por Ethan Furman; implementado por Ethan Furman y Nick Coghlan.

## PEP 414: Literales Unicode explícitos

Para facilitar la transición de Python 2 para las aplicaciones de Python que reconocen Unicode y que hacen un uso intensivo de literales Unicode, Python 3.3 una vez más admite el prefijo «`u`» para cadenas literales. Este prefijo no tiene importancia semántica en Python 3, se proporciona únicamente para reducir el número de cambios puramente mecánicos en la migración a Python 3, lo que facilita a los desarrolladores centrarse en los cambios semánticos más significativos (como la separación predeterminada más estricta de binary y datos de texto).

Ver también

PEP 414 - Literales Unicode Explícitos

  PEP escrito por Armin Ronacher.

## PEP 3155: Nombres calificados para clases y funciones

Las funciones y objetos de clases tienen un nuevo atributo `__qualname__`, que representa la ruta desde el nivel superior del módulo hasta su definición. Para funciones globales y clases, es lo mismo que `__name__`. Para otras funciones y clases, éste proporciona mejor información sobre donde han sido definidos realmente y como podrían ser accesibles desde un ámbito global.

Ejemplo con métodos (no vinculados):

    >>> class C:
    ...     def meth(self):
    ...         pass
    >>> C.meth.__name__
    'meth'
    >>> C.meth.__qualname__
    'C.meth'

Ejemplo con clases anidadas:

    >>> class C:
    ...     class D:
    ...         def meth(self):
    ...             pass
    ...
    >>> C.D.__name__
    'D'
    >>> C.D.__qualname__
    'C.D'
    >>> C.D.meth.__name__
    'meth'
    >>> C.D.meth.__qualname__
    'C.D.meth'

Ejemplo con funciones anidadas:

    >>> def outer():
    ...     def inner():
    ...         pass
    ...     return inner
    ...
    >>> outer().__name__
    'inner'
    >>> outer().__qualname__
    'outer.<locals>.inner'

La representación en cadena de estos objetos, también se ha modificado para incluir la información nueva y más precisa:

    >>> str(C.D)
    "<class '__main__.C.D'>"
    >>> str(C.D.meth)
    '<function C.D.meth at 0x7f46b9fe31e0>'

Ver también

PEP 3155 - Nombres calificados para clases y funciones

  PEP Escrito e implementado por Antoine Pitrou.

## PEP 412: Diccionario de intercambio de claves

Los diccionarios usados para almacenar atributos de objetos, ahora pueden compartir parte de su almacenamiento interno entre sí (a saber, la parte que almacena las claves y sus respectivos hashes). Esto reduce el consumo de memoria de programas creando varias instancias de tipos no integrados.

Ver también

PEP 412 -Diccionario de intercambio de claves

  PEP escrito e implementado por Mark Shannon.

## PEP 362: Objeto de firma de función

Una nueva función `inspect.signature()` hace que la introspección de las llamadas de Python sea fácil y directa. Se admite una amplia gama de invocables: funciones python, decoradas o no, clases y objetos `functools.partial()`. Las Nuevas clases `inspect.Signature`, `inspect.Parameter` y `inspect.BoundArguments` contienen información sobre las firmas de llamadas, tales como anotaciones, valores por defecto, tipos de parámetros, y los argumentos vinculados, lo cual simplifica considerablemente la escritura de decoradores y de cualquier código que valide o modifique las firmas de llamadas o argumentos.

Ver también

PEP 362: - Objeto de firmas de función

  PEP escrito por Brett Cannon, Yury Selivanov, Larry Hastings, Jiwon Seo; implementado por Yury Selivanov.

## PEP 421: Agregar sys.implementation

Un nuevo atributo en el módulo `sys` expone detalles específicos de la implementación del intérprete que se ésta ejecutando en el momento actual. El conjunto inicial de atributos en `sys.implementation` son `name`, `version`, `hexversion`, y `cache_tag`.

La intención de `sys.implementation` es consolidar dentro de un espacio de nombres, la implementación específica de datos usado por la biblioteca estándar. Esto permite que diferentes implementaciones de python puedan compartir código de la biblioteca estándar de manera más fácil. En su estado inicial, `sys.implementation` contiene solo una pequeña porción de los datos específicos de la implementación. Con el tiempo esta proporción cambiará para hacer que la biblioteca estándar sea más portable..

Un ejemplo de mejor portabilidad de la biblioteca estándar es `cache_tag`. A partir de Python 3.3, `sys.implementation.cache_tag` es utilizado por `importlib` para admitir el cumplimiento PEP 3147. Cualquier implementación de Python que utilice `importlib` para su sistema de importación integrado puede usar `cache_tag` para controlar el comportamiento de almacenamiento en caché de los módulos.

### SimpleNamespace

La implementación de `sys.implementation` también trae un nuevo tipo a Python: La clase `types.SimpleNamespace`. En comparación con un nombre de espacio basado en mapas, como `dict`, `SimpleNamespace` es basado en atributos, como `object`. Sin embargo a diferencia de `object`, las instancias de `SimpleNamespace` son editables. Esto significa que puedes agregar, eliminar, y modificar el nombre de espacio a través del acceso normal a los atributos.

Ver también

PEP 421 - Agregar sys.implementation

  PEP escrito e implementado por Mark Shannon.

## Usar importlib como implementación de Import

bpo-2377- Replace__import__w/ importlib.__import__ bpo-13959 - Re-implementar partes de `imp` en Python puro bpo-14605 - Hacer que la maquinaria de importación sea explícita bpo-14646 - Requerir que los cargadores establezcan __loader__ y __package__

La función `__import__()` ahora es potenciada por la función `importlib.__import__()`. Este trabajo conduce a completar la «fase 2» de PEP 302. Hay múltiples beneficios en éste cambio. En primer lugar, ha permitido que la mayoría de la maquinaria que potencia las importaciones sea expuesta, en vez de estar implícitas y ocultas en el código de C. También proporciona una única implementación para todas las máquinas virtuales de python que admitan el uso de Python 3.3 lo que ayuda a terminar con cualquier desviación específica de VM en la semántica de importación. Y finalmente facilita el mantenimiento de la importación, permitiendo que ocurra un crecimiento futuro.

Para el usuario común, no debería haber cambios visibles en la semántica. Para aquellos cuyo código realmente manipula la importación o las llamadas de importación de forma programática, los cambios de código que posiblemente sean necesarios, se tratan en la sección Porting Python code de éste documento.

### Nuevas APIs

Uno de los grandes beneficios de éste trabajo es la exposición de lo que implica hacer que funcione la sentencia de importación. Esto significa que los varios importadores que una vez fueron implícitos, ahora son expuestos completamente como parte del paquete `importlib`.

Las clases base abstractas definidas en `importlib.abc` se han expandido para delimitar adecuadamente entre buscadores de rutas meta y buscadores de entrada de rutas al introducir la clase `importlib.abc.MetaPathFinder` y `importlib.abc.PathEntryFinder` respectivamente. El antiguo ABC de la clase `importlib.abc.Finder` ahora solo se proporciona para compatibilidad con versiones anteriores y no exige ningún requisito de método.

En términos de buscadores, `importlib.machinery.FileFinder` expone el mecanismo utilizado para buscar archivos fuente y de código de bytes de un módulo. Anteriormente, ésta clase era un miembro implícito de `sys.path_hooks`.

Para los cargadores, la nueva clase base abstracta `importlib.abc.FileLoader` ayuda a escribir un cargador que usa el sistema de archivos como mecanismo de almacenamiento para el código de un módulo. El cargador de archivos fuente (`importlib.machinery.SourceFileLoader`), archivos de código byte sin fuente (`importlib.machinery.SourcelessFileLoader`) y módulos de extensión (`importlib.machinery.ExtensionFileLoader`) ahora están disponibles para su uso directo.

`ImportError` ahora tiene los atributos `name` y `path` que se establecen cuando hay datos relevantes para proporcionar. También, el mensaje de importaciones fallidas ahora proporcionará el nombre completo del módulo en lugar de solo el final del nombre del mismo.

La función `importlib.invalidate_caches()` ahora llamará al método con el mismo nombre en todos los buscadores almacenados en `sys.path_importer_cache` para ayudar a limpiar cualquier estado almacenado según sea necesario.

### Cambios visibles

Para conocer los posibles cambios necesarios en el código, consulte la sección Porting Python code .

Más allá de la extensión de lo que ahora expone `importlib`, hay otros cambios visibles para importar. El más grande es que `sys.meta_path` y `sys.path_hooks` ahora almacenan todos los buscadores de rutas meta y los ganchos de entrada de rutas usados por la importación. Anteriormente, los buscadores estaban implícitos y ocultos dentro del código C de importación en lugar de estar expuestos directamente. Esto significa que ahora uno puede eliminar o cambiar fácilmente el orden de los diversos buscadores para satisfacer sus necesidades.

Otro cambio es que todos los módulos tienen un atributo `__loader__` que almacena el cargador usado para crear el módulo. La PEP 302 se ha actualizado para hacer que este atributo sea obligatorio para implementar los cargadores, de manera que en el futuro, una vez que los cargadores de terceros hayan sido actualizados, las personas puedan confiar en la existencia de éste atributo. Sin embargo, hasta entonces la importación está configurando la post carga del módulo.

También se espera que ahora los cargadores establezcan el atributo `__package__` de PEP 366. Una vez más, la importación por sí misma ya está configurando ésto en todos los cargadores del módulo `importlib` y la importación misma está configurando la post carga del atributo.

Ahora se incluye el atributo `None` dentro de `sys.path_importer_cache` cuando no se encuentre ningún buscador en `sys.path_hooks`. Dado que `imp.NullImporter` no está directamente expuesto en `sys.path_hooks`, podría no haber una certeza de que esté disponible para su uso como un valor que represente que no se ha encontrado ningún buscador.

Todos los demás cambios se relacionan con los cambios de semántica que deben tomarse en cuenta al actualizar el código a python 3.3, por lo tanto, deben leerse en la sección Portar código Python de este documento.

(Implementación por Brett Cannon)

## Otros cambios de idioma

Algunos cambios más pequeños realizados en el lenguaje Python principal son:

- Se ha añadido compatibilidad con alias de nombres Unicode y secuencias con nombre. Tanto `unicodedata.lookup()` como `'N{...}'` ahora resuelven los alias de nombre, y `unicodedata.lookup()` también resuelve las secuencias con nombre.

  (Contribución de Ezio Melotti en :issue:”12753”.)

- Base de datos Unicode actualizada a la versión 6.1.0 de UCD

- Las comparaciones de igualdad en los objetos `range()` ahora retornan un resultado que refleja la igualdad de las secuencias subyacentes generadas por esos objetos de rango. (bpo-13201)

- Los métodos `count()`, `find()`, `rfind()`, `index()` y `rindex()` de los objetos `bytes` y `bytearray` ahora aceptan un entero entre 0 y 255 como su primer argumento.

  (Contribución por Petri Lehtinen en bpo-12170.)

- Los métodos `rjust()`, `ljust()`, y `center()` de `bytes` y `bytearray` ahora aceptan un `bytearray` para el argumento `fill`. (Contribución de Petri Lehtinen en bpo-12380.)

- Se han agregado nuevos métodos a `list` y `bytearray`: `copy()` y `clear()` (bpo-10516). En consecuencia, `MutableSequence` ahora también definen un método `clear()` (bpo-11388).

- Los literales de bytes sin formato ahora se pueden escribir `rb"..."` así como `br"..."`.

  (Contribución de Antoine Pitrou en bpo-13748.)

- El método `dict.setdefault()` ahora solo hace una sola búsqueda de la clave dada, haciéndola atómica cuando se usa con tipos incorporados.

  (Contribución de Filip Gruszczyński en bpo-13521.)

- Los mensajes de error producidos cuando la llamada de una función no coincide con la firma han sido mejorados significativamente.

  (Contribución de Benjamin Peterson.)

## Un bloqueo de importación más detallado

Las versiones anteriores de CPython siempre se han basado en un bloqueo de importación global. Ésto conduce a problemas inesperados tales como bloqueos cuando la importación un módulo debería disparar la ejecución de código en un hilo diferente como un efecto secundario. A veces se empleaban soluciones torpes, como la función de API C `PyImport_ImportModuleNoBlock()` .

En Python 3.3, la importación de un módulo toma un bloqueo por módulo. Esto serializa correctamente la importación de un módulo determinado a partir de múltiples subprocesos (impidiendo la exposición de módulos inicializados incompletamente), mientras elimina las molestias antes mencionadas.

(Contribución de Antoine Pitrou en bpo-9260.)

## Funciones y tipos incorporados

- `open()` obtiene un nuevo parámetro opener: el descriptor de archivo subyacente para el objeto de archivo se obtiene llamando a opener con (file, flags). Se puede utilizar para utilizar banderas personalizadas como `os.O_CLOEXEC`, por ejemplo. Se ha añadido el modo `'x'` : abierto para la creación exclusiva, fallando si el archivo ya existe.

- `print()`: agregó el argumento de palabra clave flush. Si el argumento de palabra clave flush es verdadero, la secuencia se vacía por la fuerza.

- `hash()`: hash randomization is enabled by default, see `object.__hash__()` and `PYTHONHASHSEED`.

- El tipo `str` obtiene un nuevo método `casefold()`: retorna una copia de la cadena con mayúsculas y minúsculas, las cadenas con mayúsculas y minúsculas se pueden utilizar para la coincidencia sin mayúsculas. Por ejemplo, `'ß'.casefold()` retorna `'ss'`.

- La documentación de secuencia se ha reescrito sustancialmente para explicar mejor la distinción de secuencia binaria/texto y para proporcionar secciones de documentación específicas para los tipos de secuencia individuales integrados(bpo-4966).

## Nuevos módulos

### faulthandler

Este nuevo módulo de depuración `faulthandler` contiene funciones para volcar los rastreos de Python explícitamente, en una falla (como una falla de segmentación), después de un tiempo de espera o en una señal de usuario. Llame a `faulthandler.enable()` para instalar controladores de fallas para las señales `SIGSEGV`, `SIGFPE`, `SIGABRT`, `SIGBUS`, y `SIGILL` . También puede habilitarlos al inicio configurando la variable de entorno `PYTHONFAULTHANDLER` o usando la opción de línea de comandos `-X` `faulthandler` .

Ejemplo de una falla de segmentación en Linux:

    $ python -q -X faulthandler
    >>> import ctypes
    >>> ctypes.string_at(0)
    Fatal Python error: Segmentation fault

    Current thread 0x00007fb899f39700:
      File "/home/python/cpython/Lib/ctypes/__init__.py", line 486 in string_at
      File "<stdin>", line 1 in <module>
    Segmentation fault

### ipaddress

El nuevo módulo `ipaddress` proporciona herramientas para crear y manipular objetos que representen direcciones, redes e interfaces IPv4 e IPv6 (es decir, alguna dirección IP asociada con una subred IP específica)

(Contribución de Google y Peter Moody en PEP 3144 )

### lzma

The newly added `lzma` module provides data compression and decompression using the LZMA algorithm, including support for the `.xz` and `.lzma` file formats.

(Contribución de Nadeem Vawda y Per Øyvind Karlsen en bpo-6715.)

## Módulos mejorados

### abc

Soporte mejorado para las clases base abstractas que contienen descriptores compuestos con métodos abstractos. El enfoque recomendado para declarar descriptores abstractos ahora es proporcionar `__isabstractmethod__` como una propiedad actualizada dinámicamente. Los descriptores integrados han sido actualizados en consecuencia.

> - La clase `abc.abstractproperty` ha quedado obsoleta, en su lugar use la clase `property` con `abc.abstractmethod()`.

> - La clase `abc.abstractclassmethod` ha quedado obsoleta. En su lugar use el método `classmethod` with `abc.abstractmethod()`.

> - `abc.abstractstaticmethod` ha quedado obsoleta, use `staticmethod` with `abc.abstractmethod()`.

(Contribución de Darren Dale en bpo-11610. )

El método `abc.ABCMeta.register()` ahora retorna las subclases registradas, lo cual significa que ahora éste puede ser usado como un decorador de clases (bpo-10868).

### array

The `array` module supports the `long long` type using `q` and `Q` type codes.

(Contribución de Oren Tirosh y Hirokazu Yamamoto en bpo-1172711.)

### base64

Las cadenas Unicode de solo ASCII ahora son aceptadas por las funciones de decodificación de la interfaz moderna `base64`. Por ejemplo, `base64.b64decode ('YWJj')` retorna `b'abc'`. (Contribución por Catalin Iacob en: número: 13641.)

### binascii

Además de los objetos binarios que normalmente aceptan, las funciones `a2b_` ahora también aceptan cadenas de sólo ASCII como dato de entrada. (Contribución por Antoine Petrou en bpo-13637.)

### bz2

El módulo `bz2` ha sido reescrito desde cero. Durante el proceso, han sido agregadas varias características:

- Nueva función `bz2.open()`: abre un archivo comprimido por bzip2, en modo binario o en modo de texto.

- `bz2.BZ2File` ahora puede leer y escribir en objetos de tipo archivo arbitrarios, mediante el argumento fileobj de su constructor.

  (Contribución de Nadeem Vawda en bpo-5863.)

- La clase `bz2.BZ2File` y la función `bz2.decompress()` ahora descomprimen entradas de flujo múltiple (como las producidas por la herramienta pbzip2). La clase `bz2.BZ2File` ahora puede ser usada también para crear este tipo de archivos, usando el modo `'a'` (agregar).

  (Contribución de Nir Aides en bpo-1625.)

- La clase `bz2.BZ2File` ahora implementa toda la API `io.BufferedIOBase`, excepto los métodos `detach()` y `truncate()`.

### códecs

El códec `mbcs` ha sido reescrito para manejar correctamente los controladores de error `reemplazar` e `ignorar` en todas las versiones Windows. El códec `mbcs` ahora admite todos los controladores de error, en lugar de solo `replace` para codificar e `ignore` para decodificar.

Ha sido agregado un nuevo códec únicamente para windows: `cp65001` (bpo-13216). Es la página de códigos de Windows con el código 65001 (Windows UTF-8, `CP_UTF8`). Por ejemplo, es usado por `sys.stdout` si la página de códigos de salida de la consola se establece en cp65001 (por ejemplo, usando el comando `chcp 65001`).

Los decodificadores CJK multibyte ahora se re-sincronizan más rápido. Solo ignoran el primer byte de una secuencia de bytes no válida. Por ejemplo, `` b “xffn”.decode (” gb2312 “,”replace”) `` ahora retorna un `\n` después del carácter de reemplazo.

(bpo-12016)

Los codificadores de códec incrementales CJK ya no se restablecen en cada llamada a sus métodos encode(). Por ejemplo:

    >>> import codecs
    >>> encoder = codecs.getincrementalencoder('hz')('strict')
    >>> b''.join(encoder.encode(x) for x in '\u52ff\u65bd\u65bc\u4eba\u3002 Bye.')
    b'~{NpJ)l6HK!#~} Bye.'

Este ejemplo resulta `b'~{Np~}~{J)~}~{l6~}~{HK~}~{!#~} Bye.'` con versiones anteriores de Python.

(bpo-12100)

El códec `unicode_internal` ha quedado obsoleto.

### colecciones

Adición de una nueva `ChainMap` para permitir el tratamiento de un número de asignaciones como una sola unidad. (Escrito por Raymond Hettinger para :issue:”11089”, publicado en :issue:”11297”.)

Las clases base abstractas se han movido en un nuevo módulo `collections.abc`, para diferenciar mejor entre las clases de colecciones abstractas y concretas. Los alias para ABC siguen presentes en el módulo `collections` para preservar las importaciones existentes. (bpo-11085)

La clase `Counter` ahora admite los operadores “”+”” y “”-”” unarios, así como los operadores in situ `+=`, `-=`, `|=`, and `&=`. (Contribución de Raymond Hettinger en bpo-13121.)

### contextlib

`ExitStack` ahora proporciona una base sólida para la manipulación programática de los administradores de contexto y una funcionalidad de limpieza similar. A diferencia de la API anterior `contextlib.nested` (que estaba en desuso y se eliminó), la nueva API está diseñada para funcionar correctamente independientemente de si los administradores de contexto adquieren sus recursos en su método `__init__` (por ejemplo, objetos de archivo) o en su método `__enter__` (por ejemplo, objetos de sincronización del módulo `threading`).

(bpo-13585)

### crypt

Adición de sal y formato de cripta modular (método de hashing) y la función `mksalt()` al módulo `crypt`.

(bpo-10924)

### curses

> - Si el módulo `curses` es vinculado a la nueva librería ncursesw, se usan las funciones Unicode cuando se pasen cadenas o caracteres Unicode (por ejemplo, la función `waddwstr()`) o en caso contrario, funciones de bytes (e.g. `waddstr()`).

> - Usa la codificación local en vez de `utf-8` para codificar cadenas Unicode.

> - La clase `curses.window` tiene un nuevo atributo `curses.window.encoding`.

> - La clase `curses.window` tiene un nuevo método `get_wch()` para obtener un caracter ancho

> - El módulo `curses` tiene una nueva función `unget_wch()` para enviar un caracter ancho de manera que el próximo `get_wch()` lo retorne

(Contribución por Iñigo Serna en bpo-6755.)

### datetime

> - Las comparaciones de igualdad entre instancias conscientes e ingenuas `datetime` ahora retornan `False` en lugar de generar `TypeError` (bpo-15006).

> - Nuevo método `datetime.datetime.timestamp()`: Retorna la marca de tiempo POSIX correspondiente a la instancia `datetime`.

> - El método `datetime.datetime.strftime()` admite el formato de años anteriores a 1000.

> - Ahora se puede llamar al método `datetime.datetime.astimezone()` sin argumentos para convertir la instancia datetime en la zona horaria del sistema.

### decimal

bpo-7652 - integrar la aritmética decimal nativa rápida.

  Módulo C y libmpdec escritos por Stefan Krah.

The new C version of the decimal module integrates the high speed libmpdec library for arbitrary precision correctly rounded decimal floating point arithmetic. libmpdec conforms to IBM’s General Decimal Arithmetic Specification.

El rango de ganancias del rendimiento va de 10x para las aplicaciones de base de datos, a 100x para aplicaciones numéricamente intensivas. Estos números son ganancias esperadas para las precisiones estándar usadas en la aritmética de punto flotante decimal. Dado que la precisión es configurable por el usuario, las cifras exactas pueden variar. Por ejemplo, en la aritmética de enteros bignum, las diferencias pueden ser significativamente mayores.

The following table is meant as an illustration. Benchmarks are available at https://www.bytereef.org/mpdecimal/quickstart.html.

> | decimal.py | _decimal | speedup
> --- | --- | --- | ---
> pi | 42.02s | 0.345s | 120x
> telco | 172.19s | 5.68s | 30x
> psycopg | 3.57s | 0.29s | 12x

#### Características

- La señal `FloatOperation` habilita opcionalmente las semánticas estrictas para mezclar decimales y flotantes.

- Si python se compila sin subprocesos, la versión C deshabilita automáticamente la costosa maquinaria de contexto local de subprocesos. En éste caso, la variable `HAVE_THREADS` se establece en `False`.

#### Cambios en la API

- El módulo C tiene los siguientes límites de contexto, dependiendo de la arquitectura de la máquina:

  > | 32-bit | 64-bit
  > --- | --- | ---
  > `MAX_PREC` | `425000000` | `999999999999999999`
  > `MAX_EMAX` | `425000000` | `999999999999999999`
  > `MIN_EMIN` | `-425000000` | `-999999999999999999`

- En las plantillas de contexto (`DefaultContext`, `BasicContext` and `ExtendedContext`) la magnitud de `Emax` y `Emin` se ha cambiado a `999999`.

- El constructor `Decimal` en decimal.py no observa los límites de contexto y convierte valores con exponentes arbitrarios o precisión exacta. Dado que la versión C tiene límites internos, se usa el siguiente esquema: Si es posible, los valores son convertidos a valores exactos, de lo contrario se genera `InvalidOperation` y el resultado es NaN. En éste último caso siempre es posible usar `create_decimal()` para obtener un valor redondeado o inexacto.

- The power function in decimal.py is always correctly rounded. In the C version, it is defined in terms of the correctly rounded `exp()` and `ln()` functions, but the final result is only «almost always correctly rounded».

- En la versión C, el diccionario de contexto que contiene las señales, es una `MutableMapping`. Por razones de velocidad, `flags` y `traps` siempre se refiere a la misma `MutableMapping` que el contexto con el que se inicializó. Si se asigna un nuevo diccionario de señales, `flags` y `traps` son actualizados con los nuevos valores, pero no hacen referencia al diccionario RHS.

- Decapar a `Context` produce una salida diferente para tener un formato de intercambio común para las versiones de Python y C.

- El orden de los argumentos en el constructor de la clase `Context`, ha sido cambiado para que coincida con el orden mostrado por la función `repr()`.

- El parámetro `watchexp` en el método `quantize()` ha quedado obsoleto.

### email

#### Marco de políticas

El paquete de correo electrónico ahora tiene un marco `policy`. Un `Policy` es un objeto con varios métodos y propiedades que controlan el comportamiento del paquete de correo electrónico. La política principal de Python 3.3 es la política `Compat32`, que proporciona compatibilidad con versiones anteriores del paquete de correo electrónico en Python 3.2. Se puede especificar una `policy` cuando un mensaje de correo electrónico es analizado por un `parser`, o cuando se crea un objeto `Message`, o cuando se serializa un correo electrónico mediante un `generator`. A menos que se invalide, una política pasada a un `parser` es heredada por todos los objetos `Message` y los subobjetos creados por el `parser`. De forma predeterminada, un `generator` utilizará la política del objeto `Message` que está serializando. La directiva predeterminada es `compat32`.

El conjunto mínimo de controles implementado por todos los objetos `policy` son:

> max_line_length | La longitud máxima, excluyendo el(los) caracter(es) linesep, que las líneas individuales pueden tener cuando un `Message` se serializa es por defecto de 78.
> linesep | El caracter usado para separar las líneas individuales cuando se serializa un `Message` es por defecto `\n`.
> cte_type | `7bit` or `8bit`. `8bit` sólo se aplica a un `Bytes` `generator`, y significa que pueden utilizarse «no ASCII» cuando lo permita el protocolo (o cuando exista en la entrada original).
> raise_on_defect | Hace que un “”analizador”” genere el error cuando se encuentran defectos en lugar de agregarlos a la lista “”Mensaje”” del objeto “”defectos””.

Una nueva instancia de directiva, con nueva configuración, se crea mediante el método `clone()` de objetos de política. `clone` toma cualquiera de los controles anteriores como argumentos de palabra clave. Cualquier control no especificado en la llamada conserva su valor predeterminado. Por lo tanto, puede crear una directiva que utilice caracteres linesep `\r\n` como este:

    mypolicy = compat32.clone(linesep='\r\n')

Las directivas pueden ser usadas para facilitar la generación de mensajes en el formato requerido por la aplicación. En vez de tener que recordar especificar linesep=”rn”` en todos los lugares en donde llamas a `generator`, puedes especificarlo una sola vez cuando estableces la política usada por el `analizador` o el `Mensaje`, el que tu programa utilice para crear los objetos `Mensaje`. Por otra parte, si necesitas generar mensajes en múltiples formas, aún puedes especificar los parámetros en la llamada al generador apropiado. O puedes tener instancias de política personalizadas para tus distintos casos, y pasarlos al crear el `generator`.

#### Política provisional con nueva API de encabezado

Aunque el marco de políticas vale la pena por sí solo, la principal motivación para presentarlo es permitir la creación de nuevas políticas que implementen nuevas características para el paquete de correo electrónico, de modo que mantenga la compatibilidad con versiones anteriores para aquellos quienes no usen las nuevas directivas. Dado que las nuevas políticas introducen una nueva API, estamos lanzándolas en Python 3.3 como una provisional policy. Pueden producirse cambios incompatibles con versiones anteriores (hasta la eliminación del código) si los desarrolladores principales lo consideran necesario.

Las nuevas directivas son instancias de `EmailPolicy`, y agregan los siguientes controles adicionales:

> refold_source | Controla si los encabezados analizados por un `parser` son replegados por `generator`. Éste puede ser `none`, `long`, o `all`. El valor por defecto es `long`, lo que significa que los encabezados principales con una linea más larga que `max_line_length` se repliegan. `none` significa que no se repliega ninguna linea, y `all` significa que todas las lineas son replegadas.
> header_factory | Un invocable que toma un `` nombre “” y un `` valor “” y produce un objeto de encabezado personalizado.

El `header_factory` es la clave a las nuevas características proporcionadas por las nuevas directivas. Cuando se usa una de las nuevas directivas, cualquier encabezado retornado por un objeto `Message` es un objeto producido por el `header_factory`, y en cualquier momento que se establece un encabezado en un `Message`, éste se convierte en un objeto producido por `header_factory`. Todos éstos objetos de encabezado tienen un atributo `name` igual al nombre del encabezado. Los encabezados de direcciones y fechas tienen atributos adicionales que te dan acceso a los datos analizados del encabezado. Ésto significa que ahora puedes hacer cosas como ésta:

    >>> m = Message(policy=SMTP)
    >>> m['To'] = 'Éric <foo@example.com>'
    >>> m['to']
    'Éric <foo@example.com>'
    >>> m['to'].addresses
    (Address(display_name='Éric', username='foo', domain='example.com'),)
    >>> m['to'].addresses[0].username
    'foo'
    >>> m['to'].addresses[0].display_name
    'Éric'
    >>> m['Date'] = email.utils.localtime()
    >>> m['Date'].datetime
    datetime.datetime(2012, 5, 25, 21, 39, 24, 465484, tzinfo=datetime.timezone(datetime.timedelta(-1, 72000), 'EDT'))
    >>> m['Date']
    'Fri, 25 May 2012 21:44:27 -0400'
    >>> print(m)
    To: =?utf-8?q?=C3=89ric?= <foo@example.com>
    Date: Fri, 25 May 2012 21:44:27 -0400

Notarás que el nombre de visualización Unicode se codifica automáticamente como `utf-8` cuando se serializa el mensaje, pero que cuando se accede al encabezado directamente, obtienes la versión unicode. Ésto elimina cualquier necesidad de lidiar con las funciones `email.header` `decode_header()` or `make_header()`.

También puedes crear direcciones a partir de partes:

    >>> m['cc'] = [Group('pals', [Address('Bob', 'bob', 'example.com'),
    ...                           Address('Sally', 'sally', 'example.com')]),
    ...            Address('Bonzo', addr_spec='bonz@laugh.com')]
    >>> print(m)
    To: =?utf-8?q?=C3=89ric?= <foo@example.com>
    Date: Fri, 25 May 2012 21:44:27 -0400
    cc: pals: Bob <bob@example.com>, Sally <sally@example.com>;, Bonzo <bonz@laugh.com>

La decodificación a Unicode se realiza automáticamente:

    >>> m2 = message_from_string(str(m))
    >>> m2['to']
    'Éric <foo@example.com>'

Cuando analizas un mensaje, puedes usar los atributos `addresses` y `groups` de los objetos de encabezado, para acceder a los grupos y direcciones individuales:

    >>> m2['cc'].addresses
    (Address(display_name='Bob', username='bob', domain='example.com'), Address(display_name='Sally', username='sally', domain='example.com'), Address(display_name='Bonzo', username='bonz', domain='laugh.com'))
    >>> m2['cc'].groups
    (Group(display_name='pals', addresses=(Address(display_name='Bob', username='bob', domain='example.com'), Address(display_name='Sally', username='sally', domain='example.com')), Group(display_name=None, addresses=(Address(display_name='Bonzo', username='bonz', domain='laugh.com'),))

En resumen, si usas una de las nuevas directivas, la manipulación de encabezados funciona del modo que debería: Su aplicación funciona con cadenas unicode, y el paquete de correo electrónico codifica y decodifica de forma transparente el unicode desde y hacia las codificaciones de transferencia de contenido estándar RFC.

#### Otros cambios en la API

Nuevo `BytesHeaderParser`, añadido al módulo `parser` para complementar `HeaderParser` y completar la API Bytes.

Nuevas funciones de utilidad:

> - `format_datetime()`: given a `datetime`, produce a string formatted for use in an email header.

> - `email.utils.parsedate_to_datetime()`: dada una cadena de fecha de un encabezado de correo electrónico, conviértela en un `datetime.datetime`, o un ingenuo `datetime.datetime` si el desplazamiento es `-0000`.

> - `localtime()`: With no argument, returns the current local time as an aware `datetime` using the local `timezone`. Given an aware `datetime`, converts it into an aware `datetime` using the local `timezone`.

### ftplib

- `ftplib.FTP` ahora acepta un argumento de palabra clave `source_address` para especificar el `(host, port)` que se usará como dirección de origen en la llamada de enlace al crear el socket saliente. (Contribución de Giampaolo Rodolà en bpo-8594.)

- La clase `FTP_TLS` ahora proporciona una nueva función `ccc()` para revertir el canal de control a texto sin formato. Esto puede ser útil para aprovechar los firewalls que saben cómo manejar NAT con FTP no seguro sin abrir puertos fijos. (Contribución de Giampaolo Rodolà en bpo-12139.)

- Añadido el método `ftplib.FTP.mlsd()` que proporciona un formato de listado de directorios analizable y pone en desuso `ftplib.FTP.nlst()` y `ftplib.FTP.dir()`. (Contribución de Giampaolo Rodolà en bpo-11072.)

### functools

El decorador `functools.lru_cache()` ahora acepta un argumento de palabra clave `typed` (que por defecto tiene el valor `False` para asegurar que almacene en caché valores de diferentes tipos que se comparen igual en ranuras separadas de caché. (Contribución de Raymond Hettinger en bpo-13227.)

### gc

Ahora es posible registrar devoluciones de llamadas invocadas por el recolector de basura antes y después de la recolección, utilizando la nueva lista `callbacks`.

### hmac

Se ha agregado una nueva función `compare_digest()` para prevenir los ataques de canales adyacentes en resúmenes durante el análisis de tiempos. (Contribución de Nick Coghlan y Christian Heimes en bpo-15061.)

### http

`http.server.BaseHTTPRequestHandler` ahora almacena en buffer los encabezados y los escribe todos a la vez cuando se llama a `end_headers()`. Se puede usar un nuevo método `flush_headers()` para administrar directamente cuándo se envían los encabezados acumulados. (Contribución por Andrew Schaaf en bpo-3709.)

`http.server` ahora produce una salida `HTML 4.01 strict` válida. (Contribución de Ezio Melotti in bpo-13295)

La clase `http.client.HTTPResponse` ahora tiene un método `readinto()`, lo que significa que puede ser usado como una clase `io.RawIOBase`. (Contribución de John Kuhn in bpo-13464)

### html

`html.parser.HTMLParser` ahora puede analizar el marcado no válido sin generar errores, por lo tanto, el argumento strict del constructor y la excepción `HTMLParseError` ahora están en desuso. La habilidad de analizar marcado inválido es el resultado de un número de correcciones que también están disponibles en la última versión de solución de bugs de Python 2.7/3.2. (Contribución de Ezio Melotti en bpo-15114, y bpo-14538, bpo-13993, bpo-13960, bpo-13358, bpo-1745761, bpo-755670, bpo-13357, bpo-12629, bpo-1200313, bpo-670664, bpo-13273, bpo-12888, bpo-7311.)

Se ha agregado un nuevo diccionario `html5` que asigna referencias de caracteres con nombre HTML5 a los caracteres Unicode equivalentes (por ejemplo, `html5['gt;'] == '>'`) ha sido agregado al módulo `html.entities`. El diccionario ahora también es utilizado por `HTMLParser`. (Contribución por Ezio Melotti en bpo-11113 y bpo-15156.)

### imaplib

El constructor de `IMAP4_SSL` ahora acepta un parámetro SSLContext para controlar los parámetros del canal seguro.

(Contribución de Sijin Joseph en bpo-8808.)

### inspect

Se ha añadido una nueva función `getclosurevars()`. Esta función notifica el enlace actual de todos los nombres a los que se hace referencia desde el cuerpo de la función y dónde se resolvieron esos nombres, lo que facilita la comprobación del estado interno correcto al probar el código que se basa en cierres con estado.

(Contribución de Meador Inge y Nick Coghlan en bpo-13062.)

Se ha añadido una nueva función `getgeneratorlocals()`. Esta función informa del enlace actual de variables locales en el marco de pila del generador, lo que facilita la comprobación del estado interno correcto al probar generadores.

(Contribución de Meador Inge en bpo-15153.)

### io

La función `open()` tiene un nuevo modo `'x'` que puede ser usado exclusivamente para crear un nuevo archivo, y lanzar un `FileExistsError` si el archivo ya existe. Este está basado en el modo C11 “x” para fopen().

(Contribución de David Townsend en bpo-12760.)

El constructor de la clase `TextIOWrapper` tiene un nuevo argumento opcional write_through. Si write_through es `True`, se garantiza que las llamadas a `write()` no se almacenarán en buffer: Cualquier dato escrito en el objeto `TextIOWrapper` es llevado inmediatamente a su buffer subyacente.

### itertools

`accumulate()` ahora toma un argumento opcional `func` para proporcionar una función binaria proporcionada por el usuario.

### logging

La función `basicConfig()` ahora admite un argumento opcional `handlers` tomando un iterable de manejadores para agregarlo en el registrador raíz.

Un atributo de nivel de la clase `append_nul` ha sido agregado a la clase `SysLogHandler` para permitir el control de la adición de `NUL` (`\000`) byte a los registros de syslog, dado que para algunos demonios es requerido mientras que para otros se pasa al registro.

### math

El módulo `math` tiene una nueva función, `log2()`, la cual retorna el logaritmo de x en base 2.

(Escrito por Mark Dickinson en bpo-11888.)

### mmap

El método `read()` ahora es más compatible con otros objetos similares a archivos: Si se omite el argumento o se especifica como `None`, retorna los bytes desde la posición actual hasta el final del mapeo. (Contribución de Petri Lehtinen en bpo-12021.)

### multiprocesamiento

La nueva función `multiprocessing.connection.wait()` permite sondear varios objetos (como conexiones, sockets y tuberías) con un tiempo de espera. (Contribución de Richard Oudkerk en bpo-12328.)

Los objetos `multiprocessing.Connection` ahora se pueden transferir a través de conexiones de multiprocesamiento. (Contribución de Richard Oudkerk en bpo-4892.)

`multiprocessing.Process` ahora acepta un argumento de palabra clave `daemon` para invalidar el comportamiento predeterminado de heredar el indicador `daemon` del proceso primario (bpo-6064).

Nuevo atributo `multiprocessing.Process.sentinel` permite que un programa espere múltiples objetos `Process` a la vez utilizando las primitivas adecuadas del sistema operativo (por ejemplo, `select` en sistemas posix).

Los nuevos métodos `multiprocessing.pool.Pool.starmap()` y `starmap_async()` proporcionan `itertools.starmap()` equivalentes a las funciones existentes `multiprocessing.pool.Pool.map()` y `map_async()`. (Contribución de Hynek Schlawack en bpo-12708.)

### nntplib

La `nntplib.NNTP` ahora admite el protocolo de administración de contexto para consumir incondicionalmente las excepciones `socket.error` y cerrar la conexión NNTP cuando esté listo:

    >>> from nntplib import NNTP
    >>> with NNTP('news.gmane.org') as n:
    ...     n.group('gmane.comp.python.committers')
    ...
    ('211 1755 1 1755 gmane.comp.python.committers', 1755, 1, 1755, 'gmane.comp.python.committers')
    >>>

(Contribución de Giampaolo Rodolà en bpo-9795.)

### os

- El módulo `os` tiene una nueva función `pipe2()` que hace posible crear una tubería con banderas `O_CLOEXEC` o `O_NONBLOCK` establecida automáticamente. Esto es especialmente útil para evitar las condiciones de carrera en programas multi-hilos.

- El módulo `os` tiene una nueva función `sendfile()` que proporciona una forma eficiente de «copia cero» para copiar datos desde un descriptor de archivo (o socket) a otro. La frase «copia cero» se refiere al hecho de que la copia de los datos entre dos descriptores es realizada en su totalidad por el kernel, sin copiar los datos en los búferes del espacio de usuario. La función `sendfile()` puede ser usada para copiar datos de forma eficiente desde un archivo en el disco a un conector de red, por ejemplo para descargar un archivo.

  (Revisión enviada por Ross Lagerwall y Giampaolo Rodolà en bpo-10882.)

- Para evitar las condiciones de carrera, como los ataques symlink, y errores con archivos temporales y directorios, es preferible (y más rápido) manipular los descriptores de archivos en vez de los nombres de archivos. Python 3.3 mejora las funciones existentes e introduce nuevas funciones para trabajar con los descriptores de archivos (bpo-4761, bpo-10755 and bpo-14626).

  - El módulo `os` tiene una nueva función `fwalk()` similar a `walk()` excepto que también incluye descriptores de archivos que se refieren a los directorios visitados. Esto es especialmente útil para prevenir las carreras de enlaces simbólicos.

  - Las siguientes funciones tienen las nuevas opciones dir_fd (rutas relativas a descriptores de archivos) y/o follow_symlinks (not following symlinks): `access()`, `chflags()`, `chmod()`, `chown()`, `link()`, `lstat()`, `mkdir()`, `mkfifo()`, `mknod()`, `open()`, `readlink()`, `remove()`, `rename()`, `replace()`, `rmdir()`, `stat()`, `symlink()`, `unlink()`, `utime()`. El soporte de la plataforma para usar éstos parámetros puede verificarse a través de los conjuntos `os.supports_dir_fd` and `os.supports_follows_symlinks`.

  - Las siguientes funciones ahora admiten un descriptor de archivos para su argumento de ruta: `chdir()`, `chmod()`, `chown()`, `execve()`, `listdir()`, `pathconf()`, `exists()`, `stat()`, `statvfs()`, `utime()`. El soporte de la plataforma para ésto puede ser verificado a través del conjunto `os.supports_fd`.

- `access()` acepta un argumento de palabra clave `effective_ids` acepta el uso del uid/gid efectivo en lugar del uid/gid real en la comprobación de acceso. El soporte de la plataforma para ésto, se puede comprobar a través del conjunto `supports_effective_ids`.

- El módulo `os` tiene dos nuevas funciones `getpriority()` y `setpriority()`. Estas pueden ser usadas para establecer o recuperar la prioridad en una forma similar a `os.nice()` pero extendidos a todos los procesos en vez de solo al proceso actual.

  (Revisión enviada por Giampaolo Rodolà en bpo-10784.)

- La nueva función `os.replace()` permite cambiar el nombre de un archivo entre plataformas sobrescribiendo el destino. Con `os.rename()`, un archivo de destino existente se sobrescribe bajo POSIX, pero lanza un error en Windows. (Contribución de Antoine Pitrou en bpo-8828.)

- La familia de estadísticas de funciones (`stat()`, `fstat()`, y `lstat()`) ahora admite la lectura de marcas de tiempo de un archivo con precisión de nanosegundos. Simétricamente, `utime()` ahora puede escribir marcas de tiempo de archivos con precisión de nanosegundos. (Contribución de Larry Hastings en bpo-14127.)

- La nueva función `os.get_terminal_size()` consulta el tamaño del terminal adjunto al descriptor del archivo. Vea también `shutil.get_terminal_size()`. (Contribución de Zbigniew Jędrzejewski-Szmek en bpo-13609. )

- Nuevas funciones para admitir atributos extendidos de Linux. (bpo-12720): `getxattr()`, `listxattr()`, `removexattr()`, `setxattr()`.

- Nueva interfaz para el planificador. Estas funciones controlan como el sistema operativo le asigna tiempo de CPU a un proceso. Nuevas funciones: `sched_get_priority_max()`, `sched_get_priority_min()`, `sched_getaffinity()`, `sched_getparam()`, `sched_getscheduler()`, `sched_rr_get_interval()`, `sched_setaffinity()`, `sched_setparam()`, `sched_setscheduler()`, `sched_yield()`,

- Nuevas funciones para controlar el sistema de archivos:

  - `posix_fadvise()`: Anuncia una intención de acceder a los datos en un patrón específico, permitiendo al kernel hacer optimizaciones.

  - `posix_fallocate()`: Garantiza que se asigne el espacio suficiente a un archivo.

  - `sync()`: Fuerza la escritura de cualquier cosa en el disco.

- Nuevas funciones posix adicionales:

  - `lockf()`: Aplicar, probar o eliminar un bloqueo POSIX en un descriptor de archivo abierto.

  - `pread()`: Leer desde un descriptor de archivo en un desplazamiento, el desplazamiento del archivo permanece sin cambios.

  - `pwrite()`: Escribe en un descriptor de archivo desde un desplazamiento, dejando el desplazamiento del archivo sin cambios.

  - `readv()`: Leer desde el descriptor de un archivo en varios búferes editables.

  - `truncate()`: Truncar el archivo correspondiente a path, para que tenga como máximo length bytes de tamaño.

  - `waitid()`: Espera que se completen uno o más procesos secundarios.

  - `writev()`: Escribir los contenidos de buffers a un archivo descriptor, donde buffers es una secuencia arbitraria de buffers.

  - `getgrouplist()` (bpo-9344): Retorna una lista de ids de grupo al que pertenece el usuario especificado.

- `times()` and `uname()`: El tipo de retorno cambió de tupla a un objeto tipo tupla con atributos con nombre.

- Varias plataformas admiten constantes adicionales para la función `lseek()`, tal como `os.SEEK_HOLE` y `os.SEEK_DATA`.

- Nuevas constantes `RTLD_LAZY`, `RTLD_NOW`, `RTLD_GLOBAL`, `RTLD_LOCAL`, `RTLD_NODELETE`, `RTLD_NOLOAD`, and `RTLD_DEEPBIND` están disponibles en plataformas que las soporten. Éstas son para uso con la función `sys.setdlopenflags()`, y reemplazan las constantes similares definidas en `ctypes` and `DLFCN`. (Contribución de Victor Stinner en bpo-13226.)

- `os.symlink()` ahora acepta (e ignora) el argumento de palabra clave``target_is_directory`` en plataformas diferentes a windows, para facilitar el soporte multiplataforma.

### pdb

La finalización de tabulaciones ahora está disponible no solo para los nombres de los comandos, sino también para sus argumentos. Por ejemplo, para el comando `break`, se completan las funciones y los nombres de archivo.

(Contribución de Georg Brandl en bpo-14210)

### pickle

Los objetos `pickle.Pickler` ahora tienen un atributo opcional `dispatch_table` que permite establecer funciones de reducción por recolector.

(Contribución de Richard Oudkerk in bpo-14166.)

### pydoc

La Tk GUI y la función `serve()` han sido eliminadas del módulo `pydoc`: `pydoc -g` y `serve()` han quedado obsoletos en Python 3.2.

### re

Las expresiones regulares de la clase `str` ahora admiten escapes de `\u` and `\U` .

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

### sched

- `run()` ahora acepta un parámetro blocking que al configurarse en false, hace que el método ejecute los eventos planificados debido a la pronta expiración (si corresponde) y luego responde inmediatamente. Esto es útil en caso de que quieras usar la `scheduler` en aplicaciones sin bloqueo. (Contribución de Giampaolo Rodolà in bpo-13449.)

- La clase `scheduler` ahora se puede utilizar de forma segura en entornos multiproceso. (Contribución por Josiah Carlson y Giampaolo Rodolà en bpo-8684.)

- Los parámetros timefunc y delayfunct del constructor de la clase `scheduler` ahora son opcionales y tienen el valor predeterminado `time.time()` y `time.sleep()` respectivamente. (Contribución de Chris Clark en bpo-13245.)

- El parámetro argument de `enter()` and `enterabs()` ahora es opcional. (Contribución de Chris Clark en bpo-13245.)

- `enter()` y `enterabs()` ahora aceptan un parámetro kwargs. (Contribución de Chris Clark en bpo-13245.)

### select

Solaris y plataformas derivadas tienen una nueva clase `select.devpoll` para sockets asincrónicos de alto rendimiento a través de `/dev/poll`. (Contribución de Jesús Cea Avión en bpo-6397.)

### shlex

La función auxiliar previamente indocumentada `quote` de los módulos `pipes` se ha movido al módulo `shlex` y se ha documentado. `quote()` escapa correctamente a todos los caracteres de una cadena que de otro modo podría tener un significado especial por el shell.

### shutil

- Nuevas funciones:

  - `disk_usage()`: Proporciona estadísticas sobre el espacio total, usado, y libre en el disco. (Contribución de Giampaolo Rodolà in bpo-12442.)

  - `chown()`: Permite cambiar el usuario y/o grupo de las rutas dadas, además de especificar los nombres de usuario/grupo, y no solos sus id’s numèricos. (Contribución de Sandro Tosi in bpo-12191.)

  - `shutil.get_terminal_size()`: Retorna el tamaño de la ventana del terminar a la cual se adjunta el intérprete. (Contribución de Zbigniew Jędrzejewski-Szmek in bpo-13609. )

- `copy2()` and `copystat()` ahora conservan las marcas de tiempo de archivos con precisión de nanosegundos en plataformas que lo soporten. También conservan los «atributos extendidos» de archivo en Linux (Contribución de Larry Hastings en bpo-14127 y bpo-15238.)

- Algunas funciones ahora toman un argumento opcional de `symlinks`: Cuando ese parámetro es verdadero, los enlaces simbólicos no se desreferencian y la operación actúa en el enlace simbólico en sí. (o crea uno, si es relevante). (Contribución de Hynek Schlawack in bpo-12715.)

- Al copiar archivos a un sistema de archivos diferente, `move()` ahora gestiona los enlaces simbólicos de la forma que lo hace el comando `mv` de posix, recreando el enlace simbólico en vez de copiar el contenido del archivo de destino. (Contribución de Jonathan Niehof en bpo-9993.) `move()` ahora también retorna el argumento `dst` como resultado.

- `rmtree()` ahora es resistente a los ataques de enlaces simbólicos en plataformas que admiten el nuevo parámetro `dir_fd` en `os.open()` y `os.unlink()`. (Contribución de Martin von Löwis and Hynek Schlawack in bpo-4489.)

### signal

- El módulo `signal` tiene nuevas funciones:

  - `pthread_sigmask()`: busca y/o cambia la máscara de señal del hilo de llamada (Contribución de Jean-Paul Calderone in bpo-8407);

  - `pthread_kill()`: Envía una señal a un hilo;

  - `sigpending()`: Examina funciones pendientes;

  - `sigwait()`: Espera una señal;

  - `sigwaitinfo()`: Espera una señal, retornando información detallada sobre ella;

  - `sigtimedwait()`: Es similar a `sigwaitinfo()` pero con un tiempo de espera.

- El manejador de señales escribe el número de señal, como un único byte en vez de un byte nulo en el descriptor del archivo de activación. Por lo tanto, es posible esperar más de una señal y saber cuales señales han sido lanzadas.

- `signal.signal()` y `signal.siginterrupt()` lanzan un OSError, en vez de un RuntimeError: OSError no tiene atributo errno.

### smtpd

El módulo `smtpd` ahora admite RFC 5321 (SMTP extendido) y RFC 1870 (Ampliación de tamaño). Por lo general, éstas extensiones están habilitadas si y solo si el cliente inicia la sesión con un comando `EHLO`.

Soporte inicial de `` ELHO “” de Alberto Treviño. Ampliación de tamaño por Juhana Jauhiainen. Trabajo adicional sustancial en la revisión aportada por Michele Orrù y Dan Boswell. bpo-8739)

### smtplib

Las clases `SMTP`, `SMTP_SSL`, y `LMTP` ahora aceptan un argumento de palabra clave `source_address`, para especificar el `(host, port)` a usar como dirección de origen en la llamada de enlace al crear el socket saliente. (Contribución de Paulo Scardine en bpo-11281.)

`SMTP` ahora admite el protocolo de administración de contexto, permitiendo usar a una instancia `SMTP` en una declaración `with`. (Contribución de Giampaolo Rodolà en bpo-11289.)

El constructor `SMTP_SSL` y el método `starttls()` ahora aceptan un parámetro SSLContext, para controlar los parámetros del canal seguro. (Contribución por Kasun Herath en bpo-8809.)

### socket

- La clase `socket` ahora expone métodos adicionales para procesar datos auxiliares cuando sean compatibles con la plataforma subyacente:

  - `sendmsg()`

  - `recvmsg()`

  - `recvmsg_into()`

  (Contribución de David Watson en bpo-6560, basado en una revisión anterior de Heiko Wundram)

- La clase `socket` ahora admite la familia del protocolo PF_CAN (https://en.wikipedia.org/wiki/Socketcan), en Linux (https://lwn.net/Articles/253425).

  (Contribución de Matthias Fuchs, actualizado por Tiago Gonçalves en bpo-10141.)

- La clase `socket` ahora admite la familia del protocolo PF_RDS (https://en.wikipedia.org/wiki/Reliable_Datagram_Sockets and https://oss.oracle.com/projects/rds/).

- La clase `socket` ahora admite la familia del protocolo `PF_SYSTEM` en OS X. (Contribución de Michael Goderbauer en bpo-13777.)

- New function `sethostname()` allows the hostname to be set on Unix systems if the calling process has sufficient privileges. (Contributed by Ross Lagerwall in bpo-10866.)

### socketserver

`BaseServer` ahora tiene un método reemplazable `service_actions()` que es llamado por el método `serve_forever()` en el ciclo del servicio. `ForkingMixIn` ahora usa ésto para limpiar procesos secundarios zombies. (Contribución de Justin Warkentin en bpo-11109.)

### sqlite3

Nuevo método `sqlite3.Connection` `set_trace_callback()` puede ser usado para capturar un rastro de todos los comandos sql procesados por sqlite. (Contribución de Torsten Landschoff en bpo-11688.)

### ssl

- El módulo `ssl` tiene dos funciones de generación aleatoria:

  - `RAND_bytes()`: genera bytes pseudo-aleatorios criptográficamente fuertes.

  - `RAND_pseudo_bytes()`: genera bytes pseudoaleatorios.

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

- El módulo `ssl` ahora expone una jerarquía de excepciones más detallada para facilitar la inspección de varias clases de errores. (Contribución de Antoine Pitrou en bpo-11183.)

- `load_cert_chain()` ahora acepta un argumento password que será usado si la clave privada es encriptada. (Contribución de Adam Simpkins en bpo-12803.)

- El intercambio de claves Diffie-Hellman, tanto regular como basado en curvas elípticas, ahora se admite a través de los métodos `load_dh_params()` y `set_ecdh_curve()`. (Contribución de Antoine Pitrou en bpo-13626 y bpo-13627.)

- Los sockets SSL tienen un nuevo método `get_channel_binding()` que permite la implementación de ciertos mecanismos de autenticación tales como SCRAM-SHA-1-PLUS. (Contribución por Jacek Konieczny en bpo-12551.)

- Puedes consultar el algoritmo de compresión SSL usado por un socket SSL, gracias a su nuevo método `compression()`. El nuevo atributo `OP_NO_COMPRESSION` puede ser usado para deshabilitar la compresión. (Contribución de Antoine Pitrou en bpo-13634.)

- Se ha agregado soporte para la extensión Next Protocol Negotiation usando el método `ssl.SSLContext.set_npn_protocols()`. (Contribución por Colin Marc en bpo-14204.)

- Los errores de SSL ahora pueden introspectarse más fácilmente gracias a los atributos `library` y `reason`. (Contribución de Antoine Pitrou en bpo-14837.)

- La función `get_server_certificate()` ahora admite IPv6. (Contribución por Charles-François Natali en bpo-11811.)

- El nuevo atributo `OP_CIPHER_SERVER_PREFERENCE` permite configurar los sockets del servidor SSLv3 para usar la preferencia de ordenación de cifrado del servidor en lugar de la del cliente. (bpo-13635).

### stat

La función indocumentada tarfile.filemode ha sido movida a `stat.filemode()`. Este puede ser usado para convertir el modo de un archivo a una cadena de la forma “-rwxrwxrwx”.

(Contribución de Giampaolo Rodolà in bpo-14807.)

### struct

El módulo `struct` ahora admite `ssize_t` y `size_t` a través de los nuevos códigos `n` and `N`, respectivamente. (Contribución de Antoine Pitrou en bpo-3163.)

### subprocess

Las cadenas de comandos ahora pueden ser objetos de bytes en las plataformas posix. (Contribución de Victor Stinner in bpo-8513.)

Una nueva constante `DEVNULL` permite suprimir la salida de forma independiente de la plataforma. (Contribución de Ross Lagerwall en bpo-5870.)

### sys

El módulo `sys` tiene un nuevo `thread_info` named tuple que almacena información sobre la implementación del hilo (bpo-11223).

### tarfile

`tarfile` ahora admite la codificación `lzma` a través del módulo `lzma`. (Contribución de Lars Gustäbel en bpo-5689.)

### tempfile

El método `tempfile.SpooledTemporaryFile`'s `truncate()` ahora acepta un parámetro `size`. (Contribución de Ryan Kelly en bpo-9957.)

### textwrap

El módulo `textwrap` tiene una nueva función `indent()` que facilita la adición de un prefijo común para las lineas seleccionadas en un bloque de texto (bpo-13857).

### threading

`threading.Condition`, `threading.Semaphore`, `threading.BoundedSemaphore`, `threading.Event`, y `threading.Timer`, todas las cuales son usadas para ser funciones de fábrica que retornen una instancia de clase, ahora son clases y pueden ser subclasificadas (Contribución de Éric Araujo in bpo-10968.)

El constructor de la clase `threading.Thread` ahora acepta un argumento de palabra clave `daemon` para anular el comportamiento predeterminado de heredar el valor del indicador `daemon` desde el hilo principal (bpo-6064).

La función anteriormente privada `_thread.get_ident` ahora está disponible como función pública `threading.get_ident()`. Ésto elimina varios casos de acceso directo al módulo `_thread` en el stdlib. El código de terceros que usaba `_thread.get_ident` debería de igual forma ser cambiado para usar la nueva interfaz pública.

### time

El PEP 418 agrega nuevas funciones al módulo `time`:

- `get_clock_info()`: Obtiene información en un reloj.

- `monotonic()`: Reloj monotónico (no se puede retroceder), no se ve afectado por la actualización del reloj del sistema.

- `perf_counter()`: Contador de rendimiento con la más alta resolución disponible para medir una corta duración.

- `process_time()`: Suma del tiempo de CPU del sistema y del usuario del proceso actual.

Otras nuevas funciones:

- Las funciones `clock_getres()`, `clock_gettime()` y `clock_settime()` con constantes `CLOCK_xxx` (Contribución de Victor Stinner in bpo-10278.)

Para mejorar la consistencia entre plataformas, la función `sleep()` ahora lanza un `ValueError` cuando se le pasa un valor negativo. Esto era anteriormente un error en posix, pero producía una suspensión definitiva en windows.

### types

Adición de una nueva clase `types.MappingProxyType`: Proxy de solo lectura de una asignación. (bpo-14386)

Las nuevas funciones `types.new_class()` y `types.prepare_class()` proporcionan soporte para la creación de tipos dinámicos compatibles. (bpo-14588)

### unittest

Los métodos `assertRaises()`, `assertRaisesRegex()`, `assertWarns()`, y `assertWarnsRegex()` ahora aceptan un argumento de palabra clave msg cuando son usados como administradores de contexto. (Contribución por Ezio Melotti y Winston Ewert en bpo-10775.)

`unittest.TestCase.run()` ahora retorna el objeto `TestResult`.

### urllib

La clase `Request` ahora acepta un argumento method usado por `get_method()` para determinar que método HTTP debería usarse. Por ejemplo, esto enviará una solicitud `'HEAD'`:

    >>> urlopen(Request('https://www.python.org', method='HEAD'))

(bpo-1673007)

### webbrowser

El módulo `webbrowser` admite más «navegadores»: Google Chrome (llamado chrome, chromium, chrome-browser or chromium-browser dependiendo de la versión y del sistema operativo), y los lanzadores genéricos: programa: xdg-open, del proyecto FreeDesktop.org, y gvfs-open, el cual es el controlador URI predeterminado para GNOME3. (El primero agregado por Arnaud Calmettes en: issue:13620, el segundo por Matthias Klose en :issue:14493`.)

### xml.etree.ElementTree

El módulo `xml.etree.ElementTree` ahora importa su acelerador C predeterminado, ya no es necesario importar explícitamente `xml.etree.cElementTree` (Éste módulo permanece para compatibilidad con versiones anteriores, pero ya está obsoleto). Además, la familia de métodos `iter` de `Element` se ha optimizado (Reescrito en C). La documentación del módulo también se ha mejorado mucho, con ejemplos agregados y una referencia más detallada.

### zlib

New attribute `zlib.Decompress.eof` makes it possible to distinguish between a properly formed compressed stream and an incomplete or truncated one. (Contributed by Nadeem Vawda in bpo-12646.)

Nuevo atributo `zlib.ZLIB_RUNTIME_VERSION` informa la cadena de versión de la biblioteca `zlib` subyacente que se carga en tiempo de ejecución. (Contribución de Torsten Landschoff en bpo-12306.)

## Optimizaciones

Se han agregado importantes mejoras de rendimiento:

- Gracias a PEP 393, algunas operaciones en las cadenas Unicode han sido optimizadas:

  - la huella de memoria se divide de 2 a 4 según el texto

  - codificar una cadena ASCII a UTF-8 ya no necesita codificar caracteres, la representación UTF-8 se comparte con la representación ASCII

  - el codificador UTF-8 ha sido optimizado

  - repetir una única letra ASCII y obtener una subcadena de una cadena ASCII es 4 veces más rápido

- UTF-8 ahora es 2x a 4x más rápido. La codificación UTF-16 ahora es 10x más rápida.

  (Contribución de Serhiy Storchaka, bpo-14624, bpo-14738 y bpo-15026.)

## Construcción y cambios en la API de C

Los cambios en el proceso de compilación de Python y en la API de C incluyen:

- Nueva función relacionada con PEP 3118:

  - `PyMemoryView_FromMemory()`

- PEP 393 Agregó nuevos tipos unicode, macros y funciones:

  - API de alto nivel:

    - `PyUnicode_CopyCharacters()`

    - `PyUnicode_FindChar()`

    - `PyUnicode_GetLength()`, `PyUnicode_GET_LENGTH`

    - `PyUnicode_New()`

    - `PyUnicode_Substring()`

    - `PyUnicode_ReadChar()`, `PyUnicode_WriteChar()`

  - API de bajo nivel:

    - Tipos `Py_UCS1`, `Py_UCS2`, `Py_UCS4`

    - Estructuras `PyASCIIObject` y `PyCompactUnicodeObject`

    - `PyUnicode_READY`

    - `PyUnicode_FromKindAndData()`

    - `PyUnicode_AsUCS4()`, `PyUnicode_AsUCS4Copy()`

    - `PyUnicode_DATA`, `PyUnicode_1BYTE_DATA`, `PyUnicode_2BYTE_DATA`, `PyUnicode_4BYTE_DATA`

    - `PyUnicode_KIND` con `PyUnicode_Kind` enum: `PyUnicode_WCHAR_KIND`, `PyUnicode_1BYTE_KIND`, `PyUnicode_2BYTE_KIND`, `PyUnicode_4BYTE_KIND`

    - `PyUnicode_READ`, `PyUnicode_READ_CHAR`, `PyUnicode_WRITE`

    - `PyUnicode_MAX_CHAR_VALUE`

- `PyArg_ParseTuple` ahora acepta un `bytearray` para el formato `c` (bpo-12380).

## Obsoleto

### Sistemas operativos no compatibles

OS/2 y VMS no son compatibles debido a la falta de un responsable de mantenimiento.

Windows 2000 y las plataformas windows que establezcan `COMSPEC` a `command.com` ya no son compatibles debido a la carga de mantenimiento.

La compatibilidad con OSF, que quedó obsoleta en 3.2, ha sido completamente eliminada.

### Módulos , funciones y métodos obsoletos en Python

- Pasar una cadena no vacía a `object.__format__()` está descontinuado, y producirá un `TypeError` en Python 3.4 (bpo-9856).

- El códec `unicode_internal` quedó obsoleto a causa del PEP 393, use UTF-8, UTF-16 (`utf-16-le` o `utf-16-be`), o UTF-32 (`utf-32-le` or `utf-32-be`)

- `ftplib.FTP.nlst()` y `ftplib.FTP.dir()`: use `ftplib.FTP.mlsd()`

- `platform.popen()`: use el módulo `subprocess`. Verifique especialmente la sección Cómo reemplazar anteriores funciones con el módulo subprocess (bpo-11377).

- bpo-13374: La API de bytes de Windows ha sido descontinuada en el módulo `os`. Use nombres de archivo Unicode, en vez de nombres de archivo de bytes, para no depender más de la página de códigos ANSI y admitir cualquier nombre de archivo.

- bpo-13988: El módulo `xml.etree.cElementTree` ha quedado obsoleto. El acelerador se utiliza automáticamente siempre que esté disponible.

- El comportamiento de `time.clock()` depende de la plataforma: utilice la nueva función `time.perf_counter()` o `time.process_time()` en su lugar, dependiendo de sus requerimientos, para tener un comportamiento bien definido.

- La función `os.stat_float_times()` ha quedado obsoleta.

- `abc` module:

  - La clase `abc.abstractproperty` ha quedado obsoleta, en su lugar use la clase `property` con `abc.abstractmethod()`.

  - La clase `abc.abstractclassmethod` ha quedado obsoleta. En su lugar use el método `classmethod` with `abc.abstractmethod()`.

  - `abc.abstractstaticmethod` ha quedado obsoleta, use `staticmethod` with `abc.abstractmethod()`.

- paquete `importlib`:

  - `importlib.abc.SourceLoader.path_mtime()` ha quedado obsoleto, a favor de `importlib.abc.SourceLoader.path_stats()` ya que los archivos de código de bytes ahora almacenan tanto la hora de modificación como el tamaño del archivo fuente desde el cual se compiló el archivo de código de bytes.

### Funciones y tipos obsoletos en la API de C

El `Py_UNICODE` ha quedado obsoleto por PEP 393 y será eliminado en Python 4. Todas las funciones que utilizan éste tipo quedarán en desuso:

Unicode functions and methods using `Py_UNICODE` and `Py_UNICODE*` types:

- `PyUnicode_FromUnicode`: use `PyUnicode_FromWideChar()` o `PyUnicode_FromKindAndData()`

- `PyUnicode_AS_UNICODE`, `PyUnicode_AsUnicode()`, `PyUnicode_AsUnicodeAndSize()`: use `PyUnicode_AsWideCharString()`

- `PyUnicode_AS_DATA`: use `PyUnicode_DATA` con `PyUnicode_READ` y `PyUnicode_WRITE`

- `PyUnicode_GET_SIZE`, `PyUnicode_GetSize()`: use `PyUnicode_GET_LENGTH` o `PyUnicode_GetLength()`

- `PyUnicode_GET_DATA_SIZE`: use `PyUnicode_GET_LENGTH(str) * PyUnicode_KIND(str)` (sólo funciona en cadenas listas)

- `PyUnicode_AsUnicodeCopy()`: use `PyUnicode_AsUCS4Copy()` o `PyUnicode_AsWideCharString()`

- `PyUnicode_GetMax()`

Funciones y macros que manipulen cadenas de caracteres Py_UNICODE*:

- `Py_UNICODE_strlen`: use `PyUnicode_GetLength()` o `PyUnicode_GET_LENGTH`

- `Py_UNICODE_strcat`: use `PyUnicode_CopyCharacters()` o `PyUnicode_FromFormat()`

- `Py_UNICODE_strcpy`, `Py_UNICODE_strncpy`, `Py_UNICODE_COPY`: use `PyUnicode_CopyCharacters()` o `PyUnicode_Substring()`

- `Py_UNICODE_strcmp`: use `PyUnicode_Compare()`

- `Py_UNICODE_strncmp`: use `PyUnicode_Tailmatch()`

- `Py_UNICODE_strchr`, `Py_UNICODE_strrchr`: use `PyUnicode_FindChar()`

- `Py_UNICODE_FILL`: use `PyUnicode_Fill()`

- `Py_UNICODE_MATCH`

Codificadores:

- `PyUnicode_Encode()`: use `PyUnicode_AsEncodedObject()`

- `PyUnicode_EncodeUTF7()`

- `PyUnicode_EncodeUTF8()`: use `PyUnicode_AsUTF8()` o `PyUnicode_AsUTF8String()`

- `PyUnicode_EncodeUTF32()`

- `PyUnicode_EncodeUTF16()`

- `PyUnicode_EncodeUnicodeEscape()` use `PyUnicode_AsUnicodeEscapeString()`

- `PyUnicode_EncodeRawUnicodeEscape()` use `PyUnicode_AsRawUnicodeEscapeString()`

- `PyUnicode_EncodeLatin1()`: use `PyUnicode_AsLatin1String()`

- `PyUnicode_EncodeASCII()`: use `PyUnicode_AsASCIIString()`

- `PyUnicode_EncodeCharmap()`

- `PyUnicode_TranslateCharmap()`

- `PyUnicode_EncodeMBCS()`: use `PyUnicode_AsMBCSString()` o `PyUnicode_EncodeCodePage()` (con `CP_ACP` code_page)

- `PyUnicode_EncodeDecimal()`, `PyUnicode_TransformDecimalToASCII()`

### Características obsoletas

El código del formato `'u'` del módulo `array` ha quedado obsoleto y será eliminado en Python 4, junto con el resto de la API (`Py_UNICODE`).

## Migración a Python 3.3

Esta sección enumera los cambios descritos previamente y otras correcciones que pueden requerir cambios en su código.

### Portando código Python

- La aleatoriedad de Hash ha sido habilitada de forma predeterminada. Establezca la variable de entorno `PYTHONHASHSEED` a 0, para deshabilitar la aleatoriedad de Hash. Vea también el método `object.__hash__()` method.

- bpo-12326: En Linux, sys.platform ya no contiene la versión principal. Ahora siempre es “linux”, en vez de “linux2” o “linux3” dependiendo de la versión de Linux usada para compilar Python. Reemplace sys.platform == “linux2” con sys.platform.startswith(“linux”), o directamente sys.platform == “linux” si no necesita admitir versiones anteriores de Python.

- bpo-13847, bpo-14180: `time` y `datetime`: `OverflowError` ahora se lanza en lugar de `ValueError` si una marca de tiempo está fuera de rango. `OSError` ahora se genera si fallaron las funciones C `gmtime()` o `localtime()`.

- Los buscadores predeterminados usados para las importaciones, ahora utilizan un caché de lo que está contenido en un directorio específico. Si crea un archivo fuente de Python o archivo de código de bytes sin fuente, asegúrese de llamar a `importlib.invalidate_caches()` para limpiar la caché para que los buscadores encuentren el nuevo archivo.

- `ImportError` ahora usa el nombre completo del módulo que se intentó importar. Las pruebas de documentos que verifican el mensaje de “ImportErrors” necesitaran ser actualizados para usar el nombre completo del módulo en vez de sólo la terminación del nombre.

- El argumento index para la función `__import__()` ahora tiene un valor predeterminado de 0, en vez de -1, y ya no admite valores negativos. Ha sido un descuido en la implementación de PEP 328 que el valor predeterminado permaneciera en -1. Si necesita continuar realizando una importación relativa seguida por una importación absoluta, entonces realice la importación relativa usando un índice de 1, seguida por otra importación que use un índice de 0. Sin embargo, es preferible usar `importlib.import_module()` en vez de llamar a la función `__import__()` directamente.

- `__import__()` ya no admite usar un valor de índice distinto de 0 para los módulos de alto nivel. Por ejemplo, `__import__('sys', level=1)` ahora es un error.

- Dado que `sys.meta_path` y `sys.path_hooks` ahora tienen buscadores por defecto, lo más probable es que desee usar `list.insert()` en vez de `list.append()` para agregar a esas listas.

- Dado que `None` ahora ha sido insertado en `sys.path_importer_cache`, si usted está borrando entradas en el diccionario de rutas que no tienen un buscador, usted necesitará eliminar los pares con valores de `None` y `imp.NullImporter` para ser compatible con versiones anteriores. Esto conducirá a una sobrecarga adicional con las versiones más antiguas de Python que re-inserten `None` dentro de `sys.path_importer_cache` donde éste represente el uso de buscadores implícitos, pero semánticamente no debería cambiar nada.

- `importlib.abc.Finder` no longer specifies a `find_module()` abstract method that must be implemented. If you were relying on subclasses to implement that method, make sure to check for the method’s existence first. You will probably want to check for `find_loader()` first, though, in the case of working with path entry finders.

- `pkgutil` ha sido convertido para usar `importlib` internamente. Esto elimina varios casos extremos donde el antiguo comportamiento de la emulación de importación PEP 302 fallaba al comparar el comportamiento del sistema real de importación. La emulación de importación en sí aún está presente, pero está en desuso. Las funciones `pkgutil.iter_importers()` y `pkgutil.walk_packages()` en un caso especial son los ganchos de importación estándar, por lo que aún son compatibles aunque no proporcionen el método no estándar `iter_modules ()`.

- Se ha corregido un error de larga data de cumplimiento de RFC (bpo-1079) en el análisis realizado por `email.header.decode_header()`. El código que usa el lenguaje estándar para convertir encabezados codificados en unicode (`str (make_header (decode_header (h))`) no verá cambios, pero el código que mira las tuplas individuales retornadas por decode_header verá ese espacio en blanco que precede o sigue las secciones `ASCII` ahora está incluido en la sección `ASCII`. El código que crea encabezados usando `make_header` también debería continuar funcionando sin cambios, ya que `make_header` continúa agregando espacios en blanco entre `Secciones ASCII` y no `ASCII` si aún no está presente en las cadenas de caracteres entrantes.

- `email.utils.formataddr()` ahora realiza la codificación de transferencia de contenido correcta, al pasar nombres para mostrar que no son ASCII. Cualquier código que dependa del comportamiento defectuoso anterior que conservó el unicode que no es `ASCII` en la cadena de salida formateada deberá cambiarse (bpo-1690608).

- `poplib.POP3.quit()` ahora puede generar errores de protocolos como todos los demás métodos `poplib`. El código que asume que `quit` no genera errores `poplib.error_proto` puede necesitar ser cambiado si una aplicación en particular encuentran errores en `quit` (bpo-11291).

- El argumento `strict` para la clase `email.parser.Parser`, que quedó obsoleto desde Python 2.4, finalmente ha sido eliminado.

- El método `unittest.TestCase.assertSameElements` que estaba obsoleto, ha sido eliminado.

- La variable `time.accept2dyear` que estaba obsoleta, ha sido eliminada.

- El atributo `Context._clamp` que estaba obsoleto, ha sido eliminado del módulo `decimal`. Este se reemplazó anteriormente por el atributo público `clamp`. (Ver bpo-8540.)

- La clase interna auxiliar indocumentada `SSLFakeFile`, ha sido eliminada de `smtplib`, dado que su funcionalidad ha sido proporcionada directamente por `socket.socket.makefile()`.

- El paso de valores negativos a la función `time.sleep()` en Windows, ahora lanza un error en vez de detenerse definitivamente. Este siempre ha lanzado un error en posix.

- La constante `ast.__version__` ha sido eliminada. Si usted necesita tomar decisiones afectadas por la versión AST, use `sys.version_info` para tomar la decisión.

- El código que solía solucionar el hecho de que el módulo `threading` utilizaba funciones de fábrica mediante la subclase de las clases privadas tendrá que cambiar a la subclase de las clases ahora públicas.

- La indocumentada maquinaria de depuración en el módulo threading ha sido eliminada, simplificando el código. Esto no debería tener efecto en el código de producción, pero se menciona aquí en caso de que algún framework de depuración de aplicaciones interactúe con el (bpo-13550).

### Portando código C

- En el curso de cambios a la API del buffer la estructura indocumentada `smalltable` miembro de `Py_buffer` ha sido eliminada, y el diseño de `PyMemoryViewObject` se ha cambiado.

  Todas las extensiones que quedan en las partes relevantes de `memoryobject.h` o `object.h` deben ser reconstruídas.

- Debido a PEP 393, el tipo `Py_UNICODE` y todas las funciones que lo utilicen han quedado obsoletas (pero seguirán estando disponibles por al menos 5 años). Si usted estuvo usando APIS Unicode de bajo nivel para construir y acceder a objetos unicode, y desea beneficiarse de la reducción de huella de memoria proporcionada por PEP 393, usted debe convertir su código al nuevo Unicode API.

  Sin embargo, si sólo ha estado usando funciones de alto nivel como `PyUnicode_Concat()`, `PyUnicode_Join()` o `PyUnicode_FromFormat()`, automáticamente su código se beneficiará de las nuevas representaciones unicode.

- `PyImport_GetMagicNumber()` ahora retorna `-1` en caso de falla.

- Como valor negativo para el argumento level de la función `__import__()` ya no es válido, y lo mismo ahora es válido para la función `PyImport_ImportModuleLevel()`. Esto también significa que el valor de level usado por la función `PyImport_ImportModuleEx()` ahora es `0` en vez de `-1`.

### Construyendo extensiones C

- Se ha reducido el rango de nombres de archivo posibles para las extensiones C. Muy raramente se han suprimido las ortografías utilizadas: en POSIX, los archivos denominados `xxxmodule.so`, `xxxmodule.abi3.so` y `xxxmodule.cpython-*.so` ya no se reconocen como la implementación del módulo `xxx`. Si ha estado generando estos archivos, tiene que cambiar a las otras ortografías (es decir, eliminar la cadena de caracteres `módulo` de los nombres de archivo).

  (implementado en bpo-14040.)

### Cambios en el conmutador de línea de comandos

- Se han quitado el indicador de línea de comandos -Q y los artefactos relacionados. La comprobación de código sys.flags.division_warning tendrá que actualizar.

  (bpo-10998, contribución de Éric Araujo.)

- Cuando se inicia python con `-S`, `import site` ya no agregará las rutas específicas de sitio al módulo de búsqueda de rutas. En las versiones anteriores si lo hacía.

  (bpo-11591, contribución de Carl Meyer con ediciones de Éric Araujo.)