Python 3
¿Listo para dominar Python? En esta edición actualizada de la galardonada referencia sobre Python, aprende a escribir código eficaz, ya seas un principiante o un programador profesional. Repasa los conceptos fundamentales de Python, como las funciones, la modularización y la programación orientada a objetos, y conoce a fondo los tipos de datos disponibles. Luego, sumérgete en temas más avanzados, como el manejo de excepciones, la verificación estática de tipos y las expresiones regulares. Con un sinfín de ejemplos de código a lo largo del libro, esta guía práctica tiene todo lo que necesitas para dominar Python.
- El manual completo de Python 3
- Aprende los principios básicos de Python y trabaja con funciones, métodos, tipos de datos y mucho más
- Explora las interfaces gráficas de usuario (GUI), la programación de redes, la depuración, la optimización y otros temas avanzados
Aprenderás sobre:
- Programación con Python:
¡Aprende sobre la sintaxis y la estructura de Python! Sigue los ejemplos para comenzar a desarrollar y probar tus propios programas utilizando código descargable.
- La biblioteca estándar:
Explora la biblioteca integrada de Python y descubre cómo se puede utilizar para una gran variedad de tareas, desde ejecutar funciones matemáticas hasta depurar código.
- Técnicas avanzadas de programación:
¿Ya conoces los conceptos básicos? Mejora tus habilidades profesionales con conceptos más avanzados, como las interfaces gráficas de usuario (GUI), Django, la computación científica y la integración con otros lenguajes.
Aspectos Destacados:
- Funciones
- Métodos
- Atributos
- Tipos de datos
- Interfaces gráficas de usuario
- Depuración
- Comunicación en red
- Modularización
- Orientación a objetos
- Iteradores
- Generadores
- Manejo de excepciones
Ver Tabla de Contenidos Completa
- 1 Introducción
- 1.1 ¿Por qué escribimos este libro?
- 1.2 ¿Qué ofrece este libro?
- 1.3 Estructura del libro
- 1.4 ¿Cómo se debe leer este libro?
- 1.5 Programas de ejemplo
- 1.6 Prefacio a la segunda edición en inglés (2026)
- 1.7 Agradecimientos
- 2 El lenguaje de programación Python
- 2.1 Historia y origen
- 2.2 Conceptos básicos
- 2.3 Posibles ámbitos de aplicación y fortalezas
- 2.4 Instalación de Python
- 2.4.1 Instalación de Anaconda en Windows
- 2.4.2 Instalación de Anaconda en macOS
- 2.4.3 Instalación de Anaconda en Linux
- 2.5 Instalación de módulos de terceros
- 2.6 Uso de Python
- PARTE I Introducción a Python
- 3 Primeros pasos con el modo interactivo
- 3.1 Números enteros
- 3.2 Números flotantes
- 3.3 Cadenas de caracteres
- 3.4 Listas
- 3.5 Diccionarios
- 3.6 Variables
- 3.6.1 El significado especial del guión bajo
- 3.6.2 Identificadores
- 3.7 Expresiones lógicas
- 3.8 Funciones y métodos
- 3.8.1 Funciones
- 3.8.2 Métodos
- 3.9 Salidas en pantalla
- 3.10 Módulos
- 4 El camino hacia el primer programa
- 4.1 Escribir, compilar y probar
- 4.1.1 Windows
- 4.1.2 Linux y macOS
- 4.1.3 Shebang
- 4.1.4 Procesos internos
- 4.2 Estructura básica de un programa en Python
- 4.2.1 Ajustar líneas largas
- 4.2.2 Unión de varias líneas
- 4.3 El primer programa
- 4.3.1 Inicialización
- 4.3.2 Encabezado del bucle
- 4.3.3 Cuerpo del bucle
- 4.3.4 Salida en pantalla
- 4.4 Comentarios
- 4.5 En caso de error
- 5 Estructuras de control
- 5.1 Condicionales
- 5.1.1 La instrucción «if»
- 5.1.2 Expresiones condicionales
- 5.2 Bucles
- 5.2.1 El ciclo while
- 5.2.2 Finalización de un bucle
- 5.2.3 Detección de una interrupción del bucle
- 5.2.4 Abortar la iteración actual
- 5.2.5 El bucle «for»
- 5.3 La instrucción «pass»
- 5.4 Expresiones de asignación
- 5.4.1 Motivación
- 5.4.2 El juego de adivinar números con expresiones de asignación
- 6 Archivos
- 6.1 Flujos de datos
- 6.2 Lectura de datos de un archivo
- 6.2.1 Abrir y cerrar un archivo
- 6.2.2 La instrucción «with»
- 6.2.3 Lectura del contenido del archivo
- 6.3 Escribir datos en un archivo
- 6.4 Creación del objeto de archivo
- 6.4.1 La función integrada `open`
- 6.4.2 Atributos y métodos de un objeto de archivo
- 6.4.3 Cambio de la posición de escritura/lectura
- 7 El modelo de datos
- 7.1 La estructura de las instancias
- 7.1.1 Tipo de datos
- 7.1.2 Valor
- 7.1.3 Identidad
- 7.2 Eliminación de referencias
- 7.3 Tipos de datos mutables frente a inmutables
- 7.3.1 Tipos de datos mutables y efectos secundarios
- 8 Funciones, métodos y atributos
- 8.1 Parámetros de funciones y métodos
- 8.1.1 Parámetros posicionales
- 8.1.2 Argumentos de palabra clave
- 8.1.3 Parámetros opcionales
- 8.1.4 Parámetros solo por palabra clave
- 8.2 Atributos
- 9 Fuentes de información sobre Python
- 9.1 La función de ayuda incorporada
- 9.2 La documentación en línea
- 9.3 PEP
- PARTE II Tipos de datos
- 10 Tipos de datos básicos: una visión general
- 10.1 La nada: NoneType
- 10.2 Operadores
- 10.2.1 Precedencia de los operadores
- 10.2.2 Orden de evaluación
- 10.2.3 Concatenación de comparaciones
- 11 Tipos de datos numéricos
- 11.1 Operadores aritméticos
- 11.1.1 Asignaciones aumentadas
- 11.2 Operadores de comparación
- 11.3 Conversión entre tipos de datos numéricos
- 11.4 Números enteros: int
- 11.4.1 Sistemas numéricos
- 11.4.2 Operaciones con bits
- 11.4.3 El método bit_length
- 11.5 Números flotantes: float
- 11.5.1 Notación exponencial
- 11.5.2 Precisión
- 11.5.3 Infinito y «no es un número»
- 11.6 Valores booleanos: bool
- 11.6.1 Operadores lógicos
- 11.6.2 Valores de verdad de los tipos de datos no booleanos
- 11.6.3 Evaluación de operadores lógicos
- 11.7 Números complejos: complex
- 12 Tipos de datos secuenciales
- 12.1 La diferencia entre datos de texto y datos binarios
- 12.2 Operaciones sobre instancias de tipos de datos secuenciales
- 12.2.1 Verificación de elementos
- 12.2.2 Concatenación
- 12.2.3 Repetición
- 12.2.4 Indexación
- 12.2.5 Segmentación
- 12.2.6 Longitud de una secuencia
- 12.2.7 El elemento más pequeño y el más grande
- 12.2.8 Búsqueda de un elemento
- 12.2.9 Recuento de elementos
- 12.3 El tipo de datos «lista»
- 12.3.1 Modificación de un valor dentro de la lista: asignación mediante []
- 12.3.2 Reemplazo de sublistas e inserción de nuevos elementos: asignación mediante []
- 12.3.3 Eliminación de elementos y sublistas: del en combinación con []
- 12.3.4 Métodos de las instancias de lista
- 12.3.5 Ordenación de listas: s.sort([clave, inverso])
- 12.3.6 Efectos secundarios
- 12.3.7 Comprensiones de listas
- 12.4 Listas inmutables: tuple
- 12.4.1 Empaquetado y desempaquetado
- 12.4.2 ¡Inmutable no significa necesariamente inalterable!
- 12.5 Cadenas: str, bytes, bytearray
- 12.5.1 Caracteres de control
- 12.5.2 División de cadenas
- 12.5.3 Búsqueda de subcadenas
- 12.5.4 Reemplazo de subcadenas
- 12.5.5 Eliminación de prefijos y sufijos
- 12.5.6 Alineación de cadenas
- 12.5.7 Comparaciones de cadenas
- 12.5.8 Concatenación de elementos en tipos de datos secuenciales
- 12.5.9 Formateo de cadenas
- 12.5.10 Conjuntos de caracteres y caracteres especiales
- 12.5.11 Cadenas de plantilla
- 13 Mapeos y conjuntos
- 13.1 Diccionario: dict
- 13.1.1 Creación de un diccionario
- 13.1.2 Claves y valores
- 13.1.3 Iteración
- 13.1.4 Operadores
- 13.1.5 Métodos
- 13.1.6 Comprensiones de diccionarios
- 13.2 Conjuntos: set y frozenset
- 13.2.1 Creación de un conjunto
- 13.2.2 Iteración
- 13.2.3 Operadores
- 13.2.4 Métodos
- 13.2.5 Conjuntos mutables: set
- 13.2.6 Conjuntos inmutables: frozenset
- 14 Colecciones
- 14.1 Diccionarios encadenados
- 14.2 Recuento de frecuencias
- 14.2.1 d.elements()
- 14.2.2 d.most_common([n])
- 14.2.3 d.subtract([iterable])
- 14.2.4 d.update([iterable])
- 14.3 Diccionarios con valores por defecto
- 14.4 Listas doblemente enlazadas
- 14.5 Tuplas con nombres
- 14.5.1 namedtuple(nombre_tipo, nombres_de_campos, {renombrar})
- 15 Fecha y hora
- 15.1 Funciones elementales de tiempo: time
- 15.1.1 El tipo de datos struct_time
- 15.1.2 Constantes
- 15.1.3 Funciones
- 15.2 Gestión de fechas orientada a objetos: datetime
- 15.2.1 datetime.date
- 15.2.2 datetime.time
- 15.2.3 datetime.datetime
- 15.2.4 datetime.timedelta
- 15.2.5 Operaciones para datetime.datetime y datetime.date
- 15.3 Zonas horarias: zoneinfo
- 15.3.1 La base de datos de zonas horarias de la IANA
- 15.3.2 Especificación de la hora en zonas horarias locales
- 15.3.3 Cálculos con indicaciones de hora en zonas horarias locales
- 16 Enumeraciones y indicadores
- 16.1 Tipos de enumeración: enum
- 16.2 Tipos de enumeración para patrones de bits: Flag
- 16.3 Tipos de enumeración de enteros: IntEnum
- PARTE III Técnicas avanzadas de programación
- 17 Funciones
- 17.1 Definición de una función
- 17.2 Valores de retorno
- 17.3 Objetos de función
- 17.4 Parámetros opcionales
- 17.5 Argumentos de palabra clave
- 17.6 Número arbitrario de parámetros
- 17.7 Parámetros solo por palabra clave
- 17.8 Parámetros solo posicionales
- 17.9 Desempaquetado al llamar a una función
- 17.10 Efectos secundarios
- 17.11 Espacios de nombres
- 17.11.1 Acceso a variables globales: global
- 17.11.2 Acceso al espacio de nombres global
- 17.11.3 Funciones locales
- 17.11.4 Acceso a los espacios de nombres superiores: nonlocal
- 17.11.5 Variables locales sin vincular: un escollo
- 17.12 Funciones anónimas
- 17.13 Recursión
- 17.14 Funciones integradas
- 17.14.1 abs(x)
- 17.14.2 all(iterable)
- 17.14.3 any(iterable)
- 17.14.4 ascii(objeto)
- 17.14.5 bin(x)
- 17.14.6 bool([x])
- 17.14.7 bytearray([fuente, codificación, errores])
- 17.14.8 bytes([fuente, codificación, errores])
- 17.14.9 chr(i)
- 17.14.10 complex([real, imag])
- 17.14.11 dict([fuente])
- 17.14.12 divmod(a, b)
- 17.14.13 enumerate(iterable, [inicio])
- 17.14.14 eval(expresión, [globales, locales])
- 17.14.15 exec(objeto, [globales, locales])
- 17.14.16 filter(función, iterable)
- 17.14.17 float([x])
- 17.14.18 format(valor, [especificación_de_formato])
- 17.14.19 frozenset([iterable])
- 17.14.20 globals()
- 17.14.21 hash(objeto)
- 17.14.22 help([objeto])
- 17.14.23 hex(x)
- 17.14.24 id(objeto)
- 17.14.25 input([prompt])
- 17.14.26 int([x, base])
- 17.14.27 len(s)
- 17.14.28 lista([secuencia])
- 17.14.29 locals()
- 17.14.30 map(función, [*iterable, estricto])
- 17.14.31 max(iterable, {default, key}), max(arg1, arg2, [*args], {key})
- 17.14.32 min(iterable, {default, key}), min(arg1, arg2, [*args], {key})
- 17.14.33 oct(x)
- 17.14.34 ord(c)
- 17.14.35 pow(x, y, [z])
- 17.14.36 print([*objetos], {sep, fin, archivo, vaciar})
- 17.14.37 range([inicio], fin, [paso])
- 17.14.38 repr(objeto)
- 17.14.39 reversed(secuencia)
- 17.14.40 round(x, [n])
- 17.14.41 set([iterable])
- 17.14.42 ordenado(iterable, [clave, inverso])
- 17.14.43 str([objeto, codificación, errores])
- 17.14.44 sum(iterable, [start])
- 17.14.45 tuple([iterable])
- 17.14.46 type(objeto)
- 17.14.47 zip([*iterables], {strict})
- 18 Módulos y paquetes
- 18.1 Importación de módulos globales
- 18.2 Módulos locales
- 18.2.1 Conflictos de nombres
- 18.2.2 Referencias internas del módulo
- 18.2.3 Ejecución de módulos
- 18.3 Paquetes
- 18.3.1 Importación de todos los módulos de un paquete
- 18.3.2 Paquetes de espacio de nombres
- 18.3.3 Sentencias de importación relativa
- 18.4 El paquete importlib
- 18.5 Elementos del lenguaje previstos
- 19 Programación orientada a objetos
- 19.1 Ejemplo: una cuenta no orientada a objetos
- 19.1.1 Creación de una nueva cuenta
- 19.1.2 Transferencia de dinero
- 19.1.3 Depositar y retirar dinero
- 19.1.4 Consultar el saldo de la cuenta
- 19.2 Clases
- 19.2.1 Definición de métodos
- 19.2.2 El constructor
- 19.2.3 Atributos
- 19.2.4 Ejemplo: una cuenta orientada a objetos
- 19.3 Herencia
- 19.3.1 Un ejemplo sencillo
- 19.3.2 Sobrescritura de métodos
- 19.3.3 Ejemplo: Cuenta corriente con movimiento diario
- 19.3.4 Perspectivas
- 19.4 Herencia múltiple
- 19.4.1 Posibles dificultades de la herencia múltiple
- 19.5 Atributos de propiedad
- 19.5.1 Métodos setter y getter
- 19.5.2 Definición de atributos de propiedad
- 19.6 Métodos estáticos
- 19.6.1 Definición de métodos estáticos
- 19.7 Métodos de clase
- 19.8 Atributos de clase
- 19.9 Funciones integradas para la programación orientada a objetos
- 19.9.1 Funciones para administrar los atributos de una instancia
- 19.9.2 Funciones para obtener información sobre la jerarquía de clases
- 19.10 Herencia de tipos de datos integrados
- 19.11 Métodos mágicos y atributos mágicos
- 19.11.1 Métodos mágicos generales
- 19.11.2 Sobrecarga de operadores
- 19.11.3 Emulación de tipos de datos: tipado por comportamiento
- 19.12 Clases de datos
- 19.12.1 Tuplas y listas
- 19.12.2 Diccionarios
- 19.12.3 Tuplas con nombre
- 19.12.4 Clases de datos mutables
- 19.12.5 Clases de datos inmutables
- 19.12.6 Valores por defecto en clases de datos
- 20 Manejo de excepciones
- 20.1 Excepciones
- 20.1.1 Excepciones integradas
- 20.1.2 Generación de una excepción
- 20.1.3 Manejo de una excepción
- 20.1.4 Excepciones personalizadas
- 20.1.5 Re-lanzamiento de una excepción
- 20.1.6 Encadenamiento de excepciones
- 20.1.7 Notas sobre excepciones
- 20.2 Aserciones
- 20.3 Advertencias
- 20.4 Grupos de excepciones
- 20.4.1 Un grupo de excepciones
- 20.4.2 La instrucción try/except*
- 21 Generadores e iteradores
- 21.1 Generadores
- 21.1.1 Subgeneradores
- 21.1.2 Expresiones generadoras
- 21.2 Iteradores
- 21.2.1 El protocolo del iterador
- 21.2.2 Ejemplo: la secuencia de Fibonacci
- 21.2.3 Ejemplo: la proporción áurea
- 21.2.4 Un generador para la implementación de __iter__
- 21.2.5 Uso de iteradores
- 21.2.6 Múltiples iteradores para la misma instancia
- 21.2.7 Desventajas de los iteradores en comparación con el acceso directo mediante índices
- 21.2.8 Definición alternativa para objetos iterables
- 21.2.9 Iteradores de funciones
- 21.3 Generadores especiales: itertools
- 21.3.1 accumulate(iterable, [func])
- 21.3.2 batched(iterable, n, {strict})
- 21.3.3 chain([*iterables])
- 21.3.4 combinations(iterable, r)
- 21.3.5 combinations_with_replacement(iterable, r)
- 21.3.6 compress(datos, selectores)
- 21.3.7 count([inicio, paso])
- 21.3.8 ciclo(iterable)
- 21.3.9 dropwhile(predicado, iterable)
- 21.3.10 filterfalse(predicado, iterable)
- 21.3.11 groupby(iterable, [key])
- 21.3.12 islice(iterable, [inicio], fin, [paso])
- 21.3.13 permutaciones(iterable, [r])
- 21.3.14 product([*iterables], [repeat])
- 21.3.15 repeat(objeto, [veces])
- 21.3.16 starmap(función, iterable)
- 21.3.17 takewhile(predicado, iterable)
- 21.3.18 tee(iterable, [n])
- 21.3.19 zip_longest([*iterables], {valor de relleno})
- 21.4 Los generadores como consumidores
- 21.4.1 Generación de excepciones en un generador
- 21.4.2 Un ejemplo de aplicación para consumir funciones generadoras
- 22 Administrador de contexto
- 22.1 La instrucción with
- 22.1.1 __enter__(self)
- 22.1.2 __exit__(self, exc_type, exc_value, traceback)
- 22.2 Funciones auxiliares para contextos «with»: contextlib
- 22.2.1 Combinaciones de contextos ensambladas dinámicamente: ExitStack
- 22.2.2 Supresión de ciertos tipos de excepciones
- 22.2.3 Redirección del flujo de salida estándar
- 22.2.4 Contextos opcionales
- 22.2.5 Funciones simples como administradores de contexto
- 22.2.6 Cambio temporal del directorio de trabajo
- 23 Decoradores
- 23.1 Decoradores de funciones
- 23.1.1 Decoración de funciones y métodos
- 23.1.2 Nombre y cadena de documentación tras aplicar un decorador
- 23.1.3 Decoradores anidados
- 23.1.4 Ejemplo: un decorador de caché
- 23.2 Decoradores de clases
- 23.3 El módulo functools
- 23.3.1 Simplificación de las interfaces de funciones
- 23.3.2 Simplificación de las interfaces de métodos
- 23.3.3 Cachés
- 23.3.4 Completar ordenaciones de clases personalizadas
- 23.3.5 Sobrecarga de funciones
- 24 Anotaciones para la verificación de tipos estáticos
- 24.1 Anotaciones
- 24.1.1 Anotación de funciones y métodos
- 24.1.2 Anotación de variables y atributos
- 24.1.3 Acceso a las anotaciones en tiempo de ejecución
- 24.1.4 ¿Cuándo se evalúan las anotaciones?
- 24.2 Sugerencias de tipo: el módulo typing
- 24.2.1 Sugerencias de tipo válidas
- 24.2.2 Tipos contenedores
- 24.2.3 Tipos de contenedor abstractos
- 24.2.4 Alias de tipos
- 24.2.5 Uniones de tipos y valores opcionales
- 24.2.6 Literales
- 24.2.7 Variables de tipo
- 24.3 Verificación estática de tipos en Python: mypy
- 24.3.1 Instalación
- 24.3.2 Ejemplo
- 25 Coincidencia de patrones estructurales
- 25.1 La instrucción `match`
- 25.2 Tipos de patrones en la instrucción `case`
- 25.2.1 Patrones literales y de valores
- 25.2.2 Patrón OR
- 25.2.3 Patrones con verificación de tipo
- 25.2.4 Especificación de condiciones para coincidencias
- 25.2.5 Agrupación de subpatrones
- 25.2.6 Patrones de captura y comodines
- 25.2.7 Patrones de secuencia
- 25.2.8 Patrones de asignación
- 25.2.9 Patrones para objetos y los valores de sus atributos
- PARTE IV La biblioteca estándar
- 26 Matemáticas
- 26.1 Funciones matemáticas: math, cmath
- 26.1.1 Funciones matemáticas generales
- 26.1.2 Funciones exponenciales y logarítmicas
- 26.1.3 Funciones trigonométricas e hiperbólicas
- 26.1.4 Distancias y normas
- 26.1.5 Conversión de ángulos
- 26.1.6 Representaciones de números complejos
- 26.2 Generador de números aleatorios: random
- 26.2.1 Guardar y cargar el estado de «random»
- 26.2.2 Generación de números enteros aleatorios
- 26.2.3 Generación de números flotantes aleatorios
- 26.2.4 Operaciones aleatorias sobre secuencias
- 26.2.5 SystemRandom([semilla])
- 26.3 Cálculos estadísticos: estadísticas
- 26.4 Números decimales intuitivos: decimal
- 26.4.1 Uso del tipo de datos
- 26.4.2 Valores no numéricos
- 26.4.3 El objeto de contexto
- 26.5 Funciones hash: hashlib
- 26.5.1 Uso del módulo
- 26.5.2 Otros algoritmos hash
- 26.5.3 Comparación de archivos grandes
- 26.5.4 Contraseñas
- 27 Salidas en pantalla y registro
- 27.1 Salida formateada de objetos complejos: pprint
- 27.1.1 pprint(objeto, [flujo, sangría, ancho, profundidad], {compacto})
- 27.2 Archivos de registro: logging
- 27.2.1 Personalización del formato de los mensajes
- 27.2.2 Controladores de registro
- 28 Expresiones regulares
- 28.1 Sintaxis de las expresiones regulares
- 28.1.1 Cualquier carácter
- 28.1.2 Clases de caracteres
- 28.1.3 Cuantificadores
- 28.1.4 Clases de caracteres predefinidas
- 28.1.5 Otros caracteres especiales
- 28.1.6 Cuantificadores no avaros
- 28.1.7 Grupos
- 28.1.8 Alternativas
- 28.1.9 Extensiones
- 28.2 Uso del módulo re
- 28.2.1 Búsqueda
- 28.2.2 Coincidencia
- 28.2.3 División de una cadena
- 28.2.4 Reemplazo de partes de una cadena
- 28.2.5 Reemplazo de caracteres problemáticos
- 28.2.6 Compilación de una expresión regular
- 28.2.7 Indicadores
- 28.2.8 El objeto Match
- 28.3 Un programa de ejemplo sencillo: búsqueda
- 28.4 Un programa de ejemplo más complejo: coincidencia
- 28.5 Comentarios en expresiones regulares
- 28.6 Retroceso catastrófico
- 29 Interfaz con el sistema operativo y el entorno de ejecución
- 29.1 Funcionalidad del sistema operativo: os
- 29.1.1 environ
- 29.1.2 getpid()
- 29.1.3 cpu_count()
- 29.1.4 system(cmd)
- 29.1.5 popen(comando, [modo, almacenamiento en búfer])
- 29.2 Inicio de subprocesos: subprocess
- 29.2.1 Inicio de un subproceso
- 29.2.2 Los flujos predeterminados: stdin, stdout y stderr
- 29.2.3 El código de retorno
- 29.2.4 Variables de entorno
- 29.3 Acceso al entorno de ejecución: sys
- 29.3.1 Parámetros de la línea de comandos
- 29.3.2 Rutas predeterminadas
- 29.3.3 Flujos de entrada y salida estándar
- 29.3.4 Salir del programa
- 29.3.5 Detalles de la versión de Python
- 29.3.6 Detalles del sistema operativo
- 29.3.7 Hooks
- 29.4 Parámetros de la línea de comandos: argparse
- 29.4.1 Calculadora: un ejemplo sencillo
- 29.4.2 Un ejemplo más complejo
- 30 Sistema de archivos
- 30.1 Conceptos básicos de los sistemas de archivos y las rutas
- 30.1.1 Nombres de rutas
- 30.1.2 Nombres de archivos
- 30.1.3 Rutas absolutas y relativas
- 30.1.4 Derechos de acceso
- 30.2 El enfoque moderno: pathlib
- 30.2.1 La clase Path
- 30.2.2 Combinación de rutas
- 30.2.3 Atributos de una ruta
- 30.2.4 Verificación de las propiedades de una ruta
- 30.2.5 Lectura y escritura de archivos
- 30.2.6 Cambiar el nombre de archivos
- 30.2.7 Copiar y mover archivos
- 30.2.8 Eliminación de archivos
- 30.2.9 Creación y eliminación de directorios
- 30.2.10 Enlaces
- 30.2.11 Expresiones globales
- 30.3 Acceso al sistema de archivos: os
- 30.3.1 access(ruta, modo)
- 30.3.2 chmod(ruta, modo)
- 30.3.3 listdir([ruta])
- 30.3.4 mkdir(ruta, [modo]) y makedirs(ruta, [modo])
- 30.3.5 remove(ruta)
- 30.3.6 removedirs(ruta)
- 30.3.7 rename(origen, destino) y renames(antiguo, nuevo)
- 30.3.8 walk(top, [topdown, onerror])
- 30.4 Rutas de archivos: os.path
- 30.4.1 abspath(ruta)
- 30.4.2 basename(ruta)
- 30.4.3 commonprefix(lista)
- 30.4.4 dirname(ruta)
- 30.4.5 join(ruta, *rutas)
- 30.4.6 normcase(ruta)
- 30.4.7 split(ruta)
- 30.4.8 splitdrive(ruta)
- 30.4.9 splitext(ruta)
- 30.5 Acceso al sistema de archivos: shutil
- 30.5.1 Operaciones con directorios y archivos
- 30.5.2 Operaciones con archivos comprimidos
- 30.6 Archivos temporales: tempfile
- 30.6.1 TemporaryFile([modo, [tamaño del búfer, sufijo, prefijo, dir])
- 30.6.2 TemporaryDirectory([sufijo, prefijo, dir])
- 31 Programación paralela
- 31.1 Procesos, multitarea y subprocesos
- 31.1.1 Los «ligeros» entre los procesos: los hilos
- 31.1.2 El bloqueo global del intérprete
- 31.1.3 ¿Hilos o procesos?
- 31.1.4 Multitarea cooperativa
- 31.2 Interfaces de Python para la paralelización
- 31.3 La interfaz abstracta: concurrent.futures
- 31.3.1 Un ejemplo con un futures.ThreadPoolExecutor
- 31.3.2 Instancias de ejecutor como administradores de contexto
- 31.3.3 Uso de `futures.ProcessPoolExecutor`
- 31.3.4 Administración de las tareas de un ejecutor
- 31.4 La interfaz flexible: threading y multiprocessing
- 31.4.1 Hilos en Python: threading
- 31.4.2 Procesos en Python: multiprocesamiento
- 31.5 Multitarea cooperativa
- 31.5.1 Funciones cooperativas: corrutinas
- 31.5.2 Objetos que se pueden esperar
- 31.5.3 La cooperación de las corrutinas: tareas
- 31.5.4 Un rastreador web cooperativo
- 31.5.5 Operaciones de bloqueo en corrutinas
- 31.5.6 Otras características asincrónicas del lenguaje
- 31.6 Conclusión: ¿Cuál es la interfaz adecuada?
- 31.6.1 ¿Es la multitarea cooperativa una opción?
- 31.6.2 ¿Abstracción o flexibilidad?
- 31.6.3 ¿Hilos o procesos?
- 32 Almacenamiento de datos
- 32.1 El formato de intercambio de datos JSON: json
- 32.2 Serialización de instancias: pickle
- 32.2.1 Interfaz funcional
- 32.2.2 Interfaz orientada a objetos
- 32.3 El formato de tabla CSV: csv
- 32.3.1 Lectura de datos de un archivo CSV con objetos reader
- 32.3.2 Uso de dialectos personalizados: objetos Dialect
- 32.4 Archivos comprimidos y archivos
- 32.4.1 gzip.open(nombre_archivo, [modo, nivel_compresión])
- 32.4.2 Otros módulos para acceder a datos comprimidos
- 32.5 Bases de datos
- 32.5.1 La base de datos integrada en Python: sqlite3
- 32.6 XML
- 32.6.1 ElementTree
- 32.6.2 SAX
- 33 Comunicación de red
- 33.1 API de sockets
- 33.1.1 Sistemas cliente-servidor
- 33.1.2 UDP
- 33.1.3 TCP
- 33.1.4 Sockets bloqueantes y no bloqueantes
- 33.1.5 Creación de un socket
- 33.1.6 La clase Socket
- 33.1.7 Orden de los bytes en la red
- 33.1.8 Servidores multiplexados: selectores
- 33.1.9 Desarrollo de servidores orientados a objetos: socketserver
- 33.2 XML-RPC
- 33.2.1 El servidor
- 33.2.2 El cliente
- 33.2.3 Multicall
- 33.2.4 Limitaciones
- 34 Acceso a recursos en Internet
- 34.1 Protocolos
- 34.1.1 Protocolo de transferencia de hipertexto
- 34.1.2 Protocolo de transferencia de archivos
- 34.2 Soluciones
- 34.2.1 Soluciones obsoletas para Python 2
- 34.2.2 Soluciones en la biblioteca estándar
- 34.2.3 Soluciones de terceros
- 34.3 La forma fácil: requests
- 34.3.1 Solicitudes sencillas mediante GET y POST
- 34.3.2 API web
- 34.4 URL: urllib
- 34.4.1 Acceso a recursos remotos: urllib.request
- 34.4.2 Lectura y procesamiento de URL: urllib.parse
- 34.5 FTP: ftplib
- 34.5.1 Conexión a un servidor FTP
- 34.5.2 Ejecución de comandos FTP
- 34.5.3 Trabajar con archivos y directorios
- 34.5.4 Transferencia de archivos
- 35 Correo electrónico
- 35.1 SMTP: smtplib
- 35.1.1 SMTP([host, puerto, nombre_de_host_local, tiempo_de_espera, dirección_de_origen])
- 35.1.2 Establecimiento y finalización de una conexión
- 35.1.3 Envío de un correo electrónico
- 35.1.4 Ejemplo
- 35.2 POP3: poplib
- 35.2.1 POP3(host, [puerto, tiempo de espera])
- 35.2.2 Establecimiento y finalización de una conexión
- 35.2.3 Listado de los correos electrónicos existentes
- 35.2.4 Recuperación y eliminación de correos electrónicos
- 35.2.5 Ejemplo
- 35.3 IMAP4: imaplib
- 35.3.1 IMAP4([host, puerto, tiempo de espera])
- 35.3.2 Establecimiento y finalización de una conexión
- 35.3.3 Búsqueda y selección de un buzón
- 35.3.4 Operaciones con buzones
- 35.3.5 Búsqueda de correos electrónicos
- 35.3.6 Recuperación de correos electrónicos
- 35.3.7 Ejemplo
- 35.4 Creación de correos electrónicos complejos: email
- 35.4.1 Creación de un correo electrónico sencillo
- 35.4.2 Creación de un correo electrónico con archivos adjuntos
- 35.4.3 Lectura de un correo electrónico
- 36 Depuración y control de calidad
- 36.1 El depurador
- 36.2 Pruebas automatizadas
- 36.2.1 Casos de prueba en cadenas de documentación: doctest
- 36.2.2 Pruebas unitarias: unittest
- 36.3 Análisis del rendimiento en tiempo de ejecución
- 36.3.1 Medición del tiempo de ejecución: timeit
- 36.3.2 Perfilado: cProfile
- 36.3.3 Rastreo: trace
- 37 Documentación
- 37.1 Cadenas de documentación
- 37.2 Documentación generada automáticamente: pydoc
- PARTE V Temas avanzados
- 38 Distribución de proyectos en Python
- 38.1 Historia de las distribuciones en Python
- 38.1.1 El enfoque clásico: distutils
- 38.1.2 El nuevo estándar: setuptools
- 38.1.3 El índice de paquetes: PyPI
- 38.2 Creación de distribuciones: setuptools
- 38.2.1 Instalación
- 38.2.2 Escribir el módulo
- 38.2.3 El script de instalación
- 38.2.4 Creación de una distribución de código fuente
- 38.2.5 Creación de una distribución binaria
- 38.2.6 Instalación de distribuciones
- 38.3 Creación de archivos EXE: cx_Freeze
- 38.3.1 Instalación
- 38.3.2 Uso
- 38.4 Administrador de paquetes
- 38.4.1 El administrador de paquetes de Python: pip
- 38.4.2 El administrador de paquetes conda
- 38.5 Localización de programas: gettext
- 38.5.1 Ejemplo de uso de gettext
- 38.5.2 Creación de la compilación de idiomas
- 39 Entornos virtuales
- 39.1 Uso de entornos virtuales: venv
- 39.1.1 Activación de un entorno virtual
- 39.1.2 Trabajar en un entorno virtual
- 39.1.3 Desactivación de un entorno virtual
- 39.2 Entornos virtuales en Anaconda
- 40 Interpretadores y compiladores alternativos
- 40.1 Compilación «just-in-time»: PyPy
- 40.1.1 Instalación y uso
- 40.1.2 Ejemplo
- 40.2 Numba
- 40.2.1 Instalación
- 40.2.2 Ejemplo
- 40.3 Conexión con C y C++: Cython
- 40.3.1 Instalación
- 40.3.2 La funcionalidad de Cython
- 40.3.3 Compilación de un programa en Cython
- 40.3.4 Un programa en Cython con tipado estático
- 40.3.5 Uso de una biblioteca de C
- 40.4 El shell interactivo de Python: IPython
- 40.4.1 Instalación
- 40.4.2 El shell interactivo
- 40.4.3 El cuaderno Jupyter
- 41 Interfaces gráficas de usuario
- 41.1 Kit de herramientas
- 41.1.1 Tkinter (Tk)
- 41.1.2 PyGObject (GTK)
- 41.1.3 Qt para Python (Qt)
- 41.1.4 wxPython (wxWidgets)
- 41.2 Introducción a tkinter
- 41.2.1 Un ejemplo sencillo
- 41.2.2 Variables de control
- 41.2.3 El Packer
- 41.2.4 Eventos
- 41.2.5 Widgets
- 41.2.6 Dibujos: el widget Canvas
- 41.2.7 Otros módulos
- 41.3 Introducción a PySide6
- 41.3.1 Instalación
- 41.3.2 Conceptos básicos de Qt
- 41.3.3 Proceso de desarrollo
- 41.3.4 Señales y ranuras
- 41.3.5 Widgets importantes
- 41.3.6 Funcionalidad de dibujo
- 41.3.7 Arquitectura Modelo-Vista
- 42 Python como lenguaje de programación del lado del servidor en la web: una introducción a Django
- 42.1 Conceptos y características de Django
- 42.2 Instalación de Django
- 42.3 Creación de un nuevo proyecto de Django
- 42.3.1 El servidor web de desarrollo
- 42.3.2 Configuración del proyecto
- 42.4 Creación de una aplicación
- 42.4.1 Importación de la aplicación al proyecto
- 42.4.2 Definición de un modelo
- 42.4.3 Relaciones entre modelos
- 42.4.4 Transferencia del modelo a la base de datos
- 42.4.5 La API del modelo
- 42.4.6 El proyecto cobra forma
- 42.4.7 El sistema de plantillas de Django
- 42.4.8 Procesamiento de datos de formularios
- 42.4.9 El panel de administración de Django
- 43 Computación científica y ciencia de datos
- 43.1 Instalación
- 43.2 El programa «Model»
- 43.2.1 Importación de numpy, scipy y matplotlib
- 43.2.2 Vectorización y el tipo de datos numpy.ndarray
- 43.2.3 Visualización de datos con matplotlib.pyplot
- 43.3 Descripción general de los módulos numpy y scipy
- 43.3.1 Descripción general del tipo de datos numpy.ndarray
- 43.3.2 Descripción general de scipy
- 43.4 Introducción al análisis de datos con pandas
- 43.4.1 El objeto DataFrame
- 43.4.2 Acceso selectivo a los datos
- 43.4.3 Eliminación de filas y columnas
- 43.4.4 Inserción de filas y columnas
- 43.4.5 Expresiones lógicas sobre registros de datos
- 43.4.6 Manipulación de registros de datos
- 43.4.7 Entrada y salida
- 43.4.8 Visualización
- 44 Conocimientos avanzados
- 44.1 Abrir URL en el navegador predeterminado: webbrowser
- 44.1.1 open(url, [new, autoraise])
- 44.2 Interpretación de datos binarios: struct
- 44.3 Entrada de contraseña oculta
- 44.3.1 getpass([prompt, stream], {echo_char})
- 44.3.2 getpass.getuser()
- 44.4 Intérprete de línea de comandos
- 44.5 Interfaz de archivos para cadenas: io.StringIO
- 44.6 Copia de instancias: copy
- 44.6.1 Regreso al ejemplo inicial
- 44.7 Procesamiento de imágenes: Pillow
- 44.7.1 Instalación
- 44.7.2 Carga y guardado de archivos de imagen
- 44.7.3 Acceso a píxeles individuales
- 44.7.4 Manipulación de imágenes
- 44.7.5 Interoperabilidad
- 45 Historia de las versiones de Python
- 45.1 Historia de las versiones de Python
- 45.2 El salto a Python 3
- 45.2.1 Entrada/Salida
- 45.2.2 Iteradores
- 45.2.3 Cadenas
- 45.2.4 Números enteros
- 45.2.5 Manejo de excepciones
- 45.2.6 Biblioteca estándar
- A.1 Palabras reservadas
- A.2 Precedencia de los operadores
- A.3 Funciones integradas
- A.4 Excepciones integradas
- A.5 Entornos de desarrollo integrado (IDE) de Python
- Los autores
- Índice
Python 3
Ready to master Python? In this updated edition of the prize-winning Python reference, learn to write effective code, whether you’re a beginner or a professional programmer. Review core Python concepts, including functions, modularization, and object orientation, and walk through the available data types. Then dive into more advanced topics, such as exception handling, static type checking, and regular expressions. With mountains of code examples throughout, this hands-on reference guide has everything you need to become proficient in Python!
- The complete Python 3 handbook
- Learn basic Python principles and work with functions, methods, data types, and more
- Walk through GUIs, network programming, debugging, optimization, and other advanced topics
You'll learn about:
- Coding with Python:
Learn about Python syntax and structure! Follow examples to start developing and testing your own programs using downloadable code.
- The Standard Library:
Explore Python’s built-in library and see how it can be used for a variety of different tasks, from running mathematical functions to debugging code.
- Advanced Programming Techniques:
Already know the basics? Enhance your professional skills with more advanced concepts, including GUIs, Django, scientific computing, and connecting to other languages.
Key Highlights:
- Functions
- Methods
- Attributes
- Data types
- GUIs
- Debugging
- Network communication
- Modularization
- Object orientation
- Iterators
- Generators
- Exception handling
View Full Table of Contents
- 1 Introduction
- 1.1 Why Did We Write This Book?
- 1.2 What Does This Book Provide?
- 1.3 Structure of the Book
- 1.4 How Should You Read This Book?
- 1.5 Sample Programs
- 1.6 Preface to the Second English Edition (2026)
- 1.7 Acknowledgments
- 2 The Python Programming Language
- 2.1 History and Origin
- 2.2 Basic Concepts
- 2.3 Possible Areas of Use and Strengths
- 2.4 Installing Python
- 2.4.1 Installing Anaconda on Windows
- 2.4.2 Installing Anaconda on macOS
- 2.4.3 Installing Anaconda on Linux
- 2.5 Installing Third-Party Modules
- 2.6 Using Python
- PART I Getting Started with Python
- 3 Getting Started with the Interactive Mode
- 3.1 Integers
- 3.2 Floats
- 3.3 Character Strings
- 3.4 Lists
- 3.5 Dictionaries
- 3.6 Variables
- 3.6.1 The Special Meaning of the Underscore
- 3.6.2 Identifiers
- 3.7 Logical Expressions
- 3.8 Functions and Methods
- 3.8.1 Functions
- 3.8.2 Methods
- 3.9 Screen Outputs
- 3.10 Modules
- 4 The Path to the First Program
- 4.1 Typing, Compiling, and Testing
- 4.1.1 Windows
- 4.1.2 Linux and macOS
- 4.1.3 Shebang
- 4.1.4 Internal Processes
- 4.2 Basic Structure of a Python Program
- 4.2.1 Wrapping Long Lines
- 4.2.2 Joining Multiple Lines
- 4.3 The First Program
- 4.3.1 Initialization
- 4.3.2 Loop Header
- 4.3.3 Loop Body
- 4.3.4 Screen Output
- 4.4 Comments
- 4.5 In Case of Error
- 5 Control Structures
- 5.1 Conditionals
- 5.1.1 The if Statement
- 5.1.2 Conditional Expressions
- 5.2 Loops
- 5.2.1 The while Loop
- 5.2.2 Termination of a Loop
- 5.2.3 Detecting a Loop Break
- 5.2.4 Aborting the Current Iteration
- 5.2.5 The for Loop
- 5.3 The pass Statement
- 5.4 Assignment Expressions
- 5.4.1 Motivation
- 5.4.2 The Guessing Numbers Game with Assignment Expressions
- 6 Files
- 6.1 Data Streams
- 6.2 Reading Data from a File
- 6.2.1 Opening and Closing a File
- 6.2.2 The with Statement
- 6.2.3 Reading the File Content
- 6.3 Writing Data to a File
- 6.4 Generating the File Object
- 6.4.1 The Built-In open Function
- 6.4.2 Attributes and Methods of a File Object
- 6.4.3 Changing the Write/Read Position
- 7 The Data Model
- 7.1 The Structure of Instances
- 7.1.1 Data Type
- 7.1.2 Value
- 7.1.3 Identity
- 7.2 Deleting References
- 7.3 Mutable Versus Immutable Data Types
- 7.3.1 Mutable Data Types and Side Effects
- 8 Functions, Methods, and Attributes
- 8.1 Parameters of Functions and Methods
- 8.1.1 Positional Parameters
- 8.1.2 Keyword Arguments
- 8.1.3 Optional Parameters
- 8.1.4 Keyword-Only Parameters
- 8.2 Attributes
- 9 Sources of Information on Python
- 9.1 The Built-In Help Function
- 9.2 The Online Documentation
- 9.3 PEPs
- PART II Data Types
- 10 Basic Data Types: An Overview
- 10.1 Nothingness: NoneType
- 10.2 Operators
- 10.2.1 Operator Precedence
- 10.2.2 Evaluation Order
- 10.2.3 Concatenating Comparisons
- 11 Numeric Data Types
- 11.1 Arithmetic Operators
- 11.1.1 Augmented Assignments
- 11.2 Comparison Operators
- 11.3 Conversion between Numeric Data Types
- 11.4 Integers: int
- 11.4.1 Numeral Systems
- 11.4.2 Bit Operations
- 11.4.3 The bit_length Method
- 11.5 Floats: float
- 11.5.1 Exponential Notation
- 11.5.2 Precision
- 11.5.3 Infinite and Not a Number
- 11.6 Boolean Values: bool
- 11.6.1 Logical Operators
- 11.6.2 Truth Values of Non-Boolean Data Types
- 11.6.3 Evaluating Logical Operators
- 11.7 Complex Numbers: complex
- 12 Sequential Data Types
- 12.1 The Difference Between Text and Binary Data
- 12.2 Operations on Instances of Sequential Data Types
- 12.2.1 Checking for Elements
- 12.2.2 Concatenation
- 12.2.3 Repetition
- 12.2.4 Indexing
- 12.2.5 Slicing
- 12.2.6 Length of a Sequence
- 12.2.7 The Smallest and the Largest Element
- 12.2.8 Searching for an Element
- 12.2.9 Counting Elements
- 12.3 The list Data Type
- 12.3.1 Changing a Value Within the List: Assignment via []
- 12.3.2 Replacing Sublists and Inserting New Elements: Assignment via []
- 12.3.3 Deleting Elements and Sublists: del in Combination with []
- 12.3.4 Methods of list Instances
- 12.3.5 Sorting Lists: s.sort([key, reverse])
- 12.3.6 Side Effects
- 12.3.7 List Comprehensions
- 12.4 Immutable Lists: tuple
- 12.4.1 Packing and Unpacking
- 12.4.2 Immutable Doesn’t Necessarily Mean Unchangeable!
- 12.5 Strings: str, bytes, bytearray
- 12.5.1 Control Characters
- 12.5.2 Splitting Strings
- 12.5.3 Searching for Substrings
- 12.5.4 Replacing Substrings
- 12.5.5 Removing Prefixes and Suffixes
- 12.5.6 Aligning Strings
- 12.5.7 String Tests
- 12.5.8 Concatenating Elements in Sequential Data Types
- 12.5.9 Formatting Strings
- 12.5.10 Character Sets and Special Characters
- 12.5.11 Template Strings
- 13 Mappings and Sets
- 13.1 Dictionary: dict
- 13.1.1 Creating a Dictionary
- 13.1.2 Keys and Values
- 13.1.3 Iteration
- 13.1.4 Operators
- 13.1.5 Methods
- 13.1.6 Dict Comprehensions
- 13.2 Sets: set and frozenset
- 13.2.1 Creating a Set
- 13.2.2 Iteration
- 13.2.3 Operators
- 13.2.4 Methods
- 13.2.5 Mutable Sets: set
- 13.2.6 Immutable Sets: frozenset
- 14 Collections
- 14.1 Chained Dictionaries
- 14.2 Counting Frequencies
- 14.2.1 d.elements()
- 14.2.2 d.most_common([n])
- 14.2.3 d.subtract([iterable])
- 14.2.4 d.update([iterable])
- 14.3 Dictionaries with Default Values
- 14.4 Doubly Linked Lists
- 14.5 Named Tuples
- 14.5.1 namedtuple(typename, field_names, {rename})
- 15 Date and Time
- 15.1 Elementary Time Functions: time
- 15.1.1 The struct_time Data Type
- 15.1.2 Constants
- 15.1.3 Functions
- 15.2 Object-Oriented Date Management: datetime
- 15.2.1 datetime.date
- 15.2.2 datetime.time
- 15.2.3 datetime.datetime
- 15.2.4 datetime.timedelta
- 15.2.5 Operations for datetime.datetime and datetime.date
- 15.3 Time Zones: zoneinfo
- 15.3.1 The IANA Time Zone Database
- 15.3.2 Specifying the Time in Local Time Zones
- 15.3.3 Calculating with Time Indications in Local Time Zones
- 16 Enumerations and Flags
- 16.1 Enumeration Types: enum
- 16.2 Enumeration Types for Bit Patterns: Flag
- 16.3 Integer Enumeration Types: IntEnum
- PART III Advanced Programming Techniques
- 17 Functions
- 17.1 Defining a Function
- 17.2 Return Values
- 17.3 Function Objects
- 17.4 Optional Parameters
- 17.5 Keyword Arguments
- 17.6 Arbitrarily Many Parameters
- 17.7 Keyword-Only Parameters
- 17.8 Positional-Only Parameters
- 17.9 Unpacking When Calling a Function
- 17.10 Side Effects
- 17.11 Namespaces
- 17.11.1 Accessing Global Variables: global
- 17.11.2 Accessing the Global Namespace
- 17.11.3 Local Functions
- 17.11.4 Accessing Parent Namespaces: nonlocal
- 17.11.5 Unbound Local Variables: A Stumbling Block
- 17.12 Anonymous Functions
- 17.13 Recursion
- 17.14 Built-In Functions
- 17.14.1 abs(x)
- 17.14.2 all(iterable)
- 17.14.3 any(iterable)
- 17.14.4 ascii(object)
- 17.14.5 bin(x)
- 17.14.6 bool([x])
- 17.14.7 bytearray([source, encoding, errors])
- 17.14.8 bytes([source, encoding, errors])
- 17.14.9 chr(i)
- 17.14.10 complex([real, imag])
- 17.14.11 dict([source])
- 17.14.12 divmod(a, b)
- 17.14.13 enumerate(iterable, [start])
- 17.14.14 eval(expression, [globals, locals])
- 17.14.15 exec(object, [globals, locals])
- 17.14.16 filter(function, iterable)
- 17.14.17 float([x])
- 17.14.18 format(value, [format_spec])
- 17.14.19 frozenset([iterable])
- 17.14.20 globals()
- 17.14.21 hash(object)
- 17.14.22 help([object])
- 17.14.23 hex(x)
- 17.14.24 id(object)
- 17.14.25 input([prompt])
- 17.14.26 int([x, base])
- 17.14.27 len(s)
- 17.14.28 list([sequence])
- 17.14.29 locals()
- 17.14.30 map(function, [*iterable, strict])
- 17.14.31 max(iterable, {default, key}), max(arg1, arg2, [*args], {key})
- 17.14.32 min(iterable, {default, key}), min(arg1, arg2, [*args], {key})
- 17.14.33 oct(x)
- 17.14.34 ord(c)
- 17.14.35 pow(x, y, [z])
- 17.14.36 print([*objects], {sep, end, file, flush})
- 17.14.37 range([start], stop, [step])
- 17.14.38 repr(object)
- 17.14.39 reversed(sequence)
- 17.14.40 round(x, [n])
- 17.14.41 set([iterable])
- 17.14.42 sorted(iterable, [key, reverse])
- 17.14.43 str([object, encoding, errors])
- 17.14.44 sum(iterable, [start])
- 17.14.45 tuple([iterable])
- 17.14.46 type(object)
- 17.14.47 zip([*iterables], {strict})
- 18 Modules and Packages
- 18.1 Importing Global Modules
- 18.2 Local Modules
- 18.2.1 Name Conflicts
- 18.2.2 Module-Internal References
- 18.2.3 Executing Modules
- 18.3 Packages
- 18.3.1 Importing All Modules of a Package
- 18.3.2 Namespace Packages
- 18.3.3 Relative Import Statements
- 18.4 The importlib Package
- 18.5 Planned Language Elements
- 19 Object-Oriented Programming
- 19.1 Example: A Non-Object-Oriented Account
- 19.1.1 Creating a New Account
- 19.1.2 Transferring Money
- 19.1.3 Depositing and Withdrawing Money
- 19.1.4 Viewing the Account Balance
- 19.2 Classes
- 19.2.1 Defining Methods
- 19.2.2 The Constructor
- 19.2.3 Attributes
- 19.2.4 Example: An Object-Oriented Account
- 19.3 Inheritance
- 19.3.1 A Simple Example
- 19.3.2 Overriding Methods
- 19.3.3 Example: Checking Account with Daily Turnover
- 19.3.4 Outlook
- 19.4 Multiple Inheritance
- 19.4.1 Potential Pitfalls of Multiple Inheritance
- 19.5 Property Attributes
- 19.5.1 Setters and Getters
- 19.5.2 Defining Property Attributes
- 19.6 Static Methods
- 19.6.1 Defining Static Methods
- 19.7 Class Methods
- 19.8 Class Attributes
- 19.9 Built-in Functions for Object-Oriented Programming
- 19.9.1 Functions for Managing the Attributes of an Instance
- 19.9.2 Functions for Information About the Class Hierarchy
- 19.10 Inheriting Built-In Data Types
- 19.11 Magic Methods and Magic Attributes
- 19.11.1 General Magic Methods
- 19.11.2 Overloading Operators
- 19.11.3 Emulating Data Types: Duck Typing
- 19.12 Data Classes
- 19.12.1 Tuples and Lists
- 19.12.2 Dictionaries
- 19.12.3 Named Tuples
- 19.12.4 Mutable Data Classes
- 19.12.5 Immutable Data Classes
- 19.12.6 Default Values in Data Classes
- 20 Exception Handling
- 20.1 Exceptions
- 20.1.1 Built-In Exceptions
- 20.1.2 Raising an Exception
- 20.1.3 Handling an Exception
- 20.1.4 Custom Exceptions
- 20.1.5 Reraising an Exception
- 20.1.6 Exception Chaining
- 20.1.7 Exception Notes
- 20.2 Assertions
- 20.3 Warnings
- 20.4 Exception Groups
- 20.4.1 An Exception Group
- 20.4.2 The try/except* Statement
- 21 Generators and Iterators
- 21.1 Generators
- 21.1.1 Subgenerators
- 21.1.2 Generator Expressions
- 21.2 Iterators
- 21.2.1 The Iterator Protocol
- 21.2.2 Example: The Fibonacci Sequence
- 21.2.3 Example: The Golden Ratio
- 21.2.4 A Generator for the Implementation of __iter__
- 21.2.5 Using Iterators
- 21.2.6 Multiple Iterators for the Same Instance
- 21.2.7 Disadvantages of Iterators Compared to Direct Access via Indexes
- 21.2.8 Alternative Definition for Iterable Objects
- 21.2.9 Function Iterators
- 21.3 Special Generators: itertools
- 21.3.1 accumulate(iterable, [func])
- 21.3.2 batched(iterable, n, {strict})
- 21.3.3 chain([*iterables])
- 21.3.4 combinations(iterable, r)
- 21.3.5 combinations_with_replacement(iterable, r)
- 21.3.6 compress(data, selectors)
- 21.3.7 count([start, step])
- 21.3.8 cycle(iterable)
- 21.3.9 dropwhile(predicate, iterable)
- 21.3.10 filterfalse(predicate, iterable)
- 21.3.11 groupby(iterable, [key])
- 21.3.12 islice(iterable, [start], stop, [step])
- 21.3.13 permutations(iterable, [r])
- 21.3.14 product([*iterables], [repeat])
- 21.3.15 repeat(object, [times])
- 21.3.16 starmap(function, iterable)
- 21.3.17 takewhile(predicate, iterable)
- 21.3.18 tee(iterable, [n])
- 21.3.19 zip_longest([*iterables], {fillvalue})
- 21.4 Generators as Consumers
- 21.4.1 Triggering Exceptions in a Generator
- 21.4.2 An Example Application for Consuming Generator Functions
- 22 Context Manager
- 22.1 The with Statement
- 22.1.1 __enter__(self)
- 22.1.2 __exit__(self, exc_type, exc_value, traceback)
- 22.2 Helper Functions for with Contexts: contextlib
- 22.2.1 Dynamically Assembled Context Combinations: ExitStack
- 22.2.2 Suppressing Certain Exception Types
- 22.2.3 Redirecting the Standard Output Stream
- 22.2.4 Optional Contexts
- 22.2.5 Simple Functions as Context Manager
- 22.2.6 Temporarily Changing the Working Directory
- 23 Decorators
- 23.1 Function Decorators
- 23.1.1 Decorating Functions and Methods
- 23.1.2 Name and Docstring after Applying a Decorator
- 23.1.3 Nested Decorators
- 23.1.4 Example: A Cache Decorator
- 23.2 Class Decorators
- 23.3 The functools Module
- 23.3.1 Simplifying Function Interfaces
- 23.3.2 Simplifying Method Interfaces
- 23.3.3 Caches
- 23.3.4 Completing Orderings of Custom Classes
- 23.3.5 Overloading Functions
- 24 Annotations for Static Type Checking
- 24.1 Annotations
- 24.1.1 Annotating Functions and Methods
- 24.1.2 Annotating Variables and Attributes
- 24.1.3 Accessing Annotations at Runtime
- 24.1.4 When Are Annotations Evaluated?
- 24.2 Type Hints: The typing Module
- 24.2.1 Valid Type Hints
- 24.2.2 Container Types
- 24.2.3 Abstract Container Types
- 24.2.4 Type Aliases
- 24.2.5 Type Unions and Optional Values
- 24.2.6 Literals
- 24.2.7 Type Variables
- 24.3 Static Type Checking in Python: mypy
- 24.3.1 Installation
- 24.3.2 Example
- 25 Structural Pattern Matching
- 25.1 The match Statement
- 25.2 Pattern Types in the case Statement
- 25.2.1 Literal and Value Patterns
- 25.2.2 OR Pattern
- 25.2.3 Patterns with Type Checking
- 25.2.4 Specifying Conditions for Matches
- 25.2.5 Grouping Subpatterns
- 25.2.6 Capture and Wildcard Patterns
- 25.2.7 Sequence Patterns
- 25.2.8 Mapping Patterns
- 25.2.9 Patterns for Objects and Their Attribute Values
- PART IV The Standard Library
- 26 Mathematics
- 26.1 Mathematical Functions: math, cmath
- 26.1.1 General Mathematical Functions
- 26.1.2 Exponential and Logarithm Functions
- 26.1.3 Trigonometric and Hyperbolic Functions
- 26.1.4 Distances and Norms
- 26.1.5 Converting Angles
- 26.1.6 Representations of Complex Numbers
- 26.2 Random Number Generator: random
- 26.2.1 Saving and Loading the Random State
- 26.2.2 Generating Random Integers
- 26.2.3 Generating Random Floats
- 26.2.4 Random Operations on Sequences
- 26.2.5 SystemRandom([seed])
- 26.3 Statistical Calculations: statistics
- 26.4 Intuitive Decimal Numbers: decimal
- 26.4.1 Using the Data Type
- 26.4.2 Nonnumeric Values
- 26.4.3 The Context Object
- 26.5 Hash Functions: hashlib
- 26.5.1 Using the Module
- 26.5.2 Other Hash Algorithms
- 26.5.3 Comparing Large Files
- 26.5.4 Passwords
- 27 Screen Outputs and Logging
- 27.1 Formatted Output of Complex Objects: pprint
- 27.1.1 pprint(object, [stream, indent, width, depth], {compact})
- 27.2 Log Files: logging
- 27.2.1 Customizing the Message Format
- 27.2.2 Logging Handlers
- 28 Regular Expressions
- 28.1 Syntax of Regular Expressions
- 28.1.1 Any Character
- 28.1.2 Character Classes
- 28.1.3 Quantifiers
- 28.1.4 Predefined Character Classes
- 28.1.5 Other Special Characters
- 28.1.6 Nongreedy Quantifiers
- 28.1.7 Groups
- 28.1.8 Alternatives
- 28.1.9 Extensions
- 28.2 Using the re Module
- 28.2.1 Searching
- 28.2.2 Matching
- 28.2.3 Splitting a String
- 28.2.4 Replacing Parts of a String
- 28.2.5 Replacing Problem Characters
- 28.2.6 Compiling a Regular Expression
- 28.2.7 Flags
- 28.2.8 The Match Object
- 28.3 A Simple Sample Program: Searching
- 28.4 A More Complex Sample Program: Matching
- 28.5 Comments in Regular Expressions
- 28.6 Catastrophic Backtracking
- 29 Interface to Operating System and Runtime Environment
- 29.1 Operating System Functionality: os
- 29.1.1 environ
- 29.1.2 getpid()
- 29.1.3 cpu_count()
- 29.1.4 system(cmd)
- 29.1.5 popen(command, [mode, buffering])
- 29.2 Starting Subprocesses: subprocess
- 29.2.1 Starting a Subprocess
- 29.2.2 The Default Streams: stdin, stdout, and stderr
- 29.2.3 The Return Code
- 29.2.4 Environment variables
- 29.3 Accessing the Runtime Environment: sys
- 29.3.1 Command Line Parameters
- 29.3.2 Default Paths
- 29.3.3 Standard Input/Output Streams
- 29.3.4 Exiting the Program
- 29.3.5 Details of the Python Version
- 29.3.6 Operating System Details
- 29.3.7 Hooks
- 29.4 Command Line Parameters: argparse
- 29.4.1 Calculator: A Simple Example
- 29.4.2 A More Complex Example
- 30 File System
- 30.1 Basics of File Systems and Paths
- 30.1.1 Path Names
- 30.1.2 File Names
- 30.1.3 Absolute and Relative Paths
- 30.1.4 Access Rights
- 30.2 The Modern Approach: pathlib
- 30.2.1 The Path Class
- 30.2.2 Combining Paths
- 30.2.3 Attributes of a Path
- 30.2.4 Checking Path Properties
- 30.2.5 Reading and Writing Files
- 30.2.6 Renaming Files
- 30.2.7 Copying and Moving Files
- 30.2.8 Deleting Files
- 30.2.9 Creating and Deleting Directories
- 30.2.10 Links
- 30.2.11 Globbing
- 30.3 Accessing the File System: os
- 30.3.1 access(path, mode)
- 30.3.2 chmod(path, mode)
- 30.3.3 listdir([path])
- 30.3.4 mkdir(path, [mode]) and makedirs(path, [mode])
- 30.3.5 remove(path)
- 30.3.6 removedirs(path)
- 30.3.7 rename(src, dst) and renames(old, new)
- 30.3.8 walk(top, [topdown, onerror])
- 30.4 File Paths: os.path
- 30.4.1 abspath(path)
- 30.4.2 basename(path)
- 30.4.3 commonprefix(list)
- 30.4.4 dirname(path)
- 30.4.5 join(path, *paths)
- 30.4.6 normcase(path)
- 30.4.7 split(path)
- 30.4.8 splitdrive(path)
- 30.4.9 splitext(path)
- 30.5 Accessing the File System: shutil
- 30.5.1 Directory and File Operations
- 30.5.2 Archive Operations
- 30.6 Temporary Files: tempfile
- 30.6.1 TemporaryFile([mode, [bufsize, suffix, prefix, dir])
- 30.6.2 TemporaryDirectory([suffix, prefix, dir])
- 31 Parallel Programming
- 31.1 Processes, Multitasking, and Threads
- 31.1.1 The Lightweights Among the Processes: Threads
- 31.1.2 The Global Interpreter Lock
- 31.1.3 Threads or Processes?
- 31.1.4 Cooperative Multitasking
- 31.2 Python's Interfaces for Parallelization
- 31.3 The Abstract Interface: concurrent.futures
- 31.3.1 An Example with a futures.ThreadPoolExecutor
- 31.3.2 Executor Instances as Context Managers
- 31.3.3 Using futures.ProcessPoolExecutor
- 31.3.4 Managing the Tasks of an Executor
- 31.4 The Flexible Interface: threading and multiprocessing
- 31.4.1 Threads in Python: threading
- 31.4.2 Processes in Python: multiprocessing
- 31.5 Cooperative Multitasking
- 31.5.1 Cooperative Functions: Coroutines
- 31.5.2 Awaitable Objects
- 31.5.3 The Cooperation of Coroutines: Tasks
- 31.5.4 A Cooperative Web Crawler
- 31.5.5 Blocking Operations in Coroutines
- 31.5.6 Other Asynchronous Language Features
- 31.6 Conclusion: Which Interface Is the Right One?
- 31.6.1 Is Cooperative Multitasking an Option?
- 31.6.2 Abstraction or Flexibility?
- 31.6.3 Threads or Processes?
- 32 Data Storage
- 32.1 The JSON Data Exchange Format: json
- 32.2 Serializing Instances: pickle
- 32.2.1 Functional Interface
- 32.2.2 Object-Oriented Interface
- 32.3 The CSV Table Format: csv
- 32.3.1 Reading Data from a CSV File with reader Objects
- 32.3.2 Using Custom Dialects: Dialect Objects
- 32.4 Compressed Files and Archives
- 32.4.1 gzip.open(filename, [mode, compresslevel])
- 32.4.2 Other Modules for Accessing Compressed Data
- 32.5 Databases
- 32.5.1 The Built-In Database in Python: sqlite3
- 32.6 XML
- 32.6.1 ElementTree
- 32.6.2 SAX
- 33 Network Communication
- 33.1 Socket API
- 33.1.1 Client-Server Systems
- 33.1.2 UDP
- 33.1.3 TCP
- 33.1.4 Blocking and Nonblocking Sockets
- 33.1.5 Creating a Socket
- 33.1.6 The Socket Class
- 33.1.7 Network Byte Order
- 33.1.8 Multiplexing Servers: selectors
- 33.1.9 Object-Oriented Server Development: socketserver
- 33.2 XML-RPC
- 33.2.1 The Server
- 33.2.2 The Client
- 33.2.3 Multicall
- 33.2.4 Limitations
- 34 Accessing Resources on the Internet
- 34.1 Protocols
- 34.1.1 Hypertext Transfer Protocol
- 34.1.2 File Transfer Protocol
- 34.2 Solutions
- 34.2.1 Outdated Solutions for Python 2
- 34.2.2 Solutions in the Standard Library
- 34.2.3 Third-Party Solutions
- 34.3 The Easy Way: requests
- 34.3.1 Simple Requests via GET and POST
- 34.3.2 Web APIs
- 34.4 URLs: urllib
- 34.4.1 Accessing Remote Resources: urllib.request
- 34.4.2 Reading and Processing URLs: urllib.parse
- 34.5 FTP: ftplib
- 34.5.1 Connecting to an FTP Server
- 34.5.2 Executing FTP commands
- 34.5.3 Working with Files and Directories
- 34.5.4 Transferring Files
- 35 Email
- 35.1 SMTP: smtplib
- 35.1.1 SMTP([host, port, local_hostname, timeout, source_address])
- 35.1.2 Establishing and Terminating a Connection
- 35.1.3 Sending an Email
- 35.1.4 Example
- 35.2 POP3: poplib
- 35.2.1 POP3(host, [port, timeout])
- 35.2.2 Establishing and Terminating a Connection
- 35.2.3 Listing Existing Emails
- 35.2.4 Retrieving and Deleting Emails
- 35.2.5 Example
- 35.3 IMAP4: imaplib
- 35.3.1 IMAP4([host, port, timeout])
- 35.3.2 Establishing and Terminating a Connection
- 35.3.3 Finding and Selecting a Mailbox
- 35.3.4 Operations with Mailboxes
- 35.3.5 Searching Emails
- 35.3.6 Retrieving Emails
- 35.3.7 Example
- 35.4 Creating Complex Emails: email
- 35.4.1 Creating a Simple Email
- 35.4.2 Creating an Email with Attachments
- 35.4.3 Reading an Email
- 36 Debugging and Quality Assurance
- 36.1 The Debugger
- 36.2 Automated Testing
- 36.2.1 Test Cases in Docstrings: doctest
- 36.2.2 Unit Tests: unittest
- 36.3 Analyzing the Runtime Performance
- 36.3.1 Runtime Measurement: timeit
- 36.3.2 Profiling: cProfile
- 36.3.3 Tracing: trace
- 37 Documentation
- 37.1 Docstrings
- 37.2 Automatically Generated Documentation: pydoc
- PART V Advanced Topics
- 38 Distributing Python Projects
- 38.1 A History of Distributions in Python
- 38.1.1 The Classic Approach: distutils
- 38.1.2 The New Standard: setuptools
- 38.1.3 The Package Index: PyPI
- 38.2 Creating Distributions: setuptools
- 38.2.1 Installation
- 38.2.2 Writing the Module
- 38.2.3 The Installation Script
- 38.2.4 Creating a Source Distribution
- 38.2.5 Creating a Binary Distribution
- 38.2.6 Installing Distributions
- 38.3 Creating EXE files: cx_Freeze
- 38.3.1 Installation
- 38.3.2 Usage
- 38.4 Package Manager
- 38.4.1 The Python Package Manager: pip
- 38.4.2 The conda Package Manager
- 38.5 Localizing Programs: gettext
- 38.5.1 Example of Using gettext
- 38.5.2 Creating the Language Compilation
- 39 Virtual Environments
- 39.1 Using Virtual Environments: venv
- 39.1.1 Activating a Virtual Environment
- 39.1.2 Working in a Virtual Environment
- 39.1.3 Deactivating a Virtual Environment
- 39.2 Virtual Environments in Anaconda
- 40 Alternative Interpreters and Compilers
- 40.1 Just-in-Time Compilation: PyPy
- 40.1.1 Installation and Use
- 40.1.2 Example
- 40.2 Numba
- 40.2.1 Installation
- 40.2.2 Example
- 40.3 Connecting to C and C++: Cython
- 40.3.1 Installation
- 40.3.2 The Functionality of Cython
- 40.3.3 Compiling a Cython Program
- 40.3.4 A Cython Program with Static Typing
- 40.3.5 Using a C Library
- 40.4 The Interactive Python Shell: IPython
- 40.4.1 Installation
- 40.4.2 The Interactive Shell
- 40.4.3 The Jupyter Notebook
- 41 Graphical User Interfaces
- 41.1 Toolkits
- 41.1.1 Tkinter (Tk)
- 41.1.2 PyGObject (GTK)
- 41.1.3 Qt for Python (Qt)
- 41.1.4 wxPython (wxWidgets)
- 41.2 Introduction to tkinter
- 41.2.1 A Simple Example
- 41.2.2 Control Variables
- 41.2.3 The Packer
- 41.2.4 Events
- 41.2.5 Widgets
- 41.2.6 Drawings: The Canvas Widget
- 41.2.7 Other Modules
- 41.3 Introduction to PySide6
- 41.3.1 Installation
- 41.3.2 Basic Concepts of Qt
- 41.3.3 Development Process
- 41.3.4 Signals and Slots
- 41.3.5 Important Widgets
- 41.3.6 Drawing Functionality
- 41.3.7 Model-View Architecture
- 42 Python as a Server-Side Programming Language on the Web: An Introduction to Django
- 42.1 Concepts and Features of Django
- 42.2 Installing Django
- 42.3 Creating a New Django Project
- 42.3.1 The Development Web Server
- 42.3.2 Configuring the Project
- 42.4 Creating an Application
- 42.4.1 Importing the Application into the Project
- 42.4.2 Defining a Model
- 42.4.3 Relationships between Models
- 42.4.4 Transferring the Model to the Database
- 42.4.5 The Model API
- 42.4.6 The Project Gets a Face
- 42.4.7 Django's Template System
- 42.4.8 Processing Form Data
- 42.4.9 Django’s Admin Control Panel
- 43 Scientific Computing and Data Science
- 43.1 Installation
- 43.2 The Model Program
- 43.2.1 Importing numpy, scipy, and matplotlib
- 43.2.2 Vectorization and the numpy.ndarray Data Type
- 43.2.3 Visualizing Data Using matplotlib.pyplot
- 43.3 Overview of the numpy and scipy Modules
- 43.3.1 Overview of the numpy.ndarray Data Type
- 43.3.2 Overview of scipy
- 43.4 An Introduction to Data Analysis with pandas
- 43.4.1 The DataFrame Object
- 43.4.2 Selective Data Access
- 43.4.3 Deleting Rows and Columns
- 43.4.4 Inserting Rows and Columns
- 43.4.5 Logical Expressions on Data Records
- 43.4.6 Manipulating Data Records
- 43.4.7 Input and Output
- 43.4.8 Visualization
- 44 Inside Knowledge
- 44.1 Opening URLs in the Default Browser: webbrowser
- 44.1.1 open(url, [new, autoraise])
- 44.2 Interpreting Binary Data: struct
- 44.3 Hidden Password Entry
- 44.3.1 getpass([prompt, stream], {echo_char})
- 44.3.2 getpass.getuser()
- 44.4 Command Line Interpreter
- 44.5 File Interface for Strings: io.StringIO
- 44.6 Copying Instances: copy
- 44.6.1 Back to the Initial Example
- 44.7 Image Processing: Pillow
- 44.7.1 Installation
- 44.7.2 Loading and Saving Image Files
- 44.7.3 Accessing Individual Pixels
- 44.7.4 Manipulating Images
- 44.7.5 Interoperability
- 45 A History of Python Versions
- 45.1 Python’s Version History
- 45.2 The Leap to Python 3
- 45.2.1 Input/Output
- 45.2.2 Iterators
- 45.2.3 Strings
- 45.2.4 Integers
- 45.2.5 Exception Handling
- 45.2.6 Standard Library
- A.1 Reserved Words
- A.2 Operator Precedence
- A.3 Built-In Functions
- A.4 Built-In Exceptions
- A.5 Python IDEs
- The Authors
- Index
