Contenido de la documentación de Python
***************************************

* Qué hay de nuevo en Python

  * Qué hay de nuevo en Python 3.11

    * Resumen -- Aspectos destacados de la versión

    * Nuevas características

      * PEP 657: Ubicaciones de errores detallados en rastreos

      * PEP 654: Grupos de excepción y "except*"

      * PEP 678: Las excepciones se pueden enriquecer con notas

      * Mejoras en el iniciador de Windows "py.exe"

    * Nuevas funciones relacionadas con las sugerencias de tipo

      * PEP 646: Genéricos Variádicos

      * PEP 655: Marcado de elementos "TypedDict" individuales como
        requeridos o no requeridos

      * PEP 673: tipo "Self"

      * PEP 675: tipo de cadena literal arbitraria

      * PEP 681: Transformaciones de clases de datos

      * PEP 563 puede no ser el futuro

    * Otros cambios de idioma

    * Otros cambios en la implementación de CPython

    * Nuevos Módulos

    * Módulos mejorados

      * asíncio

      * contextlib

      * clases de datos

      * fecha y hora

      * enumeración

      * fcntl

      * fracciones

      * herramientas funcionales

      * gzip

      * hashlib

      * IDLE y libre de inactividad

      * inspeccionar

      * lugar

      * Inicio sesión

      * Matemáticas

      * operador

      * sistema operativo

      * rutalib

      * re

      * cerrar

      * enchufe

      * sqlite3

      * cuerda

      * sistema

      * configuración del sistema

      * archivo temporal

      * enhebrar

      * tiempo

      * tkinter

      * rastrear

      * mecanografía

      * unicodedata

      * prueba de unidad

      * venv

      * advertencias

      * archivo zip

    * Optimizaciones

    * CPython más rápido

      * Inicio más rápido

        * Importaciones congeladas / Objetos de código estático

      * Tiempo de ejecución más rápido

        * Marcos de Python más baratos y perezosos

        * Llamadas a funciones de Python en línea

        * PEP 659: Intérprete Adaptativo Especializado

      * Varios

      * Preguntas más frecuentes

        * How should I write my code to utilize these speedups?

        * Will CPython 3.11 use more memory?

        * I don't see any speedups in my workload. Why?

        * Is there a JIT compiler?

      * Sobre

    * Cambios en el código de bytes de CPython

      * Nuevos códigos de operación

      * Códigos de operación reemplazados

      * Códigos de operación cambiados/eliminados

    * Obsoleto

      * Idioma/Construidos

      * Módulos

      * Biblioteca estándar

    * Eliminación pendiente en Python 3.12

    * Remoto

    * Migración a Python 3.11

    * Construir cambios

    * Cambios en la API de C

      * Nuevas características

      * Migración a Python 3.11

      * Obsoleto

      * Eliminación pendiente en Python 3.12

      * Remoto

    * Notable Changes in 3.11.4

      * tarfile

    * Notable Changes in 3.11.5

      * OpenSSL

    * Notable changes in 3.11.10

      * ipaddress

      * email

    * Notable changes in 3.11.13

      * os.path

      * tarfile

  * Qué hay de nuevo en Python 3.10

    * Resumen: aspectos destacados de la versión

    * Nuevas características

      * Administradores de contexto entre paréntesis

      * Mejores mensajes de error

        * SyntaxErrors

        * Errores de sangría

        * AttributeErrors

        * NameErrors

      * PEP 626: números de línea precisos para depuración y otras
        herramientas

      * PEP 634: Coincidencia de patrones estructurales

        * Sintaxis y operaciones

        * Enfoque declarativo

        * Patrón simple: coincidir con un literal

          * Comportamiento sin el comodín

        * Patrones con un literal y una variable

        * Patrones y clases

          * Patrones con parámetros posicionales

        * Patrones anidados

        * Patrones complejos y el comodín

        * Guardia

        * Otras características clave

      * Opción opcional "EncodingWarning" y "encoding="locale""

    * Nuevas funciones relacionadas con las sugerencias de tipos

      * PEP 604: Nuevo tipo de operador unión

      * PEP 612: Variables de especificación de parámetros

      * PEP 613: TypeAlias

      * PEP 647: protectores de tipo definidos por el usuario

    * Otros cambios de idioma

    * Nuevos módulos

    * Módulos mejorados

      * asyncio

      * argumentar

      * formación

      * asynchat, asyncore, smtpd

      * base64

      * bdb

      * bisecar

      * códecs

      * colecciones.abc

      * contextlib

      * maldiciones

      * clases de datos

        * __slots__

        * Campos solo de palabras clave

      * distutils

      * doctest

      * codificaciones

      * enum

      * entrada de archivo

      * manipulador de faltas

      * GC

      * glob

      * hashlib

      * hmac

      * IDLE e idlelib

      * importlib.metadata

      * inspeccionar

      * itertools

      * caché de línea

      * os

      * os.path

      * Pathlib

      * plataforma

      * pprint

      * py_compile

      * pyclbr

      * dejar de lado

      * Estadísticas

      * sitio

      * enchufe

      * ssl

      * sqlite3

      * sys

      * _hilo

      * enhebrar

      * rastrear

      * tipos

      * mecanografía

      * prueba de unidad

      * urllib.parse

      * xml

      * zipimport

    * Optimizaciones

    * Obsoleto

    * Eliminado

    * Portar a Python 3.10

      * Cambios en la sintaxis de Python

      * Cambios en la API de Python

      * Cambios en la API de C

    * Cambios en el código de bytes de CPython

    * Construir cambios

    * Cambios en la API de C

      * PEP 652: Mantenimiento del ABI estable

      * Nuevas características

      * Portar a Python 3.10

      * Obsoleto

      * Eliminado

    * Notable security feature in 3.10.7

    * Notable security feature in 3.10.8

    * Notable changes in 3.10.12

      * tarfile

  * Qué hay de nuevo en Python 3.9

    * Resumen: aspectos destacados de la versión

    * Debe verificar DeprecationWarning en su código

    * Nuevas características

      * Operadores de combinación y actualización de diccionarios

      * Nuevos métodos de cadena para eliminar prefijos y sufijos

      * Tipos genéricos de sugerencia en colecciones estándar

      * Nuevo analizador

    * Otros cambios de idioma

    * Nuevos módulos

      * zoneinfo

      * Graphlib

    * Módulos mejorados

      * ast

      * asyncio

      * compilar todo

      * Futuros concurrentes

      * maldiciones

      * fecha y hora

      * distutils

      * fcntl

      * ftplib

      * GC

      * hashlib

      * http

      * IDLE e idlelib

      * imaplib

      * importlib

      * inspeccionar

      * dirección IP

      * Matemáticas

      * multiprocesamiento

      * nntplib

      * os

      * Pathlib

      * pdb

      * poplib

      * pprint

      * Pydoc

      * aleatorio

      * señal

      * smtplib

      * enchufe

      * tiempo

      * sys

      * tracemalloc

      * mecanografía

      * unicodedata

      * venv

      * xml

    * Optimizaciones

    * Obsoleto

    * Remoto

    * Portar a Python 3.9

      * Cambios en la API de Python

      * Cambios en la API de C

      * Cambios en el código de bytes de CPython

    * Construir cambios

    * Cambios en la API de C

      * Nuevas características

      * Portar a Python 3.9

      * Remoto

    * Cambios notables en Python 3.9.1

      * mecanografía

      * Compatibilidad con macOS 11.0 (Big Sur) y Apple Silicon Mac

    * Cambios notables en Python 3.9.2

      * colecciones.abc

      * urllib.parse

    * Notable changes in Python 3.9.3

    * Notable changes in Python 3.9.5

      * urllib.parse

    * Notable security feature in 3.9.14

    * Notable changes in 3.9.17

      * tarfile

  * Qué hay de nuevo en Python 3.8

    * Resumen -- Aspectos destacados de la versión

    * Nuevas características

      * Expresiones de asignación

      * Parámetros solo posicionales

      * Caché del sistema de archivos paralelo para archivos de
        bytecode compilados

      * La compilación de depuración usa la misma ABI que la
        compilación de lanzamiento

      * los f-strings soportan "=" para expresiones autodocumentadas y
        depuración

      * PEP 578: Ganchos de auditoría en tiempo de ejecución de Python

      * PEP 587: Configuración de inicialización de Python

      * PEP 590: Vectorcall: un protocolo de llamada rápida para
        CPython

      * Protocolo 5 de Pickle con búferes de datos fuera de banda

    * Otros cambios en el lenguaje

    * Nuevos módulos

    * Módulos mejorados

      * ast

      * asyncio

      * builtins

      * collections

      * cProfile

      * csv

      * curses

      * ctypes

      * datetime

      * functools

      * gc

      * gettext

      * gzip

      * IDLE e idlelib

      * inspect

      * io

      * itertools

      * json.tool

      * logging

      * math

      * mmap

      * multiprocessing

      * os

      * os.path

      * pathlib

      * pickle

      * plistlib

      * pprint

      * py_compile

      * shlex

      * shutil

      * socket

      * ssl

      * statistics

      * sys

      * tarfile

      * threading

      * tokenize

      * tkinter

      * time

      * typing

      * unicodedata

      * unittest

      * venv

      * weakref

      * xml

      * xmlrpc

    * Optimizaciones

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

    * Obsoleto

    * APIs y características eliminadas

    * Portando a Python 3.8

      * Cambios en el comportamiento de Python

      * Cambios en la API de Python

      * Cambios en la API de C

      * Cambios en el bytecode de CPython

      * Demos y herramientas

    * Cambios notables en Python 3.8.1

    * Notable changes in Python 3.8.2

    * Notable changes in Python 3.8.3

    * Cambios notables en Python 3.8.8

    * Notable changes in Python 3.8.9

    * Notable changes in Python 3.8.10

      * macOS 11.0 (Big Sur) and Apple Silicon Mac support

    * Notable changes in Python 3.8.10

      * urllib.parse

    * Cambios notables en Python 3.8.1

      * Cambios en la API de Python

    * Notable security feature in 3.8.14

    * Notable changes in 3.8.17

      * tarfile

  * Qué hay de nuevo en Python 3.7

    * Resumen -- Lanzamientos Destacados

    * Nuevas Características

      * PEP 563: Evaluación pospuesta de anotaciones

      * PEP 538: Coerción de configuración regional del Legado de  C

      * PEP 540: Modo de tiempo de ejecución UTF-8 forzado

      * PEP 553: Incorporada en "breakpoint()"

      * PEP 539: Nueva API C para almacenamiento local de subprocesos

      * PEP 562: Personalización del acceso a los atributos del módulo

      * PEP 564: Nuevas funciones de tiempo con resolución de
        nanosegundos

      * PEP 565: Mostrar *DeprecationWarning* en "__main__"

      * PEP 560: Soporte básico para el módulo de "typing" y tipos
        genéricos

      * PEP 552: Archivos .pyc basados en hash

      * PEP 545: Traducciones de Documentaciones de Python

      * Modo de desarrollo de Python (-X dev)

    * Otros cambios en el lenguaje

    * Nuevos módulos

      * *contextvars*

      * *dataclasses*

      * *importlib.resources*

    * Módulos mejorados

      * *argparse*

      * *asyncio*

      * *binascii*

      * *calendar*

      * *collections*

      * *compileall*

      * *concurrent.futures*

      * *contextlib*

      * *cProfile*

      * *crypt*

      * *datetime*

      * *dbm*

      * *decimal*

      * *dis*

      * *distutils*

      * *enum*

      * *functools*

      * *gc*

      * *hmac*

      * *http.client*

      * *http.server*

      * *idlelib and IDLE*

      * *importlib*

      * *io*

      * *ipaddress*

      * *itertools*

      * *locale*

      * *logging*

      * *math*

      * *mimetypes*

      * *msilib*

      * *multiprocessing*

      * *os*

      * *pathlib*

      * *pdb*

      * *py_compile*

      * *pydoc*

      * *queue*

      * *re*

      * *signal*

      * *socket*

      * *socketserver*

      * *sqlite3*

      * *ssl*

      * *string*

      * *subprocess*

      * *sys*

      * *time*

      * *tkinter*

      * *tracemalloc*

      * *types*

      * *unicodedata*

      * *unittest*

      * *unittest.mock*

      * *urllib.parse*

      * *uu*

      * *uuid*

      * *warnings*

      * xml

      * *xml.etree*

      * *xmlrpc.server*

      * *zipapp*

      * *zipfile*

    * Cambios en la API C

    * Construir cambios

    * Optimizaciones

    * Otros cambios de implementación de CPython

    * Comportamiento obsoleto de Python

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

      * *aifc*

      * *asyncio*

      * *collections*

      * *dbm*

      * *enum*

      * *gettext*

      * *importlib*

      * *locale*

      * *macpath*

      * *threading*

      * *socket*

      * *ssl*

      * *sunau*

      * *sys*

      * *wave*

    * Funciones y tipos obsoletos de la API C

    * Eliminación de soporte de plataforma

    * Eliminaciones de API y funciones

    * Eliminaciones de módulos

    * Cambios solo en Windows

    * Portando a Python 3.7

      * Cambios en el comportamiento de Python

      * Cambios en la API Python

      * Cambios en la API de C

      * Cambios en el código de bytes de CPython

      * Cambios solo en Windows

      * Otra implementación de cambios en CPython

    * Cambios notables en Python 3.7.1

    * Cambios notables en Python 3.7.2

    * Cambios notables en Python 3.7.6

    * Cambios notables en Python 3.7.10

    * Notable changes in Python 3.7.11

    * Notable security feature in 3.7.14

  * Qué hay de nuevo en Python 3.6

    * Resumen: aspectos destacados de la versión

    * Nuevas características

      * PEP 498: Literales de cadena formateados

      * PEP 526: Sintaxis para anotaciones de variables

      * PEP 515: subrayados en literales numéricos

      * PEP 525: Generadores asíncronos

      * PEP 530: Comprensiones asincrónicas

      * PEP 487: personalización más sencilla de la creación de clases

      * PEP 487: Mejoras en el protocolo descriptor

      * PEP 519: Agregar un protocolo de ruta del sistema de archivos

      * PEP 495: desambiguación de la hora local

      * PEP 529: cambie la codificación del sistema de archivos de
        Windows a UTF-8

      * PEP 528: cambie la codificación de la consola de Windows a
        UTF-8

      * PEP 520: Conservación del orden de definición de atributos de
        clase

      * PEP 468: Conservación del orden de los argumentos de las
        palabras clave

      * Nueva implementación de *dict*

      * PEP 523: Agregar una API de evaluación de marcos a CPython

      * Variable de entorno PYTHONMALLOC

      * Soporte de sondeo DTrace y SystemTap

    * Otros cambios de idioma

    * Nuevos módulos

      * misterios

    * Módulos mejorados

      * formación

      * ast

      * asyncio

      * binascii

      * cmath

      * colecciones

      * Futuros concurrentes

      * contextlib

      * fecha y hora

      * decimal

      * distutils

      * Email

      * codificaciones

      * enumeración

      * manipulador de faltas

      * entrada de archivo

      * hashlib

      * http.client

      * idlelib y IDLE

      * importlib

      * inspeccionar

      * json

      * Inicio sesión

      * Matemáticas

      * multiprocesamiento

      * os

      * Pathlib

      * pdb

      * pepinillo

      * pepinillos

      * Pydoc

      * aleatorio

      * re

      * readline

      * rlcompleter

      * shlex

      * sitio

      * sqlite3

      * enchufe

      * servidor de sockets

      * ssl

      * Estadísticas

      * estructura

      * subproceso

      * sys

      * telnetlib

      * tiempo

      * cronométralo

      * tkinter

      * rastrear

      * tracemalloc

      * mecanografía

      * unicodedata

      * unittest.mock

      * urllib.request

      * urllib.robotparser

      * venv

      * advertencias

      * winreg

      * winsonido

      * xmlrpc.client

      * archivo zip

      * zlib

    * Optimizaciones

    * Cambios en la API de Build y C

    * Otras mejoras

    * Obsoleto

      * Nuevas palabras clave

      * Comportamiento de Python obsoleto

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

        * asynchat

        * asyncore

        * dbm

        * distutils

        * grp

        * importlib

        * os

        * re

        * ssl

        * tkinter

        * venv

      * xml

      * Funciones y tipos obsoletos de la API de C

      * Opciones de compilación obsoletas

    * Remoto

      * Eliminaciones de API y funciones

    * Portar a Python 3.6

      * Cambios en el comportamiento del comando 'python'

      * Cambios en la API de Python

      * Cambios en la API de C

      * Cambios en el código de bytes de CPython

    * Cambios notables en Python 3.6.2

      * Nuevo objetivo de compilación "make regen-all"

      * Eliminación del objetivo de compilación "make touch"

    * Cambios notables en Python 3.6.4

    * Cambios notables en Python 3.6.5

    * Cambios notables en Python 3.6.7

    * Cambios notables en Python 3.6.10

    * Cambios notables en Python 3.6.13

    * Notable changes in Python 3.6.14

  * Qué hay de nuevo en Python 3.5

    * Resumen -- Aspectos destacados de la versión

    * Nuevas características

      * PEP 492 - Corrutinas con sintaxis async y await

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

      * PEP 448 - Generalizaciones de desembalaje adicionales

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

      * PEP 484 - Indicador de tipos

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

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

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

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

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

      * PEP 488: Eliminación de archivos PYO

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

    * Otros cambios en el lenguaje

    * Nuevos módulos

      * typing

      * zipapp

    * Módulos mejorados

      * argparse

      * asyncio

      * bz2

      * cgi

      * cmath

      * code

      * collections

      * collections.abc

      * compileall

      * concurrent.futures

      * configparser

      * contextlib

      * csv

      * curses

      * dbm

      * difflib

      * distutils

      * doctest

      * email

      * enum

      * faulthandler

      * functools

      * glob

      * gzip

      * heapq

      * http

      * http.client

      * idlelib e IDLE

      * imaplib

      * imghdr

      * importlib

      * inspect

      * io

      * ipaddress

      * json

      * linecache

      * locale

      * logging

      * lzma

      * math

      * multiprocessing

      * operator

      * os

      * pathlib

      * pickle

      * poplib

      * re

      * readline

      * selectors

      * shutil

      * signal

      * smtpd

      * smtplib

      * sndhdr

      * socket

      * ssl

        * Soporte de memoria BIO

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

        * Otros cambios

      * sqlite3

      * subprocess

      * sys

      * sysconfig

      * tarfile

      * threading

      * time

      * timeit

      * tkinter

      * traceback

      * types

      * unicodedata

      * unittest

      * unittest.mock

      * urllib

      * wsgiref

      * xmlrpc

      * xml.sax

      * zipfile

    * Otros cambios a nivel de módulo

    * Optimizaciones

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

    * Obsoleto

      * Nuevas palabras clave

      * Comportamiento obsoleto de Python

      * Sistemas operativos no compatibles

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

    * Eliminado

      * APIs y características eliminadas

    * Portando a Python 3.5

      * Cambios en el comportamiento de Python

      * Cambios en la API de Python

      * Cambios en la API de C

    * Cambios notables en Python 3.5.4

      * Nuevo objetivo de compilación "make regen-all"

      * Eliminación del objetivo de compilación "make touch"

  * Qué hay de nuevo en Python 3.4

    * Resumen -- Puntos destacados del lanzamiento

    * Nuevas Funciones

      * PEP 453: Arranque explícito de PIP en instalaciones de Python

        * Puesta en marcha de pip por defecto

        * Cambios en la documentación

      * PEP 446: Los descriptores de archivos recién creados no son
        heredables

      * Mejoras en el manejo de códecs

      * PEP 451: Un tipo ModuleSpec para el sistema de importación

      * Otros cambios de lenguaje

    * Nuevos Módulos

      * asyncio

      * ensurepip

      * enum

      * pathlib

      * selectores

      * estadísticas

      * tracemalloc

    * Módulos mejorados

      * abc

      * aifc

      * argparse

      * audioop

      * base64

      * colecciones

      * colorsys

      * contextlib

      * dbm

      * dis

      * doctest

      * email

      * archivoecmp

      * functools

      * gc

      * glob

      * hashlib

      * hmac

      * html

      * http

      * idlelib y IDLE

      * importlib

      * inspeccionar

      * dirección IP

      * Tres mejoras más pequeñas en el módulo "logging", todas
        implementadas por Vinay Sajip, son:

      * mariscal

      * mmap

      * multiprocesamiento

      * *PEP 465*, un nuevo operador de multiplicación de matrices: "a
        @ b".

      * os

      * pdb

      * pepinillo

      * plistlib

      * poplib

      * pprint

      * pty

      * pydoc

      * re

      * recurso

      * seleccionar

      * estante

      * shutil

      * smtpd

      * smtplib

      * enchufe

      * sqlite3

      * ssl

      * stat

      * struct

      * subproceso

      * sunau

      * sys

      * tarfile

      * textwrap

      * roscado

      * traceback

      * tipos

      * urllib

      * unittest

      * venv

      * onda

      * weakref

      * xml.etree

      * archivo zip

    * Cambios en la implementación de CPython

      * PEP 445: Personalización de los Asignadores de Memoria de
        CPython

      * PEP 442: Finalización segura de objetos

      * PEP 456: Algoritmo Hash seguro e intercambiable

      * PEP 436: Clínica de Argumentación

      * Otros cambios en la API de construcción y C

      * Otras mejoras

      * Optimizaciones significativas

    * Obsoleto

      * Desapariciones en la API de Python

      * Funciones obsoletas

    * Removido

      * Sistemas operativos que ya no son compatibles

      * Eliminación de la API y de las funciones

      * Limpieza del código

    * Adaptación a Python 3.4

      * Cambios en el comportamiento del comando 'python'

      * Cambios en la API de Python

      * Cambios en la API de C

    * Cambiado en 3.4.3

      * PEP 476: Habilitar la verificación de certificados por defecto
        para los clientes http stdlib

  * Qué hay de nuevo en Python 3.3

    * Resumen -- Aspectos destacados de la versión

    * PEP 405: Entornos virtuales

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

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

      * Características

      * Cambios en la API

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

      * Funcionalidad

      * Rendimiento y uso de recursos

    * PEP 397: Lanzador de python para windows

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

    * PEP 380: Sintaxis para delegar en un subgenerador

    * PEP 409: Suprimir el contexto de excepción

    * PEP 414: Literales *Unicode* explícitos

    * PEP 3155: Nombres calificados para clases y funciones

    * PEP 412: Diccionario de intercambio de claves

    * PEP 362: Objeto de firma de función

    * PEP 421: Agregar sys.implementation

      * SimpleNamespace

    * Usar importlib como implementación de Import

      * Nuevas APIs

      * Cambios visibles

    * Otros cambios de idioma

    * Un bloqueo de importación más detallado

    * Funciones y tipos incorporados

    * Nuevos módulos

      * faulthandler

      * ipaddress

      * lzma

    * Módulos mejorados

      * abc

      * array

      * base64

      * binascii

      * bz2

      * códecs

      * colecciones

      * contextlib

      * crypt

      * curses

      * datetime

      * decimal

        * Características

        * Cambios en la API

      * email

        * Marco de políticas

        * Política provisional con nueva API de encabezado

        * Otros cambios en la API

      * ftplib

      * functools

      * gc

      * hmac

      * http

      * html

      * imaplib

      * inspect

      * io

      * itertools

      * logging

      * math

      * mmap

      * multiprocesamiento

      * nntplib

      * os

      * pdb

      * pickle

      * pydoc

      * re

      * sched

      * select

      * shlex

      * shutil

      * signal

      * smtpd

      * smtplib

      * socket

      * socketserver

      * sqlite3

      * ssl

      * stat

      * struct

      * subprocess

      * sys

      * tarfile

      * tempfile

      * textwrap

      * threading

      * time

      * types

      * unittest

      * urllib

      * webbrowser

      * xml.etree.ElementTree

      * zlib

    * Optimizaciones

    * Construcción y cambios en la API de C

    * Obsoleto

      * Sistemas operativos no compatibles

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

      * Funciones y tipos obsoletos en la API de C

      * Características obsoletas

    * Migración a Python 3.3

      * Portando código Python

      * Portando código C

      * Construyendo extensiones C

      * Cambios en el conmutador de línea de comandos

  * Qué hay de nuevo en Python 3.2

    * PEP 384: Definición de un ABI estable

    * PEP 389: Módulo de análisis sintáctico (*Parser*) de línea de
      comandos Argparse

    * PEP 391: Configuración basada en diccionario para Logging

    * PEP 3148: El módulo "concurrent.futures"

    * PEP 3147: Directorios del repositorio de PYC

    * PEP 3149: Archivos .so con etiquetado de versión para ABI

    * PEP 3333: Interfaz de puerta de enlace del servidor web Python
      v1.0.1

    * Otros cambios de lenguaje

    * Módulos nuevos, mejorados y obsoletos

      * email

      * elementtree

      * functools

      * itertools

      * collections

      * threading

      * datetime and time

      * math

      * abc

      * io

      * reprlib

      * logging

      * csv

      * contextlib

      * decimal and fractions

      * ftp

      * popen

      * select

      * gzip y zipfile

      * tarfile

      * hashlib

      * ast

      * os

      * shutil

      * sqlite3

      * html

      * socket

      * ssl

      * nntp

      * certificados

      * imaplib

      * http.client

      * unittest

      * random

      * poplib

      * asyncore

      * tempfile

      * inspect

      * pydoc

      * dis

      * dbm

      * ctypes

      * site

      * sysconfig

      * pdb

      * configparser

      * urllib.parse

      * mailbox

      * turtledemo

    * Multi-threading

    * Optimizations

    * Unicode

    * Codecs

    * Documentación

    * IDLE

    * Repositorio de código

    * Cambios en la API de construcción y C

    * Portar a Python 3.2

  * Qué hay de nuevo en Python 3.1

    * PEP 372: Diccionarios ordenados

    * PEP 378: Especificador de formato para el separador de miles

    * Otros cambios del lenguaje

    * Módulos nuevos, mejorados y obsoletos

    * Optimizaciones

    * IDLE

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

    * Portando a Python 3.1

  * Qué hay de nuevo en Python 3.0

    * Escollos comunes

      * *Print* es una función

      * Vistas e iteradores en lugar de listas

      * Comparaciones de ordenamiento

      * Enteros

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

    * Descripción general de los cambios de sintaxis

      * Nueva sintaxis

      * Sintaxis modificada

      * Sintaxis eliminada

    * Cambios ya presentes en Python 2.6

    * Cambios de biblioteca

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

    * Cambios a excepciones

    * Otros cambios diversos

      * Operadores y métodos especiales

      * Incorporados

    * Construcción y cambios a la API de C

    * Rendimiento

    * Migración a Python 3.0

  * Qué hay de nuevo en Python 2.7

    * El futuro de Python 2.x

    * Cambios en el manejo de las advertencias de desuso

    * Características de Python 3.1

    * PEP 372: Adición de un diccionario ordenado a las colecciones

    * PEP 378: Especificador de formato para separador de miles

    * PEP 389: El módulo argparse para el análisis de líneas de
      comando

    * PEP 391: Configuración basada en diccionarios para el registro

    * PEP 3106: Vistas de diccionario

    * PEP 3137: El objeto memoryview

    * Otros cambios de lenguaje

      * Cambios en el intérprete

      * Optimizaciones

    * Módulos nuevos y mejorados

      * Nuevo módulo: importlib

      * Nuevo módulo: sysconfig

      * ttk: Widgets temáticos para Tk

      * Módulo actualizado: unittest

      * Módulo actualizado: ElementTree 1.3

    * Cambios en la API de construcción y C

      * Cápsulas

      * Cambios específicos en los puertos: Windows

      * Cambios específicos en los puertos: Mac OS X

      * Cambios específicos en los puertos: FreeBSD

    * Otros cambios y correcciones

    * Adaptación a Python 2.7

    * Nuevas funciones añadidas a las versiones de mantenimiento de
      Python 2.7

      * Dos nuevas variables de entorno para el modo de depuración

      * PEP 434: Excepción de mejora de IDLE para todas las ramas

      * PEP 466: Mejoras en la seguridad de la red para Python 2.7

      * PEP 477: Backport ensurepip (PEP 453) a Python 2.7

        * Puesta en marcha de pip por defecto

        * Cambios en la documentación

      * PEP 476: Habilitar la verificación de certificados por defecto
        para los clientes http stdlib

      * PEP 493: Herramientas de migración de verificación HTTPS para
        Python 2.7

      * Nuevo objetivo de construcción "make regen-all"

      * Eliminación del objetivo de construcción "make touch"

    * Agradecimientos

  * Qué hay de nuevo en Python 2.6

    * Python 3.0

    * Cambios en el proceso de desarrollo

      * Nuevo seguidor de incidentes: Roundup

      * Nuevo formato de documentación: texto reestructurado con
        Sphinx

    * PEP 343: La sentencia *'with'*

      * Escribiendo gestores de contexto

      * El módulo contextlib

    * PEP 366: Importaciones relativas explícitas desde un módulo
      principal

    * PEP 370: Directorio de "site-packages" por usuario

    * PEP 371: El paquete "multiprocessing"

    * PEP 3101: Formateo avanzado de cadena de caracteres

    * PEP 3105: "print" como función

    * PEP 3110: Cambios en el manejo de excepciones

    * PEP 3112: Literales de bytes

    * PEP 3116: Nueva biblioteca de E/S

    * PEP 3118: Protocolo revisado de la memoria intermedia

    * PEP 3119: Clases base abstractas

    * PEP 3127: Soporte y sintaxis de literales enteros

    * PEP 3129: Decoradores de clase

    * PEP 3141: Una jerarquía de tipos para los números

      * El módulo "fractions"

    * Otros cambios lingüísticos

      * Optimizaciones

      * Cambios de intérprete

    * Módulos nuevos y mejorados

      * El módulo "ast"

      * El módulo "future_builtins"

      * El módulo "json": Notación de objetos de JavaScript

      * El módulo "plistlib": Un analizador de listas de propiedades

      * mejoras en ctypes

      * Mejora de la compatibilidad con SSL

    * Cancelaciones y eliminaciones

    * Cambios en la API de construcción y C

      * Cambios específicos en los puertos: Windows

      * Cambios específicos en los puertos: Mac OS X

      * Cambios específicos en los puertos: IRIX

    * Adaptación a Python 2.6

    * Agradecimientos

  * Qué hay de nuevo en Python 2.5

    * PEP 308: Expresiones condicionales

    * PEP 309: Aplicación parcial de funciones

    * PEP 314: Metadatos para paquetes de software Python v1.1

    * PEP 328: Importaciones absolutas y relativas

    * PEP 338: Ejecutando Módulos como Scripts

    * PEP 341: Try/except/finally unificados

    * PEP 342: Nuevas funciones del generador

    * PEP 343: La declaración "con

      * Redacción de Gestores de Contexto

      * El módulo contextlib

    * PEP 352: Las excepciones como clases de nuevo estilo

    * PEP 353: Uso de ssize_t como tipo de índice

    * PEP 357: El método '__index__'

    * Otros cambios lingüísticos

      * Cambios en el intérprete interactivo

      * Optimizaciones

    * Módulos nuevos, mejorados y eliminados

      * El paquete ctypes

      * El paquete ElementTree

      * El paquete hashlib

      * El paquete sqlite3

      * El paquete wsgiref

    * Cambios en la API de construcción y C

      * Cambios específicos en los puertos

    * Adaptación a Python 2.5

    * Agradecimientos

  * Qué hay de nuevo en Python 2.4

    * PEP 218: Objetos conjunto integrados

    * PEP 237: Unificando enteros largos y enteros

    * PEP 289: Expresiones generadoras

    * PEP 292: Sustituciones simples de cadenas de caracteres

    * PEP 318: Decoradores para funciones y métodos

    * PEP 322: Iteración inversa

    * PEP 324: Nuevo módulo de subproceso

    * PEP 327: Tipo de dato decimal

      * ¿Por qué se necesita Decimal?

      * El tipo de clase "Decimal"

      * El tipo de clase "Context"

    * PEP 328: Importaciones multilínea

    * PEP 331: Conversiones locales-independientes números
      flotantes/cadenas de texto

    * Otros cambios en el lenguaje

      * Optimizaciones

    * Módulos nuevos, mejorados y obsoletos

      * cookielib

      * doctest

    * Cambios en la API de Build y C

      * Cambios específicos del puerto

    * Portar a Python 2.4

    * Agradecimientos

  * Qué hay de nuevo en Python 2.3

    * PEP 218: Un tipo de datos de conjunto estándar

    * PEP 255: Generadores simples

    * PEP 263: Codificación del código fuente

    * PEP 273: Importar módulos desde archivos ZIP

    * PEP 277: Soporte de nombres de archivo Unicode para Windows NT

    * PEP 278: Soporte universal de nuevas líneas

    * PEP 279: enumerate()

    * PEP 282: El paquete de registro

    * PEP 285: Un tipo booleano

    * PEP 293: Llamadas de retorno para el manejo de errores del códec

    * PEP 301: Índice de paquetes y metadatos para Distutils

    * PEP 302: Nuevos ganchos de importación

    * PEP 305: Archivos separados por comas

    * PEP 307: Mejoras en Pickle

    * Rebanadas ampliadas

    * Otros cambios en el lenguaje

      * Cambios en las cadenas de texto

      * Optimizaciones

    * Módulos nuevos, mejorados y obsoletos

      * Tipo de fecha / hora

      * El módulo optparse

    * Pymalloc: un asignador de objetos especializado

    * Cambios en la API de Build y C

      * Cambios específicos del puerto

    * Otros cambios y correcciones

    * Portar a Python 2.3

    * Agradecimientos

  * Qué hay de nuevo en Python 2.2

    * Introducción

    * PEPs 252 y 253: Cambios de tipo y clase

      * Clases antiguas y nuevas

      * Descriptores

      * Herencia múltiple: la regla del diamante

      * Acceso a atributos

      * Enlaces relacionados

    * PEP 234: Iteradores

    * PEP 255: Generadores simples

    * PEP 237: Unificación de enteros largos y enteros

    * PEP 238: Cambio del operador de división

    * Cambios en Unicode

    * PEP 227: Ámbitos anidados

    * Módulos nuevos y mejorados

    * Cambios y correcciones en el intérprete

    * Otros cambios y correcciones

    * Agradecimientos

  * Qué hay de nuevo en Python 2.1

    * Introducción

    * PEP 227: Ámbitos anidados

    * PEP 236: Directivas __future__

    * PEP 207: Comparaciones Enriquecidas

    * PEP 230: Marco de advertencia

    * PEP 229: Sistema de construcción nuevo

    * PEP 205: Referencias débiles

    * PEP 232: Atributos de la función

    * PEP 235: Importación de módulos en plataformas que no distinguen
      entre mayúsculas y minúsculas

    * PEP 217: Gancho de pantalla interactivo

    * PEP 208: Nuevo modelo de coerción

    * PEP 241: Metadatos en paquetes de Python

    * Módulos nuevos y mejorados

    * Otros cambios y correcciones

    * Agradecimientos

  * Qué hay de nuevo en Python 2.0

    * Introducción

    * ¿Qué pasa con Python 1.6?

    * Nuevo proceso de desarrollo

    * Unicode

    * Comprensión de listas

    * Asignación aumentada

    * Métodos de cadena de caracteres

    * Recogida de basura de los ciclos

    * Otros cambios en el núcleo

      * Cambios menores del lenguaje

      * Cambios en las funciones incorporadas

    * Adaptación a la versión 2.0

    * Extensión/Incorporación de cambios

    * Distutils: Facilitando la instalación de módulos

    * Módulos XML

      * Soporte de SAX2

      * Soporte DOM

      * Relación con PyXML

    * Cambios en los módulos

    * Nuevos módulos

    * Mejoras en IDLE

    * Módulos eliminados y obsoletos

    * Agradecimientos

  * Registro de cambios

    * Python next

      * Build

    * Python 3.11.16 final

      * macOS

      * Tests

      * Security

      * Library

      * Build

    * Python 3.11.15 final

      * Security

      * Library

      * Core and Builtins

    * Python 3.11.14 final

      * Security

      * Library

    * Python 3.11.13 final

      * Security

      * Library

    * Python 3.11.12 final

      * Security

      * Library

      * Documentation

      * C API

    * Python 3.11.11 final

      * Tools/Demos

      * Tests

      * Security

      * Library

    * Python 3.11.10 final

      * Windows

      * Security

      * Library

      * Core and Builtins

    * Python 3.11.9 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.11.8 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

    * Python 3.11.7 final

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.11.6 final

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

    * Python 3.11.5 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.11.4 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

    * Python 3.11.3 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

    * Python 3.11.2 final

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.11.1 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.11.0 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

    * Python 3.11.0 release candidate 2

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

    * Python 3.11.0 release candidate 1

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * C API

    * Python 3.11.0 beta 5

      * Core and Builtins

      * Library

      * Tests

      * Build

      * Windows

      * C API

    * Python 3.11.0 beta 4

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

      * C API

    * Python 3.11.0 beta 3

      * Core and Builtins

      * Build

    * Python 3.11.0 beta 2

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * C API

    * Python 3.11.0 beta 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.11.0 alpha 7

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.11.0 alpha 6

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * C API

    * Python 3.11.0 alpha 5

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.11.0 alpha 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * C API

    * Python 3.11.0 alpha 3

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * C API

    * Python 3.11.0 alpha 2

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.11.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.10.0 beta 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.10.0 alpha 7

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * C API

    * Python 3.10.0 alpha 6

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.10.0 alpha 5

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.10.0 alpha 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * macOS

      * Tools/Demos

      * C API

    * Python 3.10.0 alpha 3

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.10.0 alpha 2

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.10.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.9.0 beta 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.9.0 alpha 6

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.9.0 alpha 5

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.9.0 alpha 4

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * C API

    * Python 3.9.0 alpha 3

      * Core and Builtins

      * Library

      * Documentation

      * Build

      * IDLE

      * C API

    * Python 3.9.0 alpha 2

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.9.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.8.0 beta 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.8.0 alpha 4

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.8.0 alpha 3

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.8.0 alpha 2

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Windows

      * IDLE

    * Python 3.8.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.7.0 final

      * Library

      * C API

    * Python 3.7.0 release candidate 1

      * Core and Builtins

      * Library

      * Documentation

      * Build

      * Windows

      * IDLE

    * Python 3.7.0 beta 5

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * macOS

      * IDLE

    * Python 3.7.0 beta 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

    * Python 3.7.0 beta 3

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.7.0 beta 2

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

    * Python 3.7.0 beta 1

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * C API

    * Python 3.7.0 alpha 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Windows

      * Tools/Demos

      * C API

    * Python 3.7.0 alpha 3

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.7.0 alpha 2

      * Core and Builtins

      * Library

      * Documentation

      * Build

      * IDLE

      * C API

    * Python 3.7.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.6.6 final

    * Python 3.6.6 release candidate 1

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.6.5 final

      * Tests

      * Build

    * Python 3.6.5 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.6.4 final

    * Python 3.6.4 release candidate 1

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.6.3 final

      * Library

      * Build

    * Python 3.6.3 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * Tools/Demos

    * Python 3.6.2 final

    * Python 3.6.2 release candidate 2

      * Security

    * Python 3.6.2 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * C API

      * Build

      * Documentation

      * Tools/Demos

      * Tests

      * Windows

    * Python 3.6.1 final

      * Core and Builtins

      * Build

    * Python 3.6.1 release candidate 1

      * Core and Builtins

      * Library

      * IDLE

      * Windows

      * C API

      * Documentation

      * Tests

      * Build

    * Python 3.6.0 final

    * Python 3.6.0 release candidate 2

      * Core and Builtins

      * Tools/Demos

      * Windows

      * Build

    * Python 3.6.0 release candidate 1

      * Core and Builtins

      * Library

      * C API

      * Documentation

      * Tools/Demos

    * Python 3.6.0 beta 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

    * Python 3.6.0 beta 3

      * Core and Builtins

      * Library

      * Windows

      * Build

      * Tests

    * Python 3.6.0 beta 2

      * Core and Builtins

      * Library

      * Windows

      * C API

      * Build

      * Tests

    * Python 3.6.0 beta 1

      * Core and Builtins

      * Library

      * IDLE

      * C API

      * Tests

      * Build

      * Tools/Demos

      * Windows

    * Python 3.6.0 alpha 4

      * Core and Builtins

      * Library

      * IDLE

      * Tests

      * Windows

      * Build

    * Python 3.6.0 alpha 3

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * C API

      * Build

      * Tools/Demos

      * Documentation

      * Tests

    * Python 3.6.0 alpha 2

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

      * Windows

      * Build

      * C API

      * Tools/Demos

    * Python 3.6.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

      * C API

    * Python 3.5.5 final

    * Python 3.5.5 release candidate 1

      * Security

      * Core and Builtins

      * Library

    * Python 3.5.4 final

      * Library

    * Python 3.5.4 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * C API

    * Python 3.5.3 final

    * Python 3.5.3 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * C API

      * Documentation

      * Tests

      * Tools/Demos

      * Windows

      * Build

    * Python 3.5.2 final

      * Core and Builtins

      * Tests

      * IDLE

    * Python 3.5.2 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

    * Python 3.5.1 final

      * Core and Builtins

      * Windows

    * Python 3.5.1 release candidate 1

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

    * Python 3.5.0 final

      * Build

    * Python 3.5.0 release candidate 4

      * Library

      * Build

    * Python 3.5.0 release candidate 3

      * Core and Builtins

      * Library

    * Python 3.5.0 release candidate 2

      * Core and Builtins

      * Library

    * Python 3.5.0 release candidate 1

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

    * Python 3.5.0 beta 4

      * Core and Builtins

      * Library

      * Build

    * Python 3.5.0 beta 3

      * Core and Builtins

      * Library

      * Tests

      * Documentation

      * Build

    * Python 3.5.0 beta 2

      * Core and Builtins

      * Library

    * Python 3.5.0 beta 1

      * Core and Builtins

      * Library

      * IDLE

      * Tests

      * Documentation

      * Tools/Demos

    * Python 3.5.0 alpha 4

      * Core and Builtins

      * Library

      * Build

      * Tests

      * Tools/Demos

      * C API

    * Python 3.5.0 alpha 3

      * Core and Builtins

      * Library

      * Build

      * Tests

      * Tools/Demos

    * Python 3.5.0 alpha 2

      * Core and Builtins

      * Library

      * Build

      * C API

      * Windows

    * Python 3.5.0 alpha 1

      * Core and Builtins

      * Library

      * IDLE

      * Build

      * C API

      * Documentation

      * Tests

      * Tools/Demos

      * Windows

