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

* Qué hay de nuevo en Python

  * What's New In Python 3.9

    * Summary -- Release highlights

    * You should check for DeprecationWarning in your code

    * New Features

      * Dictionary Merge & Update Operators

      * New String Methods to Remove Prefixes and Suffixes

      * Type Hinting Generics in Standard Collections

      * New Parser

    * Other Language Changes

    * New Modules

      * zoneinfo

      * graphlib

    * Improved Modules

      * ast

      * asyncio

      * compileall

      * concurrent.futures

      * curses

      * datetime

      * distutils

      * fcntl

      * ftplib

      * gc

      * hashlib

      * http

      * IDLE and idlelib

      * imaplib

      * importlib

      * inspect

      * ipaddress

      * math

      * multiprocessing

      * nntplib

      * os

      * pathlib

      * pdb

      * poplib

      * pprint

      * pydoc

      * random

      * signal

      * smtplib

      * socket

      * time

      * sys

      * tempfile

      * tracemalloc

      * typing

      * unicodedata

      * venv

      * xml

    * Optimizations

    * Deprecated

    * Removed

    * Porting to Python 3.9

      * Changes in the Python API

      * Changes in the C API

      * CPython bytecode changes

    * Build Changes

    * C API Changes

      * New Features

      * Porting to Python 3.9

      * Removed

    * Notable changes in Python 3.9.1

      * typing

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

    * Notable changes in Python 3.9.2

      * collections.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

    * Notable changes in 3.9.20

      * ipaddress

      * email

  * 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

    * Cambios notables en Python 3.8.8

    * Notable changes in Python 3.8.12

  * Que 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.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

  * What's New In Python 3.6

    * Summary -- Release highlights

    * New Features

      * PEP 498: Formatted string literals

      * PEP 526: Syntax for variable annotations

      * PEP 515: Underscores in Numeric Literals

      * PEP 525: Asynchronous Generators

      * PEP 530: Asynchronous Comprehensions

      * PEP 487: Simpler customization of class creation

      * PEP 487: Descriptor Protocol Enhancements

      * PEP 519: Adding a file system path protocol

      * PEP 495: Local Time Disambiguation

      * PEP 529: Change Windows filesystem encoding to UTF-8

      * PEP 528: Change Windows console encoding to UTF-8

      * PEP 520: Preserving Class Attribute Definition Order

      * PEP 468: Preserving Keyword Argument Order

      * New *dict* implementation

      * PEP 523: Adding a frame evaluation API to CPython

      * PYTHONMALLOC environment variable

      * DTrace and SystemTap probing support

    * Other Language Changes

    * New Modules

      * secrets

    * Improved Modules

      * array

      * ast

      * asyncio

      * binascii

      * cmath

      * collections

      * concurrent.futures

      * contextlib

      * datetime

      * decimal

      * distutils

      * email

      * encodings

      * enum

      * faulthandler

      * fileinput

      * hashlib

      * http.client

      * idlelib and IDLE

      * importlib

      * inspect

      * json

      * logging

      * math

      * multiprocessing

      * os

      * pathlib

      * pdb

      * pickle

      * pickletools

      * pydoc

      * random

      * re

      * readline

      * rlcompleter

      * shlex

      * site

      * sqlite3

      * socket

      * socketserver

      * ssl

      * statistics

      * struct

      * subprocess

      * sys

      * telnetlib

      * time

      * timeit

      * tkinter

      * traceback

      * tracemalloc

      * typing

      * unicodedata

      * unittest.mock

      * urllib.request

      * urllib.robotparser

      * venv

      * warnings

      * winreg

      * winsound

      * xmlrpc.client

      * zipfile

      * zlib

    * Optimizations

    * Build and C API Changes

    * Other Improvements

    * Deprecated

      * New Keywords

      * Deprecated Python behavior

      * Deprecated Python modules, functions and methods

        * asynchat

        * asyncore

        * dbm

        * distutils

        * grp

        * importlib

        * os

        * re

        * ssl

        * tkinter

        * venv

      * Deprecated functions and types of the C API

      * Deprecated Build Options

    * Removed

      * API and Feature Removals

    * Porting to Python 3.6

      * Changes in 'python' Command Behavior

      * Changes in the Python API

      * Changes in the C API

      * CPython bytecode changes

    * Notable changes in Python 3.6.2

      * New "make regen-all" build target

      * Removal of "make touch" build target

    * Notable changes in Python 3.6.4

    * Notable changes in Python 3.6.5

    * Notable changes in Python 3.6.7

    * Notable changes in Python 3.6.10

    * Notable changes in Python 3.6.13

  * 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"

  * What's New In Python 3.4

    * Summary -- Release Highlights

    * New Features

      * PEP 453: Explicit Bootstrapping of PIP in Python Installations

        * Bootstrapping pip By Default

        * Documentation Changes

      * PEP 446: Newly Created File Descriptors Are Non-Inheritable

      * Improvements to Codec Handling

      * PEP 451: A ModuleSpec Type for the Import System

      * Other Language Changes

    * New Modules

      * asyncio

      * ensurepip

      * enum

      * pathlib

      * selectors

      * statistics

      * tracemalloc

    * Improved Modules

      * abc

      * aifc

      * argparse

      * audioop

      * base64

      * collections

      * colorsys

      * contextlib

      * dbm

      * dis

      * doctest

      * email

      * filecmp

      * functools

      * gc

      * glob

      * hashlib

      * hmac

      * html

      * http

      * idlelib and IDLE

      * importlib

      * inspect

      * ipaddress

      * logging

      * marshal

      * mmap

      * multiprocessing

      * operator

      * os

      * pdb

      * pickle

      * plistlib

      * poplib

      * pprint

      * pty

      * pydoc

      * re

      * resource

      * select

      * shelve

      * shutil

      * smtpd

      * smtplib

      * socket

      * sqlite3

      * ssl

      * stat

      * struct

      * subprocess

      * sunau

      * sys

      * tarfile

      * textwrap

      * threading

      * traceback

      * types

      * urllib

      * unittest

      * venv

      * wave

      * weakref

      * xml.etree

      * zipfile

    * CPython Implementation Changes

      * PEP 445: Customization of CPython Memory Allocators

      * PEP 442: Safe Object Finalization

      * PEP 456: Secure and Interchangeable Hash Algorithm

      * PEP 436: Argument Clinic

      * Other Build and C API Changes

      * Other Improvements

      * Significant Optimizations

    * Deprecated

      * Deprecations in the Python API

      * Deprecated Features

    * Removed

      * Operating Systems No Longer Supported

      * API and Feature Removals

      * Code Cleanups

    * Porting to Python 3.4

      * Changes in 'python' Command Behavior

      * Changes in the Python API

      * Changes in the C API

    * Changed in 3.4.3

      * PEP 476: Enabling certificate verification by default for
        stdlib http clients

  * Que novedades hay 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

    * New and Improved Modules

      * New module: importlib

      * New module: sysconfig

      * ttk: Themed Widgets for Tk

      * Updated module: unittest

      * Updated module: ElementTree 1.3

    * Build and C API Changes

      * Capsules

      * Port-Specific Changes: Windows

      * Port-Specific Changes: Mac OS X

      * Port-Specific Changes: FreeBSD

    * Other Changes and Fixes

    * Porting to Python 2.7

    * New Features Added to Python 2.7 Maintenance Releases

      * Two new environment variables for debug mode

      * PEP 434: IDLE Enhancement Exception for All Branches

      * PEP 466: Network Security Enhancements for Python 2.7

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

        * Bootstrapping pip By Default

        * Documentation Changes

      * PEP 476: Enabling certificate verification by default for
        stdlib http clients

      * PEP 493: HTTPS verification migration tools for Python 2.7

      * New "make regen-all" build target

      * Removal of "make touch" build target

    * Acknowledgements

  * 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" As a Function

    * PEP 3110: Exception-Handling Changes

    * PEP 3112: Byte Literals

    * PEP 3116: New I/O Library

    * PEP 3118: Revised Buffer Protocol

    * PEP 3119: Abstract Base Classes

    * PEP 3127: Integer Literal Support and Syntax

    * PEP 3129: Class Decorators

    * PEP 3141: A Type Hierarchy for Numbers

      * The "fractions" Module

    * Other Language Changes

      * Optimizaciones

      * Interpreter Changes

    * New and Improved Modules

      * The "ast" module

      * The "future_builtins" module

      * The "json" module: JavaScript Object Notation

      * The "plistlib" module: A Property-List Parser

      * ctypes Enhancements

      * Improved SSL Support

    * Deprecations and Removals

    * Build and C API Changes

      * Port-Specific Changes: Windows

      * Port-Specific Changes: Mac OS X

      * Port-Specific Changes: IRIX

    * Porting to Python 2.6

    * Agradecimientos

  * Novedades de 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

  * What's New in Python 2.4

    * PEP 218: Built-In Set Objects

    * PEP 237: Unifying Long Integers and Integers

    * PEP 289: Generator Expressions

    * PEP 292: Simpler String Substitutions

    * PEP 318: Decorators for Functions and Methods

    * PEP 322: Reverse Iteration

    * PEP 324: New subprocess Module

    * PEP 327: Decimal Data Type

      * Why is Decimal needed?

      * The "Decimal" type

      * The "Context" type

    * PEP 328: Multi-line Imports

    * PEP 331: Locale-Independent Float/String Conversions

    * Other Language Changes

      * Optimizations

    * New, Improved, and Deprecated Modules

      * cookielib

      * doctest

    * Build and C API Changes

      * Port-Specific Changes

    * Porting to Python 2.4

    * Acknowledgements

  * 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

      * Date/Time Type

      * The optparse Module

    * Pymalloc: A Specialized Object Allocator

    * Build and C API Changes

      * Port-Specific Changes

    * Other Changes and Fixes

    * Porting to Python 2.3

    * Acknowledgements

  * 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

  * Novedades de 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

  * Novedades de 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

  * Changelog

    * Python 3.9.21 final

      * Tests

      * Security

      * Library

      * Documentation

    * Python 3.9.20 final

      * Windows

      * Tests

      * Security

      * Library

      * Core and Builtins

    * Python 3.9.19 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Windows

      * Tools/Demos

    * Python 3.9.18 final

      * Security

      * Library

      * Tools/Demos

      * C API

    * Python 3.9.17 final

      * Security

      * Core and Builtins

      * Library

      * Windows

      * macOS

    * Python 3.9.16 final

      * Security

    * Python 3.9.15 final

      * Security

      * Core and Builtins

      * Library

      * Windows

      * macOS

    * Python 3.9.14 final

      * Security

      * Core and Builtins

      * Library

      * Tests

    * Python 3.9.13 final

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

    * Python 3.9.12 final

      * Core and Builtins

      * Library

    * Python 3.9.11 final

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

    * Python 3.9.10 final

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.9.9 final

      * Core and Builtins

      * Library

      * Documentation

      * Windows

    * Python 3.9.8 final

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.9.7 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

    * Python 3.9.6 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.9.5 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Windows

      * macOS

      * IDLE

    * Python 3.9.4 final

      * Core and Builtins

      * Library

    * Python 3.9.3 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * macOS

      * IDLE

    * Python 3.9.2 final

      * Windows

    * Python 3.9.2 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.9.1 final

      * Core and Builtins

      * Library

      * Tests

      * macOS

      * IDLE

    * Python 3.9.1 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.9.0 final

      * Library

      * Tests

      * Build

    * Python 3.9.0 release candidate 2

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * C API

    * Python 3.9.0 release candidate 1

      * Core and Builtins

      * Library

      * Documentation

      * Windows

      * IDLE

    * Python 3.9.0 beta 5

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * macOS

      * IDLE

      * C API

    * Python 3.9.0 beta 4

      * Security

      * Core and Builtins

      * Library

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.9.0 beta 3

      * Library

      * Build

    * Python 3.9.0 beta 2

      * Core and Builtins

      * Library

      * 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

