Python 3
¿Listo para dominar Python? Aprenda a escribir código eficaz, tanto si es principiante como programador profesional. Repase los conceptos básicos de Python, incluyendo funciones, modularización y orientación a objetos, y repase los tipos de datos disponibles. A continuación, sumérjase en temas más avanzados, como el uso de Django y el trabajo con interfaces gráficas de usuario. Con numerosos ejemplos de código a lo largo de todo el libro, esta guía práctica de referencia tiene todo lo que necesita para dominar Python.
- El manual completo de Python 3
- Aprenda los principios básicos de Python y trabaje con funciones, métodos, tipos de datos y mucho más.
- Recorra las interfaces gráficas de usuario, la programación de redes, la depuración, la optimización y otros temas avanzados.
- Descarga y consulta ejemplos prácticos de código.
Aprenderás sobre:
- Programación con Python:
¡Aprenda sobre la sintaxis y la estructura de Python! Siga los ejemplos para empezar a desarrollar y probar sus propios programas utilizando código descargable.
- La biblioteca estándar:
Explora la biblioteca integrada de Python y descubre cómo se puede utilizar para realizar diversas tareas, desde ejecutar funciones matemáticas hasta depurar tu código.
- Técnicas avanzadas de programación:
¿Ya conoces los conceptos básicos? Mejora tus habilidades profesionales con conceptos más avanzados, como interfaces gráficas de usuario, Django, computación científica y conexió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 muestra
- 1.6 Prefacio a la primera edición en inglés (2022)
- 1.7 Agradecimientos
- 2 El lenguaje de programación Python
- 2.1 Historia, conceptos y áreas de aplicación
- 2.1.1 Historia y origen
- 2.1.2 Conceptos básicos
- 2.1.3 Posibles áreas de uso y puntos fuertes
- 2.1.4 Ejemplos de uso
- 2.2 Instalación de Python
- 2.2.1 Instalación de Anaconda en Windows
- 2.2.2 Instalación de Anaconda en Linux
- 2.2.3 Instalación de Anaconda en macOS
- 2.3 Instalación de módulos de terceros
- 2.4 Uso de Python
- PARTE I Introducción a Python
- 3 Introducción al modo interactivo
- 3.1 Números enteros
- 3.2 Flotadores
- 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 de pantalla
- 3.10 Módulos
- 4 El camino hacia el primer programa
- 4.1 Escribir, compilar y probar
- 4.1.1 Ventanas
- 4.1.2 Linux y macOS
- 4.1.3 Shebang
- 4.1.4 Procesos internos
- 4.2 Estructura básica de un programa Python
- 4.2.1 Ajuste de 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 de bucle
- 4.3.3 Cuerpo del bucle
- 4.3.4 Salida de 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 bucle while
- 5.2.2 Finalización de un bucle
- 5.2.3 Detección de una ruptura de bucle
- 5.2.4 Abortar la iteración actual
- 5.2.5 El bucle for
- 5.2.6 El bucle for como bucle de conteo
- 5.3 La instrucción pass
- 5.4 Expresiones de asignación
- 5.4.1 El juego de adivinar números con expresiones de asignación
- 6 archivos
- 6.1 Flujos de datos
- 6.2 Lectura de datos desde 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 Generació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
- 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 palabras clave
- 8.1.3 Parámetros opcionales
- 8.1.4 Parámetros solo de palabra clave
- 8.2 Atributos
- 9 Fuentes de información sobre Python
- 9.1 La función de ayuda integrada
- 9.2 La documentación en línea
- 9.3 PEP
- PARTE II Tipos de datos
- 10 tipos de datos básicos: descripción general
- 10.1 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.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 Métodos
- 11.5 Flotantes: float
- 11.5.1 Notación exponencial
- 11.5.2 Precisión
- 11.5.3 Infinito y no 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: complejos
- 12 Tipos de datos secuenciales
- 12.1 La diferencia entre datos de texto y datos binarios
- 12.2 Operaciones en instancias de tipos de datos secuenciales
- 12.2.1 Comprobación de elementos
- 12.2.2 Concatenación
- 12.2.3 Repetición
- 12.2.4 Indexación
- 12.2.5 Corte en rodajas
- 12.2.6 Duración 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 Cambiar 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 Ordenar listas: s.sort([clave, inverso])
- 12.3.6 Efectos secundarios
- 12.3.7 Comprensión de listas
- 12.4 Listas inmutables: tupla
- 12.4.1 Empaquetado y desembalaje
- 12.4.2 ¡Inmutable no significa necesariamente que no se pueda cambiar!
- 12.5 Cadenas: str, bytes, bytearray
- 12.5.1 Caracteres de control
- 12.5.2 Métodos de cadena
- 12.5.3 Formateo de cadenas
- 12.5.4 Conjuntos de caracteres y caracteres especiales
- 13 Asignaciones 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 Comprensión de diccionarios
- 13.2 Conjuntos: conjunto y conjunto congelado
- 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: conjunto
- 13.2.6 Conjuntos inmutables: frozenset
- 14 Colecciones
- 14.1 Diccionarios encadenados
- 14.2 Recuento de frecuencias
- 14.3 Diccionarios con valores predeterminados
- 14.4 Listas doblemente enlazadas
- 14.5 Tuplas con nombre
- 15 Fecha y hora
- 15.1 Funciones temporales elementales: tiempo
- 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 Fecha y hora.fecha
- 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 Especificar la hora en las zonas horarias locales
- 15.3.3 Cálculos con indicaciones horarias en zonas horarias locales
- 16 Enumeraciones y banderas
- 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 palabras clave
- 17.6 Muchos parámetros arbitrarios
- 17.7 Parámetros solo de palabra clave
- 17.8 Parámetros solo posicionales
- 17.9 Desempaquetar 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 principales: nonlocal
- 17.11.5 Variables locales no vinculadas: un obstáculo
- 17.12 Funciones anónimas
- 17.13 Recursividad
- 17.14 Funciones integradas
- 17.14.1 abs(x)
- 17.14.2 todos (iterable)
- 17.14.3 cualquier (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 complejo([real, imaginario])
- 17.14.11 dict([fuente])
- 17.14.12 divmod(a, b)
- 17.14.13 enumerar(iterable, [inicio])
- 17.14.14 eval(expresión, [globales, locales])
- 17.14.15 exec(objeto, [globales, locales])
- 17.14.16 filtro(función, iterable)
- 17.14.17 float([x])
- 17.14.18 formato(valor, [especificación_de_formato])
- 17.14.19 frozenset([iterable])
- 17.14.20 globales()
- 17.14.21 hash(objeto)
- 17.14.22 ayuda([objeto])
- 17.14.23 hex(x)
- 17.14.24 id(objeto)
- 17.14.25 entrada([solicitud])
- 17.14.26 int([x, base])
- 17.14.27 len(s)
- 17.14.28 lista([secuencia])
- 17.14.29 locales()
- 17.14.30 mapa(función, [*iterable])
- 17.14.31 max(iterable, {default, clave}), max(arg1, arg2, [*args], {clave})
- 17.14.32 min(iterable, {default, clave}), min(arg1, arg2, [*args], {clave})
- 17.14.33 oct(x)
- 17.14.34 orden(c)
- 17.14.35 pow(x, y, [z])
- 17.14.36 imprimir([*objetos], {sep, fin, archivo, vaciar})
- 17.14.37 rango([inicio], fin, [paso])
- 17.14.38 repr(objeto)
- 17.14.39 invertido (secuencia)
- 17.14.40 redondear(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 suma(iterable, [inicio])
- 17.14.45 tupla([iterable])
- 17.14.46 tipo(objeto)
- 17.14.47 zip([*iterables], {estricto})
- 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 Declaraciones de importación relativa
- 18.4 El paquete importlib
- 18.4.1 Importación de módulos y paquetes
- 18.4.2 Cambiar el comportamiento de importación
- 18.5 Elementos lingüísticos planificados
- 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 Depósito y retiro de dinero
- 19.1.4 Cómo ver 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 Métodos de anulación
- 19.3.3 Ejemplo: Cuenta corriente con volumen de negocios diario
- 19.3.4 Perspectivas
- 19.4 Herencia múltiple
- 19.5 Atributos de la propiedad
- 19.5.1 Setters y Getters
- 19.5.2 Definición de atributos de propiedad
- 19.6 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: Duck Typing
- 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 predeterminados en clases de datos
- 20 Manejo de excepciones
- 20.1 Excepciones
- 20.1.1 Excepciones integradas
- 20.1.2 Generar una excepción
- 20.1.3 Manejo de una excepción
- 20.1.4 Excepciones personalizadas
- 20.1.5 Volver a generar una excepción
- 20.1.6 Encadenamiento de excepciones
- 20.2 Afirmaciones
- 20.3 Advertencias
- 21 Generadores e iteradores
- 21.1 Generadores
- 21.1.1 Subgeneradores
- 21.1.2 Expresiones generadoras
- 21.2 Iteradores
- 21.2.1 El protocolo 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 acumular(iterable, [func])
- 21.3.2 cadena([*iterables])
- 21.3.3 combinaciones(iterable, r)
- 21.3.4 combinaciones_con_reemplazo(iterable, r)
- 21.3.5 comprimir(datos, selectores)
- 21.3.6 count([inicio, paso])
- 21.3.7 ciclo(iterable)
- 21.3.8 dropwhile(predicado, iterable)
- 21.3.9 filterfalse(predicado, iterable)
- 21.3.10 groupby(iterable, [clave])
- 21.3.11 islice(iterable, [inicio], fin, [paso])
- 21.3.12 permutaciones(iterable, [r])
- 21.3.13 producto([*iterables], [repetir])
- 21.3.14 repetir(objeto, [veces])
- 21.3.15 starmap(función, iterable)
- 21.3.16 takewhile(predicado, iterable)
- 21.3.17 tee(iterable, [n])
- 21.3.18 zip_longest([*iterables], {valor de relleno})
- 22 Administrador de contexto
- 22.1 La instrucción with
- 22.1.1 __enter__(self)
- 22.1.2 __exit__(self, tipo_excepción, valor_excepción, rastreo)
- 22.2 Funciones auxiliares para contextos: contextlib
- 22.2.1 Combinaciones de contexto ensambladas dinámicamente: ExitStack
- 22.2.2 Supresión de determinados tipos de excepciones
- 22.2.3 Redireccionamiento del flujo de salida estándar
- 22.2.4 Contextos opcionales
- 22.2.5 Funciones simples como administrador de contexto
- 23 Decoradores
- 23.1 Decoradores de funciones
- 23.1.1 Funciones y métodos decorativos
- 23.1.2 Nombre y cadena de documentación después de aplicar un decorador
- 23.1.3 Decoradores anidados
- 23.1.4 Ejemplo: un decorador de caché
- 23.2 Decoradores de clase
- 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 Finalización de los pedidos 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 tipos: el módulo typing
- 24.2.1 Indicaciones de tipo válidas
- 24.2.2 Tipos de contenedores
- 24.2.3 Tipos de contenedores abstractos
- 24.2.4 Alias de tipos
- 24.2.5 Uniones de tipos y valores opcionales
- 24.2.6 Variables de tipo
- 24.3 Comprobación de tipos estáticos 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 valor
- 25.2.2 Patrón OR
- 25.2.3 Patrones con verificación de tipos
- 25.2.4 Especificación de las condiciones para las 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 mapeo
- 25.2.9 Patrones para objetos y sus valores de 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: aleatorio
- 26.2.1 Guardar y cargar el estado aleatorio
- 26.2.2 Generación de números enteros aleatorios
- 26.2.3 Generación de flotantes aleatorios
- 26.2.4 Operaciones aleatorias en 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 Context
- 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 de pantalla y registro
- 27.1 Salida formateada de objetos complejos: pprint
- pprint(objeto, [flujo, sangría, ancho, profundidad], {compacto})
- 27.2 Archivos de registro: registro
- 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 personaje
- 28.1.2 Clases de personajes
- 28.1.3 Cuantificadores
- 28.1.4 Clases de caracteres predefinidas
- 28.1.5 Otros caracteres especiales
- 28.1.6 Cuantificadores no codiciosos
- 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 Emparejamiento
- 28.2.3 Dividir 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 Banderas
- 28.2.8 El objeto Match
- 28.3 Un programa de ejemplo sencillo: búsqueda
- 28.4 Un programa de muestreo más complejo: emparejamiento
- 28.5 Comentarios en expresiones regulares
- 29 Interfaz con el sistema operativo y el entorno de tiempo de ejecución
- 29.1 Funcionalidad del sistema operativo: os
- 29.1.1 entorno
- 29.1.2 getpid()
- 29.1.3 cpu_count()
- 29.1.4 sistema (cmd)
- 29.1.5 popen(comando, [modo, búfer])
- 29.2 Acceso al entorno de tiempo de ejecución: sys
- 29.2.1 Parámetros de la línea de comando
- 29.2.2 Rutas predeterminadas
- 29.2.3 Flujos de entrada/salida estándar
- 29.2.4 Salir del programa
- 29.2.5 Detalles de la versión de Python
- 29.2.6 Detalles del sistema operativo
- 29.2.7 Ganchos
- 29.3 Parámetros de la línea de comando: argparse
- 29.3.1 Calculadora: un ejemplo sencillo
- 29.3.2 Un ejemplo más complejo
- 30 Sistema de archivos
- 30.1 Acceso al sistema de archivos: os
- 30.1.1 acceso(ruta, modo)
- 30.1.2 chmod(ruta, modo)
- 30.1.3 listdir([ruta])
- 30.1.4 mkdir(ruta, [modo]) y makedirs(ruta, [modo])
- 30.1.5 eliminar(ruta)
- 30.1.6 removedirs(ruta)
- 30.1.7 renombrar(src, dst) y renombrar(antiguo, nuevo)
- 30.1.8 walk(top, [topdown, onerror])
- 30.2 Rutas de archivo: os.path
- 30.2.1 abspath(ruta)
- 30.2.2 basename(ruta)
- 30.2.3 prefijo común (lista)
- 30.2.4 dirname(ruta)
- 30.2.5 unir(ruta, *rutas)
- 30.2.6 normcase(ruta)
- 30.2.7 dividir(ruta)
- 30.2.8 splitdrive(ruta)
- 30.2.9 splitext(ruta)
- 30.3 Acceso al sistema de archivos: shutil
- 30.3.1 Operaciones con directorios y archivos
- 30.3.2 Operaciones de archivo
- 30.4 Archivos temporales: tempfile
- 30.4.1 ArchivoTemporal([modo, [tamañobúfer, sufijo, prefijo, dir])
- 30.4.2 tempfile.TemporaryDirectory([sufijo, prefijo, dir])
- 31 Programación paralela
- 31.1 Procesos, multitarea y subprocesos
- 31.1.1 Los pesos ligeros entre los procesos: subprocesos
- 31.1.2 ¿Hilos o procesos?
- 31.1.3 Multitarea cooperativa: una tercera vía
- 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 ejecutoras como administradores de contexto
- 31.3.3 Uso de futures.ProcessPoolExecutor
- 31.3.4 Gestión de las tareas de un albacea
- 31.4 La interfaz flexible: subprocesos y multiprocesamiento
- 31.4.1 Hilos en Python: subprocesos
- 31.4.2 Procesos en Python: multiprocesamiento
- 31.5 Multitarea cooperativa
- 31.5.1 Funciones cooperativas: Corrutinas
- 31.5.2 Objetos esperables
- 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 del lenguaje asíncrono
- 31.6 Conclusión: ¿Cuál es la interfaz adecuada?
- 31.6.1 ¿Es viable la multitarea cooperativa?
- 31.6.2 ¿Abstracción o flexibilidad?
- 31.6.3 ¿Hilos o procesos?
- 32 Almacenamiento de datos
- 32.1 XML
- 32.1.1 Árbol de elementos
- 32.1.2 API simple para XML
- 32.2 Bases de datos
- 32.2.1 La base de datos integrada en Python: sqlite3
- 32.3 Archivos comprimidos y archivos
- 32.3.1 gzip.open(nombre_archivo, [modo, nivel_compresión])
- 32.3.2 Otros módulos para acceder a datos comprimidos
- 32.4 Serialización de instancias: pickle
- 32.4.1 Interfaz funcional
- 32.4.2 Interfaz orientada a objetos
- 32.5 El formato de intercambio de datos JSON: json
- 32.6 El formato de tabla CSV: csv
- 32.6.1 Lectura de datos de un archivo CSV con objetos reader
- 32.6.2 Uso de dialectos personalizados: objetos dialecto
- 33 Comunicación en red
- 33.1 API de socket
- 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 bytes de red
- 33.1.8 Servidores de multiplexación: 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 manera fácil: solicitudes
- 34.3.1 Solicitudes simples 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_host_local, tiempo_de_espera, dirección_de_origen])
- 35.1.2 Establecimiento y terminació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 terminación de una conexión
- 35.2.3 Listado de 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 terminación de una conexión
- 35.3.3 Búsqueda y selección de un buzón
- 35.3.4 Operaciones con buzones de correo
- 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: correo electrónico
- 35.4.1 Creación de un correo electrónico sencillo
- 35.4.2 Crear un correo electrónico con archivos adjuntos
- 35.4.3 Leer 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 Seguimiento: rastrear
- 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 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 del idioma
- 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 Intérpretes y compiladores alternativos
- 40.1 Compilación justo a tiempo: PyPy
- 40.1.1 Instalación y uso
- 40.1.2 Ejemplo
- 40.2 Número
- 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 Cython
- 40.3.4 Un programa Cython con tipado estático
- 40.3.5 Uso de una biblioteca 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 Conjuntos 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 empacador
- 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.4 Señales y ranuras
- 41.5 Widgets importantes
- 41.5.1 QCheckBox
- 41.5.2 QComboBox
- 41.5.3 QDateEdit, QTimeEdit y QDateTimeEdit
- 41.5.4 QDialog
- 41.5.5 QLineEdit
- 41.5.6 QListWidget y QListView
- 41.5.7 QProgressBar
- 41.5.8 QPushButton
- 41.5.9 Botón de radio QRadioButton
- 41.5.10 QSlider y QDial
- 41.5.11 QTextEdit
- 41.5.12 QWidget
- 41.6 Funcionalidad de dibujo
- 41.6.1 Herramientas
- 41.6.2 Sistema de coordenadas
- 41.6.3 Formas simples
- 41.6.4 Imágenes
- 41.6.5 Texto
- 41.6.6 Atractivo visual
- 41.7 Arquitectura modelo-vista
- 41.7.1 Proyecto de ejemplo: una libreta de direcciones
- 41.7.2 Selección de entradas
- 41.7.3 Edición de entradas
- 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 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 Sistema de plantillas de Django
- 42.4.8 Procesamiento de datos de formularios
- 42.4.9 Panel de control administrativo de Django
- 43 Computación científica y ciencia de datos
- 43.1 Instalación
- 43.2 El Programa Modelo
- 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 Insertar filas y columnas
- 43.4.5 Expresiones lógicas en registros de datos
- 43.4.6 Manipulación de registros de datos
- 43.4.7 Entrada y salida
- 43.4.8 Visualización
- 44 Conocimiento interno
- 44.1 Abrir URL en el navegador predeterminado: webbrowser
- 44.2 Interpretación de datos binarios: struct
- 44.3 Entrada de contraseña oculta
- 44.3.1 getpass([prompt, stream])
- 44.3.2 getpass.getuser()
- 44.4 Interprete de línea de comandos
- 44.5 Interfaz de archivo para cadenas: io.StringIO
- 44.6 Los generadores como consumidores
- 44.6.1 Un decorador para consumir funciones generadoras
- 44.6.2 Activación de excepciones en un generador
- 44.6.3 Una tubería como cadena de funciones generadoras de consumo
- 44.7 Copiar instancias: copiar
- 44.8 Procesamiento de imágenes: Almohada
- 44.8.1 Instalación
- 44.8.2 Carga y guardado de archivos de imagen
- 44.8.3 Acceso a píxeles individuales
- 44.8.4 Manipulación de imágenes
- 44.8.5 Interoperabilidad
- 45 De Python 2 a Python 3
- 45.1 Las principales diferencias
- 45.1.1 Entrada/Salida
- 45.1.2 Iteradores
- 45.1.3 Cuerdas
- 45.1.4 Números enteros
- 45.1.5 Manejo de excepciones
- 45.1.6 Biblioteca estándar
- 45.2 Conversión automática
- Anexos
- A Apéndice
- A.1 Palabras reservadas
- A.2 Precedencia de operadores
- A.3 Funciones integradas
- A.4 Excepciones integradas
- A.5 Entornos de desarrollo integrado (IDE) para Python
- B Los autores
- Índice
Python 3
Ready to master Python? 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 using Django and working with GUIs. With plenty 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
- Download and consult practical code examples
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 your mathematical functions to debugging your 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 First English Edition (2022)
- 1.7 Acknowledgments
- 2 The Python Programming Language
- 2.1 History, Concepts, and Areas of Application
- 2.1.1 History and Origin
- 2.1.2 Basic Concepts
- 2.1.3 Possible Areas of Use and Strengths
- 2.1.4 Examples of Use
- 2.2 Installing Python
- 2.2.1 Installing Anaconda on Windows
- 2.2.2 Installing Anaconda on Linux
- 2.2.3 Installing Anaconda on macOS
- 2.3 Installing Third-Party Modules
- 2.4 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.2.6 The for Loop as a Counting Loop
- 5.3 The pass Statement
- 5.4 Assignment Expressions
- 5.4.1 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
- 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.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 Methods
- 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 String Methods
- 12.5.3 Formatting Strings
- 12.5.4 Character Sets and Special Characters
- 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.3 Dictionaries with Default Values
- 14.4 Doubly Linked Lists
- 14.5 Named Tuples
- 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])
- 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.4.1 Importing Modules and Packages
- 18.4.2 Changing the Import Behavior
- 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.5 Property Attributes
- 19.5.1 Setters and Getters
- 19.5.2 Defining Property Attributes
- 19.6 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 Re-Raising an Exception
- 20.1.6 Exception Chaining
- 20.2 Assertions
- 20.3 Warnings
- 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 chain([*iterables])
- 21.3.3 combinations(iterable, r)
- 21.3.4 combinations_with_replacement(iterable, r)
- 21.3.5 compress(data, selectors)
- 21.3.6 count([start, step])
- 21.3.7 cycle(iterable)
- 21.3.8 dropwhile(predicate, iterable)
- 21.3.9 filterfalse(predicate, iterable)
- 21.3.10 groupby(iterable, [key])
- 21.3.11 islice(iterable, [start], stop, [step])
- 21.3.12 permutations(iterable, [r])
- 21.3.13 product([*iterables], [repeat])
- 21.3.14 repeat(object, [times])
- 21.3.15 starmap(function, iterable)
- 21.3.16 takewhile(predicate, iterable)
- 21.3.17 tee(iterable, [n])
- 21.3.18 zip_longest([*iterables], {fillvalue})
- 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
- 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 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
- 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
- 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 Accessing the Runtime Environment: sys
- 29.2.1 Command Line Parameters
- 29.2.2 Default Paths
- 29.2.3 Standard Input/Output Streams
- 29.2.4 Exiting the Program
- 29.2.5 Details of the Python Version
- 29.2.6 Operating System Details
- 29.2.7 Hooks
- 29.3 Command Line Parameters: argparse
- 29.3.1 Calculator: A Simple Example
- 29.3.2 A More Complex Example
- 30 File System
- 30.1 Accessing the File System: os
- 30.1.1 access(path, mode)
- 30.1.2 chmod(path, mode)
- 30.1.3 listdir([path])
- 30.1.4 mkdir(path, [mode]) and makedirs(path, [mode])
- 30.1.5 remove(path)
- 30.1.6 removedirs(path)
- 30.1.7 rename(src, dst) and renames(old, new)
- 30.1.8 walk(top, [topdown, onerror])
- 30.2 File Paths: os.path
- 30.2.1 abspath(path)
- 30.2.2 basename(path)
- 30.2.3 commonprefix(list)
- 30.2.4 dirname(path)
- 30.2.5 join(path, *paths)
- 30.2.6 normcase(path)
- 30.2.7 split(path)
- 30.2.8 splitdrive(path)
- 30.2.9 splitext(path)
- 30.3 Accessing the File System: shutil
- 30.3.1 Directory and File Operations
- 30.3.2 Archive Operations
- 30.4 Temporary Files: tempfile
- 30.4.1 TemporaryFile([mode, [bufsize, suffix, prefix, dir])
- 30.4.2 tempfile.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 Threads or Processes?
- 31.1.3 Cooperative Multitasking: A Third Way
- 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 XML
- 32.1.1 ElementTree
- 32.1.2 Simple API for XML
- 32.2 Databases
- 32.2.1 The Built-In Database in Python: sqlite3
- 32.3 Compressed Files and Archives
- 32.3.1 gzip.open(filename, [mode, compresslevel])
- 32.3.2 Other Modules for Accessing Compressed Data
- 32.4 Serializing Instances: pickle
- 32.4.1 Functional Interface
- 32.4.2 Object-Oriented Interface
- 32.5 The JSON Data Exchange Format: json
- 32.6 The CSV Table Format: csv
- 32.6.1 Reading Data from a CSV File with reader Objects
- 32.6.2 Using Custom Dialects: Dialect Objects
- 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.4 Signals and Slots
- 41.5 Important Widgets
- 41.5.1 QCheckBox
- 41.5.2 QComboBox
- 41.5.3 QDateEdit, QTimeEdit, and QDateTimeEdit
- 41.5.4 QDialog
- 41.5.5 QLineEdit
- 41.5.6 QListWidget and QListView
- 41.5.7 QProgressBar
- 41.5.8 QPushButton
- 41.5.9 QRadioButton
- 41.5.10 QSlider and QDial
- 41.5.11 QTextEdit
- 41.5.12 QWidget
- 41.6 Drawing Functionality
- 41.6.1 Tools
- 41.6.2 Coordinate System
- 41.6.3 Simple Shapes
- 41.6.4 Images
- 41.6.5 Text
- 41.6.6 Eye Candy
- 41.7 Model-View Architecture
- 41.7.1 Sample Project: An Address Book
- 41.7.2 Selecting Entries
- 41.7.3 Editing Entries
- 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.2 Interpreting Binary Data: struct
- 44.3 Hidden Password Entry
- 44.3.1 getpass([prompt, stream])
- 44.3.2 getpass.getuser()
- 44.4 Command Line Interpreter
- 44.5 File Interface for Strings: io.StringIO
- 44.6 Generators as Consumers
- 44.6.1 A Decorator for Consuming Generator Functions
- 44.6.2 Triggering Exceptions in a Generator
- 44.6.3 A Pipeline as a Chain of Consuming Generator Functions
- 44.7 Copying Instances: copy
- 44.8 Image Processing: Pillow
- 44.8.1 Installation
- 44.8.2 Loading and Saving Image Files
- 44.8.3 Accessing Individual Pixels
- 44.8.4 Manipulating Images
- 44.8.5 Interoperability
- 45 From Python 2 to Python 3
- 45.1 The Main Differences
- 45.1.1 Input/Output
- 45.1.2 Iterators
- 45.1.3 Strings
- 45.1.4 Integers
- 45.1.5 Exception Handling
- 45.1.6 Standard Library
- 45.2 Automatic Conversion
- Appendices
- A Appendix
- A.1 Reserved Words
- A.2 Operator Precedence
- A.3 Built-In Functions
- A.4 Built-In Exceptions
- A.5 Python IDEs
- B The Authors
- Index