* El tutorial de Python

  * 1. Abriendo el apetito

  * 2. Usando el intérprete de Python

    * 2.1. Invocar el intérprete

      * 2.1.1. Paso de argumentos

      * 2.1.2. Modo interactivo

    * 2.2. El intérprete y su entorno

      * 2.2.1. Codificación del código fuente

  * 3. Una introducción informal a Python

    * 3.1. Usando Python como una calculadora

      * 3.1.1. Números

      * 3.1.2. Text

      * 3.1.3. Listas

    * 3.2. Primeros pasos hacia la programación

  * 4. Más herramientas para control de flujo

    * 4.1. La sentencia "if"

    * 4.2. La sentencia "for"

    * 4.3. La función "range()"

    * 4.4. Las sentencias "break", "continue", y "else" en bucles

    * 4.5. La sentencia "pass"

    * 4.6. La sentencia "match"

    * 4.7. Definir funciones

    * 4.8. Más sobre definición de funciones

      * 4.8.1. Argumentos con valores por omisión

      * 4.8.2. Palabras claves como argumentos

      * 4.8.3. Parámetros especiales

        * 4.8.3.1. Argumentos posicionales o de palabras claves

        * 4.8.3.2. Parámetros únicamente posicionales

        * 4.8.3.3. Argumentos únicamente de palabras clave

        * 4.8.3.4. Ejemplos de Funciones

        * 4.8.3.5. Resumen

      * 4.8.4. Listas de argumentos arbitrarios

      * 4.8.5. Desempaquetando una lista de argumentos

      * 4.8.6. Expresiones lambda

      * 4.8.7. Cadenas de texto de documentación

      * 4.8.8. Anotación de funciones

    * 4.9. Intermezzo: Estilo de programación

  * 5. Estructuras de datos

    * 5.1. Más sobre listas

      * 5.1.1. Usar listas como pilas

      * 5.1.2. Usar listas como colas

      * 5.1.3. Comprensión de listas

      * 5.1.4. Listas por comprensión anidadas

    * 5.2. La instrucción "del"

    * 5.3. Tuplas y secuencias

    * 5.4. Conjuntos

    * 5.5. Diccionarios

    * 5.6. Técnicas de iteración

    * 5.7. Más acerca de condiciones

    * 5.8. Comparando secuencias y otros tipos

  * 6. Módulos

    * 6.1. Más sobre los módulos

      * 6.1.1. Ejecutar módulos como scripts

      * 6.1.2. El camino de búsqueda de los módulos

      * 6.1.3. Archivos "compilados" de Python

    * 6.2. Módulos estándar

    * 6.3. La función "dir()"

    * 6.4. Paquetes

      * 6.4.1. Importar * desde un paquete

      * 6.4.2. Referencias internas en paquetes

      * 6.4.3. Paquetes en múltiples directorios

  * 7. Entrada y salida

    * 7.1. Formateo elegante de la salida

      * 7.1.1. Formatear cadenas literales

      * 7.1.2. El método format() de cadenas

      * 7.1.3. Formateo manual de cadenas

      * 7.1.4. Viejo formateo de cadenas

    * 7.2. Leyendo y escribiendo archivos

      * 7.2.1. Métodos de los objetos Archivo

      * 7.2.2. Guardar datos estructurados con "json"

  * 8. Errores y excepciones

    * 8.1. Errores de sintaxis

    * 8.2. Excepciones

    * 8.3. Gestionando excepciones

    * 8.4. Lanzando excepciones

    * 8.5. Encadenamiento de excepciones

    * 8.6. Excepciones definidas por el usuario

    * 8.7. Definiendo acciones de limpieza

    * 8.8. Acciones predefinidas de limpieza

    * 8.9. Lanzando y gestionando múltiples excepciones no
      relacionadas

    * 8.10. Enriqueciendo excepciones con notas

  * 9. Clases

    * 9.1. Unas palabras sobre nombres y objetos

    * 9.2. Ámbitos y espacios de nombres en Python

      * 9.2.1. Ejemplo de ámbitos y espacios de nombre

    * 9.3. Un primer vistazo a las clases

      * 9.3.1. Sintaxis de definición de clases

      * 9.3.2. Objetos clase

      * 9.3.3. Objetos instancia

      * 9.3.4. Objetos método

      * 9.3.5. Variables de clase y de instancia

    * 9.4. Algunas observaciones

    * 9.5. Herencia

      * 9.5.1. Herencia múltiple

    * 9.6. Variables privadas

    * 9.7. Cambalache

    * 9.8. Iteradores

    * 9.9. Generadores

    * 9.10. Expresiones generadoras

  * 10. Pequeño paseo por la Biblioteca Estándar

    * 10.1. Interfaz al sistema operativo

    * 10.2. Comodines de archivos

    * 10.3. Argumentos de linea de órdenes

    * 10.4. Redirigir la salida de error y finalización del programa

    * 10.5. Coincidencia en patrones de cadenas

    * 10.6. Matemática

    * 10.7. Acceso a Internet

    * 10.8. Fechas y tiempos

    * 10.9. Compresión de datos

    * 10.10. Medición de rendimiento

    * 10.11. Control de calidad

    * 10.12. Las pilas incluidas

  * 11. Pequeño paseo por la Biblioteca Estándar--- Parte II

    * 11.1. Formato de salida

    * 11.2. Plantillas

    * 11.3. Trabajar con registros estructurados conteniendo datos
      binarios

    * 11.4. Multi-hilos

    * 11.5. Registrando

    * 11.6. Referencias débiles

    * 11.7. Herramientas para trabajar con listas

    * 11.8. Aritmética de punto flotante decimal

  * 12. Entornos virtuales y paquetes

    * 12.1. Introducción

    * 12.2. Creando entornos virtuales

    * 12.3. Manejando paquetes con pip

  * 13. ¿Y ahora qué?

  * 14. Edición de entrada interactiva y sustitución de historial

    * 14.1. Autocompletado con tab e historial de edición

    * 14.2. Alternativas al intérprete interactivo

  * 15. Aritmética de Punto Flotante: Problemas y Limitaciones

    * 15.1. Error de Representación

  * 16. Apéndice

    * 16.1. Modo interactivo

      * 16.1.1. Manejo de errores

      * 16.1.2. Programas ejecutables de Python

      * 16.1.3. El archivo de inicio interactivo

      * 16.1.4. Los módulos de customización

* Configuración y uso de Python

  * 1. Línea de comandos y entorno

    * 1.1. Línea de comando

      * 1.1.1. Opciones de interfaz

      * 1.1.2. Opciones genéricas

      * 1.1.3. Opciones diversas

      * 1.1.4. Opciones que no debe usar

    * 1.2. Variables de entorno

      * 1.2.1. Variables de modo de depuración

  * 2. Uso de Python en plataformas Unix

    * 2.1. Obteniendo e instalando la última versión de Python

      * 2.1.1. En Linux

      * 2.1.2. En FreeBSD y OpenBSD

      * 2.1.3. En OpenSolaris

    * 2.2. Construyendo Python

    * 2.3. Rutas y archivos relacionados con Python

    * 2.4. Miscelánea

    * 2.5. OpenSSL personalizado

  * 3. Configurar Python

    * 3.1. Configurar opciones

      * 3.1.1. Opciones generales

      * 3.1.2. Opciones de WebAssembly

      * 3.1.3. Opciones de instalación

      * 3.1.4. Opciones de desempeño

      * 3.1.5. Compilación de depuración de Python

      * 3.1.6. Opciones de depuración

      * 3.1.7. Opciones del enlazador

      * 3.1.8. Opciones de bibliotecas

      * 3.1.9. Opciones de seguridad

      * 3.1.10. Opciones macOS

      * 3.1.11. Opciones de compilación cruzada

    * 3.2. Sistema de compilación Python

      * 3.2.1. Archivos principales del sistema de compilación

      * 3.2.2. Pasos principales de compilación

      * 3.2.3. Objetivos principales de Makefile

      * 3.2.4. Extensiones C

    * 3.3. Banderas de compilador y vinculación

      * 3.3.1. Banderas del preprocesador

      * 3.3.2. Banderas del compilador

      * 3.3.3. Banderas de vinculación

  * 4. Uso de Python en Windows

    * 4.1. El instalador completo

      * 4.1.1. Pasos para la instalación

      * 4.1.2. Quitar el límite de MAX_PATH

      * 4.1.3. Instalación sin interfaz de usuario

      * 4.1.4. Instalación sin descargas

      * 4.1.5. Modificar una instalación

    * 4.2. El paquete Microsoft Store

      * 4.2.1. Problemas conocidos

        * 4.2.1.1. Redirección de datos locales, registro y rutas
          temporales

    * 4.3. El paquete de nuget.org

    * 4.4. El paquete incrustable

      * 4.4.1. Aplicación Python

      * 4.4.2. Incrustar Python

    * 4.5. Distribuciones alternativas

    * 4.6. Configuración de Python

      * 4.6.1. Excurso: configurar variables de entorno

      * 4.6.2. Encontrar el ejecutable de Python

    * 4.7. Modo UTF-8

    * 4.8. Lanzador de Python para Windows

      * 4.8.1. Comenzar

        * 4.8.1.1. Desde la línea de comandos

        * 4.8.1.2. Entornos virtuales

        * 4.8.1.3. Desde un script

        * 4.8.1.4. Desde asociaciones de archivos

      * 4.8.2. Líneas shebang

      * 4.8.3. Argumentos en líneas shebang

      * 4.8.4. Personalización

        * 4.8.4.1. Personalización con archivos INI

        * 4.8.4.2. Personalizar las versiones de Python
          predeterminadas

      * 4.8.5. Diagnóstico

      * 4.8.6. Ejecución en seco

      * 4.8.7. Instalación bajo demanda

      * 4.8.8. Códigos de retorno

    * 4.9. Encontrar módulos

    * 4.10. Módulos adicionales

      * 4.10.1. PyWin32

      * 4.10.2. cx_Freeze

    * 4.11. Compilar Python en Windows

    * 4.12. Otras plataformas

  * 5. Usando Python en un Mac

    * 5.1. Getting and Installing Python

      * 5.1.1. Cómo ejecutar un *script* de Python

      * 5.1.2. Ejecutar scripts con una GUI

      * 5.1.3. Configuración

    * 5.2. El IDE

    * 5.3. Instalación de paquetes adicionales de Python

    * 5.4. GUI Programming

    * 5.5. Distributing Python Applications

    * 5.6. Otros recursos

  * 6. Editores e IDEs

* Referencia del Lenguaje Python

  * 1. Introducción

    * 1.1. Implementaciones alternativas

    * 1.2. Notación

  * 2. Análisis léxico

    * 2.1. Estructura de línea

      * 2.1.1. Líneas lógicas

      * 2.1.2. Líneas físicas

      * 2.1.3. Comentarios

      * 2.1.4. Declaración de Codificación

      * 2.1.5. Unión explícita de líneas

      * 2.1.6. Unión implícita de líneas

      * 2.1.7. Líneas en blanco

      * 2.1.8. Sangría

      * 2.1.9. Espacios en blanco entre tokens

    * 2.2. Otros tokens

    * 2.3. Identificadores y palabras clave

      * 2.3.1. Palabras clave

      * 2.3.2. Palabras clave suaves

      * 2.3.3. Clases reservadas de identificadores

    * 2.4. Literales

      * 2.4.1. Literales de cadenas y bytes

        * 2.4.1.1. Escape sequences

      * 2.4.2. Concatenación de literales de cadena

      * 2.4.3. f-strings

      * 2.4.4. Literales numéricos

      * 2.4.5. Literales enteros

      * 2.4.6. Literales de punto flotante

      * 2.4.7. Literales imaginarios

    * 2.5. Operadores

    * 2.6. Delimitadores

  * 3. Modelo de datos

    * 3.1. Objetos, valores y tipos

    * 3.2. Jerarquía de tipos estándar

      * 3.2.1. None

      * 3.2.2. NotImplemented

      * 3.2.3. Elipsis

      * 3.2.4. "numbers.Number"

        * 3.2.4.1. "numbers.Integral"

        * 3.2.4.2. "numbers.Real" ("float")

        * 3.2.4.3. "numbers.Complex" ("complex")

      * 3.2.5. Secuencias

        * 3.2.5.1. Secuencias inmutables

        * 3.2.5.2. Secuencias mutables

      * 3.2.6. Tipos de conjuntos

      * 3.2.7. Mapeos

        * 3.2.7.1. Diccionarios

      * 3.2.8. Tipos invocables

        * 3.2.8.1. Funciones definidas por el usuario

          * 3.2.8.1.1. Special read-only attributes

          * 3.2.8.1.2. Special writable attributes

        * 3.2.8.2. Métodos de instancia

        * 3.2.8.3. Funciones generadoras

        * 3.2.8.4. Funciones de corrutina

        * 3.2.8.5. Funciones generadoras asincrónicas

        * 3.2.8.6. Funciones incorporadas

        * 3.2.8.7. Métodos incorporados

        * 3.2.8.8. Clases

        * 3.2.8.9. Instancias de clases

      * 3.2.9. Módulos

      * 3.2.10. Clases personalizadas

      * 3.2.11. Instancias de clase

      * 3.2.12. Objetos E/S (también conocidos como objetos de
        archivo)

      * 3.2.13. Tipos internos

        * 3.2.13.1. Objetos de código

          * 3.2.13.1.1. Special read-only attributes

          * 3.2.13.1.2. Methods on code objects

        * 3.2.13.2. Objetos de marco

          * 3.2.13.2.1. Special read-only attributes

          * 3.2.13.2.2. Special writable attributes

          * 3.2.13.2.3. Frame object methods

        * 3.2.13.3. Objetos de seguimiento de pila (traceback)

        * 3.2.13.4. Objetos de segmento (Slice objects)

        * 3.2.13.5. Objetos de método estático

        * 3.2.13.6. Objetos de método de clase

    * 3.3. Nombres especiales de método

      * 3.3.1. Personalización básica

      * 3.3.2. Personalizando acceso a atributos

        * 3.3.2.1. Personalizando acceso a atributos de módulo

        * 3.3.2.2. Implementando descriptores

        * 3.3.2.3. Invocando descriptores

        * 3.3.2.4. __slots__

      * 3.3.3. Personalización de creación de clases

        * 3.3.3.1. Metaclases

        * 3.3.3.2. Resolviendo entradas de la Orden de Resolución de
          Métodos (MRU)

        * 3.3.3.3. Determinando la metaclase adecuada

        * 3.3.3.4. Preparando el espacio de nombres de la clase

        * 3.3.3.5. Ejecutando el cuerpo de la clase

        * 3.3.3.6. Creando el objeto de clase

        * 3.3.3.7. Usos para metaclases

      * 3.3.4. Personalizando revisiones de instancia y subclase

      * 3.3.5. Emulando tipos genéricos

        * 3.3.5.1. The purpose of *__class_getitem__*

        * 3.3.5.2. *__class_getitem__* versus *__getitem__*

      * 3.3.6. Emulando objetos que se pueden llamar

      * 3.3.7. Emulando tipos de contenedores

      * 3.3.8. Emulando tipos numéricos

      * 3.3.9. Gestores de Contexto en la Declaración *with*

      * 3.3.10. Personalización de argumentos posicionales en la
        coincidencia de patrones de clase

      * 3.3.11. Búsqueda de método especial

    * 3.4. Corrutinas

      * 3.4.1. Objetos esperables

      * 3.4.2. Objetos de corrutina

      * 3.4.3. Iteradores asíncronos

      * 3.4.4. Gestores de contexto asíncronos

  * 4. Modelo de ejecución

    * 4.1. Estructura de un programa

    * 4.2. Nombres y vínculos

      * 4.2.1. Vinculación de nombres

      * 4.2.2. Resolución de nombres

      * 4.2.3. Integraciones y ejecución restringida

      * 4.2.4. Interacción con funcionalidades dinámicas

    * 4.3. Excepciones

  * 5. El sistema de importación

    * 5.1. "importlib"

    * 5.2. Paquetes

      * 5.2.1. Paquetes regulares

      * 5.2.2. Paquetes de espacio de nombres

    * 5.3. Buscando

      * 5.3.1. La caché del módulo

      * 5.3.2. Buscadores y cargadores

      * 5.3.3. Ganchos de importación

      * 5.3.4. La meta ruta (*path*)

    * 5.4. Cargando

      * 5.4.1. Cargadores

      * 5.4.2. Submódulos

      * 5.4.3. Especificaciones del módulo

      * 5.4.4. Atributos de módulo relacionados con la importación

      * 5.4.5. module.__path__

      * 5.4.6. Representación (*Reprs*) de módulos

      * 5.4.7. Invalidación del código de bytes en caché

    * 5.5. El buscador basado en rutas

      * 5.5.1. Buscadores de entradas de ruta

      * 5.5.2. Buscadores de entradas de ruta

    * 5.6. Reemplazando el sistema de importación estándar

    * 5.7. Paquete Importaciones relativas

    * 5.8. Consideraciones especiales para __main__

      * 5.8.1. __main__.__spec__

    * 5.9. Referencias

  * 6. Expresiones

    * 6.1. Conversiones aritméticas

    * 6.2. Átomos

      * 6.2.1. Identificadores (Nombres)

      * 6.2.2. Literales

      * 6.2.3. Formas entre paréntesis

      * 6.2.4. Despliegues para listas, conjuntos y diccionarios

      * 6.2.5. Despliegues de lista

      * 6.2.6. Despliegues de conjuntos

      * 6.2.7. Despliegues de diccionario

      * 6.2.8. Expresiones de generador

      * 6.2.9. Expresiones yield

        * 6.2.9.1. Métodos generador-iterador

        * 6.2.9.2. Ejemplos

        * 6.2.9.3. Funciones generadoras asincrónicas

        * 6.2.9.4. Métodos asincrónicos de generador-iterador

    * 6.3. Primarios

      * 6.3.1. Referencias de atributos

      * 6.3.2. Suscripciones

      * 6.3.3. Segmentos

      * 6.3.4. Invocaciones

    * 6.4. Expresión await

    * 6.5. El operador de potencia

    * 6.6. Aritmética unaria y operaciones bit a bit

    * 6.7. Operaciones aritméticas binarias

    * 6.8. Operaciones de desplazamiento

    * 6.9. Operaciones bit a bit binarias

    * 6.10. Comparaciones

      * 6.10.1. Comparaciones de valor

      * 6.10.2. Operaciones de prueba de membresía

      * 6.10.3. Comparaciones de identidad

    * 6.11. Operaciones booleanas

    * 6.12. Expresiones de asignación

    * 6.13. Expresiones condicionales

    * 6.14. Lambdas

    * 6.15. Listas de expresiones

    * 6.16. Orden de evaluación

    * 6.17. Prioridad de operador

  * 7. Declaraciones simples

    * 7.1. Declaraciones de tipo expresión

    * 7.2. Declaraciones de asignación

      * 7.2.1. Declaraciones de asignación aumentada

      * 7.2.2. Declaraciones de asignación anotadas

    * 7.3. La declaración "assert"

    * 7.4. La declaración "pass"

    * 7.5. La declaración "del"

    * 7.6. La declaración "return"

    * 7.7. La declaración "yield"

    * 7.8. La declaración "raise"

    * 7.9. La declaración "break"

    * 7.10. La declaración "continue"

    * 7.11. La declaración "import"

      * 7.11.1. Declaraciones Futuras

    * 7.12. La declaración "global"

    * 7.13. La declaración "nonlocal"

  * 8. Sentencias compuestas

    * 8.1. La sentencia "if"

    * 8.2. La sentencia "while"

    * 8.3. La sentencia "for"

    * 8.4. La sentencia "try"

      * 8.4.1. Cláusula "except"

      * 8.4.2. Cláusula "except*"

      * 8.4.3. La sentencia "else"

      * 8.4.4. Cláusula "finally"

    * 8.5. La sentencia "with"

    * 8.6. La sentencia "match"

      * 8.6.1. Resumen

      * 8.6.2. Protecciones

      * 8.6.3. Bloques de Casos Irrefutables

      * 8.6.4. Patrones

        * 8.6.4.1. Patrones OR

        * 8.6.4.2. patrones AS

        * 8.6.4.3. Patrones literales

        * 8.6.4.4. Patrones de captura

        * 8.6.4.5. Patrones comodín

        * 8.6.4.6. Patrones de valor

        * 8.6.4.7. Patrones de grupo

        * 8.6.4.8. Patrones de secuencia

        * 8.6.4.9. Patrones de mapeo

        * 8.6.4.10. Patrones de clase

    * 8.7. Definiciones de funciones

    * 8.8. Definiciones de clase

    * 8.9. Corrutinas

      * 8.9.1. Definición de la función corrutina

      * 8.9.2. La sentencia "async for"

      * 8.9.3. La sentencia "async with"

  * 9. Componentes de nivel superior

    * 9.1. Programas completos de Python

    * 9.2. Entrada de archivo

    * 9.3. Entrada interactiva

    * 9.4. Entrada de expresión

  * 10. Especificación completa de la gramática