* Tutorial de Python

  * 1. Abriendo el apetito

  * 2. Usando el intérprete de Python

    * 2.1. Invocando al 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. Cadenas de caracteres

      * 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. Definiendo funciones

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

      * 4.7.1. Argumentos con valores por omisión

      * 4.7.2. Palabras claves como argumentos

      * 4.7.3. Parámetros especiales

        * 4.7.3.1. Argumentos posicionales o de palabras claves

        * 4.7.3.2. Parámetros únicamente posicionales

        * 4.7.3.3. Argumentos únicamente de palabras clave

        * 4.7.3.4. Ejemplos de Funciones

        * 4.7.3.5. Resumen

      * 4.7.4. Listas de argumentos arbitrarios

      * 4.7.5. Desempaquetando una lista de argumentos

      * 4.7.6. Expresiones lambda

      * 4.7.7. Cadenas de texto de documentación

      * 4.7.8. Anotación de funciones

    * 4.8. Intermezzo: Estilo de codificación

  * 5. Estructuras de datos

    * 5.1. Más sobre listas

      * 5.1.1. Usando listas como pilas

      * 5.1.2. Usando 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. Ejecutando 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. Importando * 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

  * 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

  * 3. Uso de Python en Windows

    * 3.1. El instalador completo

      * 3.1.1. Pasos para la instalación

      * 3.1.2. Quitar el límite de MAX_PATH

      * 3.1.3. Instalación sin interfaz de usuario

      * 3.1.4. Instalación sin descargas

      * 3.1.5. Modificar una instalación

    * 3.2. El paquete Microsoft Store

      * 3.2.1. Problemas conocidos

    * 3.3. El paquete de nuget.org

    * 3.4. El paquete incrustable

      * 3.4.1. Aplicación Python

      * 3.4.2. Incrustar Python

    * 3.5. Distribuciones alternativas

    * 3.6. Configuración de Python

      * 3.6.1. Excurso: configurar variables de entorno

      * 3.6.2. Encontrar el ejecutable de Python

    * 3.7. Modo UTF-8

    * 3.8. Lanzador de Python para Windows

      * 3.8.1. Comenzar

        * 3.8.1.1. Desde la línea de comandos

        * 3.8.1.2. Entornos virtuales

        * 3.8.1.3. Desde un script

        * 3.8.1.4. Desde asociaciones de archivos

      * 3.8.2. Líneas shebang

      * 3.8.3. Argumentos en líneas shebang

      * 3.8.4. Personalización

        * 3.8.4.1. Personalización con archivos INI

        * 3.8.4.2. Personalizar las versiones de Python
          predeterminadas

      * 3.8.5. Diagnóstico

    * 3.9. Encontrar módulos

    * 3.10. Módulos adicionales

      * 3.10.1. PyWin32

      * 3.10.2. cx_Freeze

    * 3.11. Compilar Python en Windows

    * 3.12. Otras plataformas

  * 4. Using Python on a Mac

    * 4.1. Obteniendo e instalando MacPython

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

      * 4.1.2. Ejecutar scripts con una GUI

      * 4.1.3. Configuración

    * 4.2. El IDE

    * 4.3. Instalación de paquetes adicionales de Python

    * 4.4. Programación de GUI en Mac

    * 4.5. Distribuyendo aplicaciones de Python en la Mac

    * 4.6. Otros recursos

  * 5. 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. Clases reservadas de identificadores

    * 2.4. Literales

      * 2.4.1. Literales de cadenas y bytes

      * 2.4.2. Concatenación de literales de cadena

      * 2.4.3. Literales de cadena formateados

      * 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.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.2.4.1. Notas sobre el uso de  *__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. 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. Problemas sin resolver

    * 5.10. 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.5. La sentencia "with"

    * 8.6. Definiciones de funciones

    * 8.7. Definiciones de clase

    * 8.8. Corrutinas

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

      * 8.8.2. La sentencia "async for"

      * 8.8.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

  * 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

    * Tipo Alias Genérico

      * Standard Generic Classes

      * Special Attributes of "GenericAlias" objects

    * 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

    * Integer string conversion length limitation

      * Affected APIs

      * Configuring the limit

      * Recommended configuration

  * Excepciones incorporadas

    * Exception context

    * Inheriting from built-in exceptions

    * Clases base

    * Excepciones específicas

      * Excepciones del sistema operativo

    * Advertencias

    * 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

      * 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

      * Objetos de Completado

  * 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

        * Formato de caracteres

        * Ejemplos

      * 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"

      * Comportamiento "strftime()" y "strptime()"

        * Códigos de formato "strftime()" y "strptime()"

        * 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

    * "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

    * "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

      * Búsqueda en listas ordenadas

      * Otros ejemplos

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

    * "weakref" --- Referencias débiles

      * Objetos de Referencias Débiles

      * Ejemplo

      * Objetos Finalizadores

      * Comparando finalizadores con los métodos "__del__()"

    * "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

      * Objetos *PrettyPrinter*

      * Ejemplo

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

      * Objetos Repr

      * Subclasificando Objetos Repr

    * "enum" — Soporte para enumeraciones

      * Contenido del Módulo

      * Creando un Enum

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

      * Duplicando miembros y valores enum

      * Garantizando valores de enumeración únicos

      * Usando valores automáticos

      * Iteración

      * Comparaciones

      * Miembros permitidos y atributos de enumeraciones

      * Subclases restringidas de Enum

      * Serialización

      * API Funcional

      * Enumeraciones derivadas

        * IntEnum

        * IntFlag

        * Bandera

        * Otros

      * Cuándo usar "__new__()" contra "__init__()"

      * Ejemplos interesantes

        * Omitir valores

          * Usando "auto"

          * Usando "object"

          * Usando una cadena descriptiva

          * Usando  "__new__()" personalizados

        * OrderedEnum

        * DuplicateFreeEnum

        * Planeta

        * Periodo de tiempo

      * ¿Cómo son diferentes las Enums?

        * Clases Enum

        * Miembros de Enum (también conocidos como instancias)

        * Puntos más finos

          * Nombres soportados "__dunder__"

          * Nombres "_sunder_" compatibles

          * _Private__names

          * Tipo de miembro "Enum"

          * Valor booleano de las clases y miembros "Enum"

          * "Enum" clases con métodos

          * Combinando miembros de``Flag``

    * "graphlib" --- Functionality to operate with graph-like
      structures

      * Exceptions

  * 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

      * 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" --- Object-oriented filesystem paths

      * 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" --- La reinterpretación de GNU de dbm

      * "dbm.ndbm" --- Interfaz basada en ndbm

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

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

      * Funciones y constantes del módulo

      * Objetos de conexión

      * Objetos Cursor

      * Objetos Fila (*Row*)

      * Excepciones

      * SQLite y tipos de Python

        * Introducción

        * Usando adaptadores para almacenar tipos adicionales de
          Python en bases de datos SQLite

          * Permitiéndole al objeto auto adaptarse

          * Registrando un adaptador invocable

        * Convertir valores SQLite a tipos de Python personalizados

        * Adaptadores y convertidores por defecto

      * Controlando Transacciones

      * Usando "sqlite3" eficientemente

        * Usando métodos atajo

        * Accediendo a las columnas por el nombre en lugar del índice

        * Usando la conexión como un administrador de contexto

  * 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

    * "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

      * Resúmenes SHAKE de largo variable

      * 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

      * 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

      * 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" --- Tiempo de acceso 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

      * 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*

    * "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

      * Security considerations

      * Esquema del diccionario de configuración

        * Detalles del esquema del diccionario

        * Configuración incremental

        * Conexiones de objeto

        * Objetos definidos por el usuario

        * 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

      * macOS Platform

      * Plataformas Unix

    * "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

        * 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" ---  Proporciona memoria
      compartida para acceso directo a través de procesos

    * El paquete "concurrent"

    * "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()"

        * Cómo reemplazar las funciones del módulo "popen2"

      * Funciones de llamada a la shell de retrocompatibilidad

      * Notas

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

    * "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

      * Corrutinas y Tareas

        * Corrutinas

        * Esperables

        * Ejecutando un programa asyncio

        * Creando Tareas

        * 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

        * Corrutinas basadas en generadores

      * 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

      * 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

      * Í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

      * Soporte LibreSSL

    * "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

      * Ejemplo

      * Nota sobre SIGPIPE

      * Note on Signal Handlers and Exceptions

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

      * Constantes MADV_*

  * 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

      * Objetos :class:'Mailbox'

        * "Maildir"

        * "mbox"

        * "MH"

        * "Babyl"

        * "MMDF"

      * Objetos "Message"

        * "MaildirMessage"

        * "mboxMessage"

        * "MHMessage"

        * "BabylMessage"

        * "MMDFMessage"

      * Excepciones

      * Ejemplos

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

      * Objetos MimeTypes

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

    * "binhex" --- Codificar y decodificar archivos binhex4

      * Notas

    * "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

      * El paquete "defusedxml"

    * "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" --- Clases base para los handlers SAX

      * Objetos ContentHandler

      * Objetos DTDHandler

      * Objetos EntityResolver

      * Objetos ErrorHandler

    * "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" --- Cómodo controlador de navegador web

      * 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*

      * 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

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

      * Objetos de "HTTPConnection"

      * Objetos de "HTTPResponse"

      * Ejemplos

      * Objetos de "HTTPMessage"

    * "ftplib" --- cliente de protocolo FTP

      * Objetos FTP

      * Objetos FTP_TLS

    * "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

      * Security Considerations

    * "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" --- Módulos XMLRPC para cliente y servidor

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

      * Objetos *ServerProxy*

      * Objetos *DateTime*

      * Objetos binarios

      * Objetos Faults

      * Objetos ProtocolError

      * Objectos 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 de caracteres 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 a 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

      * Reseña de los métodos disponibles para Turtle y *Screen*

        * 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

      * 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

      * Módulos Tkinter

      * Guía de supervivencia de Tkinter

        * Cómo usar esta sección

        * Un simple programa Hola Mundo

      * Una (muy) rápida mirada a Tcl/Tk

      * Mapeo básico de Tk en Tkinter

      * Cómo se relacionan Tk y Tkinter

      * 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

        * Terminaciones

        * Sugerencias de llamada

        * Contexto del código

        * Shell de Python

        * 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

  * Herramientas de desarrollo

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

      * Relevant PEPs

      * Alias de tipo

      * NewType

      * Callable

      * Genéricos

      * 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

          * Tipos de construcción de genéricos

          * Otras directivas especiales

        * Colecciones genéricas concretas

          * Correspondientes a tipos integrados

          * Correspondiente a tipos en "collections"

          * Otros tipos concretos

        * Clase base abstracta para tipos genéricos

          * Correspondientes a las colecciones en "collections.abc"

          * Correspondiente a otros tipos en "collections.abc"

          * Programación asíncrona

          * Tipos del administrador de contextos

        * Protocolos

        * Funciones y decoradores

        * Ayudas de introspección

        * Constantes

    * "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

    * "unittest.mock" --- primeros pasos

      * Usando Mock

        * Métodos de parcheo Mock

        * Mock de llamadas a métodos sobre un objeto

        * Clases Mocking

        * 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

      * 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 de código Python 2 a 3

      * Usando 2to3

      * Fixers

      * "lib2to3" - librería 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

  * 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

      * 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

      * Otras funciones

      * Usando "sysconfig" como un script

    * "builtins" --- Objetos incorporados

    * "__main__" --- Entorno de script del nivel superior

    * "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" --- Clases de datos

      * Decoradores, clases y funciones del módulo

      * Procesamiento posterior a la inicialización

      * Variables de clase

      * Variable de solo inicialización

      * Instancias congeladas

      * Herencia

      * Funciones fábrica por defecto

      * Valores por defecto mutables

      * Excepciones

    * "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

      * Objetos "TracebackException"

      * Objetos "StackSummary"

      * Objetos "FrameSummary"

      * Ejemplos de seguimiento de pila

    * "__future__" --- Definiciones de declaraciones futuras

    * "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

      * 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.resources" -- Recursos

      * "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

        * Configurar un importador

        * Aproximando "importlib.import_module()"

    * Usando importlib.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

      * Distribuciones

      * Extendiendo el algoritmo de búsqueda

  * Servicios del lenguaje Python

    * "parser" --- Acceder a árboles de análisis sintáctico de Python

      * Crear objetos ST

      * Convertir objetos ST

      * Consultas en objetos ST

      * Manejo de errores y excepciones

      * Objetos ST

      * Ejemplo: Emulación de "compile()"

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

      * Gramática abstracta

      * Clases Nodo

        * Literals

        * Variables

        * Expressions

          * Subscripting

          * Comprehensions

        * Statements

          * Imports

        * Control flow

        * Function and class definitions

        * Async and await

      * Ayudantes de "ast"

      * Compiler Flags

      * Command-Line Usage

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

      * Generando tablas de símbolos

      * Examinando la tabla de símbolos

    * "symbol" --- Constantes utilizadas con árboles de análisis de
      Python

    * "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

    * "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

      * 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 varios

    * "formatter" --- Formateo de salida genérica

      * La interfaz Formateador

      * Implementaciones del formateador

      * La interfaz Escritor

      * Implementaciones del escritor

  * 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

    * :mod:'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

  * 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

    * :mod:'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

    * "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 MailmanProxy

      * 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

  * Security Considerations

* 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

  * Interfaz binaria de aplicación estable

  * 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

    * Objectos 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

    * 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 Tipos

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

      * El objeto "None"

    * Objetos numéricos

      * Objetos Enteros

      * Objetos Booleanos

      * Objetos de punto flotante

      * 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 Tuplas

      * Objetos de secuencia de estructura

      * Objetos lista

    * Objetos contenedor

      * Objetos Diccionarios

      * 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

      * Objectos Modulo

        * 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

      * Objeto rebanada (*slice*)

      * Objeto Elipsis

      * Objetos de vista de memoria (*MemoryView*)

      * Objetos de referencia débil

      * Cápsulas

      * Objetos Generadores

      * Objetos corrutina

      * Objetos de variables de contexto

      * Objetos *DateTime*

      * Objects for Type Hinting

  * 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

    * PyWideStringList

    * PyStatus

    * PyPreConfig

    * Preinicialización con PyPreConfig

    * PyConfig

    * Inicialización con PyConfig

    * Configuración aislada

    * Configuración de Python

    * Configuración de ruta

    * Py_RunMain()

    * Py_GetArgcArgv()

    * API Provisional Privada de Inicialización Multifásica

  * Gestión de la memoria

    * Visión general

    * Interfaz de memoria sin procesar

    * Interfaz de memoria

    * Asignadores de objetos

    * Asignadores de memoria predeterminados

    * Personalizar asignadores de memoria

    * 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 Montículos (*Heap Types*)

    * 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

  * Versiones de API y ABI

