Machine Translated by Google

Machine Translated by Google

Conceptos básicos de Python: una introducción

práctica a Python 3

Pitón real
Machine Translated by Google

Conceptos básicos de Python

Fletcher Heisler, David Amos, Dan Bader, Joanna Jablonski

Copyright © Real Python (realpython.com), 2012­2020

Para obtener información en línea y realizar pedidos de este y otros libros de Real
Python, visite realpython.com. Para obtener más información, contáctenos en
[email protected].

ISBN: 9781775093329 (rústica)

ISBN: 9781775093336 (electrónico)

Diseño de portada por Aldren Santos.

“Python” y los logotipos de Python son marcas comerciales o marcas comerciales

registradas de Python Software Foundation, utilizadas por Real Python con el
permiso de la Fundación.

Gracias por descargar este libro electrónico. Este libro electrónico tiene licencia para
su disfrute personal únicamente. Este libro electrónico no puede revenderse ni
regalarse a otras personas. Si desea compartir este libro con otra persona, compre
una copia adicional para cada destinatario. Si está leyendo este libro y no lo compró,
o no lo compró para su uso exclusivo, regrese a realpython.com/pybasics­book y
compre su propia copia. Gracias por respetar el arduo trabajo detrás de este libro.

Actualizado el 25 de febrero de 2020 Nos gustaría agradecer a nuestros lectores de

acceso temprano por sus excelentes comentarios: Zoheb Ainapore, Marc, Ricky
Mitchell, Meir Guttman, Robert Livingston, Ricky, Jeffrey Hansen, Albrecht, Larry
Eisenberg, Kilimandaros, Joanna Jablonski, Mursalin. Simp­son, Xu Chunyang,
Ward Walker, W., Vlad, jima, Vivek, Srinivasan Samuel, Patrick Starrenburg, marp,
Jorge Alberch, Edythe, Miguel Galán, Tom Carnevale, Florent, Albrecht Kadauke,
Hans van Nielen, Youri Torchalski, Gavin, Karen H Calhoun MD, Roman, Robert
Robb Livingston, Terence Phillips, Nico, Daniel, Kumaran Rajendhiran, Ty Wait,
david fullerton, Robert, Nicklas, Jacob Andersen, Mario,

2
Machine Translated by Google

Alejandro Ramos, Beni_begin, AJ, Melvin, Sean Yang, Sean, Velu.V, Peter
Cavallaro, Charlie Browning 3, Milind Mahajani, Jason Barnes, Lucien Boland,
Adam bretel, William, Veltaine, Jerry Petrey, James, Raymond E Rogers, Espera,
Bimperng Uen, CJ Hwang, Guido, Evan, Dave, Miguel Galan, Han Qi, Jim
Bremner, Matt Chang, Daniel Drazan, Cole, Bob, Reed Howald, Edward Duarte,
Mike Parker, Aart Kleinendorst, rock, Johnny, Rock Lee, Dusan Ranisavljev,
Grant, Jack, Reinhard, Ceejay Cervantes, David, Vivek Vashist, Mark, Dan,
Garett, Peter, Jun Lee, James Silk, Nik Singhal, Charles, Allard Schmidt, Jeff
Desalle, Miguel, Steve Poe, Jonathan Seubert, Marc Poulin, MELVIN, Idris,
Lucas, John Chirico, Wynette Espinosa, JP, Gregory, Mark Edgeller, David
Melanson, Raul Pena, Darrell, Shriram, Tom Flynn, Velu, michael lindsey, Sulo
Kolehmainen, Michael, Jay, Richard, Milos “Ozzyx” Kosik, hans de Cocq, Glen
Mules, Nathan Lundner, Phil, Shubh, Puwei Wang, Alex Mück, Alex, Hitoshi,
Bruno F. De Lima, Dario David, Rajesh, Haroldas Valčiukas, GVeltaine, Susan
Fowle , Jared Simms, Nathan Collins, Dylan, Les Churchman (luckyles en
Pythonistacafe), Stephane LI­THIAO­TE, Frank P, Paul, Damien Murtagh, Jason,
Thắng Lê Quang, Neill, Lele, charles wilson, Damien, Christian, Jon, Andreas
Kreisig, Marco, Mario Panagiotopoulos, nerino, Mariusz, Thomas, Mihhail,
Mikönig, Fabio, Scott, Pedro Torres, Mathias Johansson, Joshua S., Mathias,
scott, David Koppy, Rohit Bharti, Phillip Douglas, John Stephenson, Jeff Jones,
George Mast, Allards, Palak, Nikola N., Palak Kalsi, Annekathrin, Tsung­Ju Yang,
Nick Huntington, Sai, Jordan, Wim Alsemgeest, DJ, Bob Harris, Martin, Andrew,
Reggie Smith, Steve Santy, tstalin22 @gamil.com, Mohee Jarada, Mark Arzaga,
Poulose Matthen, Brent Gordon, Gary Butler, Bryant, Dana, Koajck, Reggie, Luis
Bravo, Elijah, Nikolay, Eric Lietsch, Fred Janssen, Don Stillwell, Gaurav Sharma,
Mike, Mike McKenna, karthik babu, bulat, Bulat Mansurov, August Trillanes,
Darren Saw, Jagadish, Nathan Eger, Kyle, Tejas Shetty, Baba Sariffodeen, Don,
Ian, Ian Barbour, Redhouane, Wayne Rosing, Emanuel, Toigongonbai, Jason
Castillo, krishna chaitanya swamy kesavarapu, Corey Huguley, Nick,
[email protected], xuchunyang, Daniel BUIS, kenneth, Leo­danis Pozo
Ramos, John Phenix, Linda Moran, W Laleau, Troy Flynn, Heber Nielsen, ROCK,
Mike LeRoy, Thomas Davis, Jacob, Szabolcs

3
Machine Translated by Google

Sinka, kalaiselvan, Leanne Kuss, Andrey, omar, Jason Woden, David

Cebalo, John Miller, David Bui (novato), Nico Zanferrari, Ariel, Boris,
Boris Ender, Charlie3, Ossy, Matthias Kuehl, Scott Koch, Jesus
Avina, charlie3 , Awadhesh, Andie, Chris Johnson, Malan, Ciro,
Thamizhselvan, Neha, Christian Langpap, Ivan, Dr. Craig Levy, HB
Robinson, Stéphane, Steve McIlree, Yves, Teresa, Allard, tom cone
jr, Dirk, Joachim van der Weijden , Jim Woodward, Christoph Lipka,
John Vergelli, Gerry, Lu, Robert R., Vlad, Richard Heatwole, Gabriel,
Krzysztof Surowiecki, Alexandra Davis, Jason Voll y Dwayne Dever.
¡Gracias a todos!
Machine Translated by Google

Esta es una versión de acceso anticipado de “Conceptos básicos de Python:

Una introducción práctica a Python 3”
Con tu ayuda podemos hacer que este libro sea aún mejor:

Al final de cada sección del libro encontrará un enlace de comentarios "mágico". Al hacer
clic en el enlace, accederá a un formulario de comentarios en línea donde podrá compartir
sus opiniones con nosotros.

Agradecemos todos y cada uno de los comentarios o sugerencias

de mejora que pueda tener.

Siéntase libre de ser tan conciso o detallado como mejor le parezca. Todos los
comentarios se almacenan de forma anónima, pero puede optar por dejar su nombre e
información de contacto para que podamos realizar un seguimiento o mencionarlo en
nuestra página de "Gracias".

Usamos un enlace de comentarios diferente para cada sección, por lo que siempre
sabremos a qué parte del libro se refieren sus notas.

Gracias por ayudarnos a hacer de este libro un recurso de aprendizaje aún más valioso
para la comunidad Python.

— Dan Bader, editor en jefe de Real Python

Machine Translated by Google

Lo que dicen los Pythonistas sobre los conceptos básicos de Python: una
introducción práctica a Python 3

“¡Me encanta [el libro]! La redacción es informal, fácil de entender y hace que la
información fluya bien. Nunca me siento perdido en el material y no es
demasiado denso, por lo que me resulta fácil repasar capítulos antiguos una y otra vez.
encima.

He visto más de 10 tutoriales/libros/cursos en línea de Python diferentes, ¡y

probablemente he aprendido más de Real Python!

­Thomas Wong

"Tres años después, todavía vuelvo a mis libros de Real Python cuando necesito
un repaso rápido sobre el uso de comandos vitales de Python".

—Rob Fowler

“Estuve dudando durante mucho tiempo tratando de aprender por mi cuenta.

Revisé docenas de tutoriales en línea incompletos. Dormité durante horas de
aburridos screencasts. Renuncié a innumerables libros toscos de editoriales
importantes. Y luego encontré Real Python.

Las instrucciones paso a paso, fáciles de seguir, dividen los grandes conceptos
en fragmentos pequeños escritos en un inglés sencillo. Los autores nunca
olvidan a su audiencia y son consistentemente minuciosos y detallados en sus
explicaciones. Ya estoy en funcionamiento, pero consulto constantemente el
material para obtener orientación”.

­Jared Nielsen
Machine Translated by Google

“Me encanta el libro porque al final de cada lección en particular hay desafíos
interesantes y del mundo real. Acabo de crear una calculadora de ahorros que
realmente refleja mi cuenta de ahorros. ¡Excelente!”

­ Drew Prescott

“Como práctica de lo que enseñaste, comencé a crear guiones simples para que las
personas de mi equipo los ayudaran en sus tareas diarias. Cuando mis gerentes se
dieron cuenta de eso, me ofrecieron un nuevo puesto como desarrollador.

Sé que hay muchas cosas que aprender y que habrá grandes desafíos, pero
finalmente comencé a hacer lo que realmente me gustó.

Una vez más: ¡MUCHAS GRACIAS!”

­Kamil

“Lo que encontré genial de los cursos de Real Python en comparación con otros es
cómo explican las cosas de la manera más sencilla posible.

Muchos cursos, en cualquier disciplina en realidad, requieren el aprendizaje de mucha

jerga cuando, en realidad, lo que se enseña se puede enseñar de manera rápida y
sucinta sin demasiada. Los cursos hacen un muy buen trabajo al mantener los
ejemplos interesantes”.

­ Stephen Grady

“Después de leer el primer curso de Real Python, escribí un script para automatizar
una tarea mundana en el trabajo. ¡Lo que antes me llevaba entre tres y cinco horas,
ahora me lleva menos de diez minutos!

­ Brandon Youngdale
Machine Translated by Google

“Honestamente, a lo largo de todo este proceso lo que encontré fue que estaba buscando
con mucha atención cosas que tal vez pudieran agregarse o mejorarse, ¡pero este tutorial
es increíble! Haces un trabajo maravilloso al explicar y enseñar Python de una manera que
personas como yo, un completo novato, realmente podrían comprender.

El flujo de las lecciones funciona perfectamente en todo momento. Los ejercicios realmente
te ayudaron a lo largo del camino y te sientes muy realizado cuando terminas el libro. Creo
que tienes un don para hacer que Python parezca más accesible para personas ajenas al
mundo de la programación.

¡Esto es algo que nunca pensé que estaría haciendo o aprendiendo y con un pequeño
empujón de tu parte lo estoy aprendiendo y puedo ver que no será más que beneficioso
para mí en el futuro!

­ Shea Klusewicz

“Los autores de los cursos NO han olvidado lo que es ser un principiante – algo que muchos
autores hacen – y no asumen nada sobre sus lectores, lo que hace que los cursos sean
lecturas fantásticas. Los cursos también van acompañados de excelentes vídeos, así como
de muchas referencias para aprendizaje adicional, tareas y código de ejemplo con el que
puedes experimentar y ampliar.

Realmente me gustó que siempre hubiera ejemplos de código completo y que cada línea
de código tuviera buenos comentarios para que pudieras ver qué está haciendo qué.

Ahora tengo varios libros sobre Python y los de Real Python son los únicos que he
terminado de principio a fin, y son sin duda los mejores del mercado. Si, como yo, no eres
programador (trabajo en marketing online), estos cursos te resultarán como un mentor
gracias a las explicaciones claras y sin complicaciones. ¡Muy recomendable!"

—Craig Addyman
Machine Translated by Google

Sobre los autores

En Python real aprenderá habilidades de programación del mundo real de una
comunidad de Pythonistas profesionales de todo el mundo.

El realpython.com El sitio web se lanzó en 2012 y actualmente ayuda a más de dos

millones de desarrolladores de Python cada mes con tutoriales de programación
gratuitos y recursos de aprendizaje en profundidad.

Todos los que trabajaron en este libro son profesionales con varios años de
experiencia profesional en la industria del software. Estos son los miembros del
equipo de tutoriales de Real Python que trabajaron en los conceptos básicos de Python:

Fletcher Heisler es el fundador de Hunter2, donde enseña a los desarrolladores

cómo piratear y proteger aplicaciones web modernas. Como uno de los miembros
fundadores de Real Python, Fletcher escribió la versión original de este libro en 2012.

David Amos es matemático de formación, científico de datos/desarrollador de Python

de profesión y adicto al café por elección. Es miembro del equipo de tutoriales de
Real Python y reescribió gran parte de este libro para actualizarlo a Python 3.

Dan Bader es el propietario y editor en jefe de Real Python y un completo loco de

Python. Cuando no está ocupado trabajando en la plataforma de aprendizaje Real
Python, ayuda a los desarrolladores de Python a llevar sus habilidades de codificación
al siguiente nivel con tutoriales, libros y capacitación en línea.

Joanna Jablonski es la editora ejecutiva de Real Python. Ama los lenguajes naturales
tanto como ama los lenguajes de programación.
Cuando no está produciendo materiales educativos para ayudar a los desarrolladores
de Python a subir de nivel, encuentra nuevas formas de optimizar varios aspectos de
su vida.
Machine Translated by Google

Contenido

Contenido 10

Prefacio 15

1 Introducción 1.1 ¿Por 22

qué este libro? . . . . . . ...... . . . . . . . . 23

1.2 Acerca de Python real. . . . . . . . . . . . . . . . . . 25
1.3 Cómo utilizar este libro. . . . . . . . . . . . . . . . . 25
1.4 Material adicional y recursos de aprendizaje. . . . . . . . 27

2 Configuración de Python 2.1 30

Una nota sobre las versiones de Python. . . . . . . . ..... . 31
2.2 Ventanas. . ..... . . . ..... . . . . . . . . 32
2.3 MacOS. . . . . . . . . . . . ..... . . . . . . . . 35
2.4 UbuntuLinux. . . . . . . ...... . . . . . . . . 39

3 Su primer programa Python 3.1 Escriba un 43

script Python. . . . . . . . . . . . . . . . . 43
3.2 Estropear las cosas. . . . . . . . . . . . . . . . . . . . 49
3.3 Crear una variable. . . . . ...... . . . . . . . . 52
3.4 Inspeccionar valores en la ventana interactiva. . . . . . 57
3.5 Déjese notas útiles. . . . . . ...... . 60
3.6 Resumen y recursos adicionales. . ...... . 63

4 Cadenas y métodos de cadena 4.1 ¿Qué es sesenta y cinco

una cadena? . . . . . ...... . . ..... . 66

4.2 Concatenación, indexación y división. . ...... . 73

10
Machine Translated by Google

Contenido

4.3 Manipular cadenas con métodos. . . ...... . 81

4.4 Interactuar con la entrada del usuario. . . . . . . . . ..... . 88
4.5 Desafío: seleccione las aportaciones de su usuario. . . . . . . 90
4.6 Trabajar con cadenas y números. . ...... . 91
4.7 Optimice sus estados de cuenta impresos. . . . . . . . . . 97
4.8 Encontrar una cadena en una cadena. . . . . . . . . . ..... . 99
4.9 Desafío: convierta a su usuario en un L33t H4x0r. . . . 102
4.10 Resumen y recursos adicionales. . ...... . 103

5 Números y matemáticas 105

5.1 Números enteros y de coma flotante. ..... . . 106
5.2 Operadores y expresiones aritméticos. . .... . . 110
5.3 Desafío: realizar cálculos según la entrada del usuario. . . 118
5.4 Haz que Python te mienta. . . . . . . . . . ..... . 119
5.5 Funciones matemáticas y métodos numéricos. . . . . . . . 121
5.6 Imprimir números con estilo. . . . . . . . . . ..... . 126
5.7 Números complejos. . . . . . . . . . . . ..... . 129
5.8 Resumen y recursos adicionales. . ...... . 133

6 Funciones y bucles 6.1 135

¿Qué es realmente una función? . . . . . . . . ..... . 136
6.2 Escriba sus propias funciones. . . . . . . . ..... . 140
6.3 Desafío: Convertir temperaturas. . . ...... . 149
6.4 Correr en círculos. . . . . . . . . . . . . . . . . . . . . 150
6.5 Desafío: Realice un seguimiento de sus inversiones. . . . . . . . . . 160
6.6 Comprender el alcance en Python. . . . . . . . . . . . . 161
6.7 Resumen y recursos adicionales. . ...... . 166

7 Encontrar y corregir errores de código 168

7.1 Utilice la ventana de control de depuración. . . . . . . . . . . 169
7.2 Eliminar algunos errores. . . . . . . . . . . . ..... . 176
7.3 Resumen y recursos adicionales. . ...... . 185

8 Lógica condicional y flujo de control 8.1 186

Comparar valores. . . . . . ...... . . ..... . 187
8.2 Agregue algo de lógica. . . . . . . . . . . . . . ..... . 190
8.3 Controle el flujo de su programa. . . ...... . 198

11
Machine Translated by Google

Contenido

8.4 Desafío: Encuentra los factores de un número. . . . . . . 210

8.5 Salir del patrón. ..... . . . ..... . 211
8.6 Recuperarse de errores. . . . . . . . . . . . . . . . . 215
8.7 Simular eventos y calcular probabilidades. . . . . 221

8.8 Desafío: Simular un experimento de lanzamiento de moneda. . . . . 227

8.9 Desafío: Simular una elección. . . . ...... . 227
8.10 Resumen y recursos adicionales. . ...... . 228

9 tuplas, listas y diccionarios 230

9.1 Las tuplas son secuencias inmutables. . . . ...... . 231
9.2 Las listas son secuencias mutables. . . . . . ...... . 241
9.3 Anidar, copiar y ordenar tuplas y listas. . . 254
9.4 Desafío: Lista de listas. . . ..... . . . ..... . 260
9.5 Desafío: Cera Poética. . ..... . . . ..... . 261
9.6 Relaciones de almacenamiento en diccionarios. . . ...... . 263
9.7 Desafío: Circuito de la ciudad capital. . . . . . ...... . 274
9.8 Cómo elegir una estructura de datos. . . . . . ...... . 275
9.9 Desafío: Gatos con sombreros. . . . . . . . ..... . 276
9.10 Resumen y recursos adicionales. . ...... . 277

10 Programación Orientada a Objetos (POO) 279

10.1 Definir una clase. . . . . . . ...... . . . . . . . . 280
10.2 Crear una instancia de un objeto. . . ..... . . . ..... . 284
10.3 Heredar de otras clases. . . . . . . . ..... . 291
10.4 Desafío: Modelar una granja. . . . . . . . . ..... . 301
10.5 Resumen y recursos adicionales. . ...... . 302

11 módulos y paquetes 304

11.1 Trabajar con módulos. . ..... . . . ..... . 305
11.2 Trabajar con paquetes. . ...... . . ..... . 315
11.3 Resumen y recursos adicionales. . ...... . 326

12 Entrada y salida de archivos 328

12.1 Archivos y el sistema de archivos. . . . . . . . . ..... . 329
12.2 Trabajar con rutas de archivos en Python. . 333 . . ......
12.3 Operaciones comunes del sistema de archivos. . . 341. . . . . . .
.
12.4 Desafío: Mover todos los archivos de imagen a un nuevo directorio. 358

12
Machine Translated by Google

Contenido

12.5 Lectura y escritura de archivos. . . . . . . . ..... . 359

12.6 Leer y escribir datos CSV. ..... . . . ..... . 374
12.7 Desafío: crear una lista de puntuaciones altas. . ..... . . 385
12.8 Resumen y recursos adicionales. . ...... . 386

13 Instalación de paquetes con Pip 388

13.1 Instalación de paquetes de terceros con Pip. . . . . . . 389
13.2 Los peligros de los paquetes de terceros. . 400 . ......
13.3 Resumen y recursos adicionales. . ...... . 401

14 Crear y modificar archivos PDF 14.1 403

Extraer texto de un PDF 14.2 . ..... . . . ..... . 404
Extraer páginas de un PDF 14.3 ..... . . . ..... . 411
Desafío: clase PdfFileSplitter . . . . ...... . 418
14.4 Concatenar y fusionar archivos PDF. . . ...... . 419
14.5 Rotar y recortar páginas PDF. . . ...... . 426
14.6 Cifrar y descifrar archivos PDF. . . . ...... . 438
14.7 Desafío: descifrar un PDF 14.8 . . . . . ...... . 442
Crear un archivo PDF desde cero. . . . . ...... . 442
14.9 Resumen y recursos adicionales. . ...... . 449

15 Trabajar con bases de datos 451

15.1 Introducción a SQLite. . . . . . . . ..... . 452
15.2 Bibliotecas para trabajar con otras bases de datos SQL. . 464
15.3 Resumen y recursos adicionales. . ...... . 465

16 Interactuar con la Web 16.1 467

Extraer y analizar texto de sitios web. ...... . 468
16.2 Utilice un analizador HTML para raspar sitios web. . . . . . . 477
16.3 Interactuar con formularios HTML. . . . . . . . . . . . . . 482
16.4 Interactuar con sitios web en tiempo real. . . . . . . . . 489
16.5 Resumen y recursos adicionales. . ...... . 493

17 Computación científica y gráficos 495

17.1 Utilice NumPy para la manipulación de matrices. . . . . . . . . 496
17.2 Utilice matplotlib para trazar gráficos. . . . . . . . . . 507
17.3 Resumen y recursos adicionales. . ...... . 533

13
Machine Translated by Google

Contenido

18 Interfaces gráficas de usuario 535

18.1 Agregar elementos GUI con EasyGUI. . . . . . . . . . 536
18.2 Aplicación de ejemplo: Rotador de páginas PDF. . . . . . . . . . . 548
18.3 Desafío: Aplicación de extracción de páginas PDF. . . . . 555
18.4 Introducción a Tkinter. . ..... . . . ..... . 556
18.5 Trabajar con widgets. . . . . . . . . . ..... . 560
18.6 Control del diseño con administradores de geometría. . . . 588
18.7 Cómo hacer que sus aplicaciones sean interactivas. . . . . . . . 607
18.8 Aplicación de ejemplo: Convertidor de temperatura. . . . . . . . 617
18.9 Aplicación de ejemplo: Editor de texto. . . . . . . . . . . . . . 622
18.10 Desafío: El regreso del poeta. . . . . . ...... . 631
18.11 Resumen y recursos adicionales. . ...... . 633

19 pensamientos finales y próximos pasos 635

19.1 Consejos semanales gratuitos para desarrolladores de Python. . . . .. . 636
19.2 Trucos de Python: el libro. . 636. . . . . . . . .....
.
19.3 Biblioteca de cursos en vídeo de Real Python. . 637. ......
19.4 PythonistaCafe: una comunidad para desarrolladores de Python 638
19.5 Agradecimientos. . . 640 . . ..... . . . .....

14
Machine Translated by Google

Prefacio

Hola y bienvenido a Conceptos básicos de Python: una introducción práctica

a Python 3. Espero que estés listo para aprender por qué tantos profesionales
y los desarrolladores aficionados se sienten atraídos por Python y por cómo empezar
usándolo en sus proyectos, pequeños y grandes, de inmediato.

Este libro está dirigido a principiantes que conocen un poco de programación pero no
el lenguaje y el ecosistema Python, así como conocimientos completos.
principiantes.

Si no tienes una licenciatura en Informática, no te preocupes. Fletcher,

David, Dan y Joanna lo guiarán a través de los conceptos informáticos importantes
mientras le enseñan los conceptos básicos de Python y, lo que es igualmente
importante, omitirán los detalles innecesarios al principio.

Python es un lenguaje de espectro completo

Cuando aprendes un nuevo lenguaje de programación, todavía no tienes la

experiencia para juzgar qué tan bien le servirá a largo plazo. Si usted
Si está considerando Python, permítame asegurarle que es una buena opción.
Una razón clave es que Python es un lenguaje de espectro completo .

¿Qué quiero decir con esto? Algunos idiomas son muy buenos para principiantes.
Te toman de la mano y hacen que la programación sea muy fácil. Podemos ir
al extremo y fijarse en lenguajes visuales como Scratch.

Aquí obtienes bloques que representan conceptos de programación, como variables,

bucles, llamadas a métodos, etc., y los arrastras y sueltas.
sobre una superficie visual. Puede que sea fácil empezar con Scratch para personas

15
Machine Translated by Google

Contenido

programas simples. Pero no puedes crear aplicaciones profesionales con él.

Nombre una empresa de Fortune 500 que impulse su lógica empresarial principal
con Scratch.

¿Salió vacío? Yo también, porque eso sería una locura.

Otros lenguajes son increíblemente poderosos para los desarrolladores expertos.

El más popular en esta categoría es probablemente C++ y su pariente cercano C.
Cualquier navegador web que utilice hoy probablemente esté escrito en C o C++.
Es muy probable que el sistema operativo que ejecuta ese navegador también haya
sido creado con C/C++. ¿Tu videojuego de estrategia o de disparos en primera
persona favorito? Lo has logrado: C/C++.

Puedes hacer cosas increíbles con estos idiomas. Pero son totalmente hostiles con
los recién llegados que buscan una presentación amable.

Es posible que no hayas leído mucho código C++. Casi puede hacer que te ardan
los ojos. He aquí un ejemplo, real aunque complejo:

plantilla <nombre de tipo T>

_Defer<void(*(PID<T>, void (T::*)(void)))
(const PID<T>&, anulado (T::*)(anulado))>
diferir(const PID<T>& pid, void (T::*método)(void))
{
void (*despacho)(const PID<T>&, void (T::*)(void)) =
&process::despacho de plantilla<T>;
return std::tr1::bind(despacho, pid, método);
}

Por favor, simplemente no.

Tanto Scratch como C++ no son decididamente lo que yo llamaría lenguajes de

espectro completo. En el nivel Scratch, es fácil comenzar, pero hay que cambiar a
un lenguaje “real” para crear aplicaciones reales.
Por el contrario, puedes crear aplicaciones reales con C++, pero no hay una rampa
de acceso suave. Te sumerges de cabeza en toda la complejidad del lenguaje que
existe para soportar estas ricas aplicaciones.

dieciséis
Machine Translated by Google

Contenido

Python, por otro lado, es especial. Es un lenguaje de espectro completo.

A menudo juzgamos la simplicidad de un lenguaje basándonos en la prueba del
"hola mundo". Es decir, ¿qué sintaxis y acciones son necesarias para que ese
lenguaje envíe "hola mundo" al usuario? En Python, no podría ser más sencillo:

imprimir("Hola mundo")

Eso es todo. Sin embargo, considero que esta es una prueba insatisfactoria.

La prueba "hola mundo" es útil, pero en realidad no es suficiente para mostrar el

poder o la complejidad de un idioma. Probemos con otro ejemplo. No es necesario
que todo aquí tenga sentido, simplemente síguelo para aprender el Zen. El libro
cubre estos conceptos y más a medida que avanza. El siguiente ejemplo es
ciertamente algo que podrías escribir cerca del final.

Aquí está la nueva prueba: ¿Qué se necesitaría para escribir un programa que
acceda a un sitio web externo, descargue el contenido de su aplicación en la
memoria y luego muestre una subsección de ese contenido al usuario? Probemos
ese experimento con Python 3 con la ayuda del paquete de solicitudes (que debe
instalarse; más sobre esto en el capítulo 12):

solicitudes de importación

resp = solicitudes.get("https://realpython.com") html =

resp.texto
imprimir(html[205:294])

Increíblemente, eso es todo. Cuando se ejecuta, la salida es (algo como):

<title> Tutoriales de Python: Python real</title>

<meta nombre="autor" contenido=" Python real">

Este es el lado fácil y fácil de comenzar del espectro de Python. Unas pocas líneas
triviales y se desata un poder increíble. Debido a que Python tiene acceso a tantas
bibliotecas poderosas pero bien empaquetadas, como solicitudes, a menudo se
describe que tiene baterías incluidas.

Ahí tienes un ejemplo sencillo y potente de un iniciador. En las aplicaciones reales

17
Machine Translated by Google

Contenido

Además, también tenemos muchas aplicaciones increíbles escritas en Python.

YouTube, el sitio de transmisión de vídeos más popular del mundo, está escrito en
Python y procesa más de 1.000.000 de solicitudes por segundo. Instagram es otro
ejemplo de una aplicación Python. Más cerca de casa, incluso tenemos realpython.com
y mis sitios como talkpython.fm.

Este aspecto de espectro completo de Python significa que puede comenzar con
facilidad y adoptar funciones más avanzadas a medida que las necesite cuando crezcan
las demandas de su aplicación.

Python es popular

Es posible que hayas oído que Python es popular. Por un lado, puede parecer que
realmente no importa qué tan popular sea un idioma si puedes crear la aplicación que
deseas con él.

Para bien o para mal, la popularidad en el desarrollo de software es un fuerte indicador

de la calidad de las bibliotecas que tendrá disponibles, así como de la cantidad de
puestos vacantes que existen. En resumen, debería tender a gravitar hacia tecnologías
más populares, ya que habrá más opciones e integraciones disponibles.

Entonces, ¿Python es realmente tan popular? Sí, lo es. Por supuesto, encontrará
muchas exageraciones e hipérboles. Pero hay muchas estadísticas que respaldan esta.
Veamos algunos análisis disponibles y presentados por Stack­Overflow.com.

Dirigen un sitio llamado StackOverow Trends. Aquí puede ver las tendencias de diversas
tecnologías por etiqueta. Cuando comparamos Python con otros posibles candidatos
que podrías elegir para aprender a programar, verás que uno es diferente a los demás:

18
Machine Translated by Google

Contenido

Puede explorar este gráfico y crear gráficos similares a este en

insights.stackoverflow.com/trends.

¡Observe el increíble crecimiento de Python en comparación con la tendencia plana

o incluso a la baja de los otros candidatos habituales! Si estuvieras apostando tu
futuro al éxito de una determinada tecnología, ¿cuál elegirías de esta lista?

Este es sólo un gráfico, ¿qué nos dice realmente? Bueno, veamos otro.
StackOverflow realiza una encuesta anual a los desarrolladores. Es completo y
está muy bien hecho. Puede encontrar los resultados completos de 2018 en
insights.stackoverflow.com/survey/2018/. De ese artículo, me gustaría llamar su
atención sobre una sección titulada Idiomas más queridos, temidos y buscados.
En la sección de los más buscados, encontrará respuestas para:

Desarrolladores que no están desarrollando con el lenguaje o la

tecnología pero que han expresado interés en hacerlo con él.

Nuevamente, en el siguiente gráfico, verá que Python encabeza las listas y muy
por encima incluso del segundo lugar:

19
Machine Translated by Google

Contenido

Entonces, si estás de acuerdo conmigo en que la popularidad relativa de una programación

el idioma importa. Python es claramente una buena opción.

No necesitamos que seas un informático

Otro punto que quiero enfatizar al comenzar este viaje de

Aprender Python es que no necesitamos que seas un informático.
Si ese es tu objetivo, genial. Aprender Python es un paso poderoso en ese sentido.
dirección. Pero el aprendizaje de la programación a menudo se enmarca en la forma de
"Tenemos todos estos puestos de trabajo de desarrollador sin cubrir, ¡necesitamos desarrolladores
de software!"

Eso puede ser cierto o no. Pero lo más importante para usted es que programar (incluso
un poco de programación) puede ser un superpoder para usted personalmente.

20
Machine Translated by Google

Contenido

Para ilustrar esta idea, supongamos que usted es biólogo. ¿Deberías abandonar
la biología y conseguir un trabajo de desarrollador web front­end? Probablemente no.
Pero tener habilidades como la que abrí este prólogo, usar solicitudes para obtener
datos de la web, será increíblemente poderoso para ti mientras haces biología.

En lugar de exportar y extraer datos manualmente de la web o de hojas de cálculo,

con Python puedes extraer miles de fuentes de datos u hojas de cálculo en el
tiempo que te lleva hacerlo manualmente. Las habilidades de Python pueden ser
lo que toma tu poder biológico y lo amplifica mucho más allá del de tus colegas y
lo convierte en tu superpoder.

Dan y Python real

Finalmente, déjame dejarte un comentario sobre tus autores. Dan Bader junto con
los otros autores de Real Python trabajan día tras día para brindarnos explicaciones
claras y poderosas de los conceptos de Python a través de realpython.com.

Tienen una visión única del ecosistema Python y están enfocados en lo que los
principiantes necesitan saber.

Confío en dejarte en sus manos en este viaje con Python. Continúe y aprenda este
increíble idioma usando este gran libro. Lo más importante es ¡recuerda divertirte!

— Michael Kennedy, fundador de Talk Python (@mkennedy)

21
Machine Translated by Google

Capítulo 1
Introducción

¡Bienvenido al libro Conceptos básicos de Python de Real Python , completamente

actualizado para Python 3.8! En este libro aprenderá técnicas de programación
Python del mundo real, ilustradas con ejemplos útiles e interesantes.

Ya sea que sea nuevo en programación o un desarrollador de software profesional

que busca sumergirse en un nuevo lenguaje, este libro le enseñará todo el Python
práctico que necesita para comenzar con proyectos en su
propio.

No importa cuáles sean sus objetivos finales, si trabaja con una computadora, pronto
encontrará infinitas formas de mejorar su vida automatizando tareas y resolviendo
problemas a través de los programas Python que usted cree.

Pero, ¿qué tiene de bueno Python como lenguaje de programación? Python es un

software gratuito de código abierto, lo que significa que puedes descargarlo gratis y
utilizarlo para cualquier propósito, comercial o no.

Python también tiene una comunidad increíble que ha creado una serie de
herramientas útiles adicionales que puede utilizar en sus propios programas.
¿Necesita trabajar con documentos PDF? Existe una herramienta integral para eso.
¿Quiere recopilar datos de páginas web? ¡No es necesario empezar de cero!

Python fue creado para ser más fácil de usar que otros lenguajes de programación.

22
Machine Translated by Google

1.1. ¿Por qué este libro?

calibres. Por lo general, es mucho más fácil leer código Python y mucho más
rápido escribir código en Python que en otros lenguajes.

Por ejemplo, aquí hay un código simple escrito en C, otro lenguaje de programación
de uso común:

#incluir <stdio.h>

int principal (vacío)

{
printf("Hola mundo\n");
}

Lo único que hace el programa es mostrar el texto Hola mundo en la pantalla. ¡Fue
mucho trabajo producir una frase! Aquí está el mismo programa, escrito en Python:

imprimir("Hola mundo")

Eso es bastante simple, ¿verdad? El código Python es más rápido de escribir y más
fácil de leer. ¡Descubrimos que también parece más amigable y accesible!

Al mismo tiempo, Python tiene todas las funciones de otros lenguajes y más. Te
sorprenderá saber cuántos productos profesionales se crean con código Python:
Instagram, YouTube, Reddit, Spotify, por nombrar solo algunos.

Python no sólo es un lenguaje amigable y divertido de aprender, sino que también

impulsa la tecnología detrás de múltiples empresas de clase mundial y ofrece
fantásticas oportunidades profesionales para cualquier programador que lo domine.

1.1 ¿Por qué este libro?

Seamos realistas, hay una cantidad abrumadora de información sobre Python en
Internet.

Pero muchos principiantes que estudian solos tienen problemas para entender

23
Machine Translated by Google

1.1. ¿Por qué este libro?

Determinar qué aprender y en qué orden aprenderlo.

Quizás se esté preguntando: "¿Qué debo aprender sobre Python al principio para
obtener una base sólida?" Si es así, este libro es para usted, ya sea que sea un
completo principiante o que ya haya incursionado en Python u otros lenguajes.