* La biblioteca estándar de Python

  * Introducción

    * Notas sobre la disponibilidad

      * Plataformas WebAssembly

  * Funciones Built-in

  * Constantes incorporadas

    * Constantes agregadas por el módulo "site"

  * Tipos integrados

    * Evaluar como valor verdadero/falso

    * Operaciones booleanas --- "and", "or", "not"

    * Comparaciones

    * Tipos numéricos --- "int", "float", "complex"

      * Operaciones de bits en números enteros

      * Métodos adicionales de los enteros

      * Métodos adicionales de float

      * Calculo del *hash* de tipos numéricos

    * Tipos de iteradores

      * Tipos generador

    * Tipos secuencia --- "list", "tuple", "range"

      * Operaciones comunes de las secuencias

      * Tipos de secuencia inmutables

      * Tipos de secuencia mutables

      * Listas

      * Tuplas

      * Rangos

    * Cadenas de caracteres --- "str"

      * Métodos de las cadenas de caracteres

      * Formateo de cadenas al estilo "*printf*"

    * Tipos de secuencias binarias --- "bytes", "bytearray" y
      "memoryview"

      * Objetos de tipo Bytes

      * Objetos de tipo *Bytearray*

      * Operaciones de *bytes* y *bytearray*

      * Usando el formateo tipo "printf" con bytes

      * Vistas de memoria

    * Conjuntos --- "set", "frozenset"

    * Tipos mapa --- "dict"

      * Objetos tipos vista de diccionario

    * Tipos gestores de contexto

    * Tipos de anotaciones de type — *alias genérico*, *Union*

      * Tipo Alias Genérico

        * Clases genéricas estándar

        * Atributos especiales de los objetos "GenericAlias"

      * Tipo de conversión

    * Otros tipos predefinidos

      * Módulos

      * Clases e instancias de clase

      * Funciones

      * Métodos

      * Objetos código

      * Objetos Tipo

      * El objeto nulo (*Null*)

      * El objeto puntos suspensivos (*Ellipsis*)

      * El objeto *NotImplemented*

      * Valores booleanos

      * Objetos internos

    * Atributos especiales

    * Limitación de longitud de conversión de cadena de tipo entero

      * APIs afectadas

      * Configuración del límite

      * Configuración recomendada

  * Excepciones incorporadas

    * Contexto de una excepción

    * Heredando de excepciones incorporadas

    * Clases base

    * Excepciones específicas

      * Excepciones del sistema operativo

    * Advertencias

    * Grupos de excepciones

    * Jerarquía de excepción

  * Servicios de procesamiento de texto

    * "string" --- Operaciones comunes de cadena de caracteres

      * Constantes de cadenas

      * Formato de cadena de caracteres personalizado

      * Sintaxis de formateo de cadena

        * Especificación de formato Mini-Lenguaje

        * Ejemplos de formateo

      * Cadenas de plantillas

      * Funciones de ayuda

    * "re" --- Operaciones con expresiones regulares

      * Sintaxis de expresiones regulares

      * Contenidos del módulo

        * Indicadores

        * Funciones

        * Excepciones

      * Objetos expresión regular

      * Objetos de coincidencia

      * Ejemplos de expresiones regulares

        * Buscando un par

        * Simular scanf()

        * search() vs. match()

        * Haciendo una guía telefónica

        * Mungear texto

        * Encontrar todos los adverbios

        * Encontrar todos los adverbios y sus posiciones

        * Notación de cadena *raw*

        * Escribir un Tokenizador

    * "difflib" --- Funciones auxiliares para calcular deltas

      * Objetos *SequenceMatcher*

      * "SequenceMatcher" Ejemplos

      * Objetos *Differ*

      * Ejemplo de *Differ*

      * Una interfaz de línea de comandos para "difflib"

    * "textwrap" --- Envoltura y relleno de texto

    * "unicodedata" --- Base de datos Unicode

    * "stringprep" --- Preparación de cadenas de Internet

    * "readline" --- Interfaz readline de GNU

      * Archivo de inicio

      * Búfer de línea

      * Archivo de historial

      * Lista del historial

      * Ganchos (*hooks*) de inicialización

      * Terminación

      * Ejemplo

    * "rlcompleter" --- Función de completado para GNU readline

  * Servicios de datos binarios

    * "struct" --- Interpreta bytes como paquetes de datos binarios

      * Funciones y excepciones

      * Cadenas de formato

        * Orden de bytes, tamaño y alineación

        * Caracteres de formato

        * Ejemplos

      * Applications

        * Native Formats

        * Standard Formats

      * Clases

    * "codecs" --- Registro de códec y clases base

      * Clases Base de Códec

        * Manejadores de errores

        * Codificación y decodificación sin estado

        * Codificación y decodificación incrementales

          * Objetos IncrementalEncoder

          * Objetos IncrementalDecoder

        * Codificación y decodificación de flujos

          * Objetos StreamWriter

          * Objetos StreamReader

          * Objetos StreamReaderWriter

          * Objetos StreamRecoder

      * Codificaciones y Unicode

      * Codificaciones estándar

      * Codificaciones específicas de Python

        * Codificaciones de texto

        * Transformaciones Binarias

        * Transformaciones de texto

      * "encodings.idna" --- Nombres de dominio internacionalizados en
        aplicaciones

      * "encodings.mbcs" --- Página de códigos ANSI de Windows

      * "encodings.utf_8_sig" --- Códec UTF-8 con firma BOM

  * Tipos de datos

    * "datetime" --- Tipos básicos de fecha y hora

      * Objetos conscientes (*aware*) y naífs (*naive*)

      * Constantes

      * Tipos disponibles

        * Propiedades comunes

        * Determinando si un objeto es Consciente (*Aware*) o Naíf
          (*Naive*)

      * Objetos "timedelta"

        * Ejemplos de uso: "timedelta"

      * Objeto "date"

        * Ejemplos de uso: "date"

      * Objetos "datetime"

        * Ejemplos de uso: "datetime"

      * Objetos "time"

        * Ejemplos de uso: "time"

      * Objetos "tzinfo"

      * Objetos "timezone"

      * "strftime()" and "strptime()" Behavior

        * "strftime()" and "strptime()" Format Codes

        * Detalle técnico

    * "zoneinfo" --- Soporte de zona horaria IANA

      * Usando "ZoneInfo"

      * Fuentes de datos

        * Configurando los orígenes de datos

          * Configuración en tiempo de compilación

          * Configuración del entorno

          * Configuración de tiempo de ejecución

      * La clase "ZoneInfo"

        * Representaciones de cadenas

        * Serialización de Pickle

      * Funciones

      * Globales

      * Excepciones y advertencias

    * "calendar" --- Funciones generales relacionadas con el
      calendario

      * Command-Line Usage

    * "collections" --- Tipos de datos contenedor

      * Objetos "ChainMap"

        * Ejemplos y recetas "ChainMap"

      * Objetos "Counter"

      * Objetos "deque"

        * Recetas "deque"

      * Objetos "defaultdict"

        * Ejemplos "defaultdict"

      * "namedtuple()" Funciones *Factory* para Tuplas y Campos con
        Nombres

      * Objetos "OrderedDict"

        * Ejemplos y recetas "OrderedDict"

      * Objetos "UserDict"

      * Objetos "UserList"

      * Objetos "UserString"

    * "collections.abc" --- Clases Base Abstractas para Contenedores

      * Colecciones clases base abstractas

      * Colecciones Clases base abstractas - Descripciones detalladas

      * Ejemplos y Recetas

    * "heapq" --- Algoritmo de colas montículos (*heap*)

      * Ejemplos Básicos

      * Notas de Aplicación de la Cola de Prioridades

      * Teoría

    * "bisect" --- Algoritmo de bisección de arreglos

      * Notas de rendimiento

      * Búsqueda en listas ordenadas

      * Ejemplos

    * "array" --- Arreglos eficientes de valores numéricos

    * "weakref" --- Referencias débiles

      * Objetos de referencias débiles

      * Ejemplo

      * Objetos finalizadores

      * Comparing finalizers with "__del__()" methods

    * "types" --- Creación de tipos dinámicos y nombres para tipos
      integrados

      * Creación dinámica de tipos

      * Tipos de Intérpretes Estándar

      * Clases y funciones de utilidad adicionales

      * Funciones de utilidad de corutina

    * "copy" --- Operaciones de copia superficial y profunda

    * "pprint" --- Impresión bonita de datos

      * Functions

      * Objetos *PrettyPrinter*

      * Ejemplo

    * "reprlib" --- Implementación "repr()" alternativa

      * Objetos Repr

      * Subclasificando Objetos Repr

    * "enum" — Soporte para enumeraciones

      * Contenido del Módulo

      * Tipos de datos

        * Nombres soportados "__dunder__"

        * Nombres "_sunder_" compatibles

      * Utilidades y decoradores

      * Notas

    * "graphlib" ---Funcionalidad para operar con estructuras de tipo-
      grafo

      * Excepciones

  * Módulos numéricos y matemáticos

    * "numbers" --- Clase base abstracta numérica

      * La torre numérica

      * Notas para implementadores de tipos

        * Agregar más *ABCs* numéricos

        * Implementar operaciones aritméticas

    * "math" --- Funciones matemáticas

      * Teoría de números y funciones de representación

      * Funciones logarítmicas y exponenciales

      * Funciones trigonométricas

      * Conversión angular

      * Funciones hiperbólicas

      * Funciones especiales

      * Constantes

    * "cmath" -- Función matemática para números complejos

      * Conversión a y desde coordenadas polares

      * Funciones logarítmicas y de potencias

      * Funciones trigonométricas

      * Funciones hiperbólicas

      * Funciones de clasificación

      * Constantes

    * "decimal" --- Aritmética decimal de coma fija y coma flotante

      * Tutorial de inicio rápido

      * Objetos Decimal

        * Operandos lógicos

      * Objetos context

      * Constantes

      * Modos de redondeo

      * Señales

      * Notas sobre la representación en coma flotante

        * Mitigación del error de redondeo usando mayor precisión

        * Valores especiales

      * Trabajando con hilos

      * Casos prácticos

      * Preguntas frecuentes sobre decimal

    * "fractions" --- Números racionales

    * "random" ---Generar números pseudoaleatorios

      * Funciones de contabilidad

      * Funciones para los bytes

      * Funciones para enteros

      * Funciones para secuencias

      * Distribuciones para los nombres reales

      * Generador alternativo

      * Notas sobre la Reproducibilidad

      * Ejemplos

      * Recetas

    * "statistics" --- Funciones de estadística matemática

      * Promedios y medidas de tendencia central

      * Medidas de dispersión

      * Estadísticas para relaciones entre dos entradas

      * Detalles de las funciones

      * Excepciones

      * Objetos "NormalDist"

        * Ejemplos de uso de "NormalDist"

  * Módulos de programación funcional

    * "itertools" --- Funciones que crean iteradores para bucles
      eficientes

      * Funciones de itertools

      * Fórmulas con itertools

    * "functools" --- Funciones de orden superior y operaciones sobre
      objetos invocables

      * "partial" Objetos

    * "operator" --- Operadores estándar como funciones

      * Asignación de operadores a funciones

      * Operadores *In-place*

  * Acceso a archivos y directorios

    * "pathlib" --- Rutas de sistemas orientada a objetos

      * Uso básico

      * Rutas puras

        * Propiedades generales

        * Operadores

        * Acceso a partes individuales

        * Métodos y propiedades

      * Rutas concretas

        * Métodos

      * Correspondencia a herramientas en el módulo "os"

    * "os.path" --- Manipulaciones comunes de nombre de ruta

    * "fileinput" --- Iterar sobre líneas de múltiples flujos de
      entrada

    * "stat" --- Interpretación de los resultados de "stat()"

    * "filecmp"--- Comparaciones de Archivo y Directorio

      * La clase "dircmp"

    * "tempfile" --- Generar archivos y directorios temporales

      * Ejemplos

      * Funciones y variables deprecadas

    * "glob" --- Expansión del patrón de nombres de ruta de estilo
      Unix

    * "fnmatch" --- Coincidencia de patrones de nombre de archivos
      Unix

    * "linecache" — Acceso aleatorio a líneas de texto

    * "shutil" --- Operaciones de archivos de alto nivel

      * Operaciones de directorios y archivos

        * Operaciones de copia eficientes dependientes de la
          plataforma

        * ejemplo de *copytree*

        * ejemplo de rmtree

      * Operaciones de archivado

        * Ejemplo de archivado

        * Ejemplo de archivado con *base_dir*

      * Consulta el tamaño de la terminal de salida

  * Persistencia de datos

    * "pickle" --- Serialización de objetos Python

      * Relación con otros módulos de Python

        * Comparación con "marshal"

        * Comparación con "json"

      * Formato de flujo de datos

      * Interfaz del módulo

      * ¿Qué se puede serializar (pickled) y deserializar (unpickled)
        con *pickle*?

      * *Pickling* de Instancias de clases

        * Persistencia de objetos externos

        * Tablas de despacho

        * Manejo de objetos con estado

      * Reducción personalizada para tipos, funciones y otros objetos

      * Búferes fuera de banda

        * API de proveedor

        * API de consumidor

        * Ejemplo

      * Restricción de globals

      * Performance

      * Ejemplos

    * "copyreg" --- Registrar funciones de soporte de "pickle"

      * Ejemplo

    * "shelve" --- Persistencia de objetos de Python

      * Restricciones

      * Ejemplo

    * "marshal" --- Serialización interna de objetos Python

    * "dbm" --- Interfaces para "bases de datos" de Unix

      * "dbm.gnu" --- GNU database manager

      * "dbm.ndbm" --- New Database Manager

      * "dbm.dumb" --- Implementación de DBM portátil

    * "sqlite3" --- DB-API 2.0 interfaz para bases de datos SQLite

      * Tutorial

      * Referencia

        * Funciones del módulo

        * Constantes del módulo

        * Objetos de conexión

        * Objetos cursor

        * Objetos fila (*Row*)

        * Objetos fila (*Row*)

        * Objetos PrepareProtocol

        * Excepciones

        * SQLite y tipos de Python

        * Adaptadores y convertidores por defecto

      * Guías prácticas

        * Cómo usar marcadores de posición para vincular valores en
          consultas SQL

        * Cómo adaptar tipos de Python personalizados a valores de
          SQLite

          * Cómo escribir objetos adaptables

          * Como registrar un adaptador invocable

        * Como convertir valores SQLite a tipos de Python
          personalizados

        * Ejemplos para adaptadores y convertidores

        * Cómo utilizar los métodos de acceso directo de conexión

        * Como usar la conexión con un administrador de contexto

        * Como trabajar con URIs SQLite

        * How to create and use row factories

        * How to handle non-UTF-8 text encodings

      * Explicación

        * Control transaccional

  * Compresión de datos y archivado

    * "zlib" --- Compresión compatible con **gzip**

    * "gzip" --- Soporte para archivos **gzip**

      * Ejemplos de uso

      * Interfaz de Línea de Comandos

        * Opciones de línea de comandos

    * "bz2" --- Soporte para compresión **bzip2**

      * (De)compresión de archivos

      * (De)compresión incremental

      * (Des)comprimir en un solo paso

      * Ejemplos de uso

    * "lzma" --- Compresión utilizando el algoritmo LZMA

      * Leyendo y escribiendo ficheros comprimidos

      * Comprimiendo y descomprimiendo datos en memoria

      * Misceláneas

      * Especificando cadenas de filtro personalizadas

      * Ejemplos

    * "zipfile" --- Trabajar con archivos ZIP

      * Objetos ZipFile

      * Objetos de ruta

      * Objetos PyZipFile

      * Objetos ZipInfo

      * Interfaz de línea de comandos

        * Opciones de línea de comando

      * Problemas de descompresión

        * Del archivo mismo

        * Limitaciones del sistema de archivos

        * Limitaciones de recursos

        * Interrupción

        * Comportamientos predeterminados de extracción

    * "tarfile" --- Leer y escribir archivos tar

      * Objetos *TarFile*

      * Objetos TarInfo

      * Extraction filters

        * Default named filters

        * Filter errors

        * Hints for further verification

        * Supporting older Python versions

        * Stateful extraction filter example

      * Interfaz de línea de comandos

        * Opciones de línea de comandos

      * Ejemplos

      * Formatos tar con soporte

      * Problemas unicode

  * Formatos de archivo

    * "csv" --- Lectura y escritura de archivos CSV

      * Contenidos del módulo

      * Dialectos y parámetros de formato

      * Objetos *Reader*

      * Objetos *Writer*

      * Ejemplos

    * "configparser" --- *Parser* para archivos de configuración

      * Inicio Rápido

      * Tipos de Datos Soportados

      * Valores de contingencia

      * Estructura soportada para el archivo ini

      * Interpolación de valores

      * Acceso por protocolo de mapeo

      * Personalizando el comportamiento del parser

      * Ejemplos de la API heredada

      * Objetos ConfigParser

      * Objetos RawConfigParser

      * Excepciones

    * "tomllib" --- Analizar archivos TOML

      * Ejemplos

      * Tabla de conversión

    * "netrc" --- procesado del fichero netrc

      * Objetos netrc

    * "plistlib" --- Genera y analiza archivos ".plist" de Apple

      * Ejemplos

  * Servicios criptográficos

    * "hashlib" --- Hashes seguros y resúmenes de mensajes

      * Algoritmos de hash

      * Usage

      * Constructors

      * Attributes

      * Hash Objects

      * Resúmenes SHAKE de largo variable

      * Cifrado de archivos

      * Derivación de clave

      * BLAKE2

        * Creando objetos hash

        * Constantes

        * Ejemplos

          * Cifrado simple

          * Usar diferentes tamaños de resumen

          * Cifrado de clave

          * Cifrado aleatorio

          * Personalización

          * Modo de árbol

        * Créditos

    * "hmac" --- *Hash* con clave para autenticación de mensajes

    * "secrets" --- Genera números aleatorios seguros para trabajar
      con secretos criptográficos

      * Números aleatorios

      * Generando tokens

        * ¿Cuántos bytes deben tener los tokens?

      * Otras funciones

      * Recetas y mejores prácticas

  * Servicios genéricos del sistema operativo

    * "os" --- Interfaces misceláneas del sistema operativo

      * Nombres de archivos, argumentos de la línea de comandos y
        variables de entorno

      * Modo Python UTF-8

      * Parámetros de proceso

      * Creación de objetos de tipo archivo

      * Operaciones de descriptores de archivos

        * Consultando las dimensiones de una terminal

        * Herencia de los descriptores de archivos

      * Archivos y directorios

        * Atributos extendidos de Linux

      * Gestión de proceso

      * Interfaz al planificador

      * Información miscelánea del sistema

      * Números al azar

    * "io" --- Herramientas principales para trabajar con *streams*

      * Resumen

        * E/S Texto

        * E/S Binaria

        * E/S sin formato

      * Codificación de texto

        * EncodingWarning opcional

      * Interfaz de módulo de alto nivel

      * Jerarquía de clases

        * Clases base E/S

        * Archivo sin formato E/S

        * *Streams* almacenados (búfer)

        * E/S Texto

      * Rendimiento

        * E/S Binaria

        * E/S Texto

        * Multihilo

        * Reentrada

    * "time" --- Acceso a tiempo y conversiones

      * Las Funciones

      * Constantes de ID de reloj

      * Constantes de zona horaria

    * "argparse" — Analizador sintáctico (*Parser*) para las opciones,
      argumentos y sub-comandos de la línea de comandos

      * Funcionalidad principal

      * Enlaces rápidos para add_argument()

      * Ejemplo

        * Creando un analizador sintáctico (*parser*)

        * Añadiendo argumentos

        * Analizando argumentos

      * Objetos *ArgumentParser*

        * *prog*

        * uso

        * *description*

        * *epilog*

        * *parents*

        * *formatter_class*

        * *prefix_chars*

        * *fromfile_prefix_chars*

        * *argument_default*

        * *allow_abbrev*

        * *conflict_handler*

        * *add_help*

        * exit_on_error

      * El método *add_argument()*

        * *name or flags*

        * *action*

        * *nargs*

        * *const*

        * *default*

        * *type*

        * *choices*

        * *required*

        * *help*

        * *metavar*

        * *dest*

        * Las clases *Action*

      * El método *parse_args()*

        * Sintaxis del valor de la opción

        * Argumentos no válidos

        * Argumentos conteniendo "-"

        * Abreviaturas de los argumentos (coincidencia de prefijos)

        * Más allá de "sys.argv"

        * El objeto *Namespace*

      * Otras utilidades

        * Sub-comandos

        * Objetos *FileType*

        * Grupos de argumentos

        * Exclusión mutua

        * Valores por defecto del analizador

        * Mostrando la ayuda

        * Análisis parcial

        * Personalizando el análisis de archivos

        * Métodos de salida

        * Análisis entremezclado

      * Actualizar el código de *optparse*

      * Exceptions

    * "getopt" --- Analizador de estilo C para opciones de línea de
      comando

    * "logging" --- Instalación de logging para Python

      * Objetos logger

      * Niveles de logging

      * Gestor de objetos

      * Objetos formateadores

      * Filtro de Objetos

      * Objetos LogRecord

      * Atributos LogRecord

      * Objetos LoggerAdapter

      * Seguridad del hilo

      * Funciones a nivel de módulo

      * Atributos a nivel de módulo

      * Integración con el módulo de advertencias

    * "logging.config" --- Configuración de registro

      * Funciones de configuración

      * Consideraciones de seguridad

      * Esquema del diccionario de configuración

        * Detalles del esquema del diccionario

        * Configuración incremental

        * Conexiones de objeto

        * Objetos definidos por el usuario

        * Handler configuration order

        * Acceso a objetos externos

        * Acceso a objetos internos

        * Resolución de importación e importadores personalizados

      * Formato de archivo de configuración

    * "logging.handlers" --- Gestores de *logging*

      * StreamHandler

      * FileHandler

      * NullHandler

      * WatchedFileHandler

      * BaseRotatingHandler

      * RotatingFileHandler

      * TimedRotatingFileHandler

      * SocketHandler

      * DatagramHandler

      * Gestor *SysLog* (*SysLogHandler*)

      * Gestor de eventos *NTELog* (NTEventLogHandler)

      * SMTPHandler

      * MemoryHandler

      * HTTPHandler

      * QueueHandler

      * QueueListener

    * "getpass" --- Entrada de contraseña portátil

    * "curses" --- Manejo de terminales para pantallas de celdas de
      caracteres

      * Funciones

      * Objetos de ventana

      * Constantes

    * "curses.textpad"--- Widget de entrada de texto para programas de
      curses

      * Objeto de caja de texto

    * "curses.ascii" --- Utilidades para los caracteres ASCII

    * "curses.panel" --- Una extensión de pila de panel para curses

      * Funciones

      * Objetos de panel

    * "platform" --- Acceso a los datos identificativos de la
      plataforma subyacente

      * Plataforma cruzada

      * Plataforma Java

      * Plataforma windows

      * Plataforma macOS

      * Plataformas Unix

      * Plataformas Linux

    * "errno" --- Símbolos estándar del sistema errno

    * "ctypes" --- Una biblioteca de funciones foráneas para Python

      * tutorial de ctypes

        * Carga de bibliotecas de enlaces dinámicos

        * Acceder a las funciones de los dll cargados

        * Funciones de llamada

        * Tipos de datos fundamentales

        * Funciones de llamada, continuación

        * Calling variadic functions

        * Funciones de llamada con sus propios tipos de datos
          personalizados

        * Especificar los tipos de argumentos requeridos (prototipos
          de funciones)

        * Tipos de retorno

        * Pasar los punteros (o: pasar los parámetros por referencia)

        * Estructuras y uniones

        * Alineación de estructura/unión y orden de bytes

        * Campos de bits en estructuras y uniones

        * Arreglos

        * Punteros

        * Conversiones de tipos

        * Tipos incompletos

        * Funciones de retrollamadas (*callback*)

        * Acceder a los valores exportados de los dlls

        * Sorpresas

        * Tipos de datos de tamaño variable

      * referencia ctypes

        * Encontrar bibliotecas compartidas

        * Cargando bibliotecas compartidas

        * Funciones foráneas

        * Prototipos de funciones

        * Funciones de utilidad

        * Tipos de datos

        * Tipos de datos fundamentales

        * Tipos de datos estructurados

        * Arreglos y punteros

  * Ejecución concurrente

    * "threading" --- Paralelismo basado en hilos

      * Datos locales del hilo

      * Objetos tipo hilo

      * Objetos tipo *lock*

      * Objetos *Rlock*

      * Objetos condicionales

      * Objetos semáforo

        * Ejemplo de "Semaphore"

      * Objetos de eventos

      * Objetos temporizadores

      * Objetos de barrera

      * Uso de *locks*, condiciones y semáforos en la declaración
        "with"

    * "multiprocessing" --- Paralelismo basado en procesos

      * Introducción

        * La clase "Process"

        * Contextos y métodos de inicio

        * Intercambiando objetos entre procesos

        * Sincronización entre procesos

        * Compartiendo estado entre procesos

        * Usando una piscina de trabajadores (*pool of workers*)

      * Referencia

        * "Process" y excepciones

        * Tuberías (*Pipes*) y Colas (*Queues*)

        * Miscelánea

        * Objetos de conexión *Connection Objects*

        * Primitivas de sincronización (*Synchronization primitives*)

        * Objetos compartidos "ctypes"

          * El módulo "multiprocessing.sharedctypes"

        * Administradores (*Managers*)

          * Administradores customizables (*Customized managers*)

          * Utilizando un administrador remoto

        * Objetos Proxy (*Proxy Objects*)

          * Limpieza (*Cleanup*)

        * Piscinas de procesos (*Process Pools*)

        * Oyentes y clientes (*Listeners and Clients*)

          * Formatos de dirección (*Address formats*)

        * Llaves de autentificación

        * *Logging*

        * El módulo "multiprocessing.dummy"

      * Pautas de programación

        * Todos los métodos de inicio

        * Los métodos de inicio *spawn* y *forkserver*

      * Ejemplos

    * "multiprocessing.shared_memory" --- Shared memory for direct
      access across processes

    * The "concurrent" package

    * "concurrent.futures" --- Lanzamiento de tareas paralelas

      * Objetos ejecutores

      * ThreadPoolExecutor

        * Ejemplo de ThreadPoolExecutor

      * ProcessPoolExecutor

        * Ejemplo de *ProcessPoolExecutor*

      * Objetos futuro

      * Funciones del módulo

      * Clases de Excepciones

    * "subprocess" --- Gestión de subprocesos

      * Uso del módulo "subprocess"

        * Argumentos frecuentemente empleados

        * El constructor de Popen

        * Excepciones

      * Consideraciones sobre seguridad

      * Objetos Popen

      * Elementos auxiliares de Popen en Windows

        * Constantes de Windows

      * Antigua API de alto nivel

      * Cómo reemplazar anteriores funciones con el módulo
        "subprocess"

        * Cómo reemplazar la sustitución de órdenes de **/bin/sh**

        * Cómo remplazar los flujos de la shell

        * Cómo reemplazar "os.system()"

        * Cómo reemplazar la familia "os.spawn"

        * Cómo reemplazar "os.popen()", "os.popen2()", "os.popen3()"

        * Replacing functions from the "popen2" module

      * Funciones de llamada a la shell de retrocompatibilidad

      * Notas

        * Cómo convertir una secuencia de argumentos a una cadena en
          Windows

        * Deshabilitar el uso de "vfork()" o "posix_spawn()"

    * "sched" --- Eventos del planificador

      * Objetos de "Scheduler"

    * "queue" --- clase de cola sincronizada

      * Objetos de la cola

      * Objetos de cola simple

    * "contextvars" --- Variables de Contexto

      * variables de contexto

      * Gestión de contexto manual

      * Soporte asyncio

    * "_thread" --- API de bajo nivel para manejo de hilos

  * Comunicación en redes y entre procesos

    * "asyncio" --- E/S Asíncrona

      * Ejecutores

        * Ejecutando un programa asyncio

        * Administrador de contexto del ejecutor

        * Manejando interrupciones de teclado

      * Corrutinas y tareas

        * Corrutinas

        * Esperables

        * Creando Tareas

        * Task Cancellation

        * Task Groups

        * Durmiendo

        * Ejecutando tareas concurrentemente

        * Protección contra cancelación

        * Tiempo agotado

        * Esperando primitivas

        * Ejecutando en hilos

        * Planificación desde otros hilos

        * Introspección

        * Objeto Task

      * Streams

        * StreamReader

        * StreamWriter

        * Ejemplos

          * Cliente eco TCP usando *streams*

          * Servidor eco TCP usando *streams*

          * Obtener encabezados HTTP

          * Registrar un socket abierto para esperar datos usando
            *streams*

      * Primitivas de sincronización

        * Lock

        * Event

        * Condition

        * Semaphore

        * BoundedSemaphore

        * Barrera

      * Sub-procesos

        * Creando sub-procesos

        * Constantes

        * Interactuando con Subprocesos

          * Subprocesos y Hilos

          * Ejemplos

      * Colas

        * Cola

        * Cola de prioridad

        * Cola UEPA (o *LIFO* en inglés)

        * Excepciones

        * Ejemplos

      * Excepciones

      * Bucle de eventos

        * Métodos del bucle de eventos

          * Iniciar y para el bucle

          * Programación de llamadas de retorno

          * Planificando llamadas retardadas

          * Creando futuros y tareas

          * Abriendo conexiones de red

          * Creando servidores de red

          * Transfiriendo archivos

          * Actualización de TLS

          * Viendo descriptores de archivos

          * Trabajar con objetos sockets directamente

          * DNS

          * Trabajando con tuberías

          * Señales Unix

          * Ejecutando código en un hilos o grupos de procesos

          * API para manejo de errores

          * Habilitando el modo depuración

          * Ejecutando subprocesos

        * Gestores de llamadas

        * Objetos Servidor

        * Implementaciones del bucle de eventos

        * Examples

          * Hola Mundo con call_soon()

          * Muestra la fecha actual con call_later()

          * Mirar un descriptor de archivo para leer eventos

          * Establece los gestores de señal para SIGINT y SIGTERM

      * Futures

        * Funciones Future

        * Objeto Future

      * Transportes y protocolos

        * Transportes

          * Jerarquía de transportes

          * Transporte base

          * Transportes de solo lectura

          * Transportes de solo escritura

          * Transportes de datagramas

          * Transportes de subprocesos

        * Protocolos

          * Protocolos base

          * Protocolo base

          * Protocolos de *streaming*

          * Protocolos de *streaming* mediante búfer

          * Protocolos de datagramas

          * Protocolos de subprocesos

        * Ejemplos

          * Servidor de eco TCP

          * Cliente de eco TCP

          * Servidor de eco UDP

          * Cliente de eco UDP

          * Conectando sockets existentes

          * *loop.subprocess_exec()* y *SubprocessProtocol*

      * Políticas

        * Obteniendo y configurando la política

        * Objetos de política

        * Observadores de procesos

        * Personalizar Políticas

      * Soporte de plataforma

        * Todas las plataformas

        * Windows

          * Soporte de sub-procesos en Windows

        * macOS

      * Extensión

        * Escribir un bucle de eventos personalizado

        * Constructores privados Future y Task

        * Soporte de por vida de tareas

      * Índice de API de alto nivel

        * Tareas

        * Colas

        * Subprocesos

        * Flujos

        * Sincronización

        * Excepciones

      * Índice de API de bajo nivel

        * Obtención del bucle de eventos

        * Métodos del bucle de eventos

        * Transportes

        * Protocolos

        * Políticas de bucle de eventos

      * Desarrollando con asyncio

        * Modo depuración

        * Concurrencia y multihilo

        * Ejecutando código bloqueante

        * Logueando

        * Detectar corrutinas no esperadas

        * Detectar excepciones nunca recuperadas

    * "socket" --- interfaz de red de bajo nivel

      * Familias Socket

      * Contenido del módulo

        * Excepciones

        * Constantes

        * Funciones

          * Creación de sockets

          * Otras funciones

      * Objetos Socket

      * Notas sobre los tiempos de espera del socket

        * Tiempos de espera y el método "connect"

        * Tiempos de espera y el método "accept"

      * Ejemplo

    * "ssl" ---Empaquetador o wrapper TLS/SSL para objetos de tipo
      socket

      * Funciones, constantes y excepciones

        * Creación de sockets

        * Creación de contexto

        * Excepciones

        * Generación aleatoria

        * Gestión de certificados

        * Constantes

      * Sockets SSL

      * Contextos SSL

      * Certificados

        * Cadenas de certificados

        * Certificados CA

        * Clave y certificado combinados

        * Certificados auto-firmados

      * Ejemplos

        * Pruebas de compatibilidad con SSL

        * Operación del lado del cliente

        * Operación del lado del servidor

      * Notas sobre los sockets no bloqueantes

      * Soporte de memoria BIO

      * Sesión SSL

      * Consideraciones de seguridad

        * Los mejores valores por defecto

        * Ajustes manuales

          * Verificación de certificados

          * Versiones del protocolo

          * Selección de cifrado

        * Multiprocesamiento

      * TLS 1.3

    * "select" --- Esperando la finalización de E/S

      * Objetos de sondeo "/dev/poll"

      * Objetos de sondeo de *Edge* y *Level Trigger* (*epoll*)

      * Sondeo de objetos

      * Objetos Kqueue

      * Objetos Kevent

    * "selectors" — Multiplexación de E/S de alto nivel

      * Introducción

      * Clases

      * Ejemplos

    * "signal" --- Establece gestores para eventos asíncronos

      * Reglas generales

        * Ejecución de los gestores de señales de Python

        * Señales e hilos

      * Contenidos del módulo

      * Examples

      * Nota sobre SIGPIPE

      * Note on Signal Handlers and Exceptions

    * "mmap" --- Soporte de archivos mapeados en memoria

      * Constantes MADV_*

      * Constantes MAP_*

  * Manejo de datos de internet

    * "email" --- Un paquete de manejo de correo electrónico y MIME

      * "email.message": Representando un mensaje de correo
        electrónico

      * "email.parser": Analizar mensajes de correo electrónico

        * API *FeedParser*

        * API *Parser*

        * Notas adicionales

      * "email.generator": Generando documentos MIME

      * "email.policy": Objetos *Policy*

      * "email.errors": Clases de excepción y defecto

      * "email.headerregistry": Objetos de encabezado personalizados

      * "email.contentmanager": Gestión de contenido MIME

        * Instancias gestoras de contenido

      * "email": Ejemplos

      * "email.message.Message": Representar un mensaje de correo
        electrónico usando la API "compat32"

      * "email.mime": Creación de correo electrónico y objetos MIME
        desde cero

      * "email.header": Cabeceras internacionalizadas

      * "email.charset":  Representa conjunto de caracteres

      * "email.encoders": Codificadores

      * "email.utils": Utilidades misceláneas

      * "email.iterators": Iteradores

    * "json" --- Codificador y decodificador JSON

      * Uso básico

      * Codificadores y Decodificadores

      * Excepciones

      * Cumplimiento e interoperabilidad estándar

        * Codificaciones de caracteres

        * Valores de número infinito y NaN

        * Nombres repetidos dentro de un objeto

        * Valores de nivel superior No-Objeto , No-Arreglo

        * Limitaciones de la implementación

      * Interfaz de línea de comandos

        * Opciones de línea de comandos

    * "mailbox" --- Manipular buzones de correo en varios formatos

      * "Mailbox" objects

        * "Maildir" objects

        * "mbox" objects

        * "MH" objects

        * "Babyl" objects

        * "MMDF" objects

      * "Message" objects

        * "MaildirMessage" objects

        * "mboxMessage" objects

        * "MHMessage" objects

        * "BabylMessage" objects

        * "MMDFMessage" objects

      * Excepciones

      * Ejemplos

    * "mimetypes" --- Mapea nombres de archivo a tipos MIME

      * Objetos MimeTypes

    * "base64" --- Codificaciones de datos Base16, Base32, Base64, y
      Base85

      * Consideraciones de Seguridad

    * "binascii" --- Convertir entre binario y ASCII

    * "quopri" --- Codificar y decodificar datos MIME imprimibles
      entre comillas

  * Herramientas Para Procesar Formatos de Marcado Estructurado

    * "html" --- Compatibilidad con el Lenguaje de marcado de
      hipertexto

    * "html.parser" --- Analizador simple de HTML y XHTML

      * Aplicación ejemplo de un analizador sintáctico (*parser*) de
        HTML

      * Métodos "HTMLParser"

      * Ejemplos

    * "html.entities" --- Definiciones de entidades generales HTML

    * Módulos de procesamiento XML

      * Vulnerabilidades XML

      * The "defusedxml" Package

    * "xml.etree.ElementTree" --- La API XML de ElementTree

      * Tutorial

        * Árbol y elementos XML

        * Procesando XML

        * API de consulta para un procesamiento no bloqueante

        * Encontrando elementos interesantes

        * Modificando un archivo XML

        * Construyendo documentos XML

        * Procesando XML con espacio de nombres

      * Soporte de XPath

        * Ejemplo

        * Sintaxis XPath soportada

      * Referencia

        * Funciones

      * Soporte de XInclude

        * Ejemplo

      * Referencia

        * Funciones

        * Objetos Element

        * Objetos ElementTree

        * Objetos QName

        * Objetos TreeBuilder

        * Objetos XMLParser

        * Objetos XMLPullParser

        * Excepciones

    * "xml.dom" --- El *API* del Modelo de Objetos del Documento

      * Contenido del módulo

      * Objetos en el DOM

        * Objetos *DOMImplementation*

        * Objetos nodo

        * Objetos *NodeList*

        * Objetos *DocumentType*

        * Objetos documento

        * Objetos elemento

        * Objetos atributo

        * Objetos *NamedNodeMap*

        * Objetos comentario

        * Objetos Texto y *CDATASection*

        * Objetos *ProcessingInstruction*

        * Excepciones

      * Conformidad

        * Mapeo de tipos

        * Métodos de acceso (*accessor*)

    * "xml.dom.minidom" --- Implementación mínima del DOM

      * Objetos del DOM

      * Ejemplo de DOM

      * minidom y el estándar DOM

    * "xml.dom.pulldom" --- Soporte para la construcción parcial de
      árboles DOM

      * Objetos DOMEventStream

    * "XML.sax"--- Soporte para analizadores SAX2

      * Objetos SAXException

    * "xml.sax.handler" --- Base classes for SAX handlers

      * Objetos ContentHandler

      * Objetos DTDHandler

      * Objetos EntityResolver

      * Objetos ErrorHandler

      * Objetos DTDHandler

    * "xml.sax.saxutils" --- Utilidades SAX

    * "xml.sax.xmlreader" --- Interfaz para analizadores XML

      * Objetos XMLReader

      * Objetos IncrementalParser

      * Objetos localizadores

      * Objetos InputSource

      * La Interfaz "Attributes"

      * La Interfaz "AttributesNS"

    * "xml.parsers.expat" --- Análisis rápido XML usando Expat

      * Objetos XMLParser

      * Excepciones de ExpatError

      * Ejemplo

      * Descripciones del modelo de contenido

      * Constantes de error de expansión

  * Protocolos y soporte de Internet

    * "webbrowser" --- Controlador de navegador web conveniente

      * Objetos controladores de navegador

    * "wsgiref" --- Utilidades WSGI e implementación de referencia

      * "wsgiref.util" -- Utilidades de entorno WSGI

      * "wsgiref.headers" -- Herramientas para cabeceras de respuesta
        WSGI

      * "wsgiref.simple_server"-- Un servidor HTTP WSGI simple

      * "wsgiref.validate" --- Verificador de compatibilidad WSGI

      * "wsgiref.handlers" -- Clases base servidor/*gateway*

      * "wsgiref.types" --- Tipos de WSGI para validadores estáticos
        de tipos

      * Ejemplos

    * "urllib" --- URL módulos de manipulación

    * "urllib.request" --- Biblioteca extensible para abrir URLs

      * Objetos Request

      * Objetos OpenerDirector

      * Objetos BaseHandler

      * Objetos HTTPRedirectHandler

      * Objetos HTTPCookieProcessor

      * Objetos ProxyHandler

      * Objetos HTTPPasswordMgr

      * Objetos HTTPPasswordMgrWithPriorAuth

      * Objetos AbstractBasicAuthHandler

      * Objetos HTTPBasicAuthHandler

      * Objetos ProxyBasicAuthHandler

      * Objetos AbstractDigestAuthHandler

      * Objetos HTTPDigestAuthHandler

      * Objetos ProxyDigestAuthHandler

      * Objetos HTTPHandler

      * Objetos HTTPSHandler

      * Objetos FileHandler

      * Objetos DataHandler

      * Objetos FTPHandler

      * Objetos CacheFTPHandler

      * Objetos UnknownHandler

      * Objetos HTTPErrorProcessor

      * Ejemplos

      * Interfaz heredada

      * Restricciones "urllib.request"

    * "urllib.response" --- Clases de respuesta usadas por urllib

    * "urllib.parse" --- Analiza URL en componentes

      * Análisis de URL

      * URL parsing security

      * Análisis de bytes codificados ASCII

      * Resultados del análisis estructurado

      * Cita de URL

    * "urllib.error" --- Clases de excepción lanzadas por
      urllib.request

    * "urllib.robotparser" ---  Analizador para robots.txt

    * "http" --- Módulos HTTP

      * Códigos de estado HTTP

      * Métodos HTTP

    * "http.client" --- Cliente de protocolo HTTP

      * Objetos de "HTTPConnection"

      * Objetos de "HTTPResponse"

      * Ejemplos

      * Objetos de "HTTPMessage"

    * "ftplib" --- cliente de protocolo FTP

      * Reference

        * FTP objects

        * FTP_TLS objects

        * Module variables

    * "poplib" --- Cliente de protocolo POP3

      * Objetos POP3

      * Ejemplo POP3

    * "imaplib" --- Protocolo del cliente IMAP4

      * Objetos de IMAP4

      * Ejemplo IMAP4

    * "smtplib" --- Cliente de protocolo SMTP

      * Objetos SMTP

      * Ejemplo SMTP

    * "uuid" --- objetos UUID según **RFC 4122**

      * Ejemplo

    * "socketserver" --- Un framework para servidores de red

      * Notas de creación del servidor

      * Objetos de servidor

      * Solicitar objetos de controlador

      * Ejemplos

        * "socketserver.TCPServer" Ejemplo

        * "socketserver.UDPServer" Ejemplo

        * Mixins asincrónicos

    * "http.server" --- Servidores HTTP

      * Consideraciones de seguridad

    * "http.cookies" --- Gestión del estado HTTP

      * Objetos de cookie

      * Objetos Morsel

      * Ejemplo

    * "http.cookiejar" --- Manejo de cookies para clientes HTTP

      * Objetos CookieJar y FileCookieJar

      * Subclases FileCookieJar y co-operación con navegadores web

      * Objetos CookiePolicy

      * Objetos DefaultCookiePolicy

      * Objetos Cookie

      * Ejemplos

    * "xmlrpc" --- XMLRPC server and client modules

    * "xmlrpc.client" --- acceso cliente XML-RPC

      * Objetos *ServerProxy*

      * Objetos *DateTime*

      * Objetos binarios

      * Objetos Faults

      * Objetos ProtocolError

      * Objetos MultiCall

      * Funciones de Conveniencia

      * Ejemplo de uso de cliente

      * Ejemplo de uso de cliente y servidor

    * "xmlrpc.server" --- Servidores básicos XML-RPC

      * Objetos SimpleXMLRPCServer

        * Ejemplo de SimpleXMLRPCServer

      * CGIXMLRPCRequestHandler

      * Documentando el servidor XMLRPC

      * Objetos DocXMLRPCServer

      * DocCGIXMLRPCRequestHandler

    * "ipaddress" --- Biblioteca de manipulación IPv4 / IPv6

      * Funciones de fábrica de conveniencia

      * Direcciones IP

        * Objetos de dirección

        * Conversión a cadenas y enteros

        * Operadores

          * Operadores de comparación

          * Operadores aritméticos

      * Definiciones de red IP

        * Prefijo, máscara de red y máscara de host

        * Objetos de red

        * Operadores

          * Operadores lógicos

          * Iteración

          * Redes como contenedores de direcciones

      * Objetos de interfaz

        * Operadores

          * Operadores lógicos

      * Otras funciones de nivel de módulo

      * Excepciones personalizadas

  * Servicios Multimedia

    * "wave" --- Leer y escribir archivos WAV

      * Los objetos *Wave_read*

      * Los objetos *Wave_write*

    * "colorsys" --- Conversiones entre sistemas de color

  * Internacionalización

    * "gettext" --- Servicios de internacionalización multilingües

      * GNU API **gettext**

      * API basada en clases

        * La clase "NullTranslations"

        * La clase "GNUTranslations"

        * Soporte de catálogo de mensajes de Solaris

        * El constructor del catálogo

      * Internacionalizando sus programas y módulos

        * Agregar configuración regional a su módulo

        * Agregar configuración regional a su aplicación

        * Cambiar idiomas sobre la marcha

        * Traducciones diferidas

      * Agradecimientos

    * "locale" --- Servicios de internacionalización

      * Segundo plano, detalles, indicaciones, consejos y advertencias

      * Para escritores de extensión y programas que incrustan Python

      * Acceso a los catálogos de mensajes

  * *Frameworks* de programa

    * "turtle" --- Gráficos con *Turtle*

      * Introducción

      * Tutorial

        * Starting a turtle environment

        * Basic drawing

          * Control del lápiz

          * The turtle's position

        * Making algorithmic patterns

      * How to...

        * Get started as quickly as possible

        * Use the "turtle" module namespace

        * Use turtle graphics in a script

        * Use object-oriented turtle graphics

      * Turtle graphics reference

        * Métodos Turtle

        * Métodos de TurtleScreen/Screen

      * Métodos de *RawTurtle/Turtle* Y sus correspondientes funciones

        * Movimiento de Turtle

        * Mostrar el estado de la tortuga

        * Configuración de las medidas

        * Control del lápiz

          * Estado de dibujo

          * Control del color

          * Relleno

          * Más controles de dibujo

        * Estado de la Tortuga

          * Visibilidad

          * Apariencia

        * Usando eventos

        * Métodos especiales de *Turtle*

        * Formas compuestas

      * Métodos de *TurtleScreen/Screen* y sus correspondientes
        funciones

        * Control de ventana

        * Control de animación

        * Usando eventos de pantalla

        * Métodos de entrada

        * Configuración y métodos especiales

        * Métodos específicos de *Screen*, no heredados de
          *TurtleScreen*

      * Clases públicas

      * Explanation

      * Ayuda y configuración

        * Cómo usar la ayuda

        * Traducción de cadenas de documentos a diferentes idiomas

        * Cómo configurar Screen and Turtles

      * "turtledemo" --- Scripts de demostración

      * Cambios desde Python 2.6

      * Cambios desde Python 3.0

    * "cmd" — Soporte para intérpretes orientados a línea de comandos

      * Objetos Cmd

      * Ejemplo Cmd

    * "shlex" --- Análisis léxico simple

      * objetos "shlex"

      * Reglas de análisis

      * Compatibilidad mejorada con intérprete de comandos

  * Interfaces gráficas de usuario con Tk

    * "tkinter" --- Interface de Python para *Tcl/Tk*

      * Arquitectura

      * Módulos Tkinter

      * Guía de supervivencia de Tkinter

        * Un programa simple de Hola Mundo

        * Conceptos importantes de Tk

        * Entendiendo como funcionan los empaquetadores de Tcl/Tk

        * ¿Cómo lo hago?, ¿Cómo funciona?

        * Navegando en el manual de referencia de Tcl/Tk

      * Modelo de subprocesamiento

      * Guía práctica

        * Configuración de opciones

        * El empaquetador

        * Opciones del empaquetador

        * Asociación de variables de widget

        * El gestor de ventanas

        * Tipos de datos de opciones Tk

        * Enlaces y eventos

        * El parámetro índice

        * Imágenes

      * Gestor de archivos

    * "tkinter.colorchooser" --- Diálogo de elección de color

    * "tkinter.font" --- Envoltorio de fuente Tkinter

    * Diálogos tkinter

      * "tkinter.simpledialog" ---Diálogos de entrada estándar de
        Tkinter

      * Diálogos de selección de archivos

        * Diálogos nativos de carga/guardado

      * "tkinter.commondialog" --- Plantillas de ventanas de diálogo

    * "tkinter.messagebox" --- Indicadores de mensajes de Tkinter

    * "tkinter.scrolledtext" --- Widget de texto desplazado

    * "tkinter.dnd" --- Soporte de arrastrar y soltar

    * "tkinter.ttk" --- Tk widgets temáticos

      * Uso de Ttk

      * Ttk widgets

      * Widget

        * Opciones estándar

        * Opciones de widgets desplegables

        * Opciones de etiqueta

        * Opciones de compatibilidad

        * Estados del widget

        * ttk.Widget

      * Combobox

        * Opciones

        * Eventos virtuales

        * ttk.Combobox

      * Spinbox

        * Opciones

        * Eventos virtuales

        * ttk.Spinbox

      * Notebook

        * Opciones

        * Opciones de pestañas

        * Identificadores de pestañas

        * Eventos virtuales

        * ttk.Notebook

      * Progressbar

        * Opciones

        * ttk.Progressbar

      * Separator

        * Opciones

      * Sizegrip

        * Notas específicas por plataforma

        * Errores detectados

      * Treeview

        * Opciones

        * Opciones de elementos

        * Opciones de etiqueta

        * Identificadores de columna

        * Eventos virtuales

        * ttk.Treeview

      * Ttk Styling

        * Diseños

    * "tkinter.tix" --- Ampliación de widgets para Tk

      * Usando Tix

      * Widgets de Tix

        * Widgets Básicos

        * Selectores de Archivos

        * *ListBox* jerárquico

        * *ListBox* Tabular

        * Gestores de Widgets

        * Tipos de Imágenes

        * Widgets Varios

        * Gestor de Geometría de Formulario

      * Comandos Tix

    * IDLE

      * Menús

        * Menú de archivo (Shell y Editor)

        * Menú editar (Shell y Editor)

        * Menú de formato (solo ventana del Editor)

        * Menú ejecutar (solo ventana Editor)

        * Menú de shell (solo ventana de shell)

        * Menú de depuración (solo ventana de shell)

        * Menú de opciones (Shell y editor)

        * Menú de ventana (shell y editor)

        * Menú de ayuda (shell y editor)

        * Menús contextuales

      * Edición y navegación

        * Ventana del editor

        * Atajos de teclado

        * Indentación automática

        * Buscar y reemplazar

        * Terminaciones

        * Sugerencias de llamada

        * Contexto del código

        * Ventana de Shell

        * Colores del texto

      * Inicio y ejecución de código

        * Uso de línea de comando

        * Error de inicio

        * Ejecutando código del usuario

        * Salida del usuario en consola

        * Desarrollando aplicaciones tkinter

        * Ejecutando sin un subproceso

      * Ayuda y preferencias

        * Recursos de ayuda

        * Preferencias de configuración

        * IDLE en macOS

        * Extensiones

      * idlelib

  * Herramientas de desarrollo

    * "typing" --- Soporte para *type hints*

      * PEPs relevantes

      * Alias de tipo

      * NewType

      * Annotating callable objects

      * Genéricos

      * Annotating tuples

      * The type of class objects

      * Tipos genéricos definidos por el usuario

      * El tipo "Any"

      * Subtipado nominal vs estructural

      * Contenido del módulo

        * Primitivos especiales de tipado

          * Tipos especiales

          * Formas especiales

          * Construir tipos genéricos

          * Otras directivas especiales

        * Protocolos

        * ABCs for working with IO

        * Funciones y decoradores

        * Ayudas de introspección

        * Constantes

        * Deprecated aliases

          * Aliases to built-in types

          * Aliases to types in "collections"

          * Aliases to other concrete types

          * Aliases to container ABCs in "collections.abc"

          * Aliases to asynchronous ABCs in "collections.abc"

          * Aliases to other ABCs in "collections.abc"

          * Aliases to "contextlib" ABCs

      * Línea de tiempo de obsolescencia de características
        principales

    * "pydoc" --- Generador de documentación y Sistema de ayuda en
      línea

    * Modo de desarrollo de Python

      * Efectos del modo de desarrollo de Python

      * Ejemplo de ResourceWarning

      * Ejemplo de error de descriptor de archivo incorrecto

    * "doctest" -- Prueba ejemplos interactivos de Python

      * Uso simple: verificar ejemplos en docstrings

      * Uso Simple: Verificar ejemplos en un Archivo de Texto

      * Cómo funciona

        * ¿Qué docstrings son examinados?

        * ¿Cómo se reconocen los ejemplos de docstring?

        * ¿Cuál es el contexto de ejecución?

        * ¿Y las excepciones?

        * Banderas de Opción

        * Directivas

        * Advertencias

      * API básica

      * API de unittest

      * API avanzada

        * Objetos DocTest

        * Objetos *Example*

        * Objetos *DocTestFinder*

        * Objetos *DocTestParser*

        * Objetos *DocTestRunner*

        * Objetos *OutputChecker*

      * Depuración

      * Plataforma improvisada

    * "unittest" --- Infraestructura de tests unitarios

      * Ejemplo sencillo

      * Interfaz de línea de comandos

        * Opciones de la línea de órdenes

      * Descubrimiento de pruebas

      * Organización del código de pruebas

      * Reutilización de código de prueba anterior

      * Omitir tests y fallos esperados

      * Distinguiendo iteraciones de tests empleando subtests

      * Clases y funciones

        * Casos de test

          * Alias obsoletos

        * Agrupando tests

        * Cargando y ejecutando tests

          * load_tests protocolo

      * Instalaciones para clases y módulos

        * setUpClass y tearDownClass

        * setUpModule y tearDownModule

      * Manejo de señales

    * "unittest.mock" --- Biblioteca de objetos simulados

      * Guía rápida

      * La clase Mock

        * Llamar a los objetos simulados

        * Eliminar atributos

        * Los nombres de los objetos simulados y el atributo *name*

        * Adjuntar objetos simulados como atributos

      * Parcheadores

        * patch

        * patch.object

        * patch.dict

        * patch.multiple

        * métodos start y stop de patch

        * parchear objetos incorporados (builtins)

        * TEST_PREFIX

        * Anidando decoradores patch

        * Dónde parchear

        * Parcheando descriptores y objetos proxy

      * MagicMock y el soporte de métodos mágicos

        * Simular métodos mágicos

        * Magic Mock

      * Ayudantes

        * sentinel

        * DEFAULT

        * call

        * create_autospec

        * ANY

        * FILTER_DIR

        * mock_open

        * Autoespecificación

        * Sellar objetos simulados

      * Order of precedence of "side_effect", "return_value" and
        *wraps*

    * "unittest.mock" --- primeros pasos

      * Usando mock

        * Métodos de parcheo mock

        * Mock de llamadas a métodos sobre un objeto

        * Mocking Classes

        * Nombrando tus mocks

        * Siguiendo todas las llamadas

        * Establecer valores de retorno y atributos

        * Generar excepciones con mocks

        * Funciones de efectos secundarios e iterables

        * Iteradores asincrónicos de Mocking

        * El gestor de contexto asincrónico de Mocking

        * Creando un mock desde un objeto existente

        * Using side_effect to return per file content

      * Decoradores de Parches

      * Otros ejemplos

        * Mocking de llamadas encadenadas

        * Mocking parcial

        * Mocking de un método generador

        * Aplicar el mismo parche a cada método de prueba

        * Mocking de métodos sin enlazar

        * Comprobación de varias llamadas con mock

        * Copiando con argumentos mutables

        * Anidando parches

        * Mocking a un diccionario usando MagickMock

        * Mock de subclases y sus atributos

        * Importaciones de Mocking con patch.dict

        * Seguimiento del orden de las llamadas y de las aserciones de
          llamadas menos detalladas

        * Coincidencia de argumentos más compleja

    * 2to3 --- Traducción automática de código de Python 2 a 3

      * Usando 2to3

      * Fixers

      * "lib2to3" --- biblioteca 2to3

    * "test" --- Paquete de pruebas de regresión para Python

      * Escritura de pruebas unitarias para el paquete "test"

      * Ejecución de pruebas utilizando la interfaz de línea de
        comandos

    * "test.support" --- Utilidades para el conjunto de pruebas de
      Python

    * "test.support.socket_helper" --- Utilidades para pruebas de
      socket

    * "test.support.script_helper" ---Utilidades para las pruebas de
      ejecución de Python

    * "test.support.bytecode_helper" --- Herramientas de apoyo para
      comprobar la correcta generación de bytecode

    * "test.support.threading_helper" --- Utilidades para pruebas con
      hilos

    * "test.support.os_helper" --- Utilidades para pruebas de sistemas
      operativos

    * "test.support.import_helper" --- Utilidades para pruebas de
      importación

    * "test.support.warnings_helper" --- Utilidades para pruebas de
      advertencias

  * Depuración y perfilado

    * Tabla de auditoría de eventos

    * "bdb" --- Framework de depuración

    * "faulthandler" --- Volcar el rastreo de Python

      * Volcar el rastreo

      * Estado del gestor de fallos

      * Volcar los rastreos después de un tiempo de espera

      * Volcar el rastreo en una señal del usuario

      * Problema con descriptores de archivo

      * Ejemplo

    * "pdb" --- El Depurador de Python

      * Comandos del depurador

    * Los perfiladores de Python

      * Introducción a los perfiladores

      * Manual instantáneo de usuario

      * Referencia del módulo "profile" y "cProfile"

      * La clase "Stats"

      * ¿Qué es el perfil determinista?

      * Limitaciones

      * Calibración

      * Usando un temporizador personalizado

    * "timeit" --- Mide el tiempo de ejecución de pequeños fragmentos
      de código

      * Ejemplos básicos

      * Interfaz de Python

      * Interfaz de línea de comandos

      * Ejemplos

    * "trace" --- Rastrear la ejecución de la declaración de Python

      * Uso de la línea de comandos

        * Opciones principales

        * Modificadores

        * Filtros

      * Interfaz programática

    * "tracemalloc"--- Rastrea la asignación de memoria

      * Ejemplos

        * Mostrar los 10 principales

        * Calcula las diferencias

        * Consigue el seguimiento del bloque de memoria

        * "Los 10 más bonitos"

          * Graba los tamaños actual y máximo de todos los bloques de
            memoria rastreados

      * API

        * Funciones

        * Filtro de dominio

        * Filtro

        * Cuadro

        * Captura instantánea

        * Estadística

        * StatisticDiff

        * Rastro

        * Seguimiento

  * Empaquetado y distribución de software

    * "distutils" --- Creación e instalación de módulos Python

    * "ensurepip" --- Ejecutando el instalador "pip"

      * Interfaz de línea de comandos

      * API del módulo

    * "venv" --- Creación de entornos virtuales

      * Creación de entornos virtuales

      * Cómo funcionan los venvs

      * API

      * Un ejemplo de la extensión de "EnvBuilder"

    * "zipapp" ---  Gestiona archivadores zip ejecutables de Python

      * Ejemplo básico

      * Interfaz de línea de comando

      * API de Python

      * Ejemplos

      * Especificar el intérprete

      * Creando aplicaciones independientes con zipapp

        * Hacer un ejecutable para Windows

        * Advertencias

      * El formato de archivado Zip de aplicaciones Python

  * Servicios en tiempo de ejecución de Python

    * "sys" --- Parámetros y funciones específicos del sistema

    * "sysconfig" --- Proporciona acceso a la información de
      configuración de Python

      * Variables de configuración

      * Rutas de instalación

      * User scheme

        * "posix_user"

        * "nt_user"

        * "osx_framework_user"

      * Home scheme

        * "posix_home"

      * Prefix scheme

        * "posix_prefix"

        * "nt"

      * Installation path functions

      * Otras funciones

      * Usando "sysconfig" como un script

    * "builtins" --- Objetos incorporados

    * "__main__" --- Entorno de código de nivel máximo

      * "__name__ == '__main__'"

        * ¿Qué es el "entorno de código de máximo nivel"?

        * Uso idiomático

        * Consideraciones de empaquetado

      * "__main__.py" en paquetes de Python

        * Uso idiomático

      * "import __main__"

    * "warnings" --- Control de advertencias

      * Categorías de advertencia

      * El filtro de advertencias

        * Descripción de los filtros de advertencia

        * Filtro de advertencia predeterminado

        * Anulando el filtro por defecto

      * Eliminación temporal de las advertencias

      * Advertencias de prueba

      * Actualización del código para las nuevas versiones de las
        dependencias

      * Funciones disponibles

      * Gestores de contexto disponibles

    * "dataclasses" --- Data Classes

      * Contenidos del módulo

      * Procesamiento posterior a la inicialización

      * Variables de clase

      * Variable de solo inicialización

      * Instancias congeladas

      * Herencia

      * Re-ordering of keyword-only parameters in "__init__()"

      * Funciones fábrica por defecto

      * Valores por defecto mutables

      * Campos tipo descriptor

    * "contextlib" --- Utilidades para declaraciones de contexto
      "with"

      * Utilidades

      * Ejemplos y recetas

        * Apoyando un número variable de gestores de contexto

        * Capturando excepciones de los métodos "__enter__"

        * Limpieza en una implementación "__enter__"

        * Reemplazar cualquier uso de "try-finally" y marcar variables

        * Usar un gestor de contexto como decorador de funciones

      * Gestores de contexto de uso único, reutilizables y reentrantes

        * Gestores contextuales reentrantes

        * Gestores contextuales reutilizables

    * "abc" --- Clases de Base Abstracta

    * "atexit" --- Gestores de Salida

      * Ejemplo con "atexit"

    * "traceback" --- Imprimir o recuperar un seguimiento de pila

      * "TracebackException" Objects

      * "StackSummary" Objects

      * "FrameSummary" Objects

      * Ejemplos de seguimiento de pila

    * "__future__" --- Definiciones de declaraciones futuras

      * Module Contents

    * "gc" --- Interfaz del recolector de basura

    * "inspect" --- Inspeccionar objetos vivos

      * Tipos y miembros

      * Recuperar el código fuente

      * Introspección de los invocables con el objeto Signature

      * Clases y funciones

      * La pila del interprete

      * Obteniendo atributos estáticamente

      * Estado actual de los Generadores y las Corutinas

      * Objetos de código Bit Flags

      * Interfaz de la línea de comando

    * "site" --- Enlace (*hook*) de configuración específico del sitio

      * "sitecustomize"

      * "usercustomize"

      * Configuración de *Readline*

      * Contenido del módulo

      * Interfaz de línea de comando

  * Intérpretes de Python personalizados

    * "code" --- Clases básicas de intérpretes

      * Objetos de intérprete interactivo

      * Objetos de consola interactiva

    * "codeop" --- Compila código Python

  * Importando módulos

    * "zipimport" --- Importar módulos desde archivos zip

      * Objetos zipimporter

      * Ejemplos

    * "pkgutil" --- Utilidad de extensión de paquete

    * "modulefinder" --- Buscar módulos usados por un script

      * Ejemplo de uso de "ModuleFinder"

    * "runpy" --- Localización y ejecución de módulos *Python*

    * "importlib" --- La implementación de "import"

      * Introducción

      * Funciones

      * "importlib.abc" -- Clases base abstractas relacionadas con la
        importación

      * "importlib.machinery" -- Importadores y enlaces de ruta

      * "importlib.util" -- Código de utilidad para importadores

      * Ejemplos

        * Importar programáticamente

        * Comprobando si se puede importar un módulo

        * Importar un archivo fuente directamente

        * Implementar importaciones diferidas

        * Configurar un importador

        * Aproximando "importlib.import_module()"

    * "importlib.resources" -- Package resource reading, opening and
      access

      * Funciones en desuso

    * "importlib.resources.abc" -- Clases base abstractas para
      recursos

    * "importlib.metadata" -- Accessing package metadata

      * Descripción general

      * API funcional

        * Puntos de entrada

        * Metadatos de distribución

        * Versiones de distribución

        * Archivos de distribución

        * Requerimientos de la distribución

        * Mapping import to distribution packages

      * Distribuciones

      * Distribution Discovery

      * Extendiendo el algoritmo de búsqueda

    * La inicialización de la ruta de búsqueda de módulo de "sys.path"

      * Entornos virtuales

      * Archivos _pth

      * Python embebido

  * Servicios del lenguaje Python

    * "ast" --- Árboles de sintaxis abstracta

      * Gramática abstracta

      * Clases nodo

        * Root nodes

        * Literales

        * Variables

        * Expresiones

          * Subindexado

          * Comprensiones

        * Declaraciones

          * Importaciones

        * Control de flujo

        * La coincidencia de patrones

        * Definiciones de función y clase

        * Async y await

      * Ayudantes de "ast"

      * Banderas del compilador

      * Uso en línea de comandos

    * "symtable" --- Acceso a la tabla de símbolos del compilador

      * Generando tablas de símbolos

      * Examinando la tabla de símbolos

    * "token"--- Constantes usadas con árboles de sintaxis de Python

    * "keyword" --- Pruebas para palabras clave en Python

    * "tokenize" --- Conversor a tokens para código Python

      * Convirtiendo la entrada en *tokens*

      * Uso como línea de comandos

      * Ejemplos

    * "tabnanny" --- Detección de indentación ambigua

    * "pyclbr" --- Soporte para navegador de módulos Python

      * Objetos Function

      * Objetos Class

    * "py_compile`" --- Compila archivos fuente Python

      * Interfaz de línea de comandos

    * "compileall" --- Bibliotecas de Python de compilación de bytes

      * Uso de la línea de comandos

      * Funciones públicas

    * "dis" --- Desensamblador para bytecode de Python

      * Command-line interface

      * Análisis de bytecode

      * Funciones de análisis

      * Instrucciones bytecode de Python

      * Colecciones opcode

    * "pickletools" --- Herramientas para desarrolladores pickle

      * Uso de la línea de comandos

        * Opciones de línea de comandos

      * Interfaz programática

  * Servicios Específicos para MS Windows

    * "msvcrt" --- Rutinas útiles del entorno de ejecución MS VC++

      * Operaciones con archivos

      * Consola E/S

      * Otras funciones

    * "winreg" --- Acceso al registro de Windows

      * Funciones

      * Constantes

        * HKEY_* Constantes

        * Access Rights

          * Específico de 64 bits

        * Tipos de valor

      * Objetos de control del registro

    * "winsound" --- Interfaz de reproducción de sonido para Windows

  * Servicios específicos de Unix

    * "posix" --- Las llamadas más comunes al sistema POSIX

      * Soporte de archivos grandes

      * Contenido notable del módulo

    * "pwd" --- La base de datos de contraseñas

    * "grp" --- La base de datos de grupo

    * "termios" ---Control tty estilo POSIX

      * Ejemplo

    * "tty" --- Funciones de control de terminal

    * "pty" --- Utilidades para Pseudo-terminal

      * Ejemplo

    * "fcntl" --- Las llamadas a sistema "fcntl" y "ioctl"

    * "resource" --- Información sobre el uso de recursos

      * Límites de recursos

      * Utilización de recursos

    * "syslog" --- Rutinas de la biblioteca syslog de Unix

      * Ejemplos

        * Ejemplo sencillo

  * Modules command-line interface (CLI)

  * Módulos reemplazados

    * "aifc" — Lee y escribe archivos AIFF y AIFC

    * "asynchat" --- Gestor de comandos/respuestas en *sockets*
      asíncronos

      * Ejemplo de asynchat

    * "asyncore" --- controlador de socket asincrónico

      * Ejemplo asyncore de cliente HTTP básico

      * Ejemplo asyncore de servidor de eco básico

    * "audioop" --- Manipula datos de audio sin procesar

    * "cgi" --- Soporte de Interfaz de Entrada Común (CGI)

      * Introducción

      * Usando el módulo CGI

      * Interfaz de nivel superior

      * Funciones

      * Preocuparse por la seguridad

      * Instalando su script de CGI en un sistema Unix

      * Probando su script de CGI

      * Depurando scripts de CGI

      * Problemas comunes y soluciones

    * "cgitb" --- Administrador *traceback* para scripts CGI.

    * "chunk" --- Lee los datos de los trozos de IFF

    * "crypt" --- Función para verificar contraseñas Unix

      * Métodos de *hashing*

      * Atributos del módulo

      * Funciones del módulo

      * Ejemplos

    * "imghdr" --- Determinar el tipo de imagen

    * "imp" --- Acceda a *import* internamente

      * Ejemplos

    * "mailcap" --- Manejo de archivos Mailcap

    * "msilib" --- Leer y escribir archivos *Microsoft Installer*

      * Objetos Database

      * Objetos View

      * Objetos Summary Information

      * Objetos Record

      * Errores

      * Objetos CAB

      * Objetos Directory

      * Features

      * Clases GUI

      * Tablas pre-calculadas

    * "nis" — Interfaz a Sun's NIS (Páginas amarillas)

    * "nntplib" — Protocolo de cliente NNTP

      * Objetos NNTP

        * Atributos

        * Métodos

      * Funciones de utilidad

    * "optparse" --- Analizador sintáctico (parser) para opciones de
      línea de comandos

      * Contexto

        * Terminología

        * ¿Qué finalidad tienen las opciones?

        * ¿Qué finalidad tienen los argumentos posicionales?

      * Tutorial

        * Comprendiendo las acciones de opción

        * La acción store

        * Manejo de opciones booleanas (flags)

        * Otras acciones

        * Valores por defecto

        * Generando ayuda

          * Agrupando opciones

        * Imprimir una cadena de caracteres con la versión del
          programa

        * Cómo maneja los errores el módulo "optparse"

        * Reuniendo todas las piezas

      * Guía de referencia

        * Creando el analizador sintáctico (parser)

        * Completando el analizador con opciones

        * Definiendo las opciones

        * Atributos de opción

        * Acciones de opción estándares

        * Tipos de opción estándares

        * Analizando los argumentos

        * Consultar y manipular el analizador de opciones

        * Conflictos entre opciones

        * Limpieza

        * Otros métodos

      * Retrollamadas de opción

        * Definición de una opción con retrollamada

        * Cómo son invocadas las retrollamadas

        * Lanzando errores en una retrollamada

        * Ejemplo de retrollamada 1: una retrollamada trivial

        * Ejemplo de retrollamada 2: comprobar el orden de las
          opciones

        * Ejemplo de retrollamada 3: comprobar el orden de las
          opciones (generalizado)

        * Ejemplo de retrollamada 4: comprobar una condición
          arbitraria

        * Ejemplo de retrollamada 5: argumentos fijos

        * Ejemplo de retrollamada 6: argumentos variables

      * Extendiendo el módulo "optparse"

        * Agregando nuevos tipos

        * Agregando nuevas acciones

      * Exceptions

    * "ossaudiodev" --- Acceso a dispositivos de audio compatibles con
      OSS

      * Objetos de dispositivo de audio

      * Objetos del dispositivo mezclador

    * "pipes" --- Interfaz para tuberías de shell

      * Objetos Template

    * "smtpd" --- Servidor SMTP

      * Objetos SMTPServer

      * Objetos DebuggingServer

      * Objetos PureProxy

      * Objetos SMTPChannel

    * "sndhdr" --- Determinar el tipo de archivo de sonido

    * "spwd" --- La base de datos de contraseñas ocultas

    * "sunau" --- Lectura y escritura de ficheros Sun AU

      * Objetos AU_read

      * Objetos AU_write

    * "telnetlib" --- cliente Telnet

      * Objetos telnet

      * Ejemplo de telnet

    * "uu" --- Codifica y decodifica archivos UUEncode

    * "xdrlib" --- Codificar y decodificar datos XDR

      * Instancias de la clase *Packer*

      * Instancias de la clase *Unpacker*

      * Excepciones

  * Consideraciones de seguridad

* Ampliación e incrustación del intérprete de Python

  * Herramientas de terceros recomendadas

  * Crear extensiones sin herramientas de terceros

    * 1. Extendiendo Python con C o C++

      * 1.1. Un ejemplo simple

      * 1.2. Intermezzo: errores y excepciones

      * 1.3. De vuelta al ejemplo

      * 1.4. La tabla de métodos del módulo y la función de
        inicialización

      * 1.5. Compilación y enlazamiento

      * 1.6. Llamando funciones Python desde C

      * 1.7. Extracción de parámetros en funciones de extensión

      * 1.8. Parámetros de palabras clave para funciones de extensión

      * 1.9. Construyendo valores arbitrarios

      * 1.10. Conteo de referencias

        * 1.10.1. Conteo de referencias en Python

        * 1.10.2. Reglas de propiedad

        * 1.10.3. Hielo delgado

        * 1.10.4. Punteros NULL

      * 1.11. Escribiendo extensiones en C++

      * 1.12. Proporcionar una API C para un módulo de extensión

    * 2. Definición de tipos de extensión: Tutorial

      * 2.1. Lo básico

      * 2.2. Agregar datos y métodos al ejemplo básico

      * 2.3. Proporcionar un control más preciso sobre los atributos
        de datos

      * 2.4. Apoyo a la recolección de basura cíclica

      * 2.5. Subclases de otros tipos

    * 3. Definición de tipos de extensión: temas variados

      * 3.1. Finalización y desasignación

      * 3.2. Presentación de objetos

      * 3.3. Gestión de atributos

        * 3.3.1. Gestión de atributos genéricos

        * 3.3.2. Gestión de atributos específicos de tipo

      * 3.4. Comparación de Objetos

      * 3.5. Soporte de protocolo abstracto

      * 3.6. Soporte de referencia débil

      * 3.7. Más Sugerencias

    * 4. Construyendo extensiones C y C++

      * 4.1. Construyendo extensiones C y C++ con distutils

      * 4.2. Distribuyendo sus módulos de extensión

    * 5. Creación de extensiones C y C++ en Windows

      * 5.1. Un enfoque de libro de cocina

      * 5.2. Diferencias entre Unix y Windows

      * 5.3. Usar DLL en la práctica

  * Incrustar el tiempo de ejecución de CPython en una aplicación más
    grande

    * 1. Incrustando Python en otra aplicación

      * 1.1. Incrustación de muy alto nivel

      * 1.2. Más allá de la incrustación de muy alto nivel: una visión
        general

      * 1.3. Incrustación pura

      * 1.4. Extendiendo Python incrustado

      * 1.5. Incrustando Python en C++

      * 1.6. Compilar y enlazar bajo sistemas tipo Unix

* Manual de referencia de la API en C de Python

  * Introducción

    * Estándares de codificación

    * Archivos de cabecera (*Include*)

    * Macros útiles

    * Objetos, tipos y conteos de referencias

      * Conteo de Referencias

        * Detalles del conteo de referencia

      * Tipos

    * Excepciones

    * Integración de Python

    * Depuración de compilaciones

  * Estabilidad de la API en C

    * Interfaz binaria de aplicación estable

      * Limited C API

      * Stable ABI

      * Alcance y rendimiento de la API limitada

      * Advertencias de la API limitada

    * Consideraciones de la plataforma

    * Contenido de la API limitada

  * La capa de muy alto nivel

  * Conteo de referencias

  * Manejo de excepciones

    * Impresión y limpieza

    * Lanzando excepciones

    * Emitir advertencias

    * Consultando el indicador de error

    * Manejo de señal

    * Clases de excepción

    * Objetos excepción

    * Objetos unicode de excepción

    * Control de recursión

    * Excepciones estándar

    * Categorías de advertencia estándar

  * Utilidades

    * Utilidades del sistema operativo

    * Funciones del Sistema

    * Control de procesos

    * Importando módulos

    * Soporte de empaquetado (*marshalling*) de datos

    * Analizando argumentos y construyendo valores

      * Analizando argumentos

        * Cadena de caracteres y búferes

        * Números

        * Otros objetos

        * Funciones API

      * Construyendo valores

    * Conversión y formato de cadenas de caracteres

    * PyHash API

    * Reflexión

    * Registro de códec y funciones de soporte

      * API de búsqueda de códec

      * API de registro para controladores de errores de codificación
        Unicode

  * Capa de objetos abstractos

    * Protocolo de objeto

    * Protocolo de llamada

      * El protocolo *tp_call*

      * El protocolo vectorcall

        * Control de recursión

        * API de soporte para vectorcall

      * API para invocar objetos

      * API de soporte de llamadas

    * Protocolo de números

    * Protocolo de secuencia

    * Protocolo de mapeo

    * Protocolo iterador

    * Protocolo búfer

      * Estructura de búfer

      * Tipos de solicitud búfer

        * campos independientes de solicitud

        * formato de sólo lectura

        * formas, *strides*, *suboffsets*

        * solicitudes de contigüidad

        * solicitudes compuestas

      * Arreglos complejos

        * Estilo NumPy: forma y *strides*

        * Estilo PIL: forma, *strides* y *suboffsets*

      * Funciones relacionadas a búfer

    * Protocolo de búfer antiguo

  * Capa de objetos concretos

    * Objetos fundamentales

      * Objetos tipo

        * Crear tipos asignados en montículo (*heap*)

      * El objeto "None"

    * Objetos numéricos

      * Objetos enteros

      * Objetos booleanos

      * Objetos de punto flotante

        * Funciones de empaquetado y desempaquetado

          * Funciones de Empaquetado

          * Funciones de Desempaquetado

      * Objetos de números complejos

        * Números complejos como estructuras C

        * Números complejos como objetos de Python

    * Objetos de secuencia

      * Objetos bytes

      * Objetos de arreglos de bytes (*bytearrays*)

        * Macros de verificación de tipos

        * Funciones API directas

        * Macros

      * Objetos y códecs unicode

        * Objetos unicode

          * Tipo unicode

          * Propiedades de caracteres Unicode

          * Creando y accediendo a cadenas de caracteres Unicode

          * APIs de Py_UNICODE deprecadas

          * Codificación regional

          * Codificación del sistema de archivos

          * soporte wchar_t

        * Códecs incorporados

          * Códecs genéricos

          * Códecs UTF-8

          * Códecs UTF-32

          * Códecs UTF-16

          * Códecs UTF-7

          * Códecs Unicode escapado

          * Códecs para Unicode escapado en bruto

          * Códecs Latin-1

          * Códecs ASCII

          * Códecs de mapa de caracteres

          * Códecs MBCS para Windows

          * Métodos & Ranuras (*Slots*)

        * Métodos y funciones de ranura (*Slot*)

      * Objetos tupla

      * Objetos de secuencia de estructura

      * Objetos lista

    * Objetos contenedor

      * Objetos diccionario

      * Objetos conjunto

    * Objetos de función

      * Objetos función

      * Objetos de método de instancia

      * Objetos método

      * Objetos celda

      * Objetos código

    * Otros objetos

      * Objetos archivo

      * Objetos módulo

        * Inicializando módulos en C

          * Inicialización monofásica

          * Inicialización multifase

          * Funciones de creación de módulos de bajo nivel

          * Funciones de soporte

        * Búsqueda de módulos

      * Objetos iteradores

      * Objetos descriptores

      * Objetos rebanada (*slice*)

        * Objeto elipsis

      * Objetos de vista de memoria (*MemoryView*)

      * Objetos de referencia débil

      * Cápsulas

      * Objetos frame

      * Objetos generadores

      * Objetos corrutina

      * Objetos de variables de contexto

      * Objetos *DateTime*

      * Objetos para indicaciones de tipado

  * Inicialización, finalización e hilos

    * Antes de la inicialización de Python

    * Variables de configuración global

    * Inicializando y finalizando el intérprete

    * Parámetros de todo el proceso

    * Estado del hilo y el bloqueo global del intérprete

      * Liberando el GIL del código de extensión

      * Hilos creados sin Python

      * Precauciones sobre "fork()"

      * API de alto nivel

      * API de bajo nivel

    * Soporte de subinterprete

      * Errores y advertencias

    * Notificaciones asincrónicas

    * Perfilado y Rastreo

    * Soporte avanzado del depurador

    * Soporte de almacenamiento local de hilo

      * API de almacenamiento específico de hilo (TSS, *Thread
        Specific Storage*)

        * Asignación dinámica

        * Métodos

      * API de almacenamiento local de hilos (TLS, *Thread Local
        Storage*)

  * Configuración de inicialización de Python

    * Ejemplo

    * PyWideStringList

    * PyStatus

    * PyPreConfig

    * Preinicialización de Python con PyPreConfig

    * PyConfig

    * Inicialización con PyConfig

    * Configuración aislada

    * Configuración de Python

    * Configuración de la ruta de Python

    * Py_RunMain()

    * Py_GetArgcArgv()

    * API Provisional Privada de Inicialización Multifásica

  * Gestión de la memoria

    * Visión general

    * Dominios del asignador

    * Interfaz de memoria sin procesar

    * Interfaz de memoria

    * Asignadores de objetos

    * Asignadores de memoria predeterminados

    * Personalizar asignadores de memoria

    * Configurar enlaces para detectar errores en las funciones del
      asignador de memoria de Python

    * El asignador pymalloc

      * Personalizar asignador de arena de pymalloc

    * tracemalloc C API

    * Ejemplos

  * Soporte de implementación de objetos

    * Asignación de objetos en el montículo

    * Estructuras de objetos comunes

      * Tipos objeto base y macros

      * Implementando funciones y métodos

      * Acceder a atributos de tipos de extensión

    * Objetos tipo

      * Referencia rápida

        * "ranuras *tp*" (*tp slots*)

        * sub-ranuras (*sub-slots*)

        * ranura de *typedefs*

      * Definición de "PyTypeObject"

      * Ranuras (*Slots*) "PyObject"

      * Ranuras "PyVarObject"

      * Ranuras "PyTypeObject"

      * Tipos estáticos

      * Tipos Heap

    * Estructuras de objetos de números

    * Estructuras de objetos mapeo

    * Estructuras de objetos secuencia

    * Estructuras de objetos búfer

    * Estructuras de objetos asíncronos

    * Tipo Ranura *typedefs*

    * Ejemplos

    * Apoyo a la recolección de basura cíclica

      * Controlar el estado del recolector de basura

  * Versiones de API y ABI

* Instalando módulos de Python

  * Palabras clave

  * Uso básico

  * ¿Cómo...

    * ... instalo "pip" en versiones de Python anteriores a Python
      3.4?

    * ... instalo paquetes solamente para el usuario actual?

    * ... instalo paquetes científicos de Python?

    * ... trabajo con múltiples versiones de Python instaladas en
      paralelo?

  * Problemas de instalación comunes

    * Instalando en el Python del sistema bajo Linux

    * Pip no está instalado

    * Instalando extensiones binarias

* Comos (*HOWTOs*) de Python

  * Portar módulos de extensión a Python 3

  * Programación de curses con Python

    * ¿Qué es curses?

      * El módulo curses de Python

    * Iniciar y finalizar una aplicación de curses

    * Ventanas y pads

    * Mostrando el texto

      * Atributos y color

    * *Input* del usuario

    * Para más información

  * Guía práctica de uso de los descriptores

    * Guía introductoria

      * Ejemplo simple: un descriptor que retorna una constante

      * Búsquedas dinámicas

      * Atributos gestionados

      * Nombres personalizados

      * Pensamientos finales

    * Ejemplo completo práctico

      * Clase validadora

      * Validadores personalizados

      * Aplicación práctica

    * Tutorial técnico

      * Resumen

      * Definición e introducción

      * Protocolo de descriptores

      * Visión general de invocación de descriptores

      * Invocación desde una instancia

      * Invocación desde una clase

      * Invocación desde super

      * Resumen de la lógica de invocación

      * Notificación automática de nombre

      * Ejemplo de mapeos objeto-relacional (*ORM*)

    * Equivalentes en Python puro

      * Propiedades

      * Funciones y métodos

      * Tipos de métodos

      * Métodos estáticos

      * Métodos de clase

      * Objetos miembros y __slots__

  * Debugging C API extensions and CPython Internals with GDB

    * Prerequisites

      * Setup with Python built from source

      * Setup for Python from a Linux distro

    * Using the Debug build and Development mode

    * Using the "python-gdb" extension

      * Pretty-printers

      * "py-list"

      * "py-up" and "py-down"

      * "py-bt"

      * "py-print"

      * "py-locals"

    * Use with GDB commands

  * HOWTO - Enum

    * Acceso programático a los miembros de la enumeración y sus
      atributos

    * Duplicar miembros y valores de enumeración

    * Garantizar valores de enumeración únicos

    * Uso de valores automáticos

    * Iteración

    * comparaciones

    * Miembros permitidos y atributos de enumeraciones

    * Subclases de Enum restringidas

    * Serialización (Pickling)

    * API funcional

    * Enumeraciones derivadas

      * IntEnum

      * StrEnum

      * IntFlag

      * Bandera

      * Otros

    * Cuándo usar "__new__()" frente a "__init__()"

      * Puntos más finos

        * Nombres "__dunder__" admitidos

        * Nombres "_sunder_" admitidos

        * _Private__names

        * Tipo de miembro "Enum"

        * Creación de miembros que se mezclan con otros tipos de datos

        * Valor booleano de clases y miembros "Enum"

        * Clases "Enum" con métodos

        * Combinación de miembros de "Flag"

        * Minuciosidades "Flag" y "IntFlag"

    * How are Enums and Flags different?

      * Clases de enumeración

      * Flag Classes

      * Miembros de enumeración (también conocidos como instancias)

      * Flag Members

    * Enum Cookbook

      * Omitir valores

        * Usando "auto"

        * Usando "object"

        * Usar una cadena descriptiva

        * Usando un "__new__()" personalizado

      * Enum ordenado

      * DuplicateFreeEnum

      * Planeta

      * Periodo de tiempo

    * Subclase EnumType

  * HOWTO - Programación funcional

    * Introducción

      * Demostrabilidad formal

      * Modularidad

      * Facilidad de depurar y probar

      * Componibilidad

    * Iteradores

      * Tipos de datos que soportan iteradores

    * Expresiones generadoras y listas por comprensión

    * Generadores

      * Pasar valores a un generador

    * Funciones incorporadas

    * El módulo itertools

      * Crear nuevos iteradores

      * Aplicar funciones a los elementos

      * Seleccionar elementos

      * Funciones combinatorias

      * Agrupar elementos

    * El módulo functools

      * El módulo operator

    * Funciones pequeñas y la expresión lambda

    * Historia de revisiones y reconocimientos

    * Referencias

      * Generales

      * Específicas de Python

      * Documentación de Python

  * HOWTO hacer registros (*Logging*)

    * Tutorial básico de *logging*

      * Cuándo usar *logging*

      * Un simple ejemplo

      * Logging a un archivo

      * Registrar datos de variables

      * Cambiar el formato de los mensajes mostrados

      * Visualización de la fecha/hora en los mensajes

      * Próximos pasos

    * Tutorial de registro avanzado

      * Flujo de Registro

      * Registradores

      * Gestores

      * Formateadores

      * Configuración del registro

      * ¿Qué pasa si no se proporciona ninguna configuración

      * Configurando Logging para una biblioteca

    * Niveles de registro

      * Niveles personalizados

    * Gestores útiles

    * Excepciones lanzadas durante logging

    * Usando objetos arbitrarios como mensajes

    * Optimización

  * Libro de recetas de Logging

    * Usar logging en múltiples módulos

    * Logging desde múltiples hilos

    * Múltiples gestores y formateadores

    * Logging en múltiples destinos

    * Gestión personalizada de niveles

    * Ejemplo de servidor de configuración

    * Tratar con gestores que bloquean

    * Enviar y recibir eventos logging a través de una red

      * Ejecutando un logging de socket oyente en producción

    * Agregar información contextual a su salida de logging

      * Uso de LoggerAdapters para impartir información contextual

        * Usar objetos distintos a los diccionarios para transmitir
          información contextual

      * Usar filtros para impartir información contextual

    * Uso de "contextvars"

    * Impartir información contextual en los gestores

    * Logging a un sólo archivo desde múltiples procesos

      * Usando concurrent.futures.ProcessPoolExecutor

      * Despliegue de aplicaciones web con Gunicorn y uWSGI

    * Usando rotación de archivos

    * Uso de estilos de formato alternativos

    * Personalización de "LogRecord"

    * Subclassing QueueHandler and QueueListener- a ZeroMQ example

      * Subclass "QueueHandler"

      * Subclass "QueueListener"

    * Subclassing QueueHandler and QueueListener- a "pynng" example

      * Subclass "QueueListener"

      * Subclass "QueueHandler"

    * Una configuración de ejemplo basada en diccionario

    * Usar un rotador y un nombre para personalizar el procesamiento
      de rotación de log

    * Un ejemplo de multiprocesamiento más elaborado

    * Insertar BOM en mensajes enviados a SysLogHandler

    * Implementar logging estructurado

    * Personalización de gestores con "dictConfig()"

    * Usar estilos de formato particulares en toda su aplicación

      * Uso de fábricas de LogRecord

      * Usar objetos de mensaje personalizados

    * Configurar filtros con "dictConfig()"

    * Formato de excepción personalizado

    * Mensajes de logging hablantes

    * Almacenamiento en búfer de mensajes de logging y su salida
      condicional

    * Enviando mensajes de logging al correo electrónico, con
      almacenamiento en búfer

    * Formateo de horas usando UTC (GMT) a través de la configuración

    * Usar un administrador de contexto para logging selectivo

    * Una plantilla de inicio de aplicación CLI

    * Una GUI de Qt para logging

    * Logging en syslog con soporte RFC5424

    * Cómo tratar un logger como una salida stream

    * Patrones para evitar

      * Abrir el mismo archivo de registro varias veces

      * Usar registradores como atributos en una clase o pasarlos como
        parámetros

      * Adding handlers other than "NullHandler" to a logger in a
        library

      * Crear muchos registradores (*loggers*)

    * Otros recursos

  * Expresiones regulares COMOS (*HOWTO*)

    * Introducción

    * Patrones simples

      * Coincidencia de caracteres (*Matching Characters*)

      * Repitiendo cosas

    * Usando expresiones regulares

      * Compilando expresiones regulares

      * La plaga de la barra invertida (*The Backslash Plague*)

      * Realizando coincidencias

      * Funciones a nivel de módulo

      * Los flags de compilación

    * Más poder de patrones

      * Más metacarácteres

      * Agrupando

      * Grupos con nombre y sin captura

      * Aserciones anticipadas

    * Modificando cadenas de caracteres

      * Separando cadenas de caracteres

      * Búsqueda y reemplazo

    * Problemas comunes

      * Uso de métodos de cadenas de caracteres

      * *match() versus search()*

      * Codiciosa versus no codiciosa (*Greedy versus Non-Greedy*)

      * Usando re.VERBOSE

    * Feedback

  * HOW TO - Programación con sockets

    * Sockets

      * Historia

    * Creando un socket

      * IPC

    * Usando un socket

      * Datos binarios

    * Desconectando

      * Cuando los sockets mueren

    * *Sockets* no bloqueantes

  * HOW TO - Ordenar

    * Conceptos básicos de ordenación

    * Funciones clave

    * Funciones del módulo *operator*

    * Ascendente y descendente

    * Estabilidad de ordenamiento y ordenamientos complejos

    * Decorate-Sort-Undecorate

    * Funciones de comparación

    * Curiosidades

  * CÓMO (*HOWTO*) Unicode

    * Introducción a Unicode

      * Definiciones

      * Codificaciones

      * Referencias

    * Soporte Unicode de Python

      * El tipo cadena

      * Convirtiendo a Bytes

      * Literales Unicode en código fuente Python

      * Propiedades Unicode

      * Comparando cadenas

      * Expresiones regulares Unicode

      * Referencias

    * Leyendo y escribiendo datos Unicode

      * Nombres de archivos Unicode

      * Consejos para escribir programas compatibles con Unicode

        * Conversión entre codificaciones de archivo

        * Archivos en una codificación desconocida

      * Referencias

    * Agradecimientos

  * HOWTO - Cómo obtener recursos de Internet con el paquete urllib

    * Introducción

    * Obtención de URLs

      * Datos

      * Encabezados (Headers)

    * Gestión de excepciones

      * URLError

      * HTTPError

        * Códigos de error

      * Resumiéndolo

        * Número 1

        * Número 2

    * info y geturl

    * Objetos de Apertura (Openers) y Gestores (Handlers)

    * Autenticación básica

    * Proxies

    * Sockets y capas

    * Notas a pie de página

  * Tutorial de *argparse*

    * Conceptos

    * Las bases

    * Introducción a los argumentos posicionales

    * Introducción a los argumentos opcionales

      * Opciones cortas

    * Combinar argumentos opcionales y posicionales

    * Un poco mas avanzado

      * Opciones conflictivas

    * How to translate the argparse output

    * Conclusión

  * Introducción al modulo *ipaddress*

    * Creando objetos Dirección/Red/Interfaz
      (*Address/Network/Interface*)

      * Nota sobre versiones IP

      * Direcciones IP del Host

      * Definiendo redes

      * Interfaces de host

    * Inspeccionando objetos Dirección/Red/Interfaz
      (*Address/Network/Interface*)

    * Redes como listas de direcciones

    * Comparaciones

    * Uso de direcciones IP con otros módulos

    * Obtener más detalles cuando se produce un error en la creación
      de instancias

  * Instrumentación de CPython con DTrace y SystemTap

    * Habilitando los marcadores estáticos

    * Sondas estáticas DTrace

    * Marcadores estáticos SystemTap

    * Marcadores estáticos disponibles

    * SystemTap Tapsets

    * Ejemplos

  * Prácticas recomendadas para las anotaciones

    * Acceder al diccionario de anotaciones de un objeto en las
      versiones de Python 3.10 y posteriores

    * Acceder al diccionario de anotaciones de un objeto en las
      versiones de Python 3.9 y anteriores

    * Desencadenamiento manual de anotaciones en cadena

    * Prácticas recomendadas para "__annotations__" en cualquier
      versión de Python

    * Peculiaridades de "__annotations__"

  * Aislamiento de módulos de extensión

    * ¿Quién debería leer esto?

    * Trasfondo

      * Ingrese al estado por módulo

      * Objetos módulos aislados

      * Casos extremos sorprendentes

    * Cómo hacer que los módulos sean seguros con varios intérpretes

      * Administrar el estado global

      * Administración del estado por módulo

      * Exclusión voluntaria: limitación a un objeto de módulo por
        proceso

      * Acceso al estado del módulo desde las funciones

    * Tipos Heap

      * Cambio de tipos estáticos a tipos heap

      * Definición de tipos heap

      * Protocolo de recolección de basura

        * "tp_traverse" in Python 3.8 and lower

        * Delegating "tp_traverse"

        * Defining "tp_dealloc"

        * Not overriding "tp_free"

        * Avoiding "PyObject_New"

      * Acceso al estado del módulo desde las clases

      * Acceso al estado del módulo desde métodos regulares

      * Acceso al estado del módulo desde métodos de Slot, Getters y
        Setters

      * Vida útil del estado del módulo

    * Problemas abiertos

      * Alcance por clase

      * Conversión sin pérdidas a tipos heap

* Preguntas más frecuentes de Python

  * Preguntas frecuentes generales sobre Python

    * Información general

    * Python en el mundo real

  * Preguntas frecuentes de programación

    * Preguntas generales

    * Núcleo del lenguaje

    * Números y cadenas

    * Rendimiento

    * Secuencias (Tuplas/Listas)

    * Objetos

    * Módulos

  * Preguntas frecuentes sobre diseño e historia

    * ¿Por qué Python usa indentación para agrupar declaraciones?

    * ¿Por qué obtengo resultados extraños con operaciones aritméticas
      simples?

    * ¿Por qué los cálculos de punto flotante son tan inexactos?

    * ¿Por qué las cadenas de caracteres de Python son inmutables?

    * ¿Por qué debe usarse 'self' explícitamente en las definiciones y
      llamadas de métodos?

    * ¿Por qué no puedo usar una tarea en una expresión?

    * ¿Por qué Python usa métodos para alguna funcionalidad (por
      ejemplo, list.index()) pero funciones para otra (por ejemplo,
      len(list))?

    * ¿Por qué join() es un método de cadena de caracteres en lugar de
      un método de lista o tupla?

    * ¿Qué tan rápido van las excepciones?

    * ¿Por qué no hay un *switch* o una declaración *case* en Python?

    * ¿No puede emular hilos en el intérprete en lugar de confiar en
      una implementación de hilos específica del sistema operativo?

    * ¿Por qué las expresiones lambda no pueden contener sentencias?

    * ¿Se puede compilar Python en código máquina, C o algún otro
      lenguaje?

    * ¿Cómo gestiona Python la memoria?

    * ¿Por qué CPython no utiliza un esquema de recolección de basura
      más tradicional?

    * ¿Por qué no se libera toda la memoria cuando sale CPython?

    * ¿Por qué hay tipos de datos separados de tuplas y listas?

    * ¿Cómo se implementan las listas en Python?

    * ¿Cómo se implementan los diccionarios en CPython?

    * ¿Por qué las claves del diccionario deben ser inmutables?

    * ¿Por qué list.sort() no retorna la lista ordenada?

    * ¿Cómo se especifica y aplica una especificación de interfaz en
      Python?

    * ¿Por qué no hay goto?

    * ¿Por qué las cadenas de caracteres sin formato (r-strings) no
      pueden terminar con una barra diagonal inversa?

    * ¿Por qué Python no tiene una declaración "with" para las
      asignaciones de atributos?

    * ¿Por qué los generadores no admiten la declaración with?

    * ¿Por qué se requieren dos puntos para las declaraciones
      if/while/def/class?

    * ¿Por qué Python permite comas al final de las listas y tuplas?

  * Preguntas frecuentes sobre bibliotecas y extensiones

    * Cuestiones generales sobre bibliotecas

    * Tareas comunes

    * Hilos

    * Entrada y salida

    * Programación de Redes/Internet

    * Bases de datos

    * Matemáticas y numérica

  * Extendiendo/Embebiendo FAQ

    * ¿Puedo crear mis propias funciones en C?

    * ¿Puedo crear mis propias funciones en C++?

    * Escribir en C es difícil; ¿no hay otra alternativa?

    * ¿Cómo puedo ejecutar declaraciones arbitrarias de Python desde
      C?

    * ¿Cómo puedo evaluar una expresión arbitraria de Python desde C?

    * ¿Cómo extraigo valores C de un objeto Python?

    * ¿Cómo utilizo Py_BuildValue() para crear una tupla de un tamaño
      arbitrario?

    * ¿Cómo puedo llamar un método de un objeto desde C?

    * ¿Cómo obtengo la salida de PyErr_Print() (o cualquier cosa que
      se imprime a stdout/stderr)?

    * ¿Cómo accedo al módulo escrito en Python desde C?

    * ¿Cómo hago una interface a objetos C++ desde Python?

    * He agregado un módulo usando el archivo de configuración y el
      *make* falla. ¿Porque?

    * ¿Cómo puedo depurar una extensión?

    * Quiero compilar un módulo Python en mi sistema Linux, pero me
      faltan algunos archivos . ¿Por qué?

    * ¿Cómo digo "entrada incompleta" desde "entrada inválida"?

    * ¿Cómo encuentro símbolos g++ __builtin_new o __pure_virtual?

    * ¿Puedo crear una clase objeto con algunos métodos implementado
      en C y otros en Python (por ejemplo a través de la herencia)?

  * Preguntas frecuentes sobre Python en Windows

    * ¿Cómo ejecutar un programa Python en Windows?

    * ¿Cómo hacer que los scripts de Python sean ejecutables?

    * ¿Por qué Python tarda en comenzar?

    * ¿Cómo hacer un ejecutable a partir de un script de Python?

    * ¿Es un archivo "*.pyd" lo mismo que una DLL?

    * ¿Cómo puedo integrar Python en una aplicación de Windows?

    * ¿Cómo puedo evitar que mi editor inserte pestañas en mi archivo
      fuente de Python?

    * ¿Cómo verifico una pulsación de tecla sin bloquearla?

    * ¿Cómo resuelvo el error de api-ms-win-crt-runtime-l1-1-0.dll no
      encontrado?

  * Preguntas frecuentes sobre la Interfaz Gráfica de Usuario (*GUI*)

    * Preguntas generales de la GUI

    * ¿Qué conjuntos de herramientas de GUI existen para Python?

    * Preguntas de Tkinter

  * "¿Por qué está Python instalado en mi ordenador?" FAQ

    * ¿Qué es Python?

    * ¿Por qué Python está instalado en mi máquina?

    * ¿Puedo eliminar Python?

* Glosario

* Acerca de estos documentos

  * Contribuidores de la documentación de Python

* Lidiar con errores

  * Documentación de errores

  * Utilizar el issue tracker de Python

  * Para empezar a contribuir en Python

* Derechos de autor

* Historia y Licencia

  * Historia del software

  * Términos y condiciones para acceder o usar Python

    * ACUERDO DE LICENCIA DE PSF PARA PYTHON | lanzamiento |

    * ACUERDO DE LICENCIA DE BEOPEN.COM PARA PYTHON 2.0

    * ACUERDO DE LICENCIA CNRI PARA PYTHON 1.6.1

    * ACUERDO DE LICENCIA CWI PARA PYTHON 0.9.0 HASTA 1.2

    * LICENCIA BSD DE CLÁUSULA CERO PARA CÓDIGO EN EL PYTHON |
      lanzamiento | DOCUMENTACIÓN

  * Licencias y reconocimientos para software incorporado

    * Mersenne Twister

    * Sockets

    * Servicios de socket asincrónicos

    * Gestión de cookies

    * Seguimiento de ejecución

    * funciones UUencode y UUdecode

    * Llamadas a procedimientos remotos XML

    * test_epoll

    * Seleccionar kqueue

    * SipHash24

    * strtod y dtoa

    * OpenSSL

    * expat

    * libffi

    * zlib

    * cfuhash

    * libmpdec

    * Conjunto de pruebas W3C C14N

    * Audioop

    * asyncio