* Distribuir módulos de Python

  * Términos clave

  * Licencias de código abierto y colaboración

  * Instalando las herramientas

  * Leyendo la "Python Packaging User Guide"

  * Cómo puedo...?

    * ... elegir un nombre para mi proyecto?

    * ... crear y distribuir extensiones binarias?

* 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

  * Portando código de Python 2 a Python 3

    * La breve explicación

    * Detalles

      * Compatibilidad con Python 2.6 y versiones anteriores

      * Asegúrese de especificar el soporte de versión adecuado en su
        archivo "setup.py"

      * Tener una buena cobertura de prueba

      * Aprende las diferencias entre Python 2 & 3

      * Actualiza tu código

        * División

        * Texto frente a datos binarios

        * Utilice la detección de funciones en lugar de la detección
          de versiones

      * Evitar regresiones de compatibilidad

      * Compruebe qué dependencias bloquean la transición

      * Actualice su archivo "setup.py" para denotar compatibilidad
        con Python 3

      * Utilice la integración continua para seguir siendo compatible

      * Considere la posibilidad de usar la comprobación de tipos
        estáticos opcionales

  * 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

      * Kinds of methods

      * Métodos estáticos

      * Métodos de clase

      * Objetos miembros y __slots__

  * 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

      * *Logging* de múltiples módulos

      * 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

    * Ejemplo de servidor de configuración

    * Tratar con gestores que bloquean

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

      * Running a logging socket listener in production

    * 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

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

      * Usando concurrent.futures.ProcessPoolExecutor

      * Deploying Web applications using Gunicorn and uWSGI

    * Usando rotación de archivos

    * Uso de estilos de formato alternativos

    * Personalización de "LogRecord"

    * Subclasificación QueueHandler - un ejemplo de ZeroMQ

    * Subclasificación QueueListener - un ejemplo de ZeroMQ

    * 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

    * 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

    * Patterns to avoid

      * Opening the same log file multiple times

      * Using loggers as attributes in a class or passing them as
        parameters

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

      * Creating a lot of loggers

  * 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 Remplazo

    * 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

    * El método tradicional utilizando *Decorate-Sort-Undecorate*

    * El método tradicional utilizando el Parámetro *cmp*

    * Comentarios finales

  * 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

    * 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

  * *How-To* Argument Clinic

    * Los objetivos del Argument Clinic

    * Conceptos básicos y uso

    * Convirtiendo su primera función

    * Temas avanzados

      * Valores predeterminados simbólicos

      * Cambiar el nombre de las funciones y variables C generadas por
        Argument Clinic

      * Convirtiendo funciones usando PyArg_UnpackTuple

      * Grupos opcionales

      * Usar convertidores de Argument Clinic reales, en lugar de
        "convertidores heredados"

      * Py_buffer

      * Convertidores avanzados

      * Valores predeterminados de los parámetros

      * El valor predeterminado "NULL"

      * Expresiones especificadas como valores por defecto

      * Usando un convertidor de retorno

      * Clonando funciones existentes

      * Llamando código Python

      * Usando un "auto convertidor"

      * Escribiendo un convertidor personalizado

      * Escribiendo un convertidor de retorno personalizado

      * METH_O y METH_NOARGS

      * funciones tp_new y tp_init

      * Cambiar y redirigir la salida de Clinic

      * El truco #ifdef

      * Usando Argument Clinic en archivos Python

  * 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

* 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?

    * Why don't generators support the with statement?

    * ¿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?

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

    * Preguntas generales de la GUI

    * What GUI toolkits exist for 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