Python Basics está escrito en inglés sencillo y desglosa los conceptos básicos que
realmente necesitas saber en fragmentos pequeños. Esto significa que sabrás "lo
suficiente como para ser peligroso" con Python, rápidamente.

En lugar de simplemente revisar una lista aburrida de características del lenguaje,

verá exactamente cómo encajan los diferentes bloques de construcción y qué
implica la creación de aplicaciones y scripts reales con Python.

Paso a paso, dominará los conceptos fundamentales de Python que lo ayudarán a

comenzar su viaje para aprender Python.

Muchos libros de programación intentan cubrir hasta la última variación posible de

cada comando, lo que facilita que los lectores se pierdan en los detalles. Este
enfoque es excelente si buscas un manual de referencia, pero es una forma horrible
de aprender un lenguaje de programación. No sólo pasas la mayor parte del tiempo
metiéndote en la cabeza cosas que nunca usarás, ¡sino que tampoco es nada
divertido!

Este libro se basa en el principio 80/20. Cubriremos los comandos y técnicas

utilizados en la gran mayoría de los casos y nos centraremos en cómo programar
soluciones del mundo real a problemas que le ayudarán a hacer su vida más fácil.

De esta manera, le garantizamos que usted:

• Aprenda técnicas de programación útiles rápidamente

• Pase menos tiempo luchando con complicaciones sin importancia

• Encuentre usos más prácticos para Python en su propia vida

• Diviértete más en el proceso

Una vez que haya dominado el material de este libro, habrá adquirido

24
Machine Translated by Google

1.2. Acerca de Python real

una base lo suficientemente sólida como para que aventurarse por su cuenta en territorios
más avanzados sea muy sencillo.

¡Así que sumérgete! Aprenda a programar en un lenguaje gratuito y ampliamente utilizado

que puede hacer más de lo que jamás pensó que fuera posible.

1.2 Acerca de Python real

En Real Python, Aprenderá habilidades de programación del mundo real de una comunidad
de Pythonistas profesionales de todo el mundo.

El realpython.com El sitio web se lanzó en 2012 y actualmente ayuda a más de dos millones
de desarrolladores de Python cada mes con libros, tutoriales de programación y otros recursos
de aprendizaje en profundidad.

Todos los que trabajaron en este libro son profesionales de Python reclutados del equipo de
Real Python con varios años de experiencia profesional en la industria del software.

Aquí es donde puedes encontrar Real Python en la web:

• realpython.com

• @realpython en Twitter

• El boletín informativo por correo electrónico sobre Python real

1.3 Cómo utilizar este libro

La primera mitad de este libro es una descripción general rápida pero exhaustiva de todos los
fundamentos de Python. No necesita ninguna experiencia previa en programación para
comenzar. La segunda mitad se centra en encontrar soluciones prácticas a problemas de
codificación interesantes del mundo real.

Como principiante, le recomendamos que lea la primera mitad de este libro de principio a fin.
La segunda mitad cubre temas que no se superponen tanto para que puedas saltar más
fácilmente, pero los capítulos aumentan en dificultad a medida que avanzas.

25
Machine Translated by Google

1.3. Como usar este libro

Si es un programador con más experiencia, es posible que se encuentre

dirigiéndose hacia la segunda parte del libro de inmediato. Pero no olvides obtener
primero una base sólida en los conceptos básicos y asegúrate de llenar cualquier
vacío de conocimiento a lo largo del camino.

La mayoría de las secciones de un capítulo van seguidas de ejercicios de repaso

para ayudarle a asegurarse de que domina todos los temas tratados. También hay
una serie de desafíos de código, que son más complicados y generalmente
requieren que usted combine varios conceptos diferentes de capítulos anteriores.

Los archivos de práctica que acompañan a este libro también incluyen soluciones
completas a los desafíos, así como algunos de los ejercicios más complicados.
Pero para aprovechar al máximo el material, debes hacer todo lo posible para
resolver los problemas desafiantes por tu cuenta antes de mirar las soluciones de ejemplo.

Si es completamente nuevo en la programación, es posible que desee

complementar los primeros capítulos con práctica adicional. Recomendamos
trabajar con los tutoriales de Fundamentos de Python disponibles de forma gratuita
en realpython.com para asegurarse de estar sobre una base sólida.

Si tiene alguna pregunta o comentario sobre el libro, siempre puede contactarnos.

directamente.

Aprender haciendo
Este libro trata sobre aprender haciendo, así que asegúrese de escribir los
fragmentos de código que encuentre en el libro. Para obtener mejores resultados,
le recomendamos que evite copiar y pegar los ejemplos de código.

Aprenderá mejor los conceptos y aprenderá la sintaxis más rápido si escribe cada
línea de código usted mismo. Además, si cometes un error (lo cual es totalmente
normal y les sucede a todos los desarrolladores a diario), el simple hecho de
corregir errores tipográficos te ayudará a aprender cómo depurar tu código.

Intente completar los ejercicios de revisión y los desafíos de código usted mismo
antes de obtener ayuda de recursos externos. Con suficiente práctica, dominarás
este material y te divertirás a lo largo del camino.

26
Machine Translated by Google

1.4. Material adicional y recursos de aprendizaje

¿Cuánto tiempo llevará terminar este libro?

Si ya está familiarizado con un lenguaje de programación, podría terminar el libro en tan
solo 35 a 40 horas. Si es nuevo en la programación, es posible que necesite dedicar
hasta 100 horas o más. Tómate tu tiempo y no sientas que tienes que apresurarte. La
programación es una habilidad muy gratificante, pero compleja de aprender. Buena
suerte en tu viaje con Python, ¡te apoyamos!

1.4 Material adicional y aprendizaje

Recursos

Recursos en línea

Este libro incluye una serie de recursos adicionales gratuitos a los que puede acceder
en realpython.com/python­basics/resources. En esta página web también puede
encontrar una lista de erratas con correcciones mantenidas por el equipo de Real Python.

Cuestionarios interactivos
La mayoría de los capítulos de este libro vienen con un cuestionario en línea gratuito
para verificar su progreso de aprendizaje. Puede acceder a los cuestionarios utilizando
los enlaces que se proporcionan al final del capítulo. Los cuestionarios están alojados
en el sitio web de Real Python y se pueden ver en su teléfono o computadora.

Cada cuestionario lo lleva a través de una serie de preguntas relacionadas con un

capítulo particular del libro. Algunos de ellos son de opción múltiple, otros le pedirán que
escriba una respuesta y otros requerirán que escriba código Python real. A medida que
avanza en cada prueba, registra las preguntas que respondió correctamente.

Al final del cuestionario, recibirá una calificación basada en su resultado. Si no obtienes

el 100% en tu primer intento, ¡no te preocupes! Estos cuestionarios están destinados a
desafiarte y se espera que los realices varias veces, mejorando tu puntuación con cada
ejecución.

27
Machine Translated by Google

1.4. Material adicional y recursos de aprendizaje

Repositorio de códigos de ejercicios

Este libro tiene un repositorio de código adjunto en la web. Contiene código fuente de
ejemplo, así como respuestas a ejercicios y desafíos de código. El repositorio está dividido
por capítulos para que pueda comparar su código con las soluciones que le proporcionamos
después de terminar cada capítulo. Aquí está el enlace:

realpython.com/python­basics/exercises

Licencia de código de ejemplo

Los scripts de Python de ejemplo asociados con este libro tienen una licencia de dominio
público Creative Commons (CC0). Esto significa que puedes utilizar cualquier parte del
código para cualquier propósito en tus propios programas.

Nota

El código que se encuentra en este libro se ha probado con Python 3.8 en Windows,
macOS y Linux.

Convenciones de formato

Se utilizarán bloques de código para presentar código de ejemplo:

# Este es el código Python:

imprimir("¡Hola mundo!")

Los comandos de terminal siguen el formato Unix:

$ # Este es un comando de terminal:

$ python hola­mundo.py

(Los signos de dólar no son parte del comando).

Se utilizará texto en cursiva para indicar un nombre de archivo: hola­mundo.py.

El texto en negrita se utilizará para indicar un término nuevo o importante.

28
Machine Translated by Google

1.4. Material adicional y recursos de aprendizaje

Los atajos de teclado tendrán el siguiente formato: Ctrl + S .

Los accesos directos del menú tendrán el siguiente formato: Archivo Nuevo archivo

Los cuadros de notas y advertencias aparecen de la siguiente manera:

Nota

Esta es una nota completa con texto de marcador de posición. El veloz zorro
marrón salta sobre el perro perezoso. La veloz pitón marrón se desliza sobre el
cerdo perezoso.

Importante

Esta es una advertencia que también se completa con texto de marcador de

posición. El veloz zorro marrón salta sobre el perro perezoso. La veloz pitón
marrón se desliza sobre el cerdo perezoso.

Comentarios y erratas

Agradecemos ideas, sugerencias, comentarios y alguna queja ocasional.

¿Encontraste un tema confuso? ¿Encontraste un error en el texto o código? ¿Omitimos
algún tema sobre el que le encantaría saber más?

Siempre estamos buscando mejorar nuestros materiales didácticos. Cualquiera sea el

motivo, envíe sus comentarios al siguiente enlace:

realpython.com/python­basics/feedback

Deje comentarios sobre esta sección »

29
Machine Translated by Google

Capitulo 2

Configurando Python

Este libro trata sobre la programación de computadoras con Python. Podrías leer
este libro de principio a fin y absorber la información sin siquiera tocar un teclado,
pero te perderías la parte divertida: la codificación.

Para aprovechar al máximo este libro, necesita tener una computadora con Python
instalado y una forma de crear, editar y guardar archivos de código Python.

En este capítulo, aprenderá cómo:

• Instale la última versión de Python 3 en su computadora

• Open IDLE, el desarrollo integrado integrado de Python y

Ambiente de aprendizaje

¡Empecemos!

30
Machine Translated by Google

2.1. Una nota sobre las versiones de Python

Deje comentarios sobre esta sección »

2.1 Una nota sobre las versiones de Python

Muchos sistemas operativos, como macOS y Linux, vienen con Python preinstalado.
La versión de Python que viene con su sistema operativo se llama sistema Python.

El sistema Python casi siempre está desactualizado y es posible que ni siquiera sea
una instalación completa de Python. Es esencial que tenga la versión más reciente
de Python para poder seguir con éxito los ejemplos de este libro.

Es posible tener varias versiones de Python instaladas en su computadora. En este

capítulo, instalará la última versión de Python 3 junto con cualquier sistema Python
que ya exista en su máquina.

Nota

Incluso si ya tiene instalado Python 3.8, es una buena idea leer este capítulo
para verificar que su entorno esté configurado para seguir este libro.

Este capítulo se divide en tres secciones: Windows, macOS y Ubuntu Linux. Busque
la sección correspondiente a su sistema operativo y siga los pasos para configurarlo,
luego pase al siguiente capítulo.

Si tiene un sistema operativo diferente, consulte la Guía de instalación y

configuración de Python 3 de Real Python. para ver si su sistema operativo está cubierto.

31
Machine Translated by Google

2.2. ventanas

Deje comentarios sobre esta sección »

2.2 Ventanas
Siga estos pasos para instalar Python 3 y abrir IDLE en Windows.

Importante

El código de este libro solo se prueba con Python instalado como se describe en
esta sección.

Tenga en cuenta que si ha instalado Python por otros medios, como Anaconda
Python, puede encontrar problemas al ejecutar los ejemplos de código.

Instalar Python
Los sistemas Windows normalmente no vienen con Python preinstalado. Afortunadamente,
la instalación no implica mucho más que descargar el instalador de Python desde el sitio
web python.org. y ejecutándolo.

Paso 1: descargue el instalador de Python 3

Abra una ventana del navegador y navegue hasta la página de descarga para Windows. en
python.org.

Debajo del encabezado en la parte superior que dice Versiones de Python para Windows,
haga clic en el enlace para ver la última versión de Python 3: Python 3.xx.
Al momento de escribir este artículo, la última versión es Python 3.8. Luego, desplácese
hasta la parte inferior y seleccione el instalador ejecutable de Windows x86­64.

Nota

Si su sistema tiene un procesador de 32 bits, debe elegir el instalador de 32 bits. Si

no está seguro de si su computadora es de 32 o 64 bits, siga con el instalador de
64 bits mencionado anteriormente.

32
Machine Translated by Google

2.2. ventanas

Paso 2: ejecute el instalador

Ejecute el instalador haciendo doble clic en el archivo descargado. Deberías ver

la siguiente ventana:

Importante

Asegúrese de marcar la casilla que dice Agregar Python 3.x a la RUTA

como se muestra para garantizar que la instalación coloque el intérprete
en su ruta de ejecución.

Si instala Python sin marcar esta casilla, puede ejecutar el instalador

nuevamente y seleccionarlo.

Haga clic en Instalar ahora para instalar Python 3. Espere a que finalice la
instalación y luego continúe abriendo IDLE.

Abrir inactivo
Puede abrir IDLE en dos pasos:

33
Machine Translated by Google

2.2. ventanas

1. Haga clic en el menú de inicio y busque la carpeta Python 3.8 .

2. Abra la carpeta y seleccione IDLE (Python 3.8).

Nota

Recomendamos utilizar IDLE para seguir este libro.

Puede utilizar un editor de código diferente si lo prefiere. Sin embargo,

algunos capítulos, como el Capítulo 7: Búsqueda y corrección de errores
de código, contienen material específico de IDLE.

IDLE abre un shell de Python en una nueva ventana. El shell de Python es un

entorno interactivo que le permite escribir código Python y ejecutarlo
inmediatamente. ¡Es una excelente manera de comenzar con Python!

La ventana del shell de Python se ve así:

En la parte superior de la ventana, puede ver la versión de Python que se está

ejecutando y cierta información sobre el sistema operativo. Si ve una versión
inferior a 3.7, es posible que deba volver a consultar las instrucciones de
instalación en la sección anterior.

El símbolo >>> que ve se llama mensaje. Siempre que veas esto, significa que
Python está esperando que le des algunas instrucciones.

34
Machine Translated by Google

2.3. Mac OS

Prueba interactiva

Este capítulo viene con un cuestionario en línea gratuito para verificar su

progreso de aprendizaje. Puede acceder al cuestionario usando su teléfono
o computadora en la siguiente dirección web:

realpython.com/quizzes/python­basics­2

Ahora que tienes Python instalado, ¡vamos directamente a escribir tu primer

programa Python! Continúe y pase al Capítulo 3.

Deje comentarios sobre esta sección »

2.3 MacOS
Siga estos pasos para instalar Python 3 y abrir IDLE en macOS.

Importante

El código de este libro solo se prueba con Python instalado como se describe
en esta sección.

Tenga en cuenta que si ha instalado Python por otros medios, como

Homebrew o Anaconda Python, puede encontrar problemas al ejecutar los
ejemplos de código.

Instalar Python
La mayoría de las máquinas macOS vienen con Python 2 instalado. Querrá instalar
la última versión de Python 3. Puede hacerlo descargando un instalador desde
python.org sitio web.

Paso 1: descargue el instalador de Python 3

Abra una ventana del navegador y navegue hasta la página de descarga para
macOS en python.org.

35
Machine Translated by Google

2.3. Mac OS

Debajo del encabezado en la parte superior que dice Lanzamientos de Python para
macOS, haga clic en el enlace para la última versión de Python 3: Python 3.xx Al
momento de escribir este artículo, la última versión es Python 3.8. Luego,
desplácese hasta el final de la página y seleccione el instalador de macOS de 64 bits/32 bits.
Esto inicia la descarga.

Paso 2: ejecute el instalador

Ejecute el instalador haciendo doble clic en el archivo descargado. Deberías ver la

siguiente ventana:

1. Presione el botón Continuar varias veces hasta que se le solicite aceptar el

acuerdo de licencia de software. Luego haga clic en Aceptar . Se le muestra
una ventana que le indica dónde se instalará Python y cuánto espacio ocupará.

2. Lo más probable es que no quieras cambiar la ubicación predeterminada, así

que continúa y haz clic en Instalar para iniciar la instalación. El instalador de
Python le avisará cuando haya terminado de copiar los archivos.

36
Machine Translated by Google

2.3. Mac OS

3. Haga clic en Cerrar para cerrar la ventana del instalador. Ahora que Python está
instalado, puede abrir IDLE y prepararse para escribir su primer programa Python.

Abrir inactivo
Puede abrir IDLE en tres pasos:

1. Abra Finder y haga clic en Aplicaciones.

2. Localice la carpeta Python 3.8 y haga doble clic en ella.

3. Haga doble clic en el icono INACTIVO.

También puede abrir IDLE utilizando la función de búsqueda de Spotlight. Presione Cmd
+ barra espaciadora para abrir la búsqueda de Spotlight, escriba la palabra inactivo y
luego presione Retorno para abrir IDLE.

Nota
Recomendamos utilizar IDLE para seguir este libro.

Puede utilizar un editor de código diferente si lo prefiere. Sin embargo, algunos

capítulos, como el Capítulo 7: Búsqueda y corrección de errores de código,
contienen material específico de IDLE.

IDLE abre un shell de Python en una nueva ventana. El shell de Python es un entorno
interactivo que le permite escribir código Python y ejecutarlo inmediatamente. ¡Es una
excelente manera de comenzar con Python!

La ventana del shell de Python se ve así:

37
Machine Translated by Google

2.3. Mac OS

En la parte superior de la ventana, puede ver la versión de Python que se está

ejecutando y cierta información sobre el sistema operativo. Si ve una versión inferior
a 3.7, es posible que deba volver a consultar las instrucciones de instalación en la
sección anterior.

El símbolo >>> que ve se llama mensaje. Siempre que veas esto, significa que
Python está esperando que le des algunas instrucciones.

Prueba interactiva

Este capítulo viene con un cuestionario en línea gratuito para verificar su

progreso de aprendizaje. Puede acceder al cuestionario usando su teléfono
o computadora en la siguiente dirección web:

realpython.com/quizzes/python­basics­2

Ahora que tienes Python instalado, ¡vamos directamente a escribir tu primer

programa Python! Continúe y pase al Capítulo 3.

Deje comentarios sobre esta sección »

38
Machine Translated by Google

2.4. ubuntu linux

2.4 UbuntuLinux
Siga estos pasos para instalar Python 3 y abrir IDLE en Ubuntu Linux.

Importante

El código de este libro solo se prueba con Python instalado como se

describe en esta sección.

Tenga en cuenta que si ha instalado Python por otros medios, como

Anaconda Python, puede encontrar problemas al ejecutar los ejemplos
de código.

Instalar Python
Es muy probable que su distribución de Ubuntu ya tenga Python instalado, pero
probablemente no sea la última versión y puede que sea Python 2 en lugar de
Python 3.

Para saber qué versión(es) tiene, abra una ventana de terminal y pruebe los
siguientes comandos:

$ python ­­versión
$ python3 ­­versión

Uno o más de estos comandos deberían responder con una versión, como se muestra
a continuación (su número de versión puede variar):

$ python3 ­­versión
Pitón 3.8.1

Si la versión que se muestra es Python 2.x o una versión de Python 3 inferior a

3.8, entonces desea instalar la última versión. La forma de instalar Python en
Ubuntu depende de la versión de Ubuntu que esté ejecutando. Puede determinar
su versión local de Ubuntu ejecutando el siguiente comando:

39
Machine Translated by Google

2.4. ubuntu linux

$ lsb_release ­a

No hay módulos LSB disponibles.

ID de distribuidor: Ubuntu

Descripción: Ubuntu 18.04.1 LTS

Liberar: 18.04

Nombre clave: biónico

Mire el número de versión junto a Lanzamiento en la salida de la consola y

siga las instrucciones correspondientes a continuación.

Ubuntu 18.04+

La versión 18.04 de Ubuntu no viene con Python 3.8 de forma predeterminada,

pero está en el repositorio Universe. Puede instalarlo con los siguientes
comandos en la aplicación Terminal :

$ sudo apt­obtener actualización

$ sudo apt­get install python3.8 inactivo­python3.8

Ubuntu 17 y anteriores

Para las versiones 17 y anteriores de Ubuntu, Python 3.8 no está en el

repositorio de Universe. Debe obtenerlo de un Archivo de paquetes personales (PPA).
Para instalar Python desde el PPA “deadsnakes” , ejecute los siguientes
comandos en la aplicación Terminal :

$ sudo agregar­apt­repository ppa:deadsnakes/ppa

$ sudo apt­obtener actualización

$ sudo apt­get install python3.8 inactivo­python3.8

Puede comprobar que se instaló la versión correcta de Python ejecutando

python3 ­­version. Si ve un número de versión inferior a 3.7, es posible que
deba escribir python3.8 ­­version. Ahora está listo para abrir IDLE y prepararse
para escribir su primer programa Python.

Abrir inactivo
Puede abrir IDLE desde la línea de comando escribiendo lo siguiente:

40
Machine Translated by Google

2.4. ubuntu linux

$ inactivo­python3.8

En algunas instalaciones de Linux, puede abrir IDLE con el siguiente comando

abreviado:

$ inactivo3

Nota

Recomendamos utilizar IDLE para seguir este libro.

Puede utilizar un editor de código diferente si lo prefiere. Sin embargo,

algunos capítulos, como el Capítulo 7: Búsqueda y corrección de errores
de código, contienen material específico de IDLE.

IDLE abre un shell de Python en una nueva ventana. El shell de Python es un

entorno interactivo que le permite escribir código Python y ejecutarlo
inmediatamente. ¡Es una excelente manera de comenzar con Python!

La ventana del shell de Python se ve así:

En la parte superior de la ventana, puede ver la versión de Python que está

41
Machine Translated by Google

2.4. ubuntu linux

en ejecución y cierta información sobre el sistema operativo. Si ve una

versión inferior a 3.8, es posible que deba volver a consultar las
instrucciones de instalación en la sección anterior.

Importante

Si abrió IDLE con el comando idle3 y ve una versión inferior a 3.7

en la ventana del shell de Python, deberá abrir IDLE con el
comando idle­python3.8 .

El símbolo >>> que ve en la ventana IDLE se llama mensaje.

Siempre que veas esto, significa que Python está esperando que le des algunas
instrucciones.

Prueba interactiva

Este capítulo viene con un cuestionario en línea gratuito para verificar su

progreso de aprendizaje. Puede acceder al cuestionario usando su teléfono
o computadora en la siguiente dirección web:

realpython.com/quizzes/python­basics­2

Ahora que tienes Python instalado, ¡vamos directamente a escribir tu

primer programa Python! Continúe y pase al Capítulo 3.

Deje comentarios sobre esta sección »

42
Machine Translated by Google

Capítulo 3

Tu primer programa Python

Ahora que tiene la última versión de Python instalada en su computadora, ¡es hora
de comenzar a codificar!

En este capítulo usted:

• Escribe tu primer script Python

• Aprenda qué sucede cuando ejecuta un script con un error

• Aprenda a declarar una variable e inspeccionar su valor.

• Aprenda a escribir comentarios

¿Listo para comenzar tu viaje con Python? ¡Vamos!

Deje comentarios sobre esta sección »

3.1 Escribir un script en Python

Si aún no tienes IDLE abierto, continúa y ábrelo. Hay dos ventanas principales con
las que trabajará en IDLE: la ventana interactiva, que es la que se abre cuando
inicia IDLE, y la ventana de script.

Puede escribir código tanto en la ventana interactiva como en la de secuencia de

comandos. La diferencia entre los dos es cómo se ejecuta el código. En esta sección,

43
Machine Translated by Google

3.1. Escribir un script en Python

Escribirás tu primer programa Python y aprenderás a ejecutarlo en ambas ventanas.

La ventana interactiva
La ventana interactiva contiene un shell de Python, que es una interfaz de usuario
textual que se utiliza para interactuar con el lenguaje Python. De ahí el nombre de
“ventana interactiva”.

Cuando abre IDLE por primera vez, el texto que se muestra se parece a este:

Python 3.8.1 (tags/v3.8.1:1b293b6, 18 de diciembre de 2019, 22:39:24)

[MSC v.1916 32 bits (Intel)] en win32
Escriba "ayuda", "derechos de autor", "créditos" o "licencia" para obtener más información.
>>>

La primera línea le indica qué versión de Python se está ejecutando. En este caso, IDLE
ejecuta Python 3.8.1. La segunda y tercera líneas brindan información sobre el sistema
operativo y algunos comandos que puede usar para obtener más información sobre
Python.

El símbolo >>> en la última línea se llama mensaje. Aquí es donde escribirás tu código.
Continúe y escriba 1 + 1 cuando se le solicite y presione Entrar.

Cuando presionas Enter , Python evalúa la expresión, muestra el resultado 2 y luego

le solicita más información:

>>> 1 + 1
2
>>>

Observe que el indicador de Python >>> aparece nuevamente después de su resultado.

¡Python está listo para recibir más instrucciones! Cada vez que ejecuta algún código,
aparece un nuevo mensaje directamente debajo de la salida.

La secuencia de eventos en la ventana interactiva se puede describir como un bucle

con tres pasos:

44
Machine Translated by Google

3.1. Escribir un script en Python

1. Primero, Python lee el código ingresado cuando se le solicita.

2. Luego se evalúa el código.

3. Finalmente, el resultado se imprime en la ventana y aparece un nuevo mensaje.

desplegado.

Este bucle se conoce comúnmente como bucle de lectura, evaluación e impresión , o

REPL. Los programadores de Python a veces se refieren al shell de Python como "Python
REPL", o simplemente "el REPL" para abreviar.

Nota

A partir de este momento, el mensaje >>> final que se muestra después de

ejecutar el código en la ventana interactiva se excluye de los ejemplos de código.

Probemos algo un poco más interesante que sumar dos números.

Un rito de iniciación para todo programador es escribir su primer programa "Hola, mundo"
que imprima la frase "Hola, mundo" en la pantalla.

Para imprimir texto en la pantalla en Python, usa la función print() . Una función es un
fragmento de código que normalmente toma alguna entrada, llamada argumento, hace
algo con esa entrada y produce alguna salida, llamada valor de retorno.

En términos generales, las funciones en el código funcionan como funciones matemáticas.

Por ejemplo, la función matemática A(r)=πr² toma el radio r de un círculo como entrada y
produce el área del círculo como salida.

45
Machine Translated by Google

3.1. Escribir un script en Python

Importante

Sin embargo, la analogía con las funciones matemáticas tiene algunos

problemas, porque las funciones de código pueden tener efectos
secundarios. Un efecto secundario ocurre cada vez que una función
realiza alguna operación que cambia algo sobre el programa o la
computadora que ejecuta el programa.

Por ejemplo, puede escribir una función en Python que tome el nombre de
alguien como entrada, almacene el nombre en un archivo en la computadora
y luego genere la ruta al archivo que contiene el nombre. La operación de
guardar el nombre en un archivo es un efecto secundario de la función.

Aprenderá más sobre las funciones, incluido cómo escribir las suyas
propias, en el Capítulo 6.

La función print() de Python toma algo de texto como entrada y luego muestra
ese texto en la pantalla. Para usar print(), escriba la palabra print cuando se le
solicite en la ventana interactiva, seguida del texto "Hola, mundo" entre paréntesis:

>>> imprimir("Hola mundo")

Hola Mundo

Aquí "Hola mundo" es el argumento que se pasa a print().

"Hola mundo" debe escribirse entre comillas para que Python lo interprete como
texto y no como otra cosa.

Nota

A medida que escribe código en la ventana interactiva, puede notar que el

color de la fuente cambia en ciertas partes del código. IDLE resalta partes
de su código en diferentes colores para ayudarlo a identificar más
fácilmente cuáles son las diferentes partes.

De forma predeterminada, las funciones integradas, como print(), se

muestran en violeta y el texto en verde.

46
Machine Translated by Google

3.1. Escribir un script en Python

La ventana interactiva puede ejecutar solo una línea de código a la vez.

Esto es útil para probar pequeños ejemplos de código y explorar el lenguaje Python,
pero tiene una limitación importante. ¡El código debe ser ingresado por una persona
una línea a la vez!

Alternativamente, puede almacenar algo de código Python en un archivo de texto y

luego ejecutar todo el código en el archivo con un solo comando. El código del
archivo se denomina script y los archivos que contienen scripts de Python se
denominan archivos de script.

Los archivos de script son interesantes no sólo porque facilitan la ejecución de un

programa, sino también porque pueden compartirse con otras personas para que
también puedan ejecutar su programa.

La ventana de guión
Los scripts se escriben utilizando la ventana de script de IDLE. Puede abrir la
ventana del script seleccionando Archivo Nuevo archivo en el menú en la parte
superior de la ventana interactiva.

Observe que cuando se abre la ventana del script, la ventana interactiva permanece
abierta. Cualquier resultado generado por el código ejecutado en la ventana del
script se muestra en la ventana interactiva, por lo que es posible que desee
reorganizar las dos ventanas para poder ver ambas al mismo tiempo.

En la ventana del script, escriba el mismo código que utilizó para imprimir "Hola,
mundo" en la ventana interactiva:

imprimir("Hola mundo")

Al igual que la ventana interactiva, el código escrito en la ventana del script está
resaltado.

47
Machine Translated by Google

3.1. Escribir un script en Python

Importante

Cuando escribe código en un script, no necesita incluir el mensaje >>> que ve

en la ventana interactiva de IDLE. Tenga esto en cuenta si copia y pega código
de ejemplos que muestran el mensaje REPL.

Sin embargo, recuerde que no se recomienda copiar y pegar ejemplos del libro.
¡Escribir cada ejemplo en ti mismo realmente vale la pena!

Antes de poder ejecutar su script, debe guardarlo. En el menú en la parte superior de la

ventana, seleccione Archivo Guardar y guarde el script como hello_world.py. La extensión
de archivo .py es la extensión convencional que se utiliza para indicar que un archivo
contiene código Python.

De hecho, si guarda su script con cualquier extensión que no sea .py, el código resaltado
desaparecerá y todo el texto del archivo se mostrará en negro. IDLE solo resaltará el
código Python cuando esté almacenado en un archivo .py .

Una vez guardado el script, todo lo que tienes que hacer para ejecutar el programa es seleccionar
Ejecute Ejecutar módulo desde la ventana del script y verá aparecer Hola, mundo en la
ventana interactiva:

Hola Mundo

Nota

También puede presionar F5 para ejecutar un script desde la ventana del script.

Cada vez que ejecute un script verá algo como el siguiente resultado en la ventana
interactiva:

>>> =================== REINICIAR ====================

Esta es la forma que tiene IDLE de separar la salida de distintas ejecuciones de un script.
De lo contrario, si ejecuta un script tras otro, es posible que no quede claro qué

48
Machine Translated by Google

3.2. Arruinar las cosas

la salida pertenece a qué script.

Para abrir un script existente en IDLE, seleccione Archivo Abrir... en el menú de la

ventana del script o de la ventana interactiva. Luego busque y seleccione el archivo de
script que desea abrir. IDLE abre scripts en una nueva ventana de script, por lo que
puede tener varios scripts abiertos a la vez.

Nota
Al hacer doble clic en un archivo .py desde un administrador de archivos, como
el Explorador de Windows, se ejecuta el script en una nueva ventana. Sin
embargo, la ventana se cierra inmediatamente cuando el script termina de
ejecutarse, a menudo antes de que puedas ver lo que sucedió.

Para abrir el archivo en IDLE para poder ejecutarlo y ver el resultado, puede
hacer clic derecho en el icono del archivo ( Ctrl + clic en macOS) y elegir
Editar con IDLE. .

Deje comentarios sobre esta sección »

3.2 Estropear las cosas

Todo el mundo comete errores, ¡especialmente al programar! En caso de que aún no
hayas cometido ningún error, comencemos con eso y estropeemos algo a propósito para
ver qué sucede.

Los errores cometidos en un programa se denominan errores y existen dos tipos

principales de errores que experimentará:

1. Errores de sintaxis

2. Errores de tiempo de ejecución

En esta sección verá algunos ejemplos de errores de código y aprenderá cómo usar la
salida que Python muestra cuando ocurre un error para comprender qué error ocurrió y
qué fragmento de código lo causó.

49
Machine Translated by Google

3.2. Arruinar las cosas

Errores de sintaxis

En términos generales, se produce un error de sintaxis cuando se escribe algún código

que no está permitido en el lenguaje Python. Puede crear un error de sintaxis cambiando
el contenido del script hello_world.py de la última sección a lo siguiente:

print("Hola mundo)

En este ejemplo, se han eliminado las comillas dobles al final de "Hola, mundo" . Python
no podrá saber dónde termina la cadena de texto. Guarde el script modificado y luego
intente ejecutarlo. ¿Lo que sucede?

¡El código no se ejecutará! IDLE muestra un cuadro de alerta con lo siguiente

mensaje:

EOL al escanear una cadena literal.

EOL significa End Of Line, por lo que este mensaje le indica que Python leyó hasta el final
de la línea sin encontrar el final de algo llamado literal de cadena.

Un literal de cadena es texto contenido entre dos comillas dobles. El texto "Hola, mundo"
es un ejemplo de cadena literal.

Nota
Para abreviar, los literales de cadena a menudo se denominan cadenas, aunque
el término "cadena" técnicamente tiene un significado más general en Python.
Aprenderá más sobre las cadenas en el Capítulo 4.

De vuelta en la ventana del script, observe que la línea que contiene "Hola, mundo" está
resaltada en rojo. Esta útil función le ayuda a encontrar rápidamente qué línea de código
causó el error de sintaxis.

Errores de tiempo de ejecución

IDLE detecta errores de sintaxis antes de que un programa comience a ejecutarse, pero
algunos errores no se pueden detectar hasta que se ejecuta el programa. Estos errores son

50
Machine Translated by Google

3.2. Arruinar las cosas

Se conocen como errores de tiempo de ejecución porque solo ocurren en el momento en que
se ejecuta un programa.

Para generar un error en tiempo de ejecución, cambie el código en hello_world.py a

lo siguiente:

imprimir(Hola mundo)

Ahora se han eliminado las dos comillas de la frase "Hola, mundo" . ¿Notaste cómo
el color del texto cambia a negro cuando eliminaste las comillas? IDLE ya no
reconoce Hola mundo como una cadena.

¿Qué crees que sucede cuando ejecutas el script? ¡Pruébalo y verás!

Se muestra un texto rojo en la ventana interactiva:

Rastreo (llamadas recientes más última):

Archivo "/home/hello_world.py", línea 1, en <módulo>
imprimir(Hola mundo)
NameError: el nombre 'Hola' no está definido

¿Qué pasó? Al intentar ejecutar el programa, Python generó un error. Cada vez que
ocurre un error, Python deja de ejecutar el programa y muestra el error en la
ventana interactiva de IDLE.

El texto que se muestra cuando se produce un error se denomina rastreo. Los

rastreos le brindan información útil sobre el error. El rastreo anterior nos dice todo
lo siguiente:

• El error ocurrió en la línea 1 de hello_world.py.

• La línea que generó el error fue: print(Hola mundo).

• Se produjo un error de nombre .

• El error específico fue que el nombre 'Hola' no está definido

Faltan las comillas alrededor de Hola mundo , por lo que Python no entiende que es
una cadena de texto. En cambio, Python piensa

51
Machine Translated by Google

3.3. Crear una variable

que Hola y mundo son los nombres de algo más en el código.

Como los nombres Hola y Mundo no se han definido en ninguna parte, el programa
falla.

En la siguiente sección, verá cómo definir nombres para valores en su código. Sin
embargo, antes de continuar, puede practicar un poco con los errores de sintaxis y
los errores de tiempo de ejecución trabajando en los ejercicios de revisión.

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos

adicionales en línea en realpython.com/python­basics/resources.

1. Escribe un script que IDLE no te permita ejecutar porque tiene una sintaxis.
error.

2. Escriba un script que solo bloquee su programa una vez que ya se esté
ejecutando porque tiene un error de tiempo de ejecución.

Deje comentarios sobre esta sección »

3.3 Crear una variable

En Python, las variables son nombres a los que se les puede asignar un valor y
usarse para hacer referencia a ese valor en todo el código. Las variables son
fundamentales para la programación por dos razones:

1. Las variables mantienen los valores accesibles: por ejemplo, el resultado de

alguna operación que requiere mucho tiempo se puede asignar a una variable
para que no sea necesario realizar la operación cada vez que necesite utilizar
el resultado.

2. Las variables dan contexto a los valores: el número 28 podría significar muchas
cosas diferentes, como la cantidad de estudiantes en una clase o la cantidad
de veces que un usuario ha accedido a un sitio web, etc. Nombrar el valor 28
algo así como num_students aclara el significado del valor.

52
Machine Translated by Google

3.3. Crear una variable

En esta sección, aprenderá cómo usar variables en su código, así como algunas
de las convenciones que siguen los programadores de Python al elegir nombres
para las variables.

El operador de asignación
Los valores se asignan a una variable mediante un símbolo especial = llamado
operador de asignación. Un operador es un símbolo, como = o +, que realiza
alguna operación en uno o más valores.

Por ejemplo, el operador + toma dos números, uno a la izquierda del operador y
otro a la derecha, y los suma. Asimismo, el operador = toma un valor a la derecha
del operador y lo asigna al nombre a la izquierda del operador.

Para ver el operador de asignación en acción, modifiquemos el programa "Hola,

mundo" que vio en la última sección. Esta vez, usaremos una variable para
almacenar algo de texto antes de imprimirlo en la pantalla:

>>> frase = "Hola mundo"

>>> imprimir(frase)
Hola Mundo

En la primera línea, se crea una variable llamada frase y se le asigna el valor

"Hola mundo" usando el operador = . La cadena "Hola, mundo" que se usó
originalmente dentro del paréntesis en la función print() se reemplaza con la
frase variable.

La salida Hola, mundo se muestra cuando ejecuta print(phrase) porque Python

busca la frase del nombre y descubre que se le ha asignado el valor "Hola,
mundo".

Si no hubiera ejecutado frase = "Hola, mundo" antes de ejecutar print(phrase),

habría visto un NameError como lo hizo al intentar ejecutar print(Hello, world) en
la sección anterior.

53
Machine Translated by Google

3.3. Crear una variable

Nota
Aunque = parece el signo igual en matemáticas, tiene un significado diferente
en Python. Distinguir el operador = del signo igual es importante y puede ser
una fuente de frustración para los programadores principiantes.

Solo recuerde, cada vez que vea el operador = , todo lo que esté a la
derecha se asignará a una variable a la izquierda.

Los nombres de las variables distinguen entre mayúsculas y minúsculas, por lo que una variable

denominada frase se distingue de una variable denominada Frase (tenga en cuenta la P

mayúscula ). Por ejemplo, el siguiente código produce un NameError:

>>> frase = "Hola mundo"

>>> imprimir(Frase)
Rastreo (llamadas recientes más última):
Archivo "<stdin>", línea 1, en <módulo>
NameError: el nombre 'Frase' no está definido

Cuando tenga problemas con los ejemplos de código de este libro, asegúrese de
verificar que cada carácter de su código (incluidos los espacios) coincida exactamente
con los ejemplos. Las computadoras no pueden usar el sentido común para
interpretar lo que usted quiso decir, por lo que ser casi correcto no hará que una
computadora haga lo correcto.

Reglas para nombres de variables válidos

Los nombres de las variables pueden ser tan largos o tan cortos como quieras, pero
hay un par de reglas que debes seguir. Los nombres de variables solo pueden
contener letras mayúsculas y minúsculas (A–Z, a–z), dígitos (0–9) y guiones bajos
(_). Sin embargo, los nombres de las variables no pueden comenzar con un dígito.

Por ejemplo, frase, cadena1, _a1p4a y lista_de_nombres son nombres de variables válidos,
pero 9lives no lo es.

54
Machine Translated by Google

3.3. Crear una variable

Nota
Los nombres de las variables de Python pueden contener muchos caracteres Uni­code
válidos diferentes. Unicode es un estándar para representar digitalmente texto utilizado
en la mayoría de los sistemas de escritura del mundo.

Eso significa que los nombres de las variables pueden contener letras de alfabetos no

ingleses, como letras decoradas como é y ü, y

incluso símbolos chinos, japoneses y árabes.

Sin embargo, no todos los sistemas pueden mostrar personajes decorados, por lo que
Es una buena idea evitarlos si tu código va a ser compartido.
con personas de muchas regiones diferentes.

Puede obtener más información sobre Unicode en Wikipedia. El soporte de

Python para Unicode se trata en la documentación oficial de Python .

El hecho de que el nombre de una variable sea válido no significa necesariamente que sea
es un buen nombre. Elegir un buen nombre para una variable puede resultar sorprendentemente
difícil. Sin embargo, existen algunas pautas que puedes seguir.
para ayudarle a elegir mejores nombres.

Los nombres descriptivos son mejores que los nombres cortos

Los nombres descriptivos de las variables son esenciales, especialmente para programas
complejos. A menudo, los nombres descriptivos requieren el uso de varias palabras. No
tenga miedo de utilizar nombres de variables largos.

En el siguiente ejemplo, se asigna el valor 3600 a la variable s:

s = 3600

El nombre s es totalmente ambiguo. Usar una palabra completa lo hace mucho más fácil
para entender lo que significa el código:

segundos = 3600

segundos es un mejor nombre que s porque proporciona más contexto. Pero

55
Machine Translated by Google

3.3. Crear una variable

todavía no transmite el significado completo del código. ¿Es 3600 el número de

segundos que tarda en finalizar algún proceso o la duración de una película?
No hay manera de saberlo.

El siguiente nombre no deja dudas sobre lo que significa el código:

segundos_por_hora = 3600

Cuando lees el código anterior, no hay duda de que 3600 es la cantidad de segundos
en una hora. Aunque se tarda más en escribir segundos_por_hora que la letra s y la
palabra segundos, la recompensa en claridad es enorme.

Aunque nombrar las variables de forma descriptiva significa utilizar nombres de

variables más largos, debe evitar los nombres que sean excesivamente largos. Lo
que realmente significa "excesivamente largo" es subjetivo, pero una buena regla
general es mantener los nombres de las variables en menos de tres o cuatro palabras.

Convenciones de nomenclatura de variables de Python

En muchos lenguajes de programación, es común escribir nombres de variables

en camelCase como numStudents y listOfNames. La primera letra de cada palabra,
excepto la primera, está en mayúscula y todas las demás letras en minúscula. La
yuxtaposición de letras minúsculas y mayúsculas parece la joroba de un camello.

En Python, sin embargo, es más común escribir nombres de variables en mayúsculas

y minúsculas como num_students y list_of_names. Cada letra está en minúscula y
cada palabra está separada por un guión bajo.

Si bien no existe una regla estricta que obligue a escribir los nombres de las variables
en caso de serpiente, la práctica está codificada en un documento llamado PEP. 8,
que es ampliamente considerada como la guía de estilo oficial para escribir Python.

Seguir los estándares descritos en PEP 8 garantiza que su código Python sea legible
por una gran cantidad de programadores Python. Esto hace que compartir y colaborar
en código sea más fácil para todos los involucrados.

56
Machine Translated by Google

3.4. Inspeccionar valores en la ventana interactiva

Nota

Todos los ejemplos de código de este curso siguen las pautas de PEP 8, por
lo que obtendrá una gran exposición a cómo se ve el código Python que sigue
las pautas de formato estándar.

En esta sección aprendió cómo crear una variable, reglas para nombres de variables
válidos y algunas pautas para elegir buenos nombres de variables.
A continuación, aprenderá cómo inspeccionar el valor de una variable en la ventana
interactiva de IDLE.

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos adicionales
en línea en realpython.com/python­basics/resources.

1. Usando la ventana interactiva, muestre algo de texto en la pantalla usando la

función print() .

2. Usando la ventana interactiva, muestre una cadena de texto guardándola en una

variable, luego haga referencia a la cadena en una función print() usando el
nombre de la variable.

3. Realice cada uno de los dos primeros ejercicios nuevamente guardando primero su código en
un script y ejecutarlo.

Deje comentarios sobre esta sección »

3.4 Inspeccionar valores en la ventana interactiva

Ya has visto cómo usar print() para mostrar una cadena que ha sido asignada a una
variable. Hay otra forma de mostrar el valor de una variable cuando trabaja en el shell
de Python.

Escriba lo siguiente en la ventana interactiva de IDLE:

57
Machine Translated by Google

3.4. Inspeccionar valores en la ventana interactiva

>>> frase = "Hola mundo"

>>> frase

Cuando presiona Enter después de escribir la frase por segunda vez, se muestra
el siguiente resultado:

'Hola Mundo'

Python imprime la cadena "Hola, mundo", ¡y no era necesario escribir

print(phrase)!

Ahora escribe lo siguiente:

>>> imprimir(frase)

Esta vez, cuando presionas Enter ves:

Hola Mundo

¿Ves la diferencia entre este resultado y el resultado de simplemente escribir

una frase? No tiene comillas simples a su alrededor.
¿Que está pasando aqui?

Cuando escribe frase y presiona Enter, le está diciendo a Python que

inspeccione la frase variable . La salida mostrada es una representación útil del
valor asignado a la variable.

En este caso, a la frase se le asigna la cadena "Hola, mundo", por lo que el

resultado está entre comillas simples para indicar que la frase es una cadena.

Por otro lado, cuando imprimes() una variable, Python muestra una representación
más legible por humanos del valor de la variable. Para las cadenas, ambas
formas de mostrarse son legibles por humanos, pero este no es el caso para
todos los tipos de valores.

A veces, tanto imprimir como inspeccionar una variable produce el mismo

resultado:

58
Machine Translated by Google

3.4. Inspeccionar valores en la ventana interactiva

>>> x = 2
>>> x
2

>>> imprimir(x)
2

Aquí, x se asigna al número 2. Tanto la salida de print(x) como la

inspección de x no están entre comillas, porque 2 es un número y no una
cadena.

Inspeccionar una variable, en lugar de imprimirla, es útil por un par de

razones. Puede usarlo para mostrar el valor de una variable sin escribir
print(). Sin embargo, lo más importante es que inspeccionar una variable
generalmente proporciona información más útil que print() .

Supongamos que tiene dos variables: x = 2 e y = "2". En este caso, print(x)

e print(y) muestran lo mismo. Sin embargo, inspeccionar xey muestra la
diferencia entre el valor de cada variable:

>>> x = 2

>>> y = "2"
>>> imprimir(x)
2

>>> imprimir(y)
2
>>> x
2

>>> y
'2'

La conclusión clave aquí es que print() muestra una representación legible

del valor de una variable, mientras que la inspección proporciona
información adicional sobre el tipo de valor.

Puede inspeccionar más que solo variables en el shell de Python. Mira lo

que sucede cuando escribes imprimir y presionas Enter:

59
Machine Translated by Google

3.5. Déjate notas útiles

>>> imprimir
< función incorporada de impresión>

Tenga en cuenta que sólo puede inspeccionar variables en un shell de Python. Por
ejemplo, guarde y ejecute el siguiente script:

frase = "Hola mundo"

frase

El script se ejecuta sin errores, ¡pero no se muestra ningún resultado!

A lo largo de este libro, verá ejemplos que utilizan la ventana interactiva para
inspeccionar variables.

Deje comentarios sobre esta sección »

3.5 Déjese notas útiles

Los programadores suelen leer el código que escribieron hace varios meses y se
preguntan "¿Qué diablos hace esto?" Incluso con nombres de variables descriptivos,
puede resultar difícil recordar por qué escribiste algo de la forma en que lo hiciste
cuando no lo has visto durante mucho tiempo.

Para ayudar a evitar este problema, puede dejar comentarios en su código.

Los comentarios son líneas de texto que no afectan la forma en que se ejecuta el script.
Ayudan a documentar lo que se supone que está sucediendo.

En esta sección, aprenderá tres formas de dejar comentarios en su código. También

aprenderá algunas convenciones para formatear comentarios, así como algunas cosas
que le molestan con respecto a su uso excesivo.

Cómo escribir un comentario

La forma más común de escribir un comentario es comenzar una nueva línea en su
código con el carácter # . Cuando se ejecuta su código, se ignoran las líneas que
comienzan con # . Los comentarios que comienzan en una nueva línea se denominan
comentarios de bloque.

60
Machine Translated by Google

3.5. Déjate notas útiles

También puede escribir comentarios en línea, que son comentarios que aparecen en la
misma línea que algún código. Simplemente coloque un # al final de la línea de código,
seguido del texto de su comentario.

A continuación se muestra un ejemplo del script hello_world.py con ambos tipos de

comentarios agregados:

# Este es un comentario en bloque.

frase = "Hola mundo".

print(frase) # Este es un comentario en línea.

La primera línea no hace nada porque comienza con #. Del mismo modo, se ejecuta
print(phrase) en la última línea, pero se ignora todo lo que sigue a # .

Por supuesto, aún puedes usar el símbolo # dentro de una cadena. Por ejemplo, Python
no confundirá lo siguiente con el comienzo de un comentario:

imprimir("#1")

En general, es una buena idea mantener los comentarios lo más breves posible, pero a
veces es necesario escribir más de lo que cabe razonablemente en una sola línea. En
ese caso, puedes continuar tu comentario en una nueva línea que también comience
con el símbolo # :

# Este es mi primer guión.

# Imprime la frase "Hola mundo".
# ¡Los comentarios son más largos que el guión!

frase = "Hola mundo".

imprimir (frase)

Además de dejarte notas, los comentarios también se pueden utilizar para comentar el
código mientras pruebas un programa. En otras palabras, agregar un # al comienzo de
una línea de código le permite ejecutar su programa como si esa línea de código no
existiera sin tener que eliminar ningún código.

Para comentar una sección de código en IDLE, resalte una o más líneas

61
Machine Translated by Google

3.5. Déjate notas útiles

para comentar y presionar:

• Ventanas: Alt + 3

• Mac OS: Ctrl + 3

• Ubuntu Linux:: Ctrl + D

Se insertan dos símbolos # al principio de cada línea. Esto no sigue las convenciones
de formato de comentarios de PEP 8, ¡pero hace el trabajo!

Para descomentar su código y eliminar los símbolos # del principio de cada línea,
resalte el código que está comentado y
prensa:

• Ventanas: Alt + 4

• Mac OS: Ctrl + 4

• Ubuntu Linux: Ctrl + Mayús + D

Ahora veamos algunas convenciones comunes relacionadas con la combinación de códigos.

mentos.

Convenciones y cosas que le molestan

Según el PPE 8, los comentarios siempre deben escribirse en oraciones completas

con un solo espacio entre el # y la primera palabra del
comentario:

# Este comentario tiene el formato PEP 8.

#no hagas esto

Para comentarios en línea, PEP 8 recomienda al menos dos espacios entre el código
y el símbolo # :

frase = "Hola mundo" # Este comentario cumple con PEP 8.

print(frase)# Este comentario no lo es.

Una de las principales cosas que molestan a los programadores son los comentarios que describen

62
Machine Translated by Google

3.6. Resumen y recursos adicionales

lo que ya es obvio al leer el código. Por ejemplo, el siguiente comentario es

innecesario:

# Imprimir "Hola mundo"

imprimir("Hola mundo")

No se necesitan comentarios en este ejemplo porque el código mismo describe

explícitamente lo que se está haciendo. Los comentarios se utilizan mejor para
aclarar código que puede no ser fácil de entender o para explicar por qué algo se
hace de cierta manera.

En general, PEP 8 recomienda que los comentarios se utilicen con moderación.

Utilice comentarios sólo cuando agreguen valor a su código al facilitar la
comprensión de por qué algo se hace de cierta manera. Los comentarios que
describen lo que hace algo a menudo se pueden evitar utilizando nombres de
variables más descriptivos.

Deje comentarios sobre esta sección »

3.6 Resumen y recursos adicionales

¡En este capítulo, escribiste y ejecutaste tu primer programa Python!
Escribiste un pequeño programa que muestra el texto "Hola, mundo" usando la
función print() .

Le presentaron tres conceptos:

1. Las variables dan nombres a los valores en su código usando la asignación

operador (=)

2. Los errores, como errores de sintaxis y errores de tiempo de ejecución, surgen

cada vez que Python no puede ejecutar su código. Se muestran en la ventana
interactiva de IDLE en forma de rastreo.

3. Los comentarios son líneas de código que no se ejecutan y sirven como

documentación para usted y otros programadores que necesitan leer su código.

63
Machine Translated by Google

3.6. Resumen y recursos adicionales

Prueba interactiva

Este capítulo viene con un cuestionario en línea gratuito para verificar su progreso
de aprendizaje. Puede acceder al cuestionario usando su teléfono o computadora
en la siguiente dirección web:

realpython.com/quizzes/python­basics­3

Recursos adicionales

Para obtener más información, consulte los siguientes recursos:

• 11 consejos para principiantes para aprender a programar en Python

• Escribir comentarios en Python (Guía)

• Recursos recomendados en realpython.com

Deje comentarios sobre esta sección »

64
Machine Translated by Google

Capítulo 4

Cadenas y métodos de cadenas

Muchos programadores, independientemente de su especialidad, tratan con texto a diario. Por ejemplo,

los desarrolladores web trabajan con texto que recibe datos de formularios web. Los científicos de datos

procesan texto para extraer datos y realizar cosas como análisis de sentimientos, que pueden ayudar a

identificar y clasificar opiniones en un cuerpo de texto.

Las colecciones de texto en Python se denominan cadenas. Para manipular cadenas se utilizan funciones

especiales llamadas métodos de cadena . Existen métodos de cadena para cambiar una cadena de

minúsculas a mayúsculas, eliminar espacios en blanco desde el principio o el final de una cadena, o

reemplazar partes de una cadena con texto diferente, y muchos más.

En este capítulo, aprenderá cómo:

• Manipular cadenas con métodos de cadena.

• Trabajar con la entrada del usuario

• Tratar con cadenas de números

• Formatear cadenas para imprimir

¡Empecemos!

Deje comentarios sobre esta sección »

sesenta y cinco
Machine Translated by Google

4.1. ¿Qué es una cadena?

4.1 ¿Qué es una cadena?

En el Capítulo 3, creó la cadena "Hola, mundo" y la imprimió en la ventana interactiva
de IDLE usando la función print() . En esta sección, obtendrá una visión más profunda
de qué es exactamente una cadena y las diversas formas en que puede crearlas en
Python.

El tipo de datos de cadena

Las cadenas son uno de los tipos de datos fundamentales de Python. El término tipo
de datos se refiere al tipo de datos que representa un valor. Las cadenas se utilizan
para representar texto.

Nota
Hay varios otros tipos de datos integrados en Python. Por ejemplo, aprenderá
sobre los tipos de datos numéricos en el Capítulo 5 y los tipos booleanos en
el Capítulo 8.

Decimos que las cadenas son un tipo de datos fundamental porque no se pueden
dividir en valores más pequeños de un tipo diferente. No todos los tipos de datos son
fundamentales. Aprenderá sobre los tipos de datos compuestos, también conocidos
como estructuras de datos, en el Capítulo 9.

El tipo de datos de cadena tiene un nombre abreviado especial en Python: str.

Puede ver esto utilizando la función type() , que se utiliza para determinar el tipo de
datos de un valor determinado.

Escriba lo siguiente en la ventana interactiva de IDLE:

>>> tipo("Hola mundo")

<clase 'cadena'>

La salida <class 'str'> indica que el valor "Hola, mundo" es una instancia del tipo de
datos str . Es decir, "Hola mundo" es una cadena.

66
Machine Translated by Google

4.1. ¿Qué es una cadena?

Nota

Por ahora, puedes pensar en la palabra “clase” como sinónimo de “tipo de datos”,
aunque en realidad se refiere a algo más específico. Verás qué es una clase en
el Capítulo 10.

type() también funciona para valores que han sido asignados a una variable:

>>> frase = "Hola mundo"

>>> tipo(frase)
<clase 'cadena'>

Las cadenas tienen tres propiedades que explorará en las siguientes secciones:

1. Las cadenas contienen caracteres, que son letras individuales o símbolos.

bols.

2. Las cadenas tienen una longitud, que es la cantidad de caracteres.

contenida en la cadena.

3. Los caracteres de una cadena aparecen en una secuencia, es decir, cada carácter
El actor tiene una posición numerada en la cadena.

Echemos un vistazo más de cerca a cómo se crean las cadenas.

Literales de cadena

Como ya has visto, puedes crear una cadena encerrando algún texto entre comillas:

string1 = 'Hola mundo'

cadena2 = "1234"

Se pueden utilizar comillas simples (cadena1) o dobles (cadena2) para crear una cadena,
siempre que ambas comillas sean del mismo tipo.

Siempre que crea una cadena encerrando el texto entre comillas, la cadena se denomina
literal de cadena. El nombre indica que la cadena está literalmente escrita en su código.
Todas las cuerdas que tu

67
Machine Translated by Google

4.1. ¿Qué es una cadena?

hemos visto hasta ahora son cadenas literales.

Nota

No todas las cadenas son literales de cadena. Por ejemplo, una cadena capturada
como entrada del usuario no es una cadena literal porque no está escrita
explícitamente en el código del programa.

Aprenderá cómo trabajar con la entrada del usuario en la sección 4 de este capítulo.
ter.

Las comillas que rodean una cadena se llaman delimitadores porque le dicen a Python dónde
comienza y dónde termina una cadena. Cuando se usa un tipo de comillas como delimitador,
el otro tipo de comillas se puede usar dentro de la cadena:

string3 = "¡Somos el número 1!"

string4 = 'Dije: "Déjalo junto a la llama".'

Después de que Python lee el primer delimitador, todos los caracteres posteriores se
consideran parte de la cadena hasta que se lee un segundo delimitador coincidente. Es por
eso que puedes usar comillas simples en una cadena delimitada por comillas dobles y
viceversa.

Si intenta utilizar comillas dobles dentro de una cadena delimitada por comillas dobles,
obtendrá un error:

>>> text = "Ella dijo: "¿Qué hora es ?""

Archivo "<stdin>", línea 1
text = "Ella dijo: "¿Qué hora es ?""
^

Error de sintaxis: sintaxis invalida

Python arroja un SyntaxError porque cree que la cadena termina después del segundo " y no
sabe cómo interpretar el resto de la línea.

68
Machine Translated by Google

4.1. ¿Qué es una cadena?

Nota

Un motivo común entre los programadores es el uso de comillas mixtas como

delimitadores. Cuando trabaja en un proyecto, es una buena idea utilizar sólo
comillas simples o dobles para delimitar cada cadena.

¡Tenga en cuenta que en realidad no existe una elección correcta o incorrecta!

El objetivo es ser coherente, porque la coherencia ayuda a que el código sea
más fácil de leer y comprender.

Las cadenas pueden contener cualquier carácter Unicode válido. Por ejemplo, la
cadena "¡Somos el número 1!" contiene el signo de almohadilla (#) y "1234" contiene
números. "×Pýŧħøŋ×" también es una cadena Python válida.

Determinar la longitud de una cuerda

La cantidad de caracteres contenidos en una cadena, incluidos los espacios, se
denomina longitud de la cadena. Por ejemplo, la cadena "abc" tiene una longitud de 3
y la cadena "Don't Panic" tiene una longitud de 11.

Para determinar la longitud de una cadena, se utiliza la función len() incorporada de

Python . Para ver cómo funciona, escriba lo siguiente en la ventana interactiva de
IDLE:

>>> len("abc")
3

También puedes usar len() para obtener la longitud de una cadena asignada a una
variable:

>>> letras = "abc"

>>> num_letras = len(letras)

>>> numero_letras
3

Primero, se asigna la cadena "abc" a las letras variables. Luego se usa len() para
obtener la longitud de las letras y este valor se asigna a la variable num_letters .
Finalmente, el valor de num_letters, que es 3, es

69
Machine Translated by Google

4.1. ¿Qué es una cadena?

desplegado.

Cadenas multilínea
El PEP 8 La guía de estilo recomienda que cada línea de código Python no
contenga más de 79 caracteres, incluidos los espacios.

Nota

Se recomienda la longitud de línea de 79 caracteres de PEP 8 porque, entre

otras cosas, facilita la lectura de dos archivos uno al lado del otro. Sin
embargo, muchos programadores de Python creen que forzar que cada
línea tenga como máximo 79 caracteres a veces hace que el código sea
más difícil de leer.

En este libro seguiremos estrictamente la longitud de línea recomendada

por PEP 8. Solo debes saber que encontrarás mucho código en el mundo
real con líneas más largas.

Ya sea que decida seguir PEP 8 o elegir una mayor cantidad de caracteres para la
longitud de su línea, a veces necesitará crear cadenas literales con más caracteres
que el límite elegido.

Para trabajar con cadenas largas, puede dividir la cadena en varias líneas en una
cadena de varias líneas. Por ejemplo, supongamos que necesita incluir el siguiente
texto en una cadena literal:

“Este planeta tiene, o más bien tenía, un problema, que era el

siguiente: la mayoría de las personas que vivían en él eran infelices
durante gran parte del tiempo. Se sugirieron muchas soluciones
para este problema, pero la mayoría de ellas se referían
principalmente a los movimientos de pequeños trozos de papel
verdes, lo cual es extraño porque, en general, no eran los pequeños
trozos de papel verdes los que estaban descontentos".

— Douglas Adams, La guía del autoestopista galáctico

70
Machine Translated by Google

4.1. ¿Qué es una cadena?

Este párrafo contiene mucho más de 79 caracteres, por lo que cualquier línea de código
que contenga el párrafo como una cadena literal viola PEP 8. Entonces, ¿qué haces?

Hay un par de formas de abordar esto. Una forma es dividir la cadena en varias líneas
y colocar una barra invertida (\) al final de todas las líneas excepto la última. Para
cumplir con PEP 8, la longitud total de la línea, incluida la barra invertida, debe tener
79 caracteres o menos.

Así es como puedes escribir el párrafo como una cadena de varias líneas usando el
método de barra invertida:

parrafo = "Este planeta tiene ­ o mejor dicho tenia ­ un problema, que era \
esto: la mayoría de las personas que vivían allí eran infelices durante la mayor parte del
tiempo. Se sugirieron muchas soluciones para este problema, pero \
la mayoría de ellos se referían en gran medida a los movimientos de pequeños \
trozos de papel verdes, lo cual es extraño porque en general no lo era \
los pequeños trozos de papel verdes que estaban infelices."

Tenga en cuenta que no es necesario cerrar cada línea con comillas.

Normalmente, Python llegaría al final de la primera línea y se quejaría de que no cerró
la cadena con una comilla doble coincidente. Sin embargo, con una barra invertida al
final, puedes seguir escribiendo la misma cadena en la siguiente línea.

Cuando imprime() una cadena de varias líneas dividida por barras invertidas, el
resultado se muestra en una sola línea:

>>> long_string = "Esta cadena multilínea se \ muestra en

una sola línea"
>>> imprimir(cadena_larga)
Esta cadena de varias líneas se muestra en una línea

También se pueden crear cadenas de varias líneas utilizando comillas triples como
delimitadores (""" o '''). A continuación se explica cómo escribir un párrafo largo
utilizando este enfoque:

71
Machine Translated by Google

4.1. ¿Qué es una cadena?

parrafo = """Este planeta tiene ­ o mejor dicho tenia­ un problema, que fue
esto: la mayoría de las personas que vivían allí eran infelices la mayor parte del
tiempo. Se sugirieron muchas soluciones para este problema, pero
la mayoría de ellos se referían en gran medida a los movimientos de pequeños
trozos de papel verdes, lo cual es extraño porque en general no era
los pequeños trozos de papel verdes que estaban infelices."""

Las cadenas entre comillas triples conservan los espacios en blanco. Esto significa que
ejecutar print(paragraph) muestra la cadena en varias líneas tal como está en el literal de
cadena, incluidas las nuevas líneas. Esto puede ser lo que desea o no, por lo que deberá
pensar en el resultado deseado antes de elegir cómo escribir una cadena de varias líneas.

Para ver cómo se conservan los espacios en blanco en una cadena entre comillas triples,
escriba lo siguiente en la ventana interactiva de IDLE:

>>> print("""Un ejemplo de un

... cadena que se extiende a lo largo de varias líneas
... eso también preserva los espacios en blanco.""")
Un ejemplo de un
cadena que se extiende a lo largo de varias líneas y
que también conserva los espacios en blanco.

Observe cómo la segunda y tercera línea del resultado tienen sangría exactamente de la
misma manera que en la cadena literal.

Nota

Las cadenas entre comillas triples tienen un propósito especial en Python. Se

utilizan para documentar código. A menudo los encontrarás en la parte superior
de un .py con una descripción del propósito del código. También se utilizan para
documentar funciones personalizadas.

Cuando se utilizan para documentar código, las cadenas entre comillas triples se denominan

cadenas de documentos. Aprenderá más sobre las cadenas de documentación en el Capítulo 6.

72
Machine Translated by Google

4.2. Concatenación, indexación y corte

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos adicionales
en línea en realpython.com/python­basics/resources.

1. Imprima una cadena que utilice comillas dobles dentro de la cadena.

2. Imprima una cadena que utilice un apóstrofe dentro de la cadena.

3. Imprima una cadena que abarque varias líneas, conservando los espacios en blanco.

4. Imprima una cadena que esté codificada en varias líneas pero que se muestre en una sola línea.
línea recta.

Deje comentarios sobre esta sección »

4.2 Concatenación, indexación y

división
Ahora que sabe qué es una cadena y cómo declarar literales de cadena en su código,
exploremos algunas de las cosas que puede hacer con las cadenas.

En esta sección, aprenderá sobre tres operaciones básicas con cadenas:

1. Concatenación, que une dos cadenas

2. Indexación, que obtiene un solo carácter de una cadena.

3. Cortar, que obtiene varios caracteres de una cadena a la vez

¡Vamos a sumergirnos!

Concatenación de cadenas

Se pueden combinar o concatenar dos cadenas utilizando el operador + :

>>> cadena1 = "abra"

>>> cadena2 = "cadabra"
>>> cadena_magica = cadena1 + cadena2
>>> cadena_magica

73
Machine Translated by Google

4.2. Concatenación, indexación y corte

'abracadabra'

En este ejemplo, la concatenación de cadenas se produce en la tercera línea.

string1 y string2 se concatenan usando + y el resultado se asigna a la variable
magic_string. Observe que las dos cadenas están unidas sin ningún espacio en
blanco entre ellas.

Puede utilizar la concatenación de cadenas para unir dos cadenas relacionadas,

como unir un nombre y apellido en un nombre completo:

>>> nombre_primer = "Arturo"

>>> apellido = "Abolladura"

""
>>> nombre completo = nombre + + apellido

>>> nombre_completo

'Arturo Dent'

Aquí la concatenación de cadenas ocurre dos veces en la misma línea. first_name

se concatena con " ", lo que da como resultado la cadena "Arthur ". Luego, este
resultado se concatena con apellido para producir el nombre completo "Arthur
Mella".

Indexación de cadenas

Cada carácter de una cadena tiene una posición numerada llamada índice.
Puede acceder al carácter en la posición N poniendo el número N entre dos
corchetes ([ y ]) inmediatamente después de la cadena:

>>> sabor = "tarta de manzana"

>>> sabor[1]

'pag'

sabor[1] devuelve el carácter en la posición 1 en "tarta de manzana", que es p.

Espera, ¿no es a el primer personaje de "Apple Pie"?

En Python (y en la mayoría de los demás lenguajes de programación) el conteo

siempre comienza en cero. Para obtener el carácter al principio de una cadena,
necesita acceder al carácter en la posición 0:

74
Machine Translated by Google

4.2. Concatenación, indexación y corte

>>> sabor[0]
'a'

Nota

Olvidar que contar empieza por cero e intentar acceder

el primer carácter de una cadena con el índice 1 genera un error uno por uno.

Los errores uno por uno son una fuente común de frustración para ambos
¡Programadores principiantes y experimentados por igual!

La siguiente figura muestra el índice de cada carácter de la cadena.

"tarta de manzana":

| un | pag | pag | l | mi | | pag | yo | mi |

0 1 2 3 4 5 6 7 8

Si intenta acceder a un índice más allá del final de una cadena, Python genera
un error de índice:

>>> sabor[9]
Rastreo (llamadas recientes más última):

Archivo "<pyshell#4>", línea 1, en <módulo>

sabor[9]

IndexError: índice de cadena fuera de rango

El índice más grande de una cadena es siempre uno menos que la longitud de la cadena.
Dado que "tarta de manzana" tiene una longitud de nueve, el índice más grande permitido es 8.

Las cadenas también admiten índices negativos:

>>> sabor[­1]
'mi'

El último carácter de una cadena tiene índice ­1, que para "tarta de manzana" es el
letra e. El penúltimo carácter i tiene índice ­2, y así sucesivamente.

75
Machine Translated by Google

4.2. Concatenación, indexación y corte

La siguiente figura muestra el índice negativo de cada carácter en

la cadena "tarta de manzana":

| un | pag | pag | l| mi | | pag | i | mi |

­9 ­8 ­7 ­6 ­5 ­4 ­3 ­2 ­1

Al igual que los índices positivos, Python genera un IndexError si intenta acceder a
un índice negativo menor que el índice del primer carácter del
cadena:

>>> sabor[­10]
Rastreo (llamadas recientes más última):
Archivo "<pyshell#5>", línea 1, en <módulo>
sabor[­10]
IndexError: índice de cadena fuera de rango

Los índices negativos pueden no parecer útiles al principio, pero a veces lo son.
una mejor opción que un índice positivo.

Por ejemplo, supongamos que una cadena ingresada por un usuario se asigna a la
variable entrada_usuario. Si necesita obtener el último carácter de la cadena, ¿cómo
¿Sabes qué índice usar?

Una forma de obtener el último carácter de una cadena es calcular el valor final.
índice usando len():

índice_final = len(entrada_usuario) ­ 1
último_carácter = entrada_usuario[índice_final]

Obtener el carácter final con el índice ­1 requiere menos escritura y

No requiere un paso intermedio para calcular el índice final:

último_carácter = entrada_usuario[­1]

76
Machine Translated by Google

4.2. Concatenación, indexación y corte

Cortar cuerdas
Supongamos que necesita la cadena que contiene sólo las tres primeras letras
de la cadena "tarta de manzana". Podrías acceder a cada carácter por índice y
concatenarlos, así:

>>> primeras_tres_letras = sabor[0] + sabor[1] + sabor[2]

>>> primeras_tres_letras

'aplicación'

Si necesita algo más que las primeras letras de una cadena, obtener cada
carácter individualmente y concatenarlos es complicado y largo. Afortunadamente,
Python proporciona una manera de hacer esto con mucho menos tipeo.

Puede extraer una parte de una cadena, llamada subcadena, insertando dos
puntos entre dos números de índice dentro de corchetes, así:

>>> sabor = "tarta de manzana"

>>> sabor[0:3]

'aplicación'

sabor[0:3] devuelve los primeros tres caracteres de la cadena asignada a sabor,

comenzando con el carácter con índice 0 y llegando hasta el carácter con índice
3, pero sin incluirlo. La parte [0:3] de sabor[ 0:3] se llama corte. En este caso,
devuelve una porción de "tarta de manzana". ¡Mmm!

Los sectores de cadena pueden resultar confusos porque la subcadena devuelta

por el sector incluye el carácter cuyo índice es el primer número, pero no incluye
el carácter cuyo índice es el segundo número.

Para recordar cómo funciona el corte, puedes pensar en una cuerda como una
secuencia de ranuras cuadradas. Los límites izquierdo y derecho de cada ranura
están numerados desde cero hasta la longitud de la cadena, y cada ranura se
llena con un carácter de la cadena.

Así es como se ve la cadena "tarta de manzana":

| un | pag | pag | yo | mi | | pag | yo | mi |

77
Machine Translated by Google

4.2. Concatenación, indexación y corte

0 1 2 3 4 5 6 7 8 9

El segmento [x:y] devuelve la subcadena entre los límites xey .

Entonces, para "tarta de manzana", el segmento [0:3] devuelve la cadena "app" y el segmento
[3:9] devuelve la cadena "le pie".

Si omite el primer índice en un segmento, Python asume que desea comenzar

en el índice 0:

>>> sabor[:5]

'manzana'

El segmento [:5] es equivalente al segmento [0:5], por lo que sabor[:5] devuelve el

primeros cinco caracteres de la cadena "tarta de manzana".

De manera similar, si omite el segundo índice en el segmento, Python asume

desea devolver la subcadena que comienza con el carácter cuyo
El índice es el primer número del segmento y termina con el último carácter.
en la cadena:

>>> sabor[5:]

' tarta'

Para "tarta de manzana", la porción [5:] es equivalente a la porción [5:9]. Desde

el carácter con índice 5 es un espacio, sabor[5:9] devuelve la subcadena
que comienza con el espacio y termina con la última letra, que es "pie".

Si omites el primer y el segundo número en un segmento, obtienes un

cadena que comienza con el carácter con índice 0 y termina con el último
personaje. En otras palabras, omitir ambos números en un segmento devuelve
toda la cadena:

>>> sabor[:]

'tarta de manzana'

Es importante tener en cuenta que, a diferencia de la indexación de cadenas, Python no generará

un IndexError cuando intentas dividir entre límites antes o después

78
Machine Translated by Google

4.2. Concatenación, indexación y corte

los límites inicial y final de una cadena:

>>> sabor[:14]
'tarta de manzana'

>>> sabor[13:15]
''

En este ejemplo, la primera línea obtiene el segmento desde el principio del

cadena hasta el decimocuarto carácter, pero sin incluirlo. La cadena asignada al sabor
tiene una longitud de nueve, por lo que es de esperar que Python lance
un error. En cambio, cualquier índice inexistente se ignora y todo el
Se devuelve la cadena "tarta de manzana" .

El segundo muestra lo que sucede cuando intentas obtener una porción donde
todo el rango está fuera de límites. sabor[13:15] intenta obtener el
caracteres decimotercero y decimocuarto, que no existen. En lugar de
generando un error, se devuelve la cadena vacía "" .

Puedes usar números negativos en sectores. Las reglas para los sectores con números
negativos son exactamente las mismas que las de los sectores con números positivos.
Es útil visualizar la cadena como ranuras con los límites etiquetados por
números negativos:

|a | pag | pag | yo | mi | | pag |i | mi |

­9 ­8 ­7 ­6 ­5 ­4 ­3 ­2 ­1

Al igual que antes, el segmento [x:y] devuelve la subcadena entre los

límites x e y. Por ejemplo, el segmento [­9:­6] devuelve el primer
tres letras de la cadena "tarta de manzana":

>>> sabor[­9:­6]
'aplicación'

Observe, sin embargo, que el límite más a la derecha no tiene un índice negativo. La
elección lógica para ese límite parecería ser la
número 0, pero eso no funciona:

79
Machine Translated by Google

4.2. Concatenación, indexación y corte

>>> sabor[­9:0]
''

En lugar de devolver la cadena completa, [­9:0] devuelve la cadena vacía "". Esto se
debe a que el segundo número en un segmento debe corresponder a un límite que
viene después del límite correspondiente al primer número, pero tanto ­9 como 0
corresponden al límite más a la izquierda de la figura.

Si necesita incluir el carácter final de una cadena en su segmento, puede omitir el

segundo número:

>>> sabor[­9:]
'tarta de manzana'

Las cadenas son inmutables

Para concluir esta sección, analicemos una propiedad importante de los objetos de
cadena. Las cadenas son inmutables, lo que significa que no puedes cambiarlas una
vez que las hayas creado. Por ejemplo, vea lo que sucede cuando intenta asignar
una nueva letra a un carácter particular de una cadena:

>>> palabra = "meta"

>>> palabra[0] = "f"
Rastreo (llamadas recientes más última):
Archivo "<pyshell#16>", línea 1, en <módulo>
palabra[0] = "f"
TypeError: el objeto 'str' no admite la asignación de elementos

Python arroja un TypeError y le indica que los objetos str no admiten la asignación
de elementos.

Nota
El término str es el nombre interno de Python para el tipo de datos de cadena.

Si desea modificar una cadena, debe crear una cadena completamente nueva.
Para cambiar la cadena "meta" por la cadena "potro", puedes usar una cadena

80
Machine Translated by Google

4.3. Manipular cadenas con métodos

corte para concatenar la letra "f" con todo menos la primera letra de la palabra
"objetivo":

>>> palabra = "meta"

>>> palabra = "f" + palabra[1:]

>>> palabra

'potro'

Primero asigne la cadena "objetivo" a la palabra variable . Luego concatene la palabra

dividida [1:], que es la cadena "oal", con la letra "f" para obtener la cadena "foal". Si
obtiene un resultado diferente aquí, asegúrese de incluir el carácter de dos puntos
como parte del segmento de cadena.

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos adicionales
en línea en realpython.com/python­basics/resources.

1. Cree una cadena e imprima su longitud usando la función len() .

2. Cree dos cadenas, concatenélas e imprima el resultado

cadena.

3. Cree dos cadenas y use la concatenación para agregar un espacio en

entre ellos. Luego imprima el resultado.

4. Imprima la cadena "zing" utilizando notación de división en la cadena "bazinga"

para especificar el rango correcto de caracteres.

Deje comentarios sobre esta sección »

4.3 Manipular cadenas con métodos

Las cadenas vienen con funciones especiales llamadas métodos de cadena que se
pueden usar para trabajar y manipular cadenas. Hay numerosos métodos de
cadenas disponibles, pero nos centraremos en algunos de los más utilizados.

En esta sección, aprenderá cómo:

81
Machine Translated by Google

4.3. Manipular cadenas con métodos

• Convertir una cadena a mayúsculas o minúsculas

• Eliminar espacios en blanco de la cadena

• Determinar si una cadena comienza y termina con ciertos caracteres

¡Vamos!

Conversión de caja de cuerdas

Para convertir una cadena a letras minúsculas, se utiliza el método .lower() de la

cadena . Esto se hace agregando .lower() al final de la cadena:

>>> "Jean­luc Picard".inferior()

'jean luc picard'

El punto (.) le dice a Python que lo que sigue es el nombre de un método; en este caso,
el método lower() .

Nota
Nos referiremos a los nombres de los métodos de cadena con un punto al
principio. Entonces, por ejemplo, el método .lower() se escribe con un punto,
en lugar de lower().

La razón por la que hacemos esto es para facilitar la detección de funciones

que son métodos de cadena, a diferencia de funciones integradas como print()
y type().

Los métodos de cadena no solo funcionan con cadenas literales. También puedes usar
el método .lower() en una cadena asignada a una variable:

>>> nombre = "Jean­luc Picard"

>>> nombre.inferior()
'jean luc picard'

Lo opuesto al método .lower() es el método .upper() , que convierte cada carácter de

una cadena a mayúsculas:

82
Machine Translated by Google

4.3. Manipular cadenas con métodos

>>> voz_alta = "¿Ya puedes oírme?"

>>> voz_alta.superior()
'¿PUEDES OÍRME AÚN?'

Compare los métodos de cadena .upper() y .lower() con la función len() de propósito
general que vio en la última sección. Aparte de los diferentes resultados de estas
funciones, la distinción importante aquí es cómo se utilizan.

La función len() es una función independiente. Si desea determinar la longitud de la

cadena de voz_alta , llame directamente a la función len() , así:

>>> len(voz_alta)
20

Por otro lado, .upper() y .lower() deben usarse junto con una cadena. No existen de
forma independiente.

Eliminar espacios en blanco de una cadena

El espacio en blanco es cualquier carácter que se imprime como espacio en blanco.
Esto incluye cosas como espacios y avances de línea, que son caracteres especiales
que mueven la salida a una nueva línea.

A veces es necesario eliminar espacios en blanco del principio o del final de una
cadena. Esto es especialmente útil cuando se trabaja con cadenas que provienen de
la entrada del usuario, donde es posible que se hayan introducido espacios en blanco
adicionales por accidente.

Hay tres métodos de cadena que puede utilizar para eliminar espacios en blanco de
una cadena:

1. .rstrip()

2. .lstrip()

3. .tira()

.rstrip() elimina los espacios en blanco del lado derecho de una cadena:

83
Machine Translated by Google

4.3. Manipular cadenas con métodos

"
>>> nombre = "Jean­luc Picard
>>> nombre

'Jean­luc Picard '

>>> nombre.rstrip()
'Jean­luc Picard'

En este ejemplo, la cadena "Jean­luc Picard " tiene cinco

espacios. Python no elimina automáticamente ningún espacio final en una cadena
cuando la cadena se asigna a una variable. El método .rstrip()
elimina los espacios finales del lado derecho de la cadena y vuelve a generar
una nueva cadena "Jean­luc Picard", que ya no tiene los espacios
al final.

El método .lstrip() funciona igual que .rstrip(), excepto que elimina

espacios en blanco desde el lado izquierdo de la cadena:

"
>>> nombre = Jean­Luc Picard"
>>> nombre
' Jean­Luc Picard'
>>> nombre.lstrip()
'Jean­luc Picard'

Para eliminar espacios en blanco tanto del lado izquierdo como del derecho del
cadena al mismo tiempo, use el método .strip() :

" "
>>> nombre = Jean­luc Picard
>>> nombre
' Jean­luc Picard '

>>> nombre.strip()
'Jean­luc Picard'

Nota
Ninguno de los métodos .rstrip(), .lstrip() y .strip() elimina
espacio en blanco desde el centro de la cadena. En cada uno de los
ejemplos anteriores, el espacio entre “Jean­luc” y “Picard” es
siempre conservado.

84
Machine Translated by Google

4.3. Manipular cadenas con métodos

Determinar si una cadena comienza o termina con un

Cadena particular
Cuando trabaja con texto, a veces necesita determinar si una cadena determinada
comienza o termina con ciertos caracteres. Puede utilizar dos métodos de cadena
para resolver este problema: .startswith() y .endswith().

Veamos un ejemplo. Considere la cadena "Empresa". Así es como se

usa .startswith() para determinar si la cadena comienza con las letras e y n:

>>> nave estelar = "Empresa"

>>> nave estelar.startswith("es")

FALSO

Debe indicarle a .startswith() qué caracteres buscar proporcionando una cadena

que contenga esos caracteres. Entonces, para determinar si "Enterprise" comienza
con las letras e y n, llame a .startswith("en"). Esto devuelve Falso. ¿Por qué crees
que es?

Si adivinaste que .startswith("en") devuelve False porque "Enter­prise" comienza

con E mayúscula , ¡tienes toda la razón! El método .startswith() distingue entre
mayúsculas y minúsculas. Para que .startswith() devuelva True, debe proporcionarle
la cadena "En":

>>> nave estelar.startswith("Es")

Verdadero

El método .endswith() se utiliza para determinar si una cadena termina con ciertos
caracteres:

>>> nave estelar.termina con("ascenso")

Verdadero

Al igual que .startswith(), el método .endswith() distingue entre mayúsculas y minúsculas:

>>> nave estelar.termina con("se eleva")

FALSO

85
Machine Translated by Google

4.3. Manipular cadenas con métodos

Nota

Los valores Verdadero y Falso no son cadenas. Son un tipo especial

de datos llamado valor booleano. Aprenderá más sobre los valores
booleanos en el Capítulo 8.

Métodos de cadenas e inmutabilidad

Recuerde de la sección anterior que las cadenas son inmutables: no se

pueden cambiar una vez creadas. La mayoría de los métodos de cadena
que modifican una cadena, como .upper() y .lower(), en realidad devuelven
copias de la cadena original con las modificaciones apropiadas.

Si no tiene cuidado, esto puede introducir errores sutiles en su programa.

Pruebe esto en la ventana interactiva de IDLE:

>>> nombre = "Picard"

>>> nombre.superior()
'PICARD'

>>> nombre

'Picard'

Cuando llamas a name.upper(), nada sobre el nombre cambia realmente. Si

necesita conservar el resultado, debe asignarlo a una variable:

>>> nombre = "Picard"

>>> nombre = nombre.superior()

>>> nombre

'PICARD'

name.upper() devuelve una nueva cadena "PICARD", que se reasigna a la

variable de nombre . Esto anula la cadena original "Picard" asignada a
"nombre".

Utilice IDLE para descubrir métodos de cadena adicionales

Las cadenas tienen muchos métodos asociados. Los métodos presentados

en esta sección apenas arañan la superficie. IDLE puede ayudarte

86
Machine Translated by Google

4.3. Manipular cadenas con métodos

encontrar nuevos métodos de cadena. Para ver cómo, primero asigne un literal de
cadena a una variable en la ventana interactiva:

>>> nave estelar = "Empresa"

A continuación, escriba starship seguido de un punto, pero no presione Enter. Deberías

ver lo siguiente en la ventana interactiva:

>>> nave espacial.

Ahora espera un par de segundos. IDLE muestra una lista de cada método de cadena
por el que puede desplazarse con las teclas de flecha.

Un atajo relacionado en IDLE es la capacidad de completar texto automáticamente sin

tener que escribir nombres largos presionando Tab. Por ejemplo, si solo escribe
starship.u y luego presiona la tecla Tab , IDLE completa automáticamente
starship.upper porque solo hay un método perteneciente a starship que comienza con
u.

Esto incluso funciona con nombres de variables. Intente escribir solo las primeras letras
de nave estelar y, asumiendo que no tiene ningún otro nombre ya definido que
comparta esas primeras letras, IDLE completa el nombre nave estelar cuando presiona
la tecla Tab .

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos adicionales
en línea en realpython.com/python­basics/resources.

1. Escriba un script que convierta las siguientes cadenas a minúsculas: "An­imals",

"Badger", "Honey Bee", "Honeybadger". Imprima cada cadena en minúscula en una
línea separada.

2. Repita el ejercicio 1, pero convierta cada cadena a mayúsculas en lugar de

minúscula.

3. Escriba un script que elimine los espacios en blanco de las siguientes cadenas:
"
cadena1 = Filete Miñón"
"
cadena2 = "pechuga

87
Machine Translated by Google

4.4. Interactuar con la entrada del usuario

cadena3 = "Hamburguesa con queso"

Imprime las cadenas sin los espacios en blanco.

4. Escriba un script que imprima el resultado de .startswith("be") en cada

de las siguientes cadenas:
cadena1 = "Se convierte"
cadena2 = "se convierte"
cadena3 = "OSO"
cadena4 = " hermoso"

5. Usando las mismas cuatro cadenas del Ejercicio 4, escriba un script que use
métodos de cadena para alterar cada cadena de modo que .startswith("be")
devuelva Verdadero para todas ellas.

Deje comentarios sobre esta sección »

4.4 Interactuar con la entrada del usuario

Ahora que ha visto cómo trabajar con métodos de cadena, hagamos las cosas interactivas.
En esta sección, aprenderá cómo obtener información de un usuario con la función
input() . Escribirás un programa que le pida al usuario que ingrese un texto y luego se lo
mostrará en mayúsculas.

Ingrese lo siguiente en la ventana interactiva de IDLE:

>>> entrada()

,
Cuando presionas Enter parece que no pasa nada. El cursor se mueve a una
nueva línea, pero no aparece un nuevo >>> . ¡Python está esperando que ingreses
algo!

Continúe, escriba un texto y presione Entrar :

>>> entrada()
¡Hola!

'¡Hola!'

>>>

88
Machine Translated by Google

4.4. Interactuar con la entrada del usuario

El texto que ingresó se repite en una nueva línea con comillas simples.
Esto se debe a que input() devuelve cualquier texto ingresado por el usuario como una cadena.

Para hacer que input() sea un poco más fácil de usar, puede darle un mensaje para que se lo
muestre al usuario. El mensaje es solo una cadena que se coloca entre los paréntesis de
input(). Puede ser cualquier cosa que desee: una palabra, un símbolo, una frase, cualquier
cosa que sea una cadena Python válida.

La función input() muestra el mensaje y espera a que el usuario escriba algo en su teclado.
Cuando el usuario presiona Enter, input() devuelve su entrada como una cadena que puede
asignarse a una variable y usarse para hacer algo en su programa.

Para ver cómo funciona input() , guarde y ejecute el siguiente script:

"
inmediato = "Oye, ¿qué pasa?
entrada_usuario = entrada (mensaje)
print("Dijiste :", entrada_usuario)

Cuando ejecutes este script, verás Oye, ¿qué pasa? se muestra en la ventana interactiva con
un cursor parpadeante.

El espacio único al final de la cadena "Oye, ¿qué pasa? Asegúrate de que " marcas

cuando el usuario comience a escribir, el texto se separe del mensaje con un espacio.
Cuando escribes una respuesta y presionas Enter , tu respuesta se asigna al variable de
entrada_usuario .

Aquí hay una ejecución de muestra del programa:

¿Hola! Qué tal? Métete en tus asuntos.

Dijiste: Métete en tus propios asuntos.

Una vez que tenga la información de un usuario, puede hacer algo con ella. Por ejemplo, el
siguiente script toma la entrada del usuario y la convierte a mayúsculas con .upper() e imprime
el resultado:

89
Machine Translated by Google

4.5. Desafío: seleccione las aportaciones de su usuario

respuesta = entrada("¿Qué debería gritar? ")

gritó_response = respuesta.upper()
print("Bueno, si insistes...", gritó_response)

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos

adicionales en línea en realpython.com/python­basics/resources.

1. Escriba un script que reciba información del usuario y muestre esa información.
volver.

2. Escriba un script que reciba información del usuario y la muestre.

en minúscula.

3. Escriba un script que reciba información del usuario y muestre el número de

caracteres ingresados.

Deje comentarios sobre esta sección »

4.5 Desafío: seleccione las aportaciones de su

usuario
Escriba un script llamado first_letter.py que primero solicite la entrada del usuario
mediante la cadena "Dime tu contraseña:". El script debe entonces determinar la
primera letra de la entrada del usuario, convertir esa letra a mayúscula y mostrarla
nuevamente. .

Por ejemplo, si la entrada del usuario es "no", entonces el programa debería

responder así:

La primera letra que ingresó fue: N

Por ahora, está bien si su programa falla cuando el usuario no ingresa nada como
entrada; es decir, simplemente presiona Enter en lugar de escribir algo.
En el próximo capítulo aprenderá un par de formas en las que puede afrontar esta
situación.

90
Machine Translated by Google

4.6. Trabajar con cadenas y números

Puede encontrar las soluciones a este desafío de código y muchos otros recursos
adicionales en línea en realpython.com/python­basics/resources.

Deje comentarios sobre esta sección »

4.6 Trabajar con cadenas y números

Cuando obtiene información del usuario utilizando la función input() , el resultado es
siempre una cadena. Hay muchas otras ocasiones en las que la entrada se proporciona
a un programa como una cadena. A veces, esas cadenas contienen números que
deben incluirse en los cálculos.

En esta sección aprenderá cómo manejar cadenas de números. Verá cómo funcionan
las operaciones aritméticas en cadenas y cómo a menudo conducen a resultados
sorprendentes. También aprenderá a convertir entre cadenas y tipos de números.

Cadenas y operadores aritméticos

Has visto que los objetos de cadena pueden contener muchos tipos de caracteres,
incluidos números. Sin embargo, no confunda los números de una cadena con los
números reales. Por ejemplo, pruebe este fragmento de código en la ventana
interactiva de IDLE:

>>> número = "2"

>>> número + número

'22'

El operador + concatena dos cadenas juntas. Entonces, el resultado de "2" + "2" es

"22", no "4".

Las cadenas se pueden "multiplicar" por un número siempre que ese número sea un
número entero o un número entero. Escriba lo siguiente en la ventana interactiva:

>>> número = "12"

>>> número *3

91
Machine Translated by Google

4.6. Trabajar con cadenas y números

'121212'

número * 3 concatena la cadena "12" consigo misma tres veces y devuelve

la cadena "121212". Para comparar esta operación con la aritmética con números,
observe que "12" * 3 = "12" + "12" + "12". En otras palabras, multiplicar una
cadena por un número entero n concatena esa cadena consigo misma n.
veces.

El número en el lado derecho de la expresión num * 3 puede ser

se movió hacia la izquierda y el resultado no cambia:

>>> 3 * número

'121212'

¿Qué crees que sucede si usas el operador * entre dos

¿instrumentos de cuerda? Escriba "12" * "3" en la ventana interactiva y presione Enter:

>>> "12" * "3"

Rastreo (llamadas recientes más última):

Archivo "<stdin>", línea 1, en <módulo>
TypeError: no se puede multiplicar la secuencia por no int de tipo 'str'

Python genera un TypeError y le dice que no puede multiplicar una secuencia por
un número no entero. Cuando el operador * se usa con una cadena
en el lado izquierdo o derecho, siempre espera un número entero en el
otro lado.

Nota
Una secuencia es cualquier objeto de Python que admita el acceso a
elementos por índice. Las cadenas son secuencias. aprenderás sobre
otros tipos de secuencia en el Capítulo 9.

¿Qué crees que sucede cuando intentas agregar una cadena y un número?

>>> "3" + 3

Rastreo (llamadas recientes más última):

92
Machine Translated by Google

4.6. Trabajar con cadenas y números

Archivo "<stdin>", línea 1, en <módulo>

TypeError: solo se puede concatenar str (no "int") con str

Nuevamente, Python arroja un TypeError porque el operador + espera que ambas

cosas a cada lado sean del mismo tipo. Si cualquiera de los objetos a cada lado
de + es una cadena, Python intenta realizar una concatenación de cadenas. La
suma solo se realizará si ambos objetos son números. Entonces, para sumar "3" +
3 y obtener 6, primero debes convertir la cadena "3" en un número.

Convertir cadenas en números

Los errores TypeError que vio en la sección anterior resaltan un problema común
que se encuentra al trabajar con la entrada del usuario: tipos incorrectos al intentar
usar la entrada en una operación que requiere un número y no una cadena.

Veamos un ejemplo. Guarde y ejecute el siguiente script.

num = input("Ingrese un número a duplicar: ")

núm_doblado = núm *2

imprimir(número_duplicado)

Cuando ingresa un número, como 2, espera que el resultado sea 4, pero en este
caso, obtiene 22. Recuerde, input() siempre devuelve una cadena, por lo que si
ingresa 2, a num se le asigna la cadena " 2", no el número entero 2.
Por lo tanto, la expresión num * 2 devuelve la cadena "2" concatenada consigo
misma, que es "22".

Para realizar aritmética con números contenidos en una cadena, primero debe
convertirlos de un tipo de cadena a un tipo de número. Hay dos formas de hacer
esto: int() y float().

int() significa entero y convierte objetos en números enteros, mientras que float()
significa número de coma flotante y convierte objetos en números con coma
decimal. Así es como se ve su uso en la ventana interactiva:

93
Machine Translated by Google

4.6. Trabajar con cadenas y números

>>> int("12")
12

>>> flotante("12")
12.0

Observe cómo float() agrega un punto decimal al número. Los números de coma
flotante siempre tienen al menos un decimal de precisión. Por esta razón, no puedes
cambiar una cadena que parece un número de punto flotante a un número entero
porque perderías todo después del punto decimal:

>>> int("12.0")

Rastreo (llamadas recientes más última):

Archivo "<stdin>", línea 1, en <módulo>

ValueError: literal no válido para int() con base 10: '12.0'

Aunque el 0 adicional después del lugar decimal no agrega ningún valor al número,
Python no cambiará 12.0 a 12 porque resultaría en una pérdida de precisión.

Revisemos el script del principio de esta sección y veamos cómo solucionarlo. Aquí
está el guión de nuevo:

num = input("Ingrese un número a duplicar: ")

núm_doblado = núm *2

imprimir(número_duplicado)

El problema radica en la línea doubled_num = num * 2 porque num hace referencia

a una cadena y 2 es un número entero. Puedes solucionar el problema ajustando
num con int() o float(). Dado que las indicaciones le piden al usuario que ingrese un
número, y no específicamente un número entero, conviertamos num a un número
de punto flotante:

num = input("Ingrese un número a duplicar: ")

núm_doblado = flotante(núm) * 2

imprimir(número_duplicado)

94
Machine Translated by Google

4.6. Trabajar con cadenas y números

Ahora, cuando ejecuta este script e ingresa 2, obtiene 4.0 como se esperaba. Intentar
¡fuera!

Convertir números en cadenas

A veces es necesario convertir un número en una cadena. tu podrías hacer
esto, por ejemplo, si necesita construir una cadena a partir de alguna cadena preexistente
variables que se asignan a valores numéricos.

Como ya has visto, lo siguiente produce un TypeError:

>>> numero_panqueques = 10
"
>>> "Voy a comer + num_pancakes + "panqueques."
Rastreo (llamadas recientes más última):
Archivo "<stdin>", línea 1, en <módulo>
TypeError: solo se puede concatenar str (no "int") con str

Como num_pancakes es un número, Python no puede concatenarlo con el

cadena "voy a comer". Para construir la cadena, necesitas convertir
num_pancakes a una cadena usando str():

>>> numero_panqueques = 10
"
>>> “Voy a comer 'Voy a + str(núm_panqueques) + " panqueques."
comer 10 panqueques'.

También puedes llamar a str() en un número literal:

"
>>> “Voy a comer 'Voy a + cadena(10) + " panqueques."
comer 10 panqueques'.

str() puede incluso manejar expresiones aritméticas:

>>> total_panqueques = 10
>>> panqueques_comidos = 5
>>> "Solo quedan " + str(total_pancakes ­ pancakes_eaten) + " panqueques."
"Sólo quedan 5 panqueques".

No estás limitado a números cuando usas str(). Puedes pasarlo todo

tipos de objetos para obtener sus representaciones de cadenas:

95
Machine Translated by Google

4.6. Trabajar con cadenas y números

>>> cadena(imprimir)

'<función incorporada de impresión>'

>>> cadena(int)
"<clase 'int'>"

>>> str(flotar)
"<clase 'flotante'>"

Estos ejemplos pueden no parecer muy útiles, pero ilustran cuán flexible es str() .

En la siguiente sección, aprenderá cómo formatear cadenas claramente para

mostrar los valores de una manera agradable y legible. Sin embargo, antes de
continuar, compruebe su comprensión con los siguientes ejercicios de repaso.

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos

adicionales en línea en realpython.com/python­basics/resources.

1. Cree una cadena que contenga un número entero, luego convierta esa cadena
en un objeto entero real usando int(). Pruebe que su nuevo objeto es un
número multiplicándolo por otro número y mostrando el resultado.

2. Repita el ejercicio anterior, pero use un número de punto flotante y

flotar().

3. Cree un objeto de cadena y un objeto entero, luego muéstrelos uno al lado del
otro con una única declaración de impresión usando la función str() .

4. Escriba un script que obtenga dos números del usuario usando la función input() dos
veces, multiplique los números y muestre el resultado. Si el usuario ingresa 2 y 4, su
programa debería imprimir el siguiente texto: El producto de 2 y 4 es 8,0.

Deje comentarios sobre esta sección »

96
Machine Translated by Google

4.7. Optimice sus estados de cuenta impresos

4.7 Optimice sus estados de cuenta impresos

Supongamos que tiene una cadena nombre = "Zaphod" y dos números enteros cabezas = 2
y brazos = 3. Quieres mostrarlos en la siguiente línea: Zaphod
Tiene 2 cabezas y 3 brazos. Esto se llama interpolación de cadenas, que es
sólo una forma elegante de decir que desea insertar algunas variables en
ubicaciones específicas en una cadena.

Ya has visto dos formas de hacer esto. El primero implica el uso

comas para insertar espacios entre cada parte de la cadena dentro de un
función imprimir() :

print(nombre, "tiene", str(cabezas), "cabezas y", str(brazos), "brazos")

Otra forma de hacer esto es concatenando las cadenas con la operación +.

actor:

imprimir(nombre + " tiene " + str(cabezas) + "cabezas y" + str(brazos) + " brazos")

Ambas técnicas producen código que puede resultar difícil de leer. tratando de mantener
Hacer un seguimiento de lo que está dentro o fuera de las comillas puede ser difícil.
Afortunadamente, existe una tercera forma de combinar cadenas: cadena formateada
literales, más comúnmente conocidas como cuerdas f.

La forma más sencilla de entender las cuerdas f es verlas en acción. Aquí está
cómo se ve la cadena anterior cuando se escribe como una cadena f:

>>> f"{nombre} tiene {cabezas} cabezas y {brazos} brazos"

'Zaphod tiene 2 cabezas y 3 brazos'

Hay dos cosas importantes a tener en cuenta sobre los ejemplos anteriores:

1. El literal de cadena comienza con la letra f antes de la cuota de apertura.

marca de ción

2. Se reemplazan los nombres de variables entre llaves ({ y })

con sus valores correspondientes sin usar str()

También puede insertar expresiones de Python entre las llaves.

Las expresiones se reemplazan con su resultado en la cadena:

97
Machine Translated by Google

4.7. Optimice sus estados de cuenta impresos

>>> norte = 3

>>> metro = 4

>>> f"{n} multiplicado por {m} es {n*m}"

'3 por 4 es 12'

Es una buena idea mantener las expresiones utilizadas en una cadena f lo más
simples posible. Empaquetar un montón de expresiones complicadas en una cadena
literal puede dar como resultado un código difícil de leer y de mantener.

Las cadenas f solo están disponibles en la versión 3.6 y superior de Python. En

versiones anteriores de Python, se puede utilizar el método .format() para obtener
los mismos resultados. Volviendo al ejemplo de Zaphod, puedes usar el
método .format() para formatear la cadena de esta manera:

>>> "{} tiene {} cabezas y {} brazos".format(nombre, cabezas, brazos)

'Zaphod tiene 2 cabezas y 3 brazos'

Las cadenas f son más cortas y, a veces, más legibles que usar .for­mat(). Verá
cuerdas f utilizadas a lo largo de este libro.

Para obtener una guía detallada sobre cadenas f y comparaciones con otras
técnicas de formato de cadenas, consulte f­Strings de Python 3: una sintaxis de
formato de cadenas mejorada (guía) en realpython.com

Nota

También hay otra forma de imprimir cadenas formateadas: usando el

operador % . Es posible que veas esto en el código que encontrarás en
otros lugares y puedes leer cómo funciona aquí. si tienes curiosidad.

Tenga en cuenta que este estilo se ha eliminado por completo en Python 3.

Solo tenga en cuenta que existe y es posible que lo vea en bases de código
Python heredadas.

98
Machine Translated by Google

4.8. Encuentra una cadena en una cadena

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos

adicionales en línea en realpython.com/python­basics/resources.

1. Cree un objeto flotante llamado peso con el valor 0.2 y cree un objeto de cadena
llamado animal con el valor "tritón". Luego use estos objetos para imprimir la
siguiente cadena usando solo concatenación de cadenas: 0,2 kg es el peso del
tritón.

2. Muestra la misma cadena usando el método .format() y vacía

{} marcadores de posición.

3. Muestre la misma cadena usando una cadena f.

Deje comentarios sobre esta sección »

4.8 Encuentra una cadena en una cadena

Uno de los métodos de cadena más útiles es .find(). Como su nombre lo indica,
puede utilizar este método para encontrar la ubicación de una cadena en otra
cadena, comúnmente denominada subcadena .

Para usar .find(), colóquelo al final de una variable o un literal de cadena y

pase la cadena que desea encontrar entre paréntesis:

>>> frase = "la sorpresa está aquí en alguna parte"

>>> frase.buscar("sorpresa")
4

El valor que devuelve .find() es el índice de la primera aparición de la cadena

que le pasa. En este caso, "sorpresa" comienza en el quinto carácter de la
cadena "la sorpresa está aquí en alguna parte" que tiene índice 4 porque el
conteo comienza en 0.

Si .find() no encuentra la subcadena deseada, devolverá ­1 en su lugar:

99
Machine Translated by Google

4.8. Encuentra una cadena en una cadena

>>> frase = "la sorpresa está aquí en alguna parte"

>>> frase.find("eyjafjallajökull")
­1

Puede llamar a métodos de cadena en un literal de cadena directamente, por lo que en

este caso, no necesita crear una nueva cadena:

>>> "la sorpresa está aquí en alguna parte".find("sorpresa")

4

Tenga en cuenta que esta comparación se realiza exactamente, carácter por carácter,
y distingue entre mayúsculas y minúsculas. Por ejemplo, si intentas encontrar
"SORPRESA", el método .find() devuelve ­1:

>>> "la sorpresa está aquí en alguna parte".find("SORPRESA")

­1

Si una subcadena aparece más de una vez en una cadena, .find() solo devuelve el
índice de la primera aparición, comenzando desde el principio de la cadena:

>>> "Puse una cadena en tu cadena".find("cadena")

8

Hay dos instancias de la "cadena" en "Puse una cadena en tu cadena". El primero

comienza en el índice 8 y el segundo en el índice 23. .find() devuelve 8, que es el
índice de la primera instancia de "cadena".

El método .find() solo acepta una cadena como entrada. Si desea encontrar un número
entero en una cadena, debe pasar el número entero a .find() como una cadena. Si pasa
algo que no sea una cadena a .find(), Python genera un TypeError:

>>> "Mi número es 555­555­5555".find(5)

Rastreo (llamadas recientes más última):
Archivo "<stdin>", línea 1, en <módulo>
TypeError: debe ser str, no int

100
Machine Translated by Google

4.8. Encuentra una cadena en una cadena

>>> "Mi número es 555­555­5555".find("5")

13

A veces es necesario encontrar todas las apariciones de una subcadena en

particular y reemplazarlas con una cadena diferente. Dado que .find() solo
devuelve el índice de la primera aparición de una subcadena, no puede usarlo
fácilmente para realizar esta operación. Afortunadamente, los objetos de cadena
tienen un método .replace() que reemplaza cada instancia de una subcadena con otra cadena.

Al igual que .find(), agrega .replace() al final de una variable o cadena literal. Sin
embargo, en este caso, debes colocar dos cadenas dentro de los paréntesis
en .replace() y separarlas con una coma. La primera cadena es la subcadena a
buscar y la segunda cadena es la cadena con la que reemplazar cada aparición
de la subcadena.

Por ejemplo, el siguiente código muestra cómo reemplazar cada aparición de "la
verdad" en la cadena "Te estoy diciendo la verdad; nada más que la verdad" con
la cadena "mentiras":

>>> my_story = "Te estoy diciendo la verdad; ¡nada más que la verdad!" >>> mi_historia.replace("la

verdad", "mentiras")

"Te estoy diciendo mentiras; ¡nada más que mentiras!"

Dado que las cadenas son objetos inmutables, .replace() no altera my_story.
Si escribe inmediatamente my_story en la ventana interactiva después de
ejecutar el ejemplo anterior, verá la cadena original, sin modificaciones:

>>> mi_historia

"Te estoy diciendo la verdad; ¡nada más que la verdad!"

Para cambiar el valor de my_story, debe reasignarle el nuevo valor devuelto

por .replace():

>>> mi_historia = mi_historia.replace("la verdad", "mentiras")

>>> mi_historia

"Te estoy diciendo mentiras; ¡nada más que mentiras!"

.replace() solo puede reemplazar una subcadena a la vez, por lo que si desea
reemplazar varias subcadenas en una cadena, debe usar .replace() mul­

101
Machine Translated by Google

4.9. Desafío: convierta a su usuario en un L33t H4x0r

tres veces:

>>> texto = "algunas de las cosas"

>>> nuevo_texto = texto.replace("algunos de", "todos") >>>

nuevo_texto = nuevo_texto.replace("cosas", "cosas")

>>> nuevo_texto

'todas las cosas'

Te divertirás un poco con .replace() en el desafío de la siguiente sección.

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos

adicionales en línea en realpython.com/python­basics/resources.

1. En una línea de código, muestre el resultado de intentar .find() la subcadena

"a" en la cadena "AAA". El resultado debería ser ­1.

2. Reemplace cada aparición del carácter "s" con "x" en la cadena.

"Alguien le dijo algo a Samantha".

3. Escriba y pruebe un script que acepte entradas del usuario utilizando la

función input() y muestre el resultado de intentar .find() una letra particular en
esa entrada.

Deje comentarios sobre esta sección »

4.9 Desafío: convierta a su usuario en un

L33t H4x0r
Escriba un script llamado Translate.py que solicite al usuario alguna entrada con
el siguiente mensaje: Ingrese un texto:. Luego use el método .replace() para
convertir el texto ingresado por el usuario en "leetspeak" realizando los siguientes
cambios en letras minúsculas:

• La letra a se convierte en 4

• La letra b se convierte en 8

102
Machine Translated by Google

4.10. Resumen y recursos adicionales

• La letra e se convierte en 3

• La letra l se convierte en 1

• La letra o se convierte en 0

• La letra s se convierte en 5

• La letra t se convierte en 7

Su programa debería entonces mostrar la cadena resultante como salida. A continuación se

muestra una ejecución de muestra del programa:

Ingrese un texto: Me gusta comer huevos y spam.

Yo 1ik3 70 347 3gg5 4º 5p4m.

Puede encontrar las soluciones a este desafío de código y muchos otros recursos adicionales
en línea en realpython.com/python­basics/resources.

Deje comentarios sobre esta sección »

4.10 Resumen y Adicional

Recursos
En este capítulo, aprendió los entresijos de los objetos de cadena de Python.
Aprendió cómo acceder a diferentes caracteres en una cadena usando subíndices y sectores,
así como también cómo determinar la longitud de una cadena con len().

Las cadenas vienen con numerosos métodos. Los métodos .upper() y .lower() convierten
todos los caracteres de una cadena a mayúsculas o minúsculas, respectivamente. Los
métodos .rstrip(), .lstrip() y strip() eliminan los espacios en blanco de las cadenas, y los
métodos .startswith() y .endswith() le dirán si una cadena comienza o termina con una
subcadena determinada.

También vio cómo capturar la entrada de un usuario como una cadena usando la función in­
put() y cómo convertir esa entrada en un número usando int() y float(). Para convertir números
y otros objetos en cadenas, debe
utilizar str().

103
Machine Translated by Google

4.10. Resumen y recursos adicionales

Finalmente, vio cómo se utilizan los métodos .find() y .replace() para encontrar la
ubicación de una subcadena y reemplazarla con una nueva cadena.

Prueba interactiva
Este capítulo viene con un cuestionario en línea gratuito para verificar su
progreso de aprendizaje. Puede acceder al cuestionario usando su teléfono o
computadora en la siguiente dirección web:

realpython.com/quizzes/python­basics­4

Recursos adicionales
Para obtener más información, consulte los siguientes recursos:

• Mejores prácticas de formato de cadenas de Python

• Dividir, concatenar y unir cadenas en Python

• Recursos recomendados en realpython.com

Deje comentarios sobre esta sección »

104
Machine Translated by Google

Capítulo 5

Números y Matemáticas

No es necesario ser un genio de las matemáticas para programar bien. La verdad es

que pocos programadores necesitan saber más que álgebra básica.

Por supuesto, la cantidad de matemáticas que necesita saber depende de la aplicación

en la que esté trabajando. En general, el nivel de matemáticas necesario para trabajar
con éxito como programador es menor de lo que cabría esperar.

Aunque las matemáticas y la programación informática no están tan correlacionadas

como algunas personas podrían creer, los números son una parte integral de cualquier
lenguaje de programación y Python no es una excepción.

En este capítulo, aprenderá cómo:

• Trabajar con los tres tipos de números integrados de Python: números enteros, de
punto flotante y complejos

• Redondear números a un número determinado de decimales

• Formatear y mostrar números en cadenas

¡Empecemos!

Deje comentarios sobre esta sección »

105
Machine Translated by Google

5.1. Enteros y números de coma flotante

5.1 Enteros y coma flotante

Números
Python tiene tres tipos de datos numéricos integrados: enteros, números de punto flotante
y números complejos. En esta sección, aprenderá sobre los números enteros y de punto
flotante, que son los dos tipos de números más utilizados. Aprenderá sobre números
complejos en la sección 5.6.

Enteros
Un número entero es un número entero sin decimales. Por ejemplo, 1 es un número
entero, pero 1,0 no lo es. El nombre del tipo de datos entero es int, que puedes ver con
la función type() :

>>> tipo(1)
<clase 'int'>

Puede crear un número entero simplemente escribiendo el número explícitamente o

usando la función int() . En el Capítulo 4, aprendiste cómo convertir una cadena que
contiene un número entero en un número usando int(). Por ejemplo, lo siguiente convierte
la cadena "25" al número entero 25:

>>> int("25")
25

Un literal entero es un valor entero que está escrito explícitamente en su código, al igual
que un literal de cadena es una cadena que está escrita explícitamente en su código. Por
ejemplo, 1 es un literal entero, pero int("1") no lo es.

Los literales enteros se pueden escribir de dos maneras diferentes:

>>> 1000000

1000000

>>> 1_000_000

1000000

106
Machine Translated by Google

5.1. Enteros y números de coma flotante

El primer ejemplo es sencillo. Simplemente escriba un 1 seguido de seis ceros. La

desventaja de esta notación es que los números grandes pueden resultar difíciles de
leer.

Cuando escribes números grandes a mano, probablemente agrupas los dígitos en

grupos de tres, separados por una coma. 1.000.000 es mucho más fácil de leer que
1.000.000.

En Python, no puedes usar comas para agrupar dígitos en literales enteros, pero puedes
usar un guión bajo (_). El valor 1_000_000 expresa un millón de una manera más legible.

No hay límite en cuanto al tamaño que puede tener un número entero, lo que podría
resultar sorprendente teniendo en cuenta que las computadoras tienen una memoria
finita. Intente escribir el número más grande que se le ocurra en la ventana interactiva de IDLE.
¡Python puede manejarlo sin problemas!

Números de punto flotante

Un número de coma flotante, o avena para abreviar, es un número con un decimal. 1,0
es un número de punto flotante, al igual que ­2,75. El nombre de un tipo de datos de
punto flotante es float:

>>> tipo(1.0)
<clase 'flotante'>

Los flotantes se pueden crear escribiendo un número directamente en su código o

usando la función float() . Al igual que int(), float() se puede utilizar para convertir una
cadena que contiene un número en un número de punto flotante:

>>> flotante("1.25")
1.25

Un literal de punto flotante es un valor de punto flotante que está escrito explícitamente
en su código. 1.25 es un literal de punto flotante, mientras que float("1.25") no lo es.

Los literales de punto flotante se pueden crear de tres formas diferentes. Cada uno de
los siguientes crea un literal de punto flotante con un valor de un milímetro.

107
Machine Translated by Google

5.1. Enteros y números de coma flotante

león:

>>> 1000000.0

1000000.0

>>> 1_000_000.0

1000000.0

>>> 1e6

1000000.0

Las dos primeras formas son similares a los dos métodos para crear literales
enteros que vio anteriormente. El segundo método, que utiliza guiones bajos
para separar dígitos en grupos de tres, es útil para crear literales flotantes con
muchos dígitos.

Para números realmente grandes, puedes utilizar la notación E. El tercer método

del ejemplo anterior utiliza la notación E para crear un literal flotante.

Para escribir un literal flotante en notación E, escriba un número seguido de la

letra e y luego otro número. Python toma el número a la izquierda de la e y lo
multiplica por 10 elevado a la potencia del número después de la e. Entonces 1e6
es equivalente a 1×10 .

Nota
La notación electrónica es la abreviatura de notación exponencial y es el
nombre más común para muchas calculadoras y lenguajes de
programación que muestran números grandes.

Python también usa notación E para mostrar números grandes de punto flotante:

>>> 200000000000000000.0

2e+17

El flotante 200000000000000000.0 se muestra como 2e+17. El signo + indica

que el exponente 17 es un número positivo. También puedes usar números
negativos como exponente:

108
Machine Translated by Google

5.1. Enteros y números de coma flotante

>>> 1e­4
0.0001

El literal 1e­4 se interpreta como 10 elevado a la potencia ­4, que es 1/10000 o,

equivalentemente, 0,0001.

A diferencia de los números enteros, los flotantes tienen un tamaño máximo. El

número máximo de punto flotante depende de su sistema, pero algo como 2e400
debería estar mucho más allá de las capacidades de la mayoría de las máquinas.
2e400 es 2×10 , ¡que es mucho más que el número total de átomos en el
universo!

Cuando alcanza el número máximo de punto flotante, Python devuelve un valor

flotante especial inf:

>>> 2e400
inf

inf significa infinito y simplemente significa que el número que intentaste crear supera
el valor máximo de punto flotante permitido en tu computadora. El tipo de inf sigue
siendo flotante:

>>> norte = 2e400

>>> norte

inf
>>> tipo(n)
<clase 'flotante'>

También está ­inf que significa infinito negativo y representa un número de punto
flotante negativo que está más allá del número mínimo de punto flotante permitido
en su computadora:

>>> ­2e400
­inf

Probablemente no te encontrarás con inf e ­inf a menudo como programador, a

menos que trabajes regularmente con números extremadamente grandes.

109
Machine Translated by Google

5.2. Operadores y expresiones aritméticos

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos

adicionales en línea en realpython.com/python­basics/resources.

1. Escriba un script que cree las dos variables, num1 y num2. Tanto a num1 como
a num2 se les debe asignar el literal entero 25.000.000, uno escrito con
subrayado y el otro sin subrayado. Imprima num1 y num2 en dos líneas
separadas.

2. Escriba un script que asigne el literal de punto flotante 175000.0 a la variable

num usando notación exponencial y luego imprima num en la ventana
interactiva.

3. En la ventana interactiva de IDLE, intente encontrar el exponente N más

pequeño para que 2e<N>, donde <N> se reemplaza con su número, devuelva inf.

Deje comentarios sobre esta sección »

5.2 Operadores y expresiones

aritméticos
En esta sección, aprenderá cómo hacer aritmética básica con números en Python,
como suma, resta, multiplicación y división.
A lo largo del camino, aprenderá algunas convenciones para escribir expresiones
matemáticas en código.

Suma

La suma se realiza con el operador + :

>>> 1 + 2

Los dos números a cada lado del operador + se llaman operandos.

En el ejemplo anterior, ambos operandos son números enteros, pero no es
necesario que sean del mismo tipo. Puedes agregar un int a un float sin ningún
problema:

110
Machine Translated by Google

5.2. Operadores y expresiones aritméticos

>>> 1.0 + 2
3.0

Observe que el resultado de 1,0 + 2 es 3,0, que es flotante. Cada vez que se agrega un
flotante a un número, el resultado es otro flotante. Sumar dos números enteros siempre
da como resultado un int.

Nota
PEP 8 recomienda separando ambos operandos de un operador con un espacio.

Python puede evaluar 1+1 muy bien, pero 1 + 1 es el formato preferido porque
generalmente se considera más fácil de leer. Esta regla general se aplica a todos
los operadores de esta sección.

Sustracción
Para restar dos números, simplemente coloca un ­ entre ellos:

>>> 1 ­ 1
0

>>> 5.0 ­ 3
2.0

Al igual que sumar dos números enteros, restar dos números enteros siempre da como
resultado un int. Siempre que uno de los operandos es flotante, el resultado también es un
flotar.

El operador ­ también se utiliza para indicar números negativos:

>>> ­3
­3

Puedes restar un número negativo de otro número, pero como puedes ver a continuación,
esto a veces puede parecer confuso:

111
Machine Translated by Google

5.2. Operadores y expresiones aritméticos

>>> 1 ­ ­3
4

>>> 1 ­­3
4

>>> 1­ ­3
4

>>>1­­3
4

De los cuatro ejemplos anteriores, el primero es el que más cumple con PEP 8.
Dicho esto, puedes rodear ­3 entre paréntesis para que quede aún más claro
que el segundo ­ está modificando 3:

>>> 1 ­ (­3)
4

Usar paréntesis es una buena idea porque hace que el código sea más explícito.
Las computadoras ejecutan código, pero los humanos leen el código. Todo lo
que pueda hacer para que su código sea más fácil de leer y comprender es algo
bueno.

Multiplicación
Para multiplicar dos números, use el operador * :

>>> 3 * 3
9

>>> 2 * 8.0
16.0

El tipo de número que se obtiene al multiplicar sigue las mismas reglas que la
suma y la resta. Multiplicar dos números enteros da como resultado un int y
multiplicar un número con un flotante da como resultado un flotante.

112
Machine Translated by Google

5.2. Operadores y expresiones aritméticos

División
El operador / se utiliza para dividir dos números:

>>> 9/3
3.0

>>> 5.0 / 2
2.5

A diferencia de la suma, la resta y la multiplicación, la división con el operador /

siempre devuelve un valor flotante. Si desea asegurarse de obtener un número
entero después de dividir dos números, puede usar int() para convertir el resultado:

>>> int( 9/3 )

3

Tenga en cuenta que int() descarta cualquier parte fraccionaria del número:

>>> int(5.0 / 2)
2

5.0/2 devuelve el valor flotante 2.5 e int(2.5) devuelve el número entero 2 sin la
parte .5 .

División entera
Si escribir int(5.0 / 2) le parece un poco largo, Python proporciona un segundo
operador de división, //, llamado operación de división de enteros.
erador:

>>> 9 // 3
3

>>> 5.0 // 2
2.0

113
Machine Translated by Google

5.2. Operadores y expresiones aritméticos

>>> ­3 // 2
­2

El operador // primero divide el número de la izquierda por el número de la derecha

y luego redondea hacia abajo a un número entero. Es posible que esto no
proporcione el valor esperado cuando uno de los números es negativo.

Por ejemplo, ­3 // 2 devuelve ­2. Primero, ­3 se divide por 2 para obtener ­1,5.
Luego ­1,5 se redondea hacia abajo a ­2. Por otro lado, 3 // 2 devuelve 1

Otra cosa que ilustra el ejemplo anterior es que // devuelve un número de punto
flotante si uno de los operandos es flotante. Es por eso que 9 // 3 devuelve el
número entero 3 y 5.0 // 2 devuelve el flotante 2.0.

Veamos qué sucede cuando intentas dividir un número entre 0:

>>> 1/0
Rastreo (llamadas recientes más última):
Archivo "<stdin>", línea 1, en <módulo>
ZeroDivisionError: división por cero

Python te da un ZeroDivisionError, haciéndote saber que acabas de intentar

romper una regla fundamental del universo.

Exponentes
Puedes elevar un número a una potencia usando el operador ** :

>>> 2 ** 2
4

>>> 2 ** 3
8

>>> 2 ** 4
dieciséis

Los exponentes no tienen por qué ser números enteros. También pueden ser flotadores:

114
Machine Translated by Google

5.2. Operadores y expresiones aritméticos

>>> 3 ** 1,5

5.196152422706632

>>> 9 ** 0,5

3.0

Elevar un número a la potencia de 0,5 es lo mismo que sacar la raíz cuadrada,

pero observe que aunque la raíz cuadrada de 9 es un número entero, Python
devuelve el valor flotante 3,0.

Para operandos positivos, el operador ** devuelve un número entero si ambos

operandos son números enteros y un valor flotante si alguno de los operandos
es un número de punto flotante.

También puedes elevar números a potencias negativas:

>>> 2 ** ­1

0,5

>>> 2 ** ­2

0,25

Elevar un número a la potencia negativa es lo mismo que dividir 1 por el número

elevado a la potencia positiva. Entonces, 2**­1 es lo mismo que 1/(2**1), que es
lo mismo que 1/2 , o 0,5. De manera similar, 2**­2 es lo mismo que 1/(2**2), que
es lo mismo que 1/4 , o 0,25.

El operador de módulo
El operador % , o módulo, devuelve el resto de dividir el operando izquierdo por
el operando derecho:

>>> 5 % 3

>>> 20 % 7

115
Machine Translated by Google

5.2. Operadores y expresiones aritméticos

>>> 16 % 8
0

3 divide 5 una vez con un resto de 2, por lo que el 5 % de 3 es 2. De manera similar, 7

divide 20 dos veces con un resto de 6.

En el último ejemplo, 16 es divisible por 8, por lo que 16 % 8 es 0. Cada vez que el

número a la izquierda de % es divisible por el número de la derecha, el resultado es 0.

Uno de los usos más comunes del % es determinar si un número es divisible por otro.
Por ejemplo, un número n es par si y sólo si n % 2 es 0.

¿Qué crees que rinde el 1% 0 ? Probémoslo:

>>> 1 % 0

Rastreo (llamadas recientes más última):

Archivo "<stdin>", línea 1, en <módulo>
ZeroDivisionError: división entera o módulo por cero

Esto tiene sentido porque 1 % 0 es el resto de dividir 1 entre 0. Pero no se puede dividir
1 entre 0, por lo que Python genera un ZeroDivisionError.

Nota

Cuando trabaja en la ventana interactiva de IDLE, errores como Zero­

DivisionError no causan muchos problemas. Se muestra el error y aparece un
nuevo mensaje que le permite continuar escribiendo código.

Sin embargo, cada vez que Python encuentra un error al ejecutar un script, la
ejecución se detiene. Se dice que el programa falló .
En el Capítulo 8, aprenderá cómo manejar los errores para que sus programas
no colapsen inesperadamente.

Las cosas se ponen un poco complicadas cuando usas el operador % con números
negativos:

116
Machine Translated by Google

5.2. Operadores y expresiones aritméticos

>>> 5 % ­3
­1

>>> ­5 % 3
1

>>> ­5 % ­3
­2

Estos resultados potencialmente impactantes están bastante bien definidos. Para calcular
el resto r de dividir un número x por un número y, Python usa la ecuación r = x ­ (y * (x //
y)).

Por ejemplo, para encontrar el 5 % ­3, primero busque (5 // ­3). Dado que 5/­3 es
aproximadamente ­1,67, 5 // ­3 es ­2. Ahora multiplica eso por ­3 para obtener 6.
Finalmente, resta 6 de 5 para obtener ­1.

Expresiones aritméticas
Puede combinar operadores para formar expresiones complejas. Una expresión es una
combinación de números, operadores y paréntesis que Python puede calcular o evaluar
para devolver un valor.

A continuación se muestran algunos ejemplos de expresiones aritméticas:

>>> 2*3 ­ 1
5

>>> 4/2 + 2**3

10.0

>>> ­1 + (­3*2 + 4)
­3

Las reglas para evaluar el trabajo de expresiones son las mismas que en la aritmética
cotidiana. En la escuela, probablemente aprendiste estas reglas bajo el nombre de "orden
de operaciones".

117
Machine Translated by Google

5.3. Desafío: realizar cálculos según la entrada del usuario

Los operadores *, /, // y % tienen la misma precedencia o prioridad en una

expresión, y cada uno de ellos tiene una precedencia mayor que los operadores
+ y ­ . Esta es la razón por la que 2*3 ­ 1 devuelve 5 y no 4. 2*3 se evalúa primero,
porque * tiene mayor prioridad que el operador ­ .

Quizás observes que las expresiones del ejemplo anterior no siguen la regla de
poner un espacio a cada lado de todos los operadores.
PEP 8 dice lo siguiente sobre los espacios en blanco en expresiones complejas:

“Si se utilizan operadores con diferentes prioridades, considere

agregar espacios en blanco alrededor de los operadores con
menor prioridad. Utilice su propio criterio; sin embargo, nunca use
más de un espacio y siempre tenga la misma cantidad de espacios
en blanco en ambos lados de un operador binario”.

— PEP 8, Otras recomendaciones

Deje comentarios sobre esta sección »

5.3 Desafío: realizar cálculos según la entrada

del usuario
Escriba un script llamado exponent.py que reciba dos números del usuario y
muestre el primer número elevado a la potencia del segundo número.

Una ejecución de muestra del programa debería verse así (con la entrada de
ejemplo proporcionada por el usuario incluida a continuación):

Introduzca una base: 1,2

Introduzca un exponente: 3

1,2 elevado a 3 = 1,7279999999999998

Tenga en cuenta lo siguiente:

118
Machine Translated by Google

5.4. Haz que Python te mienta

1. Antes de poder hacer algo con la entrada del usuario, tendrás que
asigne ambas llamadas a input() a nuevas variables.

2. La función input() devuelve una cadena, por lo que necesitarás convertir la entrada
del usuario en números para poder hacer aritmética.

3. Puede utilizar una cadena f para imprimir el resultado.

4. Puede asumir que el usuario ingresará números reales como entrada.

Puede encontrar las soluciones a este desafío de código y muchos otros recursos
adicionales en línea en realpython.com/python­basics/resources.

Deje comentarios sobre esta sección »

5.4 Haz que Python te mienta

¿Qué crees que es 0,1 + 0,2 ? La respuesta es 0,3, ¿verdad? Veamos qué tiene que
decir Python al respecto. Pruebe esto en la ventana interactiva:

>>> 0,1 + 0,2

0.30000000000000004

Bueno, eso es… ¡casi correcto! ¿Qué diablos está pasando aquí? ¿Es esto un error
en Python?

¡No, no es un error! Es un error de representación de punto flotante y no tiene nada

que ver con Python. Está relacionado con la forma en que se almacenan los números
de punto flotante en la memoria de una computadora.

El número 0,1 se puede representar como la fracción 1/10. Tanto el número 0,1 como
su fracción 1/10 son representaciones decimales o representaciones en base 10. Las
computadoras, sin embargo, almacenan números de punto flotante en representación
de base 2, más comúnmente llamada representación binaria.

Cuando se representa en binario, algo familiar pero posiblemente inesperado le

sucede al número decimal 0,1. La fracción 1/3 no tiene representación decimal finita.
Es decir, 1/3 = 0,3333... con infinitos 3 después del punto decimal. Lo mismo le sucede
a la fractura.

119
Machine Translated by Google

5.4. Haz que Python te mienta

ción 1/10 en binario.

La representación binaria de 1/10 es la siguiente fracción que se repite infinitamente:

0.00011001100110011001100110011...

Las computadoras tienen memoria finita, por lo que el número 0,1 debe
almacenarse como una aproximación y no como su valor verdadero. La
aproximación que se almacena es ligeramente mayor que el valor real y tiene este aspecto:

0.10000000000000000055511151231257827021181583404541015625

Sin embargo, habrás notado que cuando se le pide que imprima 0.1, Python
imprime 0.1 y no el valor aproximado anterior:

>>> 0.1
0.1

Python no simplemente corta los dígitos en la representación binaria de 0.1. Lo

que realmente sucede es un poco más sutil.

Debido a que la aproximación de 0,1 en binario es solo eso (una aproximación),

es muy posible que más de un número decimal tenga la misma aproximación
binaria.

Por ejemplo, los números 0,1 y 0,10000000000000001 tienen la misma

aproximación binaria. Python imprime el número decimal más corto que comparte
la aproximación.

Esto explica por qué, en el primer ejemplo de esta sección, 0,1 + 0,2 no es igual a
0,3. Python suma las aproximaciones binarias para 0,1 y 0,2, lo que da un número
que no es la aproximación binaria para 0,3.

Si todo esto te empieza a dar vueltas la cabeza, ¡no te preocupes! A menos que
esté escribiendo programas para finanzas o informática científica, no necesita
preocuparse por la imprecisión de la aritmética de punto flotante.

Deje comentarios sobre esta sección »

120
Machine Translated by Google

5.5. Funciones matemáticas y métodos numéricos

5.5 Funciones matemáticas y números

Métodos
Python tiene algunas funciones integradas que puedes usar para trabajar con números.
En esta sección, conocerá tres de los más comunes:

1. round(), para redondear números a cierto número de decimales

2. abs(), para obtener el valor absoluto de un número

3. pow(), para elevar un número a alguna potencia

También aprenderá sobre un método que tienen los números de punto flotante para
verificar si tienen o no un valor entero.

¡Vamos!

La función redonda()
Puedes usar round() para redondear un número al entero más cercano:

>>> ronda(2.3)
2

>>> ronda(2.7)
3

round() tiene un comportamiento inesperado cuando el número termina en .5:

>>> ronda(2.5)
2

>>> ronda(3.5)
4

2,5 se redondea hacia abajo a 2 y 3,5 se redondea hacia arriba a 4. La mayoría de la gente
espera que un número que termina en 0,5 se redondee hacia arriba, así que echemos un vistazo
más de cerca a lo que está sucediendo aquí.

Python 3 redondea números según una estrategia llamada redondeo

121
Machine Translated by Google

5.5. Funciones matemáticas y métodos numéricos

lazos para igualar. Un empate es cualquier número cuyo último dígito es un cinco. 2,5 y
3,1415 están empatados, pero 1,37 no.

Cuando redondeas empates a pares, primero miras el dígito un decimal a la izquierda del
último dígito del empate. Si ese dígito es par, se redondea hacia abajo. Si el dígito es
impar, se redondea. Es por eso que 2,5 se redondea a 2 y 3,5 se redondea a 4.

Nota

Redondear empates a pares es la estrategia de redondeo recomendada para

números de punto flotante por el IEEE (Instituto de Ingenieros Eléctricos y
Electrónicos) porque ayuda a limitar el impacto que tiene el redondeo en
operaciones que involucran muchos números.

El IEEE mantiene un estándar llamado IEEE 754 sobre cómo se tratan los
números de punto flotante en una computadora. Se publicó en 1985 y los
fabricantes de hardware todavía lo utilizan habitualmente en la actualidad.

Puedes redondear un número a un número determinado de decimales pasando un

segundo argumento a round():

>>> ronda(3.14159, 3)
3.142

>>> ronda(2.71828, 2)
2.72

El número 3,14159 se redondea a 3 decimales para obtener 3,142, y el número 2,71828

se redondea a 2 decimales para obtener 2,72.

El segundo argumento de round() debe ser un número entero. Si no es así, Python

genera un TypeError:

>>> ronda(2.65, 1.4)

Rastreo (llamadas recientes más última):
Archivo "<pyshell#0>", línea 1, en <módulo>

122
Machine Translated by Google

5.5. Funciones matemáticas y métodos numéricos

redondo(2,65, 1,4)
TypeError: el objeto 'flotante' no se puede interpretar como un número entero

A veces, round() no obtiene la respuesta del todo bien:

>>> # Valor esperado: 2,68

>>> ronda(2.675, 2)
2.67

2,675 es un empate porque se encuentra exactamente a medio camino entre los

números 2,67 y 2,68. Dado que Python redondea los vínculos al número par más
cercano, se esperaría que round(2.675, 2) devuelva 2,68, pero en su lugar devuelve 2,67 .
Este error es el resultado de un error de representación de punto flotante y no es un
error en la función round() .

Tratar con números de punto flotante puede resultar frustrante, pero esta frustración
no es específica de Python. Todos los lenguajes que implementan el estándar de punto
flotante IEEE tienen los mismos problemas, incluidos C/C++, Java y JavaScript.

Sin embargo, en la mayoría de los casos, los pequeños errores encontrados con los
números de punto flotante son insignificantes y los resultados de round() son
perfectamente útiles.

La función abs()

El valor absoluto de un número n es simplemente n si n es positivo y ­n si n es negativo.

Por ejemplo, el valor absoluto de 3 es 3, mientras que el valor absoluto de ­5 es 5.

Para obtener el valor absoluto de un número en Python, usas la función abs() :

>>> abs(3)
3

>>> abs(­5.0)
5.0

123
Machine Translated by Google

5.5. Funciones matemáticas y métodos numéricos

abs() siempre devuelve un número positivo del mismo tipo que su argumento. Es
decir, el valor absoluto de un número entero es siempre un número entero positivo
y el valor absoluto de un flotante es siempre un flotante positivo.

La función pow()

En la sección 5.2, aprendiste cómo elevar un número a una potencia usando el

operador ** . También puedes usar la función pow() . pow() toma dos argumentos.
El primero es la base, es decir el número a elevar a una potencia, y el segundo
argumento es el exponente.

Por ejemplo, lo siguiente usa pow() para elevar 2 al exponente 3:

>>> poder(2, 3)
8

Al igual que **, el exponente en pow() puede ser negativo:

>>> poder(2, ­2)

0,25

Entonces, ¿cuál es la diferencia entre ** y pow()? La función pow() acepta un

tercer argumento opcional que calcula el primer número elevado a la potencia del
segundo número y luego toma el módulo con respecto al tercer número.

En otras palabras, pow(x, y, z) es equivalente a (x ** y) % z. Aquí hay un ejemplo

con x = 2, y = 3 y z = 2:

>>> poder(2, 3, 2)
0

Primero, se eleva 2 a la potencia 3 para obtener 8. Luego se calcula el 8 % de 2 ,

que es 0 porque 2 divide 8 sin resto.

Compruebe si un flotador es integral

En el Capítulo 3 aprendiste sobre métodos de cadena como .lower(), .upper()

y .find(). Los números enteros y de punto flotante también tienen métodos.

124
Machine Translated by Google

5.5. Funciones matemáticas y métodos numéricos

Los métodos numéricos no se utilizan con mucha frecuencia, pero hay uno que
puede resultar útil. Los números de punto flotante tienen un método .is_integer()
que devuelve True si el número es entero (lo que significa que no tiene parte
fraccionaria) y devuelve False en caso contrario:

>>> número = 2.5

>>> num.is_integer()
FALSO

>>> número = 2.0

>>> num.is_integer()
Verdadero

El método .is_integer() puede resultar útil para validar la entrada del usuario. Por
ejemplo, si está escribiendo una aplicación para un carrito de compras para una
tienda que vende pizzas, querrá verificar que la cantidad de pizzas que ingresa el
cliente sea un número entero. Aprenderá cómo realizar este tipo de comprobaciones
en el Capítulo 8.

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos

adicionales en línea en realpython.com/python­basics/resources.

1. Escriba un script que solicite al usuario que ingrese un número y luego muestre
ese número redondeado a dos decimales. Cuando se ejecute, su programa
debería verse así:
Introduzca un número: 5.432

5,432 redondeado a 2 decimales es 5,43

2. Escriba un script que solicite al usuario que ingrese un número y luego muestre
el valor absoluto de ese número. Cuando se ejecute, su programa debería
verse así:
Introduce un número: ­10

El valor absoluto de ­10 es 10,0

3. Escriba un script que le pida al usuario que ingrese dos números usando la
función input() dos veces y luego muestre si la diferencia entre esos dos
números es un número entero o no. Cuando se ejecuta, su programa

125
Machine Translated by Google

5.6. Imprimir números con estilo

debería verse así:

Introduzca un número: 1,5

Introduzca otro número: .5

¿La diferencia entre 1,5 y 0,5 es un número entero? ¡Verdadero!

Si el usuario ingresa dos números cuya diferencia no es entera, el resultado

debería verse así:
Introduzca un número: 1,5

Introduce otro número: 1.0

¿La diferencia entre 1,5 y 1,0 es un número entero? ¡FALSO!

Deje comentarios sobre esta sección »

5.6 Imprimir números con estilo

Mostrar números a un usuario requiere insertar números en una cadena.
En el Capítulo 3, aprendiste cómo hacer esto con cadenas f rodeando una variable
asignada a un número con llaves:

>>> norte = 7,125

>>> f"El valor de n es {n}"

'El valor de n es 7,125'

Esas llaves admiten un lenguaje de formato simple puede utilizar para alterar la
apariencia del valor en la cadena formateada final.

Por ejemplo, para formatear el valor de n en el ejemplo anterior con dos decimales,
reemplace el contenido de las llaves en la cadena f con {n:.2f}:

>>> norte = 7,125

>>> f"El valor de n es {n:.2f}"

'El valor de n es 7,12'

Los dos puntos (:) después de la variable n indican que todo lo que sigue es parte
de la especificación de formato. En este ejemplo, la especificación de formato es
.2f.

El .2 en .2f redondea el número a dos decimales y la f indica

126
Machine Translated by Google

5.6. Imprimir números con estilo

Python para mostrar n como un número de punto fijo. Esto significa que el número
se muestra exactamente con dos decimales, incluso si el número original tiene
menos decimales.

Cuando n = 7,125, el resultado de {n:.2f} es 7,12. Al igual que round(), Python

redondea los vínculos incluso cuando formatea números dentro de cadenas.
Entonces, si reemplazas n = 7,125 con n = 7,126, entonces el resultado de {n:.2f} es "7,13":

>>> norte = 7.126

>>> f"El valor de n es {n:.2f}"

'El valor de n es 7,13'

Para redondear a un decimal, reemplace .2 con .1:

>>> norte = 7.126

>>> f"El valor de n es {n:.1f}"

'El valor de n es 7,1'

Cuando formatea un número como punto fijo, siempre se muestra con el número
preciso de decimales especificado:

>>> norte = 1

>>> f"El valor de n es {n:.2f}"

'El valor de n es 1,00'

>>> f"El valor de n es {n:.3f}"

'El valor de n es 1.000'

Puedes insertar comas para agrupar la parte entera de números grandes por miles
con la opción :

>>> n = 1234567890

>>> f"El valor de n es {n:,}"

'El valor de n es 1.234.567.890'

Para redondear a algún número de decimales y también agrupar por miles,

, punto . en su especificación de formato:
coloque el antes del

127
Machine Translated by Google

5.6. Imprimir números con estilo

>>> norte = 1234,56

>>> f"El valor de n es {n:,.2f}"

'El valor de n es 1.234,56'

El especificador ,.2f es útil para mostrar valores de moneda:

>>> saldo = 2000.0

>>> gastado = 256,35

>>> restante = saldo ­ gastado

>>> f"Después de gastar ${gastado:.2f}, me quedé con ${restante:,.2f}"

'Después de gastar $256,35, me quedaron $1.743,65'

Otra opción útil es %, que se utiliza para mostrar porcentajes. La opción %

multiplica un número por 100 y lo muestra en formato de punto fijo, seguido de un
signo de porcentaje.

La opción % siempre debe ir al final de la especificación de formato y no puede

combinarla con la opción f . Por ejemplo, 0,1% muestra un número como porcentaje
con exactamente un decimal:

>>> relación = 0,9

>>> f"Más de {proporción:.1%} de Pythonistas dicen '¡Las verdaderas Python son geniales!'"

"Más del 90,0 % de los pitonistas dicen '¡La auténtica Python es genial!'"

>>> # Mostrar porcentaje con 2 decimales

>>> f"Más de {proporción:.2%} de Pythonistas dicen '¡Real Python es genial!'"

"Más del 90,00% de los pitonistas dicen '¡Las verdaderas Python son geniales!'"

El minilenguaje de formato es potente y extenso. Aquí sólo has visto lo básico.

Para obtener más información, le recomendamos leer la documentación oficial.

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos adicionales en línea en

realpython.com/python­basics/resources.

128
Machine Translated by Google

5.7. Números complejos

1. Imprima el resultado del cálculo 3 ** .125 como un número de punto fijo

con tres decimales.

2. Imprime el número 150000 como moneda, con los miles agrupados con comas. La
moneda debe mostrarse con dos decimales.

3. Imprima el resultado de 2/10 como porcentaje sin decimales.

La producción debería parecer del 20%.

Deje comentarios sobre esta sección »

5.7 Números complejos

Python es uno de los pocos lenguajes de programación que proporciona soporte
integrado para números complejos. Si bien los números complejos no surgen con
frecuencia fuera de los dominios de la computación científica y los gráficos por
computadora, el soporte de Python para ellos es uno de sus puntos fuertes.

Nota
Los números complejos sólo surgen en algunas situaciones específicas.
Muchos programadores nunca necesitan usarlos.

Siéntase libre de omitir esta sección por completo si no tiene interés en cómo
trabajar con números complejos en Python. Ninguna otra parte del libro
depende de la información de esta sección.

Si alguna vez ha tomado una clase de matemáticas de precálculo o álgebra de nivel

superior, quizás recuerde que un número complejo es un número con dos componentes
distintos: un componente real y un componente imaginario .

Hay varias formas de denotar números complejos, pero un método común es indicar
el componente real con la letra i y el componente imaginario con la letra j. Por ejemplo,
1i + 2j es el número complejo con parte real 1 y parte imaginaria 2.

Para crear un número complejo en Python, simplemente escribe la parte real, seguida
de un signo más y la parte imaginaria con la letra j en el

129
Machine Translated by Google

5.7. Números complejos

fin:

>>> norte = 1 + 2j

Cuando inspeccionas el valor de n, notarás que Python envuelve el número

entre paréntesis:

>>> norte

(1+2j)

Esta convención ayuda a eliminar cualquier confusión de que el resultado

mostrado pueda representar una cadena o una expresión matemática.

Los números imaginarios vienen con dos propiedades, .real y .imag, que
devuelven el componente real e imaginario del número, respectivamente:

>>> n.real
1.0

>>> n.imag
2.0

Observe que Python devuelve los componentes real e imaginario como

flotantes, aunque se hayan especificado como números enteros.

Los números complejos también tienen un método .conjugate() que devuelve

el conjugado complejo del número:

>>> n.conjugar()
(1­2j)

Para cualquier número complejo, su conjugado es el número complejo que

tiene la misma parte real y una parte imaginaria que es igual en valor absoluto
pero con signo opuesto. Entonces, en este caso, la conjugación compleja de 1
+ 2j es 1 ­ 2j.

130
Machine Translated by Google

5.7. Números complejos

Nota

Las propiedades .real y .imag no necesitan paréntesis después como lo

hace el método .conjugate() .

El método .conjugate() es una función que realiza una acción sobre el

número complejo. .real y .imag no realizan ninguna acción, solo devuelven
información sobre el número.

La distinción entre métodos y propiedades es parte de la programación

orientada a objetos, que aprenderá en el Capítulo 10.

Todos los operadores aritméticos que trabajan con números flotantes y enteros
también funcionan con números complejos, excepto el operador de división de piso (//) .
Como éste no es un libro de matemáticas, no analizaremos la mecánica de la
aritmética compleja. En cambio, aquí hay algunos ejemplos del uso de números
complejos con operadores aritméticos:

>>> a = 1 + 2j
>>> b = 3 ­ 4j

>>> a + b
(4­2j)

>>> a ­ b
(­2+6j)

>>> un * b

(11+2j)

>>> un ** b

(932.1391946432212+95.9465336603419j)

>>> a / b
(­0,2+0,4j)

131
Machine Translated by Google

5.7. Números complejos

>>> a // b
Rastreo (llamadas recientes más última):
Archivo "<stdin>", línea 1, en <módulo>
TypeError: no se puede tomar la palabra de un número complejo.

Curiosamente, aunque no es sorprendente desde un punto de vista matemático,

los objetos int y float también tienen las propiedades .real e .imag , así como el
método .conjugate() :

>>> x = 42
>>> x.real
42

>>> x.imag
0

>>> x.conjugar()
42

>>> y = 3.14
>>> y.real
3.14

>>> y.imag
0.0

>>> y.conjugar()
3.14

Para flotantes y enteros, .real y .conjugate() siempre devuelven el número mismo,

y .imag siempre devuelve 0. Sin embargo, una cosa a tener en cuenta es que
n.real y n.imag devuelven un número entero si n es un entero y flotante si n es
flotante.

Ahora que has visto los conceptos básicos de los números complejos, quizás te
preguntes cuándo necesitarás usarlos. Si está aprendiendo Python para el
desarrollo web o la automatización, la verdad es que es posible que nunca necesite
utilizar números complejos.

Por otro lado, los números complejos son importantes en ámbitos como la
informática científica y los gráficos por ordenador. Si alguna vez trabaja en esos
dominios, es posible que encuentre el soporte integrado de Python para tareas complejas.

132
Machine Translated by Google

5.8. Resumen y recursos adicionales

Números útiles.

Una mirada detallada a esos temas está más allá del alcance de este libro. Sin
embargo, obtendrá una introducción al paquete NumPy, una herramienta común para
la computación científica con Python, en el Capítulo 17.

Deje comentarios sobre esta sección »

5.8 Resumen y recursos adicionales

En este capítulo aprendiste todo sobre cómo trabajar con números en Python.
Viste que hay dos tipos básicos de números (enteros y números de punto flotante) y
que Python también tiene soporte integrado para números complejos.

Primero, aprendiste cómo hacer aritmética básica con números usando los operadores
+, ­, *, / y % . Viste cómo escribir expresiones aritméticas y aprendiste cuáles son las
mejores prácticas en PEP 8. para formatear expresiones aritméticas en su código.

Luego aprendiste sobre los números de punto flotante y cómo es posible que no siempre
sean 100% precisos. Esta limitación no tiene nada que ver con Python. Es un hecho de
la informática moderna y se debe a la forma en que se almacenan los números de
punto flotante en la memoria de una computadora.

A continuación, viste cómo redondear números a una posición decimal determinada

con la función round() y aprendiste que round() redondea los empates a pares, lo cual
es diferente de la forma en que la mayoría de la gente aprendía a redondear números
en la escuela.

Finalmente, vio numerosas formas de formatear números para su visualización.

133
Machine Translated by Google

5.8. Resumen y recursos adicionales

Prueba interactiva
Este capítulo viene con un cuestionario en línea gratuito para verificar su
progreso de aprendizaje. Puede acceder al cuestionario usando su teléfono
o computadora en la siguiente dirección web:

realpython.com/quizzes/python­basics­5

Recursos adicionales
Para obtener más información, consulte estos recursos:

• Tipos de datos básicos en Python

• Cómo redondear números en Python

• Recursos recomendados en realpython.com

Deje comentarios sobre esta sección »

134
Machine Translated by Google

Capítulo 6

Funciones y bucles

Las funciones son los componentes básicos de casi todos los programas de Python.
¡Es donde tiene lugar la verdadera acción!

Ya has visto cómo utilizar varias funciones, incluidas print(), len() y round(). Todas estas
son funciones integradas porque vienen integradas en el propio lenguaje Python.
También puede crear funciones definidas por el usuario que realicen tareas específicas.

Las funciones dividen el código en fragmentos más pequeños y son excelentes para
tareas que un programa usa repetidamente. En lugar de escribir el mismo código cada
vez que el programa necesite realizar la tarea, ¡simplemente llame a la función!

Pero a veces es necesario repetir algún código varias veces seguidas, y aquí es donde
entran los bucles .

En este capítulo, aprenderá:

• Cómo crear funciones definidas por el usuario

• Cómo escribir bucles for y while

• Qué es el alcance y por qué es importante

¡Vamos a sumergirnos!

Deje comentarios sobre esta sección »

135
Machine Translated by Google

6.1. ¿Qué es realmente una función?

6.1 ¿Qué es realmente una función?

En los últimos capítulos usaste funciones como print() y len() para mostrar texto y
determinar la longitud de una cadena. Pero ¿qué es realmente una función?

En esta sección, observará más de cerca len() para aprender más sobre qué es una
función y cómo se ejecuta.

Las funciones son valores

Una de las propiedades más importantes de una función en Python es que las
funciones son valores y se pueden asignar a una variable.

En la ventana interactiva de IDLE, inspeccione el nombre len escribiendo lo siguiente

cuando se le solicite:

>>> len

<función incorporada len>

Cuando presionas Enter, Python te dice que el nombre len es una variable cuyo valor
es una función incorporada.

Así como los valores enteros tienen un tipo llamado int y las cadenas tienen un tipo str,
los valores de función también tienen un tipo:

>>> tipo(len)

<clase 'función_o_método_incorporada'>

Como cualquier otra variable, puedes asignarle cualquier valor que quieras :

>>> len = "No soy el len que estás buscando."

>>> len

"No soy el Len que estás buscando."

Ahora len tiene un valor de cadena y puedes verificar que el tipo es str con
tipo():

136
Machine Translated by Google

6.1. ¿Qué es realmente una función?

>>> tipo(len)
<clase 'cadena'>

El nombre de la variable len es una palabra clave en Python y, aunque puedes

cambiar su valor, normalmente es una mala idea hacerlo. Cambiar el valor de len
puede hacer que su código sea confuso porque es fácil confundir el nuevo len con la
función incorporada.

Importante

Si escribió los ejemplos de código anteriores, ya no tendrá acceso a la

función len incorporada en IDLE.

Puedes recuperarlo con el siguiente código:

>>> del len

La palabra clave del se utiliza para desasignar una variable de un valor. del significa
eliminar, pero no elimina el valor. En cambio, separa el nombre del valor y elimina el
nombre.

Normalmente, después de usar del, intentar usar el nombre de la variable eliminada

genera un NameError. En este caso, sin embargo, el nombre len no se elimina:

>>> len

<función incorporada len>

Debido a que len es un nombre de función incorporado, se reasigna al valor de

función original.

Al seguir cada uno de estos pasos, hemos visto que el nombre de una función está
separado de la función misma.

Cómo ejecuta Python las funciones

Ahora echemos un vistazo más de cerca a cómo Python ejecuta una función.

Lo primero que hay que notar es que no puedes ejecutar una función simplemente

137
Machine Translated by Google

6.1. ¿Qué es realmente una función?

escribiendo su nombre. Debes llamar a la función para decirle a Python que realmente
la ejecute.

Veamos cómo funciona esto con len():

>>> # Escribir solo el nombre no ejecuta la función.

>>> # IDLE inspecciona la variable como de costumbre.

>>> len

<función incorporada len>

>>> # Utilice paréntesis para llamar a la función.

>>> len()

Rastreo (llamadas recientes más última):

Archivo "<pyshell#3>", línea 1, en <módulo>

len()

TypeError: len() toma exactamente un argumento ( se proporciona 0)

En este ejemplo, Python genera un TypeError cuando se llama a len() porque len()
espera un argumento.

Un argumento es un valor que se pasa a la función como entrada.

Algunas funciones se pueden llamar sin argumentos y otras pueden tomar tantos
argumentos como desee. len() requiere exactamente un argumento.

Cuando una función termina de ejecutarse, devuelve un valor como salida. El valor
de retorno generalmente, pero no siempre, depende de los valores de los argumentos
pasados a la función.

El proceso para ejecutar una función se puede resumir en tres pasos:

1. Se llama a la función y todos los argumentos se pasan a la función como entrada.

2. La función se ejecuta y se realiza alguna acción con el

argumentos.

3. La función regresa y se reemplaza la llamada a la función original.

con el valor de retorno.

138
Machine Translated by Google

6.1. ¿Qué es realmente una función?

Miremos esto en la práctica y veamos cómo Python ejecuta la siguiente línea de

código:

>>> num_letras = len("cuatro")

Primero, se llama a len() con el argumento "cuatro". Se calcula la longitud de la

cadena "cuatro" , que es el número 4. Luego len() devuelve el número 4 y reemplaza
la llamada a la función con el valor.

Entonces, después de que se ejecuta la función, la línea de código se ve así:

>>> numero_letras = 4

Luego Python asigna el valor 4 a num_letters y continúa ejecutando las líneas de

código restantes en el programa.

Las funciones pueden tener efectos secundarios

Ha aprendido cómo llamar a una función y que devuelven un valor cuando terminan
de ejecutarse. Sin embargo, a veces las funciones hacen más que simplemente
devolver un valor.

Cuando una función cambia o afecta algo externo a la función misma, se dice que
tiene un efecto secundario. Ya has visto una función con un efecto secundario:
imprimir().

Cuando llamas a print() con un argumento de cadena, la cadena se muestra en el

shell de Python como texto. Pero print() no devuelve ningún texto como valor.

Para ver qué devuelve print() , puede asignar el valor de retorno de print() a una
variable:

>>> valor_retorno = print("¿Qué devuelvo?")

¿Qué devuelvo ?

>>> valor_retorno

>>>

Cuando asignas print("¿Qué devuelvo?") a return_value, la cadena

139
Machine Translated by Google

6.2. Escribe tus propias funciones

"¿Qué devuelvo?" se visualiza. Sin embargo, cuando inspecciona el valor de

return_value, no se muestra nada.

print() devuelve un valor especial llamado Ninguno que indica la ausencia de datos. Ninguno
tiene un tipo llamado NingunoTipo:

>>> tipo(valor_retorno)
<clase 'NingunoTipo'>
>>> imprimir(valor_retorno)
Ninguno

Cuando llamas a print(), el texto que se muestra no es el valor de retorno. Es un

efecto secundario de print().

Ahora que sabe que las funciones son valores, al igual que las cadenas y los
números, y ha aprendido cómo se llaman y ejecutan las funciones, veamos cómo
puede crear sus propias funciones definidas por el usuario.

Deje comentarios sobre esta sección »

6.2 Escriba sus propias funciones

A medida que escribe programas más largos y complejos, es posible que necesite
utilizar las mismas pocas líneas de código repetidamente. O tal vez necesites calcular
la misma fórmula con diferentes valores varias veces en tu código.

Es posible que tengas la tentación de copiar y pegar código similar en otras partes
de tu programa y modificarlo según sea necesario, ¡pero esto suele ser una mala idea!

Mantener el código repetitivo puede ser una pesadilla. Si encuentra un error en algún
código que se ha copiado y pegado por todos lados, terminará teniendo que aplicar
la solución en todos los lugares donde se copió el código. ¡Eso es mucho trabajo y
es posible que te pierdas algún lugar!

En esta sección, aprenderá cómo definir sus propias funciones para evitar repetirse
cuando necesite reutilizar código. vamos

140
Machine Translated by Google

6.2. Escribe tus propias funciones

¡ir!

La anatomía de una función

Cada función tiene dos partes:

1. La firma de la función define el nombre de la función y las entradas que espera.

2. El cuerpo de la función contiene el código que se ejecuta cada vez que

Se utiliza la función.

Comencemos escribiendo una función que tome dos números como entrada y
devuelva su producto. Así es como se vería esta función, con la firma, el cuerpo y
la declaración de devolución identificados con comentarios:

def multiplicar(x, y): # Firma de función

# Cuerpo funcional
producto = x * y

devolver producto

Puede parecer extraño crear una función para algo tan simple como el operador * .
De hecho, multiplicar no es una función que probablemente escribirías en un
escenario del mundo real. ¡Pero es un excelente primer ejemplo para comprender
cómo se crean las funciones!

Analicemos la función para ver qué está pasando.

La firma de la función
La primera línea de código de una función se llama firma de función.
Siempre comienza con la palabra clave def , que es la abreviatura de "definir".

Miremos más de cerca la firma de la función multiplicar :

def multiplicar(x, y):

La firma de la función tiene cuatro partes:

1. La palabra clave def

141
Machine Translated by Google

6.2. Escribe tus propias funciones

2. El nombre de la función, multiplicar.

3. La lista de parámetros, (x, y)

4. Dos puntos (:) al final de la línea

Cuando Python lee una línea que comienza con la palabra clave def , crea
una nueva función. La función se asigna a una variable con el mismo
name como nombre de la función.

Nota
Dado que los nombres de funciones se convierten en variables, deben seguir las
Las mismas reglas para los nombres de variables que aprendiste en el Capítulo 3.

Por lo tanto, el nombre de una función sólo puede contener números, letras y
guiones bajos, y no debe comenzar con un número.

La lista de parámetros es una lista de nombres de parámetros rodeados por paréntesis de

apertura y cierre. Define las entradas esperadas de la función.
(x, y) es la lista de parámetros para la función de multiplicar . Crea dos
parámetros, x e y.

Un parámetro es algo así como una variable, excepto que no tiene valor.
Es un marcador de posición para los valores reales que se proporcionan siempre que el
La función se llama con uno o más argumentos.

El código en el cuerpo de la función puede usar parámetros como si fueran variables.

con valores reales. Por ejemplo, el cuerpo de la función puede contener una línea
de código con la expresión x * y.

Como xey no tienen valor , xy no tiene valor.*Python guarda el

expresión como plantilla y completa los valores faltantes cuando se ejecuta la función.

Una función puede tener cualquier número de parámetros, ¡incluso ningún parámetro!

142
Machine Translated by Google

6.2. Escribe tus propias funciones

El cuerpo funcional

El cuerpo de la función es el código que se ejecuta cada vez que se utiliza la

función en su programa. Aquí está el cuerpo de la función de multiplicar :

def multiplicar(x, y):

# Función producto
corporal = x * y

devolver producto

multiplicar es una función bastante simple. ¡Su cuerpo tiene sólo dos líneas de
código!

La primera línea crea una variable llamada producto y le asigna el valor y. Dado
*
X que x e y aún no tienen valores, esta línea es en realidad una plantilla para
el valor del producto se asigna cuando se ejecuta la función.

La segunda línea de código se llama declaración de devolución. Comienza con la

palabra clave return y va seguida de la variable producto. Cuando Python llega a la
declaración de devolución, deja de ejecutar la función y devuelve el valor del
producto.

Observe que ambas líneas de código en el cuerpo de la función tienen sangría.

¡Esto es de vital importancia! Cada línea con sangría debajo de la firma de la
función se entiende como parte del cuerpo de la función.

Por ejemplo, la función print() en el siguiente ejemplo no forma parte del cuerpo de
la función porque no tiene sangría:

def multiplicar(x, y):

producto = x * y

devolver producto

print("¿Dónde estoy?") # No en el cuerpo de la función.

Si print() tiene sangría, entonces se convierte en parte del cuerpo de la función

incluso si hay una línea en blanco entre print() y la línea anterior:

143
Machine Translated by Google

6.2. Escribe tus propias funciones

def multiplicar(x, y):

producto = x * y

devolver producto

print("¿Dónde estoy?") # En el cuerpo de la función.

Hay una regla que debes seguir al sangrar el código en un

cuerpo de la función. Cada línea debe tener una sangría del mismo número de
espacios.

Intente guardar el siguiente código en un archivo llamado multiplicar.py y ejecutar

desde IDLE:

def multiplicar(x, y):

producto = x * y

número de producto devuelto Sangrado con un espacio adicional.

¡IDLE no ejecutará el código! Aparece un cuadro de diálogo con el error "sangría

inesperada". Python no esperaba que la declaración de devolución fuera
sangría de forma diferente a la línea anterior.

Otro error ocurre cuando una línea de código tiene una sangría menor que la línea
encima, pero la sangría no coincide con ninguna línea anterior. Modificar
el archivo multiplicar.py se verá así:

def multiplicar(x, y):

producto = x * y

número de producto devuelto Sangrado menor que la línea anterior.

Ahora guarde y ejecute el archivo. IDLE lo detiene con el error "unindent

no coincide con ningún nivel de sangría exterior”. La declaración de devolución
no tiene sangría con el mismo número de espacios que cualquier otra línea en el
cuerpo funcional.

144
Machine Translated by Google

6.2. Escribe tus propias funciones

Nota
Aunque Python no tiene reglas para la cantidad de espacios utilizados para
sangrar el código en el cuerpo de una función, PEP 8 recomienda sangrar con
cuatro espacios.

Seguimos esta convención a lo largo de este libro.

Una vez que Python ejecuta una declaración de devolución , la función deja de ejecutarse
y devuelve el valor. Si aparece algún código debajo de la declaración de devolución con
sangría para formar parte del cuerpo de la función, nunca se ejecutará.

Por ejemplo, la función print() nunca se ejecutará en la siguiente función:

def multiplicar(x, y):

producto = x * y

devolver producto
print("¡ No puedes verme!")

Si llamas a esta versión de multiplicar(), nunca verás la cadena "¡No puedes verme!"
desplegado.

Llamar a una función definida por el usuario

Llamas a una función definida por el usuario como cualquier otra función. Escriba el
nombre de la función seguido de una lista de argumentos entre paréntesis.

Por ejemplo, para llamar a multiplicar() con los argumentos 2 y 4, simplemente escriba:

multiplicar(2, 4)

A diferencia de las funciones integradas, las funciones definidas por el usuario no están
disponibles hasta que se hayan definido con la palabra clave def . Debe definir la función
antes de llamarla.

Intente guardar y ejecutar el siguiente script:

145
Machine Translated by Google

6.2. Escribe tus propias funciones

número = multiplicar(2, 4)
imprimir(núm)

def multiplicar(x, y):

*
producto = x y
devolver producto

Cuando Python lee la línea num = multiplicar(2, 4), no reconoce el nombre multiplicar y
genera un NameError:

Rastreo (llamadas recientes más última):

Archivo "C:Usersdaveamultiply.py", línea 1, en <módulo>
número = multiplicar(2, 4)
NameError: el nombre 'multiplicar' no está definido

Para corregir el error, mueva la definición de la función a la parte superior del archivo:

def multiplicar(x, y):

*
producto = x y
devolver producto

número = multiplicar(2, 4)
imprimir(núm)

Ahora, cuando guarda y ejecuta el script, el valor 8 se muestra en la ventana interactiva.

Funciones sin declaración de devolución

Todas las funciones en Python devuelven un valor, incluso si ese valor es Ninguno. Sin embargo,
no todas las funciones necesitan una declaración de devolución .

Por ejemplo, la siguiente función es perfectamente válida:

saludo definido (nombre):

print(f"¡Hola, {nombre}!")

greet() no tiene declaración de devolución , pero funciona bien:

146
Machine Translated by Google

6.2. Escribe tus propias funciones

>>> saludar("Dave")
Hola dave!

Aunque greet() no tiene una declaración de devolución , aún devuelve un valor:

>>> valor_retorno = saludar("Dave")

Hola dave!
>>> imprimir(valor_retorno)
Ninguno

Observe también que la cadena "¡Hola, Dave!" se imprime incluso cuando el

resultado de saludar ("Dave") se asigna a una variable. Esto se debe a que la
llamada a print() dentro del cuerpo de la función greet() produce el efecto secundario
de imprimir siempre en la consola.

Si no esperabas ver "¡Hola, Dave!" impreso, entonces acaba de experimentar uno

de los problemas con los efectos secundarios. ¡No siempre se los espera!

Cuando crea sus propias funciones, siempre debe documentar lo que hacen. De
esa manera, otros desarrolladores pueden leer la documentación y saber cómo
usar la función y qué esperar cuando se llama.

Documentar sus funciones

Para obtener ayuda con una función en la ventana interactiva de IDLE, puede usar
la función help() :

>>> ayuda(len)
Ayuda sobre la función incorporada len en los módulos incorporados:

len(obj, /)
Devuelve la cantidad de artículos en un contenedor.

Cuando pasa un nombre de variable o nombre de función a help(), muestra

información útil al respecto. En este caso, help() le dice que len es una función
incorporada que devuelve la cantidad de elementos en un contenedor.

147
Machine Translated by Google

6.2. Escribe tus propias funciones

Nota

Un contenedor es un nombre especial para un objeto que contiene otros objetos. Una
cadena es un contenedor porque contiene caracteres.

Aprenderá sobre otros tipos de contenedores en el Capítulo 9.

Veamos qué sucede cuando llamas a help() en la función multiplicar() :

>>> ayuda(multiplicar)
Ayuda sobre la función multiplicar en el módulo __main__:

multiplicar(x,y)

help() muestra la firma de la función, pero no hay ninguna información sobre lo que hace la
función. Para documentar mejor la multiplicación (), debemos proporcionar una cadena de
documentación.

Una cadena de documentación es una cadena literal entre comillas triples colocada en la parte
superior del cuerpo de la función. Las cadenas de documentos se utilizan para documentar lo
que hace una función y qué tipo de parámetros espera.

Así es como se ve multiplicar() con una cadena de documentación agregada:

def multiplicar(x, y):

"""Devuelve el producto de dos números x e y."""
producto = x * y

devolver producto

Actualice el script multiplicar.py con la cadena de documentación, luego guarde y ejecute el

script. Ahora puedes usar help() en la ventana interactiva para ver la cadena de documentación:

>>> ayuda(multiplicar)
Ayuda sobre la función multiplicar en el módulo __main__:

multiplicar(x,y)
Devuelve el producto de dos números x e y.

148
Machine Translated by Google

6.3. Desafío: convertir temperaturas

PEP 8 no dice mucho sobre las cadenas de documentación, excepto que cada
función debería tener una.

Hay varios formatos de cadenas de documentos estandarizados, pero no los

abordaremos aquí. Algunas pautas generales para escribir cadenas de documentación
se pueden encontrar en PEP 257.

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos adicionales
en línea en realpython.com/python­basics/resources.

1. Escribe una función llamada cube() con un parámetro numérico y devuelve el

valor de ese número elevado a la tercera potencia. Pruebe la función mostrando
el resultado de llamar a su función cube() en algunos números diferentes.

2. Escriba una función llamada greet() que tome un parámetro de cadena llamado
nombre y muestre el texto "¡Hola <nombre>!", donde <nombre> se reemplaza
con el valor del parámetro de nombre .

Deje comentarios sobre esta sección »

6.3 Desafío: Convertir temperaturas

Escriba un script llamado temperatura.py que defina dos funciones:

1. convert_cel_to_far() que toma un parámetro flotante que representa grados

Celsius y devuelve un flotante que representa la misma temperatura en grados
Fahrenheit usando la siguiente fórmula:

F = C * 9/5 + 32

2. convert_far_to_cel() que toma un parámetro flotante que representa grados

Fahrenheit y devuelve un flotante que representa la misma temperatura en
grados Celsius usando la siguiente fórmula:

C = (F ­ 32) * 5/9

149
Machine Translated by Google

6.4. Corre en circulos

El script primero debe pedirle al usuario que ingrese una temperatura en grados
Fahrenheit y luego mostrar la temperatura convertida a Cel­sius.

Luego solicite al usuario que ingrese una temperatura en grados Celsius y muestre
la temperatura convertida a Fahrenheit.

Todas las temperaturas convertidas deben redondearse a 2 decimales.

Aquí hay una ejecución de muestra del programa:

Ingrese una temperatura en grados F: 72

72 grados F = 22,22 grados C

Introduzca una temperatura en grados C: 37

37 grados C = 98,60 grados F

Puede encontrar las soluciones a este desafío de código y muchos otros recursos
adicionales en línea en realpython.com/python­basics/resources.

Deje comentarios sobre esta sección »

6.4 Correr en círculos

Una de las mejores cosas de las computadoras es que puedes hacer que hagan lo
mismo una y otra vez y rara vez se quejan o se cansan.

Un bucle es un bloque de código que se repite una y otra vez, ya sea un número
específico de veces o hasta que se cumpla alguna condición. Hay dos tipos de
bucles en Python: bucles while y bucles for . En esta sección, aprenderá a utilizar
ambos.

Comencemos viendo cómo funcionan los bucles while .

150
Machine Translated by Google

6.4. Corre en circulos

El bucle while
Los bucles while repiten una sección de código mientras alguna condición sea verdadera.
Hay dos partes en cada bucle while :

1. La declaración while comienza con la palabra clave while , seguida de una condición
de prueba y termina con dos puntos (:).

2. El cuerpo del bucle contiene el código que se repite en cada paso.

del bucle. Cada línea tiene una sangría de cuatro espacios.

Cuando se ejecuta un bucle while , Python evalúa la condición de prueba y determina si

es verdadera o falsa. Si la condición de prueba es verdadera, se ejecuta el código del
cuerpo del bucle. De lo contrario, se omite el código del cuerpo y se ejecuta el resto del
programa.

Si la condición de prueba es verdadera y se ejecuta el cuerpo del bucle, una vez que
Python llega al final del cuerpo, regresa a la declaración while y reevalúa la condición de
prueba. Si la condición de prueba sigue siendo verdadera, el cuerpo se ejecuta

nuevamente. Si es falso, se omite el cuerpo.

Este proceso se repite una y otra vez hasta que la condición de prueba falla, lo que hace
que Python repita el código en el cuerpo del bucle while .

Veamos un ejemplo. Escriba el siguiente código en la ventana interactiva:

>>> norte = 1

>>> mientras n < 5:

... imprimir(n)
... norte = norte + 1

...
1
2
3
4

Primero, se asigna el número entero 1 a la variable n. Luego se crea un bucle while con
la condición de prueba n < 5, que verifica si el valor de n es menor que 5.

151
Machine Translated by Google

6.4. Corre en circulos

Si n es menor que 5, se ejecuta el cuerpo del bucle. Hay dos lineas

de código en el cuerpo del bucle. En la primera línea, el valor de n está impreso en
la pantalla, y luego n se incrementa en 1 en la segunda línea.

La ejecución del bucle se lleva a cabo en cinco pasos, que se describen a continuación.
mesa:

Paso # Valor de n Condición de prueba Lo que sucede

1 1 1 < 5 (verdadero) 1 impreso; n incrementado a 2

2 2 2 < 5 (verdadero) 2 impresos; n incrementado a 3
3 3 3 < 5 (verdadero) 3 impresos; n incrementado a 4
4 4 4 < 5 (verdadero) 4 impresos; n incrementado a 5
5 5 5 < 5 (falso) Nada impreso; extremos del bucle.

Si no tienes cuidado, puedes crear un bucle infinito. Esto pasa

cuando la condición de prueba es siempre verdadera. Un bucle infinito nunca termina.
El cuerpo del bucle se repite para siempre.

Aquí hay un ejemplo de un bucle infinito:

>>> norte = 1

>>> mientras n < 5:

... imprimir(n)
...

La única diferencia entre este bucle while y el anterior es

que n nunca se incrementa en el cuerpo del bucle. En cada paso del bucle,
n es igual a 1. Eso significa que la condición de prueba n < 5 siempre es verdadera, y
el número 1 se imprime una y otra vez para siempre.

152
Machine Translated by Google

6.4. Corre en circulos

Nota
Los bucles infinitos no son inherentemente malos. A veces son exactamente
el tipo de bucle que necesitas.

Por ejemplo, el código que interactúa con el hardware puede utilizar un

bucle infinito para comprobar constantemente si un botón o interruptor se ha
activado o no.

Si ejecuta un programa que ingresa en un bucle infinito, puede forzar el cierre de

Python presionando Ctrl+C. Python deja de ejecutar el programa y genera un error
KeyboardInterrupt :

Rastreo (llamadas recientes más última):

Archivo "<pyshell#8>", línea 2, en <módulo>
imprimir(n)
Interrupción del teclado

Veamos un ejemplo de un bucle while en la práctica. Un uso de un bucle while es

verificar si la entrada del usuario cumple con alguna condición y, de no ser así,
pedirle repetidamente al usuario una nueva entrada hasta que se reciba una entrada válida.

Por ejemplo, el siguiente programa solicita continuamente al usuario un número

positivo hasta que se ingresa un número positivo:

num = float(input("Ingrese un número positivo: "))

mientras número <= 0:

print("¡Ese no es un número positivo!")

num = float(input("Ingrese un número positivo: "))

Primero, se le solicita al usuario que ingrese un número positivo. La condición de

prueba num <= 0 determina si num es menor o igual que
0.

Si num es positivo, entonces la condición de prueba falla. Se omite el cuerpo del

bucle y el programa finaliza.

De lo contrario, si num es 0 o negativo, se ejecuta el cuerpo del bucle. El

153
Machine Translated by Google

6.4. Corre en circulos

Se notifica al usuario que su entrada fue incorrecta y se le solicita nuevamente que ingrese
un número positivo.

Los bucles while son perfectos para repetir una sección de código mientras se cumple
alguna condición. Sin embargo, no son adecuados para repetir una sección de código un
número específico de veces.

El bucle for
Un bucle for ejecuta una sección de código una vez para cada elemento de una colección
de elementos. La cantidad de veces que se ejecuta el código está determinada por la

cantidad de elementos de la colección.

Al igual que su contraparte while , el bucle for tiene dos partes principales:

1. La declaración for comienza con la palabra clave for , seguida de una expresión de
membresía y termina en dos puntos (:).

2. El cuerpo del bucle contiene el código que se ejecutará en cada paso del
el bucle y tiene una sangría de cuatro espacios.

Veamos un ejemplo. El siguiente bucle for imprime cada letra de la cadena "Python" una a
la vez:

para letra en "Python":

imprimir (carta)

En este ejemplo, la declaración for es for letter en "Python". La expresión de membresía es

una letra en "Python".

En cada paso del ciclo, a la variable letra se le asigna la siguiente letra en la cadena
"Python" y luego se imprime el valor de la letra .

Los bucles se ejecutan una vez por cada carácter de la cadena "Python", por lo que el
cuerpo del bucle se ejecuta seis veces. La siguiente tabla resume la ejecución de este
bucle for :

Paso # Valor de la letra Qué sucede

1 "PAG" P está impreso

154
Machine Translated by Google

6.4. Corre en circulos

Paso # Valor de la letra Qué sucede

2 "y" y está impreso

3 "t" está impreso
4 "h" h está impreso
5 "oh" o está impreso
6 "norte" n está impreso

Para ver por qué los bucles for son mejores para recorrer colecciones de elementos,
Reescribamos el bucle for del ejemplo anterior como un bucle while .

Para hacerlo, podemos usar una variable para almacenar el índice del siguiente carácter.
en la cuerda. En cada paso del ciclo, imprimiremos el carácter en
el índice actual y luego incrementar el índice.

El ciclo se detendrá una vez que el valor de la variable de índice sea igual al
longitud de la cuerda. Recuerde, los índices comienzan en 0, por lo que el último índice de
la cadena "Python" es 5.

Así es como podrías escribir ese código:

palabra = "Python"
índice = 0

mientras índice < len(palabra):

imprimir(palabra[índice])
índice = índice + 1

¡Eso es significativamente más complejo que la versión del bucle for !

El bucle for no sólo es menos complejo, sino que el código en sí parece más natural.
Se parece más a cómo se podría describir el bucle en inglés.

155
Machine Translated by Google

6.4. Corre en circulos

Nota
Es posible que a veces escuches a personas describir algún código como
particularmente "pitónico". El término Pythonic se usa generalmente para
describir código que es claro, conciso y que utiliza las características
integradas de Python a su favor.

En estos términos, usar un bucle for para recorrer una colección de

elementos es más pitónico que usar un bucle while .

A veces es útil recorrer un rango de números. Python tiene una práctica función
incorporada range() que produce precisamente eso: ¡un rango de números!

Por ejemplo, rango(3) devuelve el rango de números enteros que comienzan

con 0 y hasta 3, pero sin incluirlo . Es decir, rango(3) es el rango de números 0,
1 y 2.

Puedes usar range(n), donde n es cualquier número positivo, para ejecutar un

bucle exactamente n veces. Por ejemplo, el siguiente bucle for imprime la cadena
"Python" tres veces:

para n en el rango(3):
imprimir("Python")

También puedes darle a un rango un punto de partida. Por ejemplo, rango(1, 5)

es el rango de números 1, 2, 3 y 4. El primer argumento es el número inicial y el
segundo argumento es el punto final, que no está incluido en el rango.

Usando la versión de dos argumentos de range(), el siguiente bucle for imprime

el cuadrado de cada número comenzando con 10 y hasta 20, pero sin incluirlo:

para n en el rango (10, 20):

imprimir(n * n)

Veamos un ejemplo práctico. El siguiente programa le pide al usuario que ingrese

una cantidad y luego muestra cómo dividir esa cantidad entre

156
Machine Translated by Google

6.4. Corre en circulos

entre 2, 3, 4 y 5 personas:

cantidad = float(input("Ingrese una cantidad: "))

para num_people en el rango (2, 6):

print(f"{num_people} personas: ${cantidad / num_people:,.2f} cada una")

El bucle for recorre los números 2, 3, 4 y 5 e imprime el número de personas y la cantidad

que cada persona debe pagar. El especificador de formato ,.2f se utiliza para formatear la
cantidad como un número de punto fijo redondeado a dos decimales y comas cada tres
dígitos.

Ejecutar el programa con la entrada 10 produce el siguiente resultado:

Introduzca una cantidad: 10

2 personas: $5.00 cada una

3 personas: $3.33 cada una

4 personas: $2.50 cada una

5 personas: $2.00 cada una

Los bucles for generalmente se usan con más frecuencia que los bucles while en Python.
La mayoría de las veces, un bucle for es más conciso y más fácil de leer que un bucle
while equivalente .

Bucles anidados
Siempre que apliques sangría al código correctamente, puedes incluso colocar bucles
dentro de otros bucles.

Escriba lo siguiente en la ventana interactiva de IDLE:

para n en el rango (1, 4):

para j en el rango (4, 7):

imprimir(f"n = {n} y j = {j}")

Cuando Python ingresa al cuerpo del primer bucle for , a la variable n se le asigna el valor
1. Luego se ejecuta el cuerpo del segundo bucle for y a j se le asigna el valor 4. Lo primero
que se imprime es n = 1 y j = 4 .

157
Machine Translated by Google

6.4. Corre en circulos

Después de ejecutar la función print() , Python regresa al bucle for interno ,

asigna a j el valor de 5 y luego imprime n = 1 y j = 5. Python no devuelve el
bucle for externo porque el bucle for interno , que está dentro del cuerpo del
bucle for externo , no ha terminado de ejecutarse.

A continuación, a j se le asigna el valor 6 y Python imprime n = 1 y j = 6. En

este punto, el bucle for interno termina de ejecutarse, por lo que el control
regresa al bucle for externo .

A la variable n se le asigna el valor 2 y el bucle for interno se ejecuta por

segunda vez. Es decir, a j se le asigna el valor 4 y n = 2 y j = 4 se imprime en
la consola.

Los dos bucles continúan ejecutándose de esta manera y el resultado final se ve

así:

norte = 1 y j = 4
n=1yj=5n=1
yj=6
norte = 2 y j = 4
norte = 2 y j = 5
norte = 2 y j = 6
norte = 3 y j = 4
norte = 3 y j = 5
norte = 3 y j = 6

Un bucle dentro de otro bucle se llama bucle anidado y aparecen con más
frecuencia de lo que cabría esperar. Puedes anidar bucles while dentro de
bucles for , y viceversa, ¡e incluso anidar bucles de más de dos niveles de
profundidad!

158
Machine Translated by Google

6.4. Corre en circulos

Importante

Anidar bucles aumenta inherentemente la complejidad de su código,

como puede ver por el aumento dramático en la cantidad de pasos
ejecutados en el ejemplo anterior en comparación con los ejemplos con
un solo bucle for .

El uso de bucles anidados es a veces la única forma de hacer algo, pero

demasiados bucles anidados pueden tener un efecto negativo en el
rendimiento de un programa.

Los bucles son una herramienta poderosa. Aprovechan una de las mayores
ventajas que ofrecen las computadoras como herramientas de cálculo: la
capacidad de repetir la misma tarea una gran cantidad de veces sin cansarse y
sin quejarse.

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos

adicionales en línea en realpython.com/python­basics/resources.

1. Escriba un bucle for que imprima los números enteros del 2 al 10, cada uno
en una nueva línea, utilizando la función range() .

2. Utilice un bucle while que imprima los números enteros del 2 al 10 (Pista:
primero deberá crear un nuevo número entero).

3. Escribe una función llamada doubles() que tome un número como entrada y
duplique ese número. Luego use la función doubles() en un bucle para
duplicar el número 2 tres veces, mostrando cada resultado en una línea
separada. Aquí hay algunos resultados de muestra:
4

dieciséis

Deje comentarios sobre esta sección »

159
Machine Translated by Google

6.5. Desafío: realice un seguimiento de sus inversiones

6.5 Desafío: Realice un seguimiento de sus inversiones

En este desafío, escribirás un programa llamado invest.py que rastrea el

monto creciente de una inversión a lo largo del tiempo.

Se realiza un depósito inicial, llamado monto principal. Cada año, la cantidad aumenta en un
porcentaje fijo, llamado tasa de rendimiento anual.

Por ejemplo, un monto principal de $100 con una tasa de rendimiento anual
del 5% aumenta el primer año en $5. El segundo año, el aumento es del 5%
de la nueva cantidad de $105, que es $5,25.

Escriba una función llamada invertir con tres parámetros: el monto del capital,
la tasa de rendimiento anual y el número de años a calcular. La firma de la
función podría verse así:

def invertir(cantidad, tasa, años):

Luego, la función imprime el monto de la inversión, redondeado a 2 decimales,

al final de cada año durante el número de años especificado.

Por ejemplo, llamar a invest(100, .05, 4) debería imprimir lo siguiente:

año 1: $105.00
año 2: $110,25 año
3: $115,76
año 4: $121,55

Para finalizar el programa, solicite al usuario que ingrese una cantidad inicial,
una tasa de porcentaje anual y una cantidad de años. Luego llame a invest()
para mostrar los cálculos de los valores ingresados por el usuario.

Puede encontrar las soluciones a este desafío de código y muchos otros

recursos adicionales en línea en realpython.com/python­basics/resources.

Deje comentarios sobre esta sección »

160
Machine Translated by Google

6.6. Comprender el alcance en Python

6.6 Comprender el alcance en Python

Cualquier discusión sobre funciones y bucles en Python estaría incompleta sin
alguna mención a la cuestión del alcance.

El alcance puede ser uno de los conceptos más difíciles de entender en

programación, por lo que en esta sección obtendrá una breve introducción.

Al final de esta sección, sabrá qué es un alcance y por qué es importante.

También aprenderá la regla LEGB para la resolución del alcance.

¿Qué es un alcance?
Cuando asignas un valor a una variable, le estás dando un nombre a ese valor.
Los nombres son únicos. Por ejemplo, no puedes asignar el mismo nombre a dos
números diferentes.

>>> x = 2
>>> x
2

>>> x = 3
>>> x
3

Cuando asignas 3 a x, ya no puedes recuperar el valor 2 con el

nombre x.

Este comportamiento tiene sentido. Después de todo, si la variable x tiene los

valores 2 y 3 simultáneamente, ¿cómo se evalúa x + 2? ¿Deberían ser 4 o 5?

Resulta que hay una manera de asignar el mismo nombre a dos valores diferentes.
Intente ejecutar el siguiente script:

x = "Hola mundo"

función def ():

x=2

161
Machine Translated by Google

6.6. Comprender el alcance en Python

print(f"Dentro de 'func', x tiene el valor {x}")

función()

print(f"Fuera de 'func', x tiene el valor {x}")

En este ejemplo, a la variable x se le asignan dos valores diferentes. A x se le asigna

"Hola, mundo" al principio y se le asigna 2 dentro de
función().

El resultado del script, que puede resultarle sorprendente, se ve así:

Dentro de 'func', x tiene el valor 2

Fuera de 'func', x tiene el valor Hola mundo

¿Cómo es posible que x siga teniendo el valor "Hola mundo" después de llamar a
func(), lo que cambia el valor de x a 2?

La respuesta es que la función func() tiene un alcance diferente al código que existe
fuera de la función. Es decir, puedes nombrar un objeto dentro de func() con el mismo
nombre que algo fuera de func() y Python puede mantener los dos separados.

El cuerpo de la función tiene lo que se conoce como ámbito local, con su propio
conjunto de nombres disponibles. El código fuera del cuerpo de la función está en el
ámbito global.

Puedes pensar en un ámbito como un conjunto de nombres asignados a objetos.

Cuando usa un nombre particular en su código, como una variable o el nombre de una
función, Python verifica el alcance actual para determinar si ese nombre existe o no.

Resolución de alcance
Los ámbitos tienen una jerarquía. Por ejemplo, considere lo siguiente:

x=5

162
Machine Translated by Google

6.6. Comprender el alcance en Python

def función_externa():

y=3

def función_interior():

z=x+y
regresar z

devolver función_interior()

Nota

La función internal_func() se llama función interna porque está definida

dentro de otra función. Así como puedes anidar bucles, ¡también puedes
definir funciones dentro de otras funciones!

Puede leer más sobre las funciones internas en el artículo de Real Python
Funciones internas: ¿para qué sirven?

La variable z está en el ámbito local de Inner_func(). Cuando Python ejecuta la

línea z = x + y , busca las variables xey en el ámbito local. Sin embargo, ninguno
de ellos existe allí, por lo que sube al alcance de la función external_func() .

El alcance de outside_func() es un alcance adjunto de inside_func(). No es

exactamente el alcance global y no es el alcance local para internal_func().
Se encuentra entre esos dos.

La variable y se define en el alcance de external_func() y se le asigna el valor 3.

Sin embargo, x no existe en este alcance, por lo que Python sube una vez más al
alcance global. Allí encuentra el nombre x, que tiene el valor 5. Ahora que los
nombres x e y están resueltos, Python puede ejecutar la línea z = x + y, que asigna
a z el valor de 8.

La regla LEGB

Una forma útil de recordar cómo Python resuelve el alcance es con la regla LEGB .
Esta regla es un acrónimo de Local, Enclosing, Global, Built­in.

163
Machine Translated by Google

6.6. Comprender el alcance en Python

Python resuelve el alcance en el orden en que aparece cada alcance en la lista

LEGB. Aquí hay una descripción general rápida para ayudarlo a recordar cómo
funciona todo esto:

Local (L): el alcance local o actual. Podría ser el cuerpo de una función o el
alcance de nivel superior de un script. Siempre representa el ámbito en el que
está trabajando actualmente el intérprete de Python.

Adjunto (E): El alcance adjunto. Este es el alcance un nivel por encima del
alcance local. Si el alcance local es una función interna, el alcance circundante
es el alcance de la función externa. Si el alcance es una función de nivel
superior, el alcance circundante es el mismo que el alcance global.

Global (G): el alcance global, que es el alcance más alto del script. Contiene
todos los nombres definidos en el script que no están contenidos en el cuerpo
de una función.

Integrado (B): el alcance integrado contiene todos los nombres, como palabras
clave, que están integrados en Python. Funciones como round() y abs() están
en el alcance integrado. Todo lo que pueda utilizar sin definirse primero está
contenido en el alcance integrado.

Romper las reglas

Considere el siguiente guión. ¿Cuál crees que es el resultado?

total = 0

def agregar_a_total(n):
total = total + norte

agregar_al_total(5)
imprimir(total)

Pensarías que el script genera el valor 5, ¿verdad? Intente ejecutarlo para ver
qué sucede.

Ocurre algo inesperado. ¡Obtienes un error!

164
Machine Translated by Google

6.6. Comprender el alcance en Python

Rastreo (llamadas recientes más última):

Archivo "C:/Users/davea/stuff/python/scope.py", línea 6, en <módulo>
agregar_al_total(5)
Archivo "C:/Users/davea/stuff/python/scope.py", línea 4, en add_to_total
total = total + norte

UnboundLocalError: variable local 'total' a la que se hace referencia antes de la asignación

¡Espera un minuto! De acuerdo con la regla LEGB, Python debería haber reconocido
que el nombre total no existe en el alcance local de la función add_to_total() y haber
ascendido al alcance global para resolver el nombre, ¿verdad?

El problema aquí es que el script intenta realizar una asignación a la variable total, lo
que crea un nuevo nombre en el ámbito local. Luego, cuando Python ejecuta el lado
derecho de la asignación, encuentra el nombre total en el ámbito local sin nada
asignado todavía.

Este tipo de errores son complicados y son una de las razones por las que es mejor
utilizar nombres únicos de variables y funciones sin importar en qué ámbito se
encuentre.

Puede solucionar este problema con la palabra clave global . Intente ejecutar el
siguiente script modificado:

total = 0

def agregar_a_total(n):
total mundial
total = total + norte

agregar_al_total(5)
imprimir(total)

Esta vez, obtienes el resultado esperado 5. ¿Por qué?

La línea total global le dice a Python que busque en el ámbito global el nombre total.
De esa manera, la línea total = total + n no crea una nueva variable local.

165
Machine Translated by Google

6.7. Resumen y recursos adicionales

Aunque esto “arregla” el script, el uso de la palabra clave global se considera de mala
educación en general.

Si utiliza global para solucionar problemas como el anterior, deténgase y piense si existe
una mejor manera de escribir su código. ¡A menudo descubrirás que sí!

Deje comentarios sobre esta sección »

6.7 Resumen y recursos adicionales

En este capítulo, aprendió sobre dos de los conceptos más esenciales de la programación:
funciones y bucles.

Primero, aprendió a definir sus propias funciones personalizadas. Viste que las funciones
se componen de dos partes:

1. La firma de la función, que comienza con la palabra clave def e incluye el nombre de la
función y los parámetros de la función.

2. El cuerpo de la función, que contiene el código que se ejecuta cada vez que
se llama la función.

Las funciones ayudan a evitar la repetición de códigos similares en todo un programa

mediante la creación de componentes reutilizables. Esto ayuda a que el código sea más
fácil de leer y mantener.

Luego aprendiste sobre los dos tipos de bucles de Python:

1. Los bucles while repiten algún código mientras alguna condición sigue siendo verdadera

2. Los bucles for repiten algún código para cada elemento en un conjunto de objetos.

Finalmente, aprendió qué es un alcance y cómo Python lo resuelve usando la regla LEGB.

166
Machine Translated by Google

6.7. Resumen y recursos adicionales

Prueba interactiva
Este capítulo viene con un cuestionario en línea gratuito para verificar su
progreso de aprendizaje. Puede acceder al cuestionario usando su teléfono o
computadora en la siguiente dirección web:

realpython.com/quizzes/python­basics­6

Recursos adicionales
Para obtener más información sobre funciones y bucles, consulte el siguiente informe.
fuentes:

• Bucles “ while” de Python (iteración indefinida)

• Bucles “for” de Python (iteración definitiva)

• Recursos recomendados en realpython.com

Deje comentarios sobre esta sección »

167
Machine Translated by Google

Capítulo 7

Encontrar y arreglar código

Insectos

Todo el mundo comete errores, ¡incluso los desarrolladores profesionales experimentados!

IDLE es bastante bueno para detectar errores como errores de sintaxis y de tiempo de
ejecución, pero hay un tercer tipo de error que quizás ya haya experimentado. Los errores
lógicos ocurren cuando un programa que de otro modo sería válido no hace lo que se
esperaba.

Los errores lógicos provocan comportamientos inesperados llamados errores. Eliminar

errores se llama depuración y un depurador es una herramienta que le ayuda a localizar
errores y comprender por qué ocurren.

¡Saber cómo encontrar y corregir errores en su código es una habilidad que utilizará durante
toda su carrera de codificación!

En este capítulo usted:

• Aprenda a utilizar la ventana de control de depuración de IDLE

• Practique la depuración de una función con errores

¡Vamos!

Deje comentarios sobre esta sección »

168
Machine Translated by Google

7.1. Utilice la ventana de control de depuración

7.1 Usar la ventana de control de depuración

La interfaz principal del depurador de IDLE es a través de la ventana de control de
depuración, a la que nos referiremos brevemente como ventana de depuración. Puede
abrir la ventana Depurar seleccionando Depurar depurador en el menú de la ventana
interactiva. Continúe y abra la ventana de depuración.

Nota

Si el menú Depurar no aparece en la barra de menú, asegúrese de que la

ventana interactiva esté enfocada haciendo clic en esa ventana.

Abra una nueva ventana de secuencia de comandos y organice las tres ventanas en su
pantalla para que pueda verlas todas simultáneamente. Esta es una forma de reorganizar
las ventanas:

169
Machine Translated by Google

7.1. Utilice la ventana de control de depuración

Nota

Siempre que la ventana de depuración está abierta, el mensaje en la ventana

interactiva tiene [DEBUG ON] al lado para indicar que el depurador está abierto.

En esta sección aprenderá cómo está organizada la ventana Depurar, cómo recorrer su
código con el depurador línea por línea y cómo establecer puntos de interrupción para
ayudar a acelerar el proceso de depuración.

La ventana de control de depuración: descripción general

Para ver cómo funciona el depurador, comencemos escribiendo un programa simple y

sin errores. Escriba lo siguiente en la ventana del script:

para i en el rango (1, 4): j

=i*2
imprimir(f"i es {i} y j es {j}")

Cuando guarda y ejecuta este script con la ventana de depuración abierta, notará que
la ejecución no llega muy lejos. La ventana de Control de depuración se verá así:

170
Machine Translated by Google

7.1. Utilice la ventana de control de depuración

Observe que el panel Pila en la parte superior de la ventana contiene el siguiente

mensaje:

> '__main__'.<módulo>(), línea 1: para i en el rango(1, 4):

Esto le indica que la línea 1 (que contiene el código para i en el rango(1, 4):)
está a punto de ejecutarse pero aún no ha comenzado. La parte '__main__'.module()
del mensaje en el depurador se refiere al hecho de que actualmente estamos en
la sección "principal" del guión, en lugar de estar, por ejemplo, en
una definición de función antes de que se haya alcanzado el bloque principal de código.

Debajo del panel Pila , hay un panel Locales que enumera algunas cosas extrañas.
buscando cosas como __annotations__, __builtins__, __doc__, etc.
Estas son algunas variables internas del sistema que puedes ignorar por ahora.
A medida que se ejecuta su programa, verá variables declaradas en el código.
se muestran en esta ventana para que pueda realizar un seguimiento de su valor.

Hay cinco botones ubicados en la esquina superior izquierda de la ventana Depurar.

ventana: Ir a Paso
, y Salir . Estos
, Encima botones
, Afuera , controlan cómo
el depurador recorre su código.

171
Machine Translated by Google

7.1. Utilice la ventana de control de depuración

En las siguientes secciones, exploraremos qué hace cada uno de estos botones,
comenzando con el botón Paso .

El botón de paso

Continúe y haga clic en el botón Paso en la esquina superior izquierda de la ventana

Depurar. La ventana de depuración cambia un poco para verse así:

Hay dos diferencias a las que prestar atención aquí. Primero, el mensaje en la ventana
Pila cambia a:

> '__main__'.<módulo>(), línea 2: j = i * 2:

En este punto, se ejecutó la línea 1 de su código y el depurador se detuvo justo antes

de ejecutar la línea 2.

El segundo cambio a notar es la nueva variable i a la que se le asigna el valor 1 en el

panel Locales . Esto se debe a que el bucle for en la primera línea de código creó la
variable i y le asignó el valor 1.

172
Machine Translated by Google

7.1. Utilice la ventana de control de depuración

Continúe presionando el botón Paso para recorrer su código línea por línea y observar lo que sucede
en la ventana del depurador. Cuando llegue a la línea print(f"i es {i} y j es {j}"), podrá ver el resultado
mostrado en la ventana interactiva pieza por pieza.

Más importante aún, puede realizar un seguimiento de los valores crecientes de i y j a medida que
avanza por el bucle for . Probablemente puedas imaginar lo beneficiosa que es esta característica
cuando intentas localizar la fuente de errores en tus programas. Conocer el valor de cada variable
en cada línea de código puede ayudarle a identificar dónde van mal las cosas.

Puntos de interrupción y el botón "Ir"

A menudo, es posible que sepa que el error debe estar en una sección particular de su código, pero
es posible que no sepa exactamente dónde. En lugar de hacer clic en el botón Paso todo el día,
puede establecer un punto de interrupción que le indique al depurador que ejecute todo el código
antes del punto de interrupción de forma continua hasta que se alcance el punto de interrupción.

Los puntos de interrupción le indican al depurador cuándo pausar la ejecución del código para que
pueda observar el estado actual del programa. En realidad no rompen nada.

Para establecer un punto de interrupción, haga clic derecho (Mac: Ctrl + Clic ) en la línea de código
en la ventana de secuencia de comandos en la que desea hacer una pausa y seleccione Establecer
punto de interrupción . IDLE resalta la línea en amarillo para indicar que se ha establecido su punto

de interrupción. Puede eliminar un punto de interrupción en cualquier momento haciendo clic derecho
en la línea con un punto de interrupción y seleccionando Borrar punto de interrupción .

Continúe y presione el botón Salir en la parte superior de la ventana de control de depuración para
desactivar el depurador por ahora. Esto no cerrará la ventana y querrás mantenerla abierta porque
la volverás a usar en un momento.

Establezca un punto de interrupción en la línea de código con la declaración print() . La ventana del
script ahora debería verse así:

173
Machine Translated by Google

7.1. Utilice la ventana de control de depuración

Ahora ejecute el script presionando F5. Al igual que antes, el panel Pila de la ventana
de control de depuración indica que el depurador se ha iniciado y está esperando
ejecutar la línea 1. Esta vez, en lugar de hacer clic en el botón Paso , haga clic en el
botón Ir y observe lo que sucede en la ventana de depuración:

El panel Pila ahora muestra el siguiente mensaje que indica que está esperando ejecutar
la línea 3:

174
Machine Translated by Google

7.1. Utilice la ventana de control de depuración

> '__main__'.<módulo>(), línea 3: print(f"i es {i} y j es {j}")

Si observa el panel Locales , verá que ambas variables i y j tienen los valores 1 y 2,
respectivamente. Al hacer clic en Ir , le indicó al depurador que ejecutara su código
continuamente hasta llegar a un punto de interrupción o al final del programa. Ahora
presione “Ir” nuevamente. La ventana de depuración ahora se ve así:

¿Ves lo que cambió? El mismo mensaje que antes se muestra en el panel Pila , lo que
indica que el depurador está esperando para ejecutar la línea 3 nuevamente. Sin
embargo, ahora los valores de las variables i y j son 2 y 4. La ventana interactiva
también muestra el resultado de ejecutar la línea con print() la primera vez.

Cada vez que presiona el botón Ir , el depurador ejecuta el código continuamente hasta
que se alcanza el siguiente punto de interrupción. Dado que establece el punto de
interrupción en la línea 3, que está dentro del bucle for , el depurador se detiene en esta
línea cada vez que pasa por el bucle.

175
Machine Translated by Google

7.2. Aplastar algunos errores

Presione Ir por tercera vez. Ahora i y j tienen los valores 3 y 6. ¿Qué crees que sucede
cuando presionas Ir una vez más? Dado que el bucle for solo se repite 3 veces, cuando
presiona Ir esta vez, el programa termina de ejecutarse.

“Arriba” y “Fuera”

El botón Over funciona como una especie de combinación de Step and Go . Pasa por
encima de una función o bucle. En otras palabras, si está a punto de ingresar a una
función con el depurador, aún puede ejecutar el código de esa función sin tener que
recorrer cada línea. El botón Over lo lleva directamente al resultado de ejecutar esa función.

Del mismo modo, si ya está dentro de una función o bucle, el botón Fuera ejecuta el
código restante dentro del cuerpo de la función o bucle y luego
pausas.

En la siguiente sección, verá algunos códigos con errores y aprenderá cómo

solucionarlos con IDLE.

Deje comentarios sobre esta sección »

7.2 Eliminar algunos errores

Ahora que se siente cómodo usando la ventana de control de depuración, echemos un
vistazo a un programa con errores.

El siguiente código define una función add_underscores() que toma una sola palabra de
objeto de cadena como argumento y devuelve una nueva cadena que contiene una
copia de la palabra con cada carácter rodeado por guiones bajos.
Por ejemplo, add_underscores("python") debería devolver "_p_y_t_h_o_n_".

Aquí está el código del error:

def agregar_guiones bajos (palabra):

nueva_palabra = "_"

para i en rango(0, len(palabra)):

176
Machine Translated by Google

7.2. Aplastar algunos errores

nueva_palabra = palabra[i] + "_"

devolver nueva_palabra

frase = "hola"
imprimir (agregar guiones bajos (frase))

Guarde y ejecute el script anterior. El resultado esperado es _h_e_l_l_o_, pero en

cambio todo lo que ve es o_, la letra "o" seguida de un guión bajo.
Si ya ve cuál es el problema con el código, no lo solucione simplemente. El objetivo de
esta sección es aprender a utilizar el depurador de IDLE para identificar el problema.
Si no ves cuál es el problema, ¡no te preocupes! Al final de esta sección, lo habrá
encontrado y podrá identificar problemas similares en otros códigos que encuentre.

Nota

Cuando se trabaja con problemas del mundo real, la depuración a menudo

puede resultar difícil y llevar mucho tiempo, y los errores pueden ser sutiles y
difíciles de identificar. Si bien esta sección analiza un error relativamente
simple, lo importante que se debe aprender es la metodología utilizada para
inspeccionar el código.

La depuración es la resolución de problemas y, a medida que adquiera más experiencia,

desarrollará sus propios enfoques. En esta sección, aprenderá un método sencillo de
cuatro pasos que le ayudará a empezar:

1. Adivina qué sección del código puede contener el error.

2. Establezca un punto de interrupción e inspeccione el código recorriendo la sección

con errores una línea a la vez, realizando un seguimiento de las variables
importantes a lo largo del camino.

3. Identifique la línea de código, si la hay, con el error y realice un cambio.

para resolver el problema.

4. Repita los pasos 1 a 3 según sea necesario hasta que el código funcione como se esperaba.

177
Machine Translated by Google

7.2. Aplastar algunos errores

Paso 1: Adivina dónde está el error

Situado
El primer paso es identificar la sección de código que probablemente contenga el
error. Es posible que al principio no puedas identificar exactamente dónde está el
error, pero generalmente puedes hacer una suposición razonable sobre qué sección
de tu código tiene un error.

Observe que el script está dividido en dos secciones distintas: una definición de
función (donde se define add_underscores() ) y un bloque de código "principal" que
define una frase variable con el valor "hola" y luego imprime el resultado de la
llamada. add_underscores(frase).

Mira la sección “principal”:

frase = "hola"

imprimir (agregar guiones bajos (frase))

¿Crees que el problema podría estar aquí? No lo parece, ¿verdad?

Todo lo relacionado con esas dos líneas de código se ve bien. Entonces, el problema
debe estar en la definición de la función:

def agregar_guiones bajos (palabra):

nueva_palabra = "_"

para i en rango(0, len(palabra)):

nueva_palabra = palabra[i] + "_"
devolver nueva_palabra

La primera línea de código dentro de la función crea una variable nueva_palabra

con el valor "_". Todo bien, por lo que podemos concluir que el problema está en
algún lugar del cuerpo del bucle for .

Paso 2: establecer un punto de interrupción e inspeccionar el código

Ahora que ha identificado dónde debe estar el error, establezca un punto de

interrupción al inicio del bucle for para que pueda rastrear exactamente lo que
sucede dentro con la ventana de control de depuración:

178
Machine Translated by Google

7.2. Aplastar algunos errores

Ahora abra la ventana de control de depuración y ejecute el script. La ejecución

aún se detiene en la primera línea que ve (que define la función).
Presione el botón "Ir" para ejecutar el código hasta encontrar el punto de
interrupción. La ventana de depuración ahora se verá así:

En este punto, el código se pausa justo antes de ingresar al bucle for en la función
add_underscores() . Observe que en el panel Locales se muestran dos variables
locales, palabra y nueva_palabra . Actualmente, palabra tiene el valor "hola" y
nueva_palabra tiene el valor "_", como se esperaba.

179
Machine Translated by Google

7.2. Aplastar algunos errores

Haga clic en el botón Paso una vez para ingresar al bucle for . La ventana de depuración cambia y
se muestra una nueva variable i con el valor 0 en el panel "Lo­cals". i es el contador usado en el
bucle for y puedes usarlo para realizar un seguimiento de qué iteración del bucle for estás viendo
actualmente:

Haga clic en Paso una vez más. Si observa el panel Locales , verá que la variable
nueva_palabra ha tomado el valor "h_":

180
Machine Translated by Google

7.2. Aplastar algunos errores

Esto no está bien. Originalmente, new_word tenía el valor "_" y en la segunda

iteración del bucle for ahora debería tener el valor "_h_". Si hace clic en Paso unas
cuantas veces más, verá que nueva_palabra se establece en e_, luego en l_, y así
sucesivamente.

Paso 3: identifique el error e intente solucionarlo

La conclusión que puede sacar en este punto es que nueva_palabra se sobrescribe
diez en cada iteración del bucle for con el siguiente carácter de la cadena "hola" y
un guión bajo. Dado que solo hay una línea de código dentro del bucle for , sabes
que el problema debe estar en el siguiente código:

nueva_palabra = palabra[i] + "_"

Míralo de cerca. Esta línea le dice a Python que obtenga el siguiente carácter de
la palabra, agregue un guión bajo al final y asigne esta nueva cadena a la variable
nueva_palabra. ¡Este es exactamente el comportamiento que has presenciado al
recorrer el bucle for !

Para solucionar el problema, debe decirle a Python que concatene la cadena

palabra[i] + "_" con el valor existente de nueva_palabra. Presione el botón “Salir”

181
Machine Translated by Google

7.2. Aplastar algunos errores

en la ventana de control de depuración, pero no cierre esa ventana todavía.

Abra la ventana del script y cambie la línea dentro del bucle for a:

nueva_palabra = nueva_palabra + palabra[i] + "_"

Paso 4: repita los pasos 1 a 3 hasta que desaparezca el error

Guarde los nuevos cambios en su script y ejecútelo nuevamente. En la ventana

Depurar, presione el botón Ir para ejecutar el código hasta el punto de interrupción.

Nota
Si cerró el depurador en el paso anterior sin hacer clic en Salir , es posible
que vea el siguiente error al volver a abrir el
Ventana de control de depuración:

Sólo puedes alternar el depurador cuando está inactivo

Asegúrese siempre de hacer clic en Ir o Salir cuando haya terminado con

una sesión de depuración en lugar de simplemente cerrar el depurador, o
podría tener problemas para volver a abrirlo. Para deshacerse de este error,
deberá cerrar IDLE y volver a abrirlo.

Al igual que antes, su script ahora está en pausa justo antes de ingresar al bucle for
en la función add_underscores() . Presione el botón Paso repetidamente y observe
lo que sucede con la variable new_word en cada iteración.
¿Qué ves ahora? ¡Éxito! ¡Todo funciona como se esperaba!

En este ejemplo, su primer intento de corregir el error funcionó, por lo que ya no

necesita repetir los pasos 1 a 3. Sin embargo, este no será siempre el caso. A veces
tendrás que repetir el proceso varias veces antes de corregir un error.

También es importante tener en cuenta que herramientas como los depuradores no

le dicen cómo corregir un error. Sólo le ayudan a identificar dónde ocurre
exactamente un problema en su código.

182
Machine Translated by Google

7.2. Aplastar algunos errores

Formas alternativas de encontrar errores en su código

La depuración puede ser complicada y llevar mucho tiempo, pero a veces es la
forma más confiable de encontrar errores que has pasado por alto. Sin embargo,
antes de abrir un depurador, a veces es más sencillo localizar errores usando
funciones print() bien ubicadas para mostrar los valores de sus variables.

Por ejemplo, en lugar de depurar el script anterior con Debug

Ventana de control, puede agregar la siguiente línea al final del bucle for en la
función add_underscores() :

imprimir(f"i = {i}; nueva_palabra = {nueva_palabra}")

El guión modificado tendría entonces este aspecto:

def agregar_guiones bajos (palabra):

nueva_palabra = "_"

para i en rango(0, len(palabra)):

nueva_palabra = palabra[i] + "_"

imprimir(f"i = {i}; nueva_palabra = {nueva_palabra}")

devolver nueva_palabra

frase = "hola"

imprimir (agregar guiones bajos (frase))

Cuando ejecuta el script, la ventana interactiva muestra el siguiente resultado:

yo = 0; nueva_palabra = h_

yo = 1; nueva_palabra = e_

yo = 2; nueva_palabra = l_

yo = 3; nueva_palabra = l_

yo = 4; nueva_palabra = o_

o_

Esto le muestra cuál es el valor de new_word en cada iteración del bucle for . La
línea final que contiene solo un guión bajo es el resultado de ejecutar
print(add_underscore(phrase)) al final del script.

183
Machine Translated by Google

7.2. Aplastar algunos errores

Al observar el resultado anterior, podría llegar a la misma conclusión a la que llegó

mientras depuraba con la ventana de control de depuración. Es decir, el problema es
que new_word se sobrescribe en cada iteración.

Muchos programadores de Python prefieren este método simple para realizar una
depuración rápida y sucia sobre la marcha. Es una técnica útil pero tiene algunas
desventajas en comparación con el depurador de IDLE.

La desventaja más importante es que la depuración con la función print() requiere que
ejecute el script completo cada vez que desee inspeccionar los valores de sus
variables. Para scripts largos, esto puede ser una enorme pérdida de tiempo en
comparación con establecer puntos de interrupción y usar el botón "Ir" en la ventana
de control de depuración.

Otra desventaja es que tendrás que recordar eliminar esas llamadas a la función print()
de tu código cuando hayas terminado de depurarlo. De lo contrario, los usuarios
pueden ver resultados innecesarios y potencialmente confusos cuando ejecuten su
programa.

El bucle de ejemplo de esta sección puede ser un buen ejemplo para ilustrar el
proceso de depuración, pero no es el mejor ejemplo de código Pythonic. El uso del
índice i indica que podría haber una mejor manera de escribir el bucle.

Una forma de mejorar este bucle es iterar directamente sobre los caracteres de la
palabra de cadena . Aquí hay una forma de hacerlo:

def agregar_guiones bajos (palabra):

nueva_palabra = "_"

para char en Word:

nueva_palabra = nueva_palabra + carácter + "_"

devolver nueva_palabra

El proceso de reescribir el código existente para que sea más limpio, más fácil de leer
y comprender, o para que cumpla con los estándares de código establecidos por un
equipo, se llama refactorización. No discutiremos mucho la refactorización en este
curso, pero es una parte esencial para escribir código de calidad profesional.

Deje comentarios sobre esta sección »

184
Machine Translated by Google

7.3. Resumen y recursos adicionales

7.3 Resumen y recursos adicionales

En este capítulo, aprendió sobre la ventana de depuración de IDLE. Tu viste
cómo inspeccionar los valores de las variables, insertar puntos de interrupción y utilizar el
, IrPasar
Botones , por encima y Fuera . También practicaste un poco la depuración de una
función que no funcionaba correctamente mediante un proceso de cuatro pasos para
identificar y eliminar errores:

1. Adivina dónde se encuentra el error.

2. Establezca un punto de interrupción e inspeccione el código.

3. Identifique el error e intente solucionarlo.

4. Repita los pasos 1 a 3 hasta que se solucione el error.

La depuración es tanto un arte como una ciencia. La única manera de dominar

¡La depuración es practicar mucho con ella!

Una forma de practicar un poco es abrir la ventana de control de depuración.

y úsalo para recorrer tu código mientras trabajas en los ejercicios y
desafíos a lo largo del resto de este libro.

Prueba interactiva
Este capítulo viene con un cuestionario en línea gratuito para verificar su
progreso de aprendizaje. Puede acceder al cuestionario usando su teléfono
o computadora en la siguiente dirección web:

realpython.com/quizzes/python­basics­7

Recursos adicionales
Para obtener más información sobre la depuración de código Python, consulte los
siguientes recursos:

• Depuración de Python con Pdb

• Recursos recomendados en realpython.com

Deje comentarios sobre esta sección »

185
Machine Translated by Google

Capítulo 8

Lógica condicional y
Flujo de control

Casi todo el código que has visto en este libro es incondicional.

Es decir, el código no toma ninguna decisión. Cada línea de código se ejecuta
en el orden en que se escribe o en el que se llaman las funciones, con
posibles repeticiones dentro de los bucles.

En este capítulo, aprenderá a escribir programas que realicen diferentes

acciones basadas en diferentes condiciones usando lógica condicional.
Combinada con funciones y bucles, la lógica condicional le permite escribir
programas complejos que manejan muchas situaciones diferentes.

En este capítulo, aprenderá cómo:

• Comparar los valores de dos o más variables.

• Escriba declaraciones if para controlar el flujo de sus programas.

• Manejar errores con try y except

• Aplicar lógica condicional para crear simulaciones simples.

¡Empecemos!

Deje comentarios sobre esta sección »

186
Machine Translated by Google

8.1. Comparar valores

8.1 Comparar valores

La lógica condicional se basa en realizar diferentes acciones dependiendo
sobre si alguna expresión, llamada condicional, es verdadera o no.
FALSO. Esta idea no es específica de las computadoras. Los humanos usan condicional.
lógica todo el tiempo para tomar decisiones.

Por ejemplo, la edad legal para adquirir bebidas alcohólicas en el

Estados Unidos tiene 21 años. La declaración “Si tiene al menos 21 años,
entonces puedes comprar una cerveza” es un ejemplo de lógica condicional. El
La frase “tienes al menos 21 años” es condicional porque puede
ser verdadero o falso.

En programación de computadoras, los condicionales a menudo toman la forma de

comparar dos valores, como determinar si un valor es mayor que
otro, o si dos valores son iguales o no entre sí. Se utiliza un conjunto estándar de
símbolos llamados comparadores booleanos para hacer
comparaciones, y es posible que la mayoría de ellas ya le resulten familiares.

La siguiente tabla describe estos comparadores booleanos:

Ejemplo de comparador booleano Significado

> a>b a mayor que b

< a <b a menos que b
>= a >= b a mayor o igual a b
<= a <= b a menor o igual a b
!= a != b a no es igual a b
== a == b a igual a b

El término booleano se deriva del apellido del inglés

El matemático George Boole, cuyos trabajos ayudaron a sentar las bases de la
informática moderna. En honor a Boole, la lógica condicional es
a veces se llama lógica booleana, y los condicionales a veces se
llamadas expresiones booleanas.

También existe un tipo de datos fundamental llamado booleano o bool para

short, que sólo puede tener uno de dos valores. En Python, estos valores

187
Machine Translated by Google

8.1. Comparar valores

se denominan convenientemente Verdadero y Falso:

>>> tipo(Verdadero)
<clase 'bool'>

>>> tipo(Falso)
<clase 'bool'>

Tenga en cuenta que Verdadero y Falso comienzan con letras mayúsculas.

El resultado de evaluar un condicional es siempre un valor booleano:

>>> 1 == 1

Verdadero

>>> 3 > 5

FALSO

En el primer ejemplo, dado que 1 es igual a 1, el resultado de 1 == 1 es Verdadero. En el

segundo ejemplo, 3 no es mayor que 5, por lo que el resultado es Falso.

Importante

Un error común al escribir condicionales es usar como en lugar de ==, para probar
no . si dos valores del operador de signo =, son iguales o

Afortunadamente, Python generará un error de sintaxis si se encuentra este error,

por lo que lo sabrá antes de ejecutar su programa.

Puede resultarle útil pensar que los comparadores booleanos plantean una pregunta sobre
dos valores. a == b pregunta si a y b tienen el mismo valor o no . Del mismo modo, a != b
pregunta si a y b tienen valores diferentes.

Las expresiones condicionales no se limitan a comparar números. También puede comparar

valores como cadenas:

188
Machine Translated by Google

8.1. Comparar valores

>>> "un" == "un"

Verdadero

>>> "a" == "b"

FALSO

>>> "a" < "b"

Verdadero

>>> "a" > "b"

FALSO

Los dos últimos ejemplos anteriores pueden parecerle divertidos. ¿Cómo podría
una cuerda ser mayor o menor que otra?

Los comparadores < y > representan las nociones de mayor que y menor que
cuando se usan con números, pero de manera más general representan la
noción de orden. En este sentido, "a" < "b" comprueba si la cadena "a" va antes
de la cadena "b". Pero, ¿cómo se ordenan las cuerdas?

En Python, las cadenas están ordenadas lexicográficamente, lo cual es una

forma elegante de decir que están ordenadas tal como aparecerían en un
diccionario. Por lo tanto, puede pensar que "a" < "b" pregunta si la letra a va
antes de la letra b en el diccionario.

El orden lexicográfico se extiende a cadenas con dos o más caracteres al

observar cada letra componente de la cadena:

>>> "manzana" < "astronauta"

Verdadero

>>> "belleza" > "verdad"

FALSO

Dado que las cadenas pueden contener caracteres distintos de las letras del
alfabeto, el orden debe extenderse también a esos otros caracteres.

No entraremos en detalles sobre cómo son los caracteres distintos de las letras.

189
Machine Translated by Google

8.2. Añade algo de lógica

ordenado. En la práctica, los comparadores < y > se utilizan con mayor frecuencia con
números, no con cadenas.

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos adicionales
en línea en realpython.com/python­basics/resources.

1. Para cada una de las siguientes expresiones condicionales, adivina si su evaluación

es Verdadera o Falsa. Luego escríbalos en la ventana interactiva para verificar
sus respuestas:
1 <= 1
1 != 1
1 != 2

"bueno" != "malo"
"bueno" != "Bueno"
123 == "123"

2. Para cada una de las siguientes expresiones, complete el espacio en blanco

(indicado por __) con un comparador booleano apropiado para que la expresión
se evalúe como Verdadera:
3 __ 4
10 __ 5

"jack" __ "jill"
42 __ "42"

Deje comentarios sobre esta sección »

8.2 Agregue algo de lógica

Además de los comparadores booleanos, Python tiene palabras clave especiales

llamadas operadores lógicos que pueden usarse para combinar expresiones booleanas.
Hay tres operadores lógicos: y, o, y no.

Los operadores lógicos se utilizan para construir expresiones lógicas compuestas.

En su mayoría, estos tienen significados similares a su significado en el idioma inglés,
aunque las reglas respecto a su uso en Python son mucho más precisas.

190
Machine Translated by Google

8.2. Añade algo de lógica

La palabra clave y
Considere las siguientes declaraciones:

1. Los gatos tienen cuatro patas.

2. Los gatos tienen cola.

En general, ambas afirmaciones son ciertas.

Cuando combinamos estas dos afirmaciones usando y, la frase resultante “los gatos tienen cuatro
patas y cola” también es una afirmación verdadera.
Si se niegan ambas afirmaciones, la afirmación compuesta “los gatos no tienen cuatro patas y los
gatos no tienen cola” es falsa.

Incluso cuando mezclamos y combinamos afirmaciones falsas y verdaderas, la afirmación compuesta

es falsa. “Los gatos tienen cuatro patas y los gatos no tienen cola” y “los gatos no tienen cuatro patas
y los gatos tienen cola” son ambas falsas.
declaraciones.

Cuando dos enunciados P y Q se combinan con y, el valor de verdad del enunciado compuesto “P y

Q” es verdadero si y sólo si tanto P como Q son verdaderos.

El operador and de Python funciona exactamente de la misma manera. Aquí hay cuatro ejemplos
de declaraciones compuestas con y:

>>> 1 < 2 y 3 < 4 # Ambos son verdaderos

Verdadero

Ambas afirmaciones son verdaderas, por lo que la combinación también es verdadera.

>>> 2 < 1 y 4 < 3 # Ambos son falsos

FALSO

Ambas afirmaciones son falsas, por lo que su combinación también es falsa.

>>> 1 < 2 y 4 < 3 # La segunda afirmación es falsa

FALSO

1 <2 es Verdadero, pero 4 <3 es Falso, por lo que su combinación es Falsa.

191
Machine Translated by Google

8.2. Añade algo de lógica

>>> 2 < 1 y 3 < 4 # La primera afirmación es falsa

FALSO

2 <1 es falso y 3 <4 es verdadero, por lo que su combinación es falsa.

La siguiente tabla resume las reglas para el operador y :

Combinación de uso y resultado

Verdadero y verdadero Verdadero

Verdadero y falso FALSO

Falso y verdadero FALSO

Falso y Falso FALSO

Puede probar cada una de estas reglas en la ventana interactiva:

>>> Verdadero y Verdadero

Verdadero

>>> Verdadero y Falso

FALSO

>>> Falso y Verdadero

FALSO

>>> Falso y Falso

FALSO

La palabra clave o
Cuando usamos la palabra "o" en una conversación cotidiana, a veces nos
referimos a una o exclusiva. Es decir, sólo la primera opción o la segunda opción
pueden ser verdaderas.

Por ejemplo, la frase “Puedo quedarme o puedo irme” utiliza la exclusiva o.

No puedo quedarme e irme al mismo tiempo. Sólo una de estas opciones puede ser cierta.

En Python, la palabra clave o es inclusiva. Es decir, si P y Q son dos ex­

192
Machine Translated by Google

8.2. Añade algo de lógica

expresiones, la afirmación “P o Q” es verdadera si se cumple alguna de las siguientes

verdadero:

1. P es verdadera

2. Q es verdadera

3. Tanto P como Q son verdaderas

Veamos algunos ejemplos usando comparaciones numéricas:

>>> 1 < 2 o 3 < 4 # Ambos son verdaderos

Verdadero

>>> 2 < 1 o 4 < 3 # Ambos son falsos

FALSO

>>> 1 < 2 o 4 < 3 # La segunda afirmación es falsa

Verdadero

>>> 2 < 1 o 3 < 4 # La primera afirmación es falsa

Verdadero

Tenga en cuenta que si alguna parte de una declaración compuesta es Verdadera,

incluso si la otra parte es Falsa, el resultado siempre es Verdadero . La siguiente
tabla resume estos resultados:

Combinación usando o Resultado

Verdadero o Verdadero Verdadero

Verdadero o falso Verdadero

Falso o Verdadero Verdadero

Falso o Falso FALSO

Nuevamente, puedes verificar todo esto en la ventana interactiva:

>>> Verdadero o Verdadero

Verdadero

193
Machine Translated by Google

8.2. Añade algo de lógica

>>> Verdadero o Falso

Verdadero

>>> Falso o Verdadero

Verdadero

>>> Falso o Falso

FALSO

La palabra clave no
La palabra clave not invierte el valor de verdad de una sola expresión:

Uso de no resultado

no es verdad FALSO

no falso verdadero

Puedes verificar esto en la ventana interactiva:

>>> no es cierto

FALSO

>>> no es falso

Verdadero

Sin embargo , una cosa a tener en cuenta es que no siempre se comporta de la

manera esperada cuando se combina con comparadores como ==. Por ejemplo,
not True == False devuelve True, pero False == not True generará un error:

>>> no es cierto == falso

Verdadero

>>> Falso == no verdadero

Archivo "<stdin>", línea 1

194
Machine Translated by Google

8.2. Añade algo de lógica

Falso == no verdadero
^

Error de sintaxis: sintaxis invalida

Esto sucede porque Python analiza los operadores lógicos según la precedencia
de operadores, al igual que los operadores aritméticos tienen un orden de
precedencia en las matemáticas cotidianas.

El orden de precedencia de los operadores lógicos y booleanos, de mayor a

menor, se describe en la siguiente tabla. Los operadores de la misma fila tienen
la misma prioridad.

Orden de precedencia del operador (de mayor a menor)

<, <=, ==, >=, >

no
y
o

Mirando nuevamente la expresión False == not True, not tiene una precedencia
menor que == en el orden de las operaciones. Esto significa que cuando Python
evalúa False == not True, primero intenta evaluar False == not , que es
sintácticamente incorrecto.

Puede evitar SyntaxError rodeando not True entre paréntesis.

ses:

>>> Falso == (no verdadero)

Verdadero

Agrupar expresiones entre paréntesis es una excelente manera de aclarar qué

operadores pertenecen a qué parte de una expresión compuesta.

Construyendo expresiones complejas

Puede combinar las palabras clave and, or y not con Verdadero y Falso para crear
expresiones más complejas. A continuación se muestra un ejemplo de una
expresión más compleja:

195
Machine Translated by Google

8.2. Añade algo de lógica

Verdadero y no (1 != 1)

¿Cuál crees que es el valor de esta expresión?

Para averiguarlo, divide la expresión comenzando en el extremo derecho. 1 != 1 es

Falso, ya que 1 tiene el mismo valor que él mismo. Entonces puedes simplificar la
expresión anterior de la siguiente manera:

Verdadero y no (Falso)

Ahora bien, no (Falso) es lo mismo que no Falso, que es Verdadero. Entonces

puedes simplificar la expresión anterior una vez más:

Verdadero y verdadero

Finalmente, Verdadero y Verdadero es simplemente Verdadero. Entonces, después de algunos pasos, puede
ver que Verdadero y no (1! = 1) se evalúa como Verdadero.

Cuando se trabaja con expresiones complicadas, la mejor estrategia es comenzar

con la parte más complicada de la expresión y desarrollarla desde allí.

Por ejemplo, intente evaluar la siguiente expresión:

("A" != "A") o no (2 >= 3)

Comience evaluando las dos expresiones entre paréntesis. "A" != "A" es falso porque
"A" es igual a sí mismo. 2 >= 3 también es falso porque 2 es menor que 3. Esto le
da la siguiente expresión equivalente, pero más simple:

(Falso) o no (Falso)

Dado que not tiene mayor precedencia que o, la expresión anterior equivale a lo
siguiente:

Falso o (no falso)

not False es True, así que puedes simplificar la expresión una vez más:

196
Machine Translated by Google

8.2. Añade algo de lógica

Falso o Verdadero

Finalmente, dado que cualquier expresión compuesta con o es Verdadera si cualquiera

de las expresiones a la izquierda o derecha de o es Verdadera, puedes concluir que
("A" != "A") o no (2 >= 3) es Verdadero.

Agrupar expresiones en una declaración condicional compuesta con paréntesis

mejora la legibilidad. Sin embargo, a veces se requieren paréntesis para producir el
valor esperado.

Por ejemplo, tras la primera inspección, puede esperar que lo siguiente dé como
resultado Verdadero, pero en realidad devuelve Falso:

>>> Verdadero y Falso == Verdadero y Falso

FALSO

La razón por la que esto es Falso es que el operador == tiene una precedencia mayor
que y, por lo que Python interpreta la expresión como Verdadero y (Falso ==
Verdadero) y Falso. Dado que False == True es False, esto es equivalente a True y
False y False, que se evalúa como False.

A continuación se muestra cómo agregar paréntesis para que la expresión se evalúe

como Verdadera:

>>> (Verdadero y Falso) == (Verdadero y Falso)

Verdadero

Los operadores lógicos y los comparadores booleanos pueden resultar confusos la

primera vez que los encuentra, así que si no cree que el material de esta sección le
resulte natural, ¡no se preocupe!

Con un poco de práctica, podrás entender lo que está sucediendo y crear tus propias
declaraciones condicionales compuestas cuando las necesites.

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos adicionales
en línea en realpython.com/python­basics/resources.

197
Machine Translated by Google

8.3. Controle el flujo de su programa

1. Calcule cuál será el resultado (Verdadero o Falso) al evaluar las siguientes

expresiones, luego escríbalas en la ventana interactiva para verificar sus respuestas:

(1 <= 1) y (1! = 1)

no (1 != 2)

("bueno"! = "malo") o Falso

("bueno" != "Bueno") y no (1 == 1)

2. Agregue paréntesis cuando sea necesario para que cada una de las siguientes
expresiones se evalúe como Verdadera:
Falso == no verdadero
Verdadero y Falso == Verdadero y Falso

no es cierto y "A" == "B"

Deje comentarios sobre esta sección »

8.3 Controle el flujo de su programa

Ahora que podemos comparar valores entre sí con comparadores booleanos y crear
declaraciones condicionales complejas con operadores lógicos, podemos agregar algo
de lógica a nuestro código para que realice diferentes acciones para diferentes
condiciones.

La declaración si
Una declaración if le dice a Python que solo ejecute una parte del código si se cumple
una condición.

Por ejemplo, la siguiente declaración if imprimirá 2 y 2 es 4 si el condicional 2 + 2 == 4

es Verdadero:

si 2 + 2 == 4:

imprimir("2 y 2 son 4")

En inglés, puedes leer esto como "si 2 + 2 es 4, entonces imprime la cadena '2 y 2 es 4'".

Al igual que los bucles while , una declaración if tiene tres partes:

198
Machine Translated by Google

8.3. Controle el flujo de su programa

1. La palabra clave if

2. Una condición de prueba, seguida de dos puntos.

3. Un bloque de código sangrado que se ejecuta si la condición de prueba es

Verdadero

En el ejemplo anterior, la condición de prueba es 2 + 2 == 4. Dado que esta expresión es

Verdadera, al ejecutar la instrucción if en IDLE se muestra el
el texto 2 y 2 es 4.

Si la condición de prueba es Falsa (por ejemplo, 2 + 2 == 5), Python omite el bloque de

código sangrado y continúa la ejecución en la siguiente línea sin sangría.

Por ejemplo, la siguiente declaración if no imprime nada:

si 2 + 2 == 5:
print("¿Es este el universo espejo?")

¡Un universo donde 2 + 2 == 5 es Verdadero sería bastante extraño!

Nota
Dejar fuera los dos puntos (:) después de la condición de prueba en una
declaración if genera un error de sintaxis:

>>> si 2 + 2 == 4
Error de sintaxis: sintaxis invalida

Una vez que se ejecuta el bloque de código sangrado en una declaración if , Python
continuará ejecutando el resto del programa.

Considere el siguiente guión:

grado = 95

si nota >= 70:

print("¡ Aprobaste la clase!")

199
Machine Translated by Google

8.3. Controle el flujo de su programa

print("Gracias por asistir.")

La salida se ve así:

¡Pasaste la clase!
Gracias por atender.

Dado que la calificación es 95, la condición de prueba calificación >= 70 es

Verdadero y la cadena "¡Aprobaste la clase!" está impreso. Luego se ejecuta el
resto del código y "Gracias por asistir". está impreso.

Si cambia el valor de la calificación a 40, el resultado se verá así:

Gracias por atender.

La línea print("Gracias por asistir") se ejecuta independientemente de que la

calificación sea mayor o igual a 70 porque está después del bloque de código
sangrado en la declaración if .

Un estudiante reprobado no sabrá que ha reprobado si todo lo que ve en su

código es el texto "Gracias por asistir".

Agreguemos otra declaración if para decirle al estudiante que no aprobó si su

calificación es inferior a 70:

grado = 40

si la nota >= 70:

print("¡Aprobaste la clase!")

si grado < 70:

print(" No pasaste la clase :()"

print("Gracias por asistir.")

La salida ahora se ve así:

200
Machine Translated by Google

8.3. Controle el flujo de su programa

No pasaste la clase :(
Gracias por atender.

En inglés, podemos describir un caso alternativo con la palabra "other­wise". Por

ejemplo, “Si tu calificación es 70 o más, apruebas la clase.
De lo contrario, no aprobarás la clase”.

Afortunadamente, existe una palabra clave que hace para Python lo que hace la
palabra "de lo contrario" en inglés.

La palabra clave else

La palabra clave else se usa después de una declaración if para ejecutar algún código
solo si la condición de prueba de la declaración if es Falsa.

El siguiente script usa else para acortar el código del script anterior para mostrar si un
estudiante aprobó o no una clase:

grado = 40

si nota >= 70:

print("¡ Aprobaste la clase!")
demás:

print(" No pasaste la clase :()"

print("Gracias por asistir.")

En inglés, las declaraciones if y else juntas dicen: "Si la calificación es al menos 70,
imprima la cadena "¡Aprobaste la clase!"; de lo contrario, imprima la cadena "No
pasaste la clase :(".

Observe que la palabra clave else no tiene condición de prueba y va seguida de dos
puntos. No se necesita ninguna condición, porque se ejecuta para cualquier condición
que falle la condición de prueba de la declaración if .

201
Machine Translated by Google

8.3. Controle el flujo de su programa

Importante

Dejar fuera los dos puntos (:) de la palabra clave else generará un
Error de sintaxis:

>>> si 2 + 2 == 5:
... print("¿Quién rompió mis matemáticas?")
... demás
Error de sintaxis: sintaxis invalida

El resultado del script anterior es:

No pasaste la clase :(
Gracias por atender.

La línea que imprime "Gracias por asistir". todavía se ejecuta, incluso si se ejecuta el bloque
de código sangrado después de else .

Las palabras clave if y else funcionan bien juntas si solo necesita probar una condición con
exactamente dos estados.

A veces es necesario comprobar tres o más condiciones. Para eso tu

utilizar elif.

La palabra clave elif

La palabra clave elif es la abreviatura de "else if" y puede usarse para agregar condiciones
adicionales después de una declaración if .

Al igual que las declaraciones if , las declaraciones elif tienen tres partes:

1. La palabra clave elif

2. Una condición de prueba, seguida de dos puntos.

3. Un bloque de código con sangría que se ejecuta si la condición de prueba evalúa

equivale a verdadero

202
Machine Translated by Google

8.3. Controle el flujo de su programa

Importante

Dejar los dos puntos (:) al final de una declaración elif genera
un error de sintaxis:

>>> si 2 + 2 == 5:
... print("¿Quién rompió mis matemáticas?")
... elif 2 + 2 == 4
Error de sintaxis: sintaxis invalida

El siguiente script combina if, elif y else para imprimir la calificación con letras que
obtuvo un estudiante en una clase:

grado = 85 # 1

si nota >= 90: # 2

print(" Aprobaste la clase con una A.")
calificación elif >= 80: # 3
print(" Aprobaste la clase con una B.")
grado elif >= 70: # 4
print(" Aprobaste la clase con una C.")
más: # 5
print(" No pasaste la clase :()"

print("Gracias por asistir.") # 6

Tanto la calificación >= 80 como la calificación >= 70 son Verdaderas cuando la calificación es 85,
por lo que es de esperar que se ejecuten ambos bloques elif en las líneas 3 y 4 .

Sin embargo, sólo se ejecuta el primer bloque para el cual la condición de prueba
es Verdadera . Todos los bloques elif y else restantes se omiten, por lo que la
ejecución del script produce el siguiente resultado:

Pasaste la clase con una B.

Gracias por asistir.

Analicemos la ejecución del script paso a paso:

203
Machine Translated by Google

8.3. Controle el flujo de su programa

1. A la calificación se le asigna el valor 85 en la línea marcada con 1.

2. calificación >= 90 es Falso, por lo que se omite la declaración if marcada con 2 .

3. calificación >= 80 es Verdadero, por lo que se ejecuta el bloque debajo de la declaración

elif en la línea 3 y "Aprobaste la clase con una B". está impreso.

4. Se omiten las declaraciones elif y else en las líneas 4 y 5 , ya que

Se cumplió la condición para la declaración elif en la línea 3 .

5. Finalmente se ejecuta la línea 6 y “Gracias por asistir”. está impreso.

Las palabras clave if, elif y else son algunas de las palabras clave más utilizadas en el
lenguaje Python. Le permiten escribir código que responde a diferentes condiciones con
diferente comportamiento.

La declaración if le permite resolver problemas más complejos que el código sin ninguna
lógica condicional. ¡Incluso puedes anidar una declaración if dentro de otra para escribir
código que maneje una lógica tremendamente compleja!

Declaraciones if anidadas
Al igual que los bucles for y while se pueden anidar uno dentro de otro, se anida una
declaración if dentro de otra para crear una toma de decisiones complicada.
estructuras.

Considere el siguiente escenario. Dos personas practican un deporte uno contra otro. Debes
decidir cuál de los dos jugadores gana dependiendo de las puntuaciones de los jugadores y
del deporte que practican:

• Si los dos jugadores juegan baloncesto, gana el jugador con mayor puntuación.

• Si los dos jugadores están jugando al golf, entonces el jugador con el menor
la puntuación gana.

• En cualquiera de los deportes, si los dos puntajes son iguales, el juego es un empate.

El siguiente programa resuelve esto usando declaraciones if anidadas :

204
Machine Translated by Google

8.3. Controle el flujo de su programa

deporte = input("Ingrese un deporte: ")

p1_score = int(input("Ingrese la puntuación del jugador 1: "))

p2_score = int(input("Ingrese la puntuación del jugador 2: "))

#1

si sport.lower() == "baloncesto":

si puntuación_p1 == puntuación_p2:

print("El juego es un empate.")

elif puntuación_p1 > puntuación_p2:

print("El jugador 1 gana.")

demás:

print("El jugador 2 gana.")

#2

elif deporte.inferior() == "golf":

si puntuación_p1 == puntuación_p2:

print("El juego es un empate.")

elif puntuación_p1 < puntuación_p2:

print("El jugador 1 gana.")

demás:

print("El jugador 2 gana.")

#3

demás:

print("Deporte desconocido")

Este programa primero le pide al usuario que ingrese un deporte y los puntajes de dos
jugadores.

En (#1), la cadena asignada al deporte se convierte a minúsculas usando .lower() y se

compara con la cadena "baloncesto". Esto garantiza que las entradas del usuario como
"Baloncesto" o "Baloncesto" se interpreten como el mismo deporte.

Luego se comparan las puntuaciones de los jugadores. Si son iguales, el juego es un

empate. Si la puntuación del jugador 1 es mayor que la del jugador 2, entonces el
jugador 1 gana el partido de baloncesto. De lo contrario, el jugador 2 gana la pelota.
juego.

205
Machine Translated by Google

8.3. Controle el flujo de su programa

En (#2), la cadena asignada al deporte se convierte a ganancia en minúsculas y

comparado con la cuerda "golf". Luego se verifican las puntuaciones de los jugadores.
de nuevo. Si las dos puntuaciones son iguales, el juego es un empate. Si el jugador 1
la puntuación es menor que la puntuación del jugador 2, entonces el jugador 1 gana. De lo contrario,
El jugador 2 gana.

Finalmente, en (#3), si la variable deportiva se asigna a una cadena distinta de

"baloncesto" o "golf", se muestra el mensaje "Deporte desconocido" .

La salida del script depende del valor de entrada. Aquí hay una muestra
ejecución utilizando el "baloncesto" como deporte:

Introduzca un deporte: baloncesto

Puntuación del jugador 1: 75

Puntuación del jugador 2: 64

El jugador 1 gana.

Aquí está el resultado con las mismas puntuaciones de los jugadores y el deporte cambiado.
a "golf":

Introduzca un deporte: golf

Puntuación del jugador 1: 75

Puntuación del jugador 2: 64

El jugador 2 gana.

Si ingresa algo además de baloncesto o golf para el deporte, el programa muestra Deporte
desconocido.

En total, hay siete formas posibles en las que se puede ejecutar el programa,
los cuales se describen en la siguiente tabla:

Deporte Valores de puntuación

"baloncesto" puntuación_p1 == puntuación_p2

"baloncesto" puntuación_p1 > puntuación_p2

"baloncesto" puntuación_p1 < puntuación_p2

"golf" puntuación_p1 == puntuación_p2

"golf" puntuación_p1 > puntuación_p2

"golf" puntuación_p1 < puntuación_p2

206
Machine Translated by Google

8.3. Controle el flujo de su programa

Deporte Valores de puntuación

todo lo demás cualquier combinación

Las declaraciones if anidadas pueden crear muchas formas posibles de ejecutar su código. Si tiene
muchas declaraciones if profundamente anidadas (más de dos niveles), entonces la cantidad de
formas posibles en que se puede ejecutar el código crece rápidamente.

Nota

La complejidad que resulta del uso de declaraciones if profundamente anidadas puede

dificultar la predicción de cómo se comportará su programa en determinadas condiciones.

Por esta razón, generalmente no se recomiendan las declaraciones if anidadas.

Veamos cómo simplificamos el programa anterior eliminando anidados.

si declaraciones.

Primero, independientemente del deporte, el juego es un empate si p1_score es igual a p2_score.

Entonces, podemos mover la verificación de igualdad de las declaraciones if anidadas en cada
deporte para hacer una declaración if única :

if p1_score == p2_score:
print("El juego es un empate.")

elif sport.lower() == "baloncesto":

si p1_score > p2_score:
print("El jugador 1 gana.")
demás:

print("El jugador 2 gana.")

elif sport.lower() == "golf": si p1_score

< p2_score:
print("El jugador 1 gana.")
demás:

207
Machine Translated by Google

8.3. Controle el flujo de su programa

print("El jugador 2 gana.")

demás:

print("Deporte desconocido.")

Ahora sólo hay seis formas en que se puede ejecutar el programa.

Todavía quedan bastantes maneras. ¿Se te ocurre alguna forma de simplificar el programa?

He aquí una manera de simplificarlo. El jugador 1 gana si el deporte es baloncesto y su

puntuación es mayor que la del jugador 2, o si el deporte es golf y su puntuación es menor
que la del jugador 2.

Podemos describir esto con expresiones condicionales compuestas:

deporte = deporte.inferior()
p1_wins_basketball = (deporte == "baloncesto") y (p1_score > p2_score)
p1_wins_golf = (deporte == "golf") y (p1_score < p2_score) p1_wins =
jugador1_gana_basketball o jugador1_gana_golf

Este código es bastante denso, así que veámoslo paso a paso.

Primero, la cadena asignada al deporte se convierte a minúsculas para que podamos

comparar el valor con otras cadenas sin preocuparnos por errores debidos a mayúsculas y
minúsculas.

En la siguiente línea, tenemos una estructura que puede parecer un poco extraña.
Hay un operador de asignación (=) seguido de una expresión con el comparador de igualdad
(==). Esta línea evalúa la siguiente expresión lógica compuesta y asigna su valor a la variable
p1_wins_basketball :

(deporte == "baloncesto") y (p1_score > p2_score)

Si el deporte es "baloncesto" y la puntuación del jugador 1 es mayor que la del jugador 2,

entonces p1_wins_basketball es Verdadero.

A continuación, se realiza una operación similar para la variable p1_wins_golf . si puntuación

208
Machine Translated by Google

8.3. Controle el flujo de su programa

es "golf" y la puntuación del jugador 1 es menor que la puntuación del jugador 2, entonces p1_­
wins_golf es Verdadero.

Finalmente, p1_wins será Verdadero si el jugador 1 gana el juego de

baloncesto o de golf, y será Falso en caso contrario.

Usando este código, puedes simplificar bastante el programa:

si puntuación_p1 == puntuación_p2:

print("El juego es un empate.")

elif (sport.lower() == "baloncesto") o (sport.lower() == "golf"):
deporte = deporte.inferior()
p1_wins_basketball = (deporte == "baloncesto") y (p1_score > p2_score)
p1_wins_golf = (deporte == "golf") y (p1_score < p2_score) p1_wins =
p1_wins_basketball o p1_wins_golf
si p1_gana:
print("El jugador 1 gana.")
demás:

print("El jugador 2 gana.")

demás:

print("Deporte desconocido")

En esta versión revisada del programa, solo hay cuatro formas en que se
puede ejecutar el programa y el código es más fácil de entender.

Anidadas si las declaraciones a veces son necesarias. Sin embargo, si se

encuentra escribiendo muchas declaraciones if anidadas , podría ser una
buena idea detenerse y pensar en cómo podría simplificar su código.

Ejercicios de revisión

Puede encontrar las soluciones a estos ejercicios y muchos otros recursos

adicionales en línea en realpython.com/python­basics/resources.

1. Escriba un script que solicite al usuario que ingrese una palabra usando la función
input() , almacene esa entrada en una variable y luego muestre si la longitud de esa
cadena es menor de 5 caracteres, mayor de 5 caracteres o igual a 5 caracteres usando
un conjunto de if, elif

209
Machine Translated by Google

8.4. Desafío: Encuentra los factores de un número

y más declaraciones.

Deje comentarios sobre esta sección »

8.4 Desafío: Encuentra los factores de

un número
Un factor de un entero positivo n es cualquier entero positivo menor o igual que n que
divide a n sin resto.

Por ejemplo, 3 es factor de 12 porque 12 dividido por 3 es 4, sin resto. Sin embargo, 5 no
es factor de 12 porque 5 entra en 12 dos veces y el resto es 2.

Escriba un script factores.py que le pida al usuario que ingrese un número entero positivo
y luego imprima los factores de ese número. Aquí hay una ejecución de muestra del
programa con salida:

Introduzca un número entero positivo: 12

1 es un factor de 12
2 es un factor de 12
3 es un factor de 12
4 es un factor de 12
6 es un factor de 12
12 es un factor de 12

Sugerencia: recuerde del Capítulo 5 que puede usar el operador % para obtener el resto
de dividir un número por otro.

Puede encontrar las soluciones a este desafío de código y muchos otros recursos
adicionales en línea en realpython.com/python­basics/resources.

Deje comentarios sobre esta sección »

210
Machine Translated by Google

8.5. Romper con el patrón

8.5 Romper con el patrón

En el Capítulo 6 aprendiste cómo repetir un bloque de código muchas veces usando
un bucle for o while . Los bucles son útiles para realizar una tarea repetitiva y para
aplicar algún procesamiento a muchas entradas diferentes.

La combinación de declaraciones if con bucles for abre técnicas poderosas para

controlar cómo se ejecuta el código.

En esta sección, aprenderá a escribir declaraciones if anidadas en bucles for y

conocerá dos palabras clave ( interrumpir y continuar ) que le permiten controlar con
mayor precisión el flujo de ejecución a través de un bucle.

declaraciones if y bucles for

El bloque de código en un bucle for es como cualquier otro bloque de código.
Eso significa que puede anidar una declaración if en un bucle for tal como puede
hacerlo en cualquier otro lugar de su código.

El siguiente ejemplo utiliza un bucle for con una instrucción if para calcular y mostrar
la suma de todos los números enteros pares menores de 100:

suma_de_pares = 0

para n en el rango (1, 100):

si n % 2 == 0:

suma_de_pares = suma_de_pares + n

imprimir(suma_de_eventos)

Primero, la variable sum_of_evens se inicializa a 0. Luego, el programa recorre los

números del 1 al 99 y suma los valores pares a sum_of_evens. El valor final de
sum_of_evens es 2450.

211
Machine Translated by Google

8.5. Romper con el patrón

romper

La palabra clave break le dice a Python que literalmente salga de un bucle. Es decir,
el ciclo se detiene por completo y se ejecuta cualquier código posterior al ciclo.

Por ejemplo, el siguiente código recorre los números del 0 al 3, pero detiene el ciclo
cuando se encuentra el número 2 :

para n en el rango (0, 4):

si norte == 2:

romper

imprimir(n)

print(f"Terminado con n = {n}")

Sólo los dos primeros números se imprimen en el resultado:

Terminado con n = 2

continuar

La palabra clave continuar se utiliza para omitir cualquier código restante en el

cuerpo del bucle y continuar con la siguiente iteración.

Por ejemplo, el siguiente código recorre los números del 0 al 3, imprimiendo cada
número a medida que avanza, pero omite el número 2:

para i en el rango (0, 4):

si yo == 2:

continuar

imprimir(yo)

print(f"Terminado con i = {i}")

Todos los números excepto 2 se imprimen en el resultado:

212
Machine Translated by Google

8.5. Romper con el patrón

0
1
3
Terminado con i = 3

Nota

Siempre es una buena idea dar nombres cortos pero descriptivos a las
variables que faciliten saber lo que se supone que deben representar.

Las letras i, j y k son excepciones porque son muy comunes en

programación.

Estas letras casi siempre se usan cuando necesitamos un número

"desechable" únicamente con el fin de llevar la cuenta mientras trabajamos
en un bucle.

En resumen, la palabra clave break se usa para detener un bucle si se cumple una
determinada condición, y la palabra clave continue se utiliza para omitir una iteración
de un bucle cuando se cumple una determinada condición.

para...si no Bucles
Los bucles pueden tener su propia cláusula else en Python, aunque esta
estructura no se usa con mucha frecuencia.

Veamos un ejemplo:

frase = "marca el lugar"

para personaje en frase:

si carácter == "X":
romper
demás:

print("No había ninguna 'X' en la frase")

El bucle for en este ejemplo recorre la frase de caracteres "marca

213
Machine Translated by Google

8.5. Romper con el patrón

el lugar" y se detiene si se encuentra la letra "X" .

Si ejecuta el código del ejemplo, verá que No había ninguna 'X' en la frase
impresa en la consola.

Ahora intenta cambiar la frase a la cadena "X marca el lugar". Cuando ejecuta el mismo
código con esta frase, no hay resultado. ¿Qué está sucediendo?

Cualquier código en el bloque else después de un bucle for se ejecuta solo si

el bucle for se completa sin encontrar una instrucción break .

Entonces, cuando ejecuta el código con frase = "marca el lugar", la línea de

código que contiene la declaración break nunca se ejecuta ya que no hay
ningún carácter X en la frase, lo que significa que se ejecuta el bloque else y
la cadena " No había ninguna 'X' en la frase" .

Por otro lado, cuando ejecuta el código con la frase = "X marca el lugar", la
línea que contiene la instrucción break se ejecuta, por lo que el bloque else
nunca se ejecuta y no se muestra ningún resultado.

A continuación se muestra un ejemplo práctico que le brinda a un usuario tres intentos para ingresar

una contraseña:

para n en el rango(3):
contraseña = entrada("Contraseña: ")
si contraseña == "Yo<3Bieber":
romper

print("La contraseña es incorrecta.")

demás:

print("Actividad sospechosa. Las autoridades han sido alertadas.")

Este ejemplo recorre el número del 0 al 2. En cada iteración, se solicita al

usuario que ingrese una contraseña. Si la contraseña ingresada es correcta,
se utiliza break para salir del ciclo. De lo contrario, se le dice al usuario que la
contraseña es incorrecta y se le da otro intento.

Después de tres intentos fallidos, el bucle for termina sin ejecutar la línea de
código que contiene break. En ese caso, lo demás

214