Machine Translated by Google
AUTOMATICE
LAS COSAS ABURRIDAS
CON PYTHON
PROGRAMACIÓN PRÁCTICA
PARA PRINCIPIANTES TOTALES
AL SWEIGART
Machine Translated by Google
Automatice las cosas aburridas con
Python
SÍGUENOS EN FACEBOOK
Machine Translated by Google
Ethe automático
Cosas aburridas con
Python
Programación práctica para
principiantes totales
por Al Sweigart
San Francisco
Machine Translated by Google
Automatice las cosas aburridas con Python. Copyright © 2015 por Al Sweigart.
Reservados todos los derechos. Ninguna parte de este trabajo puede reproducirse o transmitirse de ninguna forma o por ningún medio,
electrónico o mecánico, incluidas las fotocopias, las grabaciones o cualquier sistema de almacenamiento o recuperación de información,
sin el permiso previo por escrito del propietario de los derechos de autor y el editor.
Impreso en EE. UU.
Segunda impresión
19 18 17 16 15 2 3 4 5 6 7 8 9
ISBN-10: 1-59327-599-4
ISBN-13: 978-1-59327-599-0
Editor: William Pollock
Editora de producción: Laurel Chun
Ilustración de portada: Josh Ellingson
Diseño de Interiores: Octopod Studios
Editores de desarrollo: Jennifer Griffith-Delgado, Greg Poulos y Leslie Shen
Revisor técnico: Ari Lacenski
Correctora: Kim Wimpsett
Compositor: Susan Glinert Stevens
Correctora: Lisa Devoto Farrell
Indexador: Servicios de corrección e indexación BIM
Para obtener información sobre distribución, traducciones o ventas al por
mayor, comuníquese directamente con No Starch Press, Inc.:
Sin prensa de almidón, Inc.
245 Calle 8, San Francisco, CA 94103
teléfono: 415.863.9900; info@nostarch.com
www.nostarch.com
Número de control de la Biblioteca del Congreso: 2014953114
No Starch Press y el logotipo de No Starch Press son marcas comerciales registradas de No Starch Press, Inc. Otros nombres de
productos y empresas mencionados aquí pueden ser marcas comerciales de sus respectivos propietarios. En lugar de utilizar un símbolo
de marca comercial cada vez que aparece un nombre de marca comercial, utilizamos los nombres solo de forma editorial y en beneficio
del propietario de la marca comercial, sin intención de infringir los derechos de propiedad intelectual.
marca comercial.
La información de este libro se distribuye "tal cual", sin garantía. Si bien se han tomado todas las precauciones en la preparación de este
trabajo, ni el autor ni No Starch Press, Inc. tendrán responsabilidad alguna ante ninguna persona o entidad con respecto a cualquier pérdida
o daño causado o presuntamente causado directa o indirectamente por el información contenida en el mismo.
Este trabajo está bajo la licencia Creative Commons Attribution-NonCommercial-ShareAlike 3.0 United
Licencia de los Estados. Para ver una copia de esta licencia, visite http://creativecommons.org/licenses/by-nc-sa/3.0/us/ o envíe una carta
a Creative Commons, PO Box 1866, Mountain View, CA 94042, EE. UU.
Machine Translated by Google
Para mi sobrino Jack
Machine Translated by Google
Sobre el Autor
Al Sweigart es un desarrollador de software y autor de libros de tecnología que
vive en San Francisco. Python es su lenguaje de programación favorito y es el
desarrollador de varios módulos de código abierto para él. Sus otros libros están
disponibles gratuitamente bajo una licencia Creative Commons en su sitio web http:// www
.inventwithpython.com/. Su gato pesa 14 libras.
Acerca del revisor técnico
Ari Lacenski es un desarrollador de aplicaciones Android y software Python.
Vive en San Francisco, donde escribe sobre la programación de Android en http://
gradlewhy.ghost.io/ y es mentora de Women Who Code. También es guitarrista de folk.
Machine Translated by Google
Contenidos breves
Agradecimientos .
........................................................................................................................... XXIII
Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Parte I: Conceptos básicos de programación en Python. .................................................................. 11
Capítulo 1: Conceptos básicos de Python. ..................................................................................................................................................................13
Capítulo 2: Control de flujo. .
Capítulo 3: Funciones. .
................................................................................................................... 31
........................................................................................................................ 61
Capítulo 4: Listas. . .................................................................................................................................. 79
Capítulo 5: Diccionarios y estructuración de datos. .................................................................................. 105
Capítulo 6: Manipulación de cadenas. ...................................................................................................... 123
Parte II: Automatización de tareas. ................................................................................. 145
Capítulo 7: Coincidencia de patrones con expresiones regulares .................................................................. 147
Capítulo 8: Lectura y escritura de archivos . . ......................................................................................... 173
Capítulo 9: Organización de archivos ......................................................................................................................... 197
Capítulo 10: Depuración . .
Capítulo 11: Web Scraping . .
................................................................................................................. 215
. ........................................................................................................ 233
Capítulo 12: Trabajar con hojas de cálculo de Excel. .
. ....................................................................... 265
Capítulo 13: Trabajar con documentos PDF y Word.
. ............................................................. 295
Capítulo 14: Trabajo con archivos CSV y datos JSON .
. ............................................................. 319
Capítulo 15: Control del tiempo, programación de tareas e inicio de programas . .
.............................. 335
Capítulo 16: Envío de correo electrónico y mensajes de texto ................................................................................................ 361
Capítulo 17: Manipulación de imágenes ..................................................................................................... 387
Capítulo 18: Controlar el teclado y el mouse con la automatización de la GUI .
.............................. 413
Machine Translated by Google
Apéndice A: Instalación de módulos de terceros. ..................................................................................... 441
Apéndice B: Programas en ejecución. ......................................................................................................... 443
Apéndice C: Respuestas a las preguntas de práctica .............................................................................. 447
índice . ...................................................................................................................................................... 461
Machine Translated by Google
Contenido en detalle
Expresiones de gratitud
XXIII
1
Introducción
¿Para quién es este libro? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
convenciones .
.. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. 2
¿Qué es la programación? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
¿Qué es Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Los programadores no necesitan saber mucho de matemáticas. . . . . . . . . . . . . . . . . . . . . . . . 4
La programación es una actividad creativa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Sobre este libro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
.. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. ..6
Descarga e instalación de Python.
.. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. ..7
Iniciar IDLE
El shell interactivo. .
.. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. ..8
Cómo encontrar ayuda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Hacer preguntas sobre programación inteligente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Resumen . . .....................................................................................................................................10
Parte I: Conceptos básicos de programación en Python
11
1
13
Conceptos básicos de Python
Introducción de expresiones en la consola interactiva. ............................................................................. 14
Los tipos de datos enteros, de punto flotante y de cadena. ................................................................ dieciséis
Concatenación y replicación de cadenas. .
. ....................................................................................17
Almacenamiento de valores en variables. ................................................................................................................................................... 18
Declaraciones de cesión. .
. ..............................................................................................18
Nombres de variables. ........................................................................................................................ 20
Tu primer programa. . ....................................................................................................................... 21
Diseccionando su programa. ................................................................................................................ 22
Comentarios ........................................................................................................................23
La función imprimir(). . . ...................................................................................................23
La función de entrada(). ........................................................................................................ 23
Impresión del Nombre del Usuario. .................................................................................................................... 24
. ......................................................................................................... 24
La función len().
. .......................................................................25
Las funciones str(), int() y float(). .
.
....................................................................................................................................
28
Resumen . .
Preguntas de práctica. ......................................................................................................................................... 28
2
Control de flujo
31
Valores booleanos................................................................................................................................. 32
Operadores de comparación................................................................................................................................. 33
Operadores booleanos......................................................................................................................................... 35
Machine Translated by Google
Operadores booleanos binarios. ............................................................................................ 35
. ........................................................................................................ 36
Mezcla de operadores booleanos y de comparación. ............................................................................. 36
Elementos de Control de Flujo. ........................................................................................................................... 37
Condiciones .......................................................................................................................... 37
Bloques de Código. ............................................................................................................... 37
Ejecución del Programa. ...................................................................................................................................... 38
Declaraciones de control de
............................................................................................................ 38
flujo. . Si
................................................................................................................. 38
declaraciones. . más ............................................................................................................ 39
Declaraciones. . ................................................................................................................. 40
. .............................................................................................. 45
Instrucciones elif while
Instrucciones de bucle ....................................................................................................................... 49
Declaraciones de ruptura. . ................................................................................................... 50
continuar Declaraciones . . for Loops y la funció. n. r.a.ng.e.() ............................................................ 53
Importación de módulos....................................................................................................................................... 57
El no Operador.
de extractos de importación.
. .............................................................................................. 58
Finalización anticipada de un programa con sys.exit() ............................................................................................................ 58
Resumen .
. ...................................................................................................................................... 58
...................................................................................................................... 59
Preguntas de práctica. .
3
Funciones
def Sentencias con parámetros. .
61
. .............................................................................................. 63
Valores de retorno y declaraciones de retorno....................................................................................................... 63
El valor Ninguno. . .............................................................................................................................
Argumentos de palabras clave e print() .............................................................................................................
sesent a y cinco
sesent a y cinco
............................................................................................................ 67
Las variables locales no se pueden utilizar en el ámbito global............................................. 67
Los ámbitos locales no pueden utilizar variables en otros ámbitos locales. ......................................... 68
Las variables globales se pueden leer desde un ámbito local. ................................................. 69
Variables locales y globales con el mismo nombre. .......................................................... 69
La Declaración mundial. . ................................................................................................................. 70
Manejo de excepciones .......................................................................................................................... 72
. .................................................................................... 74
Un programa corto: adivina el número. .
Resumen . . ...................................................................................................................................... 76
Preguntas de práctica. . ...................................................................................................................... 76
Proyectos de práctica. ........................................................................................................................................................... 77
Alcance Local y Global. .
La sucesión de Collatz. .
. .............................................................................................. 77
Validación de entrada. ....................................................................................................................................... 77
4
Liza
79
El tipo de datos de la lista..................................................................................................................................................... 80
Obtención de valores individuales en una lista con índices............................................................... 80
. ........................................................................................................ 82
Índices negativos.
Obtener sublistas con rebanadas. ...................................................................................................... 82
Obtener la longitud de una lista con len() ............................................................................................ 83
Cambio de valores en una lista con índices....................................................................... 83
x Contenido en detalle
Machine Translated by Google
Concatenación de listas y replicación de listas. . . . . . . . . . . .............................................83
Eliminación de valores de listas con declaraciones del. . . . . .............................................84
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .............................................84
Trabajando con
Listas Usando bucles for con Lista. s.. .. . . . . . . . . . . . . . . . .............................................86
.. . .. .. .. .. .. ...
Los operadores in y not in. .
El truco de la asignación múltiple. . . . . . . . . . . . . . . . .
Operadores de asignación aumentada. . . . . . . . . . . . . . . . . . . .
Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.............................................87
.............................................87
.............................................88
.............................................89
.............................................89
Encontrar un valor en una lista con el método index(). . .
. .......................89
Adición de valores a las listas con los métodos append() e insert() . .
.
............................................
90
.
.
.
.
.
.
.
Eliminación de valores de las listas con remove() .
.............................................91
Ordenar los valores en una lista con el método sort(). . .
Programa de ejemplo: Magic 8 Ball con una lista . . . . . . . . . . . . . . .............................................92
Tipos similares a listas: cadenas y tuplas.. . . . . . . . . . . . . . . . . . . . .............................................93
. . . . . . . . . . . .............................................94
Tipos de datos mutables e inmutables.
.............................................96
El tipo de datos de tupla. . . . . . . . . . . . . . . . . . . . . . .
.............................................97
Conversión de tipos con las funciones list() y tuple() .
Referencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .............................................97
Pasando referencias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
. . . . . . . . . . . . . . . . . 100
Las funciones copy() y deepcopy() del módulo copy.
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Preguntas de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Proyectos de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Código de coma. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Cuadrícula de imágenes de personajes. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . 103
5
Diccionarios y estructuración de datos
105
El tipo de datos del diccionario......10. 5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Diccionarios vs. Listas. . ....1.0.6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Los métodos keys(), valores() y items() ............................ 107
Comprobar si existe una clave o un valor en un diccionario. . . . 109. . . . . . . . . . .
El método get(). . . 10. 9. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
El método setdefault() . . . 11.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Impresión bonita. 1.1.1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Uso de estructuras de datos para modelar cosas del mundo real. . . . . . . . . . . . . . . . . . . . . . . . . .
112
Un tablero de tres en raya. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Listas y diccionarios anidados.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Preguntas de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Proyectos de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Inventario de juegos de fantasía. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Función de lista a diccionario para el inventario de juegos de fantasía. . . . . . . . . . . . . . . . . 120
6
Manipulación de cadenas
123
Trabajando con Cadenas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
Literales de cadena. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
124
Cadenas de indexación y rebanado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Los operadores in y not in con cadenas. .
. . . . . . . . . . . . . . . . . . . . . . . . 127
Contenidos en detalle
xi
Machine Translated by Google
Métodos de cadenas útiles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
. . . . . . . . . . . 128
Los métodos de cadena upper(), lower(), isupper() e islower() .
Los métodos de cadena isX. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Los métodos de cadena de caracteres "startwith()" y "termswith()". . . . . . . . . . . . . . . . . . . . . . 131
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
Los métodos de cadena join() y split().
Justificación de texto con rjust(), ljust() y center() . . . . . . . . . . . . . . . . . . . . . . . 133
Eliminación de espacios en blanco con strip(), rstrip() y lstrip() . . . . . . . . . . . . . . . . . 134
Copiar y pegar cadenas con el módulo pyperclip.
. . . . . . . . . . . . . . . 135
Proyecto: Bloqueo de contraseñas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
Paso 1: Diseño del programa y estructuras de datos. . . . . . . . . . . . . . . . . . . . . . . 136
Paso 2: manejar los argumentos de la línea de comandos. . . . . . . . . . . . . . . . . . . . . . . . . 137
Paso 3: Copie la contraseña correcta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Proyecto: Adición de viñetas al marcado Wiki. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
. . . . . . . . . . . . . . . . . . . . . . 139
Paso 1: copiar y pegar desde el portapapeles. .
. . . . . . . . . . . . . . . . . . 140
Paso 2: separe las líneas de texto y agregue la estrella
Paso 3: una las líneas modificadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Proyecto de práctica de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
preguntas de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Impresora de mesa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Parte II: Automatización de tareas
145
7
Coincidencia de patrones con expresiones regulares
147
Búsqueda de patrones de texto sin expresiones regulares. . . . . . . . . . . . . . . . . . . . . . . . 148
Búsqueda de patrones de texto con expresiones regulares. . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Creación de objetos Regex. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Coincidencia de objetos Regex. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Revisión de la coincidencia de expresiones regulares. . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Más Coincidencia de patrones con expresiones regulares. . . . . . . . . . . . . . . . . . . . . . . . . . . 152
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Agrupación con paréntesis.
Coincidencia de varios grupos con la tubería. . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Emparejamiento opcional con el signo de interrogación. . . . . . . . . . . . . . . . . . . . . . . . 154
Coincidencia de cero o más con la estrella. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
Coincidencia de uno o más con el Plus.
Coincidencia de repeticiones específicas con corchetes. . . . . . . . . . . . . . . . . . . . 156
Emparejamiento codicioso y no codicioso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
El método findall().
Clases de personajes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Creando tus propias clases de personajes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
Los caracteres de intercalación y signo de dólar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
El carácter comodín. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Coincidencia de todo con Dot-Star.
Coincidencia de líneas nuevas con el carácter de punto. . . . . . . . . . . . . . . . . . . . . . . . 162
Revisión de los símbolos Regex. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Coincidencia que no distingue entre mayúsculas y minúsculas.
xi
Contenidos en detalle
Machine Translated by Google
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Sustitución de cadenas con el método sub().
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
. . . . . . . . . . . . . . . . . 164
Combinando re.IGNORECASE, re.DOTALL y re.VERBOSE . .
Proyecto: Extractor de números de teléfono y direcciones de correo electrónico . . . . . . . . . . . . . . . . . . . . . . . . 165
Paso 1: Cree una expresión regular para números de teléfono. . . . . . . . . . . . . . . . . . . . . . . . 166
. . . . . . . . . . . . . . . . . . . . . . 166
Paso 2: Cree una expresión regular para direcciones de correo electrónico. .
Paso 3: busque todas las coincidencias en el texto del portapapeles. . . . . . . . . . . . . . . . . . . . . . 167
Paso 4: Une las coincidencias en una cadena para el portapapeles. . . . . . . . . . . . . . . . 168
Gestión de expresiones regulares complejas. . . .
Ejecutando el Programa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Ideas para programas similares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Preguntas de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Proyectos de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
Detección de contraseña segura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
Versión Regex de strip() .
8
Leer y escribir archivos
173
Archivos y rutas de archivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ....... 173
Barra invertida en Windows y barra diagonal en OS X y Linux. .
. . . . . . . . . 174
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Creación de nuevas carpetas con os.makedirs() . . . . . . . . . . . . . . . . . . . . . . . . . . 176
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
El módulo os.path.
. . . . . . . . . . . . . . . . . . . . . . . . . . 177
Manejo de rutas absolutas y relativas. .
Búsqueda de tamaños de archivos y contenidos de carpetas. . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
Comprobación de la validez de la ruta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
El proceso de lectura/escritura de archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
. . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Apertura de archivos con la función open()
Lectura del contenido de los archivos.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Escritura en archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
Salvando Variables con el Módulo Shelve. . . 184 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.. .. . .. .. .. .. .. .. . .. ..
Guardar variables con la función pprint.pformat() . . . 185
Proyecto: Generación de archivos de cuestionarios aleatorio.s.. . .. 1.8.6 . . . . . . . . . . . . . . . . . . . . . . . . . .
El directorio de trabajo actual. .
Rutas absolutas y relativas.
Paso 1: Almacene los datos de la prueba en un diccionario
187
Paso 2: cree el archivo de prueba y cambie el orden de las preguntas. . .. 1. 8.8. . . . . .
Paso 3: Cree las opciones de respuesta. . . ..1.89. . . . . . . . . . . . . . . . . . . . . . . .
Paso 4: Escriba contenido en los archivos de clave de preguntas y respuestas..... .. 1.89. . . . . . .
Proyecto: Multiportapapeles.. .. . .19. 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Paso 1: Configuración de comentarios y estantes..... ..1.92. . . . . . . . . . . . . . . . . . . . . .
Paso 2: Guarde el contenido del portapapeles con una palabra clave.... .. 1.92. . . . . . . . . . . . .
Paso 3: Enumere las palabras clave y cargue el contenido de una palabra clave.. .. . .. 1.93. . . . . . . . .
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Preguntas de 194
.. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. .. . .. ..
Proyectos de prpárcáticcati.c.a. . . . .19.4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ampliación del multiportapapeles. . ..1.9.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Libs locos. . . . .1.95. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Búsqueda de expresiones regul.ar.es... . .19.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
194
Contenidos en detalle
XIII
Machine Translated by Google
9
197
Organización de archivos
El Módulo Shutil.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
Copia de archivos y carpetas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
. . . . . . . . . . . . . . . . . . . . . . . . 199
Mover y renombrar archivos y carpetas. .
Eliminación permanente de archivos y carpetas. . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Eliminaciones seguras con el módulo send2trash. . . . . . . . . . . . . . . . . . . . . . . . . . 201
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
Recorriendo un árbol de
directorios Comprimiendo archivos con el módulo zip.fi.le.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
Lectura de archivos ZIP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
Extracción de archivos ZIP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
Creación y adición de archivos ZIP.
Proyecto: Cambio de nombre de archivos con fechas de estilo
americano a fechas de estilo eu.ro.p.eo.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
. . . . . . . . . . . . . . . . . . . . 206
Paso 2: Identifique las partes de la fecha a partir de los nombres de archivo.. . . . . . . . . . . . . . . . . . . 207
Paso 3: Forme el nuevo nombre de archivo y cambie el nombre de los archivos. . . . . . . . . . . . . . . . . 209
Ideas para programas similares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Proyecto: Copia de seguridad de una carpeta en un archivo ZIP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Paso 1: averigüe el nombre del archivo ZIP. . . . . . . . . . . . . . . . . . . . . . . . . . . 210
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Paso 2: Cree el nuevo archivo ZIP.
. . . . . . . . . . . . . . . 211
Paso 3: recorrer el árbol de directorios y agregar ideas al
archivo ZIP para programas simil.a.re.s.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Preguntas de práctica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Proyectos de práctica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Copia selectiva. .
Paso 1: Cree una expresión regular para fechas de estilo americano
Eliminación de archivos innecesarios. . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
214
Rellenando los huecos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
depuración
Levantamiento de excepciones. . . .
215
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
Obtener el Traceback como una cadena. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Afirmaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Uso de una aserción en una simulación de semáforo. . . . . . . . . . . . . . . . . . . . . . 219
Inhabilitación de aserciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Inicio sesión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Uso del módulo de registro.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
No depure con print() .
Niveles de registro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
224
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
Depurador de IDLE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
Vamos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Paso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Sobre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Afuera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Deshabilitar el registro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Iniciar sesión en un archivo. . . .
xiv Contenidos en detalle
Machine Translated by Google
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
. . . . . . . . . . . . . . . . . . . . . . . . 227
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . . . . . . . . . . . . . . . . . . . . 229
Puntos de ruptura. .
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
Preguntas de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
Proyecto de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
Depuración de lanzamiento de moneda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
Salga
de la depuración de un programa de adición de números. . .
11
Raspado web
233
. . . . . . . . . . . . . . . . . . . . . . . . . . 234
Proyecto: mapIt.py con el módulo webbrowser. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
Paso 1: Averigüe la URL.
Paso 2: manejar los argumentos de la línea de comandos. . . . . . . . . . . . . . . . . . . . . . 235
. . . . . . . . . 236
Paso 3: maneje el contenido del portapapeles e inicie el navegador.
Ideas para programas similares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
. . . . . . . . . . . . . . . . . . . 237
Descarga de Archivos de la Web con el Módulo de solicitudes.
. . . . . . . . . . . 237
Descargar una página web con la función request.get() . .
Comprobación de errores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Guardar archivos descargados en el disco duro. .
html .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Recursos para aprender HTML.
Un repaso rápido.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Visualización del código fuente HTML de una página web. . . . . . . . . . . . . . . . . . . . . . . . . 241
Apertura de las herramientas de desarrollo de su navegador. . . . . . . . . . . . . . . . . . . . . . . . . . 242
Uso de las herramientas de desarrollo para buscar elementos HTML. . . . . . . . . . . . . . . . . . . . 244
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
Análisis de HTML con el módulo BeautifulSoup.
Creación de un objeto BeautifulSoup desde HTML. . . . . . . . . . . . . . . . . . . . . . . . 245
. . . . . . . . . . . . . . . . . . . . . . 246
Encontrar un elemento con el método select(). .
Obtener datos de los atributos de un elemento . . . . . . . . . . . . . . . . . . . . . . . . . 248
Proyecto: Búsqueda en Google “Me siento con suerte”. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Paso 1: obtener los argumentos de la línea de comandos y solicitar la página de búsqueda. ......... 249
Paso 2: Encuentra todos los resultados. . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ....... 249
Paso 3: Abra navegadores web para cada resultado. . . . . . . . . . . . . . . . . . . . . ....... 250
Ideas para programas similares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ....... 251
Proyecto: Descarga de todos los cómics de XKCD. .. ....25. 1. . . . . . . . . . . . . . . . . . . . . . . . .
Paso 1: Diseñar el Programa. . . . 2.5. 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Paso 2: Descargue la página web .................................. 253
Paso 3: busque y descargue la imagen del cómic. . . . 25. 4. . . . . . . . . . . . . . . . .
Paso 4: guarda la imagen y encuentra el cómic anterior. . . . 255. . . . . . . . . . . . .
Ideas para programas similares.. .. . . 2. 56. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . 256
Controlando el Navegador con el Módulo Selenium. .
.
.
.
. . . . . . . . . . . . . . . . . . . . . . . 256
Inicio de un navegador controlado por Selenium.
Búsqueda de elementos en la página. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
Al hacer clic en la página. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Llenado y envío de formularios.
Envío de llaves especiales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
Más información sobre el selenio. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
Haciendo clic en los botones del navegador. .
Contenidos en detalle xv
Machine Translated by Google
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
.
Proyectos de práctica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
Correo electrónico de línea de comandos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
Descargador de imágenes del
sitio. 2048. .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
Verificación de enlace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
Resumen .
Preguntas de práctica
12
Trabajar con hojas de cálculo de Excel
265
Documentos de Excel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
Instalación del módulo openpyxl. .
.
.
.
.
.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
Lectura de documentos de Excel.
. . . . . . . . . . . . . . . . . . . . . . . . 267
Abrir documentos de Excel con OpenPyXL.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Obtener hojas del libro de trabajo. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Obtención de celdas de las
. . . . . . . . . . . . . . . . . . . 270
hojas Conversión entre letras y números de columna.
. . . . . . . . . . . . . . . . . . . . . . 270
Obtener Filas y Columnas de las Hojas. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
Libros, Hojas, Celdas.
Proyecto: Lectura de datos de una hoja de cálculo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
Paso 1: Lea los datos de la hoja de cálculo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
Paso 2: Complete la estructura de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
Paso 3: Escriba los resultados en un
.
.
.
archivo Ideas para programas simila re s. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
Redacción de documentos en Excel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
. . . . . . . . . . . . . . . . . . . . . . . . . . 277
Crear y guardar documentos de Excel. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Creación y eliminación de hojas. .
Proyecto de escritura de valores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
en celdas: actualización de una hoja de cálculo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
Paso 1: configurar una estructura de datos con la información de actualización. . . . . . . . . . . . 280
. . . . . . . . . . . . . . . . . . 281
Paso 2: verifique todas las filas y actualice las ideas de precios
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . . . . . . . . . . . . . . 281
incorrectos para programas similares .
Configuración del estilo de fuente de las celdas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
Objetos de fuente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
fórmulas .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
Ajuste de filas y columnas.
Configuración de la altura de fila y el ancho de columna. . . . . . . . . . . . . . . . . . . . . . . . . . . 285
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
Fusionar y desfusionar celdas. .
Congelar paneles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
gráficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
Preguntas de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
Proyectos de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
Creador de tablas de multiplicar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
Insertador de filas en blanco. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
Inversor de celdas de hoja de cálculo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
Archivos de texto a hoja de cálculo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
Hoja de cálculo a archivos de texto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
xvi Contenidos en detalle
Machine Translated by Google
13
Trabajar con documentos PDF y Word
295
Documentos PDF. . . . .29.5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Extraer texto de archivos PDF. ..... . 2.96. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Descifrar archivos PDF.. .. .. 2.9. 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Creación de archivos PD. F.. . .. 2.9.8 . .
.. .. .. . .. .. .. .. .. . .. .. .. .. .. .. . .. ..
Proyecto: Combinación de páginas seleccionadas de muchos archivos PD . F.. .. 3.03. . . . . . . . . . . . . . . . . . . .
Paso 1: busque todos los archivos PDF. . .. . .. 3.04. . .
.. .. .. .. . .. .. .. .. .. .. . .. ..
Paso 2: Abra cada PDF. . 3. 04. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Paso 3: Agregar cada página.. .. . .3.05. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Paso 4: Guarde los resultados.. .. . .3.05. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ideas para programas similares.. .. . . 3. 06. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Documentos de Word.. .. . .3.06. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lectura de documentos de Word.. .. . .3. 07. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Obtener el texto completo de un archivo .docx. .. .. . .3. 08. . . . . . . . . . . . . . . . . . . .
Estilo de párrafo y objetos de ejecución. . . . .30. 9. . . . . . . . . . . . . . . . . . . . . . .
Creación de documentos de Word con estilos no predeterminados. .. . . ..3. 10. . . . . . . . . . .
Ejecutar atributos.. .. . .31. 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Escritura de documentos de Word.. .. . .3.12. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Adición de encabezados . . .. . .3. 14. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Adición de saltos de línea y de página.. .. . .31. 5. . . . . . . . . . . . . . . . . . . . . . . . . . .
Adición de imágenes. .. .... 31. 5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Resumen . . . .3. 1. 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Preguntas de práctica. . . .. 3.16. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Proyectos de práctica. .. .. ..3.17. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
PDF Paranoia. . . .3.17. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Invitaciones personalizadas como documentos de Word .............. 317
Descifrador de contraseñas de PDF de fuerza brut. a.. . .. 3. 18. . . . . . . . . . . . . . . . . . . . . . . .
14
Trabajar con archivos CSV y datos JSON
319
El módulo csv. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
Objetos del lector. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
. . . . . . . . . . . . . . . . . . . 322
Lectura de datos de objetos Reader en un bucle for.
Objetos del escritor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
Los argumentos de palabra clave delimitador y terminador de línea. . . . . . . . . . . . . . . . . . 323
Proyecto: Eliminar el encabezado de los archivos CSV. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
Paso 1: recorrer cada archivo CSV.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
Paso 2: Lea el archivo CSV.
. . . . . . . . . . . . . . . 326
Paso 3: escriba el archivo CSV sin la primera fila. .
Ideas para programas similares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
JSON y API. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
El módulo json.
. . . . . . . . . . . . . . . . . . . . . . . . 328
Leyendo JSON con la función loads() . .
. . . . . . . . . . . . . . . . . . . . . . . . 329
Escribiendo JSON con la función dumps() . .
Proyecto: Obtención de datos meteorológicos actuales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
Paso 1: obtener la ubicación desde el argumento de la línea de comandos. . . . . . . . . . . . . . . . 330
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Paso 2: Descargue los datos JSON.
Paso 3: Cargue los datos JSON e imprima el clima. . . . . . . . . . . . . . . . . . . . . . . . 331
Ideas para programas similares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
Contenidos en detalle
xvii
Machine Translated by Google
Preguntas de práctica. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
Proyecto de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
Convertidor de Excel a CSV. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
15
Control del tiempo, programación de tareas e
inicio de programas
335
El módulo del tiempo..... .3.36. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
La función time.time() ............................................. 336
La función time.sleep() . . . . 337. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Redondeo de Números. . . 3. 3. 8. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Proyecto: Súper Cronómetro. . .. 3. 3. 8. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Paso 1: configure el programa para realizar un seguimiento de los tiemp.os.. ... .339. . . . . . . . . . . . . . . . . .
Paso 2: Seguimiento e impresión de tiempos de vuel.ta.. . .. 3. 39. . . . . . . . . . . . . . . . . . . . . . . .
Ideas para programas similares.. .. . . 3. 40. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
El módulo de fecha y hora. ..... .34. 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
El tipo de datos timedelta. . . . 34. 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Pausa hasta una fecha específica.. . .34. 4. . . . . . . . . . . . . . . . . . . . . . . . . . . .
Conversión de objetos de fecha y hora en cadenas. .. .. . .3.44. . . . . . . . . . . . . . . . . .
Conversión de cadenas en objetos de fecha y hora. .. .. . .3.45. . . . . . . . . . . . . . . . . .
Revisión de las funciones de tiempo de Pytho. n. . .. 3. 46. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Multihilo. . . 347 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Pasar argumentos a la función de destino del subproceso. . . . . . . . . . . . . . . . . . . 348
Problemas de concurrencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Proyecto: XKCD Downloader multiproceso.
Paso 1: Modificar el programa para usar una función. . . . . . . . . . . . . . . . . . . . . . 350
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
. . . . . . . . . . . . . . . . . . . . . . . . . . 352
Lanzamiento de otros programas desde Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
Pasar argumentos de la línea de comandos a Popen() . . . . . . . . . . . . . . . . . . . . . . . 354
Paso 2: crear e iniciar subprocesos.
Paso 3: Espere a que finalicen todos los subprocesos. . . .
Programador de tareas, launchd y
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
cron Apertura de sitios web con Python. .... . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
Ejecución de otros scripts de Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
Apertura de archivos con aplicaciones predeterminadas. . . . . . . . . . . . . . . . . . . . . . . . . . . 355
Proyecto: Programa Simple de Cuenta Regresiva. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
Paso 1: cuenta regresiva. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
Paso 2: reproduzca el archivo de sonido. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
Ideas para programas similares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
Resumen . . . .3. 5. 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Preguntas de práctica. . . .. 3.59. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Proyectos de práctica. .. .. ..3.59. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Cronómetro embellecido. .. .. . . 3.60. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programa de descarga de cómics web .............................. 360
dieciséis
Envío de correo electrónico y mensajes de texto
SMTP. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ...... 362
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ...... 362
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
Conexión a un servidor SMTP. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
Envío del mensaje SMTP "Hola" .
Envío de correo electrónico.
xviii
361
Contenidos en detalle
Machine Translated by Google
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
Iniciando el cifrado TLS.
Iniciar sesión en el servidor SMTP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
Enviando un correo electrónico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
Desconectarse del servidor SMTP.
IMAP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
Recuperación y eliminación de correos electrónicos con IMAP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
Conexión a un servidor IMAP. .
Iniciar sesión en el servidor IMAP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
Búsqueda de correo electrónico. . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
Obtener un correo electrónico y marcarlo como leído. . . . . . . . . . . . . . . . . . . . . . . . . 372
Obtención de direcciones de correo electrónico a partir de un mensaje sin procesar. .
. . . . . . . . . . . . . . . . . . . . 373
Obtener el cuerpo de un mensaje sin procesar. . . . . . . . . . . . . . . . . . . . . . . . . . . 374
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
Proyecto: Envío de correos electrónicos de recordatorio de cuotas de miembros. . . . . . . . . . . . . . . . . . . . . . . . . . . 376
Eliminación de correos electrónicos. .
Desconectarse del servidor IMAP.
Paso 1: Abra el archivo de Excel
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
Paso 2: Busque todos los miembros no pagado.s.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Paso 3: envíe recordatorios personalizados por correo electrónico. . .
. . . . . . . . . . . . . . . . . . . . . . 378
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
Registrarse para obtener una cuenta de Twilio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
Envío de mensajes de texto con Twilio.
Envío de mensajes de texto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
Proyecto: Módulo “Solo Escríbeme” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
.
.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
Proyectos de práctica. .
Correo electrónico de asignación de tareas al azar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
Recordatorio de paraguas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
Cancelación automática de suscripción. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
Controlar su computadora a través del correo electrónico. . . . . . . . . . . . . . . . . . . . . . . . . 386
Resumen .
Preguntas de práctica. .
17
Manipulación de imágenes
387
Fundamentos de la imagen por computadora. . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ....... 388
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
Coordenadas y Tuplas Caja. .
Manipulación de imágenes con almohada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
Trabajar con el tipo de datos de imagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392
Recortar imágenes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
. . . . . . . . . . . . . . . . . . . . 394
Copiar y pegar imágenes en otras imágenes.
. . 397
Cambiar el tamaño de una imagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
Rotación y volteo de imágenes.
Cambio de píxeles individuales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
Proyecto: Adición de un logotipo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
Paso 1: abra la imagen del logotipo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
Paso 2: recorra todos los archivos y abra las imágenes. . . . . . . . . . . . . . . . . . . . . . 402
Paso 3: Cambiar el tamaño de las imágenes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
Paso 4: agregue el logotipo y guarde los cambios. . . . . . . . . . . . . . . . . . . . . . . 404
Ideas para programas similares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
Dibujar sobre imágenes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
Formas de dibujo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
Dibujar texto.
Colores y valores RGBA. .
Contenido en detalle xix
Machine Translated by Google
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
.
Proyectos de práctica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
Ampliación y corrección de los programas del proyecto capitular. . . . . . . . . . . . . . . . . . . 411
Identificación de carpetas de fotos en el disco duro. . . . . . . . . . . . . . . . . . . . . . . . 411
Tarjetas de asientos personalizadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Resumen .
Preguntas de práctica
18
Controlar el teclado y el mouse con la automatización de
GUI
413
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
Instalación del Módulo pyautogui. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
Apagar todo mediante pausas de cierre de sesión . . . . . . . . . . . . . . . . . . . . . . . . . 414
y dispositivos de seguridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Control del movimiento del ratón. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
Moviendo el ratón. .
Conseguir la posición del ratón. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
Proyecto: “¿Dónde está el ratón ahora mismo?” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
Paso 1: Importar el Módulo.
Paso 2: configure el código de salida y el bucle infinito. . . . . . . . . . . . . . . . . . . . . . 418
Paso 3: Obtenga e imprima las coordenadas del ratón. . . . . . . . . . . . . . . . . . . . . . . 418
Mantenerse en el buen camino.
Control de la interacción del ratón. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
Haciendo clic con el Ratón. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Arrastrando el ratón.
Desplazamiento del ratón. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
Trabajar con la pantalla. .
Obtener una captura de pantalla. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
Analizando la captura de pantalla. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
Proyecto: Ampliación del programa mouseNow. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
Reconocimiento de imagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
Control del teclado.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
Envío de una cadena desde el teclado.
Nombres clave. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
. . . . . . . . . . . . . . . . . . . . . . . . . . 428
Pulsando y soltando el teclado. .
Combinaciones de teclas de acceso directo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
Revisión de las funciones de PyAutoGUI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
Proyecto: Rellenador Automático de Formularios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
Paso 1: Averigüe los pasos. .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
Paso 2: Configure las coordenadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
Paso 3: Comience a escribir datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
Paso 4: Manejar listas de selección y botones de opción. . . . . . . . . . . . . . . . . . . . . . . 435
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 436
Paso 5: envíe el formulario y espere. .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . . . . . . . . . . . . . . . . . . . . . . . . 437
Resumen .
Preguntas de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Proyectos de práctica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Buscando Ocupado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Robot de mensajería instantánea. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439
Tutorial de juego de bots.
xx Contenido en detalle
Machine Translated by Google
A
Instalación de módulos de terceros
441
La herramienta pip. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
Instalación de módulos de terceros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
B
Programas en ejecución
443
Línea Shebang.................................................................................................................................. 443
Ejecución de programas de Python en Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
Ejecución de programas de Python en OS X y Linux. ........................................................................ 445
Ejecución de programas de Python con aserciones deshabilitadas. ................................................................... 445
C Respuestas a las preguntas de práctica Capítulo 1
447
Capítulo 2 C. a. p.í.tu.lo. 3.............................................................................................................. 448
. ...................................................................................................................................... 448
. ................................................................................................................................... 450
.
......................................................................................................................................
450
Capítulo 4
Capítulo 5 . . ................................................................................................................................... 451
Capítulo 6 . . ................................................................................................................................... 451
Capítulo 7 . . ................................................................................................................................... 452
Capítulo 8 . . ................................................................................................................................... 453
Capítulo 9 . . ................................................................................................................................... 453
Capítulo 10 . . ................................................................................................................................. 454
Capítulo 11 . ................................................................................................................................... 455
Capítulo 12 . ................................................................................................................................... 456
Capítulo 13 . . ................................................................................................................................. 456
Capítulo 14 . ................................................................................................................................... 457
Capítulo 15 . . ................................................................................................................................. 457
Capítulo 16 . . ................................................................................................................................. 458
Capítulo 17 . . ................................................................................................................................. 458
Capítulo 18 . . ................................................................................................................................. 458
Índice
461
Contenido en detalle xxi
Machine Translated by Google
Machine Translated by Google
Agradecimientos
No podría haber escrito un libro como este sin la
ayuda de mucha gente. Me gustaría agradecer a Bill
Pollock; mis editores, Laurel Chun, Leslie Shen, Greg
Poulos y Jennifer Griffith-Delgado; y al resto del personal
de No Starch Press por su inestimable ayuda. Gracias a
mi revisor técnico, Ari Lacenski, por sus excelentes
sugerencias, ediciones y apoyo.
Muchas gracias a nuestro Benevolente Dictator For Life, Guido van Rossum, y a todos en
Python Software Foundation por su gran trabajo. La comunidad de Python es la mejor que he
encontrado en la industria tecnológica.
Finalmente, me gustaría agradecer a mi familia, amigos y la pandilla de Shotwell's
por no preocuparse por la vida ocupada que he tenido mientras escribía este libro.
¡Salud!
Machine Translated by Google
Machine Translated by Google
Introducción
“Acabas de hacer en dos horas lo que nosotros tres
tardamos dos días en hacer”. Mi compañero de cuarto
de la universidad trabajaba en una tienda minorista de
productos electrónicos a principios de la década de 2000.
De vez en cuando, la tienda recibía una hoja de cálculo de miles de
precios de productos de su competidor. Un equipo de tres empleados.
imprimiría la hoja de cálculo en una gruesa pila de papel y la dividiría entre ellos.
Para el precio de cada producto, buscarían el precio de su tienda y anotarían todos
los productos que sus competidores vendían por menos. Por lo general, tomó un par
de días.
“Saben, podría escribir un programa para hacer eso si tienen el archivo original
de las copias impresas”, les dijo mi compañero de cuarto, cuando los vio sentados
en el piso con papeles esparcidos y apilados alrededor de ellos.
Después de un par de horas, tenía un programa corto que leía el precio de
un competidor en un archivo, encontraba el producto en la base de datos de la
tienda y anotaba si el competidor era más barato. Todavía era nuevo en la programación, y
Machine Translated by Google
pasó la mayor parte de su tiempo buscando documentación en un libro de programación. El
programa real tardó solo unos segundos en ejecutarse. Mi compañero de cuarto y sus
compañeros de trabajo tomaron un almuerzo extra largo ese día.
Este es el poder de la programación informática. Una computadora es como una navaja
suiza que puede configurar para innumerables tareas. Muchas personas pasan horas haciendo
clic y escribiendo para realizar tareas repetitivas, sin saber que la máquina que están usando
puede hacer su trabajo en segundos si le dan las instrucciones correctas.
¿Para quién es este libro?
El software es el núcleo de muchas de las herramientas que usamos hoy en día: casi todos usan
las redes sociales para comunicarse, muchas personas tienen computadoras conectadas a
Internet en sus teléfonos y la mayoría de los trabajos de oficina implican interactuar con una
computadora para realizar el trabajo. Como resultado, la demanda de personas que puedan
codificar se ha disparado. Innumerables libros, tutoriales web interactivos y campos de
entrenamiento para desarrolladores prometen convertir a los principiantes ambiciosos en
ingenieros de software con salarios de seis cifras.
Este libro no es para esas personas. Es para todos los demás.
Por sí solo, este libro no te convertirá en un desarrollador de software profesional, como
tampoco unas pocas lecciones de guitarra te convertirán en una estrella de rock. Pero si usted
es un oficinista, administrador, académico o cualquier otra persona que usa una computadora
para trabajar o divertirse, aprenderá los conceptos básicos de programación para que pueda
automatizar tareas simples como las siguientes:
• Mover y renombrar miles de archivos y clasificarlos en carpetas
•Rellenar formularios en línea, no es necesario escribir
•Descargar archivos o copiar texto de un sitio web siempre que se actualice
•Hacer que su computadora le envíe mensajes de texto con notificaciones personalizadas
•Actualización o formateo de hojas de cálculo de Excel
•Revisar su correo electrónico y enviar respuestas escritas previamente
Estas tareas son simples pero consumen mucho tiempo para los humanos y, a
menudo, son tan triviales o específicas que no existe un software listo para realizarlas.
Armado con un poco de conocimiento de programación, puede hacer que su computadora
haga estas tareas por usted.
Convenciones
Este libro no está diseñado como un manual de referencia; es una guía para principiantes.
El estilo de codificación a veces va en contra de las mejores prácticas (por ejemplo, algunos
programas usan variables globales), pero eso es una compensación para que el código sea
más fácil de aprender. Este libro está hecho para que la gente escriba código desechable, por
lo que no se dedica mucho tiempo al estilo y la elegancia. Conceptos de programación
sofisticados, como programación orientada a objetos, comprensión de listas,
2 Introducción
Machine Translated by Google
y generadores—no están cubiertos debido a la complejidad que agregan.
Los programadores veteranos pueden señalar formas en que el código de este libro podría
cambiarse para mejorar la eficiencia, pero este libro se ocupa principalmente de hacer que los
programas funcionen con la menor cantidad de esfuerzo.
¿Qué es la programación?
Los programas de televisión y las películas a menudo muestran a los programadores escribiendo
furiosamente flujos crípticos de 1 y 0 en pantallas brillantes, pero la programación moderna no es tan
misteriosa. La programación es simplemente el acto de ingresar instrucciones para que la computadora
las realice. Estas instrucciones pueden procesar algunos números, modificar texto, buscar información
en archivos o comunicarse con otras computadoras a través de Internet.
Todos los programas usan instrucciones básicas como bloques de construcción. Estos son
algunos de los más comunes, en inglés:
"Hacer esto; entonces haz eso.
“Si esta condición es verdadera, realiza esta acción; de lo contrario, haz esa acción.”
"Haz esta acción esa cantidad de veces".
“Sigue haciendo eso hasta que esta condición sea verdadera”.
También puede combinar estos componentes básicos para implementar decisiones más
complejas. Por ejemplo, aquí están las instrucciones de programación, llamadas código fuente, para
un programa simple escrito en el lenguaje de programación Python. Comenzando en la parte
superior, el software de Python ejecuta cada línea de código (algunas líneas se ejecutan solo si una
determinada condición es verdadera o Python ejecuta alguna otra línea) hasta que llega al final.
v contraseñasecreta = archivocontraseña.read()
contraseña escrita = entrada ()
x si se escribe Contraseña == contraseña secreta:
Es posible que no sepa nada sobre programación, pero probablemente podría hacer una
suposición razonable de lo que hace el código anterior con solo leerlo. Primero, se abre el archivo
SecretPasswordFile.txt u, y se lee la contraseña secreta v. Luego, se solicita al usuario que ingrese
una contraseña (del teclado) w. Estas dos contraseñas se comparan x, y si son iguales, el programa
imprime Acceso concedido a la pantalla y. A continuación, el programa verifica si la contraseña es
12345 z y sugiere que esta opción podría no ser la mejor para una contraseña {. Si las contraseñas
no son las mismas, el programa imprime Acceso denegado en la pantalla |.
Introducción 3
Machine Translated by Google
¿Qué es Python?
Python se refiere al lenguaje de programación Python (con reglas de sintaxis para escribir lo
que se considera código Python válido) y el software de interpretación de Python que lee el
código fuente (escrito en el lenguaje Python) y ejecuta sus instrucciones. El intérprete de
Python se puede descargar gratis desde http:// python.org/, y hay versiones para Linux, OS X y
Windows.
El nombre Python proviene del grupo de comedia británico surrealista Monty Python, no de
la serpiente. Los programadores de Python son cariñosamente llamados Pythonistas, y tanto las
referencias de Monty Python como las de serpentine suelen animar los tutoriales y la
documentación de Python.
Los programadores no necesitan saber mucho de matemáticas
La ansiedad más común que escucho sobre aprender a programar es que la gente piensa que
requiere muchas matemáticas. En realidad, la mayoría de la programación no requiere
matemáticas más allá de la aritmética básica. De hecho, ser bueno programando no es tan
diferente de ser bueno resolviendo sudokus.
Para resolver un Sudoku, se deben completar los números del 1 al 9 para cada fila, cada
columna y cada cuadrado interior de 3×3 del tablero completo de 9×9.
Encuentras una solución aplicando la deducción y la lógica a partir de los números iniciales. Por
ejemplo, dado que el 5 aparece en la parte superior izquierda del Sudoku que se muestra en la
Figura 0-1, no puede aparecer en ningún otro lugar de la fila superior, en la columna más a la
izquierda o en el cuadrado de 3×3 de la parte superior izquierda. Resolver una fila, columna o
cuadrado a la vez proporcionará más pistas numéricas para el resto del rompecabezas.
Figura 0-1: Un nuevo Sudoku (izquierda) y su solución (derecha). A pesar de usar números,
Sudoku no involucra muchas matemáticas. (Imágenes © Wikimedia Commons)
El hecho de que Sudoku involucre números no significa que tengas que ser bueno
en matemáticas para encontrar la solución. Lo mismo ocurre con la programación. Al igual
que resolver un Sudoku, escribir programas implica dividir un problema en pasos individuales
y detallados. Del mismo modo, al depurar
programas (es decir, encontrar y corregir errores), observará pacientemente lo que hace el
programa y encontrará la causa de los errores. Y como todas las habilidades, cuanto más
programes, mejor te volverás.
4 Introducción
Machine Translated by Google
La programación es una actividad creativa
La programación es una tarea creativa, algo así como construir un castillo con ladrillos
LEGO. Empiezas con una idea básica de cómo quieres que se vea tu castillo y haces un
inventario de los bloques disponibles. Entonces empiezas a construir.
Una vez que haya terminado de construir su programa, puede embellecer su código como lo
haría con su castillo.
La diferencia entre programar y otras actividades creativas es que al programar, tienes
toda la materia prima que necesitas en tu computadora; no necesita comprar ningún lienzo,
pintura, película, hilo, ladrillos LEGO o componentes electrónicos adicionales. Cuando su
programa está escrito, se puede compartir fácilmente en línea con todo el mundo. Y aunque
cometerás errores al programar, la actividad sigue siendo muy divertida.
Sobre este libro
La primera parte de este libro cubre los conceptos básicos de programación de Python, y la
segunda parte cubre varias tareas que puede automatizar su computadora.
Cada capítulo de la segunda parte tiene programas de proyectos para que estudie. Aquí hay un
breve resumen de lo que encontrará en cada capítulo:
Parte I: Conceptos básicos de programación en Python
Capítulo 1: Conceptos básicos de Python Cubre expresiones, el tipo más básico de
instrucción de Python y cómo usar el software de shell interactivo de Python para
experimentar con el código.
Capítulo 2: Control de flujo Explica cómo hacer que los programas decidan qué
instrucciones ejecutar para que su código pueda responder inteligentemente a diferentes
condiciones.
Capítulo 3: Funciones Le indica cómo definir sus propias funciones para que pueda
organizar su código en fragmentos más manejables.
Capítulo 4: Listas Presenta el tipo de datos de lista y explica cómo organizar los
datos.
Capítulo 5: Diccionarios y estructuración de datos Presenta el tipo de datos del
diccionario y le muestra formas más eficaces de organizar los datos.
Capítulo 6: Manipulación de cadenas Cubre el trabajo con datos de texto
(llamados cadenas en Python).
Parte II: Automatización de tareas
Capítulo 7: Coincidencia de patrones con expresiones regulares Cubre cómo Python
puede manipular cadenas y buscar patrones de texto con expresiones regulares.
Capítulo 8: Leer y escribir archivos Explica cómo sus programas pueden leer el
contenido de archivos de texto y guardar información en archivos en su disco duro.
Capítulo 9: Organización de archivos Muestra cómo Python puede copiar, mover,
renombrar y eliminar grandes cantidades de archivos mucho más rápido que un usuario
humano. También explica cómo comprimir y descomprimir archivos.
Introducción
5
Machine Translated by Google
Capítulo 10: Depuración Muestra cómo usar las diversas herramientas de
búsqueda y corrección de errores de Python.
Capítulo 11: Web Scraping Muestra cómo escribir programas que pueden descargar
automáticamente páginas web y analizarlas para obtener información.
Esto se llama raspado web.
Capítulo 12: Trabajar con hojas de cálculo de Excel Cubre la manipulación
programática de hojas de cálculo de Excel para que no tenga que leerlas. Esto es útil
cuando la cantidad de documentos que debe analizar es de cientos o miles.
Capítulo 13: Trabajar con documentos PDF y Word Cubre la lectura programática
de documentos Word y PDF.
Capítulo 14: Trabajar con archivos CSV y datos JSON Continúa explicando cómo
manipular mediante programación documentos con archivos CSV y JSON.
Capítulo 15: Control del tiempo, programación de tareas e inicio de
programas Explica cómo los programas de Python manejan la hora y las fechas y
cómo programar su computadora para realizar tareas en ciertos momentos. Este capítulo
también muestra cómo sus programas de Python pueden iniciar programas que no son
de Python.
Capítulo 16: Envío de correos electrónicos y mensajes de texto Explica cómo escribir
programas que pueden enviar correos electrónicos y mensajes de texto en su nombre.
Capítulo 17: Manipulación de imágenes Explica cómo manipular mediante programación
imágenes como archivos JPEG o PNG.
Capítulo 18: Controlar el teclado y el mouse con automatización GUI
Explica cómo controlar mediante programación el mouse y el teclado para automatizar
los clics y las pulsaciones de teclas.
Descarga e instalación de Python
Puede descargar Python para Windows, OS X y Ubuntu de forma gratuita desde http://
python.org/ downloads/. Si descarga la última versión de la página de descargas del sitio
web, todos los programas de este libro deberían funcionar.
ADVERTENCIA Asegúrese de descargar una versión de Python 3 (como 3.4.0). Los programas de este libro están escritos para
ejecutarse en Python 3 y es posible que no se ejecuten correctamente, si es que lo hacen, en Python 2.
Encontrará instaladores de Python para computadoras de 64 y 32 bits para cada
sistema operativo en la página de descarga, así que primero averigüe qué instalador necesita.
Si compró su computadora en 2007 o después, lo más probable es que sea un sistema de 64
bits. De lo contrario, tiene una versión de 32 bits, pero aquí le mostramos cómo averiguarlo
con seguridad:
•En Windows, seleccione Inicio4Panel de control4Sistema y verifique si Tipo de sistema dice
64 bits o 32 bits.
6 Introducción
Machine Translated by Google
•En OS X, vaya al menú Apple, seleccione Acerca de esta Mac4Más información4 Informe del
sistema4Hardware y luego mire el campo Nombre del procesador. Si dice Intel Core Solo o
Intel Core Duo, tiene una máquina de 32 bits. Si dice algo más (incluido Intel Core 2 Duo),
tiene una máquina de 64 bits.
•En Ubuntu Linux, abra una Terminal y ejecute el comando uname -m.
Una respuesta de i686 significa 32 bits y x86_64 significa 64 bits.
En Windows, descargue el instalador de Python (el nombre del archivo terminará en .msi) y
haga doble clic en él. Siga las instrucciones que el instalador muestra en la pantalla para instalar
Python, como se indica aquí:
1. Seleccione Instalar para todos los usuarios y luego haga clic en Siguiente.
2. Instálelo en la carpeta C:\Python34 haciendo clic en Siguiente.
3. Haga clic en Siguiente nuevamente para omitir la sección Personalizar Python.
En Mac OS X, descargue el archivo .dmg adecuado para su versión de OS X y haga doble
clic en él. Siga las instrucciones que el instalador muestra en la pantalla para instalar Python, como
se indica aquí:
1. Cuando el paquete DMG se abra en una nueva ventana, haga doble clic en el archivo
Python.mpkg . Es posible que deba ingresar la contraseña de administrador.
2. Haga clic en Continuar a través de la sección de Bienvenida y haga clic en Acepto para aceptar
la licencia.
3. Seleccione HD Macintosh (o el nombre que tenga su disco duro) y
haga clic en Instalar.
Si está ejecutando Ubuntu, puede instalar Python desde la Terminal siguiendo estos pasos:
1. Abra la ventana Terminal.
2. Ingrese sudo apt-get install python3.
3. Ingrese sudo apt-get install idle3.
4. Ingrese sudo apt-get install python3-pip.
Inicio inactivo
Si bien el intérprete de Python es el software que ejecuta sus programas de Python, el software del
entorno de desarrollo interactivo (IDLE) es donde ingresará sus programas, como un procesador de
textos. Comencemos INACTIVO ahora.
•En Windows 7 o posterior, haga clic en el icono de Inicio en la esquina inferior izquierda de su
pantalla, ingrese IDLE en el cuadro de búsqueda y seleccione IDLE (GUI de Python).
•En Windows XP, haga clic en el botón Inicio y luego seleccione Programas4
Python 3.44IDLE (GUI de Python).
Introducción 7
Machine Translated by Google
•En Mac OS X, abra la ventana del Finder, haga clic en Aplicaciones, haga clic en
Python 3.4 y luego haga clic en el icono INACTIVO.
•En Ubuntu, seleccione Aplicaciones4Accesorios4Terminal y luego ingrese inactivo3.
(También puede hacer clic en Aplicaciones en la parte superior de la pantalla,
seleccionar Programación y luego hacer clic en IDLE 3).
La concha interactiva
Independientemente del sistema operativo que esté ejecutando, la ventana INACTIVA que
aparece por primera vez debe estar en su mayor parte en blanco, excepto por el texto que se
parece a esto:
Python 3.4.0 (v3.4.0:04f714765c13, 16 de marzo de 2014, 19:25:23) [MSC v.1600 64 bit (AMD64)]
en win32Escriba "copyright", "créditos" o "licencia()" para obtener más información .
>>>
Esta ventana se llama shell interactivo. Un shell es un programa que le permite escribir
instrucciones en la computadora, al igual que la Terminal o el Símbolo del sistema en OS X y
Windows, respectivamente. El shell interactivo de Python le permite ingresar instrucciones para
que se ejecute el software de interpretación de Python. La computadora lee las instrucciones que
usted ingresa y las ejecuta inmediatamente.
Por ejemplo, ingrese lo siguiente en el shell interactivo al lado del indicador >>> :
>>> print('¡Hola mundo!')
Después de escribir esa línea y presionar enter, el shell interactivo debería
mostrar esto en respuesta:
>>> print('¡Hola mundo!')
¡Hola Mundo!
Cómo encontrar ayuda
Resolver problemas de programación por tu cuenta es más fácil de lo que piensas. Si no
está convencido, provoquemos un error a propósito: ingrese '42' + 3 en el shell interactivo. No
necesita saber qué significa esta instrucción en este momento, pero el resultado debería verse
así:
>>> '42' + 3
u Rastreo (última llamada más reciente):
Archivo "<pyshell#0>", línea 1, en <módulo>
'42' + 3
v TypeError: no se puede convertir el objeto 'int' en str implícitamente
>>>
8 Introducción
Machine Translated by Google
El mensaje de error v apareció aquí porque Python no pudo entender sus
instrucciones. La parte de seguimiento u del mensaje de error muestra la instrucción
específica y el número de línea con el que Python tuvo problemas. Si no está seguro
de qué hacer con un mensaje de error en particular, busque en línea el mensaje de
error exacto. Ingrese "TypeError: No se puede convertir el objeto 'int' en str
implícitamente" (incluidas las comillas) en su motor de búsqueda favorito, y debería
ver toneladas de enlaces que explican qué significa el mensaje de error y qué lo causa,
como se muestra en la Figura 0 -2.
Figura 0-2: Los resultados de Google para un mensaje de error pueden ser muy útiles.
A menudo encontrará que alguien más tenía la misma pregunta que usted y que
otra persona útil ya la respondió. Ninguna persona puede saber todo acerca de la
programación, por lo que una parte cotidiana del trabajo de cualquier desarrollador de
software es buscar respuestas a preguntas técnicas.
Hacer preguntas sobre programación inteligente
Si no puede encontrar la respuesta buscando en línea, intente preguntar a las
personas en un foro web como Stack Overlow (http:// stackoverflow.com/) o el subreddit
"aprender programación" en http:// reddit.com/ r / aprenderprogramacion/. Pero tenga
en cuenta que hay formas inteligentes de hacer preguntas de programación que
ayudan a otros a ayudarlo. Asegúrese de leer las secciones de Preguntas frecuentes
que tienen estos sitios web sobre la forma correcta de publicar preguntas.
Introducción 9
Machine Translated by Google
Cuando haga preguntas de programación, recuerde hacer lo siguiente:
• Explique lo que está tratando de hacer, no sólo lo que hizo. Esto le permite a su ayudante
saber si está en el camino equivocado.
•Especifique el punto en el que ocurre el error. ¿Ocurre al comienzo del programa o solo
después de realizar una determinada acción?
•Copie y pegue el mensaje de error completo y su código en http:// pastebin
.com/ o http:// gist.github.com/.
Estos sitios web facilitan compartir grandes cantidades de código con personas
a través de la Web, sin riesgo de perder ningún formato de texto. Luego puede poner la
URL del código publicado en su correo electrónico o publicación en el foro.
Por ejemplo, aquí algunos fragmentos de código que publiqué: http:// pastebin.com/
SzP2DbFx/ y https:// gist.github.com/ asweigart/ 6912168/.
• Explique lo que ya ha intentado hacer para resolver su problema. Esto les dice a las
personas que ya has trabajado un poco para resolver las cosas por tu cuenta.
•Indique la versión de Python que está utilizando. (Existen algunas diferencias clave
entre los intérpretes de Python de la versión 2 y los intérpretes de Python de la
versión 3). Además, diga qué sistema operativo y versión está ejecutando.
•Si el error surgió después de realizar un cambio en su código, explique exactamente lo
que cambió.
•Diga si puede reproducir el error cada vez que ejecuta el programa o si ocurre solo
después de realizar ciertas acciones.
Explique cuáles son esas acciones, si es así.
Siempre siga una buena etiqueta en línea también. Por ejemplo, no publique sus
preguntas en mayúsculas ni haga demandas poco razonables a las personas que
intentan ayudarlo.
Resumen
Para la mayoría de las personas, su computadora es solo un dispositivo en lugar de una
herramienta. Pero al aprender a programar, obtendrá acceso a una de las herramientas más
poderosas del mundo moderno y se divertirá en el camino. La programación no es una cirugía
cerebral; está bien que los aficionados experimenten y cometan errores.
Me encanta ayudar a la gente a descubrir Python. Escribo tutoriales de programación
en mi blog en http:// inventwithpython.com/ blog/, y puede contactarme si tiene preguntas en
al@inventwithpython.com.
Este libro lo iniciará con cero conocimientos de programación, pero es posible que
tenga preguntas que van más allá de su alcance. Recuerde que hacer preguntas efectivas
y saber cómo encontrar respuestas son herramientas invaluables en su viaje de
programación.
¡Vamos a empezar!
10 Introducción
Machine Translated by Google
Parte I
Programación de python
B ásicos
Machine Translated by Google
Machine Translated by Google
1
Python Básicos
El lenguaje de programación Python tiene una amplia
gama de construcciones sintácticas, funciones de
biblioteca estándar y características de entorno de
desarrollo interactivo. Afortunadamente,
puedes ignorar la mayor parte de eso; solo necesita aprender lo
suficiente para escribir algunos pequeños programas útiles.
Sin embargo, tendrá que aprender algunos conceptos básicos de
programación antes de poder hacer nada. Como un mago en formación, puede
pensar que estos conceptos parecen arcanos y tediosos, pero con un poco de
conocimiento y práctica, podrá controlar su computadora como una varita
mágica para realizar hazañas increíbles.
Este capítulo tiene algunos ejemplos que lo alientan a escribir en el shell
interactivo, que le permite ejecutar las instrucciones de Python una a la vez y le
muestra los resultados al instante. El uso del shell interactivo es excelente para
aprender qué hacen las instrucciones básicas de Python, así que pruébelo a
medida que avanza. Recordarás las cosas que haces mucho mejor que las cosas
que solo lees.
Machine Translated by Google
Introducción de expresiones en el shell interactivo
Ejecuta el shell interactivo iniciando IDLE, que instaló con Python en la introducción. En
Windows, abra el menú Inicio, seleccione Todos los programas 4 Python 3.3 y luego
seleccione IDLE (GUI de Python). En OS X, seleccione Aplicaciones 4 MacPython
3.3 4 IDLE. En Ubuntu, abra una nueva ventana de Terminal e ingrese idle3.
Debería aparecer una ventana con el indicador >>> ; ese es el caparazón
interactivo. Ingrese 2 + 2 en el indicador para que Python haga algunos cálculos simples.
>>> 2 + 2
4
La ventana IDLE ahora debería mostrar un texto como este:
Python 3.3.2 (v3.3.2:d047928ae3f6, 16 de mayo de 2013, 00:06:53) [MSC v.1600 64 bit (AMD64)] en win32
Escriba "derechos de autor", "créditos" o "licencia()" para obtener más información.
>>> 2 + 2
4
>>>
En Python, 2 + 2 se denomina expresión, que es el tipo más básico de
instrucción de programación en el lenguaje. Las expresiones consisten en valores.
(como 2) y operadores (como +), y siempre pueden evaluar (es decir, reducir) a un
solo valor. Eso significa que puede usar expresiones en cualquier parte del código de
Python en las que también podría usar un valor.
En el ejemplo anterior, 2 + 2 se reduce a un solo valor, 4.
Un valor único sin operadores también se considera una expresión, aunque solo se
evalúa a sí mismo, como se muestra aquí:
>>> 2
2
¡Los errores están bien!
Los programas fallarán si contienen código que la computadora no puede entender, lo que hará que
Python muestre un mensaje de error. Sin embargo, un mensaje de error no dañará su computadora,
así que no tenga miedo de cometer errores. Un bloqueo solo significa que el programa dejó de
ejecutarse inesperadamente.
Si desea saber más acerca de un mensaje de error, puede buscar el
texto exacto del mensaje en línea para obtener más información sobre ese error específico.
También puede consultar los recursos en http://nostarch.com/automatestuff/ para ver una lista de
mensajes de error comunes de Python y sus significados.
14 Capítulo 1
Machine Translated by Google
Hay muchos otros operadores que puede usar en las expresiones de Python,
también. Por ejemplo, la Tabla 1-1 enumera todos los operadores matemáticos en Python.
Tabla 1-1: Operadores matemáticos de mayor a menor precedencia
Operador
Ejemplo
Evalúa a…
2 ** 3
8
22 % 8
6
División entera/cociente piso
22 // 8
2
División
22 / 8
2.75
15
Operación
**
%
//
/
*
Multiplicación
* 5
3
-
Sustracción
5-2
3
+
Suma
2+2
4
El orden de las operaciones (también llamado precedencia) de los operadores matemáticos de
Python es similar al de las matemáticas. El operador ** se e v a lúa sperim
e vearloú;alno sa ocpoenrtainduoarecisón* ,, /d, e// y %
izquierda a derecha; y los operadores + y - se evalúan en último lugar (también de izquierda a
derecha). Puede usar paréntesis para anular la precedencia habitual si es necesario. Ingrese las
siguientes expresiones en el shell interactivo:
2
En cada caso, usted como programador debe ingresar la expresión, pero Python hace la parte
difícil de evaluarla hasta un solo valor. Python seguirá evaluando partes de la expresión hasta que
se convierta en un solo valor, como se muestra en la Figura 1-1.
Conceptos básicos de Python 15
Machine Translated by Google
(5 - 1) * ((7 + 1) / (3 - 1))
2
Estas reglas para juntar operadores y valores para formar expresiones son una parte
fundamental de Python como lenguaje de programación, al igual que las reglas gramaticales que
nos ayudan a comunicarnos. Aquí hay un ejemplo:
Esta es una oración en inglés gramaticalmente correcta.
Esta es una oración gramaticalmente no correcta en inglés a.
La segunda línea es difícil de analizar porque no sigue las reglas del inglés. De manera similar,
si escribe una instrucción de Python incorrecta, Python no podrá entenderla y mostrará un mensaje de
error SyntaxError , como se muestra aquí:
^
^
Siempre puede probar para ver si una instrucción funciona escribiéndola en el shell interactivo. No
te preocupes por romper la computadora: lo peor que podría pasar es que Python responda con un
mensaje de error.
Los desarrolladores de software profesionales reciben mensajes de error mientras escriben código
todo el tiempo.
Los tipos de datos enteros, de punto flotante y de cadena
Recuerde que las expresiones son solo valores combinados con operadores, y siempre se
evalúan hasta un solo valor. Un tipo de datos es una categoría de valores, y cada valor pertenece
exactamente a un tipo de datos. lo mas
16 Capítulo 1
Machine Translated by Google
los tipos de datos comunes en Python se enumeran en la Tabla 1-2. Los valores -2 y
30, por ejemplo, se dice que son valores enteros . El tipo de datos entero (o int) indica
valores que son números enteros. Los números con un punto decimal, como 3,14, se
denominan números de punto flotante (o flotantes). Tenga en cuenta que aunque el
valor 42 es un número entero, el valor 42,0 sería un número de punto flotante.
Tabla 1-2: Tipos de datos comunes
Tipo de datos
Ejemplos
enteros
-2, -1, 0, 1, 2, 3, 4, 5
Números de punto flotante
-1,25, -1,0, --0,5, 0,0, 0,5, 1,0, 1,25
Instru ment os de cuerda
'a', 'aa', 'aaa', '¡Hola!', '11 gatos'
Los programas de Python también pueden tener valores de texto llamados
cadenas o strs (pronunciado “stirs”). Siempre rodee su cadena con caracteres de
comillas simples (') (como en 'Hola' o '¡Adiós, mundo cruel!') para que Python sepa
dónde comienza y termina la cadena. Incluso puede tener una cadena sin caracteres,
'', llamada cadena en blanco. Las cadenas se explican con mayor detalle en el Capítulo 4.
Si alguna vez ve el mensaje de error SyntaxError: EOL mientras escanea el literal
de cadena, probablemente olvidó el último carácter de comilla simple al final de la
cadena, como en este ejemplo:
>>> '¡Hola mundo!
SyntaxError: EOL al escanear literal de cadena
Concatenación y replicación de cadenas
El significado de un operador puede cambiar según los tipos de datos de los
valores junto a él. Por ejemplo, + es el operador de suma cuando opera en dos números
enteros o valores de punto flotante. Sin embargo, cuando se usa + en dos valores de
cadena, une las cadenas como el operador de concatenación de cadenas. Ingrese lo
siguiente en el shell interactivo:
>>> 'Alicia' + 'Bob'
'AliciaBob'
La expresión se evalúa como un único valor de cadena nuevo que combina el
texto de las dos cadenas. Sin embargo, si intenta usar el operador + en una cadena y
un valor entero, Python no sabrá cómo manejar esto y mostrará un mensaje de error.
>>> 'Alicia' + 42
Rastreo (llamadas recientes más última):
Archivo "<pyshell#26>", línea 1, en <módulo>
'Alicia' + 42
TypeError: no se puede convertir el objeto 'int' en str implícitamente
Conc eptos básicos de Python
17
Machine Translated by Google
El mensaje de error Can't convert 'int' object to str implícitamente significa que
Python pensó que estaba tratando de concatenar un número entero a la cadena 'Alice'.
Tu código tendrá que convertir explícitamente el número entero en una cadena, porque
Python no puede hacer esto automáticamente. (La conversión de tipos de datos se
explicará en “Disección de su programa” en la página 22 cuando se hable de las funciones
str(), int() y float() ).
El operador * se usa para la multiplicación cuando opera sobre dos valores enteros
o de coma flotante. Pero cuando el operador * se usaenetneruon, svealcoorndveiecrtaedenaelyoupnevradloorr
de replicación de cadena . Ingrese una cadena multiplicada por un número en el shell
interactivo para ver esto en acción.
Tiene sentido que Python no entienda estas expresiones: no puedes multiplicar dos
palabras, y es difícil replicar una cadena arbitraria una fracción de veces.
Almacenamiento de valores en variables
Una variable es como una caja en la memoria de la computadora donde puede
almacenar un solo valor. Si desea utilizar el resultado de una expresión evaluada más
adelante en su programa, puede guardarlo dentro de una variable.
Declaraciones de asignación
Almacenará valores en variables con una instrucción de asignación. Una declaración de
asignación consta de un nombre de variable, un signo igual (llamado operador de
asignación) y el valor que se almacenará. Si ingresa la declaración de asignación spam
= 42, entonces una variable llamada spam tendrá el valor entero 42 almacenado en ella.
18 Capítulo 1
Machine Translated by Google
Piense en una variable como un cuadro etiquetado en el que se coloca un valor, como
en la figura 1-2.
Por ejemplo, ingrese lo siguiente en el shell interactivo:
w >>> correo no deseado = correo no deseado + 2
Una variable se inicializa (o crea) la primera vez que se almacena un valor en ella u.
Después de eso, puede usarlo en expresiones con otras variables y valores v.
Cuando a una variable se le asigna un nuevo valor w, el valor anterior se olvida, por lo que el spam
se evaluó con 42 en lugar de 40 al final del ejemplo. Esto se llama sobrescribir la variable. Ingrese
el siguiente código en el shell interactivo para intentar sobrescribir una cadena:
Al igual que el cuadro de la Figura 1-3, la variable de spam en este ejemplo almacena 'Hola'
hasta que la reemplace con 'Adiós'.
Conceptos básicos de Python
19
Machine Translated by Google
Figura 1-3: Cuando se asigna un nuevo valor a una variable, se olvida el
anterior.
Nombres de variables
La tabla 1-3 tiene ejemplos de nombres de variables legales. Puede nombrar cualquier
variable a una variable siempre que cumpla las tres reglas siguientes:
1. Solo puede ser una palabra.
2. Solo puede usar letras, números y el carácter de subrayado (_) .
3. No puede comenzar con un número.
Tabla 1-3: Nombres de variables válidos e inválidos
Nombres de variables válidos
Nombres de variables no válidos
balance
saldo actual (no se permiten guiones)
saldo actual
saldo actual (no se permiten espacios)
saldo actual
4cuenta (no puede comenzar con un número)
_correo n o deseado
C O R R E O N O D E S E AD O
cuenta4
20 Capítulo 1
42 (no puede comenzar con un número)
total_$um (caracteres especiales como $ no están permitidos)
'hola' (caracteres especiales como ' no están permitidos)
Machine Translated by Google
Los nombres de variables distinguen entre mayúsculas y minúsculas, lo que significa que spam, SPAM, Spam y sPaM
son cuatro variables diferentes. Es una convención de Python comenzar sus variables con una
letra minúscula.
Este libro usa camelcase para nombres de variables en lugar de guiones bajos; es decir,
las variables se ven como esto en lugar de mirar_como_esto . Algunos programadores
experimentados pueden señalar que el estilo de código oficial de Python, PEP 8, dice que se deben
usar guiones bajos. Sin pedir disculpas, prefiero camelcase y señalo "A Foolish Consistency Is the
Hobgoblin of Little Minds" en PEP 8:
“La consistencia con la guía de estilo es importante. Pero lo más
importante: sepa cuándo ser inconsistente; a veces, la guía de estilo
simplemente no se aplica. En caso de duda, use su mejor juicio”.
Un buen nombre de variable describe los datos que contiene. Imagina que te mudaste a
una nueva casa y etiquetaste todas tus cajas de mudanza como Cosas. ¡Nunca encontrarías
nada! Los nombres de las variables spam, huevos y tocino se usan como nombres genéricos
para los ejemplos de este libro y en gran parte de la documentación de Python (inspirada en el
boceto "Spam" de Monty Python), pero en sus programas, un nombre descriptivo ayudará. Haz
que tu código sea más legible.
Tu primer programa
Si bien el shell interactivo es bueno para ejecutar las instrucciones de Python de una en una,
para escribir programas completos de Python, debe escribir las instrucciones en el editor de
archivos. El editor de archivos es similar a los editores de texto como el Bloc de notas o
TextMate, pero tiene algunas características específicas para escribir el código fuente. Para
abrir el editor de archivos en IDLE, seleccione File4New Window.
La ventana que aparece debe contener un cursor esperando su entrada, pero es diferente
del shell interactivo, que ejecuta las instrucciones de Python tan pronto como presiona Intro. El
editor de archivos le permite escribir muchas instrucciones, guardar el archivo y ejecutar el
programa. Así es como puedes notar la diferencia entre los dos:
•La ventana de shell interactiva siempre será la que tenga el mensaje >>> .
•La ventana del editor de archivos no tendrá el aviso >>> .
¡Ahora es el momento de crear su primer programa! Cuando la ventana del editor de archivos
se abre, escriba lo siguiente en él:
u# Este programa me saluda y me pregunta mi nombre.
v print('¡Hola mundo!')
print('¿Cuál es tu nombre?') w
miNombre = entrada()
x print('Encantado de conocerte, + miNombre)
y print('La longitud de tu nombre es:')
imprimir(len(miNombre))
# preguntar por su nombre
'
Conceptos básicos de Python 21
Machine Translated by Google
z print('¿Cuál es su edad?') miEdad =
# preguntar por su edad
entrada()
'
'
imprimir('Serás
+ str(int(miEdad) + 1) +
en un año.')
Una vez que haya ingresado su código fuente, guárdelo para que no tenga que volver a
escribirlo cada vez que inicie IDLE. Desde el menú en la parte superior de la ventana del editor de
archivos, seleccione File4Save As. En la ventana Guardar como, ingresa hello.py
en el campo Nombre de archivo y luego haga clic en Guardar.
Debe guardar sus programas de vez en cuando mientras los escribe.
De esa manera, si la computadora falla o si accidentalmente sale de IDLE, no perderá el código.
Como acceso directo, puede presionar ctrl-S en Windows y Linux o zS en OS X para guardar su
archivo.
Una vez que haya guardado, ejecutemos nuestro programa. Seleccione el módulo Run4Run
o simplemente presione la tecla F5 . Su programa debería ejecutarse en la ventana de shell
interactiva que apareció cuando inició IDLE por primera vez. Recuerde, debe presionar F5 desde
la ventana del editor de archivos, no desde la ventana del shell interactivo.
Ingrese su nombre cuando su programa lo solicite. La salida del programa en el shell interactivo
debería verse así:
Python 3.3.2 (v3.3.2:d047928ae3f6, 16 de mayo de 2013, 00:06:53) [MSC v.1600 64 bit (AMD64)] en
win32
Escriba "derechos de autor", "créditos" o "licencia()" para obtener más información.
>>> =============================== REINICIAR ============== ==================
>>>
¡Hola Mundo!
¿Cuál es su nombre?
Alabama
Es un placer conocerte, Al.
La longitud de su nombre es:
2
¿Cual es tu edad?
4
Cumplirás 5 en un año.
>>>
Cuando no hay más líneas de código para ejecutar, el programa Python
termina; es decir, deja de funcionar. (También puede decir que el programa Python finaliza ).
Puede cerrar el editor de archivos haciendo clic en la X en la parte superior de la ventana.
Para recargar un programa guardado, seleccione File4Open en el menú. Hágalo ahora y, en la
ventana que aparece, seleccione hello.py y haga clic en el botón Abrir .
Su programa hello.py previamente guardado debería abrirse en la ventana del editor de archivos.
Diseccionando su programa
Con su nuevo programa abierto en el editor de archivos, hagamos un recorrido rápido por las
instrucciones de Python que usa observando lo que hace cada línea de código.
22 Capítulo 1
Machine Translated by Google
Comentarios
La siguiente línea se llama un comentario.
u# Este programa me saluda y me pregunta mi nombre.
Python ignora los comentarios y puede usarlos para escribir notas o recordar
lo que el código está tratando de hacer. Cualquier texto del resto de la línea que sigue
a una almohadilla (#) es parte de un comentario.
A veces, los programadores colocan un # delante de una línea de código para
eliminarlo temporalmente mientras prueban un programa. Esto se llama comentar
código, y puede ser útil cuando intenta descubrir por qué un programa no funciona.
Puede eliminar el # más adelante cuando esté listo para volver a colocar la línea.
Python también ignora la línea en blanco después del comentario. Puede agregar
tantas líneas en blanco a su programa como desee. Esto puede hacer que su código
sea más fácil de leer, como los párrafos de un libro.
La función imprimir()
La función print() muestra el valor de la cadena dentro de los paréntesis en el
pantalla.
v print('¡Hola mundo!')
print('¿Cuál es tu nombre?') # pregunta por su nombre
La línea print('¡Hola mundo!') significa "Imprimir el texto en la cadena '¡Hola
mundo!'". Cuando Python ejecuta esta línea, dice que Python está llamando a la
función print() y el valor de la cadena se pasa a la función. Un valor que se pasa a una
llamada de función es un argumento. Observe que las cotizaciones no se imprimen en
la pantalla. Simplemente marcan dónde comienza y termina la cuerda; no son parte del
valor de cadena.
N ota También puede usar esta función para poner una línea en blanco en la pantalla; simplemente llame a print() con
nada entre paréntesis.
Al escribir el nombre de una función, los paréntesis de apertura y cierre al final lo
identifican como el nombre de una función. Es por eso que en este libro verás print() en
lugar de print. El Capítulo 2 describe las funciones con más detalle.
La función de entrada ()
La función input() espera a que el usuario escriba algún texto en el teclado y presione
enter.
w miNombre = entrada()
Esta llamada de función se evalúa como una cadena igual al texto del usuario, y el
la línea de código anterior asigna la variable myName a este valor de cadena.
Conceptos básicos de Python 23
Machine Translated by Google
Puede pensar en la llamada a la función input() como una expresión que se
evalúa en cualquier cadena que el usuario haya ingresado. Si el usuario ingresó 'Al',
entonces la expresión se evaluaría como myName = 'Al'.
Imprimir el nombre del usuario
La siguiente llamada a print() en realidad contiene la expresión 'Es bueno + miNombre
' entre paréntesis. conocerte,
x print('Encantado de conocerte,
'
+ miNombre)
Recuerde que las expresiones siempre pueden evaluarse en un solo valor. Si 'Al'
es el valor almacenado en myName en la línea anterior, entonces esta expresión se
evalúa como 'Es un placer conocerte, Al'. Este valor de cadena única luego se pasa a
print(), que lo imprime en la pantalla.
La función len()
Puede pasar a la función len() un valor de cadena (o una variable que contiene una
cadena), y la función se evalúa como el valor entero del número de caracteres en
esa cadena.
y print('La longitud de su nombre es:')
imprimir(len(miNombre))
Ingrese lo siguiente en el shell interactivo para probar esto:
>>> len('hola')
5
>>> len('Mi monstruo muy enérgico acaba de devorar nachos.')
46
>>> largo('')
0
Al igual que esos ejemplos, len(myName) se evalúa como un número entero.
Luego se pasa a print() para que se muestre en la pantalla. Tenga en cuenta que
print() le permite pasar valores enteros o valores de cadena. Pero observe el error que
aparece cuando escribe lo siguiente en el shell interactivo:
'
+ 29 +
años.')
Rastreo (última llamada más reciente):
Archivo "<pyshell'#6>", línea' 1, en <módulo>
print('Tengo años+.')29 +
TypeError: no se puede convertir el objeto 'int' a str implícitamente
>>> print('Tengo
'
La función print() no está causando ese error, sino que es la expresión que
intentaste pasar a print(). Obtiene el mismo mensaje de error si escribe la expresión en
el shell interactivo por sí solo.
24 Capítulo 1
Machine Translated by Google
'
>>> 'Tengo
+ 29 +
'
años.'
Rastreo (última llamada más reciente):
Archivo "<' pyshell#7'>", línea 1, en <módulo>
'Soy
+ 29 +
años.'
TypeError: no se puede convertir el objeto 'int' a str implícitamente
Python da un error porque puede usar el operador + solo para sumar dos números
enteros o concatenar dos cadenas. No puede agregar un número entero a una cadena
porque esto no es gramatical en Python. Puede arreglar esto usando una versión de
cadena del entero en su lugar, como se explica en la siguiente sección.
Las funciones str(), int() y float()
Si desea concatenar un número entero como 29 con una cadena para pasar a
print(), deberá obtener el valor '29', que es la forma de cadena de 29. A la función str()
se le puede pasar un número entero valor y se evaluará a una versión de valor de
cadena de la misma, de la siguiente manera:
>>> cadena(29)
'29'
'
>>> print('Tengo + str(29) + Tengo
29 años.
'
años.')
'
'
Debido a que str(29) se evalúa como '29', la expresión 'Tengo + str(29) + años'.
'
'
se evalúa como 'Tengo + '29' + años', aqñuoesa'. sEustveeezfsusenelcevióvanalolpúrraqinuctoe()ms.eo p'Taesnagao l2a9
Las funciones str(), int() y float() evaluarán la cadena, inte
ger y formas de punto flotante del valor que pasa, respectivamente. Intente convertir
algunos valores en el shell interactivo con estas funciones y observe lo que sucede.
>>> cadena(0)
'0'
>>> cadena(-3.14)
'-3.14'
>>> int('42')
42
>>> int('-99')
-99
>>> int(1.25)
1
>>> int(1.99)
1
>>> flotar('3.14')
3.14
>>> flotar(10)
10.0
Conceptos básicos de Python 25
Machine Translated by Google
Los ejemplos anteriores llaman a las funciones str(), int() y float() y les pasan
valores de los otros tipos de datos para obtener una forma de cadena, entero o punto
flotante de esos valores.
La función str() es útil cuando tiene un número entero o flotante que
desea concatenar a una cadena. La función int() también es útil si tiene un número como
valor de cadena que desea usar en algunas matemáticas.
Por ejemplo, la función input() siempre devuelve una cadena, incluso si el usuario ingresa un
número. Ingrese spam = input () en el shell interactivo e ingrese 101
cuando espera tu texto.
Si desea hacer cálculos usando el valor en el correo no deseado, use la función int() para obtener
la forma entera del correo no deseado y luego guárdelo como el nuevo valor en el correo no deseado.
La función int() también es útil si necesita redondear un número de punto flotante hacia
abajo.
26 Capítulo 1
Machine Translated by Google
>>> int(7.7)
7
>>> int(7.7) + 1
8
En su programa, usó las funciones int() y str() en el último
tres líneas para obtener un valor del tipo de datos apropiado para el código.
z print('¿Cuál es tu edad?') # pregunta por su edad
miEdad = entrada()
imprimir('Serás
'
+ str(int(miEdad) + 1) +
'
en un año.')
La variable myAge contiene el valor devuelto por input(). Debido a que la
función input() siempre devuelve una cadena (incluso si el usuario escribió un
número), puede usar el código int(myAge) para devolver un valor entero de la cadena
en myAge. Este valor entero luego se suma a 1 en la expresión int(myAge) + 1.
El resultado de esta suma se pasa a la función str() : str(int(miEdad)
+ 1). El valor de cadena devuelto se concatena con las cadenas 'Usted
estarán ' y '
en un año.' para evaluar a un valor de cadena grande. Esta cadena grande
finalmente se pasa a print() para que se muestre en la pantalla.
Digamos que el usuario ingresa la cadena '4' para myAge. La cadena '4' se
convierte en un número entero, por lo que puede agregarle uno. El resultado es 5. La
función str() vuelve a convertir el resultado en una cadena, por lo que puede
concatenarla con la segunda cadena, 'en un año', para crear el mensaje final. Estos
pasos de evaluación se parecerían a la Figura 1-4.
Equivalencia de texto y número
Aunque el valor de cadena de un número se considera un valor completamente
diferente de la versión entera o de coma flotante, un entero puede ser igual a
una coma flotante.
>>> 42 == '42'
Falso
>>> 42 == 42,0
Verdadero
>>> 42.0 == 0042.000
Verdadero
Python hace esta distinción porque las cadenas son texto, mientras que los números
enteros y flotantes son números.
Conceptos básicos de Python 27
Machine Translated by Google
imprimir('Serás
imprimir('Serás
imprimir('Serás
imprimir('Serás
imprimir('Serás
'
'
'
'
'
'
+ str(int(miEdad) + 1) +
'
'4'
) + 1) +
+ cadena(
4+1
)+
+ cadena(
5
)+
'5'
+
+ cadena(int(
+
print('Tendrás 5 años'
+
'
'
'
'
en un año.')
en un año.')
en un año.')
en un año.')
en un año.')
en un año.')
print('Tú cumplirás 5 años en un año.')
Figura 1-4: Los pasos de evaluación, si se almacenó 4 en myAge
Resumen
Puede calcular expresiones con una calculadora o escribir concatenaciones de
cadenas con un procesador de textos. Incluso puede replicar cadenas fácilmente
copiando y pegando texto. Pero las expresiones y los valores de sus componentes—
operadores, variables y llamadas a funciones—son los bloques de construcción
básicos que hacen los programas. Una vez que sepa cómo manejar estos
elementos, podrá indicarle a Python que opere con grandes cantidades de datos por usted.
Es bueno recordar los diferentes tipos de operadores (+, -, *, /, //, % y ** para
operaciones matemáticas, y + y * para operaciones con cadenas) y los tres tipos de
datos (enteros, punto flotante números y cadenas) presentados en este capítulo.
También se introdujeron algunas funciones diferentes. La impresión () y la entrada ()
Las funciones manejan la salida de texto simple (a la pantalla) y la entrada (desde el teclado). La
función len() toma una cadena y se evalúa como un int del número de caracteres de la cadena. Las
funciones str(), int() y float() evaluarán la forma de número de cadena, entero o punto flotante del
valor que se les pasa.
En el próximo capítulo, aprenderá cómo decirle a Python que tome
decisiones inteligentes sobre qué código ejecutar, qué código omitir y qué código
repetir en función de los valores que tiene. Esto se conoce como control de flujo y
le permite escribir programas que toman decisiones inteligentes.
Preguntas de práctica
1. ¿Cuáles de los siguientes son operadores y cuáles son valores?
*
'Hola'
-88.8
/
+
5
28 Capítulo 1
Machine Translated by Google
2. ¿Cuál de las siguientes es una variable y cuál es una cadena?
Nombre tres tipos de datos.
¿De qué se compone una expresión? ¿Qué hacen todas las expresiones?
Este capítulo introdujo sentencias de asignación, como spam = 10. ¿Cuál es la
diferencia entre una expresión y una sentencia?
¿Qué contiene la variable tocino después de ejecutar el siguiente código?
tocino = 20
tocino + 1
¿Qué deben evaluar las siguientes dos expresiones?
'spam' + 'spamspam'
'spam' * 3
¿Por qué huevos es un nombre de variable válido mientras que 100 no es válido?
¿Qué tres funciones se pueden usar para obtener el número entero, punto flotante
número o versión de cadena de un valor?
¿Por qué esta expresión da error? ¿Cómo puedes arreglarlo?
'He comido
'
+ 99 +
burritos.
Crédito adicional: busque en línea la documentación de Python para len()
función. Estará en una página web titulada "Funciones integradas". Eche un vistazo
a la lista de otras funciones que tiene Python, busque lo que hace la función round()
y experimente con ella en el shell interactivo.
Conceptos básicos de Python 29
Machine Translated by Google
Machine Translated by Google
2
Control de flujo
Entonces conoce los conceptos básicos de
las instrucciones individuales y que un programa
es solo una serie de instrucciones. Pero la verdadera
fuerza de la programación no es solo ejecutar (o ejecutar)
una instrucción tras otra como una lista de mandados de fin de semana. Según cómo se
evalúen las expresiones, el programa puede decidir omitir instrucciones, repetirlas o elegir
una de varias instrucciones para ejecutar. De hecho, casi nunca desea que sus programas
comiencen desde la primera línea de código y simplemente ejecute cada línea, directamente
hasta el final. Las declaraciones de control de flujo pueden decidir qué instrucciones de Python
ejecutar bajo qué condiciones.
Estas sentencias de control de flujo se corresponden directamente con los símbolos de
un diagrama de flujo, por lo que proporcionaré versiones de diagrama de flujo del código
analizado en este capítulo. La Figura 2-1 muestra un diagrama de flujo de qué hacer si está
lloviendo. Sigue el camino que marcan las flechas de principio a fin.
Machine Translated by Google
comienzo
¿Tienes paraguas?
Espera un momento.
Figura 2-1: Un diagrama de flujo para decirle qué hacer si está lloviendo
En un diagrama de flujo, por lo general hay más de un camino a seguir desde el
principio hasta el final. Lo mismo es cierto para las líneas de código en un programa de
computadora. Los diagramas de flujo representan estos puntos de bifurcación con rombos,
mientras que los demás pasos se representan con rectángulos. Los pasos inicial y final se
representan con rectángulos redondeados.
Pero antes de aprender acerca de las declaraciones de control de flujo, primero
debe aprender cómo representar esas opciones de sí y no , y debe comprender cómo
escribir esos puntos de bifurcación como código de Python. Con ese fin, exploremos los
valores booleanos, los operadores de comparación y los operadores booleanos.
Valores booleanos
Mientras que los tipos de datos enteros, de punto flotante y de cadena tienen un número
ilimitado de valores posibles, el tipo de datos booleano tiene solo dos valores: Verdadero
y Falso. (Boolean está en mayúsculas porque el tipo de datos lleva el nombre del
matemático George Boole). Cuando se escribe como código Python, los valores
booleanos True y False carecen de las comillas que coloca alrededor de las cadenas, y
siempre comienzan con una T o F mayúscula, con el resto de la palabra en minúsculas.
Ingrese lo siguiente en el shell interactivo. (Algunas de estas instrucciones son
intencionalmente incorrectas y harán que aparezcan mensajes de error).
32 Capítulo 2
Machine Translated by Google
u >>> spam = Verdadero
>>> correo no deseado
Verdadero
v >>> cierto
Rastreo (llamadas recientes más última):
Archivo "<pyshell#2>", línea 1, en <módulo>
verdadero
NameError: el nombre 'verdadero' no está definido
w >>> Verdadero = 2 + 2
SyntaxError: asignación a palabra clave
Como cualquier otro valor, los valores booleanos se utilizan en expresiones y se pueden
almacenar en variables u. Si no usa el caso correcto v o intenta usar Verdadero y Falso para los
nombres de variables w, Python le dará un mensaje de error.
Operadores de comparación
Los operadores de comparación comparan dos valores y evalúan hasta un único valor
booleano. La Tabla 2-1 enumera los operadores de comparación.
Tabla 2-1: Operadores de comparación
Operador Significado
==
Igual a
!=
No igual a
<
Menos que
>
Mas grande que
<=
Menos que o igual a
>=
Mayor qué o igual a
Estos operadores se evalúan como Verdadero o Falso dependiendo de los valores que usted
darles. Probemos algunos operadores ahora, comenzando con == y !=.
>>> 42 == 42
Verdadero
>>> 42 == 99
Falso
>>> 2 != 3
Verdadero
>>> 2 != 2
Falso
Como era de esperar, == (igual a) se evalúa como Verdadero cuando los valores en
ambos lados son iguales, y != (no igual a) se evalúa como Verdadero cuando los dos valores son
diferentes. Los operadores == y != pueden funcionar con valores de cualquier tipo de datos.
Control de flujo 33
Machine Translated by Google
>>> 'hola' == 'hola'
Verdadero
>>> 'hola' == 'Hola'
Falso
>>> 'perro' != 'gato'
Verdadero
>>> Verdadero == Verdadero
Verdadero
>>> Verdadero != Falso
Verdadero
>>> 42 == 42,0
Verdadero
tu >>> 42 == '42'
Falso
Tenga en cuenta que un valor entero o de punto flotante siempre será diferente a un valor de cadena. La
expresión 42 == '42' u se evalúa como Falso porque Python considera que el número entero 42 es diferente de la
cadena '42'.
Los operadores <, >, <= y >= , por otro lado, funcionan correctamente
solo con valores enteros y de punto flotante.
>>> 42 < 100
Verdadero
>>> 42 > 100
Falso
>>> 42 < 42
Falso
>>> número de huevos = 42
u >>> número de huevos <= 42
Verdadero
>>> miEdad = 29
v >>> miEdad >= 10
Verdadero
La diferencia entre los operadores == y =
Es posible que haya notado que el operador == (igual a) tiene dos signos de igual, mientras que el
operador = (asignación) tiene solo un signo de igual. Es fácil confundir estos dos operadores entre sí.
Solo recuerda estos puntos:
•El operador == (igual a) pregunta si dos valores son iguales entre sí
otro.
•El operador = (asignación) pone el valor a la derecha en la variable
a la izquierda.
Para ayudar a recordar cuál es cuál, observe que el operador == (igual a) consta de dos
caracteres, al igual que el operador != (no igual a) consta de dos caracteres.
34 Capítulo 2
Machine Translated by Google
A menudo usará operadores de comparación para comparar el valor de una variable con
algún otro valor, como en los ejemplos eggCount <= 42 u y myAge >= 10 v.
(Después de todo, en lugar de escribir 'perro' != 'gato' en su código, podría haber escrito
simplemente Verdadero). Verá más ejemplos de esto más adelante cuando aprenda sobre las
declaraciones de control de flujo.
Operadores booleanos
Los tres operadores booleanos (y, o y no) se utilizan para comparar valores booleanos. Al igual que
los operadores de comparación, evalúan estas expresiones hasta un valor booleano. Exploremos
estos operadores en detalle, comenzando con el operador and .
Operadores booleanos binarios
Los operadores and y or siempre toman dos valores booleanos (o expresiones), por lo que se
consideran operadores binarios . El operador and evalúa una expresión como verdadera si ambos
valores booleanos son verdaderos; de lo contrario, se evalúa como False.
Ingrese algunas expresiones usando y en el shell interactivo para verlo en acción.
Verdadero
Expresión
Evalúa a…
verdadero y verdadero
Verdadero
Puede ver todos los resultados posibles del operador o en su tabla de verdad, que se muestra
en la Tabla 2-3.
Control de flujo 35
Machine Translated by Google
Tabla 2-3: La tabla de verdad del operador or
Expresión
Evalúa a…
verdadero o verdadero
Verdadero
Verdadero o falso
Verdadero
Falso o Verdadero
Verdadero
Falso o Falso
Falso
El no operador
A diferencia de and y or, el operador not opera en un solo valor booleano (o expresión).
El operador not simplemente se evalúa como el valor booleano opuesto.
>>> no es cierto
Falso
tu >>> no no no no cierto
Verdadero
Al igual que el uso de dobles negativos en el habla y la escritura, puede anidar operadores no u,
aunque nunca hay ninguna razón para hacer esto en programas reales. La tabla 2-4 muestra la tabla
de verdad para not.
Tabla 2-4: La tabla de verdad del operador no
Expresión
Evalúa a…
no es verdad
Falso
No falso
Verdadero
Mezcla de operadores booleanos y de comparación
Dado que los operadores de comparación se evalúan como valores booleanos,
puede usarlos en expresiones con los operadores booleanos.
Recuerde que los operadores and, or y not se denominan operadores booleanos
porque siempre operan sobre los valores booleanos True y False. Si bien expresiones
como 4 < 5 no son valores booleanos, son expresiones que se evalúan hasta valores
booleanos. Intente ingresar algunas expresiones booleanas que usan operadores de
comparación en el shell interactivo.
>>> (4 < 5) y (5 < 6)
Verdadero
>>> (4 < 5) y (9 < 6)
Falso
>>> (1 == 2) o (2 == 2)
Verdadero
36 Capítulo 2
Machine Translated by Google
La computadora evaluará primero la expresión de la izquierda y
luego evaluará la expresión de la derecha. Cuando conozca el valor
booleano de cada uno, evaluará la expresión completa hasta un valor
(4 < 5) y (5 < 6)
Verdadero y (5 < 6)
booleano. Puede pensar en el proceso de evaluación de la computadora
para (4 < 5) y (5 < 6) como se muestra en la figura 2-2.
verdadero y verdadero
Verdadero
También puede utilizar múltiples operadores booleanos en un
expresión, junto con los operadores de comparación.
>>> 2 + 2 == 4 y no 2 + 2 == 5 y 2 * 2 == 2 + 2
Verdadero
Figura 2-2: El
proceso de
evaluar (4 < 5) y (5
< 6) a Verdadero.
Los operadores booleanos tienen un orden de operaciones al igual que los
operadores matemáticos. Después de que se evalúen los operadores matemáticos y de
comparación, Python evalúa primero los operadores not , luego los operadores and y luego
los operadores or .
Elementos de control de flujo
Las declaraciones de control de flujo a menudo comienzan con una parte llamada condición, y
todas van seguidas de un bloque de código llamado cláusula. Antes de aprender acerca de las
declaraciones de control de flujo específicas de Python, cubriré lo que son una condición y un
bloque.
Condiciones
Todas las expresiones booleanas que has visto hasta ahora podrían considerarse
condiciones, que son lo mismo que expresiones; condición es solo un nombre más
específico en el contexto de las declaraciones de control de flujo. Las condiciones siempre se
evalúan hasta un valor booleano, verdadero o falso. Una declaración de control de flujo decide
qué hacer en función de si su condición es verdadera o falsa, y casi todas las declaraciones
de control de flujo utilizan una condición.
Bloques de código
Las líneas de código de Python se pueden agrupar en bloques. Puede saber cuándo comienza y
termina un bloque a partir de la sangría de las líneas de código. Hay tres reglas para los bloques.
1. Los bloques comienzan cuando aumenta la sangría.
2. Los bloques pueden contener otros bloques.
3. Los bloques terminan cuando la sangría se reduce a cero oa la sangría de un bloque
contenedor.
Control de flujo 37
Machine Translated by Google
Los bloques son más fáciles de entender mirando un código sangrado, por lo que
busquemos los bloques en parte de un programa de juego pequeño, que se muestra aquí:
w print('Contraseña incorrecta.')
El primer bloque de código u comienza en la línea print('Hello Mary') y con
contiene todas las líneas posteriores. Dentro de este bloque hay otro bloque v, que tiene una sola
línea: print('Acceso concedido.'). El tercer bloque w también tiene una línea de longitud:
print('Contraseña incorrecta.').
Ejecución del Programa
En el programa hello.py del capítulo anterior , Python comenzó a ejecutar instrucciones en la
parte superior del programa, una tras otra. La ejecución del programa (o simplemente ejecución) es
un término para la instrucción actual que se está ejecutando. Si imprime el código fuente en papel y
pone su dedo en cada línea a medida que se ejecuta, puede pensar en su dedo como la ejecución
del programa.
Sin embargo, no todos los programas se ejecutan simplemente yendo directamente hacia abajo. Si usted
use su dedo para rastrear a través de un programa con declaraciones de control de flujo, es
probable que se encuentre saltando alrededor del código fuente en función de las condiciones, y
probablemente se salte cláusulas enteras.
Declaraciones de control de flujo
Ahora, exploremos la parte más importante del control de flujo: las declaraciones mismas. Las
declaraciones representan los diamantes que vio en el diagrama de flujo de la Figura 2-1, y son las
decisiones reales que tomarán sus programas.
si declaraciones
El tipo más común de sentencia de control de flujo es la sentencia if . un si
La cláusula de la declaración (es decir, el bloque que sigue a la declaración if ) se ejecutará si la
condición de la declaración es verdadera. La cláusula se omite si la condición es Falsa.
En lenguaje sencillo, una declaración if podría leerse como "Si esta condición es verdadera,
ejecute el código en la cláusula". En Python, una declaración if consta de lo siguiente:
•La palabra clave si
•Una condición (es decir, una expresión que se evalúa como Verdadero o Falso)
•Dos puntos
•A partir de la siguiente línea, un bloque de código sangrado (llamado cláusula if )
38 Capítulo 2
Machine Translated by Google
Por ejemplo, supongamos que tiene un código que verifica si el nombre de alguien es
Alice. (Pretende que al nombre se le asignó algún valor anteriormente).
si nombre == 'Alicia':
print('Hola, Alicia.')
Todas las declaraciones de control de flujo terminan con dos puntos y van seguidas
de un nuevo bloque de código (la cláusula). Esta cláusula de declaración if es el bloque con
print('Hola, Alice.'). La Figura 2-3 muestra cómo se vería un diagrama de flujo de este código.
comienzo
nombre == 'Alicia'
Verdadero
print('Hola, Alicia.')
Falso
Final
Figura 2-3: El diagrama de flujo para una sentencia if
Declaraciones más
Opcionalmente, una cláusula if puede ir seguida de una declaración else . La cláusula else se
ejecuta solo cuando la condición de la instrucción if es falsa. En lenguaje sencillo, una declaración
else podría leerse como: “Si esta condición es verdadera, ejecute este código. O bien, ejecuta ese
código. Una declaración else no tiene una condición y, en el código, una declaración else siempre
consta de lo siguiente:
•La palabra clave else
•Dos puntos
•A partir de la siguiente línea, un bloque de código sangrado (llamado else
cláusula)
Volviendo al ejemplo de Alice, veamos un código que usa una instrucción else para
ofrecer un saludo diferente si el nombre de la persona no es Alice.
si nombre == 'Alicia':
print('Hola, Alicia.')
Control de flujo 39
Machine Translated by Google
else:
print('Hola, extraño.')
La figura 2-4 muestra cómo se vería un diagrama de flujo de este código.
comienzo
nombre == 'Alicia'
Verdadero
print('Hola, Alicia.')
Falso
print('Hola, extraño.')
Final
Figura 2-4: El diagrama de flujo para una sentencia else
declaraciones elif
Si bien solo se ejecutará una de las cláusulas if o else , es posible que tenga un caso en el
que desee que se ejecute una de las muchas cláusulas posibles. La sentencia elif es una sentencia
"else if" que siempre sigue a una sentencia if u otra sentencia elif .
Proporciona otra condición que se verifica solo si alguna de las condiciones anteriores era Falsa.
En el código, una instrucción elif siempre consta de lo siguiente:
•La palabra clave elif •Una
condición (es decir, una expresión que se evalúa como Verdadero o Falso) •Dos puntos
•A partir de la siguiente línea, un bloque de código sangrado (llamado elif
cláusula)
Agreguemos un elif al verificador de nombres para ver esta declaración en acción.
if nombre == 'Alice':
print('Hola, Alice.')
elif edad < 12: print('Tú
no eres Alice, niña.')
40 Capítulo 2
Machine Translated by Google
Esta vez, verifica la edad de la persona y el programa le dirá algo diferente si
tiene menos de 12 años. Puede ver el diagrama de flujo para esto en la Figura 2-5.
comienzo
nombre == 'Alicia'
Verdadero
print('Hola, Alicia.')
Falso
edad < 12
Verdadero
print('Tú no eres Alice, niña.')
Falso
Final
Figura 2-5: El diagrama de flujo para una declaración elif
La cláusula elif se ejecuta si age < 12 es True y name == 'Alice' es False.
Sin embargo, si ambas condiciones son falsas, se omiten ambas cláusulas. No se
garantiza la ejecución de al menos una de las cláusulas. Cuando hay una cadena
de declaraciones elif , solo se ejecutará una o ninguna de las cláusulas. Una vez
que se determina que una de las condiciones de las declaraciones es verdadera,
el resto de las cláusulas elif se omiten automáticamente. Por ejemplo, abra una nueva
ventana del editor de archivos e ingrese el siguiente código, guardándolo como
vampire.py:
si nombre == 'Alicia':
print('Hola, Alicia.')
elif edad < 12:
print('Tú no eres Alice, niña.')
elif edad > 2000:
print('A diferencia de ti, Alice no es un vampiro inmortal no-muerto.')
elif edad > 100:
print('Tú no eres Alice, abuela.')
Control de flujo 41
Machine Translated by Google
Aquí he agregado dos declaraciones elif más para hacer el verificador de nombres
saludar a una persona con diferentes respuestas según la edad. La Figura 2-6 muestra el
diagrama de flujo para esto.
nombre == 'Alicia'
print('Hola, Alicia.')
Falso
edad < 12
print('Tú no eres Alice, niña.')
Falso
edad > 2000
print('A diferencia de ti, Alice no es un
vampiro inmortal no-muerto.')
Falso
edad > 100
print('Tú no eres Alice, abuela.')
Falso
Final
Figura 2-6: El diagrama de flujo para múltiples sentencias elif en el programa vampire.py
42 Capítulo 2
Machine Translated by Google
Sin embargo, el orden de las declaraciones elif sí importa. vamos a reorganizar
ellos para introducir un error. Recuerda que el resto de las cláusulas elif se omiten
automáticamente una vez que se encuentra una condición Verdadera , por lo que si cambias
algunas de las cláusulas en vampire.py, te encuentras con un problema. Cambie el código para
que se vea como el siguiente y guárdelo como vampire2.py:
si nombre == 'Alicia':
print('Hola, Alicia.')
elif edad < 12:
print('Tú no eres Alice, niña.')
u elif edad > 100:
print('Tú no eres Alice, abuela.')
elif edad > 2000:
print('A diferencia de ti, Alice no es un vampiro inmortal no-muerto.')
Digamos que la variable edad contiene el valor 3000 antes de que se ejecute este código.
Puede esperar que el código imprima la cadena 'A diferencia de usted, Alice no es un
vampiro inmortal no-muerto'. Sin embargo, debido a que la condición edad > 100 es Verdadera
(después de todo, 3000 es mayor que 100) u, la cadena 'No eres Alice, abuela'. se imprime, y
el resto de las sentencias elif se omiten automáticamente. Recuerde, como máximo solo se
ejecutará una de las cláusulas, y para las declaraciones elif , ¡el orden es importante!
La figura 2-7 muestra el diagrama de flujo del código anterior. Observe cómo se
intercambian los diamantes para edad > 100 y edad > 2000 .
Opcionalmente, puede tener una declaración else después de la última declaración elif .
En ese caso, se garantiza que al menos una (y solo una) de las cláusulas se ejecutará. Si las
condiciones en cada instrucción if y elif son falsas, entonces se ejecuta la cláusula else . Por
ejemplo, volvamos a crear el programa Alice para usar las cláusulas if, elif y else .
si nombre == 'Alicia':
print('Hola, Alicia.')
elif edad < 12:
print('Tú no eres Alice, niña.')
más:
print('Tú no eres ni Alicia ni un niño pequeño.')
La Figura 2-8 muestra el diagrama de flujo de este nuevo código, que guardaremos
como littleKid.py.
En lenguaje sencillo, este tipo de estructura de control de flujo sería: “Si la primera
condición es verdadera, haz esto. De lo contrario, si la segunda condición es verdadera, haz eso.
De lo contrario, haz otra cosa”. Cuando use las tres declaraciones juntas, recuerde estas reglas
sobre cómo ordenarlas para evitar errores como el de la Figura 2-7. Primero, siempre hay
exactamente una declaración if . Cualquier elif
Las declaraciones que necesita deben seguir a la declaración if . En segundo lugar, si quiere
estar seguro de que se ejecuta al menos una cláusula, cierre la estructura con un else
declaración.
Control de flujo 43
Machine Translated by Google
nombre == 'Alicia'
print('Hola, Alicia.')
Falso
edad < 12
print('Tú no eres Alice, niña.')
Falso
edad > 100
print('Tú no eres Alice, abuela.')
Falso
edad > 2000
Falso
X
print('A diferencia de ti, Alice no es un
vampiro inmortal no-muerto.')
Final
Figura 2-7: El diagrama de flujo del programa vampire2.py. El camino tachado lógicamente nunca sucederá,
porque si la edad fuera mayor a 2000, ya habría sido mayor a 100.
44 Capítulo 2
Machine Translated by Google
nombre == 'Alicia'
print('Hola, Alicia.')
Falso
edad < 12
print('Tú no eres Alice, niña.')
Falso
print('Tú no eres ni Alicia ni un niño
pequeño.')
Final
Figura 2-8: Diagrama de flujo para el programa littleKid.py anterior
Sentencias de bucle while
Puede hacer que un bloque de código se ejecute una y otra vez con una sentencia while . El
código en una cláusula while se ejecutará siempre que la condición de la instrucción while sea
Verdadera. En el código, una instrucción while siempre consta de lo siguiente:
•La palabra clave while •Una
condición (es decir, una expresión que se evalúa como Verdadero o Falso)
•Dos puntos
•A partir de la siguiente línea, un bloque de código sangrado (llamado while
cláusula)
Control de flujo 45
Machine Translated by Google
Puede ver que una instrucción while se parece a una instrucción if . los
la diferencia está en cómo se comportan. Al final de una cláusula if , la ejecución del programa
continúa después de la declaración if . Pero al final de una cláusula while , la ejecución del programa
vuelve al inicio de la instrucción while . La cláusula while a menudo se denomina bucle while o
simplemente bucle.
Veamos una sentencia if y un ciclo while que usan la misma condición y toman las mismas
acciones basadas en esa condición. Aquí está el código con una declaración if :
si el correo no deseado < 5:
imprimir('Hola, mundo.')
imprimir('Hola, mundo.')
comienzo
Verdadero
imprimir('Hola, mundo.')
Figura 2-9: El diagrama de flujo para el código de declaración if
46 Capítulo 2
Machine Translated by Google
comienzo
Verdadero
correo no d es eado < 5
imprimir('Hola, mundo.')
correo no d es eado = co rreo no d es eado + 1
Falso
Final
Figura 2-10: El diagrama de flujo para el código de instrucción while
El código con la instrucción if verifica la condición e imprime Hello, world. una
sola vez si esa condición es verdadera. El código con el bucle while , por otro lado, lo
imprimirá cinco veces. Se detiene después de cinco impresiones porque el número entero
en el correo no deseado se incrementa en uno al final de cada iteración del ciclo, lo que
significa que el ciclo se ejecutará cinco veces antes de que el correo no deseado < 5 sea Falso.
En el ciclo while , la condición siempre se verifica al comienzo de cada iteración (es
decir, cada vez que se ejecuta el ciclo). Si la condición es verdadera, entonces se ejecuta
la cláusula y, posteriormente, se vuelve a verificar la condición.
La primera vez que se determina que la condición es Falsa, se omite la cláusula while .
Un molesto bucle while
Aquí hay un pequeño programa de ejemplo que seguirá pidiéndote que escribas, literalmente,
tu nombre. Seleccione File4New Window para abrir una nueva ventana del editor de archivos,
ingrese el siguiente código y guarde el archivo como suNombre.py:
u nombre
''
= v while nombre != 'tu nombre':
print('Escriba su nombre.')
w nombre = entrada ()
x imprimir('¡Gracias!')
Primero, el programa establece la variable de nombre u en una cadena vacía. Esto es para
que la condición name != 'your name' se evalúe como True y la ejecución del programa ingrese
en la cláusula v del ciclo while .
Control de flujo 47
Machine Translated by Google
El código dentro de esta cláusula le pide al usuario que escriba su nombre, que se
asigna a la variable de nombre w. Dado que esta es la última línea del bloque, la ejecución
vuelve al inicio del ciclo while y vuelve a evaluar la condición. Si el valor de nombre no es igual a
la cadena 'su nombre', entonces la condición es Verdadera y la ejecución vuelve a introducir la
cláusula while .
Pero una vez que el usuario escriba su nombre, la condición del ciclo while será 'su
nombre' != 'su nombre', que se evalúa como Falso. La condición ahora es Falsa, y en lugar de que
la ejecución del programa vuelva a ingresar la cláusula del ciclo while , la pasa por alto y continúa
ejecutando el resto del programa x.
La Figura 2-11 muestra un diagrama de flujo para el programa yourName.py .
"
¡nombre! = 'tu nombre'
print('Escriba su nombre.')
Falso
nombre = entrada()
imprimir('¡Gracias!')
Final
Ahora, veamos suNombre.py en acción. Presione F5 para ejecutarlo e ingrese algo
aparte de su nombre unas cuantas veces antes de darle al programa lo que quiere.
Por favor escriba su nombre.
Alabama
Por favor escriba su nombre.
Alberto
48 Capítulo 2
Machine Translated by Google
Por favor escriba su nombre.
%#@#%*(^&!!!
Por favor escriba su nombre.
Su nombre
¡Gracias!
romper declaraciones
La primera línea u crea un bucle infinito; es un bucle while cuya condición
es siempre Verdadero. (La expresión True, después de todo, siempre se evalúa hasta el
valor True.) La ejecución del programa siempre entrará en el ciclo y saldrá de él solo cuando
se ejecute una declaración de ruptura . (Un bucle infinito que nunca sale es un error de
programación común).
Al igual que antes, este programa le pide al usuario que escriba su nombre v. Ahora, sin
embargo, mientras la ejecución aún está dentro del ciclo while , se ejecuta una instrucción if w para
verificar si el nombre es igual a su nombre. Si esta condición es Verdadera, la sentencia break se
ejecuta x, y la ejecución sale del ciclo para imprimir('¡Gracias!') y. De lo contrario, se omite la cláusula
de la instrucción if con la instrucción break , lo que coloca la ejecución al final de while
círculo. En este punto, la ejecución del programa vuelve al inicio de la instrucción while u
para volver a verificar la condición. Dado que esta condición es simplemente el valor booleano
verdadero , la ejecución ingresa al ciclo para pedirle al usuario que escriba su nombre
nuevamente. Consulte la Figura 2-12 para ver el diagrama de flujo de este programa.
Ejecute suNombre2.py e ingrese el mismo texto que ingresó para suNombre.py.
El programa reescrito debe responder de la misma manera que el original.
Control de flujo 49
Machine Translated by Google
"
print('Escriba su nombre.')
nombre = entrada()
Falso _
nombre == 'tu nombre'
descanso
Falso
imprimir('¡Gracias!')
Final
Figura 2-12: El diagrama de flujo para el programa yourName2.py con un bucle infinito. Tenga en
cuenta que la ruta X lógicamente nunca sucederá porque la condición del ciclo siempre es Verdadera.
continuar Declaraciones
Al igual que las sentencias break , las sentencias continue se usan dentro de los
bucles. Cuando la ejecución del programa llega a una declaración de continuación ,
la ejecución del programa vuelve inmediatamente al inicio del bucle y vuelve a
evaluar la condición del bucle. (Esto también es lo que sucede cuando la ejecución
llega al final del ciclo).
50 Capítulo 2
Machine Translated by Google
¿Atrapado en un bucle infinito?
Si alguna vez ejecuta un programa que tiene un error que hace que se atasque en un
ciclo infinito, presione ctrl-C. Esto enviará un error KeyboardInterrupt a su programa y
hará que se detenga inmediatamente. Para probarlo, cree un bucle infinito simple en el
editor de archivos y guárdelo como infiniteloop.py.
mientras que es cierto:
imprimir('¡Hola mundo!')
Cuando ejecute este programa, imprimirá Hello world! a la pantalla para siempre,
porque la condición de la sentencia while siempre es Verdadera. En la ventana de shell
interactiva de IDLE, solo hay dos formas de detener este programa: presione ctrl -C o
seleccione Shell4Restart Shell en el menú. ctrl-C es útil si alguna vez desea terminar su
programa de inmediato, incluso si no está atascado en un ciclo infinito.
Usemos continuar para escribir un programa que solicite un nombre y una contraseña.
Ingrese el siguiente código en una nueva ventana del editor de archivos y guarde el
programa como pez espada.py.
mientras que es cierto:
imprimir('¿Quien eres?')
nombre = entrada()
u if nombre != 'Joe':
v
Seguir
print('Hola, Joe. ¿Cuál es la contraseña? (Es un pez.)')
w contraseña = entrada ()
if contraseña == 'pez espada':
descanso x
y print('Acceso concedido.')
Si el usuario ingresa cualquier nombre además de Joe u, la declaración de continuar v
hace que la ejecución del programa vuelva al inicio del bucle. Cuando reevalúa la condición, la
ejecución siempre entrará en el bucle, ya que la condición es simplemente el valor True. Una vez
que superan la declaración if , se le pide al usuario una contraseña w. Si la contraseña ingresada es
pez espada, entonces se ejecuta la instrucción break x y la ejecución salta del tiempo .
bucle para imprimir Acceso concedido y. De lo contrario, la ejecución continúa hasta el final
del ciclo while , donde luego vuelve al inicio del ciclo. Consulte la Figura 2-13 para ver el
diagrama de flujo de este programa.
Control de flujo 51
Machine Translated by Google
comienzo
nombre =
"
Verdadero
imprimir('¿Quien eres?')
Verdadero
nombre = entrada()
X
Falso
Seguir
nombre != 'Joe'
Verdadero
Falso
print('Hola, Joe. ¿Cuál es la contraseña? (Es un pez.)')
contraseña = entrada ()
Falso
descanso
contraseña == 'pez espada'
Verdadero
imprimir('Acceso concedido.')
Final
Figura 2-13: Un diagrama de flujo para swordfish.py. La ruta X lógicamente nunca sucederá porque la condición
del ciclo siempre es Verdadera.
52 Capítulo 2
Machine Translated by Google
Valores de “Verdad” y “Falso”
Hay algunos valores en otros tipos de datos que las condiciones considerarán equivalentes a
Verdadero y Falso. Cuando se usa en condiciones, 0, 0.0 y '' (la cadena vacía) se consideran
falsos, mientras que todos los demás valores se consideran verdaderos. Por ejemplo, mira el
siguiente programa:
nombre =
''
mientras no nombre :u
imprimir('Ingrese su nombre:')
nombre = entrada()
print('¿Cuántos invitados tendrás?')
numOfGuests = int(entrada())
si numOfGuests:v
print('Asegúrese de tener suficiente espacio para todos sus invitados.')w
imprimir('Terminado')
Si el usuario ingresa una cadena en blanco para el nombre, entonces la condición de la instrucción while
será True u, y el programa continúa pidiendo un nombre. Si el valor de numOfGuests no es 0
v, entonces la condición se considera verdadera y el programa imprimirá un recordatorio para
el usuario w.
Podría haber escrito not name != '' en lugar de not name, y numOfGuests != 0 en lugar de
numOfGuests, pero usar los valores verdadero y falso puede hacer que su código sea más fácil
de leer.
Ejecute este programa y déle alguna entrada. Hasta que diga que es Joe,
no debería pedirle una contraseña, y una vez que ingrese la contraseña correcta,
debería salir.
¿Quién eres tú?
Estoy bien gracias. ¿Quién eres tú?
¿Quién eres tú?
José
Hola Joe. ¿Cual es la contraseña? (Es un pescado.)
María
¿Quién eres tú?
José
Hola Joe. ¿Cual es la contraseña? (Es un pescado.)
pez espada
Acceso permitido.
for Loops y la función range()
El ciclo while sigue repitiéndose mientras su condición es Verdadera (que es la razón de su nombre), pero
¿qué sucede si desea ejecutar un bloque de código solo una cierta cantidad de veces? Puede hacer esto con
una instrucción de bucle for y el rango ()
función.
Control de flujo 53
Machine Translated by Google
En el código, una instrucción for se parece a i en el rango (5): y siempre incluye lo
siguiente:
•La palabra clave for
•Un nombre de variable
•La palabra clave en
• Una llamada al método range() con hasta tres enteros pasados
•Dos puntos
•A partir de la siguiente línea, un bloque de código sangrado (llamado for
cláusula)
Vamos a crear un nuevo programa llamado fiveTimes.py para ayudarte a ver un bucle for en
acción.
El código en la cláusula del bucle for se ejecuta cinco veces. La primera vez que se
ejecuta, la variable i se establece en 0. La llamada print() en la cláusula imprimirá Jimmy Five
Times (0). Después de que Python finaliza una iteración a través de todo el código dentro de la
cláusula del bucle for , la ejecución vuelve a la parte superior del bucle y la instrucción for
incrementa i en uno. Esta es la razón por la cual range(5) da como resultado cinco iteraciones a
través de la cláusula, donde i se establece en 0, luego en 1, luego en 2, luego en 3 y luego en 4.
La variable i subirá, pero no incluirá, el número entero pasado a range(). La Figura 2-14 muestra
un diagrama de flujo para el programa fiveTimes.py .
imprimir('Mi nombre es')
Bucle
para i en el rango (5)
print('Jimmy Cinco Veces (' + str(i) + ')')
Bucle terminado
Final
Figura 2-14: El diagrama de flujo para fiveTimes.py
54 Capítulo 2
Machine Translated by Google
Cuando ejecuta este programa, debe imprimir Jimmy Five Times seguido del valor de i
cinco veces antes de salir del bucle for .
Me llamo
Jimmy cinco veces (0)
Jimmy cinco veces (1)
Jimmy cinco veces (2)
Jimmy cinco veces (3)
Jimmy cinco veces (4)
N ota También puede usar sentencias break y continue dentro de bucles for. el continuar
continuará hasta el siguiente valor del contador del ciclo for , como si la ejecución del programa
hubiera llegado al final del ciclo y regresado al inicio. De hecho, puede usar declaraciones de
continuar y romper solo dentro de bucles while y for . Si intenta usar estas declaraciones en
otro lugar, Python le dará un error.
Como otro ejemplo de bucle for , considere esta historia sobre el matemático Karl
Friedrich Gauss. Cuando Gauss era un niño, un maestro quería darle a la clase un poco de
trabajo. El maestro les dijo que sumaran todos los números del 0 al 100. El joven Gauss ideó
un ingenioso truco para averiguar la respuesta en unos segundos, pero puedes escribir un
programa en Python con un for
bucle para hacer este cálculo por usted.
tu total = 0
v para num en rango (101):
w total = total + número
x imprimir(total)
El resultado debería ser 5.050. Cuando el programa comienza por primera vez, el total
variable se establece en 0 u. El ciclo for v luego ejecuta total = total + num w
100 veces. Para cuando el bucle haya terminado todas sus 100 iteraciones, todos los
números enteros del 0 al 100 se habrán sumado al total. En este punto, el total se imprime
en la pantalla x. Incluso en las computadoras más lentas, este programa tarda menos de un
segundo en completarse.
(El joven Gauss descubrió que había 50 pares de números que sumaban
hasta 100: 1 + 99, 2 + 98, 3 + 97, y así sucesivamente, hasta 49 + 51. Como 50 × 100 es
5000, cuando sumas ese 50 del medio, la suma de todos los números del 0 al 100 es 5.050.
¡Niño inteligente!)
Un ciclo while equivalente
De hecho, puede usar un bucle while para hacer lo mismo que un bucle for ; por
los bucles son más concisos. Reescribamos FiveTimes.py para usar un bucle while
equivalente a un bucle for .
imprimir('Mi nombre es')
yo = 0
mientras yo < 5:
print('Jimmy Cinco Veces (' + str(i) + ')')
yo = yo + 1
Control de flujo 55
Machine Translated by Google
Si ejecuta este programa, la salida debería tener el mismo aspecto que el
programa fiveTimes.py , que utiliza un bucle for .
Los argumentos de inicio, parada y paso a paso para range()
Algunas funciones se pueden llamar con múltiples argumentos separados por una coma,
y range() es uno de ellos. Esto le permite cambiar el número entero pasado a range() para
seguir cualquier secuencia de números enteros, incluido comenzar en un número distinto de
cero.
para i en el rango (12, 16):
imprimir (yo)
El primer argumento será donde comienza la variable del bucle for , y el
el segundo argumento será hasta, pero sin incluir, el número en el que detenerse.
12
13
14
15
La función range() también se puede llamar con tres argumentos. El primero
dos argumentos serán los valores de inicio y fin, y el tercero será el argumento de paso.
El paso es la cantidad que aumenta la variable después de cada iteración.
para i en el rango (0, 10, 2):
imprimir (yo)
Por lo tanto, llamar al rango (0, 10, 2) contará de cero a ocho en intervalos de dos.
0
2
4
6
8
La función range() es flexible en la secuencia de números que produce para bucles. Por
ejemplo (nunca me disculpo por mis juegos de palabras), incluso puede usar un número
negativo para el argumento de paso para hacer que el ciclo for cuente hacia atrás en lugar de
hacia arriba.
para i en el rango (5, -1, -1):
imprimir (yo)
Ejecutar un ciclo for para imprimir i con rango (5, -1, -1) debería imprimir de cinco a
cero.
5
4
56 Capítulo 2
Machine Translated by Google
3
2
1
0
Importación de módulos
Todos los programas de Python pueden llamar a un conjunto básico de funciones llamadas
funciones integradas, incluidas las funciones print(), input() y len() que ha visto antes. Python
también viene con un conjunto de módulos llamado biblioteca estándar. Cada módulo es un
programa de Python que contiene un grupo relacionado de funciones que se pueden
incrustar en sus programas. Por ejemplo, el módulo matemático tiene funciones relacionadas
con las matemáticas, el módulo aleatorio tiene funciones relacionadas con números
aleatorios, etc.
Antes de que pueda usar las funciones en un módulo, debe importar el módulo
con una declaración de importación . En el código, una declaración de importación consta
de lo siguiente:
•La palabra clave de importación
•El nombre del módulo
•Opcionalmente, más nombres de módulos, siempre que estén separados por
comas
Una vez que importa un módulo, puede usar todas las funciones geniales de ese
módulo. Probémoslo con el módulo aleatorio , que nos dará acceso a la función
random.ranint() .
Ingrese este código en el editor de archivos y guárdelo como printRandom.py:
importar al azar
para i en el rango (5):
imprimir(aleatorio.randint(1, 10))
Cuando ejecute este programa, la salida se verá así:
4
1
8
4
1
La llamada a la función random.randint() se evalúa como un valor entero aleatorio
entre los dos enteros que le pasas. Dado que randint() está en el azar
módulo, primero debe escribir random. delante del nombre de la función para decirle a
Python que busque esta función dentro del módulo aleatorio .
Aquí hay un ejemplo de una declaración de importación que importa cuatro módulos
diferentes:
importar aleatorio, sys, os, matemáticas
Control de flujo 57
Machine Translated by Google
Ahora podemos utilizar cualquiera de las funciones de estos cuatro módulos. aprenderemos
más sobre ellos más adelante en el libro.
de extractos de importación
Una forma alternativa de la declaración de importación se compone de la palabra clave
from , seguida del nombre del módulo, la palabra clave import y una estrella; por ejemplo, de
importación aleatoria *.
Con esta forma de declaración de importación , las llamadas a funciones en random no
necesitarán el random. prefijo. Sin embargo, usar el nombre completo hace que el código sea
más legible, por lo que es mejor usar la forma normal de la declaración de importación .
Finalización anticipada de un programa con sys.exit()
El último concepto de control de flujo a cubrir es cómo terminar el programa.
Esto siempre sucede si la ejecución del programa llega al final de las instrucciones. Sin
embargo, puede hacer que el programa termine, o salga, llamando a la función sys.exit() . Dado
que esta función está en el módulo sys , debe importar sys antes de que su programa pueda usarla.
Abra una nueva ventana del editor de archivos e ingrese el siguiente código, guardándolo
como exitExample.py:
sistema de importación
mientras que es cierto:
print('Escriba exit para salir.')
respuesta = entrada()
si respuesta == 'salir':
sys.exit()
'
imprimir('Tú escribiste
+ respuesta + '.')
Ejecute este programa en INACTIVO. Este programa tiene un ciclo infinito sin declaración
de interrupción dentro. La única forma en que este programa finalizará es si el usuario ingresa exit,
lo que hace que se llame a sys.exit() . Cuando la respuesta es igual a salir, el programa finaliza.
Dado que la variable de respuesta la establece la función input() , el usuario debe ingresar exit para
detener el programa.
Resumen
Mediante el uso de expresiones que se evalúan como Verdadero o Falso (también llamadas
condiciones), puede escribir programas que toman decisiones sobre qué código ejecutar y qué
código omitir. También puede ejecutar código una y otra vez en un bucle mientras una
determinada condición se evalúa como verdadera. Las instrucciones break y continue son útiles si
necesita salir de un bucle o volver al principio.
Estas declaraciones de control de flujo le permitirán escribir programas mucho más
inteligentes. Hay otro tipo de control de flujo que puede lograr escribiendo sus propias funciones,
que es el tema del próximo capítulo.
58 Capítulo 2
Machine Translated by Google
Preguntas de práctica
1. ¿Cuáles son los dos valores del tipo de datos booleano? Cómo
escribirlos?
2. ¿Cuáles son los tres operadores booleanos?
3. Escriba las tablas de verdad de cada operador booleano (es decir, cada combinación
posible de valores booleanos para el operador y lo que evalúan).
4. ¿A qué equivalen las siguientes expresiones?
(5 > 4) y (3 == 5)
no (5 > 4) (5 >
o (3 == 5)
no ((5 > 4) o (3 == 5))
(Verdadero y Verdadero) y (Verdadero == Falso)
(no es falso) o (no es cierto)
si es spam == 10:
imprimir ('huevos')
imprimir('tocino')
más:
imprimir ('jamón')
9. Escriba un código que imprima Hola si 1 está almacenado en spam, imprima Hola si 2 está
almacenado en correo no deseado e imprime ¡Saludos! si algo más se almacena en spam.
10. ¿Qué puedes presionar si tu programa está atascado en un ciclo infinito?
11. ¿Cuál es la diferencia entre romper y continuar?
12. ¿Cuál es la diferencia entre rango (10), rango (0, 10) y rango (0, 10, 1)
en un bucle for ?
13. Escriba un programa corto que imprima los números del 1 al 10 usando un bucle for .
Luego escriba un programa equivalente que imprima los números del 1 al 10 usando un
bucle while .
14. Si tuviera una función llamada bacon() dentro de un módulo llamado spam, ¿cómo
¿Lo llamarías después de importar spam?
Crédito extra: busque las funciones round() y abs() en Internet y descubra lo que
hacen. Experimente con ellos en el caparazón interactivo.
Control de flujo 59
Machine Translated by Google
Machine Translated by Google
3
F unciones
Ya está familiarizado con las funciones
print(), input() y len() de los capítulos
anteriores. Python proporciona varias funciones
integradas como estas, pero también puede
escribir sus propias funciones. Una función es como un
miniprograma dentro de un programa.
Para comprender mejor cómo funcionan las funciones, creemos una. Escriba este
programa en el editor de archivos y guárdelo como helloFunc.py:
tu definitivamente hola():
v print('¡Hola!')
imprimir('Hola!!!')
imprimir('Hola.')
hola()
Hola()
Hola()
Machine Translated by Google
La primera línea es una declaración de definición u, que define una función llamada
hola(). El código en el bloque que sigue a la instrucción def v es el cuerpo de la función.
Este código se ejecuta cuando se llama a la función, no cuando se define por primera vez.
Las líneas hello() después de la función w son llamadas de función. En el código,
una llamada de función es simplemente el nombre de la función seguido de paréntesis,
posiblemente con algún número de argumentos entre paréntesis. Cuando la ejecución del
programa alcance estas llamadas, saltará a la línea superior de la función y comenzará a
ejecutar el código allí. Cuando llega al final de la función, la ejecución vuelve a la línea que
llamó a la función y continúa moviéndose a través del código como antes.
Dado que este programa llama a hello() tres veces, el código en hello()
La función se ejecuta tres veces. Cuando ejecuta este programa, la salida se ve así:
¡Hola!
¡¡¡Hola!!!
Hola.
¡Hola!
¡¡¡Hola!!!
Hola.
¡Hola!
¡¡¡Hola!!!
Hola.
Un propósito principal de las funciones es agrupar el código que se ejecuta varias
veces. Sin una función definida, tendría que copiar y pegar este código cada vez, y el
programa se vería así:
imprimir('¡Hola!')
imprimir('Hola!!!')
imprimir('Hola.')
imprimir('¡Hola!')
imprimir('Hola!!!')
imprimir('Hola.')
imprimir('¡Hola!')
imprimir('Hola!!!')
imprimir('Hola.')
En general, siempre desea evitar la duplicación de código, porque si alguna vez
decide actualizar el código, si, por ejemplo, encuentra un error que necesita corregir, tendrá
que recordar cambiar el código en todos los lugares donde lo copió.
A medida que adquiera más experiencia en programación, a menudo se encontrará
deduplicación de código, lo que significa deshacerse del código duplicado o copiado y
pegado. La deduplicación hace que sus programas sean más cortos, más fáciles de leer
y más fáciles de actualizar.
62 Capítulo 3
Machine Translated by Google
Declaraciones def con parámetros
Cuando llama a la función print() o len() , pasa valores, llamados argumentos en este
contexto, escribiéndolos entre paréntesis. También puede definir sus propias funciones que
aceptan argumentos. Escriba este ejemplo en el editor de archivos y guárdelo como
helloFunc2.py:
def hola(nombre):
v print('Hola' + nombre)
w hola('Alicia')
Hola Bob')
Cuando ejecuta este programa, la salida se ve así:
hola alicia
Hola Bob
La definición de la función hola() en este programa tiene un parámetro llamado nombre
u. Un parámetro es una variable en la que se almacena un argumento cuando se llama a
una función. La primera vez que se llama a la función hello() , es con el argumento 'Alice'
w. La ejecución del programa ingresa a la función, y el nombre de la variable se establece
automáticamente en 'Alice', que es lo que se imprime mediante la instrucción print() v.
Una cosa especial a tener en cuenta sobre los parámetros es que el valor
almacenado en un parámetro se olvida cuando la función regresa. Por ejemplo, si agregó
print(name) después de hello('Bob') en el programa anterior, el programa le daría un
NameError porque no hay una variable con nombre. Esta variable se destruyó después de
que regresara la llamada a la función hello('Bob') , por lo que print(name) se referiría a una
variable de nombre que no existe.
Esto es similar a cómo se olvidan las variables de un programa cuando finaliza el
programa. Hablaré más sobre por qué sucede eso más adelante en el capítulo, cuando
discuta qué es el alcance local de una función.
Valores de retorno y declaraciones de retorno
Cuando llama a la función len() y le pasa un argumento como 'Hola', la llamada a la
función se evalúa como el valor entero 5, que es la longitud de la cadena que le pasó. En
general, el valor al que se evalúa una llamada de función se denomina valor de retorno de
la función.
Al crear una función usando la instrucción def , puede especificar qué
el valor de retorno debe ser con una declaración de retorno . Una declaración de
devolución consta de lo siguiente:
•La palabra clave de retorno
•El valor o expresión que debe devolver la función
Funciones 63
Machine Translated by Google
Cuando se usa una expresión con una declaración de retorno , el valor de
retorno es lo que se evalúa en esta expresión. Por ejemplo, el siguiente programa
define una función que devuelve una cadena diferente según el número que se le
pase como argumento. Escriba este código en el editor de archivos y guárdelo como
magic8Ball.py:
importas al azar
v def obtenerRespuesta(númeroRespuesta):
w si número de respuesta == 1:
volver 'Es cierto'
elif número de respuesta == 2:
volver 'Es decididamente así'
elif número de respuesta == 3:
devolver 'Sí'
elif número de respuesta == 4:
elif número de respuesta == 5:
volver 'Preguntar de nuevo más tarde'
elif número de respuesta == 6:
return 'Concéntrate y vuelve a preguntar'
elif número de respuesta == 7:
volver 'Mi respuesta es no'
elif número de respuesta == 8:
volver 'Perspectiva no tan buena'
elif número de respuesta == 9:
volver 'Muy dudoso'
xr = random.randint(1, 9)
y fortuna = obtener respuesta (r)
z imprimir (fortuna)
Cuando se inicia este programa, Python primero importa el módulo aleatorio u.
Luego, la función getAnswer() se define v. Debido a que la función se define (y no
se llama), la ejecución salta el código que contiene. A continuación, se llama a la
función random.randint() con dos argumentos, 1 y 9 x. Se evalúa como un número
entero aleatorio entre 1 y 9 (incluidos 1 y 9 ), y este valor se almacena en una
variable llamada r.
La función getAnswer() se llama con r como argumento y. La ejecución del
programa se mueve a la parte superior de la función getAnswer() w, y el valor r se
almacena en un parámetro llamado answerNumber. Luego, dependiendo de este
valor en answerNumber, la función devuelve uno de los muchos valores de cadena
posibles. La ejecución del programa regresa a la línea en la parte inferior del programa
que originalmente llamó a getAnswer() y. La cadena devuelta se asigna a una variable
llamada fortuna, que luego se pasa a una llamada print() z y se imprime en la pantalla.
64 Capítulo 3
Machine Translated by Google
Tenga en cuenta que, dado que puede pasar valores devueltos como argumento a otra
llamada de función, puede acortar estas tres líneas:
r = random.randint(1, 9)
fortuna = obtener respuesta (r)
imprimir (fortuna)
a esta única línea equivalente:
imprimir(obtenerRespuesta(aleatorio.randint(1, 9)))
Recuerde, las expresiones se componen de valores y operadores. Se puede usar una
llamada de función en una expresión porque se evalúa como su valor de retorno.
El valor de ninguno
En Python existe un valor llamado Ninguno, que representa la ausencia de un valor. Ninguno
es el único valor del tipo de datos NoneType . (Otros lenguajes de programación pueden llamar a
este valor nulo, nulo o indefinido). Al igual que los valores booleanos Verdadero y Falso , Ninguno
debe escribirse con una N mayúscula.
Este valor sin valor puede ser útil cuando necesita almacenar algo que no se confundirá con
un valor real en una variable. Un lugar donde se usa Ninguno es como el valor de retorno de
print(). La función print() muestra texto en la pantalla, pero no necesita devolver nada de la misma
manera que lo hacen len() o input() . Pero dado que todas las llamadas a funciones deben
evaluarse como un valor de retorno, print() devuelve Ninguno. Para ver esto en acción, ingrese lo
siguiente en el shell interactivo:
>>> spam = imprimir('¡Hola!')
¡Hola!
>>> Ninguno == spam
Verdadero
Detrás de escena, Python agrega return None al final de cualquier definición de función
sin declaración de devolución . Esto es similar a cómo un tiempo o por
loop termina implícitamente con una declaración de continuación . Además, si utiliza una
declaración de retorno sin un valor (es decir, solo la palabra clave de retorno por sí misma), se
devuelve Ninguno .
Argumentos de palabras clave y print()
La mayoría de los argumentos se identifican por su posición en la llamada de función. Por
ejemplo, random.randint(1, 10) es diferente de random.randint(10, 1). La llamada a la función
random.randint(1, 10) devolverá un número entero aleatorio entre 1
y 10, porque el primer argumento es el extremo inferior del rango y el segundo argumento es el
extremo superior (mientras que random.randint(10, 1) provoca un error).
Funciones 65
Machine Translated by Google
Sin embargo, los argumentos de palabra clave se identifican por la palabra clave
que se les antepone en la llamada de función. Los argumentos de palabras clave a
menudo se usan para parámetros opcionales. Por ejemplo, la función print() tiene los
parámetros opcionales end y sep para especificar qué debe imprimirse al final de sus
argumentos y entre sus argumentos (separándolos), respectivamente.
Si ejecutó el siguiente programa:
imprimir('Hola')
imprimir('Mundo')
la salida se vería así:
Hola
Mundo
Las dos cadenas aparecen en líneas separadas porque la función print() agrega
automáticamente un carácter de nueva línea al final de la cadena que se pasa.
Sin embargo, puede establecer el argumento de la palabra clave final para cambiar esto a una
cadena diferente. Por ejemplo, si el programa fuera este:
imprimir('Hola', fin='')
imprimir('Mundo')
la salida se vería así:
Hola Mundo
La salida se imprime en una sola línea porque ya no hay una nueva línea impresa
después de 'Hola'. En su lugar, se imprime la cadena en blanco. Esto es útil si necesita
deshabilitar la nueva línea que se agrega al final de cada llamada a la función print() .
De manera similar, cuando pasa varios valores de cadena a print(), la función
los separará automáticamente con un solo espacio. Ingrese lo siguiente en el shell
interactivo:
>>> print('gatos', 'perros', 'ratones')
gatos perros ratones
Pero podría reemplazar la cadena de separación predeterminada pasando el sep
argumento de palabra clave. Ingrese lo siguiente en el shell interactivo:
>>> print('gatos', 'perros', 'ratones', sep=',')
gatos, perros, ratones
También puede agregar argumentos de palabras clave a las funciones que escriba,
pero primero tendrá que aprender sobre los tipos de datos de lista y diccionario en los
próximos dos capítulos. Por ahora, solo sepa que algunas funciones tienen argumentos de
palabras clave opcionales que se pueden especificar cuando se llama a la función.
66 Capítulo 3
Machine Translated by Google
Alcance Local y Global
Se dice que los parámetros y variables que se asignan en una función llamada existen en el
ámbito local de esa función. Se dice que las variables que se asignan fuera de todas las funciones
existen en el ámbito global. Una variable que existe en un ámbito local se denomina variable local,
mientras que una variable que existe en el ámbito global se denomina variable global. Una variable
debe ser una u otra; no puede ser a la vez local y global.
Piense en un ámbito como un contenedor de variables. Cuando se destruye un ámbito, se
olvidan todos los valores almacenados en las variables del ámbito. Solo hay un alcance global y se
crea cuando comienza su programa. Cuando su programa finaliza, el alcance global se destruye y
todas sus variables se olvidan. De lo contrario, la próxima vez que ejecute su programa, las variables
recordarán sus valores de la última vez que lo ejecutó.
Se crea un ámbito local cada vez que se llama a una función. Cualquier variable asignada en
esta función existe dentro del ámbito local. Cuando la función regresa, el alcance local se destruye y
estas variables se olvidan. La próxima vez que llame a esta función, las variables locales no recordarán
los valores almacenados en ellas desde la última vez que se llamó a la función.
Los alcances son importantes por varias razones:
•El código en el ámbito global no puede utilizar ninguna variable local.
•Sin embargo, un alcance local puede acceder a variables globales.
•El código en el ámbito local de una función no puede usar variables en ningún otro
ámbito local.
•Puede usar el mismo nombre para diferentes variables si están en diferentes
diferentes alcances. Es decir, puede haber una variable local llamada spam y una variable
global también llamada spam.
La razón por la que Python tiene diferentes alcances en lugar de simplemente hacer que
cada cosa sea una variable global es que cuando el código modifica las variables en una llamada
particular a una función, la función interactúa con el resto del programa solo a través de sus
parámetros y el valor devuelto. . Esto reduce las líneas de código de la lista que pueden estar
causando un error. Si su programa no contenía nada más que variables globales y tenía un error
debido a que una variable se configuró en un valor incorrecto, entonces sería difícil rastrear dónde se
configuró este valor incorrecto. Podría haberse configurado desde cualquier parte del programa, ¡y su
programa podría tener cientos o miles de líneas! Pero si el error se debe a una variable local con un
valor incorrecto, sabe que solo el código en esa función podría haberlo configurado incorrectamente.
Si bien el uso de variables globales en programas pequeños está bien, es un mal hábito.
confiar en variables globales a medida que sus programas se hacen más y más grandes.
Las variables locales no se pueden utilizar en el ámbito global
Considere este programa, que causará un error cuando lo ejecute:
definitivamente spam():
huevos = 31337
Funciones 67
Machine Translated by Google
correo no deseado()
imprimir (huevos)
Si ejecuta este programa, la salida se verá así:
Rastreo (llamadas recientes más última):
Archivo "C:/test3784.py", línea 4, en <módulo>
imprimir (huevos)
NameError: el nombre 'huevos' no está definido
El error ocurre porque la variable huevos solo existe en el ámbito local creado cuando
se llama a spam() . Una vez que la ejecución del programa regresa del spam, ese alcance
local se destruye y ya no hay una variable llamada huevos. Entonces, cuando su programa
intenta ejecutar print (huevos), Python le da un error que dice que los huevos no están
definidos. Esto tiene sentido si lo piensas; cuando la ejecución del programa está en el ámbito
global, no existen ámbitos locales, por lo que no puede haber variables locales. Esta es la razón
por la cual solo las variables globales se pueden usar en el ámbito global.
Los ámbitos locales no pueden usar variables en otros ámbitos locales
Se crea un nuevo ámbito local cada vez que se llama a una función, incluso cuando se llama a
una función desde otra función. Considere este programa:
definitivamente spam():
u huevos = 99
v tocino()
w imprimir (huevos)
def tocino():
jamón = 101
x huevos = 0
y spam()
Cuando se inicia el programa, la función spam() se llama y, y un local
se crea el alcance. La variable local huevos u se establece en 99. Luego, el tocino ()
La función se llama v, y se crea un segundo ámbito local. Pueden existir varios ámbitos
locales al mismo tiempo. En este nuevo ámbito local, la variable local ham se establece en 101,
y una variable local huevos, que es diferente de la del ámbito local de spam(), también se crea x
y se establece en 0.
Cuando bacon() regresa, se destruye el ámbito local para esa llamada. La ejecución del
programa continúa en la función spam() para imprimir el valor de huevos w, y dado que el
alcance local para la llamada a spam() todavía existe aquí, la variable huevos se establece en
99. Esto es lo que imprime el programa .
El resultado es que las variables locales en una función están completamente separadas.
tasa de las variables locales en otra función.
68 Capítulo 3
Machine Translated by Google
Las variables globales se pueden leer desde un ámbito local
Considere el siguiente programa:
imprimir (huevos)
huevos = 42
imprimir (huevos)
Dado que no hay ningún parámetro llamado huevos ni ningún código que asigne
huevos a un valor en la función spam() , cuando se usa huevos en spam(), Python lo
considera una referencia a la variable global huevos. Por eso se imprime 42 cuando se
ejecuta el programa anterior.
Para simplificar su vida, evite usar variables locales que tengan el mismo nombre que una
variable global u otra variable local. Pero técnicamente, es perfectamente legal hacerlo en
Python. Para ver qué sucede, escriba el siguiente código en el editor de archivos y guárdelo
como mismoNombre.py:
u huevos = 'spam local'
imprimir (huevos)
# imprime 'spam local'
def tocino():
v huevos = 'tocino local'
print(huevos) # imprime 'tocino local'
imprimir (huevos)
# imprime 'tocino local'
w huevos = 'global'
tocino()
imprimir (huevos)
# imprime 'global'
Cuando ejecuta este programa, genera lo siguiente:
tocino local
spam local
tocino local
global
En realidad, hay tres variables diferentes en este programa, pero de manera confusa,
todas se llaman huevos. Las variables son las siguientes:
u Una variable llamada huevos que existe en un ámbito local cuando se llama a spam() .
v Una variable denominada huevos que existe en un ámbito local cuando se llama a bacon() .
w Una variable denominada huevos que existe en el ámbito global.
Funciones 69
Machine Translated by Google
Dado que estas tres variables separadas tienen el mismo nombre, puede ser confuso hacer
un seguimiento de cuál se está utilizando en un momento dado. Esta es la razón por la que debe
evitar usar el mismo nombre de variable en diferentes ámbitos.
La declaración mundial
Si necesita modificar una variable global desde dentro de una función, use la variable global
declaración. Si tiene una línea como huevos globales en la parte superior de una función, le dice
a Python: "En esta función, los huevos se refieren a la variable global, así que no cree una variable
local con este nombre". Por ejemplo, escriba el siguiente código en el editor de archivos y guárdelo
como mismoNombre2.py:
definitivamente spam():
u huevos globales
v huevos = 'spam'
huevos = 'global'
correo no deseado()
imprimir (huevos)
Cuando ejecuta este programa, la última llamada print() generará esto:
correo no deseado
Debido a que los huevos se declaran globales en la parte superior de spam() u, cuando los
huevos se establecen en 'spam' v, esta asignación se realiza al spam de ámbito global . Sin spam local
se crea la variable.
Hay cuatro reglas para saber si una variable está en un ámbito local o en un ámbito global:
1. Si una variable se utiliza en el ámbito global (es decir, fuera de todos
funciones), entonces siempre es una variable global.
2. Si hay una declaración global para esa variable en una función, es una declaración global
variable.
3. De lo contrario, si la variable se usa en una declaración de asignación en la función, es una
variable local.
4. Pero si la variable no se usa en una instrucción de asignación, es una variable global.
variable.
Para tener una mejor idea de estas reglas, aquí hay un programa de ejemplo. Escribe
el siguiente código en el editor de archivos y guárdelo como mismoNombre3.py:
definitivamente spam():
u huevos globales
huevos = 'spam' # este es el global
def tocino():
v huevos = 'tocino' # esto es un local
70 Capítulo 3
Machine Translated by Google
def jamón():
w print(huevos) # este es el global
huevos = 42 # este es el global
correo no deseado()
imprimir (huevos)
En la función spam() , huevos es la variable global huevos , porque hay una
declaración global para huevos al comienzo de la función u. En bacon(), huevos es
una variable local, porque hay una declaración de asignación para ellos en esa
función v. En ham() w, huevos es la variable global, porque no hay ninguna declaración
de asignación o declaración global para ellos en esa función. Si ejecuta sameName3.py,
la salida se verá así:
correo no deseado
En una función, una variable siempre será global o siempre será local.
No hay forma de que el código en una función pueda usar una variable local llamada
huevos y luego en esa misma función usar la variable global huevos .
N ota
alguna vez desea modificar el valor almacenado en una variable global desde una
función, debe usar una declaración global en esa variable.
Si intenta usar una variable local en una función antes de asignarle un valor, como
en el siguiente programa, Python le dará un error. Para ver esto, escriba lo siguiente en
el editor de archivos y guárdelo como mismoNombre4.py:
definitivamente spam():
imprimir (huevos) # ¡ERROR!
u huevos = 'spam local'
v huevos = 'global'
correo no deseado()
Si ejecuta el programa anterior, produce un mensaje de error.
Rastreo (llamadas recientes más última):
Archivo "C:/test3784.py", línea 6, en <módulo>
correo no deseado()
Archivo "C:/test3784.py", línea 2, en spam
imprimir (huevos) # ¡ERROR!
UnboundLocalError: variable local 'huevos' a la que se hace referencia antes de la asignación
Este error ocurre porque Python ve que hay una declaración de asignación para
huevos en la función spam() u y, por lo tanto, considera que los huevos son locales.
Pero debido a que print(eggs) se ejecuta antes de que se le asigne algo a egg, la
variable local egg no existe. Python no recurrirá al uso de la variable global de huevos v.
Funciones 71
Machine Translated by Google
Funciona como “cajas negras”
A menudo, todo lo que necesita saber sobre una función son sus entradas (los
parámetros) y el valor de salida; no siempre tiene que preocuparse por cómo funciona
realmente el código de la función. Cuando piensa en funciones de esta manera de alto
nivel, es común decir que está tratando la función como una "caja negra".
Esta idea es fundamental para la programación moderna. Los capítulos posteriores
de este libro le mostrarán varios módulos con funciones que fueron escritas por otras
personas. Si bien puede echar un vistazo al código fuente si tiene curiosidad, no
necesita saber cómo funcionan estas funciones para usarlas. Y debido a que se
recomienda escribir funciones sin variables globales, por lo general no tiene que
preocuparse de que el código de la función interactúe con el resto de su programa.
Manejo de excepciones
En este momento, obtener un error o una excepción en su programa de Python significa
que todo el programa fallará. No querrás que esto suceda en los programas del mundo
real. En cambio, desea que el programa detecte errores, los maneje y luego continúe
ejecutándose.
Por ejemplo, considere el siguiente programa, que tiene un error de "dividir por
cero". Abra una nueva ventana del editor de archivos e ingrese el siguiente código,
guardándolo como zeroDivide.py:
def spam (dividir por):
volver 42 / dividir por
imprimir (correo no deseado (2))
imprimir (correo no deseado (12))
imprimir (correo no deseado (0))
imprimir (correo no deseado (1))
Hemos definido una función llamada spam, le hemos dado un parámetro y luego
hemos impreso el valor de esa función con varios parámetros para ver qué sucede. Este
es el resultado que obtienes cuando ejecutas el código anterior:
21.0
3.5
Rastreo (llamadas recientes más última):
Archivo "C:/zeroDivide.py", línea 6, en <módulo>
imprimir (correo no deseado (0))
Archivo "C:/zeroDivide.py", línea 2, en spam
volver 42 / dividir por
ZeroDivisionError: división por cero
Un ZeroDivisionError ocurre cada vez que intenta dividir un número por cero.
Por el número de línea proporcionado en el mensaje de error, sabe que la declaración
de devolución en spam() está causando un error.
72 Capítulo 3
Machine Translated by Google
Los errores se pueden manejar con sentencias try y except . El código que potencialmente
podría tener un error se coloca en una cláusula de prueba . La ejecución del programa se mueve
al comienzo de una siguiente cláusula excepto si ocurre un error.
Puede colocar el código de división por cero anterior en una cláusula de prueba y hacer que
una cláusula de excepción contenga código para manejar lo que sucede cuando se produce este error.
imprimir (correo no deseado (2))
imprimir (correo no deseado (12))
imprimir (correo no deseado (0))
imprimir (correo no deseado (1))
Ninguna
Funciones 73
Machine Translated by Google
La razón por la que print(spam(1)) nunca se ejecuta es porque una vez que la ejecución salta al
código en la cláusula de excepción , no vuelve al intento .
cláusula. En cambio, simplemente continúa moviéndose hacia abajo normalmente.
Un programa corto: adivina el número
Los ejemplos de juguetes que te he mostrado hasta ahora son útiles para introducir conceptos básicos,
pero ahora veamos cómo todo lo que has aprendido se une en un programa más completo. En esta
sección, te mostraré un juego simple de “adivina el número”. Cuando ejecute este programa, la salida se
verá así:
Estoy pensando en un número entre 1 y 20.
Adivina.
Adivina.
15
Adivina.
17
Adivina.
¡Buen trabajo! ¡Adivinaste mi número en 4 intentos!
# Este es un juego de adivinanzas.
importar al azar
númerosecreto = random.randint(1, 20)
print('Estoy pensando en un número entre 1 y 20.')
# Pídele al jugador que adivine 6 veces.
para conjeturas tomadas en el rango (1, 7):
print('Adivina.')
adivinar = int(entrada())
si adivinar <secretNumber:
print('Su conjetura es demasiado baja.')
elif conjetura > numerosecreto:
print('Su conjetura es demasiado alta.')
más:
# ¡Esta condición es la conjetura correcta!
if adivinar == numerosecreto:
'
print('¡Buen trabajo! Adivinaste mi número en else:
+ str(conjeturasrealizadas) + '¡conjeturas!')
print('Nop. El número en el que estaba pensando era
74 Capítulo 3
'
+ str(númerosecreto))
Machine Translated by Google
Veamos este código línea por línea, comenzando desde arriba.
# Este es un juego de adivinanzas.
importar al azar
númerosecreto = random.randint(1, 20)
Primero, un comentario en la parte superior del código explica lo que hace el
programa. Luego, el programa importa el módulo aleatorio para que pueda usar la
función random.randint() para generar un número para que el usuario lo adivine. El
valor de retorno, un entero aleatorio entre 1 y 20, se almacena en la variable
secretNumber.
print('Estoy pensando en un número entre 1 y 20.')
# Pídele al jugador que adivine 6 veces.
para conjeturas tomadas en el rango (1, 7):
print('Adivina.')
adivinar = int(entrada())
El programa le dice al jugador que ha encontrado un número secreto y le dará al
jugador seis oportunidades para adivinarlo. El código que le permite al jugador ingresar
una suposición y verificar esa suposición está en un bucle for que se repetirá como
máximo seis veces. Lo primero que sucede en el bucle es que el jugador escribe una
suposición. Dado que input() devuelve una cadena, su valor devuelto se pasa directamente
a int(), que convierte la cadena en un valor entero. Esto se almacena en una variable
llamada adivinar.
si adivinar <secretNumber:
print('Su conjetura es demasiado baja.')
elif conjetura > numerosecreto:
print('Su conjetura es demasiado alta.')
Estas pocas líneas de código verifican si la conjetura es menor o mayor que el
número secreto. En cualquier caso, se imprime una pista en la pantalla.
más:
descanso
# ¡Esta condición es la conjetura correcta!
Si la conjetura no es ni mayor ni menor que el número secreto, entonces
debe ser igual al número secreto, en cuyo caso desea que la ejecución del programa
salga del bucle for .
if adivinar == numerosecreto:
print('¡Buen trabajo! Adivinaste mi número en else:
print('Nop. El número en el que estaba pensando era
'
+ str(conjeturasrealizadas) + '¡conjeturas!')
'
+ str(númerosecreto))
Después del ciclo for , la instrucción if...else anterior verifica si el jugador ha
adivinado correctamente el número e imprime un mensaje apropiado en la pantalla. En
ambos casos, el programa muestra una variable que contiene
Funciones 75
Machine Translated by Google
un valor entero (conjeturas realizadas y número secreto). Dado que debe concatenar estos
valores enteros en cadenas, pasa estas variables a la función str() , que devuelve la forma de
valor de cadena de estos enteros. Ahora estas cadenas se pueden concatenar con los operadores
+ antes de pasar finalmente a la llamada a la función print() .
Resumen
Las funciones son la forma principal de compartimentar su código en grupos lógicos. Dado que
las variables de las funciones existen en sus propios ámbitos locales, el código de una función
no puede afectar directamente a los valores de las variables de otras funciones. Esto limita qué
código podría estar cambiando los valores de sus variables, lo que puede ser útil cuando se
trata de depurar su código.
Las funciones son una gran herramienta para ayudarte a organizar tu código. Puede
pensar en ellos como cajas negras: tienen entradas en forma de parámetros y salidas en
forma de valores de retorno, y el código que contienen no afecta las variables en otras
funciones.
En los capítulos anteriores, un solo error podría hacer que sus programas fallaran.
En este capítulo, aprendió acerca de las sentencias try y except , que pueden ejecutar código
cuando se detecta un error. Esto puede hacer que sus programas sean más resistentes a los
casos de error comunes.
Preguntas de práctica
1. ¿Por qué es ventajoso tener funciones en sus programas?
2. ¿Cuándo se ejecuta el código en una función? Cuando la función es
definido o cuando se llama a la función?
3. ¿Qué enunciado crea una función?
4. ¿Cuál es la diferencia entre una función y una llamada de función?
5. ¿Cuántos alcances globales hay en un programa de Python? ¿Cuántos ámbitos locales?
6. ¿Qué sucede con las variables en un ámbito local cuando regresa la llamada a la función?
7. ¿Qué es un valor de retorno? ¿Puede un valor de retorno ser parte de una expresión?
8. Si una función no tiene declaración de retorno, ¿cuál es el valor de retorno?
de una llamada a esa función?
9. ¿Cómo puedes forzar una variable en una función para que se refiera a la variable global?
10. ¿Cuál es el tipo de datos de Ninguno?
11. ¿Qué hace la declaración de import areallyourpetsnamederic ?
12. Si tuviera una función llamada bacon() en un módulo llamado spam, ¿cómo
¿Lo llamarías después de importar spam?
13. ¿Cómo puede evitar que un programa se bloquee cuando recibe un error?
14. ¿Qué incluye la cláusula de prueba ? ¿Qué va en la cláusula excepto ?
76 Capítulo 3
Machine Translated by Google
Proyectos de práctica
Para practicar, escriba programas para realizar las siguientes tareas.
La secuencia de Collatz
Escribe una función llamada collatz() que tenga un parámetro llamado número. Si el número es par,
collatz() debería imprimir el número // 2 y devolver este valor.
Si el número es impar, collatz() debería imprimir y devolver 3
* número + 1.
Luego escriba un programa que le permita al usuario escribir un número entero y que mantenga
llamando a collatz() en ese número hasta que la función devuelva el valor 1.
(Sorprendentemente, esta secuencia en realidad funciona para cualquier número entero; tarde o
temprano, usando esta secuencia, ¡llegará a 1! Incluso los matemáticos no están seguros de por
qué. Su programa está explorando lo que se llama la secuencia de Collatz, a veces llamada "la el
problema matemático más simple e imposible”).
Recuerde convertir el valor de retorno de input() a un número entero con la función int() ; de
lo contrario, será un valor de cadena.
Pista: Un número entero es par si el número % 2 == 0, y es impar si el número % 2
== 1.
La salida de este programa podría verse así:
dieciséis
Validación de entrada
Agregue declaraciones de prueba y excepción al proyecto anterior para detectar si el usuario escribe
una cadena no entera. Normalmente, la función int() generará un error ValueError si se pasa una
cadena no entera, como en int('cachorro'). En la cláusula de excepción , imprima un mensaje para
el usuario que indique que debe ingresar un número entero.
Funciones 77
Machine Translated by Google
Machine Translated by Google
4
L es ts
Un tema más que deberá comprender antes de
poder comenzar a escribir programas en serio
es el tipo de datos de lista y su primo, la tupla.
Las listas y tuplas pueden contener múltiples
valores, lo que facilita la escritura de programas que
manejan grandes cantidades de datos. Y dado que las
listas en sí mismas pueden contener otras listas, puede
usarlas para organizar datos en estructuras jerárquicas.
En este capítulo, discutiré los conceptos básicos de las listas. También te enseñaré
sobre los métodos, que son funciones que están vinculadas a valores de cierto tipo de datos.
Luego, cubriré brevemente los tipos de datos de cadena y tupla tipo lista y cómo se
comparan con los valores de la lista. En el próximo capítulo, le presentaré el tipo de datos
del diccionario.
Machine Translated by Google
El tipo de datos de lista
Una lista es un valor que contiene varios valores en una secuencia ordenada. El
término valor de lista se refiere a la lista en sí (que es un valor que se puede almacenar
en una variable o pasar a una función como cualquier otro valor), no a los valores dentro
del valor de lista. Un valor de lista se ve así: ['gato', 'murciélago', 'rata', 'elefante'].
Así como los valores de cadena se escriben con comillas para marcar dónde
comienza y termina la cadena, una lista comienza con un corchete de apertura y
termina con un corchete de cierre, []. Los valores dentro de la lista también se
denominan elementos. Los elementos se separan con comas (es decir, están delimitados por comas).
Por ejemplo, ingrese lo siguiente en el shell interactivo:
>>> [1, 2, 3]
[1, 2, 3]
>>> ['gato', 'murciélago', 'rata', 'elefante']
['gato', 'murciélago', 'rata', 'elefante']
>>> ['hola', 3.1415, Verdadero, Ninguno, 42]
['hola', 3.1415, Verdadero, Ninguno, 42]
u >>> spam = ['gato', 'murciélago', 'rata', 'elefante']
>>> correo no deseado
['gato', 'murciélago', 'rata', 'elefante']
A la variable de spam u todavía se le asigna un solo valor: el valor de lista. Pero
el valor de la lista en sí contiene otros valores. El valor [] es una lista vacía que no
contiene valores, similar a '', la cadena vacía.
Obtener valores individuales en una lista con índices
Digamos que tiene la lista ['gato', 'murciélago', 'rata', 'elefante'] almacenada en una
variable llamada spam. El código Python spam[0] se evaluaría como 'gato' y spam[1]
se evaluaría como 'murciélago', y así sucesivamente.
spam = ["gato", "murciélago", "rata", "elefante"]
El número entero entre corchetes que
sigue a la lista se llama índice. El primer
valor de la lista está en el índice 0, el
spam[0] spam[1] spam[2] spam[3]
segundo valor está en el índice 1, el
Figura 4-1: Un valor de lista almacenado en la
tercer valor está en el índice 2 y así
variable spam, que muestra a qué valor se
sucesivamente. La figura 4-1 muestra un
refiere cada índice
valor de lista asignado al spam, junto con
lo que evaluarían las expresiones de índice.
Por ejemplo, escriba las siguientes expresiones en el shell interactivo.
Comience asignando una lista a la variable spam.
>>> spam = ['gato', 'murciélago', 'rata', 'elefante']
>>> correo no deseado[0]
'gato'
>>> correo no deseado[1]
'murciélago'
>>> correo no deseado[2]
'rata'
>>> correo no deseado[3]
'elefante'
80 Capítulo 4
Machine Translated by Google
>>> ['gato', 'murciélago', 'rata', 'elefante'][3]
'elefante'
u >>> 'Hola' v 'Hola + correo no deseado[0]
gato'
>>> 'El ' + spam[1] + 'El
'
comió el
'
+ correo no deseado[0] + '.'
murciélago se comió al gato.'
+ spam[0] u se evalúa como 'Hola'
Tenga en cuenta que la expresión
'Hola' 'gato' porque spam[0] se evalúa como la cadena 'gato'. Esta expresión, a su
vez, se evalúa como el valor de cadena 'Hello cat' v.
Python le dará un mensaje de error IndexError si usa un índice que excede
la cantidad de valores en el valor de su lista.
+
>>> spam = ['gato', 'murciélago', 'rata', 'elefante']
>>> spam[10000]
Rastreo (llamadas recientes más última):
Archivo "<pyshell#9>", línea 1, en <módulo>
spam[10000]
IndexError: índice de lista fuera de rango
Los índices solo pueden ser valores enteros, no flotantes. El siguiente ejemplo
provocará un error TypeError :
>>> spam = ['gato', 'murciélago', 'rata', 'elefante']
>>> correo no deseado[1]
'murciélago'
>>> correo no deseado[1.0]
Rastreo (llamadas recientes más última):
Archivo "<pyshell#13>", línea 1, en <módulo>
correo no deseado[1.0]
TypeError: los índices de la lista deben ser enteros, no flotantes
>>> spam[int(1.0)]
'murciélago'
Las listas también pueden contener otros valores de lista. Los valores en estas listas de listas
se puede acceder usando múltiples índices, así:
>>> spam = [['gato', 'murciélago'], [10, 20, 30, 40, 50]]
>>> correo no deseado[0]
['gato', 'murciélago']
>>> spam[0][1]
'murciélago'
>>> spam[1][4]
50
El primer índice dicta qué valor de lista usar, y el segundo indica
el valor dentro del valor de la lista. Por ejemplo, spam[0][1] imprime 'bat', el segundo
valor de la primera lista. Si solo usa un índice, el programa imprimirá el valor de la
lista completa en ese índice.
Listas 81
Machine Translated by Google
Índices negativos
Si bien los índices comienzan en 0 y aumentan, también puede usar números enteros
negativos para el índice. El valor entero -1 se refiere al último índice de una lista, el valor -2
hace referencia al penúltimo índice de una lista, y así sucesivamente. Ingrese lo
siguiente en el shell interactivo:
>>> spam = ['gato', 'murciélago', 'rata', 'elefante']
>>> correo no deseado[-1]
'elefante'
>>> correo no deseado[-3]
'murciélago'
>>> 'El '
+ spam[-1] + 'El
'
tiene miedo de la
'
+ correo no deseado[-3] + '.'
elefante le tiene miedo al murciélago.'
Obtener sublistas con rebanadas
Así como un índice puede obtener un solo valor de una lista, un segmento puede obtener
varios valores de una lista, en forma de una nueva lista. Un segmento se escribe entre
corchetes, como un índice, pero tiene dos enteros separados por dos puntos. Observe la
diferencia entre índices y sectores.
• spam[2] es una lista con un índice (un entero).
• spam[1:4] es una lista con un segmento (dos enteros).
En un segmento, el primer entero es el índice donde comienza el segmento. El segundo
entero es el índice donde termina el segmento. Un segmento sube hasta el valor del
segundo índice, pero no lo incluye. Un segmento se evalúa como un nuevo valor de lista.
Ingrese lo siguiente en el shell interactivo:
>>> spam = ['gato', 'murciélago', 'rata', 'elefante']
>>> correo no deseado[0:4]
['gato', 'murciélago', 'rata', 'elefante']
>>> correo no deseado[1:3]
['murciélago', 'rata']
>>> spam[0:-1]
['gato', 'murciélago', 'rata']
Como método abreviado, puede omitir uno o ambos índices a cada lado de los dos
puntos en el sector. Omitir el primer índice es lo mismo que usar 0, o el comienzo de la lista.
Omitir el segundo índice es lo mismo que usar la longitud de la lista, que se dividirá hasta
el final de la lista. Ingrese lo siguiente en el shell interactivo:
>>> spam = ['gato', 'murciélago', 'rata', 'elefante']
>>> correo no deseado[:2]
['gato', 'murciélago']
>>> spam[1:]
['murciélago', 'rata', 'elefante']
82 Capítulo 4
Machine Translated by Google
>>> correo no deseado[:]
['gato', 'murciélago', 'rata', 'elefante']
Obtener la longitud de una lista con len()
La función len() devolverá la cantidad de valores que se encuentran en un valor de lista
que se le pasó, al igual que puede contar la cantidad de caracteres en un valor de cadena.
Ingrese lo siguiente en el shell interactivo:
>>> spam = ['gato', 'perro', 'alce']
>>> len(correo no deseado)
3
Cambio de valores en una lista con índices
Normalmente, un nombre de variable va en el lado izquierdo de una declaración de
asignación, como spam = 42. Sin embargo, también puede usar un índice de una lista
para cambiar el valor en ese índice. Por ejemplo, spam[1] = 'aardvark' significa "Asigne el
valor en el índice 1 en la lista spam a la cadena 'aardvark'". Ingrese lo siguiente en el shell
interactivo:
>>> spam = ['gato', 'murciélago', 'rata', 'elefante']
>>> spam[1] = 'oso hormiguero'
>>> correo no deseado
['gato', 'oso hormiguero', 'rata', 'elefante']
>>> correo no deseado[2] = correo no deseado[1]
>>> correo no deseado
['gato', 'oso hormiguero', 'oso hormiguero', 'elefante']
>>> spam[-1] = 12345
>>> correo no deseado
['gato', 'oso hormiguero', 'oso hormiguero', 12345]
Concatenación de listas y replicación de listas
El operador + puede combinar dos listas para crear un nuevo valor de lista de la misma
manera que combina dos cadenas en un nuevo valor de cadena. El ospeepraudeodre*utasamrbciéon
una lista y un valor entero para replicar la lista. Ingrese lo siguiente en el shell interactivo:
>>> [1, 2, 3] + ['A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C']
>>> ['X', 'Y', 'Z'] * 3
['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']
>>> spam = [1, 2, 3]
>>> spam = spam + ['A', 'B', 'C']
>>> correo no deseado
[1, 2, 3, 'A', 'B', 'C']
Listas 83
Machine Translated by Google
Eliminación de valores de listas con declaraciones del
La declaración del eliminará valores en un índice en una lista. Todos los valores de la
lista después del valor eliminado se moverán un índice hacia arriba. Por ejemplo, ingrese lo
siguiente en el shell interactivo:
>>> spam = ['gato', 'murciélago', 'rata', 'elefante']
>>> del correo no deseado[2]
>>> correo no deseado
['gato', 'murciélago', 'elefante']
>>> del correo no deseado[2]
>>> correo no deseado
['gato', 'murciélago']
La declaración del también se puede usar en una variable simple para eliminarla,
como si fuera una declaración de "desasignación". Si intenta usar la variable después de
eliminarla, obtendrá un error NameError porque la variable ya no existe.
En la práctica, casi nunca necesita eliminar variables simples. el del
La declaración se usa principalmente para eliminar valores de las listas.
Trabajar con listas
Cuando comienza a escribir programas por primera vez, es tentador crear muchas
variables individuales para almacenar un grupo de valores similares. Por ejemplo, si quisiera
almacenar los nombres de mis gatos, podría tener la tentación de escribir un código como este:
nombregato1 = 'Zophie'
nombregato2 = 'Pooka'
catName3 = 'Simón'
catName4 = 'Lady Macbeth'
catName5 = 'Cola gorda'
catName6 = 'Señorita Cleo'
(En realidad no tengo tantos gatos, lo juro). Resulta que esta es una mala manera de
escribir código. Por un lado, si el número de gatos cambia, su programa nunca podrá
almacenar más gatos que las variables que tiene. Estos tipos de programas también tienen
mucho código duplicado o casi idéntico. Considere cuánto código duplicado hay en el
siguiente programa, que debe ingresar en el editor de archivos y guardar como allMyCats1.py:
print('Ingrese el nombre del gato 1:')
nombregato1 = entrada()
print('Ingrese el nombre del gato 2:')
nombregato2 = entrada()
print('Ingrese el nombre del gato 3:')
nombregato3 = entrada()
print('Ingrese el nombre del gato 4:')
nombreCat4 = entrada()
print('Ingrese el nombre del gato 5:')
nombreGato5 = entrada()
84 Capítulo 4
Machine Translated by Google
print('Ingrese el nombre del gato 6:')
nombreGato6 = entrada()
print('Los nombres de los' gatos
son:')
'
'
print(nombreGato1 + + NombreGato2 +
'
'
+ nombregato3 +
'
'
+ nombregato4 +
'
'
+
'
NombreGato5 + + NombreGato6)
En lugar de usar varias variables repetitivas, puede usar una sola variable
que contenga un valor de lista. Por ejemplo, aquí hay una versión nueva y mejorada
del programa allMyCats1.py . Esta nueva versión utiliza una sola lista y puede almacenar
cualquier número de gatos que el usuario escriba. En una nueva ventana del editor de
archivos, escriba el siguiente código fuente y guárdelo como allMyCats2.py:
nombres de gato = []
mientras que es cierto:
print('Ingrese el nombre del gato
'
+ str(len(nombresdegato) + 1) +
' (O no introduzca nada para detener.):')
nombre = entrada()
si nombre == '':
descanso
catNames = catNames + [nombre] # lista de concatenación
print('Los nombres de los gatos son:')
para nombre en catNames:
impresión(' '
+ nombre)
Cuando ejecute este programa, la salida se verá así:
Ingrese el nombre del gato 1 (o no ingrese nada para detenerlo):
Zophie
Ingrese el nombre del gato 2 (o no ingrese nada para detenerlo):
Pooka
Ingrese el nombre del gato 3 (o no ingrese nada para detenerlo):
Simón
Ingrese el nombre del gato 4 (o no ingrese nada para detenerlo):
Señora Macbeth
Ingrese el nombre del gato 5 (o no ingrese nada para detenerlo):
cola gorda
Ingrese el nombre del gato 6 (o no ingrese nada para detenerlo):
Señorita Cleo
Ingrese el nombre del gato 7 (o no ingrese nada para detenerlo):
Los nombres de los gatos son:
Zophie
Pooka
Simón
Señora Macbeth
cola gorda
Señorita Cleo
El beneficio de usar una lista es que sus datos ahora están en una estructura, por
lo que su programa es mucho más flexible en el procesamiento de datos de lo que sería
con varias variables repetitivas.
Listas 85
Machine Translated by Google
Uso de bucles for con listas
En el Capítulo 2, aprendió sobre el uso de bucles for para ejecutar un bloque de
código un cierto número de veces. Técnicamente, un ciclo for repite el bloque de
código una vez para cada valor en una lista o valor similar a una lista. Por ejemplo, si
ejecutó este código:
para i en el rango (4):
imprimir (yo)
0
1
2
para i en [0, 1, 2, 3]:
imprimir (yo)
>>> suministros = ['bolígrafos', 'grapadoras', 'lanzallamas', 'carpetas']
>>> for i in range(len(suministros)):
'
'
imprimir('Índice' + str(i) +
en suministros es:
+ suministros[i])
El índice 1 en suministros es: grapadoras
El índice 2 en suministros es: lanzallamas
El índice 3 en suministros es: aglutinantes
Usar range(len(supplies)) en el ciclo for mostrado anteriormente es útil porque
el código en el ciclo puede acceder al índice (como la variable i) y al valor en ese
índice (como suministros[i]). Lo mejor de todo es que range(len(supplies)) iterará a
través de todos los índices de suministros, sin importar cuántos elementos contenga.
86 Capítulo 4
Machine Translated by Google
Los operadores in y not in
Puede determinar si un valor está o no en una lista con el en y no en
operadores. Al igual que otros operadores, in y not in se usan en expresiones y conectan
dos valores: un valor para buscar en una lista y la lista donde se puede encontrar. Estas
expresiones se evaluarán como un valor booleano. Ingrese lo siguiente en el shell interactivo:
>>> 'hola' en ['hola', 'hola', 'hola', 'hola']
Verdadero
>>> spam = ['hola', 'hola', 'hola', 'hola']
>>> 'gato' en spam
Falso
>>> 'hola' no en spam
Falso
>>> 'gato' no en spam
Verdadero
Por ejemplo, el siguiente programa le permite al usuario escribir el nombre de una
mascota y luego verifica si el nombre está en una lista de mascotas. Abra una nueva ventana
del editor de archivos, ingrese el siguiente código y guárdelo como myPets.py:
myPets = ['Zophie', 'Pooka', 'Cola Gorda']
si el nombre no está en myPets:
print('No tengo una mascota con otro
nombre:
'
imprimir(nombre +
'
es mi mascota.')
La salida puede ser algo como esto:
Introduzca un nombre de mascota:
No tengo una mascota llamada Footfoot
El truco de la asignación múltiple es un atajo que le permite asignar múltiples variables
con los valores de una lista en una línea de código. Así que en lugar de hacer esto:
>>> gato = ['gordo', 'negro', 'ruidoso']
>>> tamaño = gato[0]
>>> color = gato[1]
>>> disposición = cat[2]
podría escribir esta línea de código:
>>> gato = ['gordo', 'negro', 'ruidoso']
>>> tamaño, color, disposición = gato
Listas 87
Machine Translated by Google
El número de variables y la longitud de la lista deben ser exactamente
iguales, o Python le dará un ValueError:
>>> gato = ['gordo', 'negro', 'ruidoso']
>>> tamaño, color, disposición, nombre = gato
Rastreo (llamadas recientes más última):
Archivo "<pyshell#84>", línea 1, en <módulo>
tamaño, color, disposición, nombre = gato
ValueError: necesita más de 3 valores para desempaquetar
Operadores de asignación aumentada
Al asignar un valor a una variable, con frecuencia utilizará la variable misma. Por
ejemplo, después de asignar 42 a la variable spam, aumentaría el valor de spam en
1 con el siguiente código:
>>> spam = 42
>>> correo no deseado = correo no deseado + 1
>>> correo no deseado
43
Como atajo, puede usar el operador de asignación aumentada += para hacer lo
mismo:
>>> spam = 42
>>> spam += 1
>>> correo no deseado
43
Hay operadores de asignación aumentada para los operadores +, -, *, / y % ,
que se describen en la Tabla 4-1.
Tabla 4-1: Los Operadores de Asignación Aumentada
Declaración de asignación aumentada
Declaración de asignación equivalente
correo no deseado = correo no deseado + 1
correo no deseado += 1
correo no deseado = correo no deseado - 1
correo no deseado -= 1
correo no deseado = correo no deseado
*1
corr eo no deseado
*= 1
correo no deseado = correo no deseado / 1
correo no deseado /= 1
correo no deseado = correo no deseado % 1
correo no deseado %= 1
El operador += también puede concatenar cadenas y listas, y el operador *=
El operador puede hacer replicación de cadenas y listas. Ingrese lo siguiente en
el shell interactivo:
>>> spam = 'Hola'
' ¡mundo!'
>>> correo no deseado +=
>>> correo no deseado
'¡Hola Mundo!'
88 Capítulo 4
Machine Translated by Google
>>> tocino = ['Zophie']
>>> tocino *= 3
>>> tocino
['Zophie', 'Zophie', 'Zophie']
Métodos
Un método es lo mismo que una función, excepto que se "invoca" un valor.
Por ejemplo, si el valor de una lista se almacenara en correo no deseado, llamaría a index()
método de lista (que explicaré a continuación) en esa lista así: spam.index('hola').
La parte del método viene después del valor, separada por un punto.
Cada tipo de datos tiene su propio conjunto de métodos. El tipo de datos
de lista, por ejemplo, tiene varios métodos útiles para buscar, agregar, eliminar y
manipular valores en una lista.
Encontrar un valor en una lista con el método index()
Los valores de lista tienen un método index() al que se le puede pasar un valor y, si
ese valor existe en la lista, se devuelve el índice del valor. Si el valor no está en la
lista, Python genera un error ValueError . Ingrese lo siguiente en el shell interactivo:
>>> spam = ['hola', 'hola', 'hola', 'hola']
>>> spam.index('hola')
0
>>> spam.index('hola')
3
>>> spam.index('hola hola hola')
Rastreo (llamadas recientes más última):
Archivo "<pyshell#31>", línea 1, en <módulo>
spam.index('hola hola hola')
ValueError: 'hola, hola, hola' no está en la lista
Cuando hay duplicados del valor en la lista, se devuelve el índice de su primera
aparición. Ingrese lo siguiente en el shell interactivo y observe que index() devuelve
1, no 3:
>>> spam = ['Zophie', 'Pooka', 'Fat-tail', 'Pooka']
>>> spam.index('Pooka')
1
Agregar valores a las listas con los métodos append() e insert()
Para agregar nuevos valores a una lista, use los métodos append() e insert() . Ingrese
lo siguiente en el shell interactivo para llamar al método append() en un valor de lista
almacenado en la variable spam:
>>> spam = ['gato', 'perro', 'murciélago']
>>> spam.append('alce')
Listas 89
Machine Translated by Google
>>> correo no deseado
['gato', 'perro', 'murciélago', 'alce']
La llamada anterior al método append() agrega el argumento al final de la lista.
El método insert() puede insertar un valor en cualquier índice de la lista.
El primer argumento de insert() es el índice del nuevo valor y el segundo argumento
es el nuevo valor que se va a insertar. Ingrese lo siguiente en el shell interactivo:
>>> spam = ['gato', 'perro', 'murciélago']
>>> spam.insertar(1, 'pollo')
>>> correo no deseado
['gato', 'pollo', 'perro', 'murciélago']
Tenga en cuenta que el código es spam.append('moose') y spam.insert(1,
'chicken'), no spam = spam.append('moose') y spam = spam.insert(1, 'chicken'). Ni
append() ni insert() dan el nuevo valor de spam como su valor de retorno. (De hecho, el
valor de retorno de append() e insert() es Ninguno, por lo que definitivamente no querrá
almacenarlo como el nuevo valor de la variable). Más bien, la lista se modifica en su
lugar. La modificación de una lista en su lugar se trata con más detalle más adelante en
"Tipos de datos mutables e inmutables" en la página 94.
Los métodos pertenecen a un solo tipo de datos. Los métodos append() e insert()
son métodos de lista y solo se pueden llamar en valores de lista, no en otros valores
como cadenas o enteros. Ingrese lo siguiente en el shell interactivo y observe los
mensajes de error de AttributeError que aparecen:
>>> huevos = 'hola'
>>> huevos.append('mundo')
Rastreo (llamadas recientes más última):
Archivo "<pyshell#19>", línea 1, en <módulo>
huevos.append('mundo')
AttributeError: el objeto 'str' no tiene atributo 'append'
>>> tocino = 42
>>> tocino.insertar(1, 'mundo')
Rastreo (llamadas recientes más última):
Archivo "<pyshell#22>", línea 1, en <módulo>
tocino.insertar(1, 'mundo')
AttributeError: el objeto 'int' no tiene atributo 'insertar'
Eliminación de valores de listas con remove()
Al método remove() se le pasa el valor que se eliminará de la lista a la que se llama.
Ingrese lo siguiente en el shell interactivo:
>>> spam = ['gato', 'murciélago', 'rata', 'elefante']
>>> spam.remove('murciélago')
>>> correo no deseado
['gato', 'rata', 'elefante']
90 Capítulo 4
Machine Translated by Google
Intentar eliminar un valor que no existe en la lista dará como resultado un error
ValueError . Por ejemplo, ingrese lo siguiente en el shell interactivo y observe el error
que se muestra:
>>> spam = ['gato', 'murciélago', 'rata', 'elefante']
>>> spam.remove('pollo')
Rastreo (llamadas recientes más última):
Archivo "<pyshell#11>", línea 1, en <módulo>
spam.remove('pollo')
ValueError: list.remove(x): x no está en la lista
Si el valor aparece varias veces en la lista, solo la primera instancia de
el valor será eliminado. Ingrese lo siguiente en el shell interactivo:
>>> spam = ['gato', 'murciélago', 'rata', 'gato', 'sombrero',
'gato'] >>> spam.remove('gato') >>> spam ['murciélago', 'rata',
'gato', 'sombrero', 'gato']
La declaración del es buena para usar cuando conoce el índice del valor
desea eliminar de la lista. El método remove() es bueno cuando sabe el valor que
desea eliminar de la lista.
Ordenar los valores en una lista con el método sort()
Las listas de valores numéricos o las listas de cadenas se pueden ordenar con
el método sort() . Por ejemplo, ingrese lo siguiente en el shell interactivo:
>>> spam = [2, 5, 3.14, 1, -7] >>>
spam.sort() >>> spam [-7, 1, 2,
3.14, 5] >>> spam = ['hormigas' ,
'gatos', 'perros', 'tejones',
'elefantes'] >>> spam.sort() >>> spam ['hormigas', 'tejones', 'gatos',
'perros', 'elefantes']
También puede pasar True para el argumento de palabra clave inversa para
que sort() ordene los valores en orden inverso. Ingrese lo siguiente en el shell interactivo:
>>> spam.sort(reverse=True)
>>> spam
['elefantes', 'perros', 'gatos', 'tejones', 'hormigas']
Hay tres cosas que debe tener en cuenta sobre el método sort() . Primero,
el método sort() ordena la lista en su lugar; no intente capturar el valor de retorno
escribiendo código como spam = spam.sort().
Listas 91
Machine Translated by Google
En segundo lugar, no puede ordenar listas que tengan tanto valores numéricos como
valores de cadena, ya que Python no sabe cómo comparar estos valores.
Escriba lo siguiente en el shell interactivo y observe el error TypeError :
>>> spam = [1, 3, 2, 4, 'Alicia', 'Bob']
>>> spam.ordenar()
Rastreo (llamadas recientes más última):
Archivo "<pyshell#70>", línea 1, en <módulo>
spam.ordenar()
TypeError: tipos no ordenados: str() < int()
En tercer lugar, sort() utiliza el "orden ASCIIbético" en lugar del orden alfabético real.
orden para ordenar las cadenas. Esto significa que las letras mayúsculas van antes que las
minúsculas. Por lo tanto, la a minúscula se ordena de modo que viene después de la Z
mayúscula . Por ejemplo, ingrese lo siguiente en el shell interactivo:
>>> spam = ['Alice', 'hormigas', 'Bob', 'tejones', 'Carol', 'gatos']
>>> spam.ordenar()
>>> correo no deseado
['Alice', 'Bob', 'Carol', 'hormigas', 'tejones', 'gatos']
Si necesita ordenar los valores en orden alfabético regular, pase str.
inferior para el argumento de palabra clave clave en la llamada al método sort() .
>>> spam = ['a', 'z', 'A', 'Z']
>>> spam.sort(key=str.inferior)
>>> correo no deseado
['a', 'A', 'z', 'Z']
Esto hace que la función sort() trate todos los elementos de la lista como si fueran
estaban en minúsculas sin cambiar realmente los valores en la lista.
Programa de ejemplo: Magic 8 Ball con una lista
Usando listas, puede escribir una versión mucho más elegante del programa Magic 8 Ball del
capítulo anterior. En lugar de varias líneas de elif casi idénticas
declaraciones, puede crear una sola lista con la que funcione el código. Abra una nueva ventana del
editor de archivos e ingrese el siguiente código. Guárdelo como magic8Ball2.py.
importar al azar
mensajes = ['Es cierto',
'Es decididamente así',
'Sí definitivamente',
'Respuesta confusa, intenta otra vez',
'Pregunta de nuevo más tarde',
'Concéntrate y pregunta otra vez',
'Mi respuesta es no',
'Perspectivas no tan buenas',
'Muy dudoso']
imprimir (mensajes [random.randint (0, len (mensajes) - 1)])
92 Capítulo 4
Machine Translated by Google
Cuando ejecutes este programa, verás que funciona igual que el
anterior programa magic8Ball.py .
Observe la expresión que usa como índice en los mensajes: aleatorio
.randint(0, len(mensajes) - 1). Esto produce un número aleatorio para usar en el índice, independientemente
del tamaño de los mensajes. Es decir, obtendrá un número aleatorio entre 0 y el valor de len (mensajes) - 1.
El beneficio de este enfoque es que puede agregar y eliminar fácilmente cadenas a los mensajes .
lista sin cambiar otras líneas de código. Si luego actualiza su código, habrá menos líneas
que tendrá que cambiar y menos posibilidades de que introduzca errores.
Tipos tipo lista: cadenas y tuplas
Las listas no son los únicos tipos de datos que representan secuencias ordenadas de valores.
Por ejemplo, las cadenas y las listas son realmente similares, si considera que una cadena es
una "lista" de caracteres de texto únicos. Muchas de las cosas que puede hacer con las listas
Listas 93
Machine Translated by Google
también se puede hacer con cadenas: indexación; rebanar; y usarlos con para
bucles, con len(), y con los operadores in y not in . Para ver esto, ingrese lo siguiente en el shell
interactivo:
>>> nombre = 'Zophie'
>>> nombre[0]
'Z'
>>> nombre[-2]
'i'
'Zoph'
>>> 'Zo' en nombre
Verdadero
>>> 'z' en el nombre
Falso
>>> 'p' no en nombre
Falso
>>> para i en nombre:
impresión('* * * '
+ yo + '* * *')
***Z***
p***h***
***i***
Tipos de datos mutables e inmutables
Pero las listas y las cadenas son diferentes de una manera importante. Un valor de lista es mutable
tipo de datos: Puede tener valores agregados, eliminados o cambiados. Sin embargo, una cadena
es inmutable: no se puede cambiar. Intentar reasignar un solo carácter en una cadena da como
resultado un error TypeError , como puede ver ingresando lo siguiente en el shell interactivo:
>>> nombre = 'Zophie un gato'
>>> nombre[7] = 'el'
Rastreo (llamadas recientes más última):
Archivo "<pyshell#50>", línea 1, en <módulo>
nombre[7] = 'el'
TypeError: el objeto 'str' no admite la asignación de elementos
La forma correcta de "mutar" una cadena es usar el corte y la concatenación
para construir una nueva cadena copiando partes de la cadena anterior. Ingrese lo siguiente en
el shell interactivo:
>>> nombre = 'Zophie un gato'
>>> nuevoNombre = nombre[0:7] + 'el' + nombre[8:12]
>>> nombre
'Zophie un gato'
94 Capítulo 4
Machine Translated by Google
>>> nuevoNombre
'Zophie el gato'
Usamos [0:7] y [8:12] para referirnos a los caracteres que no deseamos
para reemplazar. Tenga en cuenta que la cadena original 'Zophie a cat' no se modifica
porque las cadenas son inmutables.
Aunque un valor de lista es mutable, la segunda línea del siguiente código no
modifica los huevos de lista:
>>> huevos = [1, 2, 3]
>>> huevos = [4, 5, 6]
>>> huevos
[4, 5, 6]
El valor de lista en huevos no se cambia aquí; más bien, un valor de lista
completamente nuevo y diferente ([4, 5, 6]) está sobrescribiendo el valor de lista anterior ([1, 2, 3]).
Esto se representa en la Figura 4-2.
Si quisiera modificar la lista original en huevos para que contuviera [4, 5, 6],
tendría que hacer algo como esto:
>>> huevos = [1, 2, 3]
>>> del huevo[2]
>>> del huevo[1]
>>> del huevo[0]
>>> huevos.append(4)
>>> huevos.append(5)
>>> huevos.append(6)
>>> huevos
[4, 5, 6]
Figura 4-2: Cuando se ejecuta huevos = [4, 5, 6] , el contenido de los huevos se reemplaza con un
nuevo valor de lista.
En el primer ejemplo, el valor de lista con el que termina huevos es el mismo valor
de lista con el que comenzó. Es solo que esta lista ha sido modificada, en lugar de
sobrescrita. La figura 4-3 muestra los siete cambios realizados por las primeras siete
líneas en el ejemplo de shell interactivo anterior.
Listas 95
Machine Translated by Google
Figura 4-3: La instrucción del y el método append() modifican el mismo valor de lista en su
lugar.
Cambiar un valor de un tipo de datos mutable (como lo que la instrucción del
y el método append() en el ejemplo anterior) cambia el valor en su lugar, ya que
el valor de la variable no se reemplaza con un nuevo valor de lista.
Los tipos mutables frente a los inmutables pueden parecer una distinción
sin sentido, pero "Pasar referencias" en la página 100 explicará el comportamiento
diferente al llamar a funciones con argumentos mutables frente a argumentos de
tabla inmutables. Pero primero, averigüemos sobre el tipo de datos de tupla, que es
una forma inmutable del tipo de datos de lista.
El tipo de datos de tupla
El tipo de datos de tupla es casi idéntico al tipo de datos de lista, excepto en dos
formas. En primer lugar, las tuplas se escriben con paréntesis, ( y ), en lugar de
corchetes, [ y ]. Por ejemplo, ingrese lo siguiente en el shell interactivo:
>>> huevos = ('hola', 42, 0.5)
>>> huevos[0]
'Hola'
>>> huevos[1:3]
(42, 0.5)
>>> len(huevos)
3
Pero la diferencia principal entre las tuplas y las listas es que las tuplas,
como las cadenas, son inmutables. Los valores de las tuplas no pueden
modificarse, agregarse ni eliminarse. Ingrese lo siguiente en el shell interactivo y
observe el mensaje de error TypeError :
>>> huevos = ('hola', 42, 0.5)
>>> huevos[1] = 99
Rastreo (llamadas recientes más última):
Archivo "<pyshell#5>", línea 1, en <módulo>
huevos[1] = 99
TypeError: el objeto 'tuple' no admite la asignación de elementos
96 Capítulo 4
Machine Translated by Google
Si solo tiene un valor en su tupla, puede indicarlo colocando una coma final
después del valor entre paréntesis. De lo contrario, Python pensará que acaba de
escribir un valor entre paréntesis regulares. La coma es lo que le permite a Python saber
que este es un valor de tupla. (A diferencia de otros lenguajes de programación, en
Python está bien tener una coma final después del último elemento de una lista o tupla).
Ingrese las siguientes llamadas a la función type() en el shell interactivo para ver la
distinción:
>>> tipo(('hola',))
<clase 'tupla'>
>>> tipo(('hola'))
<clase 'str'>
Puede usar tuplas para transmitir a cualquier persona que lea su código que
no tiene la intención de que esa secuencia de valores cambie. Si necesita una
secuencia ordenada de valores que nunca cambie, use una tupla. Un segundo
beneficio de usar tuplas en lugar de listas es que, debido a que son inmutables y su
contenido no cambia, Python puede implementar algunas optimizaciones que hacen
que el código que usa tuplas sea un poco más rápido que el código que usa listas.
Conversión de tipos con las funciones list() y tuple()
Al igual que str(42) devolverá '42', la representación de cadena del entero 42, las
funciones list() y tuple() devolverán versiones de lista y tupla de los valores que se les
pasan. Ingrese lo siguiente en el shell interactivo y observe que el valor devuelto es de
un tipo de datos diferente al valor pasado:
>>> tupla(['gato', 'perro', 5])
('gato', 'perro', 5)
>>> lista(('gato', 'perro', 5))
['gato', 'perro', 5]
>>> lista('hola')
['Hola']
Convertir una tupla en una lista es útil si necesita una versión mutable de un valor
de tupla.
Referencias
Como ha visto, las variables almacenan cadenas y valores enteros. Ingrese lo
siguiente en el shell interactivo:
>>> spam = 42
>>> queso = spam
>>> spam = 100
>>> correo no deseado
100
>>> queso
42
Listas 97
Machine Translated by Google
Asigna 42 a la variable de correo no deseado y luego copia el valor en el correo no deseado
y asígnelo a la variable queso. Cuando luego cambias el valor en spam
a 100, esto no afecta el valor en queso. Esto se debe a que el spam y el queso
son variables diferentes que almacenan valores diferentes.
Pero las listas no funcionan de esta manera. Cuando asigna una lista a una variable, en
realidad está asignando una referencia de lista a la variable. Una referencia es un valor que
apunta a algún bit de datos, y una referencia de lista es un valor que apunta a una lista. Aquí hay un
código que hará que esta distinción sea más fácil de entender.
Ingrese esto en el shell interactivo:
u >>> spam = [0, 1, 2, 3, 4, 5]
v >>> queso = spam
w >>> queso[1] = '¡Hola!'
>>> correo no deseado
[0, '¡Hola!', 2, 3, 4, 5]
>>> queso
[0, '¡Hola!', 2, 3, 4, 5]
Esto podría parecerte extraño. El código cambió solo la lista de quesos , pero parece que
tanto la lista de quesos como la de spam han cambiado.
Cuando crea la lista u, le asigna una referencia en la variable spam . Pero la siguiente línea
v copia solo la referencia de la lista en spam a cheese, no el valor de la lista en sí. Esto significa
que los valores almacenados en spam y cheese ahora se refieren a la misma lista. Solo hay una lista
subyacente porque la lista en sí nunca se copió. Entonces, cuando modifica el primer elemento de
cheese w, está modificando la misma lista a la que se refiere el correo no deseado .
Recuerda que las variables son como cajas que contienen valores. Las figuras anteriores de
este capítulo muestran que las listas en los cuadros no son exactamente precisas porque las
variables de la lista en realidad no contienen listas, sino referencias .
a las listas. (Estas referencias tendrán números de identificación que Python usa internamente,
pero puede ignorarlos). Usando cuadros como metáfora de las variables, la Figura 4 -4 muestra
lo que sucede cuando se asigna una lista a la variable spam .
Figura 4-4: spam = [0, 1, 2, 3, 4, 5] almacena una
referencia a una lista, no a la lista real.
98 Capítulo 4
Machine Translated by Google
Luego, en la Figura 4-5, la referencia en spam se copia a cheese. Solo un nuevo
la referencia fue creada y almacenada en queso, no en una nueva lista. Note cómo ambas referencias
se refieren a la misma lista.
Figura 4-5: spam = cheese copia la referencia, no la lista.
Cuando modifica la lista a la que hace referencia el queso , la lista a la que hace referencia el spam es
también cambió, porque tanto el queso como el spam se refieren a la misma lista. Puede ver esto en la
Figura 4-6.
Figura 4-6: queso[1] = '¡Hola!' modifica la lista a la que hacen
referencia ambas variables.
Las variables contendrán referencias a valores de lista en lugar de valores de lista en sí mismos.
Pero para cadenas y valores enteros, las variables simplemente contienen la cadena o el valor entero.
Python usa referencias siempre que las variables deben almacenar valores de tipos de datos mutables,
como listas o diccionarios. Para valores de tipos de datos inmutables, como cadenas, enteros o tuplas, las
variables de Python almacenarán el valor en sí.
Aunque las variables de Python técnicamente contienen referencias a valores de lista o diccionario,
la gente suele decir casualmente que la variable contiene la lista o el diccionario.
Listas 99
Machine Translated by Google
Pasando Referencias
Las referencias son particularmente importantes para comprender cómo se pasan los argumentos
a las funciones. Cuando se llama a una función, los valores de los argumentos se copian en las
variables de parámetro. Para listas (y diccionarios, que describiré en el próximo capítulo), esto
significa que se usa una copia de la referencia para el parámetro. Para ver las consecuencias de
esto, abra una nueva ventana del editor de archivos, ingrese el siguiente código y guárdelo como
passReference.py:
def huevos (algún parámetro):
algúnParámetro.append('Hola')
correo no deseado = [1, 2, 3]
huevos (spam)
imprimir (correo no deseado)
Tenga en cuenta que cuando se llama a huevos () , no se utiliza un valor de retorno para
asignar un nuevo valor al correo no deseado. En su lugar, modifica la lista en su lugar, directamente.
Cuando se ejecuta, este programa produce el siguiente resultado:
[1, 2, 3, 'Hola']
Aunque spam y someParameter contienen referencias separadas, ambos se refieren a la
misma lista. Esta es la razón por la que la llamada al método append('Hello') dentro de la función
afecta a la lista incluso después de que la llamada a la función haya regresado.
Tenga en cuenta este comportamiento: olvidar que Python maneja las variables de lista y
diccionario de esta manera puede generar errores confusos.
Las funciones copy() y deepcopy() del módulo copy
Aunque pasar referencias suele ser la forma más práctica de manejar listas y diccionarios, si la
función modifica la lista o el diccionario que se pasa, es posible que no desee estos cambios en la
lista original o el valor del diccionario. Para esto, Python proporciona un módulo llamado copy que
proporciona las funciones copy() y deepcopy() . El primero de estos, copy.copy(), se puede usar para
hacer una copia duplicada de un valor mutable como una lista o diccionario, no solo una copia de una
referencia. Ingrese lo siguiente en el shell interactivo:
>>> importar copia
>>> spam = ['A', 'B', 'C', 'D']
>>> queso = copiar.copiar(spam)
>>> queso[1] = 42
>>> correo no deseado
['A B C D']
>>> queso
['A', 42, 'C', 'D']
100 Capítulo 4
Machine Translated by Google
Ahora las variables spam y cheese se refieren a listas separadas, por lo que solo se modifica
la lista en cheese cuando asigna 42 en el índice 7. Como puede ver en la Figura 4-7, los números
de ID de referencia ya no son los mismos para ambos. variables porque las variables se refieren a
listas independientes.
Figura 4-7: cheese = copy.copy(spam) crea una segunda lista que se puede modificar
independientemente de la primera.
Si la lista que necesita copiar contiene listas, utilice copy.deepcopy()
función en lugar de copy.copy(). La función deepcopy() también copiará estas listas internas.
Resumen
Las listas son tipos de datos útiles, ya que le permiten escribir código que funciona en una cantidad
modificable de valores en una sola variable. Más adelante en este libro, verá programas que usan
listas para hacer cosas que serían difíciles o imposibles de hacer sin ellas.
Las listas son mutables, lo que significa que su contenido puede cambiar. tuplas y
las cadenas, aunque en algunos aspectos parecen listas, son inmutables y no se pueden
cambiar. Una variable que contiene un valor de tupla o cadena se puede sobrescribir con un nuevo
valor de tupla o cadena, pero esto no es lo mismo que modificar el valor existente en su lugar,
como, por ejemplo, los métodos append() o remove() hacen en liza.
Las variables no almacenan valores de lista directamente; almacenan referencias a listas.
Esta es una distinción importante al copiar variables o pasar listas como argumentos en llamadas
a funciones. Debido a que el valor que se copia es la referencia de la lista, tenga en cuenta que
cualquier cambio que realice en la lista podría afectar a otra variable de su programa. Puede usar
copy() o deepcopy() si desea realizar cambios en una lista en una variable sin modificar la lista
original.
Liza
101
Machine Translated by Google
Preguntas de práctica
1. ¿Qué es []?
2. ¿Cómo asignaría el valor 'hola' como el tercer valor en una lista almacenada en una variable
llamada spam? (Suponga que el spam contiene [2, 4, 6, 8, 10].)
Para las siguientes tres preguntas, digamos que el spam contiene la lista ['a', 'b', 'c', 'd'].
3. ¿A qué se evalúa spam[int('3' * 2) / 11] ?
4. ¿A qué se evalúa spam[-1] ?
5. ¿A qué se evalúa spam[:2] ?
Para las siguientes tres preguntas, digamos que el tocino contiene la lista
[3.14, 'gato', 11, 'gato', Verdadero].
6. ¿A qué se evalúa bacon.index('gato') ?
7. ¿Cómo se ve bacon.append(99) en el valor de la lista en bacon ?
8. ¿Cómo se ve bacon.remove('gato') en el valor de la lista en bacon ?
9. ¿Cuáles son los operadores para la concatenación de listas y la replicación de listas?
10. ¿Cuál es la diferencia entre los métodos de lista append() e insert() ?
11. ¿Cuáles son dos formas de eliminar valores de una lista?
12. Mencione algunas formas en que los valores de lista son similares a los valores de cadena.
13. ¿Cuál es la diferencia entre listas y tuplas?
14. ¿Cómo escribe el valor de tupla que tiene solo el valor entero 42 ?
15. ¿Cómo se puede obtener la forma de tupla de un valor de lista? ¿Cómo se puede obtener la forma
de lista de un valor de tupla?
16. Las variables que "contienen" valores de lista en realidad no contienen listas directamente.
¿Qué contienen en su lugar?
17. ¿Cuál es la diferencia entre copy.copy() y copy.deepcopy()?
Proyectos de práctica
Para practicar, escriba programas para realizar las siguientes tareas.
Código de coma
Digamos que tiene un valor de lista como este:
Escriba una función que tome un valor de lista como argumento y devuelva una cadena
con todos los elementos separados por una coma y un espacio, con y
insertado antes del último elemento. Por ejemplo, pasar la lista de spam anterior a la función
devolvería 'manzanas, plátanos, tofu y gatos'. Pero su función debería poder funcionar con
cualquier valor de lista que se le pase.
102 Capítulo 4
Machine Translated by Google
Cuadrícula de imágenes de personajes
Digamos que tiene una lista de listas donde cada valor en las listas internas es una cadena de un carácter,
como esta:
.OOOOOOO.
.OOOOOOO.
Sugerencia: deberá usar un bucle en un bucle para imprimir grid[0][0],
luego grid[1][0], luego grid[2][0], y así sucesivamente, hasta grid[8][0]. Esto terminará la primera fila,
entonces imprima una nueva línea. Entonces su programa debe imprimir grilla[0][1], luego grilla[1][1],
luego grilla[2][1], y así sucesivamente. Lo último que imprimirá su programa es grid[8][5].
Además, recuerde pasar el argumento de la palabra clave final a print() si
no quiero que se imprima una nueva línea automáticamente después de cada llamada print() .
Listas 103
Machine Translated by Google
Machine Translated by Google
5
D ic tion a rie sand
Estructuración de datos
En este capítulo, cubriré el tipo de datos de
diccionario, que proporciona una forma
flexible de acceder y organizar datos. Luego,
combinando diccionarios con su conocimiento de
listas del capítulo anterior, aprenderá a crear una estructura
de datos para modelar un tablero de tres en raya.
El tipo de datos del diccionario
Al igual que una lista, un diccionario es una colección de muchos valores. Pero a diferencia de los
índices para listas, los índices para diccionarios pueden usar muchos tipos de datos diferentes, no
solo números enteros. Los índices de los diccionarios se denominan claves, y una clave con su
valor asociado se denomina par clave-valor.
En código, un diccionario se escribe con llaves, {}. Ingrese lo siguiente en el shell interactivo:
>>> miGato = {'tamaño': 'gordo', 'color': 'gris', 'disposición': 'fuerte'}
Machine Translated by Google
Esto asigna un diccionario a la variable myCat . Las claves de este diccionario son 'tamaño',
'color' y 'disposición'. Los valores para estas teclas son 'grueso', 'gris' y 'alto', respectivamente.
Puede acceder a estos valores a través de sus claves:
>>> miGato['tamaño']
'grasa'
'
>>> 'Mi gato tiene + myCat['color'] + 'Mi
gato tiene pelaje gris.'
' pelaje.'
Los diccionarios aún pueden usar valores enteros como claves, al igual que las listas usan
números enteros para los índices, pero no es necesario que comiencen en 0 y pueden ser cualquier número.
>>> spam = {12345: 'Combinación de equipaje', 42: 'La respuesta'}
Diccionarios vs. Listas
A diferencia de las listas, los elementos de los diccionarios están desordenados. El primer elemento
de una lista denominada spam sería spam[0]. Pero no hay un "primer" artículo en un diccionario.
Si bien el orden de los elementos es importante para determinar si dos listas son iguales, no importa en
qué orden se escriben los pares clave-valor en un diccionario. Ingrese lo siguiente en el shell interactivo:
>>> spam = ['gatos', 'perros', 'alces']
>>> tocino = ['perros', 'alces', 'gatos']
>>> spam == tocino
Falso
>>> huevos = {'nombre': 'Zophie', 'especie': 'gato', 'edad': '8'}
>>> jamón = {'especie': 'gato', 'edad': '8', 'nombre': 'Zophie'}
>>> huevos == jamón
Verdadero
Debido a que los diccionarios no están ordenados, no se pueden dividir como listas.
Intentar acceder a una clave que no existe en un diccionario dará como resultado un mensaje de
error KeyError , muy parecido al mensaje de error IndexError "fuera de rango" de una lista . Ingrese lo
siguiente en el shell interactivo y observe el mensaje de error que aparece porque no hay una clave
de 'color' :
>>> spam = {'nombre': 'Zophie', 'edad': 7}
>>> spam['color']
Rastreo (llamadas recientes más última):
Archivo "<pyshell#1>", línea 1, en <módulo>
spam['color']
KeyError: 'color'
Aunque los diccionarios no están ordenados, el hecho de que pueda tener valores arbitrarios
para las claves le permite organizar sus datos de formas poderosas.
Digamos que desea que su programa almacene datos sobre los cumpleaños de sus amigos.
Puedes usar un diccionario con los nombres como claves y los cumpleaños como valores.
Abra una nueva ventana del editor de archivos e ingrese el siguiente código. Guárdelo como cumpleaños
days.py.
106 Capítulo 5
Machine Translated by Google
u cumpleaños = {'Alice': '1 de abril', 'Bob': '12 de diciembre', 'Carol': '4 de marzo'}
mientras que es cierto:
print('Ingrese un nombre: (en blanco para salir)')
nombre = entrada()
si nombre == '':
descanso
v si nombre en cumpleaños:
w print(cumpleaños[nombre] + else:
'
'
+ nombre)
es el cumpleaños de
'
print('No tengo información de cumpleaños para print('¿Cuál es su
+ nombre)
cumpleaños?')
cumpleaños = entrada ()
X
cumpleaños[nombre] = cumpleaños
print('Base de datos de cumpleaños actualizada.')
Creas un diccionario inicial y lo almacenas en cumpleaños u. Puede ver si el
nombre ingresado existe como una clave en el diccionario con la palabra clave in v,
tal como lo hizo con las listas. Si el nombre está en el diccionario, se accede al valor
asociado usando corchetes w; si no, puede agregarlo usando la misma sintaxis de
corchetes combinada con el operador de asignación x.
Cuando ejecute este programa, se verá así:
Introduzca un nombre: (en blanco para salir)
Alicia
El 1 de abril es el cumpleaños de Alice.
Introduzca un nombre: (en blanco para salir)
Víspera
No tengo información de cumpleaños para Eva
¿Cuál es su cumpleaños?
5 de diciembre
Base de datos de cumpleaños actualizada.
Introduzca un nombre: (en blanco para salir)
Víspera
El 5 de diciembre es el cumpleaños de Eva.
Introduzca un nombre: (en blanco para salir)
Por supuesto, todos los datos que ingresa en este programa se olvidan cuando
finaliza el programa. Aprenderá cómo guardar datos en archivos en el disco duro en
el Capítulo 8.
Los métodos keys(), valores() y items()
Hay tres métodos de diccionario que devolverán valores similares a una lista de las claves, los valores o ambas claves y
valores del diccionario: claves(), valores() y elementos().
Los valores devueltos por estos métodos no son listas verdaderas: no se pueden
modificar y no tienen un método append() . Pero estos tipos de datos (dict_keys,
Diccionarios y estructuración de datos 107
Machine Translated by Google
dict_values y dict_items, respectivamente) se pueden usar en bucles for . Para ver cómo
funcionan estos métodos, ingrese lo siguiente en el shell interactivo:
>>> spam = {'color': 'rojo', 'edad': 42}
>>> para v en spam.valores():
imprimir (v)
rojo
42
Aquí, un ciclo for itera sobre cada uno de los valores en el diccionario de spam .
Un bucle for también puede iterar sobre las claves o tanto las claves como los valores:
>>> para k en spam.keys():
imprimir (k)
color
años
>>> para i en spam.items():
imprimir (yo)
('color rojo')
('edad', 42)
Usando los métodos keys(), values() y items() , un bucle for puede iterar sobre las claves,
valores o pares clave-valor en un diccionario, respectivamente. Observe que los valores en el valor
dict_items devuelto por el método items() son tuplas de la clave y el valor.
Si desea una lista verdadera de uno de estos métodos, pase su retorno similar a una lista
valor a la función list() . Ingrese lo siguiente en el shell interactivo:
>>> spam = {'color': 'rojo', 'edad': 42}
>>> spam.claves()
dict_keys(['color', 'edad'])
>>> lista(spam.keys())
['color', 'edad']
La línea list(spam.keys()) toma el valor dict_keys devuelto por keys()
y lo pasa a list(), que luego devuelve un valor de lista de ['color', 'age'].
También puede usar el truco de asignación múltiple en un bucle for para asignar la clave y
el valor a variables separadas. Ingrese lo siguiente en el shell interactivo:
>>> spam = {'color': 'rojo', 'edad': 42}
>>> para k, v en spam.items():
'
Valor:
imprimir('Clave: ' + k +
Clave: edad Valor: 42
Clave: color Valor: rojo
108 Capítulo 5
'
+ cadena(v))
Machine Translated by Google
Comprobar si existe una clave o un valor en un diccionario
Recuerde del capítulo anterior que los operadores in y not in pueden comprobar
si existe un valor en una lista. También puede usar estos operadores para ver si
una determinada clave o valor existe en un diccionario. Ingrese lo siguiente en el
shell interactivo:
>>> spam = {'nombre': 'Zophie', 'edad': 7}
>>> 'nombre' en spam.keys()
Verdadero
>>> 'Zophie' en spam.valores()
Verdadero
>>> 'color' en spam.keys()
Falso
>>> 'color' no en spam.keys()
Verdadero
>>> 'color' en spam
Falso
En el ejemplo anterior, observe que 'color' en spam es esencialmente
una versión más corta de escribir 'color' en spam.keys(). Este es siempre el caso:
si alguna vez desea verificar si un valor es (o no es) una clave en el diccionario,
simplemente puede usar la palabra clave in (o not in) con el valor del diccionario en sí.
El método get()
Es tedioso comprobar si existe una clave en un diccionario antes de acceder al
valor de esa clave. Afortunadamente, los diccionarios tienen un método get() que
toma dos argumentos: la clave del valor a recuperar y un valor alternativo para
devolver si esa clave no existe.
Ingrese lo siguiente en el shell interactivo:
>>> picnicItems = {'ma' nzanas': 5, 'tazas': 2}
'Traigo 'tazas'.
+ str(picnicItems.get('tazas', 0)) + >>>
'Traigo 2 tazas.'
'
>>> ' Traigo ' Traigo
+ str(picnicItems.get('huevos', 0)) + ' huevos.'
0 huevos.'
Debido a que no hay una clave 'huevos' en el diccionario picnicItems , el valor predeterminado
el método get() devuelve el valor 0 . Sin usar get(), el código habría generado
un mensaje de error, como en el siguiente ejemplo:
>>> picnicItems = {'ma' nzanas': 5, 'tazas': 2}
>>> 'Traigo + str(picnicItems['eggs']) + ' egg.'
Rastreo (llamadas recientes más última):
Archivo "<pyshell#34'>", línea 1, en <módulo>
+ str(elementos de picnic['huevos']) + ' huevos.'
'Yo llevo
KeyError: 'huevos'
Diccionarios y estructuración de datos 109
Machine Translated by Google
El método setdefault()
A menudo tendrá que establecer un valor en un diccionario para una determinada
clave solo si esa clave aún no tiene un valor. El código se parece a esto:
spam = {'nombre': 'Pooka', 'edad': 5}
si 'color' no está en spam:
spam['color'] = 'negro'
El método setdefault() ofrece una manera de hacer esto en una línea de código. El
primer argumento que se pasa al método es la clave a verificar y el segundo argumento
es el valor a establecer en esa clave si la clave no existe. Si la clave existe, el método
setdefault() devuelve el valor de la clave. Ingrese lo siguiente en el shell interactivo:
>>> spam = {'nombre': 'Pooka', 'edad': 5}
>>> spam.setdefault('color', 'negro')
'negro'
>>> correo no deseado
{'color': 'negro', 'edad': 5, 'nombre': 'Pooka'}
>>> spam.setdefault('color', 'blanco')
'negro'
>>> correo no deseado
{'color': 'negro', 'edad': 5, 'nombre': 'Pooka'}
La primera vez que se llama a setdefault() , el diccionario en spam cambia a
{'color': 'black', 'age': 5, 'name': 'Pooka'}. El método devuelve el valor 'negro' porque
este es ahora el valor establecido para la clave 'color'. Cuando se llama a
continuación a spam.setdefault('color', 'white') , el valor de esa clave no es
cambiado a 'blanco' porque el spam ya tiene una clave llamada 'color'.
El método setdefault() es un buen atajo para garantizar que exista una clave.
Aquí hay un programa corto que cuenta el número de ocurrencias de cada letra en una
cadena. Abra la ventana del editor de archivos e ingrese el siguiente código, guardándolo
como characterCount.py:
mensaje = 'Era un día brillante y frío de abril, y los relojes daban las trece.'
cuenta = {}
para el carácter en el mensaje:
count.setdefault(carácter, 0)
cuenta[carácter] = cuenta[carácter] + 1
imprimir (contar)
El programa recorre cada carácter en la cadena de la variable del mensaje ,
contando con qué frecuencia aparece cada carácter. La llamada al método setdefault()
asegura que la clave esté en el diccionario de conteo (con un valor predeterminado de 0)
110 Capítulo 5
Machine Translated by Google
para que el programa no arroje un error KeyError cuando se ejecuta
count[character] = count[character] + 1 . Cuando ejecute este programa, la salida
se verá así:
{' ': 13, ',': 1, '.': 1, 'A': 1, 'I': 1, 'a': 4, 'c': 3, 'b': 1, 'e ': 5, 'd': 3, 'g': 2, 'i': 6, 'h': 3, 'k': 2, 'l': 3, 'o': 2, 'n': 4, 'p': 1,
's': 3, 'r': 5, 't': 6, 'w': 2, 'y': 1}
De la salida, puede ver que la letra minúscula c aparece 3 veces,
el carácter de espacio aparece 13 veces y la letra A mayúscula aparece 1 vez. Este
programa funcionará sin importar qué cadena esté dentro del mensaje.
variable, ¡incluso si la cadena tiene millones de caracteres!
bonita impresión
Si importa el módulo pprint a sus programas, tendrá acceso a las funciones pprint() y
pformat() que "imprimirán bastante" los valores de un diccionario. Esto es útil cuando
desea una visualización más limpia de los elementos en un diccionario que lo que
proporciona print() . Modificar el characterCount.py anterior
programe y guárdelo como prettyCharacterCount.py.
importación impresa
mensaje = 'Era un día brillante y frío de abril, y los relojes daban las trece.'
cuenta = {}
para el carácter en el mensaje:
count.setdefault(carácter, 0)
cuenta[carácter] = cuenta[carácter] + 1
pprint.pprint(contar)
Esta vez, cuando se ejecuta el programa, la salida se ve mucho más limpia,
con las claves ordenadas.
{' ': 13,
',': 1,
'.': 1,
'A': 1,
'yo': 1,
'un': 4,
'b': 1,
'c': 3,
'd': 3,
'e': 5,
'g': 2,
'h': 3,
'yo': 6,
Diccionarios y estructuración de datos
111
Machine Translated by Google
'k': 2,
'l': 3,
'n': 4,
'o': 2,
'p': 1,
'r': 5,
's': 3,
't': 6,
'w': 2,
'y': 1}
La función pprint.pprint() es especialmente útil cuando el propio diccionario contiene
listas anidadas o diccionarios.
Si desea obtener el texto embellecido como un valor de cadena en lugar de mostrarlo
en la pantalla, llame a pprint.pformat() en su lugar. Estas dos líneas son equivalentes entre
sí:
pprint.pprint(algúnValorDeDiccionario)
print(pprint.pformat(algúnValorDeDiccionario))
Uso de estructuras de datos para modelar cosas del mundo real
Incluso antes de Internet, era posible jugar una partida de ajedrez con alguien del otro lado
del mundo. Cada jugador instalaría un tablero de ajedrez en su casa y luego se turnarían para
enviarse una postal entre ellos describiendo cada movimiento. Para hacer esto, los jugadores
necesitaban una forma de describir sin ambigüedades el estado del tablero y sus movimientos.
En notación algebraica de ajedrez, los espacios en el tablero de ajedrez se identifican por
una coordenada de número y letra, como en la Figura 5-1.
8
7
6
g5
a4 b4 c4 d4
5
4
a3 b3 c3 d3
3
a2 b2 c2 d2
2
a1 b1 c1 d1
1
abdominales
cdfgh
Figura 5-1: Las coordenadas de un
tablero de ajedrez en notación algebraica
de ajedrez
Las piezas de ajedrez se identifican con letras: K de rey, Q de reina, R de torre, B de
alfil y N de caballo. Describir un movimiento usa la letra de la pieza y las coordenadas de su
destino. Un par de estos movimientos describe
112 Capítulo 5
Machine Translated by Google
lo que sucede en un solo turno (con las blancas primero); por ejemplo, la notación 2. Cf3 Cc6
indica que las blancas movieron un caballo a f3 y las negras movieron un caballo a c6 en el
segundo turno del juego.
Hay un poco más de notación algebraica que esto, pero el punto es que puedes usarlo para
describir sin ambigüedades un juego de ajedrez sin necesidad de estar frente a un tablero de ajedrez.
¡Tu oponente puede incluso estar al otro lado del mundo! De hecho, ni siquiera necesita un juego de
ajedrez físico si tiene buena memoria: puede simplemente leer los movimientos de ajedrez enviados por
correo y actualizar los tableros que tiene en su imaginación.
Las computadoras tienen buena memoria. Un programa en una computadora moderna puede
almacenar fácilmente miles de millones de cadenas como '2. Cf3 Cc6'. Así es como las computadoras
pueden jugar al ajedrez sin tener un tablero de ajedrez físico. Modelan datos para representar un tablero
de ajedrez y puede escribir código para trabajar con este modelo.
Aquí es donde pueden entrar las listas y los diccionarios. Puede usarlos para modelar cosas del
mundo real, como tableros de ajedrez. Para el primer ejemplo, usará un juego que es un poco más
simple que el ajedrez: tres en raya.
Un tablero de tres en raya
Un tablero de tres en raya se parece a un gran símbolo
de almohadilla (#) con nueve ranuras que pueden
contener cada una una X, una O o un espacio en blanco.
'superior-L'
'arriba-M'
Para representar el tablero con un diccionario, puede
asignar a cada ranura una clave de valor de cadena, como
'mediados de M'
se muestra en la Figura 5-2.
Puede utilizar valores de cadena para
representar lo que hay en cada ranura del tablero:
'
'X', 'O' o ' (un carácter de espacio). Por lo tanto,
deberá almacenar nueve cuerdas. Puede usar un
'baja-L'
'bajo-R'
diccionario de valores para esto. El valor de cadena
con la tecla 'arriba-R' puede representar la esquina
puede representar la esquina inferior izquierda, el valor
de la cadena con la clave 'M en medio' puede representar
el centro, y así sucesivamente.
Este diccionario es una estructura de datos que representa un tablero de tres en raya.
Guarde este tablero como diccionario en una variable llamada theBoard. Abra una nueva ventana
del editor de archivos e ingrese el siguiente código fuente y guárdelo como ticTacToe.py:
elTablero = {'arriba-L': ' ', 'arriba-M': ' ', 'arriba-R': ' ',
'Mid-L': ' ', 'Mid-M': ' ', 'Mid-R': ' ',
'baja-L': ' ', 'baja-M': ' ', 'baja-R': ' '}
La estructura de datos almacenada en la variable theBoard representa el tic-tac
rodapié en la Figura 5-3.
Diccionarios y estructuración de datos
113
Machine Translated by Google
Figura 5-3: Un tablero de tres en raya vacío
Dado que el valor de cada tecla en theBoard es una cadena de un solo espacio,
este diccionario representa un tablero completamente claro. Si el jugador X fue primero
y eligió el espacio del medio, podrías representar ese tablero con este diccionario:
elTablero = {'arriba-L': ' ', 'arriba-M': ' ', 'arriba-R': ' ',
'Mid-L': ' ', 'Mid-M': 'X', 'Mid-R': ' ',
'baja-L': ' ', 'baja-M': ' ', 'baja-R': ' '}
La estructura de datos en theBoard ahora representa el tablero de tres en raya en
la figura 5-4.
Figura 5-4: El primer movimiento
Un tablero en el que el jugador O ha ganado colocando O en la parte superior
podría verse así:
elTablero = {'arriba-L': 'O', 'arriba-M': 'O', 'arriba-R': 'O',
'mid-L': 'X', 'mid-M': 'X', 'mid-R': ' ',
'baja-L': ' ', 'baja-M': ' ', 'baja-R': 'X'}
La estructura de datos en theBoard ahora representa el tablero de tic-tac-toe en
la figura 5-5.
114 Capítulo 5
Machine Translated by Google
Figura 5-5: Gana el jugador O.
Por supuesto, el jugador solo ve lo que se imprime en la pantalla, no el contenido de las
variables. Vamos a crear una función para imprimir el diccionario del tablero en la pantalla. Haga la
siguiente adición a ticTacToe.py (el nuevo código está en negrita):
elTablero = {'arriba-L': ' ', 'arriba-M': ' ', 'arriba-R': ' ',
'Mid-L': ' ', 'Mid-M': ' ', 'Mid-R': ' ',
'baja-L': ' ', 'baja-M': ' ', 'baja-R': ' '}
def imprimirTablero(tablero):
print(tablero['arriba-L'] + '|' + tablero['arriba-M'] + '|' + tablero['arriba-R'])
imprimir('-+-+-')
print(tablero['mid-L'] + '|' + tablero['mid-M'] + '|' + tablero['mid-R'])
imprimir('-+-+-')
print(tablero['baja-L'] + '|' + tablero['baja-M'] + '|' + tablero['baja-R'])
imprimirTablero(elTablero)
Cuando ejecute este programa, printBoard() imprimirá un tic-tac en blanco
tablero de pie.
| |
-+-+| |
-+-+| |
La función printBoard() puede manejar cualquier estructura de datos de tic-tac-toe que le pases.
Intenta cambiar el código a lo siguiente:
elTablero = {'arriba-L': 'O', 'arriba-M': 'O', 'arriba-R': 'O', 'medio-L': 'X', 'medio-M':
'X', 'R medio': ' ', 'L bajo': ' ', 'M bajo': ' ', 'R bajo': 'X'}
def imprimirTablero(tablero):
print(tablero['arriba-L'] + '|' + tablero['arriba-M'] + '|' + tablero['arriba-R'])
imprimir('-+-+-')
print(tablero['mid-L'] + '|' + tablero['mid-M'] + '|' + tablero['mid-R'])
imprimir('-+-+-')
print(tablero['baja-L'] + '|' + tablero['baja-M'] + '|' + tablero['baja-R'])
imprimirTablero(elTablero)
Diccionarios y estructuración de datos
115
Machine Translated by Google
Ahora, cuando ejecute este programa, la nueva placa se imprimirá en
la pantalla.
O|O|O
-+-+-
X|X|
-+-+| |X
Como creó una estructura de datos para representar un tablero de tres en raya y
escribió código en printBoard() para interpretar esa estructura de datos, ahora tiene un
programa que "modela" el tablero de tres en raya. Podría haber organizado su estructura de
datos de manera diferente (por ejemplo, usando teclas como 'SUPERIOR-IZQUIERDA'
en lugar de 'top-L'), pero siempre que el código funcione con sus estructuras de datos, tendrá
un programa que funcione correctamente.
Por ejemplo, la función imprimirTablero() espera que la estructura de datos del tres en raya
sea un diccionario con claves para las nueve ranuras. Si faltara el diccionario que pasó, digamos,
la tecla 'media L' , su programa ya no funcionaría.
O|O|O
-+-+-
Rastreo (llamadas recientes más última):
Archivo "ticTacToe.py", línea 10, en <módulo>
imprimirTablero(elTablero)
Archivo "ticTacToe.py", línea 6, en printBoard
print(tablero['mid-L'] + '|' + tablero['mid-M'] + '|' + tablero['mid-R'])
KeyError: 'mid-L'
Ahora agreguemos un código que permita a los jugadores ingresar sus movimientos.
Modifique el programa ticTacToe.py para que se vea así:
elTablero = {'arriba-L': ' ', 'arriba-M': ' ', 'arriba-R': ' ', 'medio-L': ' ', 'medio-M': ' ', 'medio
-R': ' ', 'baja-L': ' ', 'baja-M': ' ', 'baja-R': ' '}
def imprimirTablero(tablero):
print(tablero['arriba-L'] + '|' + tablero['arriba-M'] + '|' + tablero['arriba-R'])
imprimir('-+-+-')
print(tablero['mid-L'] + '|' + tablero['mid-M'] + '|' + tablero['mid-R'])
imprimir('-+-+-')
print(tablero['baja-L'] + '|' + tablero['baja-M'] + '|' + tablero['baja-R'])
giro = 'X'
para i en el rango (9):
u imprimirTablero(elTabler'o)
print('Girar por
+ girar + '. ¿Moverse en qué espacio?')
v mover = entrada()
w elTablero[mover] = girar
x si gira == 'X':
giro = 'O'
más:
giro = 'X'
imprimirTablero(elTablero)
116 Capítulo 5
Machine Translated by Google
El nuevo código imprime el tablero al comienzo de cada nuevo turno u, obtiene
el movimiento v del jugador activo, actualiza el tablero de juego en consecuencia w, y
luego cambia el jugador activo x antes de pasar al siguiente turno.
Cuando ejecute este programa, se verá algo como esto:
bajo-L
bajo-M
recursos disponibles en http://nostarch.com/automatestuff/.
Listas y diccionarios anidados
Modelar un tablero de tres en raya fue bastante simple: el tablero necesitaba solo un
valor de diccionario único con nueve pares clave-valor. A medida que modela cosas
más complicadas, es posible que necesite diccionarios y listas que contengan
Diccionarios y estructuración de datos
117
Machine Translated by Google
otros diccionarios y listas. Las listas son útiles para contener una serie ordenada de
valores, y los diccionarios son útiles para asociar claves con valores. Por ejemplo, aquí
hay un programa que usa un diccionario que contiene otros diccionarios para ver quién
lleva qué a un picnic. El totalTraído()
La función puede leer esta estructura de datos y calcular el número total de artículos que
traen todos los invitados.
todos los invitados = {'Alice': {'manzanas': 5, 'pretzels': 12},
'Bob': {'sándwiches de jamón': 3, 'manzanas': 2},
'Carol': {'tazas': 3, 'tartas de manzana': 1}}
def totalBrought(invitados, artículo):
numTraído = 0
u por k, v en guest.items():
v
numBrought = numBrought + v.get(item, 0)
devolver numBrought
print('Número de cosas que se traen:')
'
+ str(totalTraído(todosLosInvitados, 'manzanas')))
'
+ str(totalTraído(todosLosInvitados, 'copas')))
'
+ str(totalTraído(todoslosInvitados, 'pasteles')))
- Pasteles print(' '
+ str(totalTraído(todoslosInvitados, 'sándwiches de jamón')))
Sándwiches de jamón print(' '
+ str(totalBrought(todoslosInvitados, 'tartas de manzana')))
Pasteles de manzana
print(' - Manzanas
print(' - Tazas print('
Dentro de la función totalBrought() , el ciclo for itera sobre los pares de valores
clave en los invitados u. Dentro del ciclo, la cadena del nombre del invitado se asigna a
k, y el diccionario de artículos de picnic que traerán se asigna a v. Si el parámetro del
artículo existe como clave en este diccionario, se agrega su valor (la cantidad). a
numBrought v. Si no existe como clave, get()
El método devuelve 0 para agregarlo a numBrought.
La salida de este programa se ve así:
Número de cosas que se traen:
- Manzanas 7
- Copas 3
- Pasteles 0
- Sándwiches De Jamón 3
- Pasteles
de
manzana
Esto puede parecer algo tan simple de modelar que no necesitaría molestarse en
escribir un programa para hacerlo. Pero tenga en cuenta que esta misma función
totalBrought() podría manejar fácilmente un diccionario que contiene miles de invitados,
cada uno trayendo miles de artículos de picnic diferentes. Luego, tener esta información
en una estructura de datos junto con totalBrought()
¡La función le ahorraría mucho tiempo!
Puede modelar cosas con estructuras de datos de la forma que desee, siempre que
el resto del código de su programa pueda funcionar correctamente con el modelo de
datos. Cuando comience a programar por primera vez, no se preocupe tanto por
118 Capítulo 5
1
Machine Translated by Google
la forma "correcta" de modelar datos. A medida que adquiera más experiencia, podrá
encontrar modelos más eficientes, pero lo importante es que el modelo de datos funcione
para las necesidades de su programa.
Resumen
Aprendiste todo acerca de los diccionarios en este capítulo. Las listas y los diccionarios
son valores que pueden contener varios valores, incluidas otras listas y diccionarios.
Los diccionarios son útiles porque puede asignar un elemento (la clave) a otro (el valor),
a diferencia de las listas, que simplemente contienen una serie de valores en orden. Se
accede a los valores dentro de un diccionario usando corchetes al igual que con las
listas. En lugar de un índice de enteros, los diccionarios pueden tener claves de una
variedad de tipos de datos: enteros, flotantes, cadenas o tuplas. Al organizar los valores
de un programa en estructuras de datos, puede crear representaciones de objetos del
mundo real. Viste un ejemplo de esto con un tablero de tres en raya.
¡Eso cubre casi todos los conceptos básicos de la programación en Python!
Continuará aprendiendo nuevos conceptos a lo largo del resto de este libro, pero
ahora sabe lo suficiente como para comenzar a escribir algunos programas útiles que
pueden automatizar tareas. Es posible que piense que no tiene suficiente conocimiento de
Python para hacer cosas como descargar páginas web, actualizar hojas de cálculo o
enviar mensajes de texto, ¡pero ahí es donde entran los módulos de Python! Estos
módulos, escritos por otros programadores, proporcionan funciones que le facilitan hacer
todas estas cosas. Entonces, aprendamos cómo escribir programas reales para realizar
tareas automatizadas útiles.
Preguntas de práctica
1. ¿Cómo es el código de un diccionario vacío?
2. ¿Qué aspecto tiene un valor de diccionario con una clave 'foo' y un valor 42 ?
3. ¿Cuál es la principal diferencia entre un diccionario y una lista?
4. ¿Qué sucede si intentas acceder a spam['foo'] si el spam es {'bar': 100}?
5. Si un diccionario está almacenado en spam, ¿cuál es la diferencia entre las
expresiones 'cat' en spam y 'cat' en spam.keys()?
6. Si un diccionario está almacenado en spam, ¿cuál es la diferencia entre las
expresiones 'cat' en spam y 'cat' en spam.values()?
7. ¿Qué es un atajo para el siguiente código?
si 'color' no está en spam:
spam['color'] = 'negro'
8. ¿Qué módulo y función se pueden usar para "imprimir bastante" el diccionario?
¿valores?
Diccionarios y estructuración de datos
119
Machine Translated by Google
Proyectos de práctica
Para practicar, escriba programas para realizar las siguientes tareas.
Inventario de juegos de fantasía
Estás creando un videojuego de fantasía. La estructura de datos para modelar el inventario
del jugador será un diccionario donde las claves son valores de cadena que describen el
artículo en el inventario y el valor es un valor entero que detalla cuántos artículos tiene el
jugador. Por ejemplo, el valor del diccionario {'cuerda': 1, 'antorcha': 6, 'moneda de oro': 42,
'daga': 1, 'flecha': 12} significa que el jugador tiene 1 cuerda, 6 antorchas, 42 de oro monedas,
y así sucesivamente.
Escriba una función llamada displayInventory() que tomaría cualquier "inventario" posible
y lo mostraría de la siguiente manera:
Inventario:
12 flecha
1 cuerda
6 antorcha
1 daga
Número total de artículos: 62
# inventario.py
cosas = {'cuerda': 1, 'antorcha': 6, 'moneda de oro': 42, 'daga': 1, 'flecha': 12}
def mostrarInventario(inventario):
imprimir("Inventario:")
artículo_total = 0
para k, v en inventario.i'tem
' s():
artículo_total += v
print("Número total de elementos:
"
+ str(elemento_total))
mostrar inventario (cosas)
Función de lista a diccionario para el inventario de juegos de fantasía
dragonLoot = ['moneda de oro', 'daga', 'moneda de oro', 'moneda de oro', 'rubí']
Escribe una función llamada addToInventory(inventario, elementos agregados), donde el
parámetro de inventario es un diccionario que representa el inventario del jugador (como en el
proyecto anterior) y el parámetro elementos agregados es una lista como dragonLoot.
120 Capítulo 5
Machine Translated by Google
La función addToInventory() debería devolver un diccionario que represente el inventario
actualizado. Tenga en cuenta que la lista de elementos agregados puede contener
múltiplos del mismo elemento. Su código podría ser algo como esto:
1 cuerda
Diccionarios y estructuración de datos
121
Machine Translated by Google
Machine Translated by Google
6
Manipulación de cadenas
El texto es una de las formas más comunes de datos
que manejarán sus programas. Ya sabes cómo
concatenar dos cadenas
valores junto con el operador + , pero puede hacer mucho
más que eso. Puede extraer cadenas parciales de valores de cadena,
agregar o eliminar espacios, convertir letras a minúsculas o mayúsculas
y verificar que las cadenas tengan el formato correcto. Incluso puede
escribir código Python para acceder al portapapeles para copiar y pegar texto.
En este capítulo, aprenderá todo esto y más. Luego, trabajará en dos proyectos de
programación diferentes: un administrador de contraseñas simple y un programa para
automatizar la aburrida tarea de formatear fragmentos de texto.
Trabajar con cadenas
Veamos algunas de las formas en que Python le permite escribir, imprimir y acceder a
cadenas en su código.
Machine Translated by Google
Literales de cadena
Escribir valores de cadena en el código de Python es bastante sencillo: comienzan y terminan con
una comilla simple. Pero entonces, ¿cómo puedes usar una cita dentro de una cadena? Escribir
'Ese es el gato de Alice'. no funcionará, porque Python piensa que la cadena termina después de
Alice, y el resto (s cat.') es un código de Python no válido.
Afortunadamente, hay varias formas de escribir cadenas.
Doble comillas
Las cadenas pueden comenzar y terminar con comillas dobles, tal como lo hacen con comillas
simples. Una ventaja de usar comillas dobles es que la cadena puede tener un carácter de comilla
simple. Ingrese lo siguiente en el shell interactivo:
>>> spam = "Ese es el gato de Alice".
Dado que la cadena comienza con una comilla doble, Python sabe que la comilla simple es
parte de la cadena y no marca el final de la cadena.
Sin embargo, si necesita usar comillas simples y comillas dobles en la cadena, deberá usar
caracteres de escape.
Personajes de escape
Un carácter de escape le permite usar caracteres que de otro modo serían imposibles de poner en
una cadena. Un carácter de escape consta de una barra invertida (\) seguida del carácter que desea
agregar a la cadena. (A pesar de que consta de dos caracteres, se suele denominar carácter de
escape singular). Por ejemplo, el carácter de escape para una comilla simple es \'. Puede usar esto
dentro de una cadena que comienza y termina con comillas simples. Para ver cómo funcionan los
caracteres de escape, ingrese lo siguiente en el shell interactivo:
>>> spam = 'Saluda a la madre de Bob.'
Python sabe que, dado que la comilla simple en Bob tiene una barra invertida, no es una
comilla simple destinada a terminar el valor de la cadena. Los caracteres de escape \' y \" le permiten
poner comillas simples y comillas dobles dentro de sus cadenas, respectivamente.
La Tabla 6-1 enumera los caracteres de escape que puede utilizar.
Tabla 6-1: Caracteres de escape
124 Capítulo 6
Personaje de escape
Imprime como
\'
Una frase
\"
Comillas dobles
\t
Pestaña
\norte
Nueva línea (salto de línea)
\\
barra invertida
Machine Translated by Google
Ingrese lo siguiente en el shell interactivo:
>>> print("¡Hola!\n¿Cómo están?\nEstoy bien.")
¡Hola!
¿Cómo estás?
Estoy bien.
Cuerdas en bruto
Puede colocar una r antes de las comillas iniciales de una cadena para convertirla en una cadena
sin procesar. Una cadena sin procesar ignora por completo todos los caracteres de escape e
imprime cualquier barra invertida que aparece en la cadena. Por ejemplo, escriba lo siguiente en el
shell interactivo:
>>> print(r'Ese es el gato de Carol.')
Ese es el gato de Carol.
Debido a que se trata de una cadena sin formato, Python considera la barra invertida como
parte de la cadena y no como el comienzo de un carácter de escape. Las cadenas sin procesar
son útiles si está escribiendo valores de cadena que contienen muchas barras invertidas, como las
cadenas que se usan para las expresiones regulares descritas en el próximo capítulo.
Cadenas multilínea con comillas triples
Si bien puede usar el carácter de escape \n para poner una nueva línea en una cadena, a menudo
es más fácil usar cadenas de varias líneas. Una cadena multilínea en Python comienza y termina
con tres comillas simples o tres comillas dobles. Cualquier comilla, tabulación o salto de línea
entre las "comillas triples" se considera parte de la cadena. Las reglas de sangría de Python para
bloques no se aplican a las líneas dentro de una cadena de varias líneas.
Abra el editor de archivos y escriba lo siguiente:
print('''Estimada Alicia,
El gato de Eve ha sido arrestado por secuestro, robo de gatos y extorsión.
Sinceramente,
Beto''')
Guarde este programa como catnapping.py y ejecútelo. La salida se verá así:
Querida Alice,
El gato de Eve ha sido arrestado por secuestro, robo de gatos y extorsión.
Sinceramente,
Beto
Manipulación de cadenas 125
Machine Translated by Google
Tenga en cuenta que no es necesario escapar del carácter de comilla simple en Eve .
Escapar comillas simples y dobles es opcional en cadenas sin formato. La siguiente llamada print()
imprimiría texto idéntico pero no usa una cadena de varias líneas:
print('Querida Alice,\n\nEl gato de Eve ha sido arrestado por secuestro, robo de gatos y extorsión.
\n\nAtentamente,\nBob')
Comentarios multilínea
Mientras que el carácter almohadilla (#) marca el comienzo de un comentario para el resto de la
línea, una cadena de varias líneas se usa a menudo para comentarios que abarcan varias líneas. El
siguiente es un código de Python perfectamente válido:
"""Este es un programa de prueba de Python.
Escrito por Al Sweigart al@inventwithpython.com
Este programa fue diseñado para Python 3, no para Python 2.
"""
"""Este es un comentario de varias líneas para ayudar
explicar qué hace la función spam()."""
imprimir('¡Hola!')
Las cadenas usan índices y sectores de la misma manera que las listas. Puedes pensar en la cadena
'¡Hola mundo!' como una lista y cada carácter de la cadena como un elemento con un índice
correspondiente.
'
H
mi
yo
yo
o
0
1
2
3
4
5
w
o
r
yo
d
6
7
8
9
10 11
El espacio y el signo de exclamación se incluyen en el recuento de caracteres,
así que '¡Hola mundo!' tiene 12 caracteres, desde H en el índice 0 hasta ! en el índice 11.
Ingrese lo siguiente en el shell interactivo:
>>> spam = '¡Hola mundo!'
>>> correo no deseado[0]
'H'
>>> correo no deseado[4]
'o'
>>> correo no deseado[-1]
'!'
>>> correo no deseado[0:5]
'Hola'
126 Capítulo 6
!
'
Machine Translated by Google
>>> correo no deseado[:5]
'Hola'
>>> spam[6:]
'¡mundo!'
Si especifica un índice, obtendrá el carácter en esa posición en la cadena. Si especifica un rango
de un índice a otro, se incluye el índice inicial y no el índice final. Por eso, si el spam es '¡Hola mundo!',
el spam[0:5] es 'Hola'. La subcadena que obtiene del spam[0:5] incluirá todo, desde spam[0] hasta spam[4],
dejando fuera el espacio en el índice 5.
Tenga en cuenta que cortar una cadena no modifica la cadena original. Puede
capturar un segmento de una variable en una variable separada. Intente escribir lo
siguiente en el shell interactivo:
>>> spam = '¡Hola mundo!'
>>> efervescencia = spam[0:5]
>>> efervescencia
'Hola'
Al dividir y almacenar la subcadena resultante en otra variable, puede
tenga a mano tanto la cadena completa como la subcadena para un acceso rápido y fácil.
Los operadores in y not in con cadenas
Los operadores in y not in se pueden usar con cadenas al igual que con valores de lista.
Una expresión con dos cadenas unidas usando in o not in se evaluará como un valor
booleano verdadero o falso. Ingrese lo siguiente en el shell interactivo:
>>> 'Hola' en 'Hola mundo'
Verdadero
>>> 'Hola' en 'Hola'
Verdadero
>>> 'HOLA' en 'Hola mundo'
Falso
''
>>>
en 'correo no deseado'
Verdadero
>>> 'gatos' no en 'gatos y perros'
Falso
Estas expresiones prueban si la primera cadena (la cadena exacta, caso
sensitivo) se puede encontrar dentro de la segunda cadena.
Métodos de cadenas útiles
Varios métodos de cadena analizan cadenas o crean valores de cadena transformados.
Esta sección describe los métodos que usará con más frecuencia.
Manipulación de cadenas 127
Machine Translated by Google
Los métodos de cadena upper(), lower(), isupper() e islower()
Los métodos de cadena upper() y lower() devuelven una nueva cadena en la que todas
las letras de la cadena original se han convertido a mayúsculas o minúsculas,
respectivamente. Los caracteres que no son letras en la cadena permanecen sin cambios.
Ingrese lo siguiente en el shell interactivo:
>>> spam = '¡Hola mundo!'
>>> spam = spam.superior()
>>> correo no deseado
'¡HOLA MUNDO!'
>>> spam = spam.inferior()
>>> correo no deseado
'¡Hola Mundo!'
Tenga en cuenta que estos métodos no cambian la cadena en sí, sino que
devuelven nuevos valores de cadena. Si desea cambiar la cadena original, debe llamar
a upper() o lower() en la cadena y luego asignar la nueva cadena a la variable donde
se almacenó la original. Esta es la razón por la que debe usar spam = spam.upper()
para cambiar la cadena en spam en lugar de simplemente spam.upper().
(Esto es como si una variable huevos contiene el valor 10. Escribiendo huevos + 3
no cambia el valor de huevos, pero huevos = huevos + 3 sí.)
Los métodos upper() y lower() son útiles si necesita hacer una comparación que
no distinga entre mayúsculas y minúsculas. Las cadenas 'great' y 'GREat' no son iguales
entre sí. Pero en el siguiente programa pequeño, no importa si el usuario escribe Genial,
GENIAL o GENIAL, porque la cadena primero se convierte a minúsculas.
imprimir('¿Cómo estás?')
sentimiento = entrada ()
if sentimiento.inferior() == 'genial':
print('Yo también me siento genial.')
más:
print('Espero que el resto de tu día sea bueno.')
Cuando ejecuta este programa, se muestra la pregunta y al ingresar una variación
de genial, como GREat, seguirá dando el resultado Me siento genial también.
Agregar código a su programa para manejar variaciones o errores en la entrada del
usuario, como mayúsculas inconsistentes, hará que sus programas sean más fáciles de
usar y menos propensos a fallar.
¿Cómo estás?
Estupendo
Yo también me siento genial.
Los métodos isupper() e islower() devolverán un valor booleano verdadero
si la cadena tiene al menos una letra y todas las letras están en mayúsculas o
128 Capítulo 6
Machine Translated by Google
minúsculas, respectivamente. De lo contrario, el método devuelve False. Ingrese lo
siguiente en el shell interactivo y observe lo que llama cada método
devoluciones:
>>> spam = '¡Hola mundo!'
>>> spam.islower()
Falso
>>> spam.isupper()
Falso
>>> 'HOLA'.isupper()
Verdadero
>>> 'abc12345'.islower()
Verdadero
>>> '12345'.islower()
Falso
>>> '12345'.isupper()
Falso
Dado que los métodos de cadena superior() e inferior() devuelven cadenas, también
puede llamar a métodos de cadena en esos valores de cadena devueltos. Las expresiones que
hacen esto se verán como una cadena de llamadas a métodos. Ingrese lo siguiente en el shell
interactivo:
>>> 'Hola'.superior()
'HOLA'
>>> 'Hola'.superior().inferior()
'Hola'
>>> 'Hola'.superior().inferior().superior()
'HOLA'
>>> 'HOLA'.inferior()
'Hola'
>>> 'HOLA'.inferior().isinferior()
Verdadero
Los métodos de cadena isX
Junto con islower() e isupper(), existen varios métodos de cadenas cuyos nombres comienzan
con la palabra is. Estos métodos devuelven un valor booleano que describe la naturaleza de
la cadena. Aquí hay algunos isX comunes
métodos de cadena:
• isalpha() devuelve True si la cadena consta solo de letras y no está en blanco.
• isalnum() devuelve True si la cadena consta solo de letras y números
y no está en blanco.
• isdecimal() devuelve True si la cadena consta solo de caracteres numéricos
y no está en blanco.
Manipulación de cadenas 129
Machine Translated by Google
• isspace() devuelve True si la cadena consta solo de espacios, tabulaciones y new
líneas y no está en blanco.
• istitle() devuelve True si la cadena consta solo de palabras que comienzan con una letra
mayúscula seguida de solo letras minúsculas.
Ingrese lo siguiente en el shell interactivo:
>>> 'hola'.isalpha()
Verdadero
>>> 'hola123'.isalpha()
Falso
>>> 'hola123'.isalnum()
Verdadero
>>> 'hola'.isalnum()
Verdadero
>>> '123'.isdecimal()
Verdadero
>>>
'
'.isespacio()
Cierto
>>> 'Este es el caso del título'.istitle()
Verdadero
>>> 'Este es el Caso de Título 123'.istitle()
Verdadero
>>> 'Este no es un caso de título'.istitle()
Falso
>>> 'Este NO es un caso de título tampoco'.istitle()
Falso
Los métodos de cadena isX son útiles cuando necesita validar la entrada del
usuario. Por ejemplo, el siguiente programa solicita repetidamente a los usuarios su edad y
una contraseña hasta que proporcionen una entrada válida. Abra una nueva ventana del
editor de archivos e ingrese este programa, guardándolo como validateInput.py:
mientras que es cierto:
imprimir('Ingrese su edad:')
edad = entrada ()
si edad.isdecimal():
print('Ingrese un número para su edad.')
mientras que es cierto:
print('Seleccione una nueva contraseña (solo letras y números):')
contraseña = entrada ()
si contraseña.isalnum():
print('Las contraseñas solo pueden tener letras y números.')
En el primer ciclo while , le preguntamos al usuario su edad y almacenamos su
entrada en edad. Si la edad es un valor válido (decimal), salimos de este primero mientras
bucle y pasar al segundo, que pide una contraseña. De lo contrario, le informamos al
usuario que debe ingresar un número y nuevamente le solicitamos que
130 Capítulo 6
Machine Translated by Google
ingrese su edad. En el segundo ciclo while , solicitamos una contraseña, almacenamos
la entrada del usuario en contraseña y salimos del ciclo si la entrada fue alfanumérica. Si
no fue así, no estamos satisfechos, por lo que le decimos al usuario que la contraseña
debe ser alfanumérica y nuevamente le pedimos que ingrese una contraseña.
Cuando se ejecuta, la salida del programa se ve así:
Al llamar a isdecimal() e isalnum() en variables, podemos probar si
los valores almacenados en esas variables son decimales o no, alfanuméricos o no.
Aquí, estas pruebas nos ayudan a rechazar la entrada cuarenta y dos y aceptar 42, ¡ y
rechazar secr3t! y acepta secr3t.
Los métodos comienza con () y termina con () devuelven True si el valor de cadena al que
se les llama comienza o termina (respectivamente) con la cadena pasada al método; de lo
contrario, devuelven False. Ingrese lo siguiente en el shell interactivo:
Verdadero
Verdadero
Verdadero
Verdadero
Estos métodos son alternativas útiles al operador == es igual si necesita verificar
solo si la primera o la última parte de la cadena, en lugar de todo, es igual a otra cadena.
Los métodos de cadena join() y split()
El método join() es útil cuando tiene una lista de cadenas que deben unirse en un solo
valor de cadena. El método join() se llama en un
Manipulación de cadenas
131
Machine Translated by Google
cadena, se le pasa una lista de cadenas y devuelve una cadena. La cadena devuelta es la
concatenación de cada cadena en la lista pasada. Por ejemplo, ingrese lo siguiente en el
shell interactivo:
>>> ', '.join(['gatos', 'ratas', 'murciélagos'])
'gatos, ratas, murciélagos'
>>> ' '.join(['Mi', 'nombre', 'es', 'Simón'])
'Mi nombre es Simón'
>>> 'ABC'.join(['Mi', 'nombre', 'es', 'Simón'])
'MiNombreABCABCisABCSimon'
Observe que la cadena a la que llama join() se inserta entre cada cadena del
argumento de la lista. Por ejemplo, cuando se llama a join(['gatos', 'ratas', 'murciélagos'])
en la cadena ',' , la cadena devuelta es 'gatos, ratas, murciélagos'.
Recuerde que se llama a join() en un valor de cadena y se le pasa un valor de lista.
(Es fácil llamarlo accidentalmente al revés). El split()
El método hace lo contrario: se invoca en un valor de cadena y devuelve una lista de
cadenas. Ingrese lo siguiente en el shell interactivo:
>>> 'Mi nombre es Simón'.split()
['Mi nombre es Simón']
De forma predeterminada, la cadena 'Mi nombre es Simon' se divide dondequiera que
se encuentren caracteres de espacio en blanco, como espacios, tabuladores o caracteres
de nueva línea. Estos caracteres de espacio en blanco no se incluyen en las cadenas de la
lista devuelta. Puede pasar una cadena delimitadora al método split() para especificar una
cadena diferente para dividir. Por ejemplo, ingrese lo siguiente en el shell interactivo:
>>> 'MiNombreABCABCisABCSimon'.split('ABC')
['Mi nombre es Simón']
>>> 'Mi nombre es Simón'.split('m')
['Mi na', 'e es Si', 'on']
Un uso común de split() es dividir una cadena de varias líneas a lo largo de los
caracteres de nueva línea. Ingrese lo siguiente en el shell interactivo:
>>> spam = '''Querida Alicia,
¿Como has estado? Estoy bien.
hay un recipiente en la heladera
que está etiquetado como "Experimento de leche".
Por favor, no lo beba.
Sinceramente,
Beto'''
>>> spam.split('\n')
['Querida Alice,', '¿Cómo has estado? Estoy bien.', 'Hay un recipiente en la nevera', 'que tiene
la etiqueta "Experimento con leche".', 'Por favor, no lo bebas', 'Atentamente', 'Bob']
132 Capítulo 6
Machine Translated by Google
Al pasar split() el argumento '\n' nos permite dividir la cadena multilínea almacenada en
el spam a lo largo de las nuevas líneas y devolver una lista en la que cada elemento
corresponde a una línea de la cadena.
Justificación de texto con rjust(), ljust() y center()
Los métodos de cadena rjust() y ljust() devuelven una versión rellenada de la cadena a
la que se llaman, con espacios insertados para justificar el texto. El primer argumento de
ambos métodos es una longitud entera para la cadena justificada.
Ingrese lo siguiente en el shell interactivo:
>>> 'Hola'.rjust(10)
'
Hola'
>>> 'Hola'.rjust(20)
'
Hola'
>>> 'Hola Mundo'.rjust(20)
'
Hola Mundo'
>>> 'Hola'.ljust(10)
'
'Hola
'Hola'.rjust(10) dice que queremos justificar a la derecha 'Hola' en una cadena de
longitud total 10. 'Hola' tiene cinco caracteres, por lo que se agregarán cinco espacios a su
izquierda, lo que nos da una cadena de 10 caracteres con 'Hola' justificado a la derecha.
Un segundo argumento opcional para rjust() y ljust() especificará un carácter de
relleno que no sea un carácter de espacio. Ingrese lo siguiente en el shell interactivo:
>>> 'Hola'.rjust(20, '*')
'***************Hola'
>>> 'Hola'.ljust(20, '-')
'Hola --------------- '
El método de cadena center() funciona como ljust() y rjust() pero centra
el texto en lugar de justificarlo a la izquierda o a la derecha. Ingrese lo siguiente en el
shell interactivo:
>>> 'Hola'.center(20)
'
Hola
'
>>> 'Hola'.center(20, '=')
'=======Hola========'
Estos métodos son especialmente útiles cuando necesita imprimir datos tabulares
con el espaciado correcto. Abra una nueva ventana del editor de archivos e ingrese el
siguiente código, guardándolo como picnicTable.py:
def imprimirPicnic(itemsDict, ancho izquierdo, ancho derecho):
print('ARTÍCULOS DE PICNIC'.center(ancho izquierdo + ancho derecho, '-'))
para k, v en itemsDict.items():
print(k.ljust(ancho a la izquierda, '.') + str(v).rjust(ancho a la derecha))
Manipulación de cadenas 133
Machine Translated by Google
picnicItems = {'sándwiches': 4, 'manzanas': 12, 'tazas': 4, 'galletas': 8000}
imprimirPicnic(PicnicItems, 12, 5)
imprimirPicnic(PicnicItems, 20, 6)
En este programa, definimos un método printPicnic() que tomará un diccionario de
información y usará center(), ljust() y rjust() para mostrar esa información en un formato de
tabla perfectamente alineado.
El diccionario que pasaremos a printPicnic() es picnicItems. En picnicItems,
tenemos 4 sándwiches, 12 manzanas, 4 tazas y 8000 galletas.
Queremos organizar esta información en dos columnas, con el nombre del artículo a la
izquierda y la cantidad a la derecha.
Para ello, decidimos qué ancho queremos que tengan las columnas izquierda y derecha.
Junto con nuestro diccionario, pasaremos estos valores a printPicnic().
printPicnic() toma un diccionario, un ancho izquierdo para la columna izquierda de una tabla
y un ancho derecho para la columna derecha. Imprime un título, ARTÍCULOS DE PICNIC,
centrado sobre la mesa. Luego, recorre el diccionario, imprimiendo cada par clave -valor en una
línea con la clave justificada a la izquierda y rellenada con puntos, y el valor justificado a la
derecha y rellenado con espacios.
Después de definir printPicnic(), definimos el diccionario picnicItems y
llame a printPicnic() dos veces, pasándole diferentes anchos para las columnas izquierda y
derecha de la tabla.
Cuando ejecuta este programa, los elementos del picnic se muestran dos veces.
La primera vez que la columna de la izquierda tiene 12 caracteres de ancho y la columna de la
derecha tiene 5 caracteres de ancho. La segunda vez tienen 20 y 6 caracteres de ancho,
respectivamente.
---ARTÍCULOS DE PICNIC--
bocadillos.. 4
manzanas. ....... 12
tazas. ........ 4
galletas. .....8000
-------ARTÍCULOS DE PICNIC-------
sándwiches..........
manzanas.................. 4
4
12
tazas................
galletitas. ............ 8000
El uso de rjust(), ljust() y center() le permite asegurarse de que las cadenas estén
perfectamente alineadas, incluso si no está seguro de cuántos caracteres tienen.
Eliminar espacios en blanco con strip(), rstrip() y lstrip()
A veces, es posible que desee eliminar los caracteres de espacio en blanco (espacio, tabulador
y nueva línea) del lado izquierdo, del lado derecho o de ambos lados de una cadena. El método
de cadena strip() devolverá una nueva cadena sin ningún espacio en blanco
134 Capítulo 6
Machine Translated by Google
caracteres al principio o al final. Los métodos lstrip() y rstrip() eliminarán los espacios
en blanco de los extremos izquierdo y derecho, respectivamente.
Ingrese lo siguiente en el shell interactivo:
'
'
Hola mundo
>>> spam = >>> spam.strip()
'Hola Mundo'
>>> spam.lstrip()
'
'Hola Mundo
>>> spam.rstrip()
'
Hola Mundo'
Opcionalmente, un argumento de cadena especificará qué caracteres en los extremos
debe ser despojado. Ingrese lo siguiente en el shell interactivo:
>>> spam = 'SpamSpamBaconSpamEggsSpamSpam'
>>> spam.strip('ampS')
'BaconSpamHuevos'
Al pasar strip(), el argumento 'ampS' le indicará que elimine las ocurrencias de a, m, p
y S mayúscula de los extremos de la cadena almacenada en el spam. El orden de los
caracteres en la cadena pasada a strip() no importa: strip('ampS') hará lo mismo que
strip('mapS') o strip('Spam').
Copiar y pegar cadenas con el módulo pyperclip
El módulo pyperclip tiene funciones de copiar () y pegar () que pueden enviar y recibir
texto desde el portapapeles de su computadora. Enviar la salida de su programa al
portapapeles facilitará pegarlo en un correo electrónico, procesador de textos o algún otro
software.
Pyperclip no viene con Python. Para instalarlo, siga las instrucciones
para instalar módulos de terceros en el Apéndice A. Después de instalar el módulo
pyperclip , ingrese lo siguiente en el shell interactivo:
>>> importar clipper
>>> pyperclip.copy('¡Hola mundo!')
>>> pyperclip.paste()
'¡Hola Mundo!'
Por supuesto, si algo fuera de su programa cambia el portapapeles
contenido, la función paste() lo devolverá. Por ejemplo, si copié esta oración en el
portapapeles y luego llamé a pegar (), se vería así:
>>> pyperclip.paste()
'Por ejemplo, si copié esta oración en el portapapeles y luego llamé a pegar (), se
vería así:'
Manipulación de cadenas 135
Machine Translated by Google
Ejecución de secuencias de comandos de Python fuera de IDLE
Hasta ahora, ha estado ejecutando sus secuencias de comandos de Python utilizando el
shell interactivo y el editor de archivos en IDLE. Sin embargo, no querrá pasar por el
inconveniente de abrir IDLE y el script de Python cada vez que desee ejecutar un script.
Afortunadamente, hay atajos que puede configurar para facilitar la ejecución de scripts
de Python. Los pasos son ligeramente diferentes para Windows, OS X y Linux, pero cada
uno se describe en el Apéndice B. Consulte el Apéndice B para aprender cómo ejecutar
sus scripts de Python de manera conveniente y poder pasarles argumentos de línea de
comandos. (No podrá pasar argumentos de línea de comando a sus programas usando
IDLE).
Proyecto: Casillero de contraseñas
Probablemente tengas cuentas en muchos sitios web diferentes. Es un mal hábito usar la
misma contraseña para cada uno de ellos porque si alguno de esos sitios tiene una brecha de
seguridad, los piratas informáticos aprenderán la contraseña de todas sus otras cuentas. Es
mejor usar un software de administrador de contraseñas en su computadora que use una
contraseña maestra para desbloquear el administrador de contraseñas. Luego, puede copiar la
contraseña de cualquier cuenta en el portapapeles y pegarla en el campo Contraseña del sitio
web.
El programa administrador de contraseñas que creará en este ejemplo no es seguro,
pero ofrece una demostración básica de cómo funcionan dichos programas.
Los Proyectos del Capítulo
Este es el primer “proyecto de capítulo” del libro. De ahora en adelante, cada capítulo
tendrá proyectos que demuestren los conceptos cubiertos en el capítulo. Los proyectos
están escritos en un estilo que lo lleva de una ventana de editor de archivos en blanco a
un programa de trabajo completo. Al igual que con los ejemplos de shell interactivos, no
solo lea las secciones del proyecto, ¡sígalos en su computadora!
Paso 1: Diseño del programa y estructuras de datos
Desea poder ejecutar este programa con un argumento de línea de comandos que sea el
nombre de la cuenta, por ejemplo, correo electrónico o blog. La contraseña de esa cuenta se
copiará en el portapapeles para que el usuario pueda pegarla en un campo de Contraseña.
De esta forma, el usuario puede tener contraseñas largas y complicadas sin tener que
memorizarlas.
Abra una nueva ventana del editor de archivos y guarde el programa como pw.py. Necesitas
para iniciar el programa con un #! (shebang) línea (ver Apéndice B) y también debe escribir un
comentario que describa brevemente el programa. Dado que desea asociar el nombre de cada
cuenta con su contraseña, puede almacenarlos como
136 Capítulo 6
Machine Translated by Google
cadenas en un diccionario. El diccionario será la estructura de datos que organiza los
datos de su cuenta y contraseña. Haga que su programa se vea como el siguiente:
#! pitón3
# pw.py - Un programa de bloqueo de contraseña inseguro.
CONTRASEÑAS = {'correo electrónico': 'F7minlBDDuvMJuxESSKHFhTxFtjVB6',
'blog': 'VmALvQyKAxiVH5G8v01if1MLZF3sdt',
'equipaje': '12345'}
Paso 2: manejar los argumentos de la línea de comandos
Los argumentos de la línea de comandos se almacenarán en la variable sys.argv.
(Consulte el Apéndice B para obtener más información sobre cómo usar los argumentos
de la línea de comandos en sus programas). El primer elemento de la lista sys.argv
siempre debe ser una cadena que contenga el nombre de archivo del programa ('pw.py'),
y el segundo elemento debe ser el primer argumento de la línea de comando. Para este
programa, este argumento es el nombre de la cuenta cuya contraseña desea. Dado que
el argumento de la línea de comando es obligatorio, muestra un mensaje de uso al usuario
si se olvida de agregarlo (es decir, si la lista sys.argv tiene menos de dos valores). Haga
que su programa se vea como el siguiente:
#! pitón3
# pw.py - Un programa de bloqueo de contraseña inseguro.
CONTRASEÑAS = {'correo electrónico': 'F7minlBDDuvMJuxESSKHFhTxFtjVB6',
'blog': 'VmALvQyKAxiVH5G8v01if1MLZF3sdt',
'equipaje': '12345'}
sistema de importación
si len(sys.argv) < 2:
print('Uso: python pw.py [cuenta] - copiar contraseña de la cuenta')
sys.exit()
cuenta = sys.argv[1]
# primera línea de comando arg es el nombre de la cuenta
Paso 3: copia la contraseña correcta
Ahora que el nombre de la cuenta está almacenado como una cadena en la cuenta
variable, debe ver si existe en el diccionario de CONTRASEÑAS como clave. Si es así,
desea copiar el valor de la clave en el portapapeles usando pyperclip.copy(). (Dado que
está utilizando el módulo pyperclip , debe importarlo). Tenga en cuenta que en realidad
no necesita la variable de cuenta ; simplemente podría usar sys.argv[1] en todos los
lugares donde se usa la cuenta en este programa. Pero una cuenta con nombre variable
es mucho más legible que algo críptico como sys.argv[1].
Haga que su programa se vea como el siguiente:
#! pitón3
# pw.py - Un programa de bloqueo de contraseña inseguro.
Manipulación de cadenas
137
Machine Translated by Google
CONTRASEÑAS = {'correo electrónico': 'F7minlBDDuvMJuxESSKHFhTxFtjVB6',
'blog': 'VmALvQyKAxiVH5G8v01if1MLZF3sdt',
'equipaje': '12345'}
sistema de importación, pyperclip
si len(sys.argv) < 2:
print('Uso: py pw.py [cuenta] - copiar contraseña de la cuenta')
sys.exit()
cuenta = sys.argv[1]
# primera línea de comando arg es el nombre de la cuenta
si cuenta en CONTRASEÑAS:
pyperclip.copy(CONTRA SEÑAS[cuenta] )
'
'
print('Contraseña para + cuenta + else: Copiado al portapapeles.')
'
print('No hay ninguna cuenta nombrada + cuenta)
Este nuevo código busca en el diccionario de CONTRASEÑAS el nombre de la cuenta.
Si el nombre de la cuenta es una clave en el diccionario, obtenemos el valor correspondiente a
esa clave, lo copiamos en el portapapeles e imprimimos un mensaje que dice que copiamos el
valor. De lo contrario, imprimimos un mensaje diciendo que no hay ninguna cuenta con ese nombre.
Ese es el guión completo. Usando las instrucciones del Apéndice B para iniciar programas
de línea de comandos fácilmente, ahora tiene una forma rápida de copiar las contraseñas de su
cuenta en el portapapeles. Tendrás que modificar el valor del diccionario PASSWORDS en la
fuente cada vez que quieras actualizar el programa con una nueva contraseña.
Por supuesto, probablemente no desee guardar todas sus contraseñas en un solo lugar
donde cualquiera pueda copiarlas fácilmente. Pero puede modificar este programa y usarlo para
copiar rápidamente texto normal al portapapeles. Digamos que está enviando varios correos
electrónicos que tienen muchos de los mismos párrafos comunes en común. Podría poner cada
párrafo como un valor en el diccionario de CONTRASEÑAS (probablemente quiera cambiar el
nombre del diccionario en este punto), y luego tendría una forma de seleccionar y copiar
rápidamente una de las muchas piezas de texto estándar en el portapapeles. .
En Windows, puede crear un archivo por lotes para ejecutar este programa con la ventana
Win-R Run. (Para obtener más información sobre los archivos por lotes, consulte el Apéndice B).
Escriba lo siguiente en el editor de archivos y guarde el archivo como pw.bat en la carpeta C:\Windows :
@py.exe C:\Python34\pw.py %*
@pausa
Con este archivo por lotes creado, ejecutar el programa de protección de contraseñas en
Windows es solo cuestión de presionar win-R y escribir pw <nombre de cuenta>.
138 Capítulo 6
Machine Translated by Google
Proyecto: Adición de viñetas al marcado Wiki
Al editar un artículo de Wikipedia, puede crear una lista con viñetas colocando cada
elemento de la lista en su propia línea y colocando una estrella al frente. Pero
supongamos que tiene una lista realmente grande a la que desea agregar viñetas.
Podría escribir esas estrellas al comienzo de cada línea, una por una. O puede
automatizar esta tarea con un breve script de Python.
El script bulletPointAdder.py obtendrá el texto del portapapeles, agregará una
estrella y un espacio al comienzo de cada línea y luego pegará este nuevo texto en
el portapapeles. Por ejemplo, si copié el siguiente texto (para el artículo de Wikipedia
"Lista de listas de listas") en el portapapeles:
Listas de animales
Listas de la vida del acuario
Listas de biólogos por abreviatura de autor
Listas de cultivares
y luego ejecutó el programa bulletPointAdder.py , el portapapeles contendría lo
siguiente:
* Listas de animales
* Listas de vida del acuario
* Listas de biólogos por abreviatura de autor
* Listas de cultivares
Este texto con el prefijo de estrella está listo para pegarse en un artículo de Wikipedia como
lista con viñetas.
Paso 1: copiar y pegar desde el portapapeles
Desea que el programa bulletPointAdder.py haga lo siguiente:
1. Pegar texto desde el portapapeles
2. Hazle algo
3. Copie el nuevo texto en el portapapeles
Ese segundo paso es un poco complicado, pero los pasos 1 y 3 son bastante
sencillos: solo involucran las funciones pyperclip.copy() y pyperclip.paste() . Por
ahora, solo escribamos la parte del programa que cubre los pasos 1 y 3. Ingrese
lo siguiente y guarde el programa como bulletPointAdder.py:
#! pitón3
# bulletPointAdder.py - Añade viñetas de Wikipedia al principio
# de cada línea de texto en el portapapeles.
importar clipper
texto = pyperclip.paste()
Manipulación de cadenas 139
Machine Translated by Google
# TODO: Separa líneas y agrega estrellas.
pyperclip.copiar(texto)
El comentario TODO es un recordatorio de que debe completar esta parte del programa
eventualmente. El siguiente paso es implementar realmente esa parte del programa.
Paso 2: separe las líneas de texto y agregue la estrella
La llamada a pyperclip.paste() devuelve todo el texto en el portapapeles como una gran cadena.
Si usamos el ejemplo de "Lista de listas de listas", la cadena almacenada en el texto se vería así:
'Listas de animales\nListas de vida del acuario\nListas de biólogos por abreviatura
de autor\nListas de cultivares'
Los caracteres \n de nueva línea en esta cadena hacen que se muestre con varias líneas
cuando se imprime o se pega desde el portapapeles. Hay muchas "líneas" en este valor de
cadena. Desea agregar una estrella al comienzo de cada una de estas líneas.
Podría escribir un código que busque cada \n carácter de nueva línea en la cadena y luego
agregue la estrella justo después de eso. Pero sería más fácil usar el método split() para devolver
una lista de cadenas, una para cada línea en la cadena original, y luego agregar la estrella al
frente de cada cadena en la lista.
Haga que su programa se vea como el siguiente:
#! pitón3
# bulletPointAdder.py - Añade viñetas de Wikipedia al principio
# de cada línea de texto en el portapapeles.
importar clipper
texto = pyperclip.paste()
# Separe líneas y agregue estrellas.
lineas = texto.split('\n')
for i in range(len(lines)):
# recorrer todos los índices en la lista de "líneas"
'* '
lines[i] = + lin e s[i]a#gregar estrella a cada cadena en la lista de "líneas"
pyperclip.copiar(texto)
Dividimos el texto a lo largo de sus nuevas líneas para obtener una lista en la que cada
elemento es una línea del texto. Almacenamos la lista en líneas y luego recorremos los elementos
en líneas. Para cada línea, agregamos una estrella y un espacio al comienzo de la línea. Ahora
cada cadena en líneas comienza con una estrella.
140 Capítulo 6
Machine Translated by Google
Paso 3: Une las Líneas Modificadas
La lista de líneas ahora contiene líneas modificadas que comienzan con estrellas.
Pero pyperclip.copy() espera un único valor de cadena, no una lista de valores de cadena.
Para hacer que este valor de cadena única, pase líneas al método join() para obtener una
sola cadena unida de las cadenas de la lista. Haga que su programa se vea como el
siguiente:
#! pitón3
# bulletPointAdder.py - Añade viñetas de Wikipedia al principio
# de cada línea de texto en el portapapeles.
importar clipper
texto = pyperclip.paste()
# Separe líneas y agregue estrellas.
lineas = texto.split('\n')
for i in range(len(lines)):
# recorrer todos los índices para la lista de "líneas"
lines[i] = + lin'*e's[i] a#gregar estrella a cada cadena en la lista de "líneas"
texto = '\n'.join(líneas)
pyperclip.copiar(texto)
Cuando se ejecuta este programa, reemplaza el texto en el portapapeles con texto
que tiene estrellas al comienzo de cada línea. Ahora el programa está completo y puede
intentar ejecutarlo con el texto copiado en el portapapeles.
Incluso si no necesita automatizar esta tarea específica, es posible que desee automatizar
algún otro tipo de manipulación de texto, como eliminar los espacios finales del final de las
líneas o convertir el texto a mayúsculas o minúsculas.
Sean cuales sean sus necesidades, puede utilizar el portapapeles para entrada y salida.
Resumen
El texto es una forma común de datos, y Python viene con muchos métodos de cadena útiles
para procesar el texto almacenado en valores de cadena. Hará uso de métodos de indexación,
división y cadenas en casi todos los programas de Python que escriba.
Los programas que está escribiendo ahora no parecen demasiado sofisticados: no tienen
interfaces gráficas de usuario con imágenes y texto colorido. Hasta ahora, está mostrando
texto con print() y permitiendo que el usuario ingrese texto con input().
Sin embargo, el usuario puede ingresar rápidamente grandes cantidades de texto a través del
portapapeles. Esta capacidad proporciona una vía útil para escribir programas que manipulan
grandes cantidades de texto. Es posible que estos programas basados en texto no tengan
ventanas o gráficos llamativos, pero pueden realizar una gran cantidad de trabajo útil rápidamente.
Otra forma de manipular grandes cantidades de texto es leer y escribir.
archivos directamente del disco duro. Aprenderá cómo hacer esto con Python en el próximo
capítulo.
Manipulación de cadenas
141
Machine Translated by Google
Preguntas de práctica
1. ¿Qué son los caracteres de escape?
2. ¿Qué representan los caracteres de escape \n y \t ?
3. ¿Cómo se puede poner un carácter de \ barra invertida en una cadena?
4. El valor de la cadena "El castillo ambulante de Howl" es una cadena válida. ¿Por qué
no es un problema que el carácter de comilla simple en la palabra Howl no se
escape?
5. Si no quiere poner \n en su cadena, ¿cómo puede escribir una cadena con saltos de
línea?
6. ¿A qué equivalen las siguientes expresiones?
• '¡Hola mundo!'[1]
• '¡Hola mundo!'[0:5]
• '¡Hola mundo!'[:5]
• '¡Hola mundo!'[3:]
7. ¿A qué equivalen las siguientes expresiones?
• 'Hola'.superior()
• 'Hola'.upper().isupper()
• 'Hola'.superior().inferior()
8. ¿A qué equivalen las siguientes expresiones?
• 'Recuerda, recuerda, el cinco de noviembre.'.split()
• '-'.join('Solo puede haber uno.'.split())
9. ¿Qué métodos de cadena puede usar para justificar a la derecha, a la izquierda y al centro?
¿una cuerda?
10. ¿Cómo puede recortar los caracteres de espacio en blanco desde el principio o el final de
¿una cuerda?
Proyecto de práctica
Para practicar, escribe un programa que haga lo siguiente.
Impresora de mesa
Escriba una función llamada printTable() que tome una lista de cadenas y la muestre
en una tabla bien organizada con cada columna justificada a la derecha.
Suponga que todas las listas internas contendrán el mismo número de cadenas.
Por ejemplo, el valor podría verse así:
tableData = [['manzanas', 'naranjas', 'cerezas', 'plátano'],
['Alice', 'Bob', 'Carol', 'David'],
['perros', 'gatos', 'alces', 'gansos']]
142 Capítulo 6
Machine Translated by Google
Su función printTable() imprimiría lo siguiente:
manzanas alicia perros
naranjas Bob gatos
cerezas Carol alce
plátano David ganso
Sugerencia: su código primero tendrá que encontrar la cadena más larga en cada una de las listas
internas para que toda la columna pueda ser lo suficientemente ancha como para que quepan todas las cadenas.
Puede almacenar el ancho máximo de cada columna como una lista de números
enteros. La función printTable() puede comenzar con colWidths = [0] * len(tableData),
lo que creará una lista que contenga el mismo número de valores 0 que el número de
listas internas en tableData. De esa forma, colWidths[0] puede almacenar el ancho de
la cadena más larga en tableData[0], colWidths[1] puede almacenar el ancho de la
cadena más larga en tableData[1], y así sucesivamente. Luego puede encontrar el valor
más grande en la lista colWidths para averiguar qué ancho entero pasar al método de
cadena rjust() .
Manipulación de cadenas 143
Machine Translated by Google
Machine Translated by Google
Parte II
Automatización de tareas
Machine Translated by Google
Machine Translated by Google
7
Coincidencia de patrones con
Expresiones regulares
Es posible que esté familiarizado con la búsqueda
de texto presionando ctrl-F y escribiendo las
palabras que está buscando. Las expresiones
regulares van un paso más allá: te permiten especificar un patrón
de texto a buscar. Es posible que no sepa el número de
teléfono exacto de una empresa, pero si vive en los Estados
Unidos o Canadá, sabe que serán tres dígitos, seguidos de
un guión y luego cuatro dígitos más (y opcionalmente, un código de área de tres dígitos al
principio). Así es como usted, como ser humano, reconoce un número de teléfono cuando
lo ve: 415-555-1234 es un número de teléfono, pero 4,155,551,234 no lo es.
Las expresiones regulares son útiles, pero no muchos no programadores las
conocen a pesar de que la mayoría de los editores de texto y procesadores de texto
modernos, como Microsoft Word u OpenOffice, tienen funciones de búsqueda y
búsqueda y reemplazo que pueden buscar en función de expresiones regulares. Las
expresiones regulares ahorran mucho tiempo, no solo para los usuarios de software sino también para
Machine Translated by Google
programadores De hecho, el escritor de tecnología Cory Doctorow argumenta que
incluso antes de enseñar programación, deberíamos enseñar expresiones regulares:
“Conocer [expresiones regulares] puede significar la diferencia entre resolver
un problema en 3 pasos y resolverlo en 3000 pasos. Cuando eres un nerd, te
olvidas de que los problemas que resuelves con un par de pulsaciones de
teclas pueden llevar a otras personas días de trabajo tedioso y propenso a
errores para resolverlos.”1
En este capítulo, comenzará escribiendo un programa para encontrar patrones
de texto sin usar expresiones regulares y luego verá cómo usar expresiones regulares
para hacer que el código sea mucho menos inflado. Le mostraré la coincidencia básica
con expresiones regulares y luego pasaré a algunas características más potentes, como
la sustitución de cadenas y la creación de sus propias clases de caracteres. Finalmente,
al final del capítulo, escribirá un programa que pueda extraer automáticamente números
de teléfono y direcciones de correo electrónico de un bloque de texto.
Búsqueda de patrones de texto sin expresiones regulares
Digamos que quiere encontrar un número de teléfono en una cadena. Conoces el
patrón: tres números, un guión, tres números, un guión y cuatro números.
Aquí hay un ejemplo: 415-555-4242.
Usemos una función llamada isPhoneNumber() para verificar si una cadena
coincide con este patrón, devolviendo True o False. Abra una nueva ventana del editor
de archivos e ingrese el siguiente código; luego guarde el archivo como isPhoneNumber.py:
def esNúmeroTeléfono(texto):
u si len(texto) != 12:
falso retorno
v
para i en el rango (0, 3):
si no es texto[i].isdecimal():
falso retorno
w si texto[3] != '-':
falso retorno
para i en el rango (4, 7):
si no es texto[i].isdecimal():
falso retorno
y si texto[7] != '-':
falso retorno
X
z
para i en el rango (8, 12):
si no es texto[i].isdecimal():
falso retorno
imprimir('415-555-4242 es un número de teléfono:')
imprimir(esNúmeroTeléfono('415-555-4242'))
print('Moshi moshi es un número de teléfono:')
print(esNúmeroTeléfono('Moshi moshi'))
1. Cory Doctorow, "Esto es lo que las TIC realmente deberían enseñar a los niños: cómo hacer expresiones regulares"
Guardian, 4 de diciembre de 2012, http:// www.theguardian.com/ technology/ 2012/ dec/ 04/ ict-teach-kids
-expresiones regulares/.
148 Capítulo 7
Machine Translated by Google
Cuando se ejecuta este programa, la salida se ve así:
415-555-4242 es un número de teléfono:
Verdadero
Moshi moshi es un número de teléfono:
Falso
La función isPhoneNumber() tiene un código que realiza varias comprobaciones para
ver si la cadena de texto es un número de teléfono válido. Si alguna de estas comprobaciones
falla, la función devuelve False. Primero, el código verifica que la cadena tenga exactamente
12 caracteres u. Luego verifica que el código de área (es decir, los tres primeros caracteres
del texto) contenga solo caracteres numéricos v. El resto de la función verifica que la cadena
siga el patrón de un número de teléfono: El número debe tener el primer guión después del
código de área w, tres caracteres numéricos más x, luego otro guión y, y finalmente cuatro
números más z. Si la ejecución del programa logra superar todas las comprobaciones,
devuelve True {.
Llamar a isPhoneNumber() con el argumento '415-555-4242' devolverá True. Llamar
a isPhoneNumber() con 'Moshi moshi' devolverá False; la primera prueba falla porque
'Moshi moshi' no tiene 12 caracteres.
Tendría que agregar aún más código para encontrar este patrón de texto en una cadena
más grande. Reemplace las últimas cuatro llamadas a la función print() en isPhoneNumber.py
con lo siguiente:
mensaje = 'Llámame al 415-555-1011 mañana. 415-555-9999 es mi oficina.'
para i en el rango (len (mensaje)):
u trozo = mensaje[i:i+12]
v si esNúmeroTeléfono(fragmento):
print('Número de teléfono encontrado:
'
+ trozo)
print('Terminado')
Cuando se ejecuta este programa, la salida se verá así:
Número de teléfono encontrado: 415-555-1011
Número de teléfono encontrado: 415-555-9999
Hecho
En cada iteración del bucle for , se asigna una nueva porción de 12 caracteres del
mensaje a la variable u. Por ejemplo, en la primera iteración, i es 0 y se le asigna el mensaje
[0:12] (es decir, la cadena 'Llámame a las 4').
En la siguiente iteración, i es 1, y se le asigna el mensaje [1:13] (la cadena 'all me at 41').
Pasa el fragmento a isPhoneNumber () para ver si coincide con el patrón de número
de teléfono v, y si es así, imprime el fragmento.
Continúe recorriendo el mensaje y, finalmente, los 12 caracteres del fragmento
serán un número de teléfono. El bucle recorre toda la cadena, prueba cada pieza de 12
caracteres e imprime cualquier parte que encuentre que satisfaga isPhoneNumber (). Una
vez que hayamos terminado de revisar el mensaje, imprimimos Listo.
Coincidencia de patrones con expresiones regulares
149
Machine Translated by Google
Si bien la cadena en el mensaje es corta en este ejemplo, podría tener millones de caracteres
y el programa aún se ejecutaría en menos de un segundo. Un programa similar que encuentra
números de teléfono usando expresiones regulares también se ejecutaría en menos de un segundo,
pero las expresiones regulares hacen que sea más rápido escribir estos programas.
Búsqueda de patrones de texto con expresiones regulares
El programa de búsqueda de números de teléfono anterior funciona, pero usa mucho código
para hacer algo limitado: la función isPhoneNumber() tiene 17 líneas, pero solo puede encontrar
un patrón de números de teléfono. ¿Qué pasa con un número de teléfono formateado como
415.555.4242 o (415) 555-4242? ¿Qué pasaría si el número de teléfono tuviera una extensión,
como 415-555-4242 x99? La función isPhoneNumber() no podría validarlos. Podría agregar aún
más código para estos patrones adicionales, pero hay una manera más fácil.
Las expresiones regulares, llamadas regex para abreviar, son descripciones de un
patrón de texto. Por ejemplo, \d en una expresión regular representa un carácter de dígito :
es decir, cualquier número único del 0 al 9. Python utiliza la expresión regular \d\d\d-\d\d\d-\d\d\d\d
para que coincida con el mismo texto que la función isPhoneNumber() anterior. : una cadena de tres
números, un guión, tres números más, otro guión y cuatro números. Cualquier otra cadena no
coincidiría con la expresión regular \d\d\d-\d\d\d-\d\d \d\d .
Pero las expresiones regulares pueden ser mucho más sofisticadas. Por ejemplo, agregar un
3 entre llaves ({3}) después de un patrón es como decir: "Haz coincidir este patrón tres veces". Por
lo tanto, la expresión regular ligeramente más corta \d{3}-\d{3}-\d{4} también coincide con el formato
de número de teléfono correcto.
Creación de objetos Regex
Todas las funciones de expresiones regulares en Python están en el módulo re . Ingrese lo siguiente
en el shell interactivo para importar este módulo:
>>> importar re
NOTA
mayoría de los ejemplos que siguen en este capítulo requerirán el módulo re , así que recuerde
importarlo al comienzo de cualquier script que escriba o cada vez que reinicie IDLE.
De lo contrario, obtendrá un mensaje de error NameError: el nombre 're' no está definido .
Pasar un valor de cadena que representa su expresión regular a re.compile()
devuelve un objeto de patrón Regex (o simplemente, un objeto Regex ).
Para crear un objeto Regex que coincida con el patrón de número de teléfono, ingrese lo
siguiente en el shell interactivo. (Recuerde que \d significa "un carácter de dígito" y \d\d\d-\d\d\d\d\d\d\d es la expresión regular para el patrón de número de teléfono correcto).
150 Capítulo 7
Machine Translated by Google
>>> phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
Ahora la variable phoneNumRegex contiene un objeto Regex .
Pasar cadenas sin formato a re.compile()
Recuerde que los caracteres de escape en Python usan la barra invertida (\). El valor de
cadena '\n' representa un solo carácter de nueva línea, no una barra invertida seguida de una
n minúscula. Debe ingresar el carácter de escape \\ para imprimir una sola barra invertida. Así
que '\\n' es la cadena que representa una barra invertida seguida de una n minúscula . Sin
embargo, al colocar una r antes de la primera comilla del valor de la cadena, puede marcar la
cadena como una cadena sin formato, que no se escapa de los caracteres.
Dado que las expresiones regulares suelen utilizar barras invertidas, es conveniente
pasar cadenas sin procesar a la función re.compile() en lugar de escribir barras invertidas
adicionales. Escribir r'\d\d\d-\d\d\d-\d\d\d\d' es mucho más fácil que escribir '\\d\\d\\d-\\d\\d\\ d\\d\\d\\d\\d'.
Coincidencia de objetos
Regex El método search() de un objeto Regex busca en la cadena que se le pasa cualquier
coincidencia con la expresión regular. El método search() devolverá Ninguno si el patrón de
expresión regular no se encuentra en la cadena. Si se encuentra el patrón , el método search()
devuelve un objeto Match . Los objetos de coincidencia tienen un método group() que devolverá el
texto coincidente real de la cadena buscada. (Explicaré los grupos en breve). Por ejemplo, ingrese
lo siguiente en el shell interactivo:
>>> phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
>>> mes = phoneNumRegex.search('Mi número es 415-555-4242.')
'
>>> print('Número de teléfono encontrado: + mes.grupo())
Número de teléfono encontrado: 415-555-4242
El nombre de la variable mo es solo un nombre genérico para usar con los objetos Match .
Este ejemplo puede parecer complicado al principio, pero es mucho más corto que el programa
isPhoneNumber.py anterior y hace lo mismo.
Aquí, pasamos nuestro patrón deseado a re.compile() y almacenamos el objeto Regex resultante
en phoneNumRegex. Luego llamamos a search() en phoneNumRegex y pasamos search() la cadena
que queremos buscar para una coincidencia. El resultado de la búsqueda se almacena en la variable
mo. En este ejemplo, sabemos que nuestro patrón se encontrará en la cadena, por lo que sabemos
que se devolverá un objeto Match .
Sabiendo que mo contiene un objeto Match y no el valor nulo None, podemos llamar a group() en mo
para devolver la coincidencia. Escribir mo.group() dentro de nuestra declaración de impresión muestra
la coincidencia completa, 415-555-4242.
Coincidencia de patrones con expresiones regulares
151
Machine Translated by Google
Revisión de la coincidencia de expresiones regulares
Si bien hay varios pasos para usar expresiones regulares en Python, cada paso es bastante
simple.
1. Importe el módulo regex con import re.
2. Cree un objeto Regex con la función re.compile() . (Recuerde usar un
cuerda cruda.)
3. Pase la cadena que desea buscar en el método search() del objeto Regex .
Esto devuelve un objeto Match .
4. Llame al método group() del objeto Match para devolver una cadena del texto coincidente
real.
NOTA
bien lo animo a ingresar el código de ejemplo en el shell interactivo, también debe utilizar probadores
de expresiones regulares basados en la web, que pueden mostrarle exactamente cómo una
expresión regular coincide con un fragmento de texto que ingresa. Recomiendo el probador en http://
regexpal.com/.
Más coincidencia de patrones con expresiones regulares
Ahora que conoce los pasos básicos para crear y encontrar objetos de expresión regular con
Python, está listo para probar algunas de sus capacidades más poderosas de coincidencia de
patrones.
Agrupación con paréntesis
Digamos que desea separar el código de área del resto del número de teléfono.
Agregar paréntesis creará grupos en la expresión regular: (\d\d\d)-(\d\d\d-\d\d\d\d).
Luego puede usar el método de objeto de coincidencia group() para obtener el texto coincidente
de un solo grupo.
El primer conjunto de paréntesis en una cadena de expresiones regulares será el grupo 1.
El segundo conjunto será el grupo 2. Al pasar el número entero 1 o 2 al método de objeto de
coincidencia group() , puede tomar diferentes partes del texto coincidente. pasando 0
o nada al método group() devolverá el texto coincidente completo. Ingrese lo siguiente en el shell
interactivo:
>>> phoneNumRegex = re.compile(r'(\d\d\d)-(\d\d\d-\d\d\d\d)')
>>> mes = phoneNumRegex.search('Mi número es 415-555-4242.')
>>> mes.grupo(1)
'415'
>>> mes.grupo(2)
'555-4242'
>>> mes.grupo(0)
'415-555-4242'
>>> mes.grupo()
'415-555-4242'
152 Capítulo 7
Machine Translated by Google
Si desea recuperar todos los grupos a la vez, use los grupos ()
método: tenga en cuenta la forma plural del nombre.
>>> meses.grupos()
('415', '555-4242')
>>> código de área, númeroprincipal = mes.grupos()
>>> imprimir (código de área)
415
>>> print(numeroprincipal)
555-4242
Dado que mo.groups() devuelve una tupla de múltiples valores, puede usar el
truco de asignación múltiple para asignar cada valor a una variable separada, como en la
línea anterior areaCode, mainNumber = mo.groups() .
Los paréntesis tienen un significado especial en las expresiones regulares, pero ¿qué
haces si necesitas hacer coincidir un paréntesis en tu texto? Por ejemplo, tal vez los números
de teléfono que está tratando de hacer coincidir tengan el código de área establecido entre
paréntesis. En este caso, debe escapar de los caracteres ( y ) con una barra invertida.
Ingrese lo siguiente en el shell interactivo:
>>> phoneNumRegex = re.compile(r'(\(\d\d\d\)) (\d\d\d-\d\d\d\d)')
>>> mo = phoneNumRegex.search('Mi número de teléfono es (415) 555-4242.')
>>> mes.grupo(1)
'(415)'
>>> mes.grupo(2)
'555-4242'
Los caracteres de escape \( y \) en la cadena sin formato pasada a re.compile()
coincidirá con los caracteres de paréntesis reales.
Coincidencia de varios grupos con la tubería
el | carácter se llama tubería. Puede usarlo en cualquier lugar que desee para que coincida
con una de las muchas expresiones. Por ejemplo, la expresión regular r'Batman|Tina Fey'
coincidirá con 'Batman' o 'Tina Fey'.
Cuando tanto Batman como Tina Fey aparecen en la cadena buscada, la primera
aparición de texto coincidente se devolverá como el objeto Match . Ingrese lo siguiente en el
shell interactivo:
>>> heroRegex = re.compilar (r'Batman|Tina Fey')
>>> mo1 = heroRegex.search('Batman y Tina Fey.')
>>> mo1.grupo()
'Hombre murciélago'
>>> mo2 = heroRegex.search('Tina Fey y Batman.')
>>> mo2.grupo()
'Tina Fey'
NOTA Puede encontrar todas las ocurrencias coincidentes con el método findall() que se describe en
“El método findall() ” en la página 157.
Coincidencia de patrones con expresiones regulares 153
Machine Translated by Google
También puede usar la canalización para hacer coincidir uno de varios patrones como
parte de su expresión regular. Por ejemplo, supongamos que desea hacer coincidir cualquiera
de las cadenas 'Batman', 'Batmobile', 'Batcopter' y 'Batbat'. Dado que todas estas cadenas
comienzan con Bat, sería bueno si pudiera especificar ese prefijo solo una vez. Esto se puede
hacer con paréntesis. Ingrese lo siguiente en el shell interactivo:
>>> batRegex = re.compile(r'Bat(man|mobile|copter|bat)')
>>> mo = batRegex.search('Batimóvil perdió una rueda')
>>> mes.grupo()
'Batimóvil'
>>> mes.grupo(1)
'móvil'
La llamada al método mo.group() devuelve el texto coincidente completo 'Batmóvil',
mientras que mo.group(1) devuelve solo la parte del texto coincidente dentro del primer
grupo de paréntesis, 'móvil'. Al usar el carácter de canalización y agrupar paréntesis, puede
especificar varios patrones alternativos que le gustaría que coincidieran con su expresión
regular.
Si necesita hacer coincidir un carácter de tubería real, escápelo con una barra
invertida, como \|.
Emparejamiento opcional con el signo de interrogación
A veces hay un patrón que desea hacer coincidir solo opcionalmente. Es decir, la expresión
regular debe encontrar una coincidencia ya sea que ese fragmento de texto esté allí o no.
el ? carácter marca el grupo que lo precede como una parte opcional del patrón. Por
ejemplo, ingrese lo siguiente en el shell interactivo:
>>> batRegex = re.compile(r'Bat(wo)?man')
>>> mo1 = batRegex.search('Las aventuras de Batman')
>>> mo1.grupo()
'Hombre murciélago'
>>> mo2 = batRegex.search('Las aventuras de Batwoman')
>>> mo2.grupo()
'Batwoman'
El (wo)? parte de la expresión regular significa que el patrón wo es un grupo opcional.
La expresión regular coincidirá con el texto que tiene cero instancias o una instancia de wo
en él. Esta es la razón por la que la expresión regular coincide con 'Batwoman' y
'Hombre murciélago'.
Usando el ejemplo anterior del número de teléfono, puede hacer que la expresión regular
busque números de teléfono que tengan o no un código de área. Ingrese lo siguiente en el shell
interactivo:
>>> phoneRegex = re.compile(r'(\d\d\d-)?\d\d\d-\d\d\d\d')
>>> mo1 = phoneRegex.search('Mi número es 415-555-4242')
>>> mo1.grupo()
'415-555-4242'
154 Capítulo 7
Machine Translated by Google
>>> mo2 = phoneRegex.search('Mi número es 555-4242')
>>> mo2.grupo()
'555-4242'
¿Puedes pensar en el ? como si dijera: “Haga coincidir cero o uno del grupo que
precede a este signo de interrogación”.
Si necesita hacer coincidir un carácter de signo de interrogación real, escápelo con \?.
Coincidencia de cero o más con la estrella
El * (llamado estrella o asterisco) significa "coincidencia con cero o más": el grupo que
precede a la estrella puede aparecer cualquier número de veces en el texto. Puede estar
completamente ausente o repetirse una y otra vez. Veamos de nuevo el ejemplo de Batman.
>>> batRegex = re.compile(r'Bat(wo)*man')
>>> mo1 = batRegex.search('Las aventuras de Batman')
>>> mo1.grupo()
'Hombre murciélago'
>>> mo2 = batRegex.search('Las aventuras de Batwoman')
>>> mo2.grupo()
'Batwoman'
>>> mo3 = batRegex.search('Las aventuras de Batwowowowoman')
>>> mo3.grupo()
'Batwowowomujer'
Para 'Batman', la parte (wo)* de la expresión regular coincide con cero instancias de wo
en la cadena; para 'Batwoman', el (wo)* coincide con una instancia de wo; y para
'Batwowowowoman', (wo)* coincide con cuatro instancias de wo.
Si necesita hacer coincidir un carácter de estrella real, prefije la estrella en la expresión
regular con una barra invertida, \*.
Coincidencia de uno o más con el Plus
Mientras que * significa "coincidir con cero o más", el + (o más) significa "coincidir con uno
o más". A diferencia de la estrella, que no requiere que su grupo aparezca en la cadena
coincidente, el grupo que precede a un signo más debe aparecer al menos una vez. No es
opcional. Ingrese lo siguiente en el shell interactivo y compárelo con las expresiones
regulares de estrella en la sección anterior:
>>> batRegex = re.compile(r'Bat(wo)+man')
>>> mo1 = batRegex.search('Las aventuras de Batwoman')
>>> mo1.grupo()
'Batwoman'
>>> mo2 = batRegex.search('Las aventuras de Batwowowowoman')
>>> mo2.grupo()
'Batwowowomujer'
Coincidencia de patrones con expresiones regulares
155
Machine Translated by Google
>>> mo3 = batRegex.search('Las aventuras de Batman')
>>> mo3 == Ninguno
Verdadero
La expresión regular Bat(wo)+man no coincidirá con la cadena 'The Adventures of
Batman' porque el signo más requiere al menos un wo .
Si necesita hacer coincidir un carácter de signo más real, prefije el signo más
con una barra invertida para escapar: \+.
Coincidencia de repeticiones específicas con corchetes
Si tiene un grupo que desea repetir un número específico de veces, siga al grupo en su
expresión regular con un número entre llaves. Por ejemplo, la expresión regular (Ha){3}
coincidirá con la cadena 'HaHaHa', pero no con 'HaHa', ya que esta última tiene solo dos
repeticiones del grupo (Ha) .
En lugar de un número, puede especificar un rango escribiendo un mínimo, una coma y un
máximo entre llaves. Por ejemplo, la expresión regular (Ha){3,5} coincidirá con 'HaHaHa', 'HaHaHaHa'
y 'HaHaHaHaHa'.
También puede omitir el primer o segundo número entre llaves para dejar el mínimo o
el máximo sin límites. Por ejemplo, (Ha){3,} coincidirá con tres o más instancias del grupo
(Ha) , mientras que (Ha){,5} coincidirá con cero a cinco instancias. Los corchetes pueden
ayudar a acortar sus expresiones regulares. Estas dos expresiones regulares coinciden con
patrones idénticos:
(Ha){3}
(Jajaja)
Y estas dos expresiones regulares también coinciden con patrones idénticos:
(Ha){3,5}
((Ha)(Ha)(Ha))|((Ha)(Ha)(Ha)(Ha))|((Ha)(Ha)(Ha)(Ha)(Ha))
Ingrese lo siguiente en el shell interactivo:
>>> haRegex = re.compilar(r'(Ha){3}')
>>> mo1 = haRegex.search('HaHaHa')
>>> mo1.grupo()
'Jajaja'
>>> mo2 = haRegex.search('Ha')
>>> mo2 == Ninguno
Verdadero
Aquí, (Ha){3} coincide con 'HaHaHa' pero no con 'Ha'. Dado que no coincide con 'Ha', search()
devuelve Ninguno.
Emparejamiento codicioso y no codicioso
Dado que (Ha){3,5} puede coincidir con tres, cuatro o cinco instancias de Ha en la cadena
'HaHaHaHaHa', es posible que se pregunte por qué la llamada del objeto Match a group() en el
156 Capítulo 7
Machine Translated by Google
El ejemplo anterior de corchetes devuelve 'HaHaHaHaHa' en lugar de las posibilidades más
cortas. Después de todo, 'HaHaHa' y 'HaHaHaHa' también son coincidencias válidas de la
expresión regular (Ha){3,5}.
Las expresiones regulares de Python son codiciosas por defecto, lo que significa que
en situaciones ambiguas coincidirán con la cadena más larga posible. La versión no codiciosa
de los corchetes, que coincide con la cadena más corta posible, tiene el corchete de cierre
seguido de un signo de interrogación.
Ingrese lo siguiente en el shell interactivo y observe la diferencia entre las formas
codiciosas y no codiciosas de los corchetes que buscan la misma cadena:
>>> codiciosoHaRegex = re.compile(r'(Ha){3,5}')
>>> mo1 = codiciosoHaRegex.buscar('HaHaHaHaHa')
>>> mo1.grupo()
'Jajajajaja'
>>> no codiciosoHaRegex = re.compile(r'(Ha){3,5}?')
>>> mo2 = nongreedyHaRegex.search('HaHaHaHaHa')
>>> mo2.grupo()
'Jajaja'
Tenga en cuenta que el signo de interrogación puede tener dos significados en las
expresiones regulares: declarar una coincidencia no codiciosa o marcar un grupo opcional.
Estos significados no tienen ninguna relación.
El método findall()
Además del método search() , los objetos Regex también tienen un findall()
método. Mientras que search() devolverá un objeto Match del primer texto coincidente en
la cadena buscada, el método findall() devolverá las cadenas de cada
coincidencia en la cadena buscada. Para ver cómo search() devuelve un objeto Match solo
en la primera instancia de texto coincidente, ingrese lo siguiente en el shell interactivo:
>>> phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
>>> mes = phoneNumRegex.search('Celular: 415-555-9999 Trabajo: 212-555-0000')
>>> mes.grupo()
'415-555-9999'
Por otro lado, findall() no devolverá un objeto Match sino una lista de cadenas, siempre
que no haya grupos en la expresión regular. Cada cadena en la lista es una parte del texto
buscado que coincidió con la expresión regular.
Ingrese lo siguiente en el shell interactivo:
>>> phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d') # no tiene grupos
>>> phoneNumRegex.findall('Celular: 415-555-9999 Trabajo: 212-555-0000')
['415-555-9999', '212-555-0000']
Si hay grupos en la expresión regular, findall() devolverá una lista de tuplas. Cada tupla
representa una coincidencia encontrada y sus elementos son los
Coincidencia de patrones con expresiones regulares 157