PROGRAMAR EN PYTHON

pág. 1
 CONTENIDO Pág.

MODULO 1: INTRODUCCIÓN A PYTHON

INTRODUCCIÓN AL CURSO ……………………………………………………………………………………….. 9
¿Cómo se utiliza Python en el mundo real? ………………………………………………………………. 11
Programa del curso …………………………………………………………………………………………………… 13
Cómo tener éxito en este curso ………………………………………………………………………………… 16
BIENVENIDO A LA PROGRAMACIÓN EN PYTHON ………………………………………………………. 19
Introducción a la programación ………………………………………………………………………………… 19
¿Por qué elegir Python? ……………………………………………………………………………………………. 25
Dependencias necesarias ………………………………………………………………………………………….. 36
Comprobación del entorno para Windows ………………………………………………………………… 37
Ejecutar código - Línea de comandos VS IDE …………………………………………………………….. 39
Sintaxis de Python, los espacios importan …………………………………………………………………. 43
"Cheatsheet" de sintaxis de Python …………………………………………………………………………… 46
Comentar el código …………………………………………………………………………………………………… 48
Variables …………………………………………………………………………………………………………………… 50
Tipos de datos básicos ……………………………………………………………………………………………… 55
Cadenas ……………………………………………………………………………………………………………………. 61
Tipos de datos básicos y función "Cheatsheet" ………………………………………………………… 66
Fundición de tipo …………………………………………………………………………………………………….. 70
Entrada de usuario, salida de consola ………………………………………………………………………. 73
Tipo de fundición, un aspecto más profundo ……………………………………………………………. 80
Tareas de programación: Escribir entrada de fundición ……………………………………………. 84
Comprobación de conocimientos: Programación en Python …………………………………….. 89
Recursos adicionales …………………………………………………………………………………………………. 90
FLUJO DE CONTROL Y CONDICIONALES …………………………………………………………………….. 91
Operadores matemáticos y lógicos …………………………………………………………………………… 91

pág. 2
 Flujo de control: If/else, else if ………………………………………………………………………………….. 97
Sentencias condicionales ………………………………………………………………………………………….. 103
Sentencia "switch" ……………………………………………………………………………………………………. 106
Construcciones en bucle …………………………………………………………………………………………… 111
Construcciones en bucle: ejemplos prácticos ……………………………………………………………. 115
Practicar el flujo de control y los bucles ……………………………………………………………………. 119
Ejercicio: utilice el flujo de control y los bucles para resolver un problema ……………….. 127
Auto revisión: utilice el flujo de control y los bucles para resolver un problema ………… 131
Cuestionario del módulo - Introducción a Python …………………………………………………….. 133
Recursos adicionales …………………………………………………………………………………………………. 135
MODULO 2: PROGRAMACIÓN BÁSICA CON PYTHON
FUNCIONES Y ESTRUCTURA DE DATOS ……………………………………………………………………… 137
Funciones …………………………………………………………………………………………………………………. 137
Ámbito de la variable ………………………………………………………………………………………………… 141
Función y ámbito de la variable …………………………………………………………………………………. 145
¿Qué son las estructuras de datos? …………………………………………………………………………… 148
Listas …………………………………………………………………………………………………………………………. 150
Tuplas ……………………………………………………………………………………………………………………….. 153
Conjuntos …………………………………………………………………………………………………………………. 155
Diccionarios ………………………………………………………………………………………………………………. 158
"kwargs" ……………………………………………………………………………………………………………………. 163
Funciones, bucles y estructuras de datos ………………………………………………………………….. 165
Elegir y utilizar estructuras de datos ………………………………………………………………………….. 167
Visual Studio Code en Coursera ………………………………………………………………………………… 170
Tareas de programación: Funciones, bucles y estructuras de datos …………………………. 177
Comprobación de conocimientos: funciones y estructuras de datos ………………………… 181
Recursos adicionales ………………………………………………………………………………………………… 182

pág. 3
 ERRORES, EXCEPCIONES Y MANEJO DE ARCHIVOS …………………………………………………… 183
¿Que son las excepciones? ………………………………………………………………………………………. 183
Manejo de excepciones …………………………………………………………………………………………….. 186
Ejercicio: excepciones en Python ………………………………………………………………………………. 190
Excepciones en Python ……………………………………………………………………………………………… 193
Manejo de archivos en Python ………………………………………………………………………………….. 194
Creación de archivos …………………………………………………………………………………………………. 199
Archivos de lectura …………………………………………………………………………………………………… 203
Almacenar el contenido de los archivos en estructuras de datos ………………………………. 206
Leer datos, almacenar, manipular y generar nuevos datos en un archivo ………………… 211
Tareas de programación: Leer datos, almacenar, manipular y generar nuevos datos 213
en un archivo …………………………………………………………………………………………………………….
Preguntas del módulo: programación básica con Python …………………………………………. 218
Recursos adicionales ………………………………………………………………………………………………… 220
MODULO 3: PARADIGMAS DE PROGRAMACIÓN
PROGRAMACIÓN PROCEDIMENTAL ………………………………………………………………………….. 222
¿Qué es la programación procedimental? ………………………………………………………………… 222
Algoritmos ………………………………………………………………………………………………………………… 228
Algoritmos de escritura …………………………………………………………………………………………….. 232
Ejercicio: prepare una taza de café …………………………………………………………………………… 235
Auto revisión: prepare una taza de café …………………………………………………………………… 237
Complejidad algorítmica …………………………………………………………………………………………… 238
Introducción a la notación Big-O ………………………………………………………………………………. 242
Comprobación de conocimientos: programación procedimental ……………………………… 244
Recursos adicionales …………………………………………………………………………………………………. 245
PROGRAMAMCIÓN FUNCIONAL ……………………………………………………………………………….. 246
¿Qué es la programación funcional? ………………………………………………………………………… 246
Funciones puras ……………………………………………………………………………………………………….. 251
Recursión ………………………………………………………………………………………………………………….. 254

pág. 4
Ejemplo de recursión: Torre de Hanoi ………………………………………………………………………. 259
Invertir una cadena en Python ………………………………………………………………………………….. 263
Mapa y filtro ……………………………………………………………………………………………………………… 266
Comprensiones …………………………………………………………………………………………………………. 269
Asignación de valores clave a estructuras de datos de diccionario ……………………………. 275
Tareas de programación: Asignación de valores clave a estructuras de datos de 276
diccionario …………………………………………………………………………………………………………………
Comprobación de conocimientos: programación funcional ………………………………………. 281
Recursos adicionales …………………………………………………………………………………………………. 282
PROGRAMACIÓN ORIENTADA A OBJETOS …………………………………………………………………. 283
Introducción a la Programación Orientada a Objetos ……………………………………………….. 283
Principios de la OOP ………………………………………………………………………………………………….. 289
Clases e instancias de Python ……………………………………………………………………………………. 293
Ejercicio: definir una clase ………………………………………………………………………………………… 296
Autorrevisión: definir una clase ………………………………………………………………………………… 300
Instanciar un objeto personalizado …………………………………………………………………………… 302
Ejercicio: instanciar un objeto personalizado ……………………………………………………………. 306
Autorrevisión: instanciar un objeto personalizado ……………………………………………………. 309
Métodos de instancia ……………………………………………………………………………………………….. 311
Clases padres vs. clases hijas …………………………………………………………………………………….. 316
Herencia y herencia múltiple ……………………………………………………………………………………. 320
Ejercicio: exploración de clases y objetos …………………………………………………………………. 325
Clases y métodos abstractos …………………………………………………………………………………….. 329
Tarea: Clases y métodos abstractos ………………………………………………………………………….. 333
Tareas de programación: Clases y métodos abstractos …………………………………………….. 335
Método Orden de resolución ……………………………………………………………………………………. 343
Trabajar con métodos: ejemplos ………………………………………………………………………………. 350
Autorrevisión: trabajar con métodos ………………………………………………………………………… 361
Resumen del módulo: paradigmas de programación ……………………………………………….. 364

pág. 5
 Cuestionario del módulo: paradigmas de programación …………………………………………… 366
Recursos adicionales …………………………………………………………………………………………………. 368
MODULO 4: MÓDULOS, PAQUETES, BIBLIOTECAS Y HERRAMIENTAS
MODULOS ………………………………………………………………………………………………………………… 370
¿Qué es un Módulo en Python? ……………………………………………………………………………….. 370
Acceder a los módulos ………………………………………………………………………………………………. 375
La sentencia "import" ……………………………………………………………………………………………….. 378
Escribir sentencias "import" ..……………………………………………………………………………………. 382
Espacio de nombres y ámbito …………………………………………………………………………………… 387
Tareas de programación: Importar y ámbito …………………………………………………………….. 393
Función "reload()"……………………………………………………………………………………………………… 398
Casos de uso del módulo …………………………………………………………………………………………… 402
Verificación de conocimientos: módulos …………………………………………………………………… 405
Recursos adicionales …………………………………………………………………………………………………. 406
PAQUETES, BIBLIOTECAS Y MARCOS POPULARES …………………………………………………….. 407
Paquetes populares: NumPy, Pandas, Matplotlib, etc. ……………………………………………… 407
Paquetes populares: ejemplos ………………………………………………………………………………….. 413
Aprendizaje automático, aprendizaje profundo e AI: PyTorch, TensorFlow ………………. 423
Big Data y análisis con Python …………………………………………………………………………………… 426
Marcos web de Python ……………………………………………………………………………………………… 430
Comprobación de conocimientos: paquetes, bibliotecas y marcos populares ………….. 433
Recursos adicionales …………………………………………………………………………………………………. 434
HERRAMIENTAS DE PRUEBA ……………………………………………………………………………………… 435
¿Qué son las pruebas? ……………………………………………………………………………………………… 435
Tipos de pruebas ………………………………………………………………………………………………………. 440
Prueba de nivel …………………………………………………………………………………………………………. 446
Paquetes de automatización de prueba ……………………………………………………………………. 448
Escribir pruebas con PyTest ………………………………………………………………………………………. 452

pág. 6
 Cheat sheet de PyTest ………………………………………………………………………………………………. 456
Tareas de programación: Escribir una prueba …………………………………………………………… 459
Desarrollo dirigido por pruebas (TDD) ………………………………………………………………………. 464
Aplicar TDD ………………………………………………………………………………………………………………. 468
Resumen del módulo: módulos, paquetes, bibliotecas y herramientas …………………….. 472
Preguntas del módulo: módulos, paquetes, bibliotecas y herramientas …………………… 474
Recursos adicionales ………………………………………………………………………………………………… 476
MODULO 5: EVALUACIÓN CALIFICADA DE FINAL DEL CURSO
EVALUACIÓN CALIFICADA …………………………………………………………………………………………. 478
Resumen del curso: programar en Python ………………………………………………………………… 478
Acerca de la evaluación calificada de final del curso …………………………………………………. 481
Evaluación calificada de final del curso: utilizar Python …………………………………………….. 482
RESUMEN DEL CURSO ………………………………………………………………………………………………. 488
Próximos pasos después de PROGRAMAR EN PYTHON ……………………………………………… 491
APENDICE: Ejemplos de programas con pruebas de escritorio 492

pág. 7
MODULO 1

INTRODUCCIÓN A PYTHON

Comience con el lenguaje de programación Python y los conceptos básicos asociados.

Objetivos de aprendizaje

• Reconocer aplicaciones comunes del lenguaje de programación Python

• Explicar los conceptos básicos de la ingeniería del software

• Utilizar operadores para programar una salida sencilla en Python

• Utilizar el flujo de control y los bucles para resolver un problema

pág. 8
INTRODUCCIÓN AL CURSO

Bienvenido al curso de programación con Python. Python es un versátil lenguaje de programación

de alto nivel disponible en múltiples plataformas. Es un lenguaje que utilizan compañías grandes
y pequeñas, para crear un rango diverso de aplicaciones. Algunas áreas en las que se utiliza Python
dentro del desarrollo web, son el análisis de datos y los pronósticos de negocios.

La sintaxis de programación de Python es muy similar al inglés. Es intuitivo y los principiantes

suelen comprender rápidamente lo que ocurre. También es una gran opción para programadores
experimentados, que apreciarán su poder y adaptabilidad. Como Python es una herramienta de
desarrollo de software muy popular, es importante para usted como desarrollador nuevo saber
cómo funciona y cómo codificar con ella. Este curso cubre los puntos clave que necesita conocer
para comenzar a programar en Python. A partir del módulo uno, se iniciará con un lenguaje de
programación Python y los conceptos básicos asociados. Aprenderá a reconocer las aplicaciones
comunes de Python, y será capaz de explicar conceptos básicos de ingeniería de software, utilizar
operadores para programar la salida en Python, y utilizar el flujo de control y los bucles para
resolver un problema de codificación. Y en el módulo dos, se basará en lo que ha aprendido en el
primer módulo obteniendo los conceptos básicos que sustentan el lenguaje de programación
Python, las variables y los diferentes tipos de datos en Python. Y llegará a utilizar el flujo de control
y los bucles para ejecutar un código bajo condiciones específicas. Este módulo también lo
introduce en el trabajo con funciones y estructuras de datos en Python, reconocimiento de
errores, determinación de sus causas y búsqueda de soluciones. Además de crear, leer y escribir

pág. 9
datos en archivos. En el módulo tres, aprenderá sobre los paradigmas de programación funcional
y programación orientada a objetos. Además, utilizará funciones para explorar el pensamiento
algorítmico, aprenderá a trabajar con objetos, clases y métodos en Python. Luego, en el módulo
cuatro, se verán módulos, paquetes, bibliotecas y herramientas. Aquí aprenderá a buscar,
importar y utilizar los módulos populares de Python y aprovechar las potentes herramientas para
optimizar el flujo de trabajo de programación. Descubrirá los diferentes tipos de pruebas y sus
características, y podrá utilizar herramientas de prueba para hacer una prueba. El módulo cinco
es la evaluación calificada en la que puede demostrar su capacidad de codificación en Python.
Podrá ejercitar las habilidades y los conocimientos de este curso. Y tendrá la oportunidad de
reflexionar sobre el contenido del curso y el camino de aprendizaje que tiene por delante.

Es posible que haya encontrado algunos conceptos o terminología en este video que no
comprende completamente. No se preocupe por eso ahora. Este curso está diseñado para abordar
todas estas cuestiones y brindarle una sólida base sobre la codificación en Python. Disfrute el
curso.

pág. 10
¿Cómo se utiliza Python en el mundo real?

Al desarrollador que escribió Python le encantaba el programa de televisión Monty Python´s Flying
Circus y pensó que el nombre Python era corto y cifrado y lo convirtió en el nombre del lenguaje.
Hola, soy Layla Rizvi, soy ingeniera de software de fondo en Instagram de San Francisco. Llevo 10
años codificando en Python, fue el primer lenguaje de programación que aprendí. Utilizo Python
todos los días para mi trabajo en Meta, es mi lenguaje favorito para escribir porque es muy sencillo
y simple de utilizar. La primera aplicación que tuve que codificar en Python era crear una
calculadora. Como Python fue el primer lenguaje que aprendí, mi primera aplicación en Python
fue un poco complicada, aprender a insertar una sangría derecha. Cómo hacer el espaciado,
aprender la sintaxis y aprender qué son los bucles, y todos estos conceptos básicos de la ciencia
de la computación fue muy difícil para mí, pero lo intenté por un tiempo y funcionó. Algunas
formas importantes en las que ha interactuado con Python en sus actividades cotidianas
probablemente incluyen el uso de Instagram, el uso de Facebook, el uso de Google o Spotify.
Python es un lenguaje tan omnipresente que es probable que lo haya utilizado,
independientemente de si sabe o no que lo ha hecho. Python también se utiliza para TensorFlow,
que es un marco de aprendizaje automático que Airbnb utiliza para clasificar imágenes, y algunas
empresas de atención sanitaria lo utilizan para clasificar los datos de las imágenes por resonancia
magnética. En Meta, Python se utiliza para el back-end de Instagram, se utiliza para los algoritmos
de anuncios de aprendizaje automático. También es usado por los ingenieros de producción que
mantienen nuestros servicios vivos y en funcionamiento. Debería pasar por el proceso de
aprendizaje de Python aunque pueda ser un desafío porque es un lenguaje más simple de
aprender. Es sencillo, tiene muchas bibliotecas que lo respaldan. Así que también hace que sea
más fácil construir más y más características porque hay muchos ingenieros que ya lo utilizan. Así,
facilita el desarrollo rápido de funciones y puede ver resultados mucho más rápido con Python.
Gracias por ver el video con nosotros hoy y buena suerte en su trayectoria como ingeniero de
software.

pág. 11
¿Qué espera aprender?

Este curso en línea es una experiencia de aprendizaje a su propio ritmo. Puesto que va a tener un
rol muy activo como estudiante, es importante que piense cuáles son sus objetivos y expectativas.
¿Qué espera aprender de este curso?

pág. 12
Programa del curso

Requisitos previos

Para realizar este curso, no es necesario tener experiencia previa en desarrollo. ¡Simplemente
debe estar dispuesto a empezar a codificar en Python!

Contenido del curso

Durante este curso, aprenderá todo lo que necesita saber para comenzar con el desarrollo de
Python. El contenido de los cuatro módulos se enumera a continuación.

Módulo 1 - Introducción a Python

En este módulo obtendrá una introducción al curso y un breve resumen de la historia de la

programación. También aprenderá los fundamentos del funcionamiento de la programación y
descubrirá los usos típicos de Python en la vida real. Además, encontrará algunos consejos sobre
cómo realizar este curso con éxito.

Antes de comenzar a programar, compruebe si su sistema informático actual está configurado

correctamente e identifique las dependencias requeridas del sistema operativo. A continuación,
explorará diferentes formas de ejecutar programas a través de Python.

Luego, estudiará la sintaxis de Python mediante comentarios, variables, tipos de datos y entrada
y salida de usuarios. Continuará ampliando sus habilidades de Python mediante operadores
matemáticos y lógicos para poder controlar el flujo del código y realizar operaciones como adición,
resta, división y multiplicación.

Python tiene varias formas de hacer bucles de código o bucles. Examinará las construcciones de
bucle para iterar su código sobre varias secuencias.

Módulo 2 - Programación básica con Python

En el módulo 2, recibirá una introducción a las funciones de Python, incluyendo cómo declarar
una función, y cómo pasar datos a una función o devolver datos de una función. También explorará
las estructuras de datos, el alcance y los conceptos de las listas y cómo se pueden utilizar en

pág. 13
Python. Además, descubrirá las tuplas, los conjuntos, los diccionarios y los kwargs y comprenderá
sus principales usos.

Los errores y las excepciones son dos aspectos muy importantes del aprendizaje de Python como
nuevo desarrollador. En el módulo 2, comenzará con los errores y las excepciones, y explorará lo
que ocurre cuando su código no funciona. También verá el manejo de excepciones y el manejo de
archivos en Python, así como la creación de archivos en Python y varios métodos para insertar
contenido en un archivo nuevo.

Módulo 3 - Paradigmas de programación

En el tercer módulo, aprenderá sobre los paradigmas de programación y analizará las

características y los conceptos detrás de la programación de procedimientos, la programación
funcional y la programación orientada a objetos.

Una característica clave de la programación de procedimientos son los algoritmos. Explorará cómo
se pueden utilizar para resolver problemas y cómo se calcula la complejidad algorítmica, y
aprenderá sobre la notación Big-O.

Luego, aprenderá sobre las funciones puras y la recursividad en la programación funcional, además
de la diferencia entre mapas y filtros.

Finalmente, explorará la programación orientada a objetos y sus cuatro conceptos principales.

Conocerá la relación entre clases e instancias en Python creando clases a las que le proporcionará
instancias y accediendo a sus variables y métodos. Aprenderá sobre clases y métodos abstractos
y cómo implementarlos. También se explican las reglas de resolución de métodos y de herencia
con clases hijas y padres. Poder leer archivos es esencial cuando se trabaja con datos almacenados
en Python, y descubrirá varias funciones integradas que lo harán más sencillo.

Módulo 4: módulos, paquetes, bibliotecas y herramientas

En el módulo 4, aprendió que Python es un poderoso lenguaje que le permite construir cosas
increíbles, y que puede obtener aún más funcionalidad con el uso de módulos, bibliotecas y

pág. 14
herramientas. Aprenderá sobre módulos y verá que son los componentes básicos para agregar
funcionalidad a su código, y de ese modo sabrá que no necesita rehacer todo continuamente.

También explorará algunas de las bibliotecas de Python más utilizadas en el análisis de datos y la
ciencia de datos, y cómo pueden aplicarse a las áreas de aprendizaje automático e inteligencia
artificial.

Por último, descubrirá por qué las pruebas son un componente esencial del control de calidad y
explorará el tipo de pruebas que debe utilizar. Aprenderá sobre los paquetes de automatización
de pruebas y la importancia de las pruebas automatizadas y realizará algunas pruebas con PyTest.
Por último, explorará la evolución del TDD (Test-driven development, Desarrollo dirigido por
pruebas), y se centrará en cómo aplicar una metodología de desarrollo dirigido por pruebas.

Módulo 5: evaluaciones calificadas

Aquí aprenderá sobre las evaluaciones calificadas. Luego de completar los elementos individuales
de este módulo, probará sus conocimientos y habilidades mediante una evaluación calificada de
final del curso.

pág. 15
Cómo tener éxito en este curso

Tomar un curso en línea puede ser abrumador. ¿Cómo aprender a su propio ritmo y alcanzar con
éxito sus objetivos?

Estos son algunos consejos generales que pueden ayudarlo a mantenerse centrado y encaminado.

Establecer objetivos diarios de estudio

Pregúntese qué espera lograr en su curso cada día. Definir un objetivo claro puede ayudarlo a
mantenerse motivado y superar la procrastinación. El objetivo debe ser específico y fácil de medir,
como: "Veré todos los videos del módulo 2 y haré la primera tarea de programación". ¡Y no se
olvide de recompensarse cuando avance hacia su objetivo!

Crear un espacio de estudio exclusivo

Es más fácil recordar la información si está en el mismo lugar donde la aprendió, así que tener un
espacio exclusivo en el hogar para hacer cursos en línea puede hacer que su aprendizaje sea más
eficaz. Elimine cualquier distracción del espacio y, si es posible, elija un lugar que esté separado
de la cama o el sofá. Distinguir claramente dónde estudia y dónde descansa puede ayudarlo a
concentrarse.

Programar tiempo para estudiar en su calendario

Abra su calendario y elija un horario previsible y confiable que pueda dedicar a mirar las clases y
completar las tareas. Esto lo ayudará a garantizar que los cursos no se conviertan en lo último de
su lista de tareas pendientes.

Consejo: puede agregar fechas límite de un curso Coursera a su Google Calendar, Apple Calendar
u otra aplicación de calendario.

Ser responsable

Cuénteles a sus amigos acerca de los cursos que está realizando, publique sus logros en las redes
sociales o escriba un blog sobre sus tareas. Tener una comunidad y una red de amigos y familiares
para animarse marca la diferencia.

pág. 16
Tomar notas de forma activa

Tomar notas puede fomentar el pensamiento activo, impulsar la comprensión y ampliar su

capacidad de atención. Es una buena estrategia para internalizar el conocimiento, tanto si está
aprendiendo en línea como en el aula. Así que tome un cuaderno o encuentre una aplicación
digital que le sea útil y empiece a sintetizar puntos clave.

Consejo: mientras mira una clase en Coursera, puede hacer clic en el botón “Guardar nota” que se
encuentra debajo del video para guardar una captura de pantalla de sus notas del curso y añadir
sus propios comentarios.

Unirse a los debates

Los foros de debate del curso son un lugar estupendo para hacer preguntas sobre las tareas,
debatir temas, compartir recursos y hacer amigos. En nuestros estudios se demuestra que los
estudiantes que participan en los foros de debate tienen un 37 % más de probabilidades de
terminar un curso. Así que ¡haga una publicación hoy!

Hacer una cosa a la vez

La multitarea es menos productiva que centrarse en una única tarea a la vez. Los investigadores
de la Universidad de Stanford descubrieron que "las personas que son bombardeadas
regularmente con varios flujos de información electrónica no pueden prestar atención, recordar
información o cambiar de un trabajo a otro de manera tan eficaz como quienes realizan una tarea
a la vez". Concéntrese en una cosa a la vez. Absorberá más información y completará las tareas
con mayor productividad y facilidad que si intentara hacer muchas cosas a la vez.

Tomar descansos

Relajar el cerebro después del aprendizaje es fundamental para un alto rendimiento. Si se

encuentra trabajando en un problema difícil sin mucho progreso durante una hora, tómese un
descanso. Salir a la calle, tomar una ducha o hablar con un amigo puede ayudarlo a recuperar
energías e, incluso, darle nuevas ideas sobre cómo abordar ese proyecto.

pág. 17
¡Su proceso de aprendizaje comienza ahora!

Mientras se prepara para el cuestionario del módulo o trabaja para alcanzar sus objetivos de
aprendizaje, le recomendamos lo siguiente:

• Repase cada lección del itinerario de aprendizaje. Intente no saltarse ninguna actividad o
lección, a menos que esté seguro de que ya conoce esta información lo suficiente como
para seguir adelante.

• Aproveche la oportunidad para volver a ver un video o leer la información adicional

proporcionada antes de pasar a la siguiente lección o módulo.

• Responda todos los cuestionarios y haga todos los ejercicios de conocimientos y módulos.

• Lea atentamente los comentarios cuando responda a los cuestionarios, ya que lo ayudarán
a reforzar lo que está aprendiendo.

• Aproveche el entorno de aprendizaje práctico que ofrecen los ejercicios. Puede obtener
un refuerzo sustancial de su aprendizaje a través de la aplicación paso a paso de sus
habilidades.

pág. 18
BIENVENIDO A LA PROGRAMACIÓN EN PYTHON

Introducción a la programación

Las computadoras y sus programas están integrados en nuestras vidas a un nivel que nunca podría
haberse imaginado. En los últimos 20 años, hemos visto avances tecnológicos increíbles en áreas
de computación distribuida, computación en la nube y mejoras en AI (inteligencia artificial), como
el reconocimiento de voz y reconocimiento facial y los vehículos autónomos.

En los próximos minutos, les haré un breve resumen de la historia de la programación y también
aprenderá los conceptos básicos de cómo funciona la programación. Los orígenes de la
informática se remontan a muchos años atrás en nuestra historia. En 1882, Charles Babbage, quien
estudiaba en la Universidad de Cambridge en Gran Bretaña, se dedicó a mejorar los dispositivos
de cálculo, como las cartas de navegación y las tablas astronómicas, que en aquella época
utilizaban muchos barcos en el mar.

pág. 19
Babbage llegó a la conclusión de que todos estos dispositivos de cálculo tenían diversas cantidades
de errores humanos y se preguntaba si había una solución mejor. Su solución fue el motor de
diferencia. El motor de diferencia utilizó engranajes mecánicos con números del 0 al 9 grabados
en sus huecos separados por los dientes del engranaje. Su función principal era realizar una
operación que se calculaba moviendo manualmente manivelas hasta que se revelaba la respuesta
final.

Después de construir un prototipo de trabajo, Babbage pasó muchos años trabajando en mejorar
sus diseños y construir versiones que superaran la idea original. Creó otro dispositivo denominado
motor de diferencia dos, pero finalmente produjo un concepto nuevo y mejor, denominado motor

pág. 20
analítico. El motor analítico es ampliamente aceptado como la base de la informática actual. Ada
Lovelace, una amiga de Babbage, publicó un documento en el que describía cómo el motor podría
realizar una secuencia de cálculos, que es esencialmente lo que hace un programa de
computadora.

Sin embargo, el motor analítico nunca se completó y Babbage, como muchos desarrolladores, no
invirtió en una buena documentación. Ahora que ya hemos visto el lado histórico de las cosas,
vamos a profundizar en la comprensión de lo que es la programación. Antes de explicar la
programación, es útil entender cómo funcionan las computadoras en el nivel más fundamental.
Las computadoras solo entienden el código binario, que consta de dos dígitos: 0 y 1.

Esto puede parecer bastante extraño al principio, pero con una pequeña explicación, todo tendrá
sentido. El 0 y el 1 se refieren a diferentes estados eléctricos similares a un interruptor de luz, 0 es
igual a off (apagado) y 1 es igual a on (encendido).

Por ejemplo, en programación, cuando se calculan números, costos o cualquier aritmética, se

utilizan principalmente números decimales. Cada programa escrito debe convertirse en código
binario o código de máquina. Un ejemplo de conversión de decibeles a binario es el uno decimal
es el uno binario, el dos decimal es el 10 binario, el tres decimales es 1 binario, 1, etc.

pág. 21
La computadora representa el código binario utilizando pequeños conductores eléctricos
denominados transistores. Estos transistores se alojan dentro de la unidad central de
procesamiento o CPU, que es esencialmente el cerebro de la computadora.

Cuando se escribe un programa utilizando cualquier tipo de lenguaje es necesario compilarlo o

interpretarlo. El resultado consiste en convertir el código de programación legible para nosotros
en código de programación legible para la computadora.

pág. 22
Básicamente, es muy difícil para los humanos leer y entender el código binario y, por lo tanto, su
uso es propenso a los errores. Es mucho más fácil leer y escribir lenguajes de programación.
Entonces, ¿qué es la programación? La programación es la capacidad de proporcionar a una
computadora un conjunto de instrucciones en un determinado lenguaje que pueda entender y
realizar esas operaciones o tareas. En otras palabras, debe decirle a la computadora lo que quería
hacer en un formato y lenguaje que pueda comprender; la programación es una habilidad. Cuanto
más practique y aprenda, mejor será.

pág. 23
Al principio, puede llevar bastante tiempo escribir programas sencillos, a medida que avanza se
familiarizará con el lenguaje y el modo en que se debe aplicar la lógica en las condiciones. La
programación también es una habilidad creativa. Esto se debe a que puede escribir un programa
informático para resolver problemas de muchas maneras diferentes. Y eso nos lleva al final de este
video. Ahora ya conoce la breve historia de la programación y de cómo funciona la típica
programación informática.

pág. 24
¿Por qué elegir Python?

¿Le gustaría poder programar en distintas plataformas? ¿Por ejemplo, Windows, Mac y Linux en
una sintaxis sencilla similar a inglés? Entonces Python es su solución. Es un lenguaje de
programación de alto nivel que funciona en muchas plataformas diferentes. Al final de este video,
conocerá los beneficios de aprender Python y sabrá dónde utilizarlo. Python fue creado por Guido
van Rossum y lanzado en 1991. Fue diseñado para ser legible y toma muchas similitudes entre el
idioma inglés y las matemáticas.

Desde su lanzamiento, ha ganado mucho en popularidad y admite una amplia selección de marcos
y bibliotecas. En la actualidad, es uno de los lenguajes de programación más populares para
aprender. Se usa ampliamente en todas las áreas de negocio, como desarrollo web, inteligencia
artificial, aprendizaje automático, análisis de datos y diferentes aplicaciones de programación.
Python también es muy sencillo de aprender y empezar a utilizar.

pág. 25
Dado que la sintaxis se asemeja al idioma inglés, es sencillo leerla y descifrarla. Los programas
escritos en Python también requieren menos código si se los compara con los lenguajes de
programación como C o Java.

Una de las principales ventajas de Python es que hace que los desarrolladores sean muy
productivos y permite finalizar los proyectos más rápidamente. Crear un buen software que sea
utilizado por muchos es difícil y lleva mucho tiempo. La naturaleza simple de Python elimina gran
parte de la complejidad para el desarrollador y le permite centrarse en la tarea en cuestión. Dado
que el lenguaje es bastante sencillo de comprender y recoger, puede ser una vía más simple de
acceso al mercado para los nuevos programadores que consiguen resultados en mucho menos
tiempo.

En comparación con otros idiomas, Python tiene una curva de aprendizaje mucho más simple. Se
ajusta a la filosofía de escribir menos, hacer más. Ahora que puede describir los beneficios del
aprendizaje de Python y dónde se puede utilizar, también es bueno saber que los desarrolladores

pág. 26
de Python están muy solicitados. Convertirse en desarrollador de Python es una buena opción
profesional.

Visual Studio Code

En este curso, utilizará Visual Studio Code (VSCode), que es un IDE (Integrated Development
Environment, Entorno de Desarrollo Integrado) proporcionado por Microsoft de forma gratuita.
VSCode viene con una gran cantidad de "plugins" y extensiones para hacer su vida más fácil como
desarrollador. Al final de esta lectura, serás capaz de instalar y configurar Visual Studio Code en
sus dispositivos.

Tiene dos opciones para utilizar Visual Studio Code y completar sus actividades del curso:

Opción 1: utilizar Visual Studio Code en el navegador con los laboratorios de Coursera

La plataforma de Coursera ofrece una versión en el navegador de Visual Studio Code

preconfigurada y no requiere configuración local. Puede acceder al entorno Visual Studio Code a
través de los elementos "Laboratorio" incluidos en este curso. Su trabajo y sus archivos se
guardarán y estarán disponibles en este laboratorio en el navegador mientras tenga acceso al
curso.

Opción 2: trabajar en su dispositivo local

Comience por descargar VSCode desde el sitio web de Microsoft:

https://code.visualstudio.com/load. Seleccione la descarga según su sistema operativo.

Windows

1. Descargue los archivos de 64 bits o 32 bits según su sistema operativo.

2. Una vez que se complete la descarga, abra el archivo para instalarlo.

3. Utilice la ubicación del directorio por defecto cuando se le pregunte dónde instalar.

4. En la vista Seleccionar tareas adicionales, asegúrese de que la opción Agregar a ruta esté
seleccionada.

pág. 27
5. Haga clic en Siguiente y el instalador comenzará.

6. Al finalizar, cargue la aplicación. Debería ver algo similar a esto:

pág. 28
Mac

1. Descargue la aplicación basada en el conjunto de chips que tiene. Los macs M1 utilizan
Silicio de Apple y las versiones más antiguas utilizan Intel. Si no está seguro, elija la opción
Universal.

2. Una vez finalizada la descarga, diríjase a la carpeta donde se descargó el archivo (por
defecto suele ser la carpeta Descargas).

3. Haga doble clic en el archivo zip para extraer los contenidos.

4. Arrastre y suelte el archivo .app al vínculo Aplicaciones en el Explorador de archivos, como

se muestra a continuación.

pág. 29
5. Abra la aplicación.

Extensión de Python

Visual Studio Code ofrece una extensión de Python en su tienda de extensiones. Se puede añadir
directamente desde el IDE completando los siguientes pasos.

1. Haga clic en el icono Extensiones

pág. 30
2. En la barra de búsqueda, escriba Python. Obtendrá algunas extensiones diferentes, pero la que
desea es la extensión proporcionada por Microsoft.

pág. 31
3. Haga clic en el botón Instalar. Es posible que deba reiniciar el IDE una vez finalizada la instalación.

pág. 32
Instalar rutas de Python (opcional para usuarios de Windows)

Si desea trabajar en su dispositivo local y tiene un equipo con Windows necesitará instalar Python.
Para instalar Python en Windows, primero debe descargar la versión más reciente del sitio web
python.org.

1. Vaya a https://www.python.org/downloads/

Phyton website with the link displayed on browser

2. Seleccione la última versión.

3. Según lo que mejor se adapte a su sistema operativo, seleccione la oferta de 32 o 64 bits.

pág. 33
Compressed files as windows installers and tarball

4. Haga clic en el enlace para descargar el archivo del Windows Installer - Recommended.

5. Una vez descargado, abra el archivo.

6. En la ventana de instalación, marque las casillas siguientes:

• Install Launcher for all users (instalar Launcher para todos los usuarios)

• Add Python 3.10 a PATH (añadir Python 3.10 a PATH)

pág. 34
Install Phyton display

7. Seleccione Install Now (instalar ahora).

8. Seleccione Yes (Sí) en la siguiente ventana para permitir que la aplicación realice cambios en su
dispositivo.

9. El proceso de instalación comenzará. Espere a que termine y, a continuación, seleccione "Close"

(cerrar) una vez que se haya realizado correctamente.

10. Ahora debería poder acceder a la última versión de Python desde el menú de Windows.

pág. 35
Dependencias necesarias

Al finalizar esta lectura, podrá identificar las dependencias necesarias para su sistema operativo.

Configurar Python en Windows es sencillo y se instalará sin ninguna dependencia necesaria. En

Mac, sin embargo, se necesitan algunas dependencias adicionales antes de instalar Python.

XCode

Para instalar "brew", primero debe instalar Xcode. Homebrew no viene con su propio compilador
y necesita tener instalado Xcode para funcionar correctamente. Para instalar Xcode realice estos
pasos:

1. Abra una terminal.

2. Ejecute lo siguiente:

shell xcode-select --install

3. Aparecerá una ventana emergente pidiéndole que confirme la instalación. Haga clic en el
botón "Install" (Instalar).

4. Acepte el acuerdo de licencia.

brew

Las Mac no incluyen gestores de paquetes como la mayoría de distribuciones de Linux. Para
compensarlo, se creó una herramienta externa llamada brew. Para instalar brew, haga lo
siguiente:

pág. 36
Comprobación del entorno para Windows

Cuando comienza a utilizar Python, es importante asegurarse de que funciona correctamente en

su sistema operativo con el entorno de desarrollo integrado o IDE, en este caso, el código de Visual
Studio o código VS. Un paso esencial para utilizar este software es asegurarse de que la versión
correcta de Python se utiliza como el intérprete cuando ejecuta VS Code. En este video,
demostraré cómo configurar el código VS en Windows y me aseguraré de que apunta al intérprete
correcto de Python. Comienzo por abrir VS Code Editor. Para ello, hago clic en el ícono Windows
de la barra de tareas, que muestra un menú. A continuación, escribo Visual Studio Code en la barra
de búsqueda. La mejor coincidencia para la búsqueda es la aplicación Visual Studio Code, en la que
hago clic para abrir. VS Code ya está abierto. A continuación, selecciono "Get started with Python
Development" (Introducción al desarrollo de Python). Esta es una guía útil para configurar Python
en el IDE VS Code. El primer paso de la guía es instalar Python. Una vez que Python está instalado,
puedo verificarlo escribiendo la versión Python guión guión en la terminal. Para abrir la terminal,
seleccione la pestaña "Terminal" (Terminal) en en el menú superior y elija "New Terminal
(Terminal nueva)". Después de pulsar la tecla "Enter" (Intro), muestra la versión de Python 3.10,
que es correcta. El segundo paso de la guía es crear un archivo Python. Hago clic en la opción
"Create a Python File" (Crear un archivo Python) en el menú guía, y luego hago clic en el botón
"Create a Python file" (Crear un archivo Python) que aparece. A continuación, pongo una sentencia
"print" y escribo "print Hello World" (imprimir Hola Mundo). Explicaré qué es una impresión más
adelante. Pero por ahora, solo necesita saber que es para imprimir en un valor dentro de la propia
terminal. Ahora veo esto como un archivo Python y mi directorio de nivel raíz al hacer clic en "File"
(Archivo), "Save As" (Guardar como) e introducir el nombre de archivo hello_world.py. Py es la
extensión de archivo que tengo que usar cuando se guarda un archivo Python.

pág. 37
El siguiente paso en la guía es para seleccionar un intérprete de Python. Hago clic en esta opción
en el menú. Luego hago clic en el botón de intérprete Python que aparece que muestra todas las
versiones de Python que tengo instaladas. Hago esto porque quiero asegurarme de que cuando
ejecute el "script" de Python, elegirá el intérprete correcto. La versión que viene es la versión de
Python 3.10 y la puse como el intérprete porque es la versión más reciente. Para probar y verificar
que todo funciona correctamente, tengo que ejecutar el archivo Python. En la parte superior
derecha de la pantalla notará un botón de reproducción. Cerré las guías para que se muestre
mejor. El botón "Play" (Reproducir) tiene un menú desplegable que tiene la opción para ejecutar
el archivo Python o ejecutarlo en depuración. Haré clic en la opción "Run Python file" (Ejecutar el
archivo Python). Noto que en la ventana de terminal ha ejecutado el archivo mediante Python
3.10 como intérprete y obtengo la salida de "hello world" (hola mundo) Eso significa que ahora
aparece la configuración para utilizar Python directamente en el IDE para poder ejecutar y depurar
mis "scripts". Ahora sabe cómo crear y guardar un archivo Python y cómo seleccionar el intérprete
de Python correcto para ejecutar sus archivos en VS Code.

pág. 38
Ejecutar código - Línea de comandos VS IDE

¿Sabía que Python se puede ejecutar directamente en la línea de comandos en Windows o en la

terminal en Mac y Linux? En este video, obtendrá más información sobre las principales diferencias
de ejecución del código desde la línea de comando a través del IDE, así como explorar formas en
las que puede ejecutar programas a través de Python. Veamos las dos formas principales de
ejecutar los programas de Python.

La primera forma es utilizar "shell" de Python, y la segunda es ejecutar un archivo Python

directamente desde la terminal de línea de comandos. El shell Python es útil para ejecutar y probar
"scripts" pequeños. Por ejemplo, le permite ejecutar código sin necesidad de crear archivos
new.PY.

pág. 39
Comienza por agregar fragmentos de código que puede ejecutar directamente en el "shell".
Vamos a explorar la segunda forma principal para ejecutar los programas de Python, que es
ejecutar un archivo Python directamente desde la línea de comando o la terminal. Tenga en cuenta
que cualquier archivo que tiene la extensión de archivo de.PY se puede ejecutar siguiendo el
comando. Por ejemplo, escriba Python y luego un espacio, y luego escriba el nombre del archivo
con la extensión a.PY. VS Code es mejor opción que utilizar el Python shell o ejecutarlo
directamente desde la terminal porque, además de ambas opciones, viene con muchas mejoras
adicionales que hacen que la codificación en Python sea una mejor experiencia.

Visual Studio Code también ofrece funciones como la autofinalización, la depuración y la sintaxis
de código, resaltado, espacio en blanco, y ayudantes de sangría.

pág. 40
Ahora voy a demostrar las diferentes formas en que puede ejecutar programas Python en VS Code.
Existen dos opciones de ejecución de programas a través de Python. Una es ejecutar directamente
desde la línea de comandos o la terminal si está en Mac, y luego la otra opción es ejecutar
directamente desde el IDE, que en este caso es Visual Studio Code. Averigüemos cómo hacerlo.
En primer lugar, abro la ventana terminal o línea de comandos desde IDE haciendo clic en el menú
de la terminal y seleccionando nueva terminal. Ahora ejecuto "Hello World" (Hola mundo) punto
"scripts" Py mayúscula directamente desde la terminal. Puedo ejecutar esto escribiendo el
comando Python, luego el nombre del archivo, hello worlds.Py, seguido por el nombre del archivo,
luego presiono la tecla "Intro".

pág. 41
El resultado es "Hello world" (Hola mundo). Existe una segunda opción utilizando la terminal, que
es introducirlo en el "shell" Python. Si solo escribo el Python, pulso la tecla Intro, se abre un
enfoque "shell" Python. Aquí puedo escribir código y ejecutarlo directamente dentro de la ventana
de la terminal. Puedo, por ejemplo, utilizar el mismo código que tengo por encima del código
"Hello World" (Hola Mundo) de impresión. Presiono la tecla Intro, que imprimirá las palabras
"Hello World" directamente en "shell". Digamos que quiero salir de shell. Luego escribo la palabra
salir. Como esta es una función, debo agregar el paréntesis, presionar la tecla Intro, y ahora estoy
de vuelta en la ventana de comandos. Para hacer lo mismo desde dentro del IDE, solo cierro la
ventana de la terminal. Aquí puedo ejecutar cualquier "script" de Python desde el IDE
directamente usando los botones en la esquina superior derecha de la pantalla y seleccionando
en el menú desplegable ya sea el archivo para ejecutar Python o el archivo Python de depuración.
Ahora hago clic en el botón Ejecutar. y la terminal debería abrirse automáticamente. El resultado
es "hello world" (hola mundo) que se imprime. Ahora ha explorado las dos opciones disponibles
para ejecutar código Python directamente desde la terminal o línea de comandos, y del IDE. Esto
nos lleva al final de este video. Ahora conoce las principales diferencias en ejecución de código de
la línea de comando a través del IDE, También puede demostrar formas en las que puede ejecutar
programas a través de Python.

pág. 42
Sintaxis de Python, los espacios importan

En este video explorará la sintaxis de Python y aprenderá cómo los espacios en blanco y la sangría
pueden afectar a un programa si se utilizan mal. En el código VS, creo un archivo nuevo
denominado python underscore syntax dot PY. Comienzo por utilizar una sentencia print para
generar una línea de texto. No se preocupe si no está familiarizado con "print" o la declaración de
variables en este punto que se cubrirá más adelante en el curso. Escribo "print" seguido de la
cadena, "Hello". Al hacer clic en el botón Ejecutar, aparece el texto, "Hello", en el panel de la
terminal. Ahora digamos que queremos usar otra sentencia "print" en la misma línea que dará
salida al valor de texto "world". Así que agrego un espacio y luego escribo otra sentencia "print"
con la cadena "world". Y esperamos que esto nos dé las palabras "hello world". Pero cuando hago
clic en ejecutar, realmente obtenemos un error. Dice "syntax error invalid syntax". Esto sucede
porque el intérprete no sabe cuándo se produce la línea nueva o una sentencia. Existen dos formas
de resolver este problema. Una es mover la segunda sentencia "print" a otra línea. Entonces coloco
el cursor de texto antes de la sentencia "print" para "world" y luego presiono la tecla Intro para
moverlo hacia abajo. Cuando hago clic en ejecutar esta vez no hay error y obtengo las palabras
"hello" y "world" en líneas separadas. Permítame deshacer las ediciones que hice a mi código
pulsando control y Z o Comando Z en una Mac. Y luego pruebe el segundo método que es separar
las dos sentencias "print" con un punto y coma en un espacio. Cuando hago clic de nuevo en
ejecutar, también ejecuta ambas sentencias como se esperaba.

A continuación, se tratará el impacto del espacio en blanco en la sintaxis de Python. Primero borro
mi pantalla y luego declaro una variable y le asigno un valor escribiendo x = 1 + 2. En la siguiente
línea, agregaré una sentencia "print" para x. Sin embargo, antes de hacer clic en ejecutar, volveré
a mi asignación de variables y agregaré un número aleatorio de espacios alrededor del símbolo
más. Esto no causará ningún problema con esta línea. Sin embargo, surgirán problemas si agrego
una nueva línea o una sentencia final para demostrarlo. Voy a introducir una nueva línea y escribir
más tres mediante este código, entonces obtengo un valor de tres.

pág. 43
Lo que ha ocurrido es que el intérprete ha ejecutado nuestra primera línea de uno más dos
correctamente a pesar del espacio en blanco adicional. Pero no representó el más tres en la
segunda línea. Existen varias formas de solucionar este problema. Para ello, lo más sencillo es
utilizar una línea de fuerza. Escribo una barra oblicua invertida al final de la primera línea.

Ahora, cuando hago clic en ejecutar, obtengo un valor de seis, lo que significa que ambas líneas
han sido representadas para resumir cualquier cantidad de espacios en blanco o sangrías en una
línea, está bien. Pero tenga en cuenta que, si lo combina con líneas adicionales, tendrá que dar
indicaciones claras de dónde se ha producido una nueva línea a continuación.

pág. 44
Verá cómo agregar sangrías en Python. Empiezo por limpiar mi pantalla y declarar la variable nueva
"name" con un valor de cadena de John. Quiero escribir una sentencia "if" que devuelva "John"
solo si la variable "name" tiene un nuevo valor de "John". Para ello, escribo "if name == John". Y
luego en una nueva línea introduzco la sentencia "print" para "name", para que este programa
funcione. Necesito tener una sangría antes de la sentencia "print" que V s código se agrega
automáticamente. Cuando hago clic en ejecutar, obtengo "John" como esperaba. Pero, ¿qué
sucede cuando la sangría no está ahí? Si borro la sangría de mi código y lo vuelvo a ejecutar,
obtengo el error. Se esperaba un error de sangría en un bloque con sangrías. Esto nos dice que no
se encontró una sangría donde debería haber estado. Afortunadamente, el mensaje de error nos
lleva a la línea específica en la que se produjo el problema. Luego podría editar mi código y
arreglarlo al escribir programas en Python. Es un buen hábito leer la salida siempre que se
encuentre con un error cuando se dan los detalles de lo que salió mal y dónde sucedió, como
observó aquí.

pág. 45
"Cheatsheet" de sintaxis de Python

Esta lectura le proporciona una hoja con trucos que puede utilizar como referencia rápida.

Espaciado

Sangría

pág. 46
pág. 47
Comentar el código

Al finalizar esta lectura, podrá explicar por qué y dónde usar los comentarios en la codificación.

Agregar comentarios al código no solo lo ayuda como desarrollador, sino que también ayuda a
otros miembros de su equipo. Los comentarios son excelentes para actualizar su memoria de
código que puede haber escrito hace meses y es posible que haya olvidado lo que se pretendía
hacer. Existen varias razones por las que debe agregar comentarios a un archivo de código. Que
abarcan desde los siguientes:

• Explicar la finalidad del código.

• Informar a los desarrolladores que el código está obsoleto.

• Agregar comentarios TODO para completar el trabajo más adelante.

A continuación se presentan ejemplos de los diferentes tipos de comentarios que se pueden

utilizar.

Comentarios de una línea

El uso de un símbolo # le dice a Python que ignore todo después de este punto hasta el final de la
línea actual.

Comentarios en varias líneas

Python realmente no tiene un método para declarar comentarios multilínea por lo que se puede
usar un símbolo # al principio de cada línea del comentario.

pág. 48
Comentarios en línea

El símbolo # le indica a Python que ignore todo después de este punto hasta el final de la línea
actual, lo que permite colocar los comentarios dentro del código en sí. Los comentarios en línea
deben utilizarse para proporcionar información importante sobre el código con el que tratan.

Recuerde siempre tener una razón para un comentario, ya que deben proporcionar información
al lector y no ser una molestia que distraiga.

pág. 49
Variables

Las variables son una parte esencial de programación y se utilizan para almacenar todos los
diferentes tipos de datos. Incluso podría decirse que son la piedra angular de la programación, y
esto se debe a que permiten trabajar y manipular datos. Por lo tanto, es importante que pueda
identificar variables y reconocer cómo se utilizan.

Declarar variables en Python es muy sencillo. Lo único que debe hacer es declarar un nombre y
asignarle un valor. La palabra variable se refiere a algo que se pueda cambiar. Para hacer esto en
Python, para una variable que ya se ha declarado, solo necesita asignarla o lo declararla
nuevamente. Vamos a analizar un ejemplo. Digamos que a la variable X se le ha asignado el valor
de 10. Para cambiar esto, solo tiene que volver a declararlo, así tendrá el valor de 20. Los ejemplos
hasta ahora se han basado en convenciones de nomenclatura simples como X, Y y Z.

pág. 50
Cuando se trabaja en un proyecto con otros desarrolladores, será cada vez más difícil conocer qué
significan estas variables o a qué se refieren.

Como programador, escribirá una pérdida de código con el tiempo, y si han pasado unos meses,
lo más probable es que no recuerde exactamente lo que el código se suponía que debía hacer.

Utilizar variables genéricas como X e Y no da cualquier información sobre esa variable y dónde se
utiliza. Dar nombres significativos a sus variables que tengan sentido en el contexto dado le
permitirá a usted y otros programadores a comprender fácilmente lo que está pasando.

pág. 51
Como programador, es importante comprender que los datos cambiarán a lo largo del ciclo de
vida de su programa. Ya sea que esté recibiendo entrada del usuario a través de un formulario
web o trabajando con variables dentro del código en sí, la función clave de la variable es mantener
una referencia a algún valor. Ahora que comprende qué son las variables y sus funciones en
Python, pasemos a una demostración práctica de las variables y cómo utilizarlas. Voy a demostrar
cómo usar variables en Python, pero primero quiero hablar brevemente sobre convenciones de
nomenclatura. Existen diferentes opciones disponibles para usted como para un desarrollador
cuando se trata de nombrar sus variables. Una opción se denomina "CamelCase". La primera letra
de la primera palabra es en minúsculas, y la primera letra de cada palabra después de eso no tiene
espacios entre palabras. Por ejemplo, si tengo una variable que se denomina "my name" (mi
nombre), voy a poner la M de "mi" en minúscula y el N del nombre en mayúsculas con el resto de
las letras en minúsculas y sin espacio entre las palabras. Puedo tomar un enfoque diferente con
"snake_case". Al utilizar snake_case, mantiene todo en minúsculas, pero utiliza un guión bajo
entre palabras. Si quiero hacer la variable "mi nombre", "my_name" sería el resultado de este
enfoque. Aunque cuenta con diferentes opciones como desarrollador, es una buena idea ser
coherente cuando crea variables a través de sus programas. Voy a borrar la pantalla para poder
comenzar. Creo una variable en Python inicializando una variable y asignándole un valor. Todo lo
que tengo que hacer es nombrar la variable.

pág. 52
Por ejemplo, si escribo X es igual a 5, he declarado una variable y le asigné un valor. También
puedo imprimir el valor de una variable al llamar las sentencias "print" y pasar el nombre de la
variable, que en este caso es X, así que escribo "print X". Cuando ejecuto el programa, obtengo el
valor de cinco, que son las asignaciones que proporcioné a la variable inicial. Volveré a borrar mi
pantalla. Tiene varias opciones cuando decide declarar variables. Se puede declarar cualquier tipo
diferente de variable en términos de valor. Por ejemplo, X podría ser igual a una cadena
denominada "Hello" (Hola).

Para ello, escribo X es igula a "hello". Entonces puedo imprimir el valor de nuevo, ejecutarlo y
encuentro que el resultado es la palabra "hello". Detrás de escena, Python asigna
automáticamente el tipo de datos. Obtendrá más información sobre este tema en un próximo
video sobre tipos de datos. Puede declarar varias variables y asignarlas también a un solo valor.
Por ejemplo, hacer "a", "b", y "c" igual a 10. Hago esto escribiendo "a" es igual a "b" es igual a "c"
es igual a 10. Imprimo los tres valores por separado. Luego hago de nuevo clic en el botón "Run"
(Ejecutar), encuentro que las tres de esas asignaciones tienen 10 como su valor. De nuevo, borro
la pantalla antes de pasar al siguiente ejemplo. Otra opción que tiene es hacer varias asignaciones.

pág. 53
Por ejemplo, escribo "a", "b", "c", separados por comas es igual, 1, 2, 3 también separados por
comas. De esta manera, he asignado cada uno de esos valores a la letra correspondiente. "A" es
igual a 1, "b" es igual a 2, "c" es igual a 3. Para probar esto, puedo imprimir las tres variables. Hago
clic en" Ejecutar", y encontraré que los valores 1, 2, 3 corresponde a la declaración anterior. Otro
punto importante que debe tener en cuenta son las asignaciones de variables y cómo puede
cambiarlas. Una variable está sujeto a cambios. A lo largo del ciclo de vida de su programa, hará
cambios en el valor o la asignación de la variable misma, así que debe saber cómo hacerlo. Vamos
a analizar otro ejemplo. Escribo "a" es igual a 10, e imprimo ese valor. Luego, cambio el valor de
uno a cinco, e imprimo ese valor también. Cuando hago clic en el botón "Run" (Ejecutar), "a" se
imprime como 10 en la primera línea y es cinco en la línea a continuación porque se reasigna el
valor. Por último, necesita saber cómo eliminar una variable. Mi variable, su valor es 10, y la
imprimí, y luego en una nueva línea, escribo el comando "delete" (eliminar), o "del for short",
seguido de un espacio y una letra "a", que representa mi variable. Luego imprimo la variable por
medio de la función de impresión, y hago clic en el botón "Run" (Ejecutar). El valor nos da por
primera vez 10 porque la variable aún existió, pero después de la eliminación, muestra un error
diciendo que "a" no está definido. Acaba de ver convenciones de nomenclatura variable. Ahora ya
sabe cómo declarar una variable y asignar su valor, y sabe cómo declarar cualquier tipo diferente
de variable en términos de valor. Puede declarar varias variables y asignarlas como valor único, y
puede hacer varias asignaciones. Por último, también aprendió a eliminar una variable. Esto nos
lleva al final de este video. Ahora puede identificar variables y reconocer cómo utilizarlas en
Python.

pág. 54
Tipos de datos básicos

Los sistemas informáticos deben interpretar los diferentes valores de datos. En programación, los
datos pueden venir en diferentes tipos. Al final, podrá describir diferentes tipos de datos en
Python. Un tipo de datos es un atributo asociado con un fragmento de datos que indican a un
sistema informático cómo interpretar su valor. Saber qué tipos de datos utilizar garantiza que los
datos se recogen en el formato preferido. También garantiza que el valor de cada propiedad es
como se espera. Python ofrece tipos de datos raw para permitir datos que se asignarán a variables
o constantes. Los cinco tipos principales clasificados como literales son numérico, secuencia,
diccionario, booleano y conjunto. Algunos de estos tipos de datos se pueden ampliar. Por ejemplo,
el tipo de datos numérico puede constar de tipos, entero, flotante y número complejo.

Ahora hablemos de los tipos de datos con más detalle, comenzando con el NUMÉRICO. En
programación, debe decidir qué tipo se adaptará a sus necesidades. Por ejemplo, al trabajar con
moneda, probablemente vaya a utilizar el tipo numérico flotante, ya que permite contar
decimales.

pág. 55
Para determinar un tipo de variable, Python también proporciona un nombre de función tipo, que
proporcionará el tipo de clase basado en la variable que se pasa. Python ofrece tres opciones
diferentes de tipos numéricos, que son enteros, flotantes y números complejos. La clase de entero
representa cualquier número no fraccional, es decir, números enteros sin decimales. Estos
números pueden ser positivos o negativos, por ejemplo, 10 o -10. Los flotantes son números que
contienen decimales y se representan con la clase floats, algunos ejemplos podrían ser 10.5 o 6.7.
La clase compleja se utiliza para representar números complejos que están formados por números
reales e imaginarios, a es igual a 10 +10j.

A continuación, exploraremos los tipos de datos de SECUENCIA. Secuencia de tipos de clústeres

contenedores de tipos que contienen uno o más del mismo tipo en una lista ordenada.

También se puede acceder a ellos en el índice de la secuencia. Python tiene tres tipos de secuencia
diferentes, denominadas cadenas, listas y tuplas. Analicemos brevemente cada una de ellas,
comenzando por las cadenas. Una cadena es una secuencia de caracteres encerrada entre comillas
simples o dobles. Las cadenas se representan mediante la clase de cadena o str para abreviar.

pág. 56
Las listas son una secuencia de uno o más tipos diferentes o similares. Son esencialmente un array
y contienen cualquier tipo entre corchetes.

Se puede acceder a cada elemento por su índice. Las tuplas son similares a las listas de muchas
maneras. Contienen una secuencia ordenada de uno o más tipos, pero la principal diferencia es
que son inmutables. Esto significa que los valores dentro de la tupla no se pueden modificar o
cambiar.

Las tuplas se representan por la clase tupla y mantienen los tipos de datos entre paréntesis.

El siguiente tipo de datos es DICCIONARIO. El diccionario almacena datos en una estructura de

objetos de valor clave. Se puede acceder a cada valor directamente por su clave. Los diccionarios
también pueden almacenar cualquier tipo de datos. Por ejemplo, supongamos que declara una

pág. 57
variable denominada ed y le asigna un diccionario, el diccionario contiene una agrupación de pares
clave-valor. El primer par es a: 22, donde a es la clave y 22 es un valor. El segundo par es b: 44.4,
donde b es una clave y 44.4 es el valor. Luego puede generar el valor de 22 accediendo a su clave,
que es a.

A continuación, exploraremos los tipos de datos BOOLEANOS que se representan simplemente

como verdadero o falso. Combinado con operadores lógicos, los booleanos se utilizan para
comprobar si una condición es verdadera o falsa. En este ejemplo, reviso el tipo de datos
subyacente de los valores verdadero y falso.

Se devuelve la clase bool, lo que significa que es booleano.

El último tipo de datos es SET, que es una colección desordenada y no indexada de valores no
repetidos. Voy a mostrar un ejemplo de este tipo de datos. Supongamos que asigno un conjunto
de cuatro elementos a la variable denominada conjunto de elementos. Luego compruebo el tipo
del valor almacenado en la variable conjunto de elementos al pasarla a la función type.

pág. 58
Python informa que el tipo de datos subyacente que contiene la variable set de ejemplo es un
conjunto.

En programación, el tipo de datos es un concepto importante. Las variables pueden almacenar

datos de diferentes tipos, y diferentes tipos de datos pueden hacer cosas diferentes. Vamos a
explorarlos con más detalle. Siempre que declare una variable en Python, el tipo de datos se le
asigna automáticamente en función del valor de esa variable. Permítame demostrarlo al escribir
una variable denominada a y asignándole un valor de 10. Para comprobar el tipo de datos que ha
sido asignado por Python, selecciono "Print" y utilizo la función type. A continuación, paso la
variable "a" como el parámetro y hago clic en "Ejecutar". Desde la salida en la terminal, puedo ver
que se asignaba una clase de flotantes porque aparecía una posición decimal. Aquí hay otro
ejemplo. Estoy usando la variable "b" y le asigno un valor decimal de 2.3. Para comprobar el tipo
de datos asignado por Python, imprimo el tipo b y hago clic en "Ejecutar".

pág. 59
Desde la salida en la terminal, puedo ver que se asigna una clase de flotantes porque ahí aparece
un decimal. Se trata de una asignación diferente que el entero estándar. Estos son los tipos de
datos numéricos que ofrece Python. Para declarar una variable como cadena, puse un texto entre
comillas simples o dobles. De nuevo, ejecuto la sentencia "print" para el tipo de función y paso la
variable "c" como el perímetro. Luego hago clic en "Ejecutar", las salidas y la terminal ahora
muestra las clases int, float y str para la cadena.

Esta secuencia también se puede aplicar a otros tipos de datos. Por ejemplo, puedo crear una lista
de números mediante la variable "d" y asignándole los números 1, 2, 3, 4. Cuando ejecuto la
sentencia print con un tipo de función y paso la variable "d" como parámetro, aparece la lista de
clases luego de hacer clic en "Ejecutar". Cada vez que asigno un valor a una variable concreta,
Python asigna automáticamente el tipo de dato correcto de esa variable. En este video ha
aprendido sobre los diferentes tipos de datos en Python. Lo invito a que comience a experimentar
con estos tipos de datos en su código de práctica.

pág. 60
Cadenas

Tal vez recuerde que Python puede funcionar con varios tipos de datos. En este video, aprenderá
cómo declarar y utilizar cadenas en Python. También obtendrá conocimientos generales de las
secuencias y cómo acceder a elementos individuales en una secuencia. En Python, una cadena es
una secuencia de caracteres adjuntos en comillas simples o dobles. Como sabrá, las computadoras
solo comprenden el código binario, que consiste en unos y ceros. Esto significa que los caracteres
se deben convertir a una forma que las computadoras puedan interpretar, un proceso conocido
como codificación.

Python utiliza un tipo de codificación denominado Unicode para comunicarse con computadoras.
Las cadenas en Python se pueden declarar de varias maneras. Por ejemplo, para una sola línea,
puede escribir la variable "nombre" seguido de un signo de igual y luego el caracter incluido en las
comillas. Si su cadena es demasiado larga para una línea, puede agregar una barra diagonal al final
de cada línea para crear una declaración multilínea.

pág. 61
Cuando ejecuta la impresión en su variable, todas esas cadenas se combinan y aparecen en una
línea.

Si es necesario, puede reasignar el valor de una cadena. Digamos, por ejemplo, el nombre de la
variable tiene un valor de cadena de John, pero desea cambiar el valor para Paul, lo que se puede
hacer simplemente escribiendo el nombre es igual a Paul. Ahora, cuando se ejecuta imprimir en
nombre, se debe reflejar esta actualización.

Es importante saber que una cadena es solo una secuencia de caracteres, lo que, a su vez, significa
que es esencialmente una matriz. Se puede acceder a cada caracter de la secuencia en función de
su índice. Por ejemplo, las cadenas Python utilizan indexación cero.

pág. 62
Puede acceder al primer caracter con un número 0 entre corchetes, o el número 2 para acceder
al tercero. Si necesita verificar la longitud de una cadena, Python tiene funcionalidades para
ayudarlo. Puede aplicar la función "len" a una variable con un valor de cadena. Esto entonces
devolverá un número que representa cuántos caracteres hay en la cadena. Ahora que aprendió
qué cadenas hay en Python, vamos a ver algunos ejemplos de código de cadenas en acción. En
primer lugar, permítanme demostrar las dos formas de declarar una cadena. El primer método es
colocar los caracteres dentro de comillas simples. Escribí un igual y luego 'hello' (hola) entre
comillas. En la siguiente línea, cuando escribo imprimir seguido por "a" entre paréntesis y luego
hago clic en el botón "Ejecutar", mi código devuelve la cadena "hello" como resultado. El segundo
método es similar, pero utiliza comillas dobles. Lo ingresaría como "b" es igual a "hello" (hola) con
comillas dobles. Ejecuto la función "imprimir" de nuevo, también devuelve la cadena "hello".
Ambos tipos de comillas son métodos de declaración igualmente válidos. La elección es una
cuestión de preferencia personal, pero lo mejor es elegir una opción y utilizarla de manera
consistente a lo largo de su código. Además de la tipos de comillas, puede declarar cadenas de
una sola línea o multilíneas. Un ejemplo de una sola cadena de línea puede ser "a" es igual a una
sola línea. Solicité imprimir el valor de "a". Cuando lo ejecuto, el valor se imprime a medida que lo
declaro. Sin embargo, puede haber casos en donde una cadena es muy larga, y quiere romperla
en segmentos para hacerla más legible. Para hacer eso, puedo utilizar la tecla Backslash para crear
una cadena de varias líneas. Para declarar una cadena multilínea, escribo "b" es igual seguido por
la cadena, esto es una multi. Antes de continuar, agrego una barra oblicua invertida al final de esta
línea. En la siguiente línea, escribo la continuación de mi cadena, ejemplo de cadena de línea.

pág. 63
Tenga en cuenta que los signos se espaciaron antes de la línea de palabra para que se separe de
la última palabra de la cadena en la línea anterior. Cuando ejecuto la impresión en "b", la barra
diagonal invertida tiene el efecto de unir ambos segmentos para que aparezcan las salidas como
una sola cadena. Otra cosa que puede hacer con cadenas es la concatenación, que es la unión de
cadenas separadas. Para demostrarlo, primero creo dos variables nuevas, "a" es igual a "hello",
con un espacio al final y "b" es igual "there". Cuando ejecuto la impresión esta vez, entre
paréntesis, escribo un signo más "b" y vuelvo a unir ambas cadenas. El símbolo más se suele utilizar
como operador aritmético, pero cuando se aplica en cadenas, en cambio las combina. Una cosa
más para saber sobre las cadenas es que se consideran colecciones de caracteres. Esto significa
que muy parecido a una matriz, puede acceder a caracteres individuales según un índice, y
también puede consultar la longitud de una cadena mediante L-E-N o función "len".

Para darle un ejemplo, intenté nombrar la variable, con un valor de cadena, John. Ahora, quiero
imprimir solo el primer caracter de la cadena. Para ello, ejecuto "print on name" seguido del
número de índice de caracteres entre corchetes. Las cadenas en Python no están indexadas, lo
que significa que el recuento de secuencia comienza desde cero, entonces cero es un número que
coloco entre corchetes. Cuando hago clic en "Ejecutar", recupero la letra "J". Si cambio el número
a tres y lo ejecuto de nuevo, obtengo la letra "n", el cuarto caracter de la cadena John.

pág. 64
A continuación, comprobemos cuántos caracteres están en esta cadena utilizando la función "len".
Comienzo una función de impresión y en ella, escribo "len" seguido por nombre entre paréntesis.
Cuando lo ejecuto, devuelve cuatro, como la longitud. En este video, ha aprendido sobre las
cadenas en Python. Específicamente, ahora sabrá cómo declararlos y usarlos y entender que son
secuencias de caracteres. Nos vemos en el siguiente video.

pág. 65
Tipos de datos básicos y función "Cheatsheet"

Aquí tiene una referencia rápida para los tipos de datos en Python.

Control de caudal

Comentarios

Comentarios de una línea

Si coloca un símbolo # delante del texto que desea que sea un comentario, Python ignorará todo
desde ese punto hasta el final de la línea actual.

pág. 66
Comentarios en varias líneas

En realidad, Python no tiene un método para comentarios de varias líneas, por lo que se puede
utilizar un símbolo # en cada línea.

Comentarios en línea/de código

El símbolo # hará que Python ignore todo desde ese punto hasta el final de la línea actual, por lo
que se pueden crear comentarios en línea de este modo.

Funciones integradas

print()

Esta función busca el dispositivo de salida predeterminado, su terminal, y muestra el valor que se
le pasa.

entrada()

Esta función busca el dispositivo de entrada predeterminado, su teclado, y captura el valor. Este
valor se puede asignar o utilizar.

pág. 67
len()

Esta función devuelve la longitud o el recuento de los elementos contenidos en la estructura en la

que se aplica. Puede ser una cadena, una matriz, una lista, una tupla, un diccionario o cualquier
secuencia.

str()

Esta función se puede utilizar para convertir el valor proporcionado en una String

int()

Esta función se puede utilizar para convertir el valor proporcionado en un int

pág. 68
float()

Esta función se puede utilizar para convertir el valor proporcionado en un float

Creación de funciones

Las funciones en Python requieren una palabra clave para definirlas: def seguida de un
identificador (un nombre) que forma la firma de la función. El cuerpo de la función contiene el
código que se ejecutará cuando se llame a la función.

pág. 69
Fundición de tipo

Python utiliza diferentes tipos de datos de procesamiento, usa la información de manera efectiva.
A veces es necesario cambiar el tipo de datos de una variable luego de haber recopilado valores
para ella. Por ejemplo, un usuario envía un formulario en nuestro sitio web. Uno de los campos
era un entero, pero los datos se pasaron como cadena. Esto es un problema porque la única forma
de realizar cálculos con los números guardados como una cadena es convertirlos en un tipo de
datos entero. Para ello, puede utilizar fundición de tipos en Python. En este video, aprenderá sobre
dos métodos diferentes de fundición de tipos en Python. También aprenderá a aplicar fundición
de tipos mediante las funciones de Python proporcionadas. ¿Qué es la fundición de tipos? La
fundición de tipos es el proceso de conversión de un tipo de datos a otro. Python tiene dos tipos
diferentes de conversiones: implícitas y explícitas. Exploremos cada una con mayor detalle,
comenzando por implícita. La conversión de tipo de datos implícita la realiza automáticamente el
compilador de Python para evitar la pérdida de datos. Convertirá, por ejemplo, un "int" a "float"
si selecciona que el valor insertado es un decimal.

Es importante tener en cuenta que Python solo podrá convertir valores si los tipos de datos son
compatibles. "int" y "float" son compatibles pero "strings" e "int" no lo son.

pág. 70
Si los tipos de datos no son compatibles, Python generará un error de tipo. Como alternativa, los
desarrolladores pueden realizar fundición de tipos con la conversión explícita de tipos de datos.

Para ello, utilice las funciones de Python proporcionadas. Existen muchas funciones, pero algunas
de las más comunes son "string" (cadena), "integer" (entero) y "float" (flotante). Permítame
guiarlo por algunas de estas funciones y cómo utilizarlas. La primera es la función costo de cadena.
Se utiliza para convertir cualquier tipo de datos en un tipo de datos de cadena. Para usar esta
función, escriba str seguido del valor que desea convertir entre paréntesis. La siguiente es la
función "int" tipo "casting". Use este tipo "int" seguido del valor que desea convertir entre
paréntesis. La función flotante es otro tipo común de función de costo. Una vez más, escriba la
palabra "float" y agregue el valor que desea convertir entre paréntesis. Python tiene muchas más
funciones de tipo "casting" y también tienen una estructura similar. Son todas "ord", que
devuelven un número entero que representa el caracter "unicode" subyacente. La función "hex",
que convierte un entero dado a una cadena hexadecimal. Una "oct" que toma un entero y

pág. 71
devuelve una cadena que representa un "oct" a un número. También existen "tupla", "set", "list",
y "dict", sobre las que obtendrá más información más adelante en la lección.

En este video, ha aprendido sobre el tipo "casting" en Python. Es importante recordar que los tipos
de datos no son intercambiables. Puede convertir tipos de datos mediante las funciones de Python
si lo necesita.

pág. 72
Entrada de usuario, salida de consola

Como otros lenguajes de programación, Python se centra en tomar entradas de usuarios u otros
servicios y proporcionar un resultado. Python tiene muchas funciones de ayuda que hacen que
sea fácil realizar ambas acciones. Puede que recuerde que utiliza la función "print" para imprimir
las variables y otros valores. En este video, obtendrá más información sobre la función "print" y
cómo utilizar otra función nueva denominada "inputs".

La función "input" está diseñada para obtener datos de una fuente de entradas, y también se
puede utilizar de diferentes maneras, por ejemplo, uno de sus usos más básicos es cuando utiliza
la función "input" para obtener datos que el usuario escribe en el teclado. Esta entrada se puede
imprimir en la pantalla. En muchos casos, querrá obtener información directamente de un usuario.
Por ejemplo, cuando solicita la dirección de correo electrónico del usuario, digamos que quiere
utilizar la función "input" para pedir al usuario que introduzca su dirección de correo electrónico
y luego guardar esa entrada en una variable denominada correo electrónico.

Si ejecuta este código, al usuario se le presentará un mensaje para introducir su correo electrónico.
La variable de correo electrónico contendrá la dirección.

pág. 73
Volvamos a la función de impresión, que se utiliza para salidas en Python. Se puede utilizar para
imprimir todos los diferentes tipos de datos y permite un formato más complejo.

La propia función de impresión acepta cualquier número de argumentos, Por ejemplo, separados
por comas, para imprimir números en secuencia. Aritmética para imprimir la salida de una

pág. 74
ecuación, y la concatenación de cadenas a unir o concatenar dos cadenas. La función de impresión
de Python también tiene reservadas palabras clave que se pueden analizar como argumentos
adicionales.

Incluye objetos, que son valores impresos en pantalla, "sep", que define cómo se imprimen los
objetos o se separan y "end", que define lo que se imprime al final. También hay un archivo que
especifica dónde se imprimen los valores, que por defecto es "STD out". Por último, "flush", una
expresión booleana para vaciar el "buffer" o memoria intermedia, que básicamente mueve los
datos de un almacenamiento temporal al almacenamiento de memoria permanente de las
computadoras.

Por ejemplo, supongamos que puede pasar tres parámetros a la función de impresión, la palabra
"hello" (hola), que es una cadena, la palabra "you" (tú), que es otra cadena, y "sep", que es un

pág. 75
parámetro integrado cuyo valor se establece en una cadena que contiene una coma y un espacio.
Se utilizará como separador entre las cadenas "hello" y "you", y la salida es "hello you". A menudo
mientras programa, necesita conocer el valor de una variable y las salidas en la pantalla.

Python permite el formato directo dentro de la sentencia "print".

También puede controlar el orden mediante los números dentro de las llaves. Por ejemplo, si
imprime las mismas sentencias dos veces, pero con un número cambiado, los resultados serán
diferentes.

Pasemos a una aplicación más práctica de lo que aprendió mediante algunos ejemplos de código
de entrada y salida. Voy a demostrar cómo utilizar entradas y salidas en Python. Empezaré por
mostrar la función de entrada. Escribiré entrada, paréntesis de apertura y paréntesis de cierre.

pág. 76
Luego hago clic en el comando Ejecutar. Notará que ejecuta la función de entrada. Se me
proporciona una consola donde puedo realmente escribir una entrada. Escribo "Hello" (Hola) y
presiono "Enter" (Intro). No pasa nada, porque en realidad no estoy recopilando datos. Sólo estoy
disparando la función de entrada. Por defecto, abrirá el acceso a la línea de comandos o la consola
y me permitirá introducir datos. También puedo añadir un "prompt" a la función de entrada. Por
ejemplo, puedo hacer una pregunta a los usuarios como, "Please enter a number", así que escribo
"Please enter a number" entre paréntesis luego de la palabra introducida. Primero borro la consola
y luego haré clic en Ejecutar. De nuevo, notará que los resultados ahora me piden que introduzca
un número. escribo cinco y pulso "Enter" (Intro). De nuevo no aparece nada desde la perspectiva
de la salida. Esto es porque en realidad no hice nada con el valor de entrada. Solo muestro cómo
funciona la función de entrada. Si quiero obtener el valor de la entrada, necesito asignar una
variable. Escribo "num" igual a "input". Por favor, introduzca un número. Reclamo la pantalla de
mi consola y hago clic en el botón "Ejecutar". Me pide un número en la consola y escribo el número
seis esta vez. Ahora el "num", o valor numérico tendrá el número seis. Pero para ver eso, tengo
que generar esa variable en la pantalla. Puedo hacerlo mediante otra función denominada la
función de impresión. En este caso, imprimo el número después de la entrada y escribo paréntesis
de apertura, el número de abreviatura y un paréntesis de cierre. Borro la pantalla de nuevo y hago
clic en "Ejecutar". Esta vez escribo el número siete. Cuando se me pide que introduzca un número,
pulso "Enter" (Intro) y vemos que la salida imprime siete. Ahora quiero mostrarle que puede
recopilar más de una entrada como parte de la entrada porque las entradas funcionan de modo
secuencial. Denomino esta variable "num one" (número uno), e ingreso otra variable denominada
"num two" (número dos) en la línea siguiente. La entrada para esta variable es "please enter a
second number" (introduzca un segundo número). Acabo de cambiar las primeras variables de
entrada a "please enter a number" (introduzca un número) para que las instrucciones sean más
claras. Imprimo el valor de num uno, num dos. La sentencia "print" acepta ambas variables porque
están separadas por una coma, e imprimirá cada una en ese orden. Una vez más, borro la consola
y hago clic en Ejecutar. Escribo cuatro como primer número. Presiono "Enter" (Intro) y escribo
"cinco es el segundo número", seguido de la tecla "Enter" (Intro) otra vez, observará que 4 y 5
están impresos. También puede realizar operaciones aritméticas dentro de la sentencia "print".

pág. 77
En otras palabras, puede sumar, sustraer, multiplicar y dividir. En lugar de utilizar comas en la
sentencia "print", escribo número uno más número dos. He borrado la pantalla una vez más y hago
clic en Ejecutar. Ingreso los números 5 y 4 otra vez, y obtengo 54. Esto no es exactamente lo que
quería hacer, y la razón es porque ambas variables son cadenas. Esto se remonta a lo que ha
aprendido previamente con tipos de datos. Si quiero hacer el cálculo aritmético, primero tendré
que convertir cada variable en un entero. Puedo utilizar la función de enteros en num uno, num
dos. Vuelvo a hacer clic en el botón Ejecutar e ingreso los mismos dos números, 5 y 4. Pero ahora
lo que obtengo es nueve. Si quiero ver qué tipo de entrada es, puedo comprobar el tipo de datos
mediante la función "type". Para ello, escribo "print" y abro paréntesis, la palabra "type" y abro
paréntesis, número uno, seguido de dos paréntesis de cierre. Primero voy a despejar la pantalla.
Hago clic en Ejecutar e ingreso los números 5 y 4 de nuevo en la consola. Dice que la clase es
"string" y no "integer", que es el tipo con el que realmente quiero hacer aritmética. Tenga en
cuenta cuando utilice entradas que obtendrá una cadena.

Lo más probable es que tenga que utilizar la fundición de tipo de datos explícita para convertirlo
al tipo de datos que necesite. Las sentencias "print" también se pueden utilizar para la
concatenación. En lugar de num uno, lo cambié a STR uno o cadena 1 y hago lo mismo con num
dos cambiándolo por STR dos. Entonces agrando la entrada para leer, introduzca su nombre para
la cadena uno, e introduzca su segundo nombre para la cadena dos. Después, imprimo hola. Luego
utilizo la concatenación para que se salude al usuario por su nombre y apellido. Ahora quiero
ejecutar este programa, Permítame despejar la terminal, rápidamente y luego hacer clic en
ejecutar. En la consola, escribo "Tom" para el nombre y "Jones" para el apellido. El resultado es la
salida de "hello Tom Jones" (hola Tom Jones).

pág. 78
La concatenación también se puede utilizar con una sentencia "print". Por último, también puede
cambiar la forma de asignar variables.

No es necesario que utilice la concatenación, puede tan solo usar el reemplazo de cadenas. Para
esto, voy a utilizar una función dentro Python denominada "formatos". Según el orden de los
corchetes, puede pasar las variables con las que quiere que sea reemplazado. En este caso, las
cadenas 1 y 2. Una vez más, hago clic en "Ejecutar" e introduzco el nombre de usuario de "Tom
Jones". Se imprime "Hello, Tom Jones". En este video, ha ampliado sus conocimientos al aprender
acerca de las entradas y la función de salida en Python.

pág. 79
Tipo de fundición, un aspecto más profundo

Existen algunos escenarios en los que el tipo de datos de un valor determinado se debe cambiar a
otro tipo de datos.

Este proceso se conoce como fundición tipográfica.

Otra forma más informal de referirse al proceso es "conversión de tipo de datos".

El ejemplo más sencillo de convertir datos podría ser la siguiente comparación:

En el fragmento de código anterior, le pregunto a Python si el número 10 es igual al número 10, y

obtendré el valor booleano True impreso, confirmando que, efectivamente, son iguales.

¿Qué ocurre si hago esto?

De nuevo, el valor booleano True aparece en la pantalla.

Ahora, usted podría decir que, bueno, 10 no es técnicamente igual a 10.0 porque, uno podría
argumentar, el primer número es un entero, y el segundo número es un flotante. Tendría razón,
aunque son los mismos números, no son los mismos tipos de datos.

Sin embargo, Python realiza aquí lo que se conoce como "conversión implícita de tipos".

pág. 80
Para comprender cómo funciona, modificaré un poco el ejemplo anterior. En lugar de pedirle a
Python que compare los dos números y devuelva si son iguales o no, le pediré a Python que
imprima el resultado de sumar estos dos números.

El resultado impreso es 20.0.

Esta salida me permite concluir que cuando Python ejecuta operaciones con enteros y flotantes,
convierte implícitamente el tipo de enteros en un flotante y luego completa la operación.

Para comprenderlo mejor, puedo ampliar mi ejemplo anterior utilizando la función type():

La salida es <class 'float'>, entonces se confirma mi conclusión.

Permítame mostrarle un programa pequeño en Python, trabajando con números:

Cuando ejecuto este programa, podría, por ejemplo, proporcionar el valor del primer número
como 5 y el valor del segundo número también como 5, y esperar que el valor user_sum impreso
sea 10.

Sin embargo, cuando hago exactamente eso, el número 55 se imprime en su lugar.

pág. 81
¿Por qué no funcionaba?

Bueno, la respuesta es bastante simple: todo lo que un usuario escribe, se convierte, mediante
Python, al tipo de datos de cadena.

Esto significa que, aunque escribí números en estas dos entradas, lo que se guardó en user_num_1
y user_num_2 en realidad eran cadenas.

Efectivamente, es exactamente lo mismo que si hubiera hecho esto:

Esta vez, la salida de imprimir user_sum sigue siendo "55", pero esto no es ninguna sorpresa.

Para que mi código Python funcione como me propongo, necesito realizar la conversión explícita
de tipos.

En otras palabras, tengo que convertir el valor de "5" al valor de 5.

Aquí está mi código actualizado:

Lo que estoy haciendo aquí es asegurarme de que mi programa puede manejar e incluso aceptar
flotantes como entradas, y continuar con su funcionamiento normal.

En otras palabras, me aseguro de que si un usuario proporciona el valor flotante de 5.5 como
primer y segundo número al ejecutar el código anterior, la salida no arrojará un error. En su lugar,
será el 11.0 esperado.

¿Y si decido enviar unas palabras al usuario para contarle lo que ha pasado?

pág. 82
Este es un intento de hacerlo:

Si ejecuto el código anterior, generará el siguiente error:

Traceback (most recent call last):

File "<string>", line 4, in <module>

TypeError: can only concatenate str (not "float") to str

Lo que significa que no puedo concatenar una cadena y un flotante así. En otras palabras, aunque
la conversión de tipos implícita de Python funciona cuando utilizo el operador + en cadenas y
enteros, no funciona en cadenas y flotantes.

La solución es realizar la conversión de tipos explícita, de la siguiente manera.

Esta vez, la salida es: The sum of 5.5 and 5.5 is 11.0.

En Python, es fácil realizar conversiones explícitas, y a veces son muy útiles. Obtendrá más
información sobre cómo funciona esto a medida que adquiera más experiencia en Python.

pág. 83
Tareas de programación: Escribir entrada de fundición

Introducción

En este laboratorio se le presentarán tres ejercicios para demostrar cómo se puede utilizar la
fundición de tipos explícita para resolver los datos que introduce un usuario final. En cada ejercicio
se le pedirá que resuelva un problema concreto relacionado con los tipos.

Objetivo

• Comprender cómo y dónde utilizar la fundición implícita.

Objetivos

• Ejercicio 1: Utilizar la fundición explícita para aplicar el tipo de fundición correcto

• Ejercicio 2: Corregir el script para que genere correctamente el total de la factura

Instrucciones para el alumno

Ejercicio 1

Paso 1: Abrir el script exercise1.py presente dentro de la carpeta del proyecto

Paso 2: Para ejecutar el script, abrir el terminal y ejecutar el comando python3 exercise1.py.

pág. 84
Paso 3: Corregir el script para que las variables tengan el tipo correcto.

Ejercicio 2

Paso 1: Abra el script exercise2.py presente dentro de la carpeta del proyecto

Paso 2: Para ejecutar el script, abra el terminal y ejecute el siguiente comando.

python3 exercise2.py

Paso 3: Corrija el script para que genere el total de factura correcto en función de los datos
ingresados.

pág. 85
# Using explicit type conversion, change the following
# inputs so the types match with the following below
#
# name = type string
# age = type int
# height = type float
# loyalty = type boolean

# Modify the line below

name = str(input('What is your name? '))

print(f"Type of name variable is: {type(name)}. It should be <class 'str'>")

# Modify the line below

age = int(input('What is your age? '))

print(f"Type of age variable is: {type(age)}. It should be <class 'int'>")

# Modify the line below

height = float(input('What is your height in meters? '))

print(f"Type of height variable is: {type(height)}. It should be <class 'float'>")

# Modify the line below

loyalty = bool(input('Are you part of our loyalty program? '))

print(f"Type of loyalty variable is: {type(loyalty)}. It should be <class 'bool'>")

pág. 86
# The below script will ask for 3 inputs. Each input will be based
# on the price of the items - the price is determined by you. The output
# should print the total of the 3 inputs rounded to 2 decimal places e.g
#
# 1 coffee @ $ 2.00
# 1 sandwich @ $ 4.99
# 1 cake @ $ 2.75
#
# Your total bill is $ 9.74

# Modify the line below

coffee = float(input('1 coffee @: $ '))

# Modify the line below

sandwich = float(input('1 sandwich @: $ '))

# Modify the line below

cake = float(input('1 cake @: $ '))

bill_total = coffee + sandwich + cake

print('Your total bill is $', bill_total)

pág. 87
pág. 88
Comprobación de conocimientos - Bienvenido a la programación en Python

pág. 89
Recursos adicionales

Python permite hacer muchas cosas con muy poco código. En comparación con otros lenguajes
como Java o C#, Python tiene una curva de aprendizaje mucho más sencilla. Se adapta bien a la
filosofía "escribir menos, hacer más". Los desarrolladores de Python también están muy
solicitados, y aprender a programar en Python es una buena opción profesional.

Puede acceder a los siguientes enlaces para obtener más información sobre la programación en
Python.

Consulte el sitio web de Python para obtener más información sobre las funciones integradas:

https://docs.python.org/3/library/functions.html

Visite W3 Schools para obtener más información sobre codificación y desarrollo web:

https://www.w3schools.com/python/default.asp

Consulte HackerRank para practicar sus nuevos conocimientos de Python:

https://www.hackerrank.com/domains/python

pág. 90
FLUJO DE CONTROL Y CONDICIONALES

Operadores matemáticos y lógicos

Un operador es un símbolo que le indica a Python realizar una determinada operación. Son como
señales de tránsito en la vida real.

Por ejemplo, supongamos que está conduciendo por una carretera peligrosa y ve una señal de
alerta para reducir la velocidad, después se encuentra con una señal de pare y, por último, le
asignan instrucciones para girar a la derecha. Puede que no se haya dado cuenta de que estaba
en una carretera peligrosa. Estos símbolos lo ayudan a mantenerse a salvo indicándole que realice
una operación específica. Del mismo modo, cuando Python se encuentra con un operador que
usted coloca en su código, también realizará esa operación específica.

Estas operaciones pueden ser matemáticas, lógicas, y de comparación. Se aprenderá sobre los
operadores matemáticos y lógicos en Python. La mayoría de las veces, los operadores trabajan en

pág. 91
dos valores. Los operadores matemáticos se utilizan para cálculos simples y complejos.
Esencialmente, todas las mismas opciones que tendría una calculadora. Lo explicaré con ejemplos
de operadores matemáticos y lógicos. El primer operador que quiero que conozca es el operador
de suma o +. El signo más es un símbolo que se debe utilizar al sumar números. Por ejemplo, 2 +
3. Para restar números entre sí, se utiliza el operador de resta o -. Utilice el signo menos para
restar números. Un ejemplo sería 3 - 2. El operador de división es el siguiente, y el símbolo que se
utiliza es una barra oblicua /. La división es una operación en la que un número se divide por otro.
Por ejemplo, 35 / 5. El último operador que necesita conocer es el operador de multiplicación. El
símbolo que utilizamos es la tecla estrella o *. Utilícelo para multiplicar números entre sí. Por
ejemplo, 7 * 4.

Ahora veamos los operadores lógicos. Los operadores lógicos se utilizan en Python en sentencias
condicionales para determinar un resultado verdadero o falso. Exploremos ahora algunos de ellos.

pág. 92
El primer operador lógico se denomina "y". Este operador comprueba que todas las condiciones
sean verdaderas. Por ejemplo, a es mayor que 5 y a es menor que 10. El segundo operador lógico
se denomina "o". Este operador comprueba que al menos una de las condiciones sea verdadera.
Por ejemplo, a es mayor que 5, o b es mayor que 10. El operador final se denomina "no". Este
operador devuelve un valor falso si el resultado es verdadero. Por ejemplo, a es no mayor que 5.

Los operadores suelen combinarse con sentencias condicionales para controlar el flujo de un
programa que cumple con criterios específicos. Por ejemplo, digamos que un restaurante da

pág. 93
descuentos basados en las dos siguientes condiciones. ¿Forma parte el cliente del programa de
fidelización, y ha gastado más de $100?

Para determinar esto, puede escribir el código mediante operadores lógicos para comprobar si un
cliente está en el programa de fidelización y si ha gastado más de $100.

Obtendrá más información sobre las sentencias condicionales en una lección posterior. Ahora,
permítame demostrar cómo utilizar los operadores lógicos matemáticos de Python. Los
operadores matemáticos le ofrecen básicamente la misma funcionalidad que tiene en una
calculadora estándar, para poder realizar operaciones como suma, resta, división, multiplicación.
Empiezo con un ejemplo sencillo de suma. Utilizo las sentencias print para que la salida se muestre

pág. 94
en mi consola. Escribo Imprimir y en el paréntesis agrego 2 más 2. El valor que espero de vuelta
es 4. Cuando ejecuto esta sentencia, el valor de 4 se muestra en la terminal. Para la resta, cambio
el signo más por un signo menos. Hago clic en el botón Ejecutar y el valor que se muestra es 0. Si
resto 2 menos 2, la respuesta es 0. Para la división, cambio el signo menos por una barra oblicua.
Escribo 35 barra oblicua 5 entre paréntesis, hago clic en el botón Ejecutar y el resultado es el valor
de 7.0. Sólo para tener en cuenta, el valor devuelto es un flotante en lugar de un entero. Ahora
vamos a hablar de la multiplicación. He cambiado la barra oblicua por un signo estrella que
representa la multiplicación. Escribo 25 asterisco 5. Hago clic en el botón Ejecutar y me devuelve
el valor de 175. Esa fue una breve introducción a los operadores matemáticos. A continuación,
explorará operadores lógicos. Los operadores lógicos se utilizan para controlar el flujo de su
aplicación. Los operadores lógicos son; "y", "o" y "no". Veamos las distintas combinaciones de cada
uno de ellos. En este ejemplo, declaro dos variables, a igual a verdadero y b también igual a
verdadero. Desde estas variables utilizo una sentencia "if". Escribo "if" "a" y "b" dos puntos, y en
la siguiente línea, Escribo imprimir, entre paréntesis y comillas dobles, Escribo, todo verdadero.
En breve aprenderá sobre la sentencia if. Pero por ahora, basta con saber que esta sentencia
"print" solo se ejecutará si tanto "a" como "b" son verdaderos. La sentencia "print" de todos los
verdaderos se muestra en la terminal. Si cambio el valor de "b" a falso y vuelvo a ejecutar la
sentencia, nada se imprime. La razón es que la sentencia "and" como condición es "a" y "b"
verdaderas para que imprima la sentencia. Ahora vamos a ver el operador OR. Cambio "and" a
"or", y hago clic en el botón Ejecutar. Todos los valores verdaderos se han impreso. La razón es
que con el operador OR, si "a" es verdadera o "b" es verdadera, la sentencia "if" es verdadera. Si
configuro los valores de ambas variables en falso y hago clic en el botón Ejecutar, nada se imprime.
Esto se debe a que "a" es falso y "b" es falso por lo que la condición de la sentencia "if" no se ha
cumplido. En este último ejemplo, voy a demostrar el operador NOT. Me quedo con el operador
OR. Antes de "or", escribo "if not a" entre paréntesis, entonces "or" no puede estar entre
paréntesis, seguido de dos puntos. Hago clic en el botón Ejecutar y el valor devuelto es todo
verdadero. Lo que está haciendo, es buscar una negación contra a. Así que "not a", no es falso, lo
cual es cierto. La negación de B, que resulta en B verdadero o condición, comprueba si alguno de
los dos es verdadero. Ahora cambio la "a" y la "b" para que sean verdaderas. Hago clic en Ejecutar

pág. 95
y no se imprime nada. La razón de esto es que al comprobar de nuevo para "if not a",
esencialmente, "if a" es no verdadero. En este caso, "a" es verdadero y su negación es falsa, por
lo que no va a cumplir esa condición. "Or not b" también resulta falso y tampoco cumple esa
condición porque ambos son la negación de verdadero. Esto aun no va a imprimir ningún valor
porque de nuevo, ninguna de las condiciones se cumple. Esta es una breve introducción al uso de
los operadores matemáticos y lógicos en Python. Felicitaciones, aprendió sobre operadores
matemáticos y lógicos. Gran trabajo. Si desea más información sobre los operadores matemáticos
en Python, hay una lectura adicional al final de esta lección.

pág. 96
Flujo de control: If/else, else if

En programación, es importante entender cómo controlar el orden en que se ejecuta el código.

Por ejemplo, supongamos que está invitado a un evento; antes de ir debe pensar si necesita vestir
formal o informalmente. Otro ejemplo de flujo de control es un interruptor de luz.

pág. 97
El flujo está representado por la corriente eléctrica y el control es el propio interruptor, con los
dos estados de encendido y apagado. El orden en que toma las decisiones es importante, y lo
mismo se aplica a la escritura de programas efectivos. En este video, explicaremos cómo utilizar
sentencias condicionales para el flujo de control en programas Python. ¿Qué es el flujo de control?
El flujo de control se refiere al orden en que se ejecutan las instrucciones de un programa. En
todos los programas hay que tomar decisiones. Como resultado, el programa tomará diferentes
acciones o direcciones.

En Python, existen dos tipos de flujos de control. En primer lugar, puede utilizar sentencias
condicionales como "if", "else", y "elif" o "else if". En segundo lugar, puede utilizar bucles como el
bucle "for" y el bucle "while". Conozcamos un poco más del tema. La palabra clave "if" establece
que si la condición resulta ser cierta, se realiza una función. La palabra clave "else" atrapa cualquier
cosa que no atrapan las condiciones anteriores. La palabra clave "elif" o "else if" es la forma de
Python de decir si las condiciones anteriores no fueron verdaderas, entonces intente esta
condición. El bucle "for" comprueba las condiciones específicas y luego ejecuta repetidamente un
bloque de código siempre que se cumplan esas condiciones. El bucle "while" repite un bloque
específico de código un número desconocido de veces hasta que se cumple una condición.

pág. 98
Veamos con más detalle las sentencias condicionales con algunos ejemplos prácticos usando "if",
"else" y "elif". Ahora voy a escribir un código para un restaurante que quiere aplicar diferentes
descuentos en función del monto que su cliente gasta. Para comenzar, defino una variable para la
factura del cliente. La denominaré "bill_total" y le asignaré el valor de 114. Ahora, aplico la
condición con una sentencia "if". Si "bill_total" es mayor a 100, imprimo la sentencia "la factura es
mayor a 100". A continuación, para aplicar un descuento a "bill_total", necesito crear una segunda
variable. Lo haré encima de la sentencia "if" en mi código, la denominaré descuento1 y le asignaré
un valor de 10. La condición también tiene que cambiar. Dentro de la sentencia "if". Agrego
"bill_total" igual a "bill_total" menos descuento1. Al final del fragmento de código, fuera de la
sentencia "if", voy a imprimir cuál es el valor de la factura total. Para ello, escribo una sentencia
"print" que dice la factura total y luego un signo más. Para añadir aquí el valor de bill_total,
necesito convertir el entero en una cadena. Para ello, utilizo la función "str typecasting".

pág. 99
Hagamos clic en "Run" (Ejecutar), genial. En la terminal, se imprimen dos cadenas, "la factura es
mayor a 100" y "la factura total es 104". Pero, ¿qué ocurre si la factura es menor a 100? Cambio
el valor de bill_total a 95 y presiono "Run" (Ejecutar). Observe que esta vez, debido a que no se
cumple la condición "if", solo se imprime la sentencia que la factura total es 95. Pero me gustaría
imprimir una sentencia que dijera que la factura es menor que 100. Para ello, agrego una sentencia
"else" debajo de la sentencia "if". Escribo "else": y en la siguiente línea imprimo la sentencia "la
factura es menor a 100". Vamos a ejecutar el código.

La salida en la terminal ahora dice que "la factura es menor a 100 y que "la factura total es de 95".
Hasta este punto, ha visto cómo utilizar las sentencias "if" y "else" para controlar el orden en que
se asignan e imprimen los valores. Ahora está listo para llevar el flujo del programa un paso más
allá. Digamos que este restaurante quiere agregar otro descuento para facturas superiores a 200.
¿Cómo lo haría? Una vez más, primero debo crear una nueva variable sobre las condiciones que
denomino "discount2", que establezco que sea igual a 20. Si ejecuto el código ahora, se imprimirá
el mismo resultado porque no he cambiado ninguna de las condiciones o valores todavía.
Cambiemos el valor del total de la factura a 210 y hagamos clic en "Run" (Ejecutar). Observe que

pág. 100
ambas sentencias se imprimen, pero se sigue aplicando el descuento1. Está claro que la sentencia
"if" aún se ejecuta. Como el valor es 210, la condición se sigue cumpliendo. Para cambiar el flujo
del programa para valores superiores a 200, necesito agregar una condición "and" a la sentencia
"if". Cambio la sentencia a "si el total de una factura es mayor a 100" y "la factura total es inferior
a 200". Vamos a ejecutar el código y ver qué ocurre. El descuento no se aplicó. El resultado
simplemente dice que "el total de la factura es 210". ¿Por qué? Porque no se cumple la condición.
Y es aquí donde se pone interesante. Para agregar una segunda condición para "facturas
superiores a 200", utilizaré una sentencia "else if". Entre las sentencias "if" y "else", escribo "elif",
que significa "else if" y luego "la factura total es superior a 200". Imprimir la sentencia "la factura
es mayor a 200". En la línea siguiente, aplico el nuevo descuento. Escribo "el total de la factura es
igual al total menos el descuento2". Primero, permítame limpiar mi pantalla para que podamos
centrarnos solo en los resultados. Ahora presiono "Run" (Ejecutar). Observe cómo ha cambiado el
flujo del programa. No se cumplió la primera condición, así que el código fue a la segunda
condición donde el valor total de la factura se comparó con 200. Como era mayor a 200, se
imprimió que "la sentencia de la factura es mayor a 200". El código pasó la condición "else" porque
la condición "elif" anterior era verdadera. Recuerde que la condición "else" solo se ejecuta si
ninguna de las condiciones anteriores es verdadera. Por último, imprimió las sentencias al final del
fragmento de código, es decir, "la factura total es de 190".

Lo que demuestra que se ha aplicado el descuento2. Felicitaciones, ya sabe cómo controlar el flujo
del programa con "if", "else, y "else if"i. Una vez que domine el uso de sentencias condicionales,

pág. 101
la programación se vuelve divertida. Lo animo a que lo pruebe. En este video, aprendió a utilizar
las sentencias condicionales en Python. Escribir declaraciones condicionales es una parte esencial
de la programación, y lo animo a que practique en su código. La próxima vez que necesite tomar
una decisión, piense en las condiciones involucradas y en cómo se pueden representar si las
codificara en Python.

pág. 102
Sentencias condicionales

Esta lectura lo introduce en las sentencias condicionales if, else y elif.

"If"

De acuerdo con el ejemplo del interruptor de luz, el estado del interruptor se puede almacenar
con un valor booleano de True (Verdadero) o False (Falso).

On = Verdadero

Off = Falso

El fragmento de código anterior tiene una variable denominada current que mantiene un registro
del estado de la luz, encendida o apagada. La primera sentencia if comprobará si la luz está
encendida, y de estarlo, el flujo irá dentro de la condición y establecerá la variable current en False,
apagando la luz. En el fragmento de código anterior, el valor de la variable current se establece
inicialmente en False, por lo que esta condición no se cumple.

La segunda sentencia if verificará si la luz está apagada y, si es así, el flujo pasará dentro de la
condición y establecerá la variable current en True, encendiendo la luz.

pág. 103
"If else"

El código anterior funciona bien, pero se puede reescribir de manera más eficaz utilizando otra
condición denominada else. El siguiente código es un ejemplo:

La sentencia else ha hecho que su código sea un poco más fácil de leer y dado que el flujo se
relaciona con la misma condición, tiene más sentido combinarlos como parte de una sola unidad.

"elif"

Python también tiene otra condición denominada elif que ayuda cuando tiene varias condiciones
para satisfacer. El ejemplo del interruptor de luz es bastante sencillo en el que solo tiene que
verificar el estado de encendido o apagado: True o False. En ciertas condiciones, puede que no
sea tan simple Por suerte elif está aquí para ayudar.

Supongamos que quiere ofrecer un determinado descuento a los clientes si gastan más de $100.
También proporcionará un descuento adicional si ese cliente forma parte de un programa de
fidelización. Si el cliente no forma parte del programa de fidelización y no gastó más de $100, se
aplica un cargo por servicio del 5 %.

pág. 104
El fragmento de código anterior primero verifica si el cliente forma parte del programa de
fidelización y si está gastando más de $100. Si se cumplen ambas condiciones, se aplica un
descuento del 20 % a la factura. La sentencia elif solo se ejecutará si no se cumple la primera
condición if. El estado de cuenta elif solo verificará si la factura supera los $100 y si es así, aplicará
un descuento del 10 % a la factura.

La sentencia else final solo se ejecuta si no se cumple ninguna de las otras dos condiciones. En
este caso, se aplica un cargo del 5 % a la factura.

pág. 105
Sentencia "switch"

Puede que recuerde cómo utilizar las sentencias "if else" y "else if" para probar una variable ante
algunas condiciones. Pero en algunas ocasiones tendrá que probar una variable ante muchas
condiciones para tratar esto.

Puede utilizar lo que se conoce como sentencia "case match". En este video aprenderá a utilizar
una sentencia "match" como una alternativa a una sentencia "if". Ahora tomemos un ejemplo para
comparar la sentencia "match" con la sentencia "if".

Digamos que desea escribir un código para "print http error messages" según los códigos de error.
Para hacerlo con la sentencia "if", tendría que escribir la condición "if", todas las condiciones
alternativas "if else" y finalmente una sentencia condicional de condición "else" condicional.

pág. 106
Las sentencias "like if" y "else" funcionan bien sobre un pequeño número de condiciones, pero no
sobre un gran número de condiciones. Su código puede ser muy complejo y desordenado, pero
afortunadamente, existe un modo más limpio para alcanzar el mismo resultado utilizando la
sentencia "match".

La sentencia "match" en Python se introdujo en la versión 3.10 mediante la sentencia "match",

que puede lograr un código más limpio y legible que permite todas las mismas funciones que la
sentencia "if controlled". Al utilizar sentencias "match", hay algunas cosas que debe recordar:
puede combinar varias condiciones mediante el operador "or" en la sentencia condicional. El valor
por defecto es esencialmente el resultado final si no se encuentra nada en las comprobaciones
"case". Es el equivalente a "else" en los bloques "if". Permítame demostrar este ejemplo "ow"

pág. 107
mediante el código V S. Bien, he escrito una simple sentencia "if" que controla "for an http status
code if" el valor de la variable "http status Matches one" de las condiciones, imprimirá el mensaje
equivalente. Ahora voy a agregar una sentencia "match" debajo de la sentencia "if" para una
comparación clara. Probaré la misma variable con los mismos valores que "type match" y luego la
variable "http status" y dos puntos en la siguiente línea. Escribo "case" que es el equivalente de la
palabra "if" y el valor de 200 en otra línea; repito la acción mediante la sentencia "if" para 200 que
es para imprimir la palabra "success". En otras palabras, la variable se compara con el valor 200, y
si los valores "if" son iguales imprimirá la palabra "success". Observe que el valor del estado HTTP
es efectivamente 200, así que vamos a ejecutar el código para comprobar cómo se procesan en la
terminal las sentencias "if" y "match”. La palabra "success" se imprime dos veces porque el valor
de "http status" coincide dos veces en mi código. Ejecute una vez la sentencia "if" y una vez la
sentencia "match". Ahora cambiemos el valor de "http status" a 201 y volvamos a ejecutar el
código. En este caso solo se imprime una vez, ¿por qué cree que sucede eso? Porque existe una
condición completa para el valor de 201 en la sentencia "if", pero ninguno en la sentencia "match"
para hacer el equivalente en esta sentencia. Usted usa el operador "or" así que coloco mi cursor
entre 200 y los dos puntos y agrego un caracter y el valor de 200 y uno. Limpio mi pantalla usando
C L S y entonces hago clic en ejecutar de nuevo. Ahora "success" se imprime dos veces de nuevo
por lo que en la sentencia "match" el comando "pipe" es una abreviatura de "if" o lo bueno es que
se pueden agregar muchas sentencias "case" en una sentencia "match". Pero ¿qué pasa si ninguno
de los valores coincide con el valor de las variables? Ahora, cambiemos el valor "HTTP status" al
valor de 550 y vea lo que ocurre, haga clic en ejecutar y esta vez se imprime la palabra "unknown".
Tal vez se pregunte por qué. Bueno, porque la sentencia L es como un "catch all" si el valor no
coincide con nada dentro de las sentencias "if" o "L if". El valor predeterminado será la sentencia
"else" que en este caso tiene una función "print" para la palabra "unknown". Bueno, la sentencia"
match" también tiene una clase predeterminada y se agrega al escribir la palabra "case" guion bajo
dos puntos y en la línea siguiente. "Print unknown": vamos a ejecutar de nuevo el código, bien, la
salida es "unknown", lo que significa que la sentencia por defecto tanto "if" como "match", fue
acción.

pág. 108
Mi sentencia "match" va bien pero todavía necesita algunos retoques para que actúe exactamente
como la sentencia "if" dada para hacer eso. Agregaré algunas sentencias "case" más que
comprobarán los mismos valores que las sentencias "L if", escribo "case" 400 dos puntos y luego
agrego un comando "print" con las palabras "bad request", y agrego otro "case" y el valor de 500.
Y también tengo que probar para 501 como en la sentencia "L if" anterior por lo que una vez más
agrego un caracter y escribo 501 en la siguiente línea Agrego el mensaje de error que quiero que
imprima que es "server error". La coincidencia ahorra un poco de espacio al combinar su
sentencia, pero no tiene que hacer una comparación con una variable cada vez. Como en la
declaración "if", cambiemos el valor de "http status one" más tiempo a 500 y uno. Acabo de borrar
la pantalla de nuevo y hago clic en ejecutar y se imprime "server error" para ambas sentencias.
Ahora sabe que existen algunas diferencias entre las dos, pero la sentencia "match" hace
exactamente lo mismo que la sentencia "in summary".

pág. 109
La sentencia "match" compara un valor con varias condiciones diferentes hasta que una de estas
condiciones se cumpla. Así que ahora sabe cómo utilizar la sentencia "match" como alternativa a
la sentencia "if" para probar una variable con muchos valores posibles. La sentencia "match" es
relativamente nueva en Python anterior a la versión 3.10, los desarrolladores tuvieron que ser
creativos y codificar para sus propias soluciones, aprenderá más sobre estos métodos alternativos
más adelante en esta lección.

pág. 110
Construcciones en bucle

¿Alguna vez se ha encontrado con una canción que le gusta tanto que quiere escucharla una y otra
vez? Selecciona la opción de bucle para poder escucharla repetidamente. Esta acción de repetición
se conoce como "looping", y también existe en Python. En este video aprenderá a utilizar las
construcciones "looping" cuando el mismo conjunto de pasos se debe llevar a cabo muchas veces.
Python tiene dos tipos diferentes de construcciones "looping" para iterar sobre secuencias, el
bucle "For" y el bucle "While".

El bucle se utiliza para iterar a través de la secuencia y acceder a cada elemento dentro de la
secuencia. Comencemos con un ejemplo básico de bucle utilizando una cadena. En primer lugar,
se declara una variable denominada "str", que es de tipo cadena, recuerde que una cadena en
Python es una secuencia, lo que significa que puede iterar sobre cada caracter de la cadena. Una
secuencia no es más que un conjunto ordenado. Ahora, separemos el bucle "for" y descubramos
cómo funciona. El elemento variable es un marcador de posición que almacenará la letra actual
en la secuencia. Es posible que también recuerde que puede acceder a cualquier caracter en la
secuencia por su índice. El bucle "For" accede a él de la misma manera y asigna el valor actual al
elemento variable. Esto nos permite acceder al caracter actual para imprimirlo.

pág. 111
Cuando el código se haya ejecutado, la salida será las letras de la palabra, en bucle, cada letra en
su propia línea.

Ahora que ya conoce cómo construir bucles en Python, permítame demostrar cómo funciona con
algunos ejemplos de código para obtener un conjunto de sabrosos postres. Python nos ofrece
varias formas de hacer bucles. Ahora verá el bucle "For" y el bucle "While". Comencemos por lo
básico de un simple bucle "For". Para declarar un bucle "For", utilicé la palabra clave "for". Ahora
necesito una variable para agregar el valor. En este caso utilizo "i", y la palabra clave "in" para
especificar dónde quiero hacer el bucle. Agrego una nueva función denominada "rango" para
especificar el número de elementos de un rango. En este caso, utilizo 10 como ejemplo. A
continuación, hago una simple sentencia "print" al presionar la tecla "Enter" (Intro) para pasar a
una nueva línea. Selecciono la función de impresión, y dentro de los corchetes, ingreso el nombre
en bucle y el valor de "i", luego hago clic en el botón "ejecutar". La salida indica el bucle de iteración
a través del rango de 0 a 9. Es importante observar los tres puntos principales. La iteración
comienza en 0 basándose en el índice del elemento mismo. Cada bucle "for" suele comenzar por
0. La mayoría de las matrices comienza en 0. La razón es que es el primer elemento de una matriz

pág. 112
o el primer elemento del índice. En este caso, el último elemento de la matriz o el índice será 9.
Ahora, quiero cambiar lo que veo. Por ejemplo, escribiré una matriz simple arriba y la llamaré
favoritos. Para ello, comienzo por eliminar el signo "hash" (numeral) delante de favoritos. A
continuación, sustituí la función "range" en el bucle actual "for" con favoritos para consultar. La
"i" que declaré como parte del bucle "for" puede cambiar a cualquier valor, y en este caso utilizo
elemento. Ahora cambio mis sentencias "print" para incluir el elemento en mi bucle de impresión.
También he cambiado el texto, "I like this dessert" (Me gusta este postre). Hago clic en el botón
"Run" (Ejecutar) para imprimir el flujo de valores. En este caso, elemento llama sucesivamente a
cada uno de los cinco títulos de postre y nuestra sentencia "print" los combina en una frase. La
siguiente opción de bucle que les presento es el bucle "While". El bucle "While" difiere ligeramente
del bucle "For". Para demostrar este tipo de bucle, primero comento el bucle "for" en mi pantalla.
Empecemos por utilizar la palabra clave "while". Al igual que en el bucle "for", necesito especificar
una condición para que el bucle se repita "n" veces, según el valor mismo. Primero, necesito
declarar un contador. Hago esto escribiendo "count = 0" por encima de mi sentencia de bucle. A
continuación, escribo "count" luego de la palabra clave "while" (mientras) seguido del signo < y la
palabra "favorites" (favoritas). Ahora inserto la función "len" para proporcionar la longitud de
favoritos. Esto significa que el bucle se ejecutará mientras la cuenta es menor que la longitud de
favoritos. En otras palabras, mientras sea menos de cinco. Para imprimir el valor de la sentencia
de bucle, Presiono la tecla Enter para pasar a una nueva línea. Luego selecciono la función "print"
y entre corchetes escribo el texto, "I like this dessert" (Me gusta este postre). La diferencia clave
aquí es que necesito utilizar el índice para acceder a los elementos dentro del conjunto "favorite".
Para ello, escribo "favorites" y agrego "count to" para representar el índice. Es importante que
ahora aumente "count" para que esencialmente coincida con la sentencia de bucle. Si no
incremento "count", acabaré con lo que se denomina un bucle infinito. Esto significa que se
mantendrá en bucle y bucle hasta que el compilador deje de quedarse sin memoria. Para
incrementar la cuenta, presiono "enter" (intro) para moverme a una nueva línea y agregar count
+= 1. Borro la pantalla y hago clic en el botón "Run" (Ejecutar). Obtengo la misma salida de
impresión que con el bucle "for".

pág. 113
Es importante tener en cuenta que en un bucle "for" estándar, no tengo acceso al índice, pero
puede utilizar la función enumerar para hacerlo. Cambié mi sentencia de bucle actual agregando
"idx", y se convierte para "idx Item in". A continuación, llamo a la función enumerar con "favorites"
entre paréntesis.

En la siguiente línea, para imprimir la salida, reemplazo el texto, "I like this dessert" (Me gusta este
postre) con "idx" y hago clic en el botón "Run" (Ejecutar).

Los resultados muestran el índice y el valor del elemento dentro de la matriz. Felicitaciones, en
este video aprendió sobre las construcciones de bucle en Python mediante el bucle "For".

pág. 114
Construcciones en bucle: ejemplos prácticos

Esta lectura le presenta las diferentes construcciones de bucle en Python.

Bucle "For"

Los bucles de datos son una tarea bastante común en cualquier lenguaje de programación. El bucle
for facilita el trabajo con cualquier tipo de secuencia en Python. Veamos algunos ejemplos de
bucles for y las diferentes formas de utilizarlos.

En el fragmento de código anterior, el bucle for itera sobre el contenido de la lista favorites e
imprime una frase con el nombre del postre para cada elemento de la lista.

El bucle for se basa en el tamaño o la longitud de los elementos a iterar.

pág. 115
Bucle "While"

Por otro lado, un bucle while se basa en que una condición sea verdadera. Una vez que la
condición ya no es verdadera, el bucle se detiene. La cantidad de veces que se ejecuta el bucle
while no se conoce de antemano como ocurre con el bucle for.

Si toma el ejemplo de bucle anterior for y lo convierte en la alternativa de bucle while, terminará
con algo así:

pág. 116
Tome en cuenta que necesita declarar una variable counter. La variable counter se compara
entonces con la longitud de la lista de favorites. A medida que se hace un bucle alrededor de los
datos, se incrementa el counter. Una vez que la condición cont < len(favorites) ya no sea
verdadera, el bucle se detendrá.

pág. 117
pág. 118
Practicar el flujo de control y los bucles

Bucles de control

Hasta ahora, sólo ha iterado sobre secuencias basadas en la longitud de los datos sobre los que
quería iterar. En muchos casos, esto no es necesario, y según la cantidad de datos, también
puede ser bastante costoso. Ahora examinará cómo puede controlar el flujo del bucle y salir
cuando se cumpla una condición específica. También verá sentencias "control" como break,
continue y pass.

"If else"

En muchos casos, es posible que necesite buscar un elemento concreto en una lista. Una vez
encontrado el elemento, no es necesario seguir repasando los demás resultados. Si utilizamos el
ejemplo anterior, supongamos que solo necesita comprobar si el postre "Churros" está en la lista
y, en caso afirmativo, imprimir una única sentencia.

Ejecutar el código anterior generará lo siguiente:

Yes! One of my favorite desserts is Churros

Pero, ¿qué pasa si busca un postre y ese postre no está en la lista? El código anterior no está
configurado actualmente para resolver esta situación. Busquemos el postre "Pudding" que no
está en la lista, y agreguemos también una sentencia else para manejar el caso de que no se
encuentre. Si el postre no forma parte de la lista, imprimirá una nueva sentencia.

pág. 119
Al ejecutar el código anterior se obtendrá la siguiente salida:

No sorry, that dessert is not on my list

Sentencias de control de bucle

Interrupción

El código funciona según lo previsto, pero puede notar un fallo. Si cambia el término de búsqueda
a algo que está en la lista como "Churros" y lo ejecuta de nuevo, obtendrá el siguiente resultado:

Yes one of my favorite desserts is Churros No sorry, not a dessert on my list

¡Esto no es lo que quiere! El postre está en la lista, pero aún se imprime en la condición else.
Para solucionarlo, debe utilizar una instrucción de control denominada break.

Agregue lo siguiente:

pág. 120
Ejecutar el código anterior resolverá el problema. La sentencia break se utiliza para detener el
bucle, que a su vez también detiene la condición else. Sin break, el bucle continuará incluso
después de que se cumpla la condición if.

Continuar

Al igual que break, continue se puede utilizar para controlar la iteración del bucle. La diferencia
clave es que puede permitirle saltar una sección del bucle, pero luego continuar con el resto. Si
cambia su código a este, notará que el resultado imprimirá todo excepto el postre Churros.

Pase

La sentencia pass le permite pasar por el bucle en su totalidad e ignorar eficazmente que se ha
cumplido la condición if.

pág. 121
Bucles anidados y su efecto en la complejidad algorítmica

Los bucles anidados de Python se pueden utilizar para resolver problemas más complejos. Por
ejemplo, el bucle "for" anidado se escribe con sangría dentro del bucle exterior. Exploremos esto
más a fondo y analicemos cómo funciona un bucle anidado.

En primer lugar, el bucle exterior y comenzar y luego ingresar en el bucle interior. Luego, el bucle
interior se ejecutará hasta que su límite de alcance sea "met", 10 en este caso. Una vez que se
completa el bucle interior, regresará al bucle exterior para la siguiente iteración y y vuelve a
ingresar en el bucle interior. Esto sucederá en el bucle exterior cuando haya alcanzado sus
límites. Ahora, veamos un ejemplo usando bucles anidados para iterar más de dos listas. Por
ejemplo, supongamos que tiene dos listas de enteros de uno a nueve y un recuento variable que
se establece en cero.

pág. 122
Tiene dos bucles de nuevo. El bucle exterior, que iterará sobre la lista 1, y el bucle interior, que
repite la lista 2. Si ejecuta este código, da un resultado de 90. Permítame romperlo por usted. El
bucle exterior ejecuta un total de nueve veces. El bucle interior ejecuta un total de 9 multiplicado
por 9, que es 81 veces y 9 más 81 da un total de 90. Para ayudar a visualizar cómo se vería esto,
puede hacer algunos cambios menores al bucle para dar salida a como se ve.

Ya sabe que el número de veces que el bucle se ejecuta se basa en el tamaño de la lista. Ahora
que ha aprendido sobre los bucles anidados, permítame demostrar algunos ejemplos de códigos
de bucles anidados. Tengo VS Code abierto. Primero, permítanme comenzar con un ejemplo
simple y escribir un bucle "for". Escribo para "i" y utilizo la función "range". Tengo en el rango 10.

pág. 123
Por encima del bucle, lo etiqueto con un comentario bucle exterior. Este primer bucle "for" se
considera un bucle exterior. Dentro voy a tener un bucle interior. Escribo un comentario bucle
interior justo debajo del primer bucle "for". Ahora escribo "for j in". Luego utilizo la función range
nuevamente. Paso 10 y termino con dos puntos. El 10 indica el número de veces que el bucle
iterará o se repetirá. En este ejemplo, imprimo cero, y luego uso "fin es igual" y una cadena con
espacio entre comillas dobles para asegurar que se imprime de manera uniforme. Por último,
voy a imprimir una línea vacía para que vaya a una línea nueva en cada iteración.

Si ejecuto el bucle "for", el sistema imprime una cuadrícula de matriz 2D. Esto es solo lo que
demuestra cómo funciona el bucle "for".

Si quiero imprimir una sola línea, puedo cambiar el bucle exterior a uno. Reproduzco mi pantalla,
lo vuelvo a ejecutar, y esta vez una sola línea de ceros se imprime porque el bucle exterior solo
se repite una vez. Todo esto se basa solo en el bucle exterior. Se ejecuta una vez. Pero cuando
va al bucle interior que se ejecuta 10 veces e imprime un cero para cada elemento en la misma
línea. Cada vez que comienza el bucle exterior, irá al bucle interior. El bucle interior debe finalizar
antes de que vuelva al bucle exterior para comenzar en dos, tres, cuatro, y así sucesivamente.
Puedo demostrarlo simplemente al cambiar el rango 2 del bucle exterior. En este caso, solo se
imprimen dos líneas. El primero cuando "i" es igual a 0, ingresa en el bucle interior y se imprime
10 veces.

pág. 124
Cuando termina, vuelve al bucle exterior. Luego "i" se incrementa de nuevo a uno. Luego se
imprimirá desde el bucle interior "j" y otros 10 ceros de nuevo. Los otros temas a considerar con
los bucles anidados son la complejidad, o lo que se conoce comúnmente como complejidad del
tiempo. Cuanto más grande sea la matriz, más tiempo llevará ejecutar mi código. Permítame
exhibir esto ejecutando un bucle "for" para un rango más amplio, pero también poniendo un
marca de tiempo en él. Importo el módulo de tiempo para poner una marca de tiempo y lo que
se imprime. Lo cierro como el tiempo de inicio es igual al tiempo dos puntos tiempo, que es la
función que quiero llamar. Se inicializa el tiempo de inicio en el momento en que ejecuto el
"script". También quiero imprimir cuánto tiempo tardó en finalizar. Lo hago mediante una
sentencia "print" fuera del bucle "for". Luego calculo el tiempo como el tiempo que tardó en
terminar y luego restarlo del tiempo de inicio anterior. Esto va a imprimir muchas posiciones
decimales. Utilizo otra función denominada "round", que redondea los números a un decimal
por elección.

pág. 125
En este caso, lo redondeé a dos decimales. Permítame despejar mi pantalla una vez más. Hago
clic en ''Ejecutar'', y sale el tiempo de cero dos puntos cero segundos.

Esto tiene sentido porque el tiempo "my code" tarda en ejecutarse es muy corto. Permítame
aumentar el rango en el bucle exterior a 100. También aumento el rango y el bucle interior a
100. Hago clic en "Ejecutar" una vez más. El tiempo ahora sube a 0.01. En este caso, no es una
gran diferencia. Cuando se trata de grandes conjuntos de datos, esto tendrá un gran efecto en
el tiempo de ejecución de mi código. Esta vez, digamos, por ejemplo, que mantengo el bucle
exterior en 100, pero aumento el bucle interno a 1000. Borro la pantalla y hago clic en "Run"
(Ejecutar). El tiempo aumenta a 0.04.

Si aumento el bucle interno una vez más a 10000 y despejo la pantalla y hago clic en "Run"
(Ejecutar). Ahora el tiempo sube a 0.45. Cuanto más grande sea la matriz o más grande sea el
rango, en este caso, mayor será el tiempo necesario para completar un programa. Siempre es
importante recordar cómo optimizar el código para ejecutarlo de modo más eficiente. Considere
la cantidad de tiempo que su código tardará en ejecutarse. Acaba de aprender sobre bucles "for"
anidados y el problema de la complejidad del tiempo. En este video ha aprendido sobre los bucles
anidados y cómo funcionan.

pág. 126
Ejercicio: utilice el flujo de control y los bucles para resolver un problema

Introducción

En este ejercicio, practicará el flujo de control con bucles para resolver problemas. Se le dará una
lista de enteros y tendrá que agregar algún código para encontrar un número concreto en una
lista y devolverlo.

Instrucciones

1. En num_list cree un bucle "for" nuevo e imprima cada valor de la lista en orden secuencial.

2. Dentro del bucle "for", cree una condición que busque todos los números mayores que 45 e
imprima solo números que cumplan esa condición.

3. Cambie la sentencia "print" a "Más de 45" y agregue una condición "else" con una sentencia
"print" de "Menos de 45".

4. Actualice el bucle "for" para utilizar la función enumerar y poder obtener y utilizar el índice.
Modifique la condición para buscar el número 36 e imprima lo siguiente: "Número encontrado
en la posición:", número de índice

5. A continuación, cree una nueva variable denominada "count", asígnele el valor 0 y ubíquela
fuera del bucle "for".

6. Dentro del bucle "for" incremente el contador en 1.

7. Agregue una sentencia "print" fuera del bucle "for" para imprimir el valor de la variable
"count".

8. Por último, agregue una sentencia "break" directamente luego de la sentencia "print" dentro
de la condición "if" para encontrar el número.

pág. 127
pág. 128
Utilice el flujo de control y los bucles para resolver un problema: solución

Código de solución

Paso 1

Paso 2

Paso 3

Paso 4

pág. 129
Pasos 5, 6, 7

Paso 8

pág. 130
Auto revisión: utilice el flujo de control y los bucles para resolver un problema

pág. 131
Módulo 1 - Introducción a Python

Felicitaciones por haber llegado al final de flujos de control y condicionales y al final del módulo
sobre introducción a Python. Recapitulemos lo que ha aprendido.

Ahora ya sabe cómo explicar la historia de la programación y cómo funciona en sentido general.
Describa los beneficios de Python y dónde se utiliza. Evalúe si su sistema está configurado
correctamente para el desarrollo de Python. Identifique las diferencias de ejecutar el código
desde la línea de comandos a través del IDE (Integrated Development Environment, Entorno de
desarrollo integrado). Explique la importancia de la sintaxis y del espacio en Python. Describa
qué son las variables y cómo se utilizan. Identifique los tipos de datos en Python. Explique cómo
declarar y utilizar las cadenas. Describa los dos tipos de conversión y cómo aplicarlos. Describa
los fundamentos de las entradas del usuario y las salidas de la consola. Reconozca operadores
matemáticos y lógicos en Python. Utilice las sentencias condicionales para controlar el flujo de
los programas. Utilice la sentencia de caso de coincidencia como alternativa a las sentencias "if".
Explique las construcciones en bucle y cómo utilizarlas y explique los bucles anidados y cómo
funcionan. Ha aprendido mucho sobre la estructura y las reglas que guían a Python y ahora está
listo para crear programas. Buen trabajo, nos vemos la próxima vez.

pág. 132
Cuestionario del módulo - Introducción a Python

pág. 133
pág. 134
Recursos adicionales

Puede acceder a los siguientes enlaces para obtener más información sobre la programación en
Python.

Explore el sitio web de Python para obtener más información sobre el flujo de control: Más
información sobre Python

Consulte "W3Scools" para obtener más información sobre los operadores condicionales:
W3Schools

Obtenga más información sobre las sentencias condicionales en el sitio web Real Python:
realpython.com

pág. 135
MODULO 2

PROGRAMACIÓN BÁSICA CON PYTHON

Aprenda a utilizar la sintaxis básica de Python para usar el flujo de control y los bucles y trabajar
con funciones y estructuras de datos. También aprenderá a reconocer posibles errores, sus causas
y cómo manejarlos.

Objetivos de aprendizaje

• Explicar los conceptos básicos que sostienen el lenguaje de programación Python

• Trabajar con variables y diferentes tipos de datos en Python

• Utilizar el flujo de control y los bucles para ejecutar código en condiciones específicas

• Trabajar con funciones y estructuras de datos en Python

• Reconocer los posibles errores, sus causas y cómo solucionarlos

• Crear, leer y escribir datos en archivos

pág. 136
FUNCIONES Y ESTRUCTURA DE DATOS

Funciones

¿Qué son las funciones? En el nivel más básico, se puede pensar en funciones como un conjunto
de instrucciones que toma una entrada y devuelve salidas.

Por ejemplo, la tarea principal de la función de impresión es imprimir un valor. Este valor suele
imprimirse en la pantalla y se pasa a la función de impresión como argumento. En el ejemplo que
tenemos aquí, la cadena "hello world" (hola mundo) es el valor que se pasa a la función de
impresión. Al final de este video, podrá declarar una función en Python, pasar datos a una función
y devolver datos de una función. Una función de Python es una pieza modular de código que se
puede volver a usar repetidamente.

Ya utilizó algunas funciones de Python en este curso, tales como "print" e "input". Ambas son
funciones y cada una tiene una tarea o acción específica para completar. La función "input"
también aceptará parámetros, pero también aceptará la entrada del usuario. Entonces, ¿cómo
declarar una función? Una función se declara mediante la palabra clave "def" seguida por el
nombre y la tarea a completar.

pág. 137
También se pueden agregar parámetros opcionales después del nombre de la función dentro de
un par de paréntesis. Aquí hay un ejemplo de creación de una función para agregar dos valores.
Escriba la palabra clave "def" seguida del nombre de la función "sum", luego ingrese x e y como
parámetros. Por último, ingrese la devolución x + y como tarea para completar. Ahora le daré una
demostración práctica de funciones, cómo declararlas, cómo se utilizan y cómo también pueden
simplificar su código poniéndolo en una estructura reutilizable. Comencemos con un breve
ejemplo que explica cómo calcular un monto de impuesto para un cliente, según el valor total de
esa factura. Voy a empezar por declarar dos variables. Escribo la primera variable denominada
"bill" (factura) y le asigno el número, digamos, 175.00. Sé que esto va a ser un tipo de dato
conocido como flotantes porque estoy usando los puntos decimales como es la norma para la
moneda. La segunda variable es la tasa impositiva, que es la tasa de impuesto porcentual que
debería ser aplicada a la factura, así que pongo 15. Entonces lo que quiero hacer es calcular el
monto del impuesto para la factura en sí. Lo que hago es agregar esto a otra variable denominada
"total tax" (impuesto total). Luego hago los cálculos, que es la factura multiplicada por la tasa
impositiva y luego dividido por 100 para obtener un monto en dólares. La salida es el valor.
Imprimo el impuesto total y paso la variable "impuesto total" y luego ejecuto el programa.

pág. 138
El impuesto total es de 26.25, que es el 15 por ciento de 175. En el mundo real, el valor de la
factura será diferente para cada cliente y las tasas de impuestos también pueden cambiar. Al
actualizar cada variable, siempre es ineficiente. Para superar este problema, crearé una función
reutilizable. Empezaré por crear una función, utilizo un comando "define" o def para abreviar.
Entonces le voy a dar un nombre que se relaciona con la tarea que se está llevando a cabo. En este
caso, va a ser "calcular impuestos". Con funciones, puede pasar argumentos. El objetivo es hacerlo
más dinámico. Considere los argumentos que necesito tomar. Tomaré una factura, que sería el
valor total de la factura misma, y también una tasa impositiva. Entonces, como he hecho antes,
calcularé el impuesto total tomando la factura, multiplicándolo por la tasa impositiva, y luego
dividiéndolo por 100. Luego hago una devolución, escribo "factura" entre paréntesis, multiplico
por "tasa impositiva", y divido por 100. Ahora puedo eliminar la declaración que hice antes para
las variables y el cálculo.

Con una función, si ejecuta el código actual tal como está, volverá con nada porque una función
es solo alguna vez se ejecutar cuando en realidad es llamada. Lo demostraré. Si hago una
impresión, puedo calcular impuestos y luego pasarlo como he hecho antes. Ciento setenta y cinco
es la factura total y luego la tasa impositiva será de 15. También voy a poner solo el impuesto total
y luego hago clic en "Ejecutar", y el impuesto total es de 26.25. Si quiero cambiar la tasa, puedo
reutilizar la misma función, "impuesto total". Llamaré de nuevo a la función para calcular los
impuestos. Le daré un valor diferente para una factura, digamos, 164.33. Esta vez cambiaré la tasa
impositiva a 22 por ciento. Despejo la pantalla y luego hago clic en "Run" (Ejecutar) y mi impuesto
total para el segundo elemento es de 36.1526.

pág. 139
Para limpiar las salidas un poco y hacer que sean visualmente más atractivas, pondré una función
redonda que permite el control del número de decimales que quiero devolver. En este caso, haré
dos y luego volveré a ejecutar el código. Esto es mucho más claro con 36.15. Una de las cosas
lindas de una función es que puede actualizarla una vez y cualquier parte del código que llama esa
función conseguirá esos cambios también. En este video, verá funciones básicas en Python, cómo
declarar funciones, y pasar y devolver datos hacia y desde ellos.

pág. 140
Ámbito de la variable

También el alcance, para el cual Python permite obtener un mayor control sobre los elementos
de su código, lo que reduce las posibilidades de cambios accidentales o no deseados. Al final,
entenderá los fundamentos de la exploración en Python e identificará los cuatro tipos de alcance.
Antes de explorar el alcance y sus complejidades, es importante saber que Python tiene diferentes
tipos de alcance. Analizaremos cada uno en detalle y los mostraré con ejemplos de codificación.
En orden de cobertura ascendente, los cuartos alcances son local, cerrado, global e integrado.

Juntos, se denominan LEGB. Las variables dentro del alcance integrado y global son accesibles
desde cualquier parte del código. Por ejemplo, si hay una variable en el alcance global, se puede
denominar codificar en el nivel local. El propósito del alcance es proteger la variable, para que no
se modifique por otras partes del código. Por ejemplo, digamos que ha declarado una variable b
en el alcance cerrado y la variable c localmente. Mientras que se puede denominar b en el código
local, no funciona del modo inverso. Por regla general, se desaconseja el alcance global en
aplicaciones, ya que esto aumenta la posibilidad de errores en los resultados. Ahora, voy a explorar

pág. 141
el uso de los cuatro tipos de alcances de Python en esta demostración práctica. El primero que
quiero utilizar es el alcance global. Declaro una variable denominada mi global y luego le doy un
valor de 10, así que lo siguiente que hago es declarar una función y la denomino fn1, y dentro de
esta función, declaro otra variable, que denominaré variables locales o local_v, y le doy un valor
de cinco. Para demostrar que mi variable global es accesible desde cualquier lugar, puedo hacer
una sentencia "print", digamos el acceso global, y luego imprimir el valor de la variable my_global,
y si quiero ejecutar esa función, tengo que llamarla específicamente, fn1, hago clic en ''Ejecutar''
y luego el valor de 10 se imprime para la variable global. Pero si intento imprimir la variable local
dentro de f y una fuera de la función, devolverá un error, entonces accedo a local y luego se pone
underscore_v local. Es una consola inteligente, hago clic en ''Ejecutar'' y obtengo un error de
nombre, el nombre underscore_v local no está definido. Esto se debe a que solo es accesible desde
el alcance local de la función fn1. A continuación, para ilustrar un alcance cerrado, voy a declarar
una segunda función dentro de fn1 denominada fn2. A continuación, declaro una variable cerrada,
a la que denomino tarifa cerrada, y le asigno el valor de ocho. La v local será local en la fn2. Ahora
explicaré cómo funciona el alcance cerrado. Dentro de fn2, tengo acceso a enclosed_v, que puedo
demostrar haciendo otra sentencia "print" e imprimiendo la variable enclosed_v. Voy a probar que
esto funciona llamando a la función fn1 y luego asegurándome de llamar a nuestra función fn2
dentro de fn1, Debo llamar físicamente a una función para que se ejecute, así que borro la consola,
hago clic en Ejecutar, y luego se imprime el acceso a global 10 y acceso al cerrado ocho. El modo
en que funciona el ámbito es que la función más interna tiene acceso a casi todo desde el exterior.
Puede acceder a la variable cerrada en este nivel y luego también acceder a la variable global en
el nivel exterior.

pág. 142
Las mismas reglas siguen aplicándose desde el exterior, así que si intento acceder a la variable de
enclosed_v, o intento acceder a la variable de local_v, recibo el mismo error de que la variable
enclosed_v no está definida. Los elementos anidados tienen acceso tanto al global como al
cerrado, pero desde el exterior, no se puede acceder desde un alcance anidado o cerrado, tanto
el local como el cerrado.

El último globo es alcance integrado, que usted ha utilizado cuando escribió el código en Python.
El alcance integrado se refiere a lo que se denomina palabras clave de reserva, como impresión y
def. El alcance integrado cubre todo el lenguaje de Python, lo que significa que puede acceder a
él desde los alcances más externos o los alcances más internos en las clases de funciones.

pág. 143
Esta es una breve demostración del alcance en Python, incluidos ejemplos de global, local, cerrado
e integrado. Después de ver todo este video ha obtenido una amplia comprensión de por qué la
exploración es importante en la programación en Python, y ahora puede identificar los cuatro
tipos de alcance.

pág. 144
Función y ámbito de la variable

Funciones y variables

Es esencial comprender los niveles de ámbito en Python y cómo se puede acceder a las cosas
desde los cuatro niveles de ámbito diferentes. A continuación, se presentan los cuatro niveles de
ámbito y una breve explicación de dónde y cómo se utilizan.

1. Ámbito local

Ámbito local se refiere a una variable declarada dentro de una función. Por ejemplo, en el siguiente
código, la variable total solo está disponible para el código dentro de la función get_total.
Cualquier cosa fuera de esta función no tendrá acceso a ella.

2. Ámbito cerrado

El ámbito cerrado se refiere a una función dentro de otra función o lo que se denomina función
anidada.

En el siguiente código, agregué una función anidada denominada double_it a la función get_total.

pág. 145
Como double_it está dentro del ámbito de la función get_total, se puede acceder a la variable. Sin
embargo, no se puede acceder a la variable cerrada dentro de la función double_it desde dentro
de la función get_total.

3. Ámbito global

El ámbito global es cuando se declara una variable fuera de una función. Esto significa que se
puede acceder desde cualquier lugar.

En el siguiente código, agregué una variable global denominada special. A continuación, se puede
acceder desde ambas funciones get_total y double_it:

pág. 146
4. Ámbito integrado

El ámbito integrado se refiere a las palabras clave reservadas que Python usa para sus funciones
integradas, como print, def, for, in y así sucesivamente. Se puede acceder a las funciones con
ámbito integrado en cualquier nivel.

pág. 147
¿Qué son las estructuras de datos?

Esta lectura es una introducción a las estructuras de datos. Hasta ahora, solo ha almacenado
pequeños bits de datos en una variable. Puede ser un entero, un booleano o una cadena.

Pero, ¿qué sucede si necesita trabajar con información más compleja, como una recopilación de
datos de una lista de personas o una lista de empresas?

Las estructuras de datos están diseñadas precisamente para eso.

Una estructura de datos le permite organizar y acomodar sus datos para realizar operaciones en
ellos. Python tiene las siguientes estructuras de datos integradas: Lista, diccionario, tupla y
conjunto. Todas ellas se consideran estructuras de datos no primitivas, lo que significa que se
clasifican como objetos. Esto se verá más adelante en el curso.

Además de las estructuras de datos integradas, Python permite a los usuarios crear las suyas
propias. El usuario puede crear estructuras de datos como "Stacks", "Queues" y "Trees".

Cada estructura de datos se puede diseñar para resolver un problema en particular u optimizar
una solución actual para que sea mucho más eficiente.

pág. 148
Mutabilidad e inmutabilidad

Las estructuras de datos pueden ser mutables o inmutables. La siguiente pregunta que puede
hacer es, ¿qué es la mutabilidad? La mutabilidad hace referencia a datos dentro de la estructura
de datos que se pueden modificar. Por ejemplo, puede cambiar, actualizar o eliminar los datos
cuando sea necesario. Una lista es un ejemplo de estructura de datos mutable. Lo contrario de
mutable es inmutable. Una estructura de datos inmutable no permitirá la modificación una vez
que se hayan establecido los datos. La tupla es un ejemplo de una estructura de datos inmutable.

pág. 149
Listas

Las listas son una secuencia de uno o más tipos de datos diferentes o similares. Una lista en Python
es esencialmente una matriz dinámica que puede contener cualquier tipo de datos. Pasemos a la
consola y demostraré algunos ejemplos prácticos de listas de Python. En primer lugar, repasaré
algunos ejemplos de declaración de listas. Creo mi lista escribiendo list1= y luego los números 1,
2, 3, 4, 5 entre corchetes y separados por comas porque utiliza comas para separar elementos en
una lista. List2 es una lista de cadenas, A, B, C. También puedo tener una lista de diferentes tipos
de datos. Por ejemplo, en mi lista3, puedo tener una cadena, un entero, un booleano y un flotante.
El tipo no importa necesariamente. Solo se va a almacenar de la misma manera. Algo a considerar
con las listas es que se basan en un índice. Por ejemplo, supongamos que quería acceder al número
3 de mi ejemplo de lista1. Dado que el índice siempre comienza con cero, tendría que escribir
"list1[2]". Esto obtiene el tercer elemento de la lista, que es el número 3. Si imprimo eso, obtengo
el valor 3 que se imprime. Una opción importante con las listas es que también puede tener listas
anidadas. Si declaro otra lista, por ejemplo, lista4, y pongo 1, entonces puedo tener una lista
anidada de 2, 3, y 4 y luego obtener un 5 y 6. Eso también es completamente válido. Cualquier tipo
de datos se puede almacenar dentro de la propia lista, solo tenga eso en cuenta.

Veamos qué más pueden hacer las listas. Tengo diferentes opciones para añadir elementos a una
lista. Uno es utilizar la función de inserción. Pero antes de hacer eso, haré una impresión. Para
imprimir toda la lista, existen un par de maneras diferentes de hacerlo. Puedo utilizar la lista1 de
signos de estrella, hacer clic en ''Ejecutar'', y obtener toda la lista impresa. Para imprimirlo como
se muestra en mi código puedo utilizar el tipo de sentencia "print" en la lista1 poniendo solo igual
a y luego coma con un solo espacio. Hago clic en "Ejecutar" y obtengo este tipo de impresiones.

pág. 150
Volver a agregar algo nuevo a la lista. La primera opción que tengo es lo que se denomina la
función "insert" (insertar). Puedo hacer "list1.insert". Lo que busca es el índice de dónde insertar.
Aquí puedo utilizar LEN, o función LEN para obtener la longitud de la lista1. Luego pongo cuál
debería ser el siguiente valor. En este caso, lo puse en el número 6. Hago la misma sentencia
"print" directamente debajo de eso. A continuación, hago clic en ''Ejecutar'' y aparece seis
agregado a la lista final. También puedo usar otra función denominada "append" (anexar). En lugar
de tener que especificar el índice o dónde se deben colocar los elementos, puedo ubicarlo en la
palabra clave "append" (apéndice). Escribo append 6 y hago clic en ''Ejecutar'', y se agrega sin
tener que especificar el índice. Existe otra función que puedo usar para agregar uno o varios
elementos a la lista. Se denomina "extend" (extender).

También aceptará una lista. Puedo poner una extensión 6, 7, 8, 9 y luego hacer clic en "Ejecutar",
y así mi lista se extiende con 6, 7, 8 y 9. Para eliminar algo de una lista, existen algunas opciones
diferentes. La primera forma es utilizar "pop" y luego especificar el índice o la ubicación del
elemento que quiero quitar. Para mostrar "pop", diré "pop for", para el índice 4. Hago clic en
"Ejecutar" y el último elemento de la lista se elimina. Recuerde que, dentro de la lista, el índice
siempre comienza con cero. Índice 4 significa que el quinto elemento es el valor 5, y eso es lo que
se ha eliminado. Otra opción es "delete" (borrar) o "del keyword" (borrar palabra clave). Puedo
decir "del list1" (borrar lista1) y, a continuación, especificar el índice que se desea eliminar. En este
caso, pongo el índice de 2, hago clic en ''Ejecutar'' y se elimina el índice 2, que en este caso es el
número 3. 0, 1, 2 es el número tres. Por último, puedo iterar a través de una lista. Una de las
principales razones por las que utilizo listas es que puedo iterar a través de los valores y acceder a
grandes cantidades de datos. Para iterar, puedo utilizar un bucle simple cuatro. Entonces, la X de
la lista1, y luego puedo hacer una impresión simple. Voy a quitar esta debajo. Me gustaría imprimir

pág. 151
el valor de X. Acabo de poner el valor de impresión y luego X. Cuando hago clic en ''Ejecutar'',
imprimirá todos los valores de la lista.

Esa es una breve demostración de lo que puede lograr mediante la lista en Python. Acaba de ver
cómo una lista en Python funciona como una matriz dinámica. Ha explorado listas y ha aprendido
a utilizar funciones integradas de una lista para acceder a los elementos de la lista, modificarlos,
agregarlos a la lista, y eliminarlos de la lista.

pág. 152
Tuplas

Aprenderemos sobre tuplas y cómo se puede utilizar para almacenar diferentes tipos de datos. Se
utilizan como estructuras de datos y ayudan a crear un código sólido y de buen rendimiento. Para
declarar una tupla, declaro una variable simple. La denominaré mi_tupla. A continuación, hago la
asignación operador de iguales, luego para declarar la tupla en sí, uso paréntesis. Una tupla puede
aceptar cualquier mezcla de tipos de datos. Y puede ir desde números enteros como uno, hasta
cadenas, a un doble, como 4.5 a un booleano como verdadero. Para acceder a cualquiera de los
elementos dentro de la tupla. Puedo utilizar métodos similares a los utilizados con la lista haciendo
referencia a un índice. Así que, en mi_tupla, si quiero tener acceso a la cadena que sé que va a
estar en el índice uno, solo imprimo el valor. Entonces escribo, Print My _ Triple Brackets, one.
recuerda que el índice siempre empieza por cero. Una ejecución rápida y encuentro que devuelve
el valor de las cadenas. Si quiero determinar el tipo de la tupla, puedo utilizar la función tipo que
proporciona Python. Hago clic en Ejecutar y obtengo una tupla de clase. También podríamos
declarar una tupla sin usar los paréntesis. Tiene el mismo efecto y seguirá siendo clasificada como
una tupla. Sin embargo, es recomendable utilizar los paréntesis. Las tuplas también proporcionan
diferentes métodos de recuento e índice. Puedo hacer mi recuento de puntos de tupla de
subrayado y pasar el valor de cadenas. Hago clic en ejecutar y vuelvo a la cuenta de uno. Lo que
hace es buscar el número de apariciones de ese valor dentro de la tupla.

Antes de continuar, escribiré clear en mi terminal para borrar la salida anterior. Así podríamos
empezar de cero y ver qué va a pasar después. El otro método es el índice, que me devolverá el
índice de donde se encuentra el valor en la tupla. Cambiaré la sentencia print para buscar el índice

pág. 153
del doble 4.5. Cuando hago clic en Ejecutar, recupero dos. Esto significa que el doble 4,5 está en
el Índice dos de la tupla. También puedo hacer un bucle manejable. Es decir, iterar a través de los
valores e imprimirlos. Puedo escribir un bucle para X en mi tupla guión bajo y luego imprimir el
valor de X. Hago clic en ejecutar y obtengo uno, cadenas 4.5 y verdadero. Todos los valores de la
propia tupla. La diferencia clave de una tupla sobre una lista es que los valores de la tupla son lo
que se denomina inmutable. Y eso significa que no se pueden cambiar. Así que lo probaré y
demostraré cómo funciona. Digamos que quiero cambiar el valor con el primer elemento en la
tupla, el valor uno. Utilizará cero para acceder a él basándome en el índice. Y digamos que quiero
cambiarlo a cinco.

Si lo ejecuto esto, obtendré un error. Y me da el error diciendo "type error", el objeto tupla no
admite la asignación de elementos. Esto se debe a que todo lo que se declara en una tupla es
inmutable. En este video, aprendió sobre tuplas, además de cómo declararlas y trabajar con su
contenido.

pág. 154
Conjuntos

En este video, aprenderá sobre los conjuntos y cómo pueden ayudar a almacenar ciertos tipos de
datos en diferentes tipos de formatos. Primero, declaro un conjunto, puedo comenzar por declarar
una simple variable denominada set_a= y luego utilizar llaves para definir el propio conjunto.
Luego, los valores van dentro de los corchetes, pongo 1, 2, 3, 4 y 5. Haré una impresión simple
para demostrar que tenemos un conjunto, Hago clic en ejecutar para que se impriman los valores
del 1 al 5. Los conjuntos difieren ligeramente de las listas, en que no permiten valores duplicados.
Puedo hacer una demostración poniendo otro 5, cuando hago clic en ejecutar, Veo que el segundo
5 no está impreso en la lista. Los conjuntos también tienen métodos que podemos utilizar, puedo
utilizar un método para agregar contenido nuevo. Si utilizo set_a.add (6), puedo agregar el número
6, Hago clic en ejecutar para ver que el valor 6 se agrega al conjunto.

También podría utilizar el método de eliminación, eliminaré el número 2, cuando hice clic en
Ejecutar, encontré que el número 2 se eliminó del conjunto.

También existe la función descartar que básicamente hace lo mismo que la función eliminar.

Si utilizo descartar, al hacer clic en Ejecutar, me encuentro con el mismo resultado. Permítame
despejar la consola antes de seguir. También existen algunos métodos útiles que se pueden utilizar
con conjuntos para realizar operaciones matemáticas, permítame hacer una demostración de
algunos ahora. Primero, voy a crear un nuevo conjunto, set_b, pondré 4, 5, 6, 7 y 8, y restableceré
los valores de set_a a los valores originales. Existen dos formas de utilizar operadores
matemáticos. Por ejemplo, para una unión, puedo hacer set_a.union y luego pasar en set_b,
entonces, puedo hacer clic en el botón Ejecutar para ver lo que sucede. Descubro que une los dos
conjuntos, menos los valores duplicados como el 4 y el 5, la unión los fusiona en uno. Entonces,
tiene un conjunto 1, 2, 3, 4, 5, 6, 7, 8. Para las otras opciones de unión, puedo utilizar el símbolo

pág. 155
de línea vertical o el símbolo 0 y eso funciona de la misma manera. Voy a despejar la consola antes
de continuar.

Otra operación que puedo utilizar es la intersección, puedo aplicarla a set_a escribiendo
set_a.intersection y pasando set_b como argumento. Cuando hago clic en Ejecutar, obtengo todos
los elementos que coinciden tanto en set_a como en set_b, aquí tenemos 4 y 5. La intersección
también se puede representar mediante el ampersand y funcionará de la misma manera. Cuando
hago clic en Ejecutar, también me devuelve 4 y 5, despejaré la consola de nuevo antes de
continuar. Otra operación matemática que puedo utilizar es la diferencia establecida. Para
utilizarla, all print set_a.diferencef(set_b), esto debería devolverme todos los elementos que solo
están en set_a y no en set_b.

Al hacer clic en Ejecutar, obtuvimos la salida correcta de 1, 2 y 3. También podría representar la

diferencia mediante el símbolo menos, cuando hago clic en Ejecutar, también obtengo los mismos
valores, 1, 2 y 3.

La última operación de la que hablaré es la que se denomina diferencia simétrica. Se representa

mediante la función de diferencia simétrica, que se utiliza de modo similar. Al hacer clic en
Ejecutar, me devuelve 12367 y ocho. En otras palabras, todos los elementos presentes en el
conjunto A. O conjunto B. Pero no en ambos conjuntos, la diferencia simétrica también se puede

pág. 156
representar mediante el operador zanahoria. Cuando hago clic en Ejecutar, me devuelve los
mismos valores. Lo más importante de los conjuntos es que un conjunto es una colección sin
duplicados, pero también es una colección de elementos sin alterar. A diferencia de una lista en la
que puedo imprimir contenido basado en el índice. Si intento imprimir un corchete cero para
obtener el elemento cero en el conjunto, obtendré un error. Permítame despejar mi consola.
Antes de intentar imprimir esta salida.

Al hacer clic en Ejecutar, se devuelve un error tipo que indica que el objeto de conjunto es no
subscribible, esto significa que el conjunto no es una secuencia, no contiene un índice ordenado
de todos los elementos que contiene. Bien, con esto concluye nuestra apacible introducción a los
conjuntos. Buen trabajo.

pág. 157
Diccionarios

¿Qué es un diccionario en Python? De muchas maneras, es muy similar a un diccionario real. En

un diccionario normal, para ubicar una palabra, se busca por la primera letra y luego se usa el
sistema de orden alfabético para encontrar su ubicación. Del mismo modo, los diccionarios de
Python se optimizan para recuperar valores. Puede que recuerden cuan útiles son las listas de
Python para acceder a un "array" de valores. Los diccionarios acceden a los valores basándose en
las claves y no en la posición del índice. Por lo tanto, son más rápidos y más flexibles en su
funcionamiento. Al final de este video, podrá explicar el propósito y la función de los diccionarios
en Python e identificar las ventajas de rendimiento de los diccionarios.

Con un diccionario Python, se asigna una clave a un valor específico. Esto se denomina el par clave-
valor. Los beneficios de este método es que es mucho más rápido que usar listas tradicionales.
Para buscar un elemento en una lista, necesita continuar revisando la lista hasta que localice el
elemento. Pero en un diccionario Python, puede ir directamente al elemento que necesita
mediante su clave. Un diccionario también es inmutable en el sentido de que los valores se pueden
modificar o actualizar. Por ejemplo, puede declarar el número 1 como clave, y el café es el
elemento, y, a continuación, cambiarlo por cualquier otro número o elemento bebida. Pero,
¿cómo funciona? ¿Cómo acceder o localizar el elemento que necesita dentro de un diccionario
Python con el uso de las claves? Para demostrar esto, accederé al elemento "café" en un
diccionario Python. Primero, declaro el nombre de mi diccionario como "sample dictionary". Luego
lo igualo con una serie de pares clave-valor o claves y elementos en un par de llaves. También me
aseguro de separar cada par con una coma. Luego escribo la función de impresión seguida del
nombre de mi diccionario.

pág. 158
Necesito acceder al elemento "café", al que se le ha asignado una clave de uno. Inserto el número
uno entre corchetes. Ejecuto la función de impresión y devuelve "café" como resultado, tal y como
pretendía. También puedo actualizar un diccionario reemplazando un elemento por otro. Solo
necesito usar la clave para referenciarla mientras uso el operador de asignación "es igual a" para
asignar el valor.

Por ejemplo, puedo cambiar el elemento 2 en mi diccionario, de "té" a "té de menta". Solo escribo
una nueva línea de código que comienza con el nombre del diccionario, seguido de la clave que
quiero cambiar entre corchetes. Luego agrego un operador "igual a" seguido por el nombre del
elemento nuevo. Lo que dice la codificación es tomar el elemento 2 en el diccionario de muestra
y cambiarlo a "té de menta". Al ejecutar esta función, cambia el elemento. También puedo
eliminar un elemento del diccionario.

Para ello, escribo una línea de código con la función de eliminación seguida por el nombre de mi
diccionario. A continuación, agrego la clave para el elemento que deseo eliminar entre corchetes.
En este caso, quiero eliminar el elemento 3, "jugo". Al ejecutar esta función de eliminación, se
quitará el valor de "jugo" de mi diccionario. Por último, también puedo utilizar tres métodos

pág. 159
diferentes para iterar sobre el diccionario. Puedo utilizar el método estándar de iteración, la
función elementos o la función valores.

Exploremos estos métodos de iteración y las demás funciones de operación del diccionario con
más detalle. Para crear mi diccionario, comenzaré por declarar una variable simple denominada
my_d, y, a continuación, utilizaré el operador de asignación y luego corchetes. Puede ser lo mismo
que un conjunto, pero de forma predeterminada, que se clasifica como un diccionario vacío.
Puedo imprimirlo mediante una declaración "print", utilizando la función tipo y a continuación
pasar la variable my_d, haciendo clic en "Ejecutar". La clase ha vuelto como diccionario tipo. A
continuación, agregaré algunos valores en el diccionario, y necesito hacerlo en dos partes. Un
diccionario contiene lo que se denomina una clave y un valor. La clave puede ser numérica, puede
ser cadena. Pero para significar la asignación, Utilizo dos puntos y luego pongo en el valor que
quiera. En este caso, pondré un valor de cadena simple de prueba. Para señalarlo, puedo cambiar
o tener claves diferentes, cadenas, enteros o "ints". Puse una clave de cadena de nombre, y luego
el valor, "Jim". Imprimo "my dictionary" mediante la función impresión. Ahora tengo un diccionario
básico configurado con una clave de un nombre y luego un nombre de prueba, que es "Jim". Si
quiero acceder a una clave en el diccionario, Solo tengo que utilizar los corchetes y luego pasar la
clave-valor. En este caso de uno paso el numérico. En el caso del valor de cadena, solo tengo que
pasar el valor de cadena real en sí. Luego hago clic en "Ejecutar", y obtengo tanto la prueba como
"Jim", que son los valores para cada clave correspondiente. Si quiero agregar una nueva clave en
el diccionario o actualizarlo, puedo simplemente hacer "my d" y luego agregar una nueva

pág. 160
asignación, dos en este caso, Test 2 haga clic en "Run". A continuación, se agrega la clave con el
diccionario actual. Para actualizar la clave, tengo que señalar los valores que quiero. Solo voy a
actualizar la primera clave, que es número 1, con un valor de "no una prueba" en lugar de
"prueba". Haga clic en "Play" y se actualiza en la pantalla. Otra cuestión a señalar sobre el
diccionario es, si intento poner una clave duplicada, no lo permite. Si pongo el Número 1 y luego
"no una prueba". Haga clic en "Ejecutar" y la clave se sobrescribirá con la última. Solo aparece el
número 1 una vez en las salidas y no permite imprimir las dos claves porque no permitirá
establecer valores duplicados. Si quiero borrar una clave del diccionario usaré el operador "del",
escribo mi_d y luego especifico la clave que deseo eliminar. En este caso, el número 1 se elimina
del diccionario. Sin embargo, con un diccionario también puedo iterar. Por ejemplo, puedo usar
"for" x "in my dictionary" e imprimir el valor de x. Hacer clic en "Ejecutar" y obtener uno.

Esto solo imprime las claves. En muchos casos, puedo necesitar acceso a ambos. Para ello, utilizo
un método denominado "mis elementos". Con eso, entonces puedo obtener acceso a la asignación
de la clave y el valor.

Hago una impresión aquí, clave más valor. Utilizaré algo de concatenación para imprimir tanto la
clave como el valor. Haga clic en "Ejecutar". Tengo que tener cuidado porque utilizo un entero con
una cadena. Encierro eso con el tipo "str", hago clic en "Ejecutar" de nuevo, y obtengo el valor de
la clave y el valor para cada uno de los elementos en el propio diccionario.

pág. 161
Ahora debería comprender el propósito y la función de los diccionarios en Python y sus beneficios
en términos de rendimiento.

pág. 162
"kwargs"

En este video, conocerá sobre "args" y también "kwargs", o "args" de palabras clave. Utilizarlos
tiene la ventaja de poder pasar cualquier cantidad de variables que no sean palabras clave y
argumentos de palabras clave. Para comenzar con un ejemplo corto, definiré una función "sum
of" que acepta dos parámetros, "a" y "b", y luego devuelve la suma, "a" más "b". Si hago una
sentencia "print", denominada la función "sum of", con los dos valores, 4 y 5, debería obtener el
valor de 9, que es lo que obtengo. Todo funciona bien. Pero digamos que quería agregar otro valor,
6, por ejemplo. Si vuelvo a hacer clic en "Ejecutar", me devuelve un error, y me dice que la "sum"
de la función toma dos argumentos posicionales, pero se dieron tres. Si quiero una manera de
evitarlo, aquí es donde los "args" son útiles. Para definir "args", utilizo el símbolo de la estrella, y
la denomino "args" por motivos de nomenclatura. En lugar de pasar solo dos argumentos, "args"
permitirá "n" argumentos a través de cualquier número de argumentos, Al tratar con más de un
argumento, puede haber mucho para iterar. Para calcular la suma total, tendré una variable
denominada "sum", que asignaré a 0, entonces voy a crear un bucle simple "for", y luego haré un
bucle a través de los parámetros del argumento que se han pasado. Entonces voy a agregar todos
los valores que vienen como parte de los "args", que se asignan a la variable x usando el signo más
igual a, y finalmente devuelve el valor de suma. De nuevo, si ejecuto la sentencia, recupero el valor
de 15. Como mencioné, podría pasar en cualquier número de argumentos, y se debe devolver la
suma total para cada uno. En este caso, es 30 con el número de argumentos que se han pasado.

Es una introducción simple a los "args". Ahora voy a mostrar los "kwargs". Borremos la terminal y
cambiemos a mi archivo "kwargs". Voy a copiar el código del archivo "args" para empezar. Por
ejemplo, quería calcular la cuenta total de un restaurante. Un usuario recibió una taza de café que
era de 299. Además, le dieron una torta que costaba 455, y un jugo por 299. Lo primero que podría

pág. 163
hacer es cambiar el bucle "for". Cambiemos el argumento a "kwargs" agregando otra estrella, y
luego actualizando la variable en el bucle "for". A continuación, obtengo la clave en el valor, y
luego extiendo los "kwargs" con la función del elemento. Entonces puedo simplemente cambiar
la suma para agregar todos los elementos que se pasan por el valor, porque agregar la clave no
tiene sentido.

Es solo la cadena, y no le dará el valor real que pretende obtener. Cuando lo ejecuto, me devuelve
un valor de 10.53 con un montón de ceros de más. Ahora puedo cambiar el decimal para la
sentencia "return" final mediante la función de redondeo y limitarlo a dos decimales. Luego hago
de nuevo clic en "Ejecutar", obtengo el total de 10.53. Para resumir, con "args" se puede pasar
cualquier cantidad de variables que no sean palabras clave.

pág. 164
Con los "kwargs" se puede pasar cualquier cantidad de argumentos de palabra clave. Esta es una
introducción sencilla a "args" y "kwargs".

Funciones, bucles y estructuras de datos

pág. 165
pág. 166
Elegir y utilizar estructuras de datos

Esta lectura ilustra la importancia de seleccionar la estructura de datos correcta para la tarea en
cuestión.

¿Qué estructura de datos elegir?

La parte complicada para los nuevos desarrolladores es entender qué estructura de datos es la
adecuada para la solución requerida. Cada estructura de datos ofrece un enfoque diferente para
almacenar, actualizar y tener acceso a la información almacenada dentro de ella. Puede haber
muchos factores que se pueden seleccionar, como el tamaño, la velocidad y el rendimiento. La
mejor manera de probar y entender cuál es más adecuada es a través de un ejemplo.

Ejemplo: lista de empleados

En este ejemplo, hay una lista de empleados que trabajan en un restaurante. Necesita poder
encontrar a un empleado por su ID de empleado, un ID numérico basado en números. La función
get_employee contiene un bucle for para iterar sobre la lista de empleados y devuelve un objeto
empleado si el ID coincide.

El código se ejecuta bien y devolverá al usuario Paul, ya que su ID, 12458, coincide. El desafío
aparece cuando la lista se hace más grande.

En lugar de dos empleados, puede tener 2,000 o incluso 20,000. El código tendrá que iterar sobre
la lista secuencialmente hasta que el número coincida.

pág. 167
Se podría optimizar el código para dividir la búsqueda, pero incluso con esto, seguiría teniendo un
rendimiento inferior al de otras estructuras de datos, como el diccionario.

Observe cómo, en este bloque de código, si cambia la estructura de datos para utilizar un
diccionario, le permitirá encontrar al empleado. La diferencia principal es que ya no necesita iterar
sobre la lista para localizarlos. Si la lista se amplía a un tamaño mucho mayor, el tiempo de
búsqueda para encontrar al empleado sigue siendo el mismo.

Este es un buen ejemplo de cómo elegir la estructura de datos adecuada para la solución.

Ambas funcionan bien, pero el equilibrio a considerar es el tiempo y la escala. La primera solución
funcionará bien para cantidades pequeñas de datos, pero pierde rendimiento a medida que los
datos aumentan.

La segunda solución es más adecuada para grandes cantidades de datos, ya que su estructura
permite un tiempo de búsqueda constante y de ese modo acceder a grandes cantidades de datos
a una velocidad constante.

pág. 168
En este ejemplo se muestra que no hay ningún tamaño que se ajuste a todas las soluciones y que
se debe considerar cuidadosamente la elección de la estructura de datos que se va a utilizar en
función de las restricciones de la solución.

pág. 169
Visual Studio Code en Coursera

Además de tener Visual Studio Code instalado en su propia computadora, en este curso y durante
todo este programa, tendrá la oportunidad de trabajar en Visual Studio Code aquí mismo en
Coursera.

A medida que avance en el curso, podrá escribir código en actividades prácticas denominadas
laboratorios. En estos laboratorios podrá abrir Visual Studio Code y comenzar a escribir código sin
salir del curso.

Tendrá muchas oportunidades de ver los laboratorios en acción más adelante en el curso, pero
por ahora, utilice las siguientes imágenes como guía visual de cómo se verán y funcionarán los
laboratorios en su navegador.

Los laboratorios contienen instrucciones que explican la tarea de codificación.

pág. 170
Cuando haga clic en el botón para abrir el laboratorio, se abrirá una nueva pestaña con Visual
Studio Code ya configurado y listo para que usted empiece a escribir código.

Verá todos los archivos del laboratorio en la carpeta Proyecto en la barra lateral izquierda.

Y la gran zona del editor donde escribe su código para el laboratorio.

pág. 171
Es posible que necesite utilizar una herramienta denominada Terminal de vez en cuando para
hacer las actividades del curso. Puede abrirla seleccionando la opción Terminal en la barra de
herramientas superior de Visual Studio Code.

pág. 172
Cómo descargar archivos del laboratorio de Visual Studio Code al dispositivo local

1. Seleccione el botón Lab Files (Archivos del laboratorio) en la barra de herramientas del
laboratorio.

2. Podrá descargar todo su espacio de trabajo, carpetas específicas o archivos individuales a través
de la herramienta de selección de casillas.

3. Después de seleccionar estos archivos, utilice el enlace Download (Descargar) para descargar
los archivos en su dispositivo local.

pág. 173
Cómo cargar archivos locales en el laboratorio de Visual Studio Code

Si desea cargar los archivos del curso desde su dispositivo local a su laboratorio de Visual Studio
Code, arrastre y suelte el archivo desde su dispositivo local en el árbol de archivos de código de
Visual Studio.

pág. 174
Cómo obtener una nueva copia de los archivos de inicio del curso

Su trabajo se guardará y se conservará en su laboratorio de Visual Studio Code mientras usted esté
matriculado en el curso. Si desea obtener en cualquier momento una copia actualizada de los
archivos originales proporcionados por el instructor, puede hacerlo a través de la opción Lab Help
(Ayuda del laboratorio) de la barra de herramientas del laboratorio. No se preocupe: su trabajo y
sus archivos originales seguirán estando en su laboratorio hasta que los elimine o borre
personalmente, incluso cuando actualice sus archivos siguiendo los pasos que se indican a
continuación.

1. Primero, cambie el nombre de sus archivos originales por algo como [nombredearchivo]
[original].[su extensión de archivo]. Para ello, haga clic derecho sobre el archivo en el árbol de
archivos de Visual Studio Code, seleccione Rename (Renombrar) e introduzca un nuevo nombre
de archivo.

pág. 175
 • Por ejemplo, para index.html, se podría cambiar el nombre a "index [original].html".

2. Seleccione Lab Help (Ayuda de laboratorio) en la barra de herramientas del laboratorio y, a

continuación, seleccione Get latest version. (Obtener la última versión)

3. Debería ver una copia nueva de los archivos originales proporcionados por un instructor en su
laboratorio, además de sus propios archivos (con nombre cambiado).

pág. 176
Tareas de programación: Funciones, bucles y estructuras de datos

Introducción

En este laboratorio se le presentará un sistema de pedido de menús que permitirá a los usuarios
introducir tres opciones para un menú selecto. Su tarea consiste en completar el sistema de menús
para que devuelva y calcule la factura final para el usuario.

Objetivos

• Cree nuevas funciones para resolver problemas específicos.

• Obtenga experiencia en el uso de bucles para iterar sobre diferentes colecciones de datos.
• Cree y utilice estructuras de datos para almacenar, recuperar y realizar bucles sobre los
datos.

Instrucciones

Paso 1: Abra el script ordering_system.py presente dentro de la carpeta del proyecto.

Paso 2: Ejecute el script y, cuando se le solicite, ingrese los tres productos de su elección según el
menú - 1 = espresso, 2 = café, etc.

Paso 3: Para ejecutar el script, abra la terminal y ejecute el siguiente comando.

python3 ordering_system.py

pág. 177
Paso 4: Amplíe el script para que tenga una nueva función denominada calculate_subtotal. Debe
aceptar un argumento que sea la lista de pedidos y devolver la suma de los precios de los artículos
en la lista de pedidos.

Paso 5: Implemente calculate_tax(), que calcula el impuesto del subtotal. El porcentaje del
impuesto es del 15% de la factura general.

Paso 6: Implemente summarize_order(), que devuelve una lista de los nombres de los elementos
que el cliente solicitó y el importe total (impuestos incluidos) que debe pagar. Las órdenes deben
mostrar el nombre y el precio.

menu = {

1: {"name": 'espresso', "price": 1.99},

2: {"name": 'coffee', "price": 2.50},
3: {"name": 'cake', "price": 2.79},
4: {"name": 'soup', "price": 4.50},
5: {"name": 'sandwich', "price": 4.99}
}

def calculate_subtotal(order):

subtotal = sum(item["price"] for item in order)

return round(subtotal, 2)

def calculate_tax(subtotal):

pág. 178
 tax = subtotal * 0.15 # 15% de impuesto
return round(tax, 2)

# Se asegura que la función siempre reciba estos 3 parámetros

def summarize_order(order, subtotal=0, tax=0):

if subtotal == 0: # Si no se proporciona el subtotal, calcularlo

subtotal = calculate_subtotal(order)
if tax == 0: # Si no se proporciona el impuesto, calcularlo
tax = calculate_tax(subtotal)

total = subtotal + tax

items = [item["name"] for item in order]

print("\n--- Orden resumida ---")

print(f"Artículos pedidos: {items}")
print(f"Total (incluyendo impuestos): ${total:.2f}")

return items, total

# Funciones auxiliares

def print_order(order):

print(f"\nHas ordenado {len(order)} artículos")

items = [item["name"] for item in order]
print(items)

def display_menu():

print("\n------- Menú -------")

for selection in menu:
print(f"{selection}. {menu[selection]['name'] : <9} | ${menu[selection]['price'] : >5.2f}")
print()

def take_order():

display_menu()
order = []

pág. 179
 for i in range(3):
item = input(f'Selecciona el artículo {i+1} (del 1 al 5): ')
order.append(menu[int(item)])
return order

def main():

order = take_order()
print_order(order)
subtotal = calculate_subtotal(order)
print(f"\nSubtotal de la factura: ${subtotal:.2f}")
tax = calculate_tax(subtotal)
print(f"Impuesto aplicado: ${tax:.2f}")
summarize_order(order, subtotal, tax) # Ahora pasamos los valores ya calculados

if __name__ == "__main__":
main()

pág. 180
Comprobación de conocimientos: funciones y estructuras de datos

pág. 181
Recursos adicionales

Esta es una lista de recursos que pueden ser útiles a medida que avanza con el proceso de
aprendizaje.

Obtenga más información sobre las estructuras de datos Python (documentación de Python) en el
sitio web de Python:

Python.org - Data structures

Explore las estructuras de datos comunes de Python en el sitio web Real Python:

Real Python - Data structures

pág. 182
ERRORES, EXCEPCIONES Y MANEJO DE ARCHIVOS

¿Que son las excepciones?

En este video, aprenderá sobre los errores y las excepciones, dos aspectos muy importantes de
aprender a usar Python como nuevo desarrollador. Verá la diferencia entre errores y excepciones,
y explorará lo que sucede cuando algo sale mal con su código. Los errores son una codificación
molesta, y ocurren por varias razones. Empecemos por explorar dos tipos de errores. Errores de
sintaxis, causados por errores humanos, y excepciones, que son errores conocidos que debe
manejar. El desarrollador suele cometer errores de sintaxis. Puede ser el resultado de un error
ortográfico o un typo en el código. Generalmente, estos tipos de errores tienen un impacto
mínimo porque la mayoría de los IDE, como Visual Studio Code, ayudarán al desarrollador y le
darán pistas sobre cómo arreglarlos. Un error común para los nuevos desarrolladores que
aprenden en Python es no agregar los dos puntos al final de las condiciones o sentencias. Si utiliza
un editor de código con comprobación de sintaxis, errores como este se pueden resaltar en el
lugar del error. Por ejemplo, la falta de dos puntos se resaltará en el código. La salida indicará el
nombre del archivo y la línea donde se produjo el error con, un [inaudible] señalando el error.

Ejecutar el código dará como resultado un error de sintaxis no válido que informa que hay un
problema de sintaxis. Otros errores comunes son los problemas de sangría, que también son
errores de sintaxis. Por ejemplo, si existe un problema de sangría, el código de error será error de
sangría.

pág. 183
Cuanto más aprenda a usar Python, menos tendrá que lidiar con este tipo de errores porque
tendrá más habilidad para crear y analizar su código.

Ahora pasemos a Errores de Excepción. Ocurren durante la ejecución del código y pueden pasar
fácilmente desapercibidos por el ojo no entrenado, pero el desarrollador debe manejar las
excepciones. Se debe ocupar de cualquier posible problema y de la base de códigos para evitar
que la aplicación falle. Exploremos una excepción lanzada. Por ejemplo, su código puede ser
sintácticamente correcto, pero si intenta dividir cinco por cero, no tiene sentido matemático.

pág. 184
Por lo tanto, cuando usted ejecute este programa, se lanza la excepción ZeroDivisionError. Por
suerte, por defecto, Python incluye muchos errores de excepción que puede utilizar para detectar
posibles problemas en su código. En este video, conoció los conceptos básicos de errores y las
excepciones, que es un paso en la dirección correcta para convertirse en un mejor programador
de Python.

pág. 185
Manejo de excepciones

En este video, verá cómo manejar las excepciones en Python. Aprenderá a cambiar los mensajes
de error y a envolver su código dentro de las sentencias "try" y "accept". Como ejemplo, escribiré
una función matemática simple. Defino una nueva función llamada dividir por y le permito que
acepte dos parámetros, A y B. El objetivo de esta función es devolver el valor de la división de
ambos números. En la siguiente línea, escribiré devolver a dividido por b. Ahora, añado una
sentencia "print" para la función dividir por dentro de la sentencia "print". Además, agregaré un
nuevo conjunto de paréntesis con un valor de 40 y 4. Estos son los valores que dividiré por la
función. Hago clic en "Ejecutar" y el valor devuelto es 10, que es correcto porque cuatro va en 40,
10 veces. Ahora, vamos a probar lo que sucederá si paso los valores 40 y 0. Al hacer clic en
"Ejecutar", Obtengo un error o una excepción. La excepción en este caso dice error de división
cero, división por cero. Aparece este error porque en matemáticas no se puede dividir un número
por cero. Estará de acuerdo en que recibir errores crípticos puede molestar a los usuarios, así que
la pregunta es, ¿cómo puedo manejar los errores de modo más amigable? ¿Cómo puedo evitar
que un usuario vea la excepción real que se está imprimiendo? Lo puede hacer con las sentencias
"try" y "accept" de Python. Simplemente escriba "try", dos puntos, y luego la siguiente línea
"except", dos puntos. Añada el código que desea para que se ejecute dentro de la sentencia "try",
así que elimino las impresiones en la parte inferior y corto la función dividir por cero. Dentro de la
sentencia "try" escribo A, y S igual, y pego la función. A continuación, en la sentencia "except"
añadiré mi propia sentencia de error. Añado una sentencia "print" para la cadena.

pág. 186
Algo salió mal. Permítame despejar la terminal, para que pueda centrarse en la salida. Hago clic
en "Ejecutar" y ahora se imprime la sentencia de error. Entonces, ¿qué está pasando? La sentencia
"try" probará y ejecutará el código que agregó dentro. En caso de una excepción, desencadenará
la línea "except" y ejecutará cualquier código que se añada debajo de la sentencia "except", pero
Python nos permite hacer la sentencia "except" más específica. Si quiere atrapar la excepción en
sí misma podría añadir la excepción de la clase base después de aceptar. La clase base excepción
se utiliza para todas las excepciones que se escriben dentro de Python. Puede acceder a la
información sobre excepciones utilizando E después de la excepción. La variable E actúa como un
alias para la excepción.

pág. 187
Puedo utilizar E para imprimir la excepción en la sentencia "print", así que vamos a editar la
sentencia "print". Añado E al final del mensaje de error, Pulso "Ejecutar" y ¿qué ocurre? Nuestro
mensaje personalizado está impreso, pero también se imprimen los contenidos de E, así que esta
vez dice algo salió mal, división por cero. En Python, puede también obtener acceso al tipo o a la
clase real de excepción que se ha producido. Para ello, agrego otra sentencia "print" de Clase
E.subrayado, subrayado. Ejecuto esta sentencia una vez más. Esta vez la salida incluye la clase de
error también, es decir, error de división de clase cero. Voy a despejar la terminal de nuevo. Vamos
a dar un paso más para proporcionar una información aún más específica al usuario final. En la
sentencia "except", he sustituido la clase base excepción por el error real que se imprimió, el error
de división cero. Cambiaré la sentencia "print" para que al principio imprima el error real
añadiendo E al comienzo de esta sentencia, y ahora añadiré un texto descriptivo que diga no
podemos dividir por cero. Hago clic en "Ejecutar" y ahora la salida es división por cero, no podemos
dividir por cero. Hasta este punto, ha visto cómo envolver su código con las sentencias "try" y
"except", y cómo optimizar el mensaje que ve un usuario, pero ¿cómo puede manejar más de una
excepción sin saber cuáles son de antemano? Afortunadamente, puede encadenar la sentencia
"except" añadiendo otra sentencia "except". Digamos que el código no arroja el error de división
por cero y la primera sentencia except. Podría añadir otra sentencia "except" que compruebe una
excepción genérica. Ahora, añada la excepción de la clase base.

De nuevo, añado una sentencia "print" con E y un mensaje con algo de información general. Haré
clic en "Ejecutar" y en este caso porque todavía existe un error matemático, la función se disparará
igualmente en la primera sentencia "except", pero esto le da una buena idea de cómo puede

pág. 188
probar más excepciones. Enhorabuena. Ahora ya sabe cómo envolver el código en las sentencias
"try" y "except" para manejar todas las posibles excepciones en su código.

pág. 189
Ejercicio: excepciones en Python

Al final de este ejercicio, podrá atrapar excepciones.

Ejercicio

Su tarea en este ejercicio es agregar código para atrapar excepciones y gestionarlas de modo más
sencillo para el usuario.

IndexError

El siguiente código presenta un problema. Intenta localizar un elemento de la lista que no existe.
Al ejecutar el código se generará IndexError. Agregue la gestión de excepciones para evitar que se
produzca el error y se devuelva un mensaje más sencillo para el usuario, como "El elemento no
existe en la lista".

ZeroDivisionError

En matemáticas existen reglas sobre dividir por cero. El siguiente código intenta hacerlo y mostrará
un ZeroDivisionError. Agregue la gestión de excepciones para devolver 0 en lugar de permitir que
se produzca el error.

pág. 190
FileNotFoundError

El código siguiente busca un archivo que no existe. Agregue la gestión de excepciones para
detectar este error y devolver el siguiente mensaje "No se pudo encontrar el archivo".

pág. 191
Excepciones en Python: solución

Código de solución

pág. 192
Excepciones en Python

pág. 193
Manejo de archivos en Python

Si bien el manejo es parte esencial del aprendizaje de Python. Python tiene varias funciones
integradas para crear y manejar archivos. El manejo de archivos incluye apertura, lectura y
escritura de archivos entre otras operaciones. Como desarrollador, probablemente trabajará con
grandes cantidades de datos y el manejo alejado lo hace más fácil. Por eso es importante aprender
a trabajar con archivos.

Ya sea que esté trabajando con datos en su computadora, en la web o en la nube, lo más probable
es que se guarde en algún tipo de archivo. Existen dos funciones de manejo de archivos en Python,
"open" y "close" (abrir y cerrar). Vamos a explorar primero la función "open". La función "open"
se utiliza para lectura, escritura y creación de archivos.

La función "open" acepta dos argumentos. El primero es el nombre del archivo o la ubicación del
archivo y el segundo argumento es el modo. El modo indica qué acción se requiere como leer,
escribir o crear. También especifica si desea la salida del archivo en formato binario o de texto.
Veamos los modos de manejo de archivos que puede utilizar en Python. Primero tiene "r" que se
utiliza para abrir y leer un archivo en formato de texto y para que "rb" abre y lee un archivo en
formato binario. Más adelante, obtendrá más información sobre este tema. R+ por otro lado, abre

pág. 194
el archivo tanto para lectura como para escritura y "w" abre el archivo para escritura. Tenga en
cuenta que "w" sobrescribirá el archivo existente. Por último, "a" abre archivos para editar o
agregar datos.

Luego, hay la función "close". La función "close" se utiliza para cerrar la conexión de archivos
abiertos, sepa que no toma argumentos. Existe una forma más de abrir y cerrar un archivo en
Python y eso es con la función "open".

La ventaja de utilizarlo es que cierra el archivo automáticamente. La función "open" se mostrará

en breve. A estas alturas ya entiende cómo abrir archivos para ciertas acciones, pero podría quizá
se pregunte cuál es la diferencia entre abrir un archivo en formato de texto y en formato binario.
En Python, generalmente maneja archivos en dos formas, ya sea en formato de texto o binario. El
formato de texto es más amigable con el usuario porque los humanos tienen la capacidad de leer.

pág. 195
No podrá leer archivos en formatos binarios, pero son mucho más compactos y, por lo tanto,
tienen un mejor rendimiento. Ahora vamos a cubrir cómo especificar el tipo de manejo de archivos
en Python. Python utiliza texto como formato predeterminado para el manejo de archivos.

Entonces, pasar en cualquier modo para leer o escribir un archivo lo establecerá automáticamente
en un formato de texto. Para configurar el manejo de archivos en binario, debe pasar la letra "b"
junto con la opción de lectura o escritura.

pág. 196
Por ejemplo, usted escribe el nombre del archivo y "rb" para leer un archivo en formato binario o
"ab" para agregar a un archivo en formato binario. Ahora explorará el manejo de archivos en
código.

Primero declaro una simple variable denominada archivo y le asigno la función "open" para
obtener acceso a un archivo. Pero antes de poder utilizar la función "open", primero necesito crear
un nuevo archivo para probar, llamémoslo "test.txt". Dentro de este archivo de texto agrego una
línea de texto simple. Bien ahí. Volvamos al archivo Python. Dentro de los paréntesis de la función
"open", ahora puedo agregar el primer argumento, es decir, test.txt entre comillas desde que es
una cadena. Para el segundo argumento, escribo la palabra modo, el signo igual y luego solo
utilizaré "r" para leer también entre comillas.

Hasta ahora, la variable denominada "archivo" tendrá acceso al contenido de test.txt. Pero para
leer el archivo, debe agregar una función "readline" o "readlines". "Readline" solo devolverá la
primera línea del archivo mientras que"readlines" dará salida a una matriz con múltiples líneas.
Dado que solo tenemos una sola línea de texto en este archivo, solo utilizaré la función "readline"
que escribo file.readline(). Asigné la línea de código a un nuevo nombre de variable, datos. Luego,

pág. 197
agrego una sentencia "print" para imprimir el contenido de los datos. Por último, agrego una
función "close" que cerrará el acceso al último archivo test.txt. Simplemente cierro con un
conjunto de paréntesis.

Hago clic en ejecutar y el contenido del archivo se imprime, es decir, "Hello" (Hola) ahí. A
continuación, voy a demostrar otra manera para obtener acceso a un archivo en Python. Voy a
cambiar la función "open" a la función "with open". Solo borraré la pantalla para asignar una
variable a la función "open". Es necesario agregar "as" después de los paréntesis y luego el nombre
de la variable. ¿Por qué utilizaría eso con la función "open"? La función "with open" es mejor en
el manejo de excepciones y cerrará automáticamente el archivo por usted.

Igual que antes, creo una segunda variable de datos, "readline" y luego imprimo el contenido de
los datos. Voy a hacer clic en ejecutar y al igual que antes se imprimirá el contenido del archivo.
Ya sabe cómo trabajar con archivos en Python. Esto incluye las funciones integradas para crear y
manejar archivos y las funciones para abrir, leer y escribir archivos.

pág. 198
Creación de archivos

En este video, aprenderá cómo crear archivos en Python y explorar métodos para insertar
contenidos en un archivo nuevo. Los archivos se utilizan para datos almacenados de forma
permanente. Cualquier cosa almacenada en las variables de su código existe en la memoria de
acceso aleatorio o RAM. Dado que la RAM pierde sus datos cuando se apaga la computadora, es
importante poder crear archivos y, de ese modo, los datos estarán disponibles para uso futuro o
como registro permanente. En Python, podemos crear nuevos archivos mediante la función de
apertura y habilitando el modo de escritura. Comencemos con un ejemplo corto. Utilizaré una
sentencia "with" con la función "open" y pasaré en los siguientes parámetros. Nuestro archivo será
newfile.text. Vamos a establecer el modo al pasar modo es igual a "w". Ahora, asigno este archivo
a una variable escribiendo, "As file." Una forma abreviada de asignar el modo es introducir un solo
caracter que representa el modo que necesita. En este caso, puedo reemplazar modo es igual a
"w" con solo la letra "w" y significa lo mismo. Ahora que tengo acceso al archivo recién creado
como variable, puedo comenzar a agregar contenido al archivo mediante la función de escritura.

En una nueva línea, escribo file.Write. Voy a agregar algo de texto simple. Se trata de un nuevo
archivo creado. Cuando hago clic en Ejecutar, el panel Explorador en el lado izquierdo del código
VS muestra que mi archivo denominado newfile.text se generó como un nuevo archivo. Al hacer
clic una vez en el archivo nuevo para seleccionarlo se muestra su contenido y se confirma que el
texto que he introducido mediante la función de escritura está ahora presente en el archivo. Si
elijo escribir varias líneas de contenido del archivo en lugar de una sola línea, Puedo utilizar la
función Writelines. La función Writelines acepta una lista. Una lista en Python se representa
mediante corchetes y luego una coma para cada línea. Edito mi file.write para decir file.writelines.
A continuación, entre corchetes, agrego una coma después de la oración y escribo la oración
siguiente; esta es otra línea para agregar.

pág. 199
Hago clic en Ejecutar y el nuevo file.text tiene ahora las dos líneas creadas por mi función
Writelines. Pero no es exactamente de la manera que necesito que sea. Python añadirá el
contenido de la lista exactamente como se especifica dentro de la lista. Si quiero que el contenido
se rompa en una nueva línea, necesito especificar una nueva línea poniendo una barra oblicua
invertida y la letra n, sin espacio. Justo dentro de la cita abierta de la segunda oración, agrego
barra oblicua invertida n. Ahora, cuando hago clic en Ejecutar, el contenido de newfile.text es más
legible con cada oración en una línea separada. Una cosa a tener en cuenta es que cada vez que
ejecuto mi script, está reemplazando el archivo actual. Por ejemplo, si inserto el número 2 en la
primera línea de texto, hago clic en Ejecutar y luego compruebo mi archivo de texto, se ha
reemplazado el archivo anterior por uno donde acabo de agregar el número 2 en la primera
oración, sobrescribiendo así el archivo existente con un nuevo file.text. Por otro lado, si quiero
agregar el archivo en lugar de reemplazarlo cada vez, solo tengo que cambiar la acción de modo.
Para hacerlo, reemplazo la letra "w" y pongo una letra "a", que significa anexar. Ahora hago clic en
Ejecutar tres veces, entonces reviso mi newfile.text para encontrar que el contenido se ha
agregado y ahora tiene varias líneas. Sin embargo, no se ha extraído exactamente como quería
que fuera.

pág. 200
La razón es que no tengo una nueva línea especificada al principio, así que agrego una barra
oblicua invertida n antes de mi primera oración. Dado que necesito reemplazar el archivo, vuelvo
a cambiar el modo a "w" para asegurarme de que estoy anulando el último archivo. Hago clic en
Ejecutar y eso reemplaza las líneas existentes que estaban allí. Ahora quiero volver a agregar al
archivo. Vuelvo a cambiar el modo a Anexar cambiando la "w" a "a", y hago clic en Ejecutar tres
veces. Compruebo el archivo y confirmo que las nuevas líneas se anexaron cada vez. La parte final
de mi código será atrapar excepciones. Tenga siempre presente la necesidad de tratar con
cualquier excepción utilizando las sentencias "try" y "accept". Agrego una nueva línea sobre mi
código existente y allí escribo, "Try colon". Como ejemplo, utilizo filenotfound error, que es un
error frecuente. Esto necesita dos nuevas líneas agregadas al final de mi código. Escribo except
filenotfound error como "e" y presiono Enter para una nueva línea. Entonces para imprimir el error
escribo, F print error coma e.

Ahora para forzar que el error suceda, digamos que pedí un directorio que sé que no existe en mi
directorio actual. El directorio defectuoso se denomina "sample". Edito mi código para leer sample
barra oblicua invertida newfile.text. Ahora, voy a borrar mi terminal y ejecutar mi pantalla de
nuevo.

pág. 201
Obtengo el error generado por mi comando de impresión, no dicho archivo o directorio. Al crear
archivos, asegúrese de que el directorio donde desea colocar el archivo existe realmente. En esos
casos, debe asegurarse de que el directorio ya existe o crear un directorio desde Python y luego
crear el archivo dentro de él. En este video ha aprendido sobre la creación de archivos dentro de
Python utilizando los modos "append" y "write" e insertando contenido único o multilínea en el
archivo.

pág. 202
Archivos de lectura

Ya sabe cómo manejar archivos en Python, pero ¿sabe cómo leer el contenido de un archivo?
Poder leer archivos es esencial cuando se trabaja con datos almacenados en Python. Python ofrece
varias funciones integradas que facilitan esta tarea. Los tres métodos que exploraremos en este
video son "read", "readline" y "readlines". Comencemos con "read". El método "read" devuelve
todo el contenido del archivo como una cadena que contendrá todos los caracteres. También
puede pasar un entero para devolver solo el número de caracteres especificado en el archivo. El
segundo método para leer archivos en Python es "readline". Exploremos este método. La función
"readline" devuelve una sola línea como una cadena. Si, por ejemplo, tiene un archivo con dos
líneas de texto que dicen: esta es la primera línea y esta es la segunda línea, la función de lectura
de archivos devolverá como la salida solo la primera línea de texto. Esta es la primera línea. La
función "readline" también puede incluir un argumento entero para devolver un número
determinado de caracteres en una sola línea. Digamos que utiliza el mismo archivo de prueba,
pero pasa un entero de 10, su salida será los primeros 10 caracteres de la primera línea. En este
caso, las palabras, "this is" (esto es), y letras, th, para un total de 10 caracteres. El tercer método
para leer archivos en Python es "readlines". Permítame demostrar este método. El método
"readlines" lee todo el contenido del archivo y luego lo devuelve en una lista ordenada. Esto le
permite iterar sobre la lista o elegir líneas específicas basadas en una condición. Por ejemplo, tiene
un archivo con cuatro líneas de textos y superan una condición de longitud, la función de lectura
de archivos devolverá la salida, todas las líneas de su archivo en el orden correcto. Los archivos se
almacenan en directorios y tienen rutas. Leer archivos del mismo directorio es sencillo. Solo
necesita el nombre del archivo. Sin embargo, cuando se trabaja con diferentes ubicaciones, es
importante que conozca la diferencia entre rutas absolutas y relativas. Comencemos con las rutas
absolutas. Las rutas absolutas contienen la etiqueta "forward" o de unidad. Una ruta de archivo
absoluta incluye toda la información que necesita para localizar un archivo, tanto si se encuentra
en ese directorio de archivos o no. Las rutas relativas normalmente no contienen ninguna
referencia al directorio raíz y, en general, son relativas al archivo de llamada. Una ruta de archivo

pág. 203
relativa solo incluye la información que necesita para localizar un archivo en su actual directorio
de trabajo.

Ahora voy a demostrar cómo puede leer archivos en Python. Comienzo con un simple archivo txt
de ejemplo. Solo tiene algunos textos con un par de líneas que usaré en la demostración de
algunas de las opciones disponibles para la lectura de archivos. Comencé por usar "with open" y
pasé mi nombre de archivo, que es "sample.txt. Solo quiero leer el contenido, así que establezco
el modo en "r" y lo firmo en una variable de archivo. La primera opción para leer un archivo es
imprimir todo el contenido del archivo.

Para ello, utilizo la función "print file.read", y hago clic en el botón "ejecutar". Observe que todo
el contenido del archivo se imprime tal cual. La segunda opción me permite imprimir solo una
determinada sección del archivo. Por ejemplo, digamos que solo quiero imprimir "the quick brown
fox jumps over the lazy dog" (el rápido zorro marrón salta sobre el perro perezoso) Son 44
caracteres. Puedo pasar un parámetro a la función de lectura que le indica a la función que lea los
primeros 44 caracteres. Para ello, escribo el número 44 y verá que solo imprime la primera línea

pág. 204
cuando hago clic en "Ejecutar". La forma en que esto funciona es que comienza en el principio
basado en el índice de 0, y 44 es el último caracter que se debe imprimir. De esta manera, puedo
controlar qué secciones se imprimen.

La tercera opción que tengo es leer una línea. La función que quiero es "readline", solo tomará la
primera línea del archivo. Hago clic en "Ejecutar" e imprime solo la primera línea de texto dentro
de ese archivo. La cuarta opción es utilizar la función "readlines" que devolverá una lista de líneas.
Hago clic en "Ejecutar"; observe que el texto del archivo ahora está entre corchetes. Por último,
dado que es una lista, puedo asignarlo a una variable. Por ejemplo, puedo decir "data=
file.readlines".

Entonces puedo escribir un bucle "for" para "x" en datos. Imprimo el valor de "x", y luego cuando
hago clic en " Ejecutar". Se dará cuenta de que los elementos de la lista se imprimen línea por
línea. Algo a tener en cuenta es que cuando se utiliza el "with open" y obtiene "as file", devuelve
una lista por defecto. Puedo cambiar el bucle "for" para que apunte a la variable de archivo.
Cuando hago clic en "Ejecutar" se devuelve la misma opción. Estos son solo algunos de los métodos
que puede utilizar en Python para la lectura de archivos. Ahora podrá describir cómo leer archivos
en Python y demostrar cómo dar salida a diferentes formatos mediante las funciones "read",
"readline" y "readlines".

pág. 205
Almacenar el contenido de los archivos en estructuras de datos

Imagine que intenta encontrar un nombre para su perro nuevo. No está seguro de cómo le gustaría
llamarlo, así que opta por utilizar sus conocimientos de Python para poder decidir.

Primero, accede a un archivo con una lista de nombres que le gustarían para su nueva mascota.

El archivo se denomina petnames.txt, y tiene el siguiente contenido:

1. Ace
2. Atlas
3. Bailey
4. Bear
5. Blaze
6. Boomer
7. Buddy
8. Coco
9. Cooper
10. Duke
11. Dozer
12. Echo
13. Gizmo
14. Harley
15. Mac
16. Max
17. Milo
18. Oscar
19. Rex
20. Rocky
21. Rocket
22. Wolfie

pág. 206
Ahora que tiene el archivo petnames.txt, le gustaría utilizarlo dentro de su programa de Python
para elegir al azar un solo nombre de mascota.

Para ello, necesitará tener un archivo Python en el que importará el petnames.txt como se indica
a continuación:

f = open("petnames.txt", "r")

La función open() lee un archivo fuera del propio programa.

La función open() acepta dos parámetros:

La ruta y el nombre del archivo en forma de cadena.

El modo de importación (por defecto "r", que significa "leer")

En la línea anterior, importo el archivo en la raíz del proyecto. Solo especifico el nombre del
archivo, sin la ruta. También utilizo el modo por defecto "r" para leer en el archivo. Guardo el
archivo importado en una variable denominada f.

A continuación, voy a agregar otra variable, f_content, y le asigno el resultado de la lectura del
archivo f.

En la tercera línea, imprimo la variable f_content.

La línea print(f_content) devuelve el contenido exacto del archivo, tal cual:

1. Ace
2. Atlas
3. Bailey
4. Bear
5. Blaze
6. Boomer
7. Buddy

pág. 207
 8. Coco
9. Cooper
10. Duke
11. Dozer
12. Echo
13. Gizmo
14. Harley
15. Mac
16. Max
17. Milo
18. Oscar
19. Rex
20. Rocky
21. Rocket
22. Wolfie

Ahora que he confirmado que leo correctamente el archivo, no sería útil continuar con la
impresión del contenido del archivo, por lo que puedo convertir la línea en un comentario
print(f_content).

Además, puedo obtener la variable f_content en una lista. La cadena "\n" se utiliza para dividir el
texto donde se encuentra una nueva línea.

f_content_list = f_content.split("\n")

Ahora estoy listo para imprimir la variable f_content_list, de la siguiente manera:

print(f_content_list)

Esta vez, el resultado es el siguiente:

pág. 208
Aquí está mi código completo hasta este punto, con las llamadas print() redundantes eliminadas.

Ahora que tengo todos mis posibles nombres de mascotas en una lista, puedo elegir al azar un
nombre de la f_content_list de nombres.

Para ello, tendré que importar el módulo aleatorio en la parte superior de mi código: import
random.

Ahora puedo utilizar la función choice() del módulo aleatorio: random.choice().

La función choice() acepta un parámetro de secuencia. Una lista es uno de sus valores aceptados.
Lo que significa que ahora puedo añadir otra línea de código al final de mi programa:

print(aleatori.choice(f_content_list))

Al ejecutar el código ahora, se generará un nombre de mascota aleatorio. La primera vez que lo
ejecuté, obtuve el nombre "Milo", y la segunda vez, "Dozer". Siempre es bueno volver a comprobar
los programas de este tipo ejecutándolos varias veces como una forma rápida de confirmar que
se comportan según lo previsto.

Aquí está el código completo de mi programa ahora (incluidas las líneas de código convertidas en
comentarios):

pág. 209
Por último, si tuviera varios archivos en mi carpeta, podría permitirme elegir un archivo del que
leer en una lista de nombres.

A continuación, explicare cómo funcionaría:

La única diferencia entre esta mejora y el programa anterior es que ahora guardo la variable
f_name como resultado de la entrada proporcionada por el usuario. Una vez que tengo la variable
f_name, ejecuto la función open() y luego continúo con otros pasos como ya se ha explicado.

pág. 210
Leer datos, almacenar, manipular y generar nuevos datos en un archivo

pág. 211
pág. 212
Tareas de programación: Leer datos, almacenar, manipular y generar nuevos datos en un archivo
Introducción
En este laboratorio debe leer el contenido de un archivo y luego escribir el contenido a otro
archivo. También debe almacenar el contenido de un archivo en una lista para poder acceder a
él de diferentes maneras.
Objetivo
Utilice la función "open" para leer y escribir archivos.
Objetivos

• Crear una función para lectura en un archivo.

• Crear una función para escribir archivos.
Instrucciones
Paso 1: Compruebe que los archivos sampletext.txt y file_ops.py existen y están presentes
dentro de la carpeta del proyecto. Puede ejecutar el archivo file_ops.py abriendo una terminal y
ejecutando el comando python3 file_ops.py.

Paso 2: Complete la función read_file() para leer en el archivo sampletext.txt utilizando la función
open y devolver todo el contenido del archivo.

pág. 213
Paso 3: Complete la función read_file_into_line() para que devuelva una estructura de datos de
todo el contenido del archivo en un orden secuencial de línea por línea.

Paso 4: Complete write_first_line_to_file(), que acepta dos argumentos: el contenido de un

archivo a escribir y el nombre de un archivo de salida, y escribe sólo la primera línea del contenido
del archivo en el archivo de salida dado.

Paso 5: Complete la función read_even_numbered_lines() para devolver una lista de las líneas
pares de un fichero (2, 4, 6, etc.)

Paso 6: Complete la función read_file_in_reverse() para devolver una lista de las líneas de un
archivo en orden inverso.

def read_file(file_name):

with open(file_name, "r") as file:

file_name = file.read()
print(file_name)
return file_name

def read_file_into_list(file_name):

with open(file_name, "r") as file:

file_name = file.readlines()
return file_name

pág. 214
def write_first_line_to_file(file_contents, output_filename):

first_line = file_contents.split("\n")[0]
with open(output_filename, "w") as file:
file.write(first_line)

def read_even_numbered_lines(file_name):

with open(file_name, 'r') as file:

lines = file.readlines()
return [lines[i] for i in range(1, len(lines), 2)]

def read_file_in_reverse(file_name):

with open(file_name, 'r', encoding='utf-8') as file:

lines = file.readlines() # Lee todas las líneas en una lista

# Invierte la lista y elimina espacios extra

reversed_lines = [line.strip() for line in reversed(lines)]
print(reversed_lines) # Imprime la lista en orden inverso

return reversed_lines # Devuelve la lista en orden inverso

file_name = "sampletext.txt"
print(read_file_in_reverse(file_name))

Here are some sample commands to help you run/test your implementations.

Feel free to uncomment/modify/add to them as you wish.

def main():

file_contents = read_file("sampletext.txt")
print(read_file_into_list("sampletext.txt"))
write_first_line_to_file(file_contents, "online.txt")
print(read_even_numbered_lines("sampletext.txt"))

pág. 215
 print(read_file_in_reverse("sampletext.txt"))
if __name__ == "__main__":
main()
Resumen del módulo: programación básica con Python
Ha llegado al final de este módulo sobre programación básica con Python, Durante este módulo,
ha recibido una introducción a las funciones de Python y estructuras de datos, y descubrió cómo
Python trata los errores, excepciones y manejo de archivos.

Ahora es el momento de recapitular los puntos clave de este módulo. Como con la mayoría de los
lenguajes de programación, las funciones son la base para crear acciones en Python. Al completar
la primera lección en este módulo, será capaz de declarar una función en Python, pasar datos a
una función, devolver datos de una función, y explicar el alcance a un nivel básico. Para utilizar
eficazmente las funciones en un proyecto, es importante determinar su accesibilidad en diferentes
niveles de código. En esta lección también aprenderá cómo identificar los cuatro ámbitos, describir
cómo las funciones controlan el ámbito en diferentes niveles, explicar las estructuras de datos y
describir el concepto de listas en Python. Python tiene varias estructuras de datos integradas para
ayudarlo a organizar y almacenar sus datos para acceder a ellos fácilmente, y ha aprendido sobre
los más comunes. Al completar correctamente la segunda lección, podrá identificar métodos de
lista, explicar qué tipos se pueden almacenar en una lista, describir cómo iterar sobre una lista, y
explicar los principales usos de las tuplas, los conjuntos, los diccionarios y los "kwargs". El manejo
de archivos en Python como una excepción con temas se verá en la última lección de este módulo.

pág. 216
Una vez completada esta lección, debería ser capaz de; identificar cómo crear y manipular archivos
con la función "open", describir cómo leer archivos en Python, y demostrar cómo generar
diferentes formatos y almacenar el contenido de los archivos en estructuras de datos. Este módulo
le dio la oportunidad de empezar con la programación básica de Python. Bien hecho. Eso es un
paso más para convertirse en desarrollador de Python.

pág. 217
Preguntas del módulo: programación básica con Python

pág. 218
pág. 219
Recursos adicionales
Los siguientes recursos serán útiles como referencias adicionales para tratar los diferentes
conceptos relacionados con los temas incluidos en este módulo.
Obtenga más información sobre excepciones y errores en Python en el sitio web de Python:
Exceptions and Errors in Python - Python docs
Consulte el sitio web PyNative para obtener más información sobre la gestión de archivos en
Python:
File handling in Python

pág. 220
MODULO 3

PARADIGMAS DE PROGRAMACIÓN

Conozca los paradigmas de la programación procedimental y los conceptos lógicos asociados.

Explorará la programación funcional y orientada a objetos, y obtendrá una introducción a los
algoritmos.

Objetivos de aprendizaje

• Utilizar funciones para explorar el pensamiento algorítmico

• Utilizar los conceptos lógicos asociados con el flujo del programa de procedimiento

• Identificar y explicar los paradigmas de la programación de procedimientos

• Crear instancias y trabajar con objetos, clases y métodos en Python

• Explicar los conceptos de programación orientados a objetos que sustentan Python

pág. 221
PROGRAMACIÓN PROCEDIMENTAL

¿Qué es la programación procedimental?

Los desarrolladores pueden estructurar su código de muchas maneras diferentes. Python permite
modelos de programación orientados a objetos, procedimentales, y funcionales, o como a
menudo se les llama paradigmas. En este video, me centraré en la programación procedimental,
que es como escribir instrucciones paso a paso que este programa ejecuta. Es una paso importante
en la programación orientada a objetos, Por lo tanto, como nuevo desarrollador, es importante
aprende más sobre ello. El objetivo principal de un modelo de programación es estructurar su
código. Esa estructura facilita la actualización del código y crea nuevas funcionalidades dentro del
código. Pero no existe un modelo perfecto que sea una solución para las estructuras de
codificación, y a veces una combinación de enfoques funciona mejor.

La programación procedimental estructura el código en procedimientos a veces denominados

subrutinas o secciones funcionales de código.

pág. 222
Debido a este enfoque, el código está compuesto por pasos lógicos para completar una tarea
específica. Por ejemplo, agregar dos números para devolver su suma. Puedo sumar los números 5
y 10 con una pieza corta de código. Ahora quiero sumar los números 8 y 4. Sin embargo, el código
que escribí era específicamente para sumar 5 y 10.

Para mis números nuevos, debo crear otro código similar para hacer el cálculo. Eso no sería una
forma muy eficiente de codificar. En cambio, modifiqué el código a una función que aceptará dos
números como argumentos y devolverá la suma. Con esta función, no declararé los números
reales como variables, en cambio, utilizo los parámetros "a" y "b". Se necesita menos código. Pero

pág. 223
algo más importante ha sucedido. Ahora tengo la función denominada "suma", que se puede
reutilizar tantas veces como yo quiera con muchos conjuntos de números diferentes.

En programación, existe un principio denominado DRY. No se repita. Se trata de reducir la

duplicación en código. El código original que escribí para agregar dos números juntos para
devolver su suma es un buen ejemplo de lo que no hay que hacer porque tuve que escribir el
código dos veces para acomodar el segundo conjunto de números. Una pauta a tener en mente
es crear funciones que se pueden reutilizar a lo largo de su aplicación. Veamos otro ejemplo, esta
vez, para calcular el total de una factura y agregándole impuestos.

Se presentará el código en cuatro secciones para ayudarlo a enfocarse en lo que hace cada
procedimiento. Primero, el total de la factura acepta una función construida como un parámetro
y se repite para calcular la factura total y devolver su total.

pág. 224
La función de calcular impuestos acepta dos parámetros, el porcentaje y el total de la factura.
Luego devuelve el monto total del impuesto que se agregará a la factura, que también se redondea
a dos decimales.

La factura de los alimentos, que contiene sus elementos, representa la factura de un cliente, que
es estática, pero también se podría cambiar a una entrada para aceptar datos del usuario para
crear dinámicamente una factura.

En las últimas secciones, llamaremos las dos funciones para calcular la factura e impuestos y luego
imprimirlos junto con el total general. ¿Podría identificar las subrutinas o secciones funcionales de
código? ¿Observó cómo estas secciones se reutilizan entre sí? Ahora, juntemos las cuatro
subrutinas para examinar las cuatro formas en que la huella del código se reduce mediante
programación de procedimientos. Lo mejor es inspeccionar el código comenzando por el final. El
total de impuestos reutiliza el total de alimentos. El total de alimentos reutiliza el total de la factura
y la factura de alimentos. Calcule el total de la factura de reutilización de impuestos.

pág. 225
El total de la factura reutiliza la factura de alimentos. En resumen, las ventajas del paradigma
procedimental son, es fácil para principiantes para aprender y empezar. Los procedimientos se
pueden reutilizar por otras partes del código.

El código es fácil de entender porque cada procedimiento se rompe en tareas específicas. La

programación procedimental tiene algunas desventajas, como la dificultad para mantenerla y
extenderla. En algunos casos, no se relaciona bien a objetos del mundo real. Los datos están
expuestos en todo el programa.

pág. 226
La programación procedimental tiene tanto sus ventajas como desventajas. A medida que obtiene
más información como desarrollador nuevo, va a ser más capaz para decidir si es el mejor enfoque
para una codificación específica o no.

pág. 227
Algoritmos

En este video recibirá información sobre algoritmos. Un algoritmo es una serie de pasos para
completar una tarea dada o resolver un problema. En lo cotidiano, se usan algoritmos todo el
tiempo para completar tareas.

Un ejemplo de ello es una receta para hacer un

omelet de huevo. En primer lugar, tiene la lista de
los ingredientes para hacer los omelets. Esto se
puede llamar sus "entradas". A continuación, el
método o las instrucciones para seguir paso a paso
para crear su plato.

Por último, completa su omelet, su "salida".

Los pasos para hacer los omelets son siempre
los mismos. Un algoritmo en programación
funciona de forma similar. En programación,
los algoritmos se utilizan para resolver una
gran cantidad de problemas que pueden ser desde simples a muy complejos. La clave para
entender y crear un algoritmo es dividir el problema en partes más pequeñas, al igual que la receta
del omelet de huevo. De esa manera, construye los pasos para completar el algoritmo que
resolverá el problema global. Ahora, veamos una aplicación práctica de algoritmos en codificación.
Voy a demostrar un algoritmo particular que comprueba si una palabra es un palíndromo. Un

pág. 228
palíndromo es una palabra que puede escribirse igual, tanto hacia delante como hacia atrás. Por
ejemplo, la palabra "racecar" (coche de carreras) es un palíndromo porque puedo deletrearla
hacia adelante como R-A-C-E-C-A-R y hacia atrás, sigue siendo igual: R-A-C-E-C-A-R. Para poder
comprobar si una palabra es un palíndromo, necesito usar un algoritmo. Como ya se ha
mencionado, un algoritmo es una serie de pasos para resolver un problema. Permítame desglosar
el problema. Sé que la cadena en mi ejemplo, "racecar", tiene un índice y necesito comprobar si
el índice en la parte delantera de la cuerda es igual al índice en el final de la cadena. De este modo,
puedo comparar los dos valores de los índices. Imprimo "str0" porque ese es el primer índice, y
también imprimo "str6" porque ese es el último índice. Puedo contar esto hasta comprobar dos
veces 0, 1, 2, 3, 4, 5, 6. Luego hago clic en ''Run" (Ejecutar). La salida es los dos valores que necesito
comparar. Ambas son la letra "r" al principio y al final del "racecar". Ahora voy a desglosar nuestro
problema en pasos más pequeños. En primer lugar, tengo que comprobar si el valor del índice 0
es igual al valor del último índice 6, que en este caso es "r". Luego necesito comprobar que el
siguiente o segundo caracter, que es el Índice 1, es igual al segundo último caracter, que es Índice
5. Por último, tengo que comprobar si el caracter 2 es igual al caracter 4. Lo que tengo que hacer
es comprobar si estas condiciones son verdaderas o falsas. Veamos cómo puedo escribir esto en
algún código. Empiezo por crear una función "def is_palindrome". Sé que aceptará un único
parámetro denominado "string", que he ingresado. Ahora quiero obtener el índice inicial, así como
el índice final. Pongo el índice inicial en una variable igual a cero. Cada cadena siempre comenzará
en el índice 0 y luego el índice final será la longitud de la cadena. Ingreso índice final igual a función
"len str" y luego menos 1. Esto se debe a que una cadena siempre comienza en cero, y tengo que
pensar en el último índice. A continuación, lo que quiero hacer es iterar a través de la cadena y
comparar el índice inicial con los caracteres del índice final para validar que son iguales. Para ello,
creo un bucle "for" escribiendo 4x en "str" y haré la comparación dentro del bucle "for". Puedo
comprobar si el primer índice es igual al último índice. Dado que los dos caracteres "r" y "r" son
iguales, seguirá siendo cierto, pero sería más rápido para mí para comprobar si es falso porque
sabré directamente si no es un palíndromo. Hago una sentencia "if" y uso la cadena que se pasa
como parámetro. Luego utilizo el índice inicial para obtener el caracter. Compruebo si no es igual
a la cadena dentro del índice final. Si se cumple esta condición devolverá falso, lo que confirma

pág. 229
que no es un palíndromo. Pero si la condición nunca se cumple fuera del bucle "for", devuelve
verdadero, lo que confirma que es un palíndromo. He hecho todas las comprobaciones a través
del índice inicial y el índice final, y vuelve a la condición de verdadero para confirmar que es un
palíndromo. Ahora voy a probar el algoritmo para comprobar que funciona. Utilizaré una sentencia
"print". Llamo a la función "is_palindrome" y paso "racecar" porque sé que es un palíndromo.

Hago clic en "Run" (Ejecutar), y devuelve el valor de verdadero. Si cambio "racecar" a "racecars" y
lo ejecuto de nuevo, se devuelve la condición de falso. Este es un ejemplo de creación de un
algoritmo de código "in" para resolver un problema.

Consta de una serie de pasos que deben seguirse para resolver el problema en código para
devolver la condición de si la cadena es un palíndromo o no. Ahora sabe lo útiles que pueden ser

pág. 230
los algoritmos como una forma de resolver paso a paso un problema con codificación. Un
algoritmo puede utilizarse para resolver problemas tanto pequeños como complejos. Una vez
creados los pasos de un algoritmo, se ejecutarán de la misma manera cada vez que se utiliza el
algoritmo.

pág. 231
Algoritmos de escritura

Un algoritmo es un conjunto de instrucciones que se completan paso a paso para resolver un

problema concreto. Pero, ¿cómo se hace para escribir una instrucción desde cero? Existen
diferentes maneras. A algunas personas les gusta escribir el pseudocódigo, una sintaxis en inglés
que se asemeja al código, para explicar el problema en una serie de pasos. Otra manera es utilizar
un diagrama de flujo que proporcione una representación gráfica de la serie de pasos. El diagrama
de flujo recorre el flujo lógico del algoritmo y muestra las diferentes decisiones que hay que tomar
para resolverlo.

Supongamos que quiere crear un algoritmo para determinar cuántos pedidos de comida están
pendientes en la cocina en el tablero de la barra de un restaurante. Si tuviera que hacerlo sin una
computadora, debería contar la cantidad de hojas de notas con pedidos y obtendría su número
total. En código, puede ser bastante similar. Vamos a crear un pseudocódigo para representar
esto.

El pseudocódigo comienza en 0 y luego comprueba cuántas hojas de notas hay en el tablero. Si se

encuentra una hoja de notas, el contador se incrementará en 1. Y finalmente, devolverá el
recuento total.

Uno de los aspectos de la escritura de un algoritmo es su eficiencia. A esto se le llama optimizar el

código. Si quiero optimizar el código anterior tengo que ver cómo puedo hacer que llegue más
rápido a la respuesta. En el mundo físico, en lugar de contar de uno en uno, podría contar dos
hojas de notas a la vez. ¿Cómo puedo representarlo en mi pseudocódigo? Solo tengo que cambiar
el incremento de 1 a 2.

pág. 232
Esta es una optimización bastante sencilla, pero ¿funcionará en todos los casos? ¿Qué sucede, por
ejemplo, si hay tres pedidos en el tablero? El código funcionaría de la siguiente manera:

• Hojas de notas = 0
• Cada par = 1
• Incrementar el contador en 2
• Devolver 2

Este código tiene errores. No incluye la hoja de notas individual en el tablero y solo devuelve 2.
Puedo corregir el código añadiendo una condición para manejar este caso límite.

Comprobemos el código para ver si cumple con los requisitos:

• Hojas de notas = 0

• Cada par = 1

• Incrementar el contador en 2

• Comprobar si hay hojas de notas individuales

• Incrementar el contador en 1

• Devolver 3

pág. 233
¡Sí! El código funciona y puede manejar el caso límite. Los algoritmos están diseñados para resolver
problemas, pero también deben ser eficientes. Necesitaba cambiar mi código para asegurarme de
que funcionaba como se esperaba.

Existen muchos tipos diferentes de algoritmos diseñados para resolver toda clase de problemas
en informática. Cuando se escribe un algoritmo, se puede resolver de muchas maneras diferentes
y cada una puede tener sus propias ventajas y desventajas.

Recursión

La recursión se refiere a un método o una función que se llama a sí misma. Se utiliza para resolver
problemas dividiendo el problema en subproblemas. Observemos algunos de los tipos de
algoritmos recursivos más populares.

Dividir y conquistar

Este algoritmo consta de dos partes. La primera consiste en dividir el problema en subproblemas
más pequeños, y la segunda, en encontrar la solución final.

Programación dinámica

Se utiliza principalmente para problemas de optimización. Es similar al algoritmo de dividir y

conquistar, ya que divide los problemas en subproblemas.

Algoritmo codicioso

Este algoritmo encuentra la mejor solución en cada paso, en lugar de abordar la optimización de
manera global.

pág. 234
Ejercicio: prepare una taza de café

Introducción

En este ejercicio, practicará el uso de un algoritmo para preparar una taza de café instantáneo. El
objetivo es establecer los pasos necesarios para obtener el producto final.

Instrucciones

Paso 1: Comience con las entradas: ¿qué se necesita para preparar una taza de café instantáneo?

Paso 2: Piense en todos los pasos necesarios en el aspecto físico para preparar una taza de café
instantáneo.

Paso 3: Considere los casos extremos de productos opcionales como la leche o el azúcar, algunas
personas pueden solicitarlos.

Paso 4: El algoritmo cuando está completo debería tener como resultado final "una taza de café".

Consejos: la planificación es clave con cualquier algoritmo. Asegúrese de tener todos los pasos
bien ordenados.

Recursos

• de algoritmos

pág. 235
Prepare una taza de café: solución

Algoritmo de solución

Entrada

Ingredientes requeridos:

• Taza

• Agua caliente

• Gránulos de café

Opcional:

• Leche

• Crema

• Azúcar

Salida

Una taza de café.

Pasos

1. Agregue agua potable a un hervidor eléctrico.

2. Encienda el hervidor para hervir el agua.

3. Mientras espera, prepare el café.

• 4. Agregue los gránulos de café a la taza.

• 5. Si el agua está hervida, vierta el agua en una taza y siga esperando.

6. Si se requiere leche o crema, agregue y revuelva.

7. Si se requiere azúcar, agregue y revuelva.

pág. 236
8. Entregue el café.

Auto revisión: prepare una taza de café

pág. 237
Complejidad algorítmica

Como desarrollador, su tarea principal será escribir código para satisfacer las necesidades de la
empresa. Ese código tendrá que ir a través de lo que se denomina refactorización. Esto significa
que reescribe o vuelve a trabajar el código para que sea más fácil de administrar o para que se
ejecute de manera más eficiente. La refactorización es una pieza estándar del ciclo de desarrollo
del software. Facilitar la administración del código, puede ser sencillo, pero ¿y hacerlo más rápido
o mejorar su rendimiento? Para determinar cómo hacer código más rápido o mejorar su
rendimiento, debe poder medirlo. El código se mide por tiempo y espacio. El tiempo se mide por
cuánto tarda y el espacio por cuánta memoria utiliza. La notación Big O tiene diferentes
complejidades o categorías que van desde horrible a excelente.

Se utiliza para medir la eficiencia del algoritmo en términos de espacio y tiempo. Exploremos los
diferentes tipos de complejidades del tiempo. Primero, el tiempo constante. Este es un algoritmo
que siempre se ejecutará bajo el mismo tiempo y espacio, independientemente del tamaño.
Tomemos un diccionario, por ejemplo. Para obtener el valor de un elemento, necesita tener la
clave. La clave es un puntero directo al valor y no requiere ninguna iteración para encontrarlo.

pág. 238
Se considera constante. El segundo es un algoritmo de tiempo lineal. Esto crecerá según el tamaño
de la entrada.

Por ejemplo, si tengo una matriz de números con un rango de 100, se ejecutará muy rápido. Pero
si se aumenta a un millón, tardará mucho más en completarse. El tamaño en este caso afecta al
tiempo de ejecución del código. Tercero, un algoritmo de tiempo logarítmico se refiere a el tiempo
de ejecución de las entradas frente al número de operaciones. Puedo adoptar un enfoque lineal
para intentar encontrar un número entre 100. Digamos que el número es 97. En una ecuación
lineal, se necesitan 96 iteraciones antes de que se encuentre el valor.

pág. 239
Esto se debe a que debe iterar a través de cada elemento uno por uno hasta que encuentra el
valor objetivo. Mediante una búsqueda binaria, puedo reducir drásticamente las iteraciones y
encontrarlo en las siete iteraciones.

Esto se mide por tiempo logarítmico. La búsqueda binaria funciona al dividir la lista en dos partes
cada vez para comprobar si un objetivo es menor o mayor que uno. Cuarto, el tiempo cuadrático
se refiere a una operación lineal de cada valor de los datos de entrada al cuadrado. Esto suele ser
una lista anidada, como en este bucle "for". Este bucle "for" se considera tiempo cuadrático ya
que el bucle exterior tendrá que iterar de manera lineal 10 veces.

Pero también tiene que iterar el bucle interno las mismas 10 veces para cada bucle exterior único.
Esto significa que las iteraciones totales son 10 veces 10, que es 100. El quinto y último es el tiempo
exponencial, que es un algoritmo que se duplica con cada iteración.

pág. 240
La secuencia de Fibonacci es un buen ejemplo de ello. El código de refactorización puede ser una
gran tarea, pero al comprender la complejidad algorítmica y cómo se calcula, se hace más sencillo
optimizar el código.

Ahora que ya conoce sobre tiempo lineal constante, logarítmico, cuadrático, y exponencial, está
un paso más cerca de su objetivo de ser desarrollador.

pág. 241
Introducción a la notación Big-O

Big-O

Todo lo que hacemos necesita ser medido. ¿Por qué, se preguntará? Para hacer algo mejor
necesita una métrica desde la que comenzar. Si una compañía de autos necesita hacer un auto
más rápido, necesita conocer la velocidad máxima del auto existente para mejorarlo. En ciencias
de la computación, la notación Big-O es la herramienta más fundamental para medir el costo de
un algoritmo. Describe la complejidad del código mediante términos algebraicos.

<Imagen que se insertará>

Big-O tiene diferentes tipos de medidas, como puede observar en el diagrama anterior. Estas
medidas determinan la velocidad de funcionamiento y el costo de su código.

Complejidad algorítmica

La complejidad algorítmica es una medida de cuánto tiempo tardará un algoritmo en completarse

dado el tamaño de la entrada, o lo que comúnmente se denomina n o n veces. La n representa el
número de elementos. La complejidad del algoritmo se puede dividir en dos tipos:

• Complejidad temporal

• Complejidad espacial

En ciencias de la computación, el tiempo se refiere al tiempo que tarda un algoritmo en

completarse. La complejidad espacial se refiere a la cantidad de memoria necesaria para
completar el algoritmo. Cuando un programador crea un algoritmo, también debe considerar
estas dos medidas críticas para que el programa funcione de modo eficiente. La eficiencia se puede
medir mediante un concepto denominado Big-O Notation. En la siguiente tabla se muestran los
resultados más rápidos a los más lentos de estas diferentes categorías:

pág. 242
 Función Notación Big O

Constante O(c)

Logaritmo O(log(n))

Lineal O(n)

Cuadrática O(n^2)

Cúbico O (n^3)

Exponencial O(2^n)

Factorial O(n!)

¿Por qué es importante?

Quizá se esté preguntando por qué como desarrollador necesita saber sobre Big O y la importancia
de aplicarlo y comprenderlo. El código mal escrito es costoso en el mundo actual de las soluciones
escalables. El código optimizado tiene muchos beneficios. Por un lado, garantizará que la
experiencia del usuario sea de máxima calidad. Un código más rápido significa una mejor
experiencia desde la perspectiva de un usuario. A nadie le gusta mirar la rueda que gira en la
pantalla mientras espera a que se carguen los elementos.

Aprender sobre y saber cómo aplicar Big-O a su código lo ayudará a crecer como desarrollador y
mejorará su código.

pág. 243
Comprobación de conocimientos: programación procedimental

pág. 244
Recursos adicionales

Los siguientes recursos serán útiles como referencias adicionales para tratar los diferentes
conceptos relacionados con los temas incluidos en este módulo.

• Estilos de programación en Python

• Diferentes tipos de algoritmos utilizados en Python

• Introducción a la notación Big-O

pág. 245
PROGRAMAMCIÓN FUNCIONAL

¿Qué es la programación funcional?

Quizá haya oído hablar de la programación funcional, que utiliza un paradigma diferente al de
otros modelos, como orientado a objetos. Es particularmente hábil para procesar grandes
cantidades de datos a gran velocidad. Este video le permitirá comenzar con lo que es la
programación funcional, luego, en nuestra lección. Explorará temas como funciones puras versión
Riker, invertir una cadena y funciones útiles de Python, como "map" y "filter".

Comencemos por explorar el papel de una función, las funciones toman alguna entrada, la
procesan y luego producen algunas salidas. Existen dos tipos de funciones: tradicionales y puras;
las funciones puras siempre harán lo mismo y devolverán los mismos resultados sin importar
cuántas veces se llamen. Existen varias diferencias entre tradicional y pura, así que vamos a
enumerarlas. Las funciones tradicionales pueden acceder a las variables del estado global y
modificarlas, pero las funciones puras no pueden. Tanto las funciones tradicionales como las
funciones puras pueden acceder a variables en el estado local. Las funciones tradicionales pueden
cambiar nuestros "dogs", mientras que las funciones puras no pueden, y, por último, las salidas de
las funciones tradicionales no dependen de las entradas.

pág. 246
Sin embargo, la salida de las funciones puras depende de la entrada, la programación funcional en
esencia es un paradigma de programación que utiliza funciones para código limpio, consistente y
mantenible. En comparación con la programación orientada a objetos, que veremos más adelante,
la programación funcional se diferencia por su diseño.

La programación funcional no cambia los datos fuera del ámbito de la función. Esto significa
simplemente que la función debe evitar modificar los datos de entrada o argumentos que se
pasan, en su lugar solo debe devolver el resultado completo de la función prevista que se llama.

Las funciones se consideran autónomas o independientes y esto ayuda a la naturaleza limpia y

elegante del código. De hecho, muchos de los lenguajes orientados a objetos fuertemente escritos
han incorporado la programación de funciones en su estructura, con el fin de apoyar la
programación funcional. El propio lenguaje tiene que permitir pasar la función como argumento y
también devolver una función a su llamador.

pág. 247
En Python, las funciones son lo que se conoce como ciudadanos de primera clase, lo que
básicamente significa que tienen el mismo nivel de cadenas y números, se pueden asignar a una
variable, pasar como argumento o devolver a su llamador.

Veamos algunos ejemplos de funciones disponibles en Python, tomemos por ejemplo la función
"sorted". La función "sorted" acepta una lista de elementos y y luego devuelve esa lista ordenada.
Puede utilizar la función de ordenación para poner en una lista los elementos en orden alfabético.

pág. 248
Pasando una lista de cafés a la función "sorted", se obtiene una la lista ordenada alfabéticamente.
Lo bueno de la programación funcional es que la lógica que hay detrás de ciertas tareas ya se
encuentra integrada, las funciones son reutilizables y de ese modo, se ahorra mucho tiempo de
desarrollo. Pero ¿sabía que también puede crear sus propias funciones específicas para sus
requisitos? Veamos un ejemplo sencillo, imagine que quiere deletrear los nombres de los cafés al
revés.

El ejemplo no es algo útil, pero es una buena muestra de funcionalidad. Puede crear su propia
función simple "reverse" para hacer esto, definir la función (llamémosla "reverse") y asignarle la
variable str. Ahora devuelve el valor de str con una función "slice", obtendrá más información
sobre la función "slice" más adelante en la lección, luego un signo de variable. Para obtener los
resultados de la función "map", la función "map" acepta como primer argumento, la función
"reverse" y los cafés que se pueden ingresar. Luego manejará automáticamente las iteraciones
para cada café y aplicará la función "reverse".

pág. 249
En este video, ha aprendido qué es la programación funcional y vio ejemplos de funciones
integradas en Python.

pág. 250
Funciones puras

Un buen codificador intentará mantener limpio el código, facilitar la depuración, y asegurar que
sea extensible. Lo bueno es que las funciones puras pueden ayudarlo a hacer todo eso. En este
video, aprenderá qué son las funciones puras y cómo puede utilizarlas en programación funcional.
Es importante entender que existe una clara diferencia entre funciones tradicionales y puras. Una
función pura es una función que no cambia o tiene algún efecto en una variable, datos, lista o
conjuntos más allá de su propio alcance. Por ejemplo, si tiene una lista con el ámbito global, una
función pura no puede agregar algo a esa lista o alterarla de cualquier manera. Veamos una
función de ejemplo y determinemos si es una función pura o no. Este código incluye una lista en
la escala global y una función denominada add_to a un solo parámetro denominado elemento. El
valor del elemento luego se establece en 4. La salida es 1, 2, 3, 4. ¿Qué cree usted? ¿Es esta una
función pura? No, no es una función pura ya que cambia la lista global al agregar el elemento que
se pasa como argumento. Para cambiarla a una función pura, hay que pensar en cómo extender
la función para aceptar una lista como argumento, agregar el elemento a la lista sin modificar la
lista original, y cómo devolver una lista nueva con el elemento recién agregado. La solución es
crear una lista nueva y copiar o clonar los datos de la lista original. Volvamos a ver el código para
hacer algunos cambios. Esta vez, realice una copia de la lista original, el nuevo elemento se agrega
a la lista nueva, entonces la lista nueva se devuelve al "caller".

Ahora que conoce más sobre funciones puras, repasemos algunos beneficios de estas funciones.
Primero, con funciones puras, siempre sabe cuál será el resultado. Las funciones puras son
fragmentos consistentes de código que hacen exactamente lo que están destinados a hacer. En

pág. 251
tercer lugar, las funciones puras incluyen la capacidad de cobrar ya que sabe que el rendimiento
siempre va a ser el mismo. Por último, las funciones puras se adaptan bien a un programa de varios
hilos. En programas con varios hilos, más de un proceso se puede ejecutar simultáneamente, lo
que crea muchos hilos de datos. Las funciones puras ayudan a evitar cambios en el ámbito global
asegurando que los datos se mantengan confiables. Ahora creo que es tiempo de ofrecerle una
demostración paso a paso en VS Code de cómo convertir una función normal en una función pura.
Las funciones puras son especialmente útiles porque son más fáciles de leer, mejores para
depurar, y más consistentes. Ahora le voy a mostrar un ejemplo sencillo de cómo crear una función
pura. Empezaré por crear una función que no se comporta como una función pura, y luego la
retocaré hasta que sea una función pura. Primero, creo una lista denominada my_list, y dentro
agrego tres números, 1, 2 y 3. Luego agrego una función simple denominada add_to_list, que toma
una única variable denominada elemento. Esta función devolverá my_list y anexará el nuevo
elemento que se pasa. Por debajo de eso, llamo a la función add_to_list y le asigno el valor de 4 al
elemento variable. Por último, agrego una sentencia "print" de my_list para que pueda enfocarme
en la salida de la consola. Hago clic en el botón "Run" (Ejecutar) y se imprimen los números 1, 2, 3
y 4. Esto significa que my_list ahora contiene el número 4 insertado también porque la función lo
anexó a la lista existente. ¿Qué cree usted? ¿Es esta una función pura? No, no lo es. Porque los
datos han sido manipulados en el ámbito global desde dentro del alcance de la función.
Intentemos convertirla en una función pura. Lo primero que modificaré es cómo se llama a la
función. Quiero pasar un nuevo argumento. Escribo new_list es igual a add_to_list. Me quedo con
el valor de 4, y también imprimiré la lista nueva a continuación de las primeras sentencias "print"
para comparar las salidas. Ahora hagamos algunas modificaciones a la función misma. Agrego un
simple "append" a my_list, que va a tomar la variable de elemento. Escribo my_list.append y un
elemento entre paréntesis. Luego quiero volver a la lista. Escribo return my_list. Luego hago clic
en "Run" (Ejecutar), y las salidas y la consola indican que tanto my_list como new_list incluyen los
valores de 1 a 4. Está claro que la función todavía no es una función pura. ¿Por qué? Porque,
aunque devuelve una nueva variable, todavía tiene una referencia a la variable my_list. Vamos a
probar algo más para convertirla en una función pura. Esta vez, voy a aceptar un parámetro
denominado lst para el elemento variable. Escribo lst coma delante del elemento entre paréntesis.

pág. 252
También cambié la sentencia "append" a elemento lst.append, y también cambio la acción de
devolución para devolver lst. Finalmente, cambio la acción principal pasando my_list coma dentro
de los paréntesis antes del valor de 4. Vamos a ejecutarlo. Una vez más, ambas listas contienen
los valores de 1 a 4. La razón es que la función sigue utilizando la lista como un argumento y se
sigue actualizando desde la función. En última instancia, con el fin de crear una función pura, el
problema que tengo que resolver es cómo crear una new_list, y luego necesito resolver cómo
obtener todos los valores de la lista que se está pasando y luego devuelve la new_list a la acción
de llamada. Vamos a darle otra oportunidad. Esta vez creo un new_list mediante una copia. En la
función, escribo el nombre de new_list, nl es igual a lst.copy y a un conjunto de paréntesis. Ahora,
en lugar de poner los valores pasados en el lst, lo pondré en la copia. Escribo nl.append, y luego
también cambio la acción de devolución para devolver lst. Borro la pantalla de la consola para
poder centrarme en la salida y hacer clic en "Run" (Ejecutar), y finalmente, obtengo dos resultados
diferentes. My_list se imprime con los valores 1, 2 y 3. Pero la segunda sentencia "print" para
new_list incluye los valores de 1 a 4.

Esta función es ahora una función pura porque agrega valor a una lista, pero no manipula la lista
original fuera de la función. En esta demostración, ha aprendido qué es una función pura y qué
necesita hacer para cambiar una función que afecta a una lista en el ámbito global a una función
pura que no interfiere con la lista original. Es probable que utilice funciones puras regularmente
en su carrera programática porque las funciones puras mantendrán su código más limpio, más
fácil de depurar y fácil de extender.

pág. 253
Recursión

En programación, la recursión se utiliza para resolver problemas que se pueden desglosar en

problemas más pequeños y repetitivos. Es especialmente útil para trabajar en situaciones que se
pueden resolver de diferentes maneras y demasiado complejas para un enfoque iterativo. Un
buen ejemplo sería buscar en un sistema de archivos. ¿Qué es la recursión? La recursión es
esencialmente una función que se llama a sí misma.

La recursión crea un patrón que se repite una y otra vez. ¿Qué significa eso desde una perspectiva
de codificación? En este ejemplo, una función acepta un único argumento y dentro de la función,
tiene cierta lógica para abordar el problema que está intentando resolver. La parte clave es el
retorno.

pág. 254
En el código, la sentencia "return" devuelve la misma función. La recursión es bastante similar a
un bucle "for". Iterará, o en el caso de una función recursiva, se llamará a sí misma varias veces.
Pero una advertencia al crear una función recursiva, es que siempre se deben considerar los
resultados. De no hacerlo, girará en un bucle infinito y consumirá toda la memoria hasta que el
programa finalmente se bloquea o se cierra. Comparemos cómo utilizar un bucle y una solución
recursiva para encontrar el factorial de un número que se puede resolver. Comencemos con la
solución de bucle. La función de bucle acepta un único entero denominado "n" como un
argumento y primero comprueba si el número es menor que 0. Si lo es, devuelve 0, ya que no se
puede tener un número factorial negativo. La condición "else" establece el factorial en 1 y luego
recorre el rango del argumento, que será 5 en este caso. El bucle calculará 1 por 2 por 3 por 4 por
5, que dará como respuesta 120, el factorial de 5.

Ahora, veamos la solución recursiva para el mismo problema. La función recursiva es más sencilla
y compacta. La razón principal es que ya no necesita el bucle "for" para realizar la iteración del
argumento. La primera línea de la función verifica que el número es 1 y devuelve 1 si es verdadero.
La condición "else" multiplica el argumento "n" llamando a la función recursiva "find_factorial" y
pasándole "n" menos 1. La recursión puede ser difícil de comprender.

pág. 255
A modo de explicación, demostremos exactamente lo que sucede cuando la función se llama a sí
misma. La función se llama una y otra vez y la parte que cambia es el valor que se pasa a la función
cada vez. El argumento de "n", o 5 en este caso, se reduce en 1 cada vez hasta que finalmente es
1. Esto impide que la función se llame de nuevo y sale del proceso recursivo. ¿Cómo obtuvo
exactamente este código los resultados de 120? Esto lo proporciona la sentencia "return".

Mantiene una referencia al valor incrementado, y esta es la devolución final luego de que se haya
completado. Es hora de revisar las ventajas y desventajas de la recursión.

pág. 256
Primero, las ventajas son que el código recursivo puede hacer que su código sea más ordenado y
menos voluminoso. Las tareas complejas se pueden desglosar en subproblemas más fáciles de
leer. La generación de secuencias puede ser más fácil de entender que los bucles anidados, pero
existen desventajas.

Puede resultar más difícil seguir la lógica del código recursivo. En términos de memoria, son caros
y a veces ineficientes. También puede ser difícil depurar y recorrer el código. Ahora debería ser

pág. 257
capaz de explicar qué es la recursión y cómo se puede utilizar para solucionar problemas. Creo
que se beneficiaría del uso de la recursión en su código en el futuro.

pág. 258
Ejemplo de recursión: Torre de Hanoi

Introducción

La Torre de Hanoi es un rompecabezas popular en matemáticas y programación, y es ampliamente

utilizado como una buena manera de demostrar la recursión. Existe una leyenda sobre un antiguo
templo hindú que contiene una sala grande con tres postes rodeados de 64 discos dorados. El
rompecabezas se presentó a un joven sacerdote al que se le dijo que moviera todos los discos de
un poste a otro sin infringir un conjunto de reglas dadas. Según las estimaciones, si el sacerdote
siguiera las reglas y moviera un disco por segundo, el rompecabezas se resolvería en 264 - 1
segundo. Eso es unos 585 mil millones de años. Para entonces, el templo ya no existiría. Inspirado
por esta leyenda, el matemático francés Edouard Lucas inventó el rompecabezas de la Torre de
Hanoi hace más de cien años.

Objetivo y reglas del rompecabezas

El objetivo es mover n número de discos de una torre a otra siguiendo un conjunto de reglas. Estas
reglas son las siguientes:

• Solo se puede mover un disco por vez

• Sólo se puede mover el disco superior de cualquiera de las torres

• Los discos más grandes no se pueden colocar sobre los discos más pequeños

pág. 259
Arriba se ofrece una imagen de las fases inicial y final del rompecabezas.

En el escenario óptimo de resolución del rompecabezas, el total de movimientos será de 2 n - 1,

donde n es el número de discos que hay que mover.

Ahora examinemos cómo puede escribir el código en Python mediante los principios de recursión
que ha aprendido.

Comprender los bloqueos de código

Empiece con tres torres o postes, destino de origen y ayudante. En la primera sección del código,
cubrirá la condición base de recursión. Las condiciones base sirven principalmente para completar
la ejecución y garantizar que la recursión no se ejecute en un bucle infinito.

La segunda sección de código se ocupa de la llamada real a la función de recursión dentro de sí

misma.

La tercera sección consiste en el código del controlador para la llamada inicial, y consta de los
nombres reales de las torres que se pasan como argumentos a la función, junto con el número de

pág. 260
discos. El código de controlador es un término genérico que se utiliza para indicar la sección de
código que da la llamada real a la función o clase.

Explicación

Si puede imaginar los discos en cuestión como se muestran en la imagen, puede comprender cómo
el código distribuye correctamente los tres discos de la torre A a la C, siguiendo las reglas
esperadas.

Observe cómo el disco variable toma inicialmente el número de discos como la entrada y luego se
lee o se entiende como el número de discos en cuestión dentro del código.

pág. 261
En el bloque de código, la primera sección es la condición base que se aplica al utilizar el disco 1.
Una vez que se ejecutó, vuelve al resto del flujo de ejecución fuera de la condición "if".

Los discos restantes se mueven pasando los valores de origen a ayudante con el destino como
ayudante. El disco restante se mueve de origen a destino. Los discos n-1 restantes del ayudante
se mueven del ayudante al destino con origen como ayudante.

En la última sección, el código del controlador toma la entrada del número de discos que quiero
mover. De acuerdo con eso, paso los valores de A, B y C como los nombres de las torres y doy la
llamada a la función.

Notará que llevó 23 - 1 = 7 pasos para completar la transferencia, lo que cumple mis expectativas.

La Torre de Hanoi y la recursión, en general, pueden ser confusas, incluso para un ávido
programador de Python. Por eso, la mejor manera de entender la recursión es mediante la
inserción de los valores y la ejecución de un código seco utilizando un lápiz y papel para ver cómo
cambian los valores y qué función se llama en el código en qué momento.

pág. 262
Invertir una cadena en Python

Una de las formas básicas de probar las habilidades de resolución de problemas del desarrollador
de Python es preguntándoles cómo invertirían una cadena, saber cómo hacerlo es muy útil en el
entorno de producción. Algunos lenguajes de programación tienen una función integrada para
invertir una cadena, pero Python no tiene esa función. Afortunadamente, gracias a la flexibilidad
del lenguaje, existen varias formas de hacerlo. En este video, mostraré dos formas de invertir una
cadena en Python. En primer lugar, voy a demostrar cómo hacerlo con una función de corte. Para
comenzar, creo un archivo denominado "string_reversal.py". El formato o la sintaxis de una
función de corte es que comienza siempre con el nombre de una cadena. Abro corchete, el
parámetro "start" (inicio) :, el parámetro "stop" (parar), otros :, y luego el parámetro "step" (de
paso) seguido por un corchete de cierre, agrego un símbolo "hash" (numeral) delante de esta línea
para indicar que se trata de una nota. Esto se denomina sintaxis de corte ampliada. Los parámetros
"inicio" y "parar" son los índices entre los que la función manipula la cadena. El parámetro de paso
representa los saltos. La función hace "Walter" vs una cadena dada. Primero definiré una cadena,
luego manipularé la cadena con la función de corte y finalmente imprimiré la cadena. Llamaré a la
cadena de prueba y asignaré la palabra "reversal" como su valor escribiendo prueba, signo igual y
la palabra "reversal" entre comillas dobles. Para manipular la cadena, creo una cadena nueva
denominada "prueba nueva". Ahora firmo un valor para una prueba nueva con la función de corte.
Escribo una prueba de signo igual y un corchete abierto. Para indicarle a Python que utilice toda
la cadena, dejo el valor de los parámetros "inicio" y "de parada" vacíos. Simplemente escribo dos
puntos y luego agrego el valor del parámetro de paso como el número menos uno, seguido de un
corchete cerrado. El valor negativo del parámetro de paso indica que la cadena se debe atravesar
desde la posición derecha de un índice a la vez. En lugar del método convencional de comenzar
por la izquierda. Finalmente, imprimo la cadena manipulada para probar si funciona. Escribo
imprimir entre paréntesis, agrego el nombre de la cadena, nueva prueba, hago clic en "Run"
(Ejecutar) Genial, la cadena se invirtió con éxito en la terminal. En resumen, toda la cadena se
atraviesa de derecha a izquierda, una posición del índice cada vez. Este nuevo objeto cortado se

pág. 263
copia en otra cadena que luego se reorganiza e imprime. Se debe tener en cuenta que puede
utilizar la función de corte para manipular la misma variable.

Solo utilicé una segunda variable en este ejemplo para la claridad. La función de corte es la forma
más sencilla de invertir una cadena. Ahora voy a demostrar otra forma en la que puede utilizar la
función de corte para invertir una cadena, esta vez mediante la recursión. Comienzo por crear un
nuevo archivo y guardándolo como inversión de cadena 2.pi. A continuación, defino una función
y le paso una variable de cadena denominada "str". Escribo sordo y el nombre de la función,
cadena, invertir, y "str" entre paréntesis seguido de dos puntos. Esta función actuará como una
sentencia condicional "if". Escribo "if len", abro paréntesis,"str", cierro paréntesis, dos Signos
iguales, el número cero seguido de dos puntos. En la siguiente línea, devolveré el valor de "str".
Ahora vamos a agregar la sentencia "else". La sentencia "else" será recursiva llamamos a la función
de corte, pero con una cadena modificada cada vez. En la siguiente línea, agrego "else" y dos
puntos. Luego en la siguiente línea, escribo "return string reverse str". Pero antes de cerrar el
paréntesis, agrego una función de corte escribiendo corchete, número uno y dos puntos seguidos
por el corchete de cierre. Esta vez la cadena se recorre desde el principio, y se salta el primer
caracter en cada bucle, y este primer caracter que se saltó, se anexa a la cadena restante. Ahora
agrego un signo más, "str" y el valor cero entre corchetes. Fuera de la función le doy a "str" el valor
de la inversión, luego creo una segunda variable que almacenará el valor de la cadena de retorno.

pág. 264
Llamaré a esta variable "reverse" y le asignaré el valor de la función. Por último, agrego una
sentencia "print" para la variable "reverse". Ejecutemos el código ahora. Éxito.

La cadena se muestra en orden inverso en la terminal, básicamente la función se llama a sí misma

pasando una cadena diferente en cada recursión y anexando el elemento que se ha mantenido
justo después de ella. En este video, aprendió dos métodos diferentes para invertir una cadena en
Python, el primero, usando solo una función de corte y el segundo, utilizando una función de corte
con recursión de registros.

pág. 265
Mapa y filtro
Digamos que quiero generar una lista mediante una lista existente. El proceso general implicaría
la solicitud de alguna operación para cada elemento de la lista existente y utilizar esas salidas para
generar la nueva lista. Existen muchas maneras de hacerlo en Python. En este video, aprenderá a
procesar una lista con las funciones "map" y "filter". Mi archivo contiene una lista denominada
"menu" (menú), y contiene una lista de varios "coffees" (cafés). Quiero filtrar esta lista para ver un
café específico. Digamos, quiero imprimir todos los cafés que comienzan con la letra C. Lo haré al
crear una función a través de la que pasará la lista para compararla con la letra C. Luego
demostraré cómo obtener el resultado. Primero como "map" y luego como "filter". Antes de
empezar, voy a hablar sobre el formato de una función "map", pero tenga en cuenta, la función
"filter" sigue el mismo formato. Para crear un "map", escribo "map", y luego necesito definir sus
argumentos. La función "map" acepta dos argumentos. El primer argumento es una función real.
En este caso, será la función que voy a utilizar para hacer coincidir los valores en función de una
condición. El segundo argumento son los artículos que se pasarán por esa función. En este caso,
los cafés de mi lista de menú. Ahora, vamos a crear la función con la condición. Presiono "Intro"
dos veces para bajar la función "map". Escribí "def" y el nombre de la función, que es "find coffee"
(encontrar café). Luego agrego un solo parámetro, café entre paréntesis y dos puntos luego del
paréntesis de cierre. El perímetro del café que agregué será el café de mi lista. Ahora necesito
verificar si el primer caracter de los elementos en la lista coincide con la letra C. Para ello, voy a
crear una sentencia "if" al escribir "if coffee" y pasar cero para establecer la acción en la primera
letra de la variable café. Luego escribo el signo igual dos veces, seguido por la letra C y dos puntos.
Presiono "Enter" y en la siguiente línea escribo "return coffee" (devolver café) si esta afirmación
es verdadera. Para utilizar la función "map", voy a asignarlo a una variable denominada "map
coffee". Ingreso un signo igual en el mapa. Ahora puedo pasar los argumentos para la función
"map". Recuerde, el primer argumento es la función en sí. Ingreso el nombre de la función "find
coffee" (encontrar café). Es importante tener en cuenta que no estoy llamando a la función. Solo
la paso como un argumento. Agrego una coma luego de "find coffee" (encontrar café) y luego el
segundo argumento, el artículo, en este caso "menú". Por último, quería imprimir el valor de "map
coffee" para que se pueda centrar en los resultados en la terminal. Hago clic en "Run" (Ejecutar) y

pág. 266
en la terminal recibo un objeto mapa como salida. El siguiente paso es iterar a través del objeto
mapa. Escribo "for X" en el café del mapa imprimir el valor de X. Hago clic en "Ejecutar" de nuevo,
y ahora obtengo la salida como mapa.

En la terminal, aparece una lista con muchos valores que dicen ninguno, excepto "capuchino" y
"cortado", y eso es porque "capuchino" y "cortado" son las dos coincidencias para la letra C en la
función. Lo mejor de la función "map" es que no debo crear un bucle para pasar por la lista. La
función "map" toma la función como un argumento y pasa los valores de la lista de menú en la
función uno por uno para que maneje la iteración por mí, lo que lo hace bastante útil. A
continuación, voy a demostrar cómo obtener la salida con la función de filter. Para comenzar,
comento la sección del código relacionado con la función "map" y limpio mi terminal. La función
"filter" funciona igual que la función "map". Declaro una variable denominada "café de filtro" y le
asigno la función "filter". Nuevamente, agrego los dos argumentos, a saber, la función "café"
hallada y "menú". Luego imprimo la variable "café de filtro". Hago clic en "Ejecutar" y recibo un
objeto de filtro como resultado. Ahora voy a iterar a través del objeto de filtro, como lo hice con
el objeto del mapa. Escribo para X en café con filtro, imprimir el valor de X. Borraré la terminal
ahora y haré clic en "Ejecutar". Esta vez solo se devuelven "capuchino" y "cortado".

pág. 267
¿Por qué es eso? Permítame explicarle la diferencia entre una función "map" y "filter". "Map" se
lleva todos los objetos en la lista y le permite aplicar una función a ello.

Un filtro también le permite tomar todos los objetos de la lista y pasar una función, pero crea una
nueva lista y solo devuelve valores donde la función evaluada devuelve verdadero. Por eso no
existe ningún valor que se muestre en la salida para la función de filtro. Ya sabe cómo funcionan
"map" y "filter" en Python, y debería ser capaz de explicar también la diferencia entre las dos
funciones.

pág. 268
Comprensiones

La comprensión de listas en Python es una forma de crear una nueva secuencia a partir de una
secuencia ya existente.

Existen cuatro tipos principales de comprensiones en Python:

• Comprensión de la lista

• Comprensión del diccionario

• Establecer la comprensión

• Comprensión del generador

Ahora explorará cada uno de estos temas para aprender a usarlos.

Comprensión de la lista

La sintaxis para la comprensión de listas es:

[ <expression> for x in <sequence> if <condition>]

Lo mismo se puede ilustrar con el ejemplo siguiente.

pág. 269
El ejemplo dado proporciona diferentes formas en las que las comprensiones de lista se pueden
utilizar para actualizar la lista o generar una nueva lista. Las comprensiones proporcionan una
forma corta y elegante de actualizar secuencias. Como puede resultar evidente, el mismo código
se puede escribir al utilizar el bucle "for" convencional y las condiciones "if else".

Por ejemplo, en el caso del ejemplo 1:

pág. 270
La comprensión de listas puede ser una opción mejor una vez que haya comprendido el concepto.
Se debe tomar en cuenta cómo se puede ampliar el mismo concepto para incluir varias
condiciones si es necesario.

La comprensión de listas es la más utilizada, pero hay otros tipos que también pueden hacer que
el código sea pragmático y sencillo. Su estructura y sintaxis son muy similares a las de las
comprensiones de listas, salvo por los tipos de datos que se utilizan.

Comprensión del diccionario

La sintaxis para la comprensión del diccionario es:

dict = { key:value for key, value in <sequence> if <condition> }

La comprensión del diccionario toma una o dos listas como entrada y crea un diccionario fuera de
él. Ahora demostraré cómo se puede hacer esto usando solo una lista y usando dos listas.

Nótese como en el caso de utilizar dos listas, el formato que sigue es:

• new_dict ={key:value for (key, value) in zip(list1, list2)}

pág. 271
Aquí he utilizado la función zip que combina las dos listas. Cuando las dos listas son de longitud
diferente, la longitud de la lista más corta es la longitud del diccionario.

Establecer la comprensión

La comprensión del conjunto se ocupa del tipo de datos del conjunto y es muy similar a la
comprensión de la lista. La única diferencia clave es el uso de llaves para los conjuntos en lugar de
corchetes como en las listas. Por ejemplo:

Puede ver que el formato del código es similar al que utilicé en las comprensiones de listas. Para
mostrar versatilidad, utilicé las palabras clave "not in" (no en) para comprobar los valores de la
lista. La salida son los valores de los rangos 10 y 20 que no están presentes en esa lista.

Comprensión del generador

Las comprensiones de generadores también son muy similares a las listas, solo que utilizan
corchetes curvos en lugar de cuadrados. También son más eficientes en memoria que las
comprensiones de listas. Por ejemplo:

pág. 272
En el código anterior, creé un objeto generador del generador de clases en lugar de una lista. No
se puede acceder directamente a los elementos en este objeto iterador y se necesita la ayuda de
un bucle "for " y "such as". Itero sobre estos elementos y los imprimo.

En breve veremos la diferencia entre la función "map()" y las comprensiones de listas. Supongamos
que sabemos que hay alguna función denominada "square()" que existe como se muestra a
continuación:

He aquí la diferencia entre la función "map()" y las comprensiones de listas:

newdata = map(square, data)

newdata = [x + 3 for x in data]

Observe cómo tanto las funciones "map()" como la comprensión de listas hacen efectivamente el
mismo trabajo de modificar secuencias de iteradores como la lista del ejemplo anterior.

Las comprensiones de lista han sido un desarrollo relativamente reciente, pero no necesariamente
significa que sean más eficientes. Las comprensiones han ganado popularidad principalmente por
proporcionar una legibilidad de código más limpia y facilidad de uso. También ofrecen algunas
ventajas agregadas, como el filtrado mediante condiciones "if else".

pág. 273
Las comprensiones de lista también proporcionan la devolución directa de una lista en
comparación con la función "map()" que devuelve un objeto "map". Es principalmente la claridad
lo que ha hecho populares a las comprensiones de listas, pero las funciones "map()" siguen siendo
posiblemente una mejor opción cuando se trata del uso de secuencias más grandes.

pág. 274
Asignación de valores clave a estructuras de datos de diccionario

pág. 275
Tareas de programación: Asignación de valores clave a estructuras de datos de diccionario

Introducción

Hasta ahora ha aprendido que Python tiene diferentes técnicas para modificar una secuencia dada
de iteradores como listas o diccionarios usando comprensiones, la función map(), y así
sucesivamente. Ahora utilizará lo que ha aprendido. Digamos que tiene una lista de datos de
empleados para la empresa Little Lemon. Desea crear cuentas de inicio de sesión para los
empleados y creará nombres de usuario para estos empleados en el primer ejemplo.

Usted también quiere actualizar la lista de estos empleados en el calendario y quiere acceder
fácilmente a sus iniciales e ID de empleado, ya que son únicos. Para conseguirlo, en el segundo
ejemplo, creará un diccionario con la información requerida.

Instrucciones

Paso 1: Abra el archivo comprehensions.py

Paso 2: Implemente la función to_mod_list() usando la función map() para aplicar mod() a todos
los elementos dentro de employee_list. Asigne el resultado de la misma a una nueva variable
denominada map_emp. Convierta map_emp en una lista y devuélvala.

La función mod() devuelve, por ejemplo, un valor de cadena como "Lisa_Cold Storage" a partir del
diccionario que se le ha pasado.

Paso 3: En este punto, usted debe tener una lista de los valores tales como: "Lisa_Cold Storage"
mencionada anteriormente. Pero eso no sirve para un nombre de usuario con los espacios en
blanco presentes en él. Implemente el método generate_username() utilizando la comprensión
de la lista y el replace() sobre mod_list para reemplazar todos los espacios (" ") por guiones bajos
("_"). Devuelva la lista resultante.

Paso 4: Queremos crear un diccionario que almacene las iniciales y los DNI de los empleados.
Implemente map_id_to_inicial() utilizando la comprensión del diccionario sobre la lista de
empleados para crear un diccionario en el que cada clave sea la primera letra del nombre de un
empleado y el valor sea el ID del empleado.

pág. 276
Paso 5: Ejecute la secuencia de comandos abriendo el terminal y ejecutando el comando

python3 comprehensions.py

# Input data: List of dictionaries

employee_list = [
{"id": 12345, "name": "John", "department": "Kitchen"},
{"id": 12456, "name": "Paul", "department": "House Floor"},
{"id": 12478, "name": "Sarah", "department": "Management"},
{"id": 12434, "name": "Lisa", "department": "Cold Storage"},
{"id": 12483, "name": "Ryan", "department": "Inventory Mgmt"},
{"id": 12419, "name": "Gill", "department": "Cashier"}
]

# Function to be passed to the map() function. Do not change this.

def mod(employee_list):
temp = employee_list['name'] + "_" + employee_list["department"]
return temp

def to_mod_list(employee_list):
""" Modifies the employee list of dictionaries into list of employee-department strings

[IMPLEMENT ME]
1. Use the map() method to apply mod() to all elements in employee_list

Args:
employee_list: list of employee objects

Returns:
list - A list of strings consisting of name + department.
"""
### WRITE SOLUTION CODE HERE

raise NotImplementedError()

def generate_usernames(mod_list):
""" Generates a list of usernames

[IMPLEMENT ME]
1. Use list comprehension and the replace() function to replace space
characters with underscores

List comprehension looks like:

list = [ function() for <item> in <list> ]

The format for the replace() function is:

pág. 277
 test_str.replace(“a”, “z”) # replaces every “a” in test_str with “z”

Args:
mod_list: list of employee-department strings

Returns:
list - A list of usernames consisting of name + department delimited by underscores.
"""
### WRITE SOLUTION CODE HERE

raise NotImplementedError()

def map_id_to_initial(employee_list):
""" Maps employee id to first initial

[IMPLEMENT ME]
1. Use dictionary comprehension to map each employee's id (value) to the first letter in their name (key)

Dictionary comprehension looks like:

dict = { key : value for <item> in <list> }

Args:
employee_list: list of employee objects

Returns:
dict - A dictionary mapping an employee's id (value) to their first initial (key).
"""
### WRITE SOLUTION CODE HERE

raise NotImplementedError()

def main():
mod_emp_list = to_mod_list(employee_list)
print("Modified employee list: " + str(mod_emp_list) + "\n")

print(f"List of usernames: {generate_usernames(mod_emp_list)}\n")

print(f"Initials and ids: {map_id_to_initial(employee_list)}")

if __name__ == "__main__":
main()

pág. 278
# Input data: List of dictionaries
employee_list = [
{"id": 12345, "name": "John", "department": "Kitchen"},
{"id": 12456, "name": "Paul", "department": "House Floor"},
{"id": 12478, "name": "Sarah", "department": "Management"},
{"id": 12434, "name": "Lisa", "department": "Cold Storage"},
{"id": 12483, "name": "Ryan", "department": "Inventory Mgmt"},
{"id": 12419, "name": "Gill", "department": "Cashier"}
]

# Function to be passed to the map() function. Do not change this.

def mod(employee_list):
temp = employee_list['name'] + "_" + employee_list["department"]
return temp

def to_mod_list(employee_list):
### WRITE SOLUTION CODE HERE
# Use map() to apply mod() to each employee in employee_list
map_emp = map(mod, employee_list)
# Convert the map object to a list and return it
return list(map_emp)
raise NotImplementedError()

def generate_usernames(mod_list):
### WRITE SOLUTION CODE HERE
# Use list comprehension to replace spaces with underscores in each string
return [name.replace(" ", "_") for name in mod_list]
raise NotImplementedError()

def map_id_to_initial(employee_list):
### WRITE SOLUTION CODE HERE
# Use dictionary comprehension to map first initial to employee id
return {employee['name'][0]: employee['id'] for employee in employee_list}
raise NotImplementedError()

def main():
mod_emp_list = to_mod_list(employee_list)
print("Modified employee list: " + str(mod_emp_list) + "\n")

print(f"List of usernames: {generate_usernames(mod_emp_list)}\n")

print(f"Initials and ids: {map_id_to_initial(employee_list)}")

if __name__ == "__main__":
main()

pág. 279
Explicación de las implementaciones:
1. to_mod_list(employee_list):
o Utilizamos la función map() para aplicar la función mod() a cada elemento
de employee_list.
o Convertimos el resultado de map() en una lista y la devolvemos.
2. generate_usernames(mod_list):
o Utilizamos una comprensión de lista para iterar sobre mod_list y reemplazar los
espacios en blanco con guiones bajos (_) usando el método replace().
3. map_id_to_initial(employee_list):
o Utilizamos una comprensión de diccionario para crear un diccionario donde la clave
es la primera letra del nombre del empleado y el valor es el ID del empleado.

pág. 280
Comprobación de conocimientos: programación funcional

pág. 281
Recursos adicionales
Los siguientes recursos serán útiles como referencias adicionales para tratar los diferentes
conceptos relacionados con los temas incluidos en este módulo.
• Mapa Python, reducción y comprensión de listas
• Recursión en Python
• Programación funcional en Python

pág. 282
PROGRAMACIÓN ORIENTADA A OBJETOS
Introducción a la Programación Orientada a Objetos
Los lenguajes de programación se basan en ciertos modelos para asegurar que el código se
comporte de manera predecible. Python sigue principalmente lo que se conoce como un
paradigma o modelo orientado a objetos. Como pronto descubrirá, la programación orientada a
objetos u OOP, se basa en gran medida en la simplicidad y la reutilización para mejorar el flujo de
trabajo. Al final de este video, estará familiarizado con el paradigma de programación orientado a
objetos. También podrá identificar los cuatro conceptos principales que definen la programación
orientada a objetos. Los paradigmas de programación son una estrategia para reducir la
complejidad del código y determinar el flujo de ejecución. Existen varios paradigmas diferentes
como declarativo, procedimental, orientado a objetos, función, lógica, dirigido por eventos,
dirigido por el flujo. Estos paradigmas no son mutuamente excluyentes. Los programas y los
lenguajes de programación pueden elegir varios paradigmas.

Por ejemplo, Python está orientado principalmente a objetos, pero también es procedimental y
funcional. En términos simples, un paradigma puede ser definido como un estilo de escritura de
un programa.

pág. 283
La OOP es uno de los paradigmas más ampliamente utilizados hoy debido a la creciente
popularidad de los lenguajes que lo utilizan, como Java, Python, C++ y más. Pero la capacidad de
la OOP para traducir problemas del mundo real en código es posiblemente el mayor factor de su
éxito.

La OOP tiene alta modularidad, que hace que el código sea más sencillo de comprender, lo hace
reutilizable, agrega capas de abstracción y permite que los bloques de código se muevan entre
proyectos. Para ayudarlo a comprender mejor la OOP, primero aclararé algunos de sus
componentes clave, que son clases, objetos y métodos. Una clase es un bloque de código lógico
que contiene atributos y comportamiento.

pág. 284
En Python, se define una clase con la palabra clave "class". Los atributos pueden ser variables y el
comportamiento pueden ser funciones dentro de él. Se pueden crear instancias a partir de estas
clases denominadas objetos. Es decir, una clase proporciona una huella para crear un objeto. En
términos prácticos, digamos que quiere grabar los atributos de los empleados en Little Lemon,
como su posición y su situación laboral. Podría crear una clase denominada "empleado" y agrupar
esos atributos de forma conveniente en un solo lugar. A continuación, hablaremos sobre los
objetos. Como se mencionó, un objeto es una instancia de una clase, y se puede crear la cantidad
de objetos que se desee. El estado de un objeto comprende sus atributos y comportamiento, y
cada uno tiene un identificador único para distinguirlo de otras instancias.

Los atributos y el comportamiento de la clase son lo que definen el estado del objeto. Por ejemplo,
puede crear el objeto "emp1" al llamar a la clase de empleado. Una vez llamada, puede definir los
atributos de posición y estado de empleo como "jefe de turno" y "tiempo completo"
respectivamente. En código, esto sería escrito como emp1=employee, seguido de ''Jefe de turno''
y FT entre paréntesis.

pág. 285
Este es un caso de instanciación o crear una instancia de una clase. Finalmente, existen métodos
que son las funciones definidas dentro de una clase que determina el comportamiento de una
instancia de objeto. Digamos que quiere que los objetos "empleado" emitan una cadena que
indique su posición.

Primero declararía su función "intro" en la clase "empleado" y luego la llamaría en un objeto para
obtener las salidas. Ahora que sabe sobre clases, objetos y métodos, exploremos los conceptos en
los que se basa la OOP.

El primero es la herencia, que es la creación de una nueva clase derivada de una existente. La
original se denomina padre o superclase, y las derivadas se denominan subclase o clase hija.

pág. 286
El siguiente concepto se denomina polimorfismo. Es una palabra que significa tener muchas
formas. En el contexto de Python, polimorfismo significa que una sola función puede actuar de
manera diferente según el objeto o las causas. Por ejemplo, el operador "plus" (más) integrado
funciona de manera diferente para diferentes tipos de datos. En el caso de tipos de datos enteros,
el operador "plus" integrado realiza operaciones de adición como 3 + 5 = 8. Por otro lado, en el
caso de tipo de datos de cadena, el operador "plus" integrado realiza una concatenación o
combina dos cadenas. Esta capacidad de modificar la funcionalidad se denomina polimorfismo.

El tercer concepto es encapsulación. En general, esto significa que Python puede vincular métodos
y variables desde acceso directo envolviéndolos dentro de una sola unidad de ámbito, como una
clase. La encapsulación ayuda a evitar modificaciones no deseadas, en efecto, reduciendo la
aparición de errores y salidas.

Finalmente, existe un concepto de abstracción. Se refiere a la capacidad de ocultar detalles de

implementación para hacer datos más seguros. Tenga en cuenta que Python no soporta la
abstracción directamente y utiliza la herencia para lograrlo.

pág. 287
Esto es algo que verá más específicamente más adelante. Existen algunos otros conceptos
importantes en OOP como sobrecarga de métodos, sobreestimación de método, constructores,
etc, que aprenderá con más detalle más adelante.

En este video, aprendió sobre los paradigmas de OOP y los cuatro conceptos que los respaldan:
herencia, polimorfismo, encapsulación, y abstracción. Nos vemos la próxima.

pág. 288
Principios de la OOP

Esta lectura le presenta los principios de OOP (Object-Oriented Programming, programación

orientada de objetos) con más detalle mediante algunos ejemplos.

El paradigma orientado a objetos fue introducido en los años 60 por Alan Kay. En aquel momento,
el paradigma no era la mejor solución informática, dada la escasa escalabilidad del software
desarrollado entonces. A medida que la complejidad del software y las aplicaciones de la vida real
mejoraron, los principios orientados a objetos se convirtieron en una mejor solución.

Anteriormente conoció los cuatro pilares principales de la programación orientada a objetos. Estos
son: encapsulación, polimorfismo, herencia y abstracción. Veamos algunos ejemplos que
demuestran cómo se traducen estos principios al utilizar Python.

Encapsulación

La idea de encapsulación es tener métodos y variables dentro de los límites de una unidad
determinada. En el caso de Python, esta unidad se denomina "clase". Y los miembros de una clase
se enlazan localmente a esa clase. Estos conceptos se comprenden mejor con el alcance, como el
alcance global (que en términos simples son los archivos con los que estoy trabajando), y el alcance
local (que se refiere al método y las variables que son "locales" a una clase). Por lo tanto, la
encapsulación ayuda a establecer estos ámbitos en cierta medida.

Por ejemplo, la empresa Little Lemon puede tener diferentes departamentos como el de
inventario, el de marketing y el de contabilidad. Y es posible que usted se tenga que ocupar de los
datos y las operaciones de cada uno de ellos por separado. Las clases y los objetos ayudan a
encapsular y a su vez a restringir las diferentes funcionalidades.

La encapsulación también se utiliza para ocultar los datos y su representación interna. El término
para referirse a ella es "ocultación de datos". Python tiene una forma de abordar este tema, pero
está mejor implementado en otros lenguajes de programación como Java y C++. Los modificadores
de acceso representados por palabras clave como "public" (público), "private" (privado) y
"protected" (protegido) se utilizan para ocultación de datos. El uso de guiones bajos simples y

pág. 289
dobles para este propósito en Python es un sustituto de esta práctica. Por ejemplo, veamos un
ejemplo de miembros protegidos en Python.

self._a es un miembro protegido al que pueden acceder la clase y sus subclases.

Los miembros privados de Python se utilizan de modo convencional con guiones bajos dobles
precedentes: __. self.__b es un miembro privado de la clase Alpha y solo se puede acceder desde
la clase Alpha.

Se debe tener en cuenta que se puede acceder a estos miembros privados y protegidos desde
fuera de la clase mediante métodos públicos o una práctica conocida como "name mangling". Esta
práctica se refiere al uso de dos guiones bajos principales y un guión bajo final, por ejemplo:

_class__identifier

"Class" es el nombre de la clase e "identifier" es el miembro de datos al que quiero acceder.

Polimorfismo

El polimorfismo se refiere a algo que puede tener muchas formas. En este caso, un objeto
determinado. Recuerde que todo en Python es inherentemente un objeto, así que cuando hablo
de polimorfismo, puede ser un operador, un método o cualquier objeto de alguna clase. Puedo
ilustrar el caso del polimorfismo utilizando funciones y operaciones integradas, por ejemplo:

pág. 290
En el ejemplo, he utilizado el mismo operador () para actuar sobre una cadena, un entero y una
lista. Puede ver que el operador () se comporta de modo diferente en los tres casos.

Veamos otro ejemplo.

La función len() puede tomar entradas variables. En el ejemplo anterior se trata de una cadena y
una lista que proporciona la salida en formato entero.

pág. 291
Herencia

La herencia en Python se tratará más adelante en el curso, pero el modelo básico para ella es el
siguiente:

A medida que la estructura de herencia se complica más, Python se adhiere a algo que se
denomina MRO (Order Resolution Method, Orden de resolución de métodos) que determina el
flujo de ejecución. El MRO es un conjunto de reglas, o un algoritmo, que Python utiliza para
implementar la monotonicidad, que se refiere al orden o a la secuencia en los que el intérprete
buscará las variables y funciones a implementar. Esto además ayuda a determinar el alcance de
los diferentes miembros de la clase dada.

Abstracción

La abstracción se puede ver como un medio para ocultar información importante, así como
información innecesaria en un bloque de código. El núcleo de la abstracción en Python es la
implementación de algo denominado clases y métodos abstractos, que se pueden implementar
mediante la herencia de algo denominado módulo abc. "abc" significa clase base abstracta.
Primero se importa y luego se utiliza como clase padre para alguna clase que se convierte en una
clase abstracta. Su implementación más sencilla se puede realizar como se muestra a
continuación.

Se tratará la abstracción con mayor detalle más adelante en el curso.

pág. 292
Clases e instancias de Python

Las clases tienen la capacidad de combinar datos y funcionalidad, que es una función muy útil a la
hora de codificar. Al final de este video, podrá explicar qué clases, instancias y objetos están en
Python. También podrá crear una clase, crear instancias para clases, y acceder a sus variables y
métodos. Es posible que también haya oído hablar de las clases en términos de atributos y
comportamientos. En general, los atributos se refieren a variables declaradas en una clase,
mientras que los comportamientos se asocian con los métodos de la clase. La creación de una
clase crea un nuevo tipo de objeto desde el que se pueden crear instancias. Algo importante a
tener en cuenta es que todo en Python es un objeto o derivado de la clase objeto. Para demostrar
cómo funciona, crearé una clase desde la que luego podré derivar objetos. En un archivo VS Code
nuevo, primero escribo palabra clave "class" (clase) seguida por el nombre "my class" (mi clase) y
dos puntos. Debo hacer un paso más para que Python no lance un error. Ese es el tipo, la palabra
clave "pass" en la siguiente línea. La palabra clave "pass" desempeña el papel de un marcador de
posición cuando no es necesario ejecutar nada. En la práctica, esto dice a Python que no haré nada
con esta clase todavía. A continuación, creemos un objeto para esta clase. Creo una variable
denominada "MyClass" y luego le asigno la clase escribiendo es igual a "my class" seguida de
paréntesis. Si ejecuto este código, la salida muestra que se ha ejecutado sin errores. Sin embargo,
solo para comprobar que funciona como se espera, agreguemos una sentencia "print" a la clase.
Eso sería impreso, seguido de la cadena "Hello" (Hola) entre paréntesis. Cuando ejecuto el código
nuevamente, la palabra "Hello" aparece en la salida. Voy a despejar la terminal antes de continuar.
Habrá notado que utilizo el mismo nombre para la clase y su objeto, pero el nombre del objeto
puede ser realmente cualquier cosa. Por ejemplo, si cambio el nombre del objeto a "myc" y ejecuto
el código una vez más, se ejecutará igual que antes. Todo lo que he escrito forma parte del proceso
de instanciar en Python, que implica tres pasos clave. Uno, definición de clase, dos, creación de
una nueva instancia, y tres, inicialización de la nueva instancia. Como todo en Python es un objeto,
tiene sentido seguir las convenciones de nombre para que las cosas sean menos confusas más
adelante. En este caso, tengo mi clase para el objeto de clase y "myc" para el objeto de instancia.
Existe un tercer tipo de objeto denominado objeto método, que puede utilizar el método de

pág. 293
columna siempre que sea necesario. Las clases realizan principalmente dos tipos de operaciones,
referencias de atributos e instanciación. Ya he escrito un ejemplo de la escalera, así que vamos a
intentar crear una referencia de atributo esta vez. Primero, creo una variable "a" para el objeto de
clase y le asigno un valor de 5. Para imprimir esta variable, primero necesito referirme a la clase.
Bajo el objeto de instancia, escribo imprimir y luego "my class.a". Cuando ejecuto el código,
devuelve cinco en la salida. Para confirmar la clase es necesaria la referencia, elimino mi clase de
la sentencia "print" y ejecuto el código de nuevo y Python arroja un error. Voy a corregir el código
y poner mi clase de nuevo. Voy a despejar la terminal antes de continuar. Ya sabe lo que ocurre si
referencia un objeto de clase, pero ¿qué ocurre si referencia un objeto instancia? Averigüémoslo
escribiendo una sentencia "print" para "myc.a" y luego ejecutándola. En la salida, obtengo 5, que
muestra que esa referencia de atributo aún funciona con los objetos de instancia. Por último,
finalicemos creando un método dentro de esta clase. Utilizaré la palabra clave "def" seguida por
"hello", un par de paréntesis y dos puntos. En la siguiente línea, escribo una sentencia "print" para
la cadena "hello world" (hola mundo). También eliminaré la primera sentencia "print" para evitar
confusiones. Para llamar a este método, agrego una nueva sentencia "print" al final del documento
para "myc.hello", que utiliza el objeto de instancia. Esto debería funcionar justo cuando llamo con
éxito a la variable a través de un objeto de instancia. Al ejecutar el código se produce un error. Los
métodos no son tan simples. Afortunadamente, puedo resolverlo al agregar la palabra clave "self"
en los paréntesis del método como se define en la clase.

pág. 294
¡Ejecutar el código de nuevo produce las palabras “Hello, world!" (¡Hola mundo!) en la salida.
También encontrará la palabra "None" (ninguno) impresa debajo, ya que no hay valor de retorno
de la función dada.

Esa es una breve demostración de clases, instancias y objetos. He creado una clase, entonces pude
crear instancias y acceder a sus variables y métodos.

pág. 295
Ejercicio: definir una clase

Objetivos de aprendizaje

Usted ha visto los principios básicos de la programación orientada a objetos y, de alguna manera,
ha demostrado cómo los diferentes principios se pueden poner en práctica con la ayuda de las
clases, los bloques de construcción de la programación orientada a objetos. Veamos ahora la
estructura de estas clases.

Aquí aprenderá a crear clases y objetos con la ayuda de ejemplos. Veamos primero los miembros
básicos de una clase. Estos pueden ser los atributos o los miembros de datos, los métodos y,
además, los comentarios que puede incluir. Estos miembros se pueden mostrar con la ayuda de
un ejemplo a continuación. Imaginemos que quiere hacer una clase de una casa, y comienza por
crear una clase para ella.

Ejemplo 1

En el código anterior, comienza con un comentario multilínea, que también se puede denominar
docstring (''comentarios adjuntos"). En la línea siguiente aparece la definición de la clase, seguida
de un par de miembros de datos o atributos: num_rooms y bathrooms. Esto va seguido de una
definición de función, que está vacía, excepto por la palabra clave pass que básicamente indica a
Python que continúe la ejecución sin arrojar un error. La última línea del bloque de código es el
comentario de una sola línea precedido por #.

El código define completamente la clase y las funciones presentes en su interior, pero en realidad
no es útil a menos que se llame o se genere una instancia. Puede hacerlo de una de las dos

pág. 296
siguientes maneras: Llamando directamente a la clase Generando una instancia de un objeto de
esa clase

Puede agregar unas líneas de código debajo de su código que llamarán a la variable num_rooms
en el objeto "casa" y en la clase "Casa" luego de que generemos un objeto "casa" a partir de la
clase "Casa":

Para hacer un seguimiento de este ejemplo, agregue unas pocas líneas más a este código y vea la
salida, esta vez después de actualizar la variable num_room llamada "on house object" a 7:

pág. 297
Lo que ha ocurrido en el código anterior es que ha creado una instancia de una clase
denominada house y luego ha modificado el atributo de esa instancia con un valor de 7. Esto
actualiza el valor del atributo de la instancia, pero no el atributo de la clase. Por lo tanto, el atributo
num_rooms de la clase permanece sin cambios como 5, pero el atributo de instancia asociado con
el objeto "casa" cambia a 7. Ahora insertaremos un fragmento de código alternativo.

Esta vez, en lugar de un atributo de instancia, modificará el atributo de clase llamándolo

directamente sobre la clase de la siguiente forma:

Verá que los cambios en un atributo de clase afectarán incluso a las instancias que creará sobre
él. Tenga en cuenta también el uso de la clave self en este ejemplo. self es una convención en
Python y puede utilizar cualquier otra palabra en su lugar, pero como práctica, es fácil de
reconocer. self aquí se pasa dentro del método cost_evaluation() ,ya que es un método de
instancia y facilita que el método apunte a cualquier instancia de la Casa cuando se llama a ese
método. Observe cómo se puede pasar cualquier número de parámetros a estos métodos de
instancia, pero el primero es siempre la referencia a la instancia de esa clase.

pág. 298
Definir una clase: solución

Código solución

class House:
'''
This is a stub for a class representing a house that can be used to create ob
jects and evaluate different metrics that we may require in constructing it.
'''
num_rooms = 5
bathrooms = 2

def cost_evaluation(self, rate):

# Functionality to calculate the costs from the area of the house
cost = rate * self.num_rooms
return cost

house = House()

print(house.num_rooms)
print(House.num_rooms)
house.num_rooms = 7
# House.num_rooms = 7
print(house.num_rooms)
print(House.num_rooms)

Salida:

pág. 299
Autorrevisión: definir una clase

pág. 300
pág. 301
Instanciar un objeto personalizado

La reutilización del código es el uso del código existente para construir software nuevo. La
reutilización es un concepto básico de programación. Al final de este video, no solo podrá crear
una clase y darle una instancia con variables y métodos, pero también descubrir cómo referenciar
las mismas variables y los métodos en instancias separadas puede producir resultados diferentes,
lo que significa que el código es reutilizable. Comenzaré por crear un nuevo archivo denominado
"recipes.py" donde también crearé una clase denominada receta. Antes de continuar,
exploraremos dos métodos especiales en Python. El primero es el método nuevo, que se encarga
de crear y devolver un nuevo objeto vacío. Para escribirlo, comienzo con la palabra clave "def",
seguido de doble subrayado nuevo. A continuación, aparece como una sugerencia, así que hago
clic en él para completar el resto. Aquí, CLS no es una palabra clave, sino más bien una convención.
Actúa como marcador de posición para pasar la clase como su primer argumento, que se utilizará
para crear el nuevo objeto vacío. El segundo método es el método "init", que es similar a lo que
se conoce como un constructor en otros lenguajes de programación. Toma los objetos creados
utilizando el nuevo método junto con otros argumentos para inicializar el nuevo objeto que se
está creando. Lo escribo con el "def" doble guión bajo "init" y luego elijo la primera sugerencia que
aparece. El método de entrada toma el nuevo objeto como su primer argumento. La palabra clave
"self" aquí es otra convención. No tiene ninguna función en sí, pero sirve como un marcador de
posición para la autorreferencia por el objeto de instancia. Eliminemos los dos métodos de
ejemplo y luego escribimos algún código que demuestre cómo utilizar el estado de el objeto a su
favor. Comencé con un método "init", que luego utilizo para inicializar algunos valores. Hago esto
por el valor "dish" (plato) y escribo "self.dish" igual a "dish". Luego hago lo mismo para los valores,
los elementos y el tiempo. Antes de continuar, quiero comprobar que los argumentos en el
inicializador coincidirán con los de mis instancias. Para hacerlo, agrego plato, elementos y tiempo
después de sí mismo. Imagine un escenario del mundo real donde el chef de un restaurante quiere
información sobre las recetas que han estado utilizando, escribamos una clase que lo ayude con
eso. Tengo las variables plato, elementos, y tiempo en el que los elementos mantendrán los
ingredientes de la receta. Ahora escribo una función para producir una cadena a partir de esta

pág. 302
información. Escribo "def contents" y luego "self" entre paréntesis. En la siguiente línea, agrego
una sentencia "print" para la cadena. el "plus self.dish plus has plus self.items plus" y "takes plus
self.time min to prepare". Aquí, utilizaremos el caracter de barra oblicua invertida para forzar una
nueva línea y continuar la cadena en la línea siguiente. Para que se imprima correctamente,
necesito convertir las referencias "self.items" y "self.time" a cadenas agregando STR al principio y
encerrando cada referencia entre paréntesis. Ahora que tengo una configuración de clase, vamos
a utilizarla para crear una instancia de pizza. La escribo como pizza es igual a receta, paréntesis de
apertura, la pizza de cadena coma, corchete de apertura, queso, coma, pan, coma, tomate,
corchete de cierre coma, y 45 para representar el tiempo seguido por el paréntesis de cierre.
También quiero un objeto "pasta". Vamos a copiar y pegar el código para el objeto "pizza" y
cambiar el nombre del objeto por "pasta", los ingredientes a "penne" y "salsa", y el tiempo de
preparación a 55. Ahora que tengo una clase y dos instancias, veamos si puedo acceder a los
atributos y métodos de instancia.

pág. 303
Escribo dos sentencias "print" para "pizza.items" y "pasta.items". Cuando ejecuto el código,
encuentro que a pesar de pasar la misma función y elementos variables, las dos instancias
producen contenidos diferentes.

A continuación, intentemos imprimir el contenido del método de instancia sobre pizza. Antes de
avanzar, despejemos la terminal para que podamos ver con mayor claridad cuál será la salida.
Escribo otra sentencia "print" para "pizza.contents" y paréntesis vacíos. Ejecuto el código una vez
más y la salida utiliza el método de clase para imprimir una línea que indica que la pizza tiene
queso, tomate y pan, y tarda 45 minutos en prepararse.

pág. 304
Esa es una demostración de crear una clase y darle una instancia con variables y métodos que
luego hacen referencia a las mismas variables y métodos en instancias separadas para obtener
resultados diferentes.

pág. 305
Ejercicio: instanciar un objeto personalizado

Esta es su primera experiencia al crear clases y objetos en Python. Seguirá un proceso secuencial
donde creará una clase, definirá su estado mediante variables y funciones para definir sus
atributos y comportamiento, y luego creará instancias mediante alguna variable. Finalmente,
utilizará los miembros de la clase para obtener el resultado deseado.

Siga los pasos para construir y ejecutar su programa en el entorno proporcionado al final de la
lectura.

Paso 1

1.1 Defina una clase denominada MyFirstClass (Mi primera clase).

1.2 Agregue una sentencia "print" dentro de ella como Who wrote this? (¿Quién escribió esto?) .

Paso 2

Cree una variable de cadena denominada index y inicialícela con una cadena “Author-Book"
(Autor-Libro).

Paso 3

3.1 Defina una función denominada hand_list () con la ayuda de la palabra clave def.

3.2 Pase el parámetro self. Y luego pásele dos parámetros, philosopher (filósofo) y book (libro).

Paso 4

4.1 Escriba una sentencia "print" mediante la función print() y pase la variable "class" accediendo
a ella.

Sugerencia: se accede directamente a las variables de clase llamándola sobre el nombre de la clase
mediante notación de puntos.

4.2 Escriba una sentencia "print" que dé resultados como: "Plato wrote the book: Republic" (Plato
escribió el libro: República) donde "Plato" es el filósofo y "Republic" es el libro.

pág. 306
Sugerencia: puede utilizar el operador de concatenación integrado (+) para unir estas cadenas.

Paso 5

5.1 Cree e instancie un objeto de esa clase, denominado whodunnit

5.2 Método de llamada hand_list() sobre este objeto "Whodunnit" y pásele dos valores "Sun Tzu"
y "The Art of War".

# 1.1. Define una clase denominada MyFirstClass.

class MyFirstClass:
# 1.2. ¿Agregue una sentencia “print” dentro de ella como “Who wrote this?"
print("Who wrote this?")

# 2. Cree una variable de cadena denominada index y inicialícela con una cadena “
Author-Book"
index = "Author-Book"

# 3.1. Defina una función denominada hand_list() con la ayuda de la palabra clave
def.
def hand_list(self, philosopher, book):
# 4.2. Escriba una sentencia "print" que dé resultados como: "Plato wrote the
book: Republic"
print(philosopher + " wrote the book: " + book)

# 4.1. Escriba una sentencia "print" mediante la función print() y pase la variable "
class" accediendo a ella.
print(MyFirstClass.index)

# 5.1. Cree e instancie un objeto de esa clase, denominado whodunnit.

whodunnit = MyFirstClass()

# 5.2. Método de llamada hand_list() sobre este objeto "Whodunnit" y pásele dos valor
es "Sun Tzu" y "The Art of War".
whodunnit.hand_list("Sun Tzu", "The Art of War")

pág. 307
Instanciar un objeto personalizado: solución

Código de solución

pág. 308
Autorrevisión: instanciar un objeto personalizado

pág. 309
pág. 310
Métodos de instancia

Intentemos resolver un problema que puede ocurrir para gerentes o restaurantes. Dado que los
gerentes están ocupados dirigiendo los restaurantes, tienen un tiempo limitado para ocuparse de
las necesidades de los empleados. El sistema actual de pago de salarios requiere que los gerentes
se pongan al día, cada vez que un empleado solicita el pago. Como esto es engorroso, les gustaría
implementar un alcance automatizado. Entonces, ¿qué puede hacerse? Afortunadamente, existe
una manera de reducir el número de pasos utilizando instancias. Al final de este video, podrá
explicar qué son las variables de instancia y los métodos. También sabrá cómo utilizarlos para
cambiar el estado de un objeto instantáneo. Así que vamos a escribir un código para ayudar a esos
ocupados gerentes de restaurantes.

Comencemos un nuevo archivo denominado pago info.py, en este archivo crearé la clase e
inicializaré tres variables en su nombre, estado de pago e importe. Empiezo por escribir las
nóminas de las clases, y luego en la siguiente línea llamo a una función "in its" con "def" doble
subrayado en ella, y luego selecciono la sugerencia activada. Para las variables escribo cada una
en el formato self.variable igual a variable. A continuación crearé dos funciones, una para mostrar
el estado del pago, otra para actualizar el estado. La primera función se escribe como "death pay"
con "self" entre paréntesis, seguido de "self.payment" igual a "yes" en la siguiente línea. La
segunda función es de estado sordo, y contiene una sentencia "if else". Si "self.payment" es
doblemente igual a "yes", devuelve "self.name" "plus" se paga más "self.amount" con str añadido
al principio. La segunda parte de la sentencia es "else" "return", "self.name plus" no está pago
todavía.

Finalmente, creemos instancias de esta clase para los empleados. Las denominaré Nathan y Roger.
Escribí la primera instancia Nathan igual a nóminas y entre paréntesis, "Nathan" para el nombre,
"no" para el pago y "1000" para el importe. Para Roger copio y pego esta instancia y establezco los
valores en "Roger", "No" y "3000" respectivamente. También necesito asegurarme de pasar estos
valores dentro del método "in its", así que escribo el nombre, el pago y el importe después de sí
mismo. Ahora estoy listo para llamar al estado del método instantáneo para comprobar el estado
de los pagos. Escribo una sentencia "print" para el paréntesis "Nathan.status" y para el paréntesis

pág. 311
"Roger.status". Cuando ejecuto el código, aparece la salida "all" en una línea que no es muy
presentable. Agrego un nuevo caracter de línea entre los elementos y la sentencia "print", que es
la barra invertida n, esta vez la salida es mucho más limpia. La salida afirma que ni a Nathan ni a
Roger se les ha pagado, pero digamos que un gerente decide pagarle a Nathan. Utilizaré la función
de pago para actualizar el estado. Recuerde que la función de pago está configurada para
actualizar el valor de la variable de pago, escribo el paréntesis "Nathan.pay" y luego copio y pego
la última sentencia "print". Sobre esta línea escribo otra sentencia "print" con la cadena después
del pago. Ejecuto el código una vez más y ahora me dice que Nathan recibió el pago de 1000,
mientras que Roger aún no ha recibido el pago.

Esa es una demostración de métodos de instancia en acción. Ahora describiré el código con más
detalle. Ahora hablemos de lo que sucedió en ese ejemplo de codificación con más detalle.

pág. 312
Los dos objetos de instancia que son Nathan y Roger tienen cada uno sus propios estados. Puede
que haya notado que cuando se llamó al método de instancia pago para cambiar el estado de
Nathan, Roger no se vio afectado. Esto se debe a que el método dentro de la clase no se ve
afectado.

pág. 313
En lugar de ello, proporciona un plano separado para cada instancia, que luego se puede actualizar
solo para esa instancia. En el ejemplo de codificación no imprimí los valores de variable después
de llamar a la función pago, pero si lo hiciera mostraría que la variable de instancia de pago para
Nathan cambió de "no" a "sí", mientras que Roger se mantuvo en "no".

Ahora imaginemos que este código es la base para un sistema de pago en línea. Permitiría a
cualquiera de los gerentes hacer clic en el botón de pago de un empleado, lo que actualizaría el
estado de ese empleado.

pág. 314
No más llamadas de ida y vuelta, en este video, aprendió a utilizar variables de instancia y métodos
para cambiar el estado de un objeto de instancia sin afectar a otras instancias.

pág. 315
Clases padres vs. clases hijas

Al crear instancias de objetos a partir de una clase, puede encontrar que falta la clase de algunas
propiedades que utiliza con frecuencia. En ese caso, usted podría decidir hacer una nueva clase
que replique la primera, pero también agrega algunas propiedades más. Sería engorroso escribir
todo desde cero, pero gracias a la herencia, no tiene que hacerlo. Al final de este video, se
familiarizará con la herencia en términos de clases hijas derivadas de una clase padre. La herencia
es un concepto fundamental en la programación orientada a objetos en general, y en particular,
en Python, y es una parte importante de la reutilización del código. Puede que sepa que todo en
Python es un objeto, pero vamos a explorar esa idea más de cerca. Específicamente significa que
cada clase en Python hereda de una clase base integrada denominada "objetos", que se encuentra
en "built-ins dot objects". En otras palabras, una declaración de clase como "Someclass" con
paréntesis vacíos implica alguna clase con objeto como sus argumentos. Al hablar de derivación
de clase, la clase de origen es conocida como la clase padre, superclase o clase base. La clase que
hereda de ella es la clase hija, subclase o clase derivada.

Se acepta cualquier emparejamiento con nombre. Pero lo importante es que la clase hija extiende
los atributos y comportamientos de su clase padre. Esto le permite hacer dos cosas. Puede añadir
nuevas propiedades a la clase hija y puede modificar las propiedades heredadas en la clase hija sin
afectar a los padres. Ahora, veamos un ejemplo de cómo se hace esto en Python. Aquí tiene una

pág. 316
clase padre "P", que contiene la variable "a" con un valor de siete. Luego está la clase hija vacía
"C", en la que la clase "P" se pasa como argumento. Finalmente, una "c" representa una instancia
de clase hija "C". Si escribe una sentencia "print" para "c.a" y ejecuta el código, la salida es siete.

Aunque la propia "C" esté vacía, mantiene los atributos heredados de "P". Tenga en cuenta que
cualquier cambio en la clase padre también afectará a cualquier clase hija. Ahora que ya tiene una
idea de cómo funciona la herencia, vamos a analizar un ejemplo que demuestra la flexibilidad que
proporciona. Empezaré por crear un nuevo archivo denominado "employer.py", y mi primer paso
es crear una clase padre denominada "employees" (empleados) donde definiré dos variables para
nombres y apellidos. Escribo "class Employees" dos puntos y en una nueva línea, ""def__init para
activar y seleccionar la sugerencia método "init". Para la primera variable, escribo "self.name" igual
a "name" en una nueva línea, y para la segunda, avanzo a otra línea y escribo "self.last" es igual a
"last". Luego agrego nombre y apellido al argumento "init" en la línea 2 después de la palabra
"self". A continuación, crearé dos clases hijas que extienden la clase "Empleado". La primera que
creo es "supervisores". Para llamar a la clase "Empleados", escribo clase "Supervisores", abro
paréntesis, "Empleados", cierro paréntesis y dos puntos. Luego, necesito modificar el método
"init" de la clase de "Supervisores" para que pueda agregar otra variable denominada contraseña.
De nuevo, disparo y selecciona el método "init", pero esta vez, ya incluye el nombre y las últimas
variables. Al llamar a la clase "Empleados", el método "super" se ha aplicado automáticamente
para acceder a las variables allí e inicializarlas dentro de la clase "Supervisores". Agrego la tercera
variable, "contraseña", dentro del método "init". A continuación, la convierto en una variable de

pág. 317
instancia con la línea "self.password" es igual a "password". Ahora, escribiré otra clase hija
denominada "Chefs". De nuevo, he ampliado la clase "Empleados" al agregar "Empleados" como
un método dentro de esta clase. Quiero que contenga una nueva función denominada
"leave_request", así que escribo "def leave_request" y luego "self" y "días" como las variables
entre paréntesis. El propósito de la función "leave_request" es devolver una línea que especifique
el número de días solicitados. Para escribirlo, pongo "return", la cadena, "may I take a leave for"
(puedo tomar una licencia para), más "str", abro paréntesis, la palabra "day´s" (del día), cierro
paréntesis, más otra cadena, "days" (días). Ahora que tengo todas las clases, Crearé algunas
instancias a partir de estas clases. Una para un supervisor y dos para los chefs. Primero escribo
Adrian igual a supervisores, seguido de los valores Adrian y A entre paréntesis. A continuación,
puedo copiar y pegar este caso dos veces más para que sea la plantilla para las instancias de los
chefs. El primer chef es Emily y contendrá los valores Emily y E, mientras el segundo chef, Juno,
tiene los valores Juno y J. Finalmente, como instancia de la clase "Supervisors" (supervisores),
Adrian necesita otro valor para la variable de contraseña, así que asignaré "apple" (manzana) aquí.
A continuación, llamemos al método de instancia sobre Emily y pasémosle un valor. Emiliy quiere
solicitar tres días libres, así que escribo print emily.leave_request y el número 3. También voy a
agregar otro sentencia "print" que comprobará el valor de la instancia variable sobre el supervisor
Adrian. Escribo "print adrian.password" (imprimir la clave de Adrian). La tercera sentencia "print"
imprime el valor de la variable del nombre de Emily. Ahora, ejecuto el código y obtengo las
siguientes salidas. Las palabras, "may I take leave for three days" (puedo tomarme tres días libres)
a partir de la primera sentencia "print" , la palabra "apple" (manzana) de la segunda, y la palabra
Emily de la tercera sentencia "print".

pág. 318
Obsérvese que tanto las variables de instancia y los métodos dentro de la las clases individuales
heredadas están presentes junto con las variables de la clase padre.

En este video, ha aprendido cómo heredar en Python ayuda a que el código sea reutilizable,
organizado y menos redundante.

pág. 319
Herencia y herencia múltiple

Digamos que hay dos clases, a saber, la clase A y la clase B. Si tiene que realizar una herencia
simple, se puede llevar a cabo de la siguiente manera:

Class A:
pass
Class B(A):
pass

Si la clase A es la clase padre y la clase B hereda de ella, entonces la clase A se pasa dentro de la
clase B como parámetro. Esto permitirá a la clase B acceder directamente a los atributos y
métodos dentro de la clase A.

Herencia múltiple

Hasta ahora ha aprendido sobre la herencia simple, pero Python también nos da la posibilidad de
realizar herencia múltiple entre clases.

He aquí un ejemplo sencillo de cómo se puede hacer.

# Example 1
class A:
a = 1

class B:
b = 2

class C(A, B):

pass

c = C()
print(c.a, c.b)

pág. 320
En primer lugar, se crean dos clases denominadas A y B y, a continuación, se inicializan las variables
a y b, respectivamente, con valores. A continuación, se define una nueva clase C y se le pasan las
clases A y B. Así es como se hace la herencia múltiple en Python. El orden de las clases es
importante, pero no en este ejemplo concreto. A continuación, instalo un objeto 'c' de la clase C.
Los valores de las variables a y b se imprimen sobre el objeto c de la clase C aunque a y b no estén
presentes dentro de la clase C.

El código anterior es un ejemplo de herencia múltiple. También existen otros tipos de herencia
que caen bajo la categoría de herencia múltiple. Veamos un ejemplo.

Herencia de varios niveles

class A:
a = 1

class B(A):
a = 2

class C(B):
pass

c = C()
print(c.a)

La salida es 2 porque C deriva de la superclase inmediata de C, y esa es B.

El caso anterior es un ejemplo de herencia de varios niveles donde la clase derivada C hereda de
la clase base B. La clase B es a su vez una clase derivada de la clase base C. La clase B es aquí una
clase derivada intermedia. Existen tres niveles de herencia en este caso, pero podría extenderse
siempre y cuando lo desee, aunque puede ser poco práctico luego de un tiempo.

Funciones integradas

Existen dos funciones integradas que pueden ser útiles cuando se trata de encontrar la relación
entre diferentes clases y objetos: issubclass() y isinstance().

A continuación, se muestra la primera issubclass ().

pág. 321
 issubclass(class A, class B)
Se pasan dos clases como argumentos a esta función y se devuelve un resultado booleano. El
ejemplo anterior se puede ampliar como sigue.

print(issubclass(A,B))
print(issubclass(B,A))

Esto demuestra cómo se pasa la clase hija como el primer argumento. Para evitar confusiones,
esto se puede leer como: "¿Es la subclase B de A?" Puede ver que el resultado es "Verdadero" en
el segundo caso donde la hija B es la subclase.

Otra función integrada similar a esta es isinstance(), que determina si algún objeto es una instancia
de alguna clase. Entonces, si escribo:

Class A:
pass
Class B(A):
pass

b = B()
print(isinstance(b,B))
print(isinstance(b,B))

La salida que obtendré es "Verdadero".

Ahora que sabe cómo se pueden extender clases desde otras clases, veamos otra útil función
integrada denominada función super().

La función super() es una función integrada que se puede llamar dentro de la clase derivada y da
acceso a los métodos y las variables de las clases padre o hermanas. Las clases hermanas son las

pág. 322
clases que comparten la misma clase padre. Cuando llama a la función super(), obtiene un objeto
que representa la clase padre en devolución.

La función super() juega un papel importante en la herencia múltiple y ayuda a impulsar el flujo
de ejecución del código. Ayuda a gestionar o determinar el control de donde puedo sacar los
valores de mis funciones y variables deseadas.

Si cambia algo dentro de la clase padre, hay una recuperación directa de los cambios dentro de la
clase derivada. Esto se utiliza principalmente en lugares donde se necesita inicializar las
funcionalidades presentes dentro de la clase padre en la clase hija también. Luego, puede agregar
código adicional en la clase hija.

Aquí tiene un ejemplo.

class Fruit():
def __init__(self, fruit):
print('Fruit type: ', fruit)

class FruitFlavour(Fruit):
def __init__(self):
super().__init__('Apple')
print('Apple is sweet')

apple = FruitFlavour()

En el código anterior, si hubiera comentado la línea para la función super(), la salida sería:

Apple is sweet

pág. 323
Esto ocurrió porque cuando se inicializa la clase hija, no se inicializa la clase base con ella. La
función super() lo ayuda a lograr esto y a agregar la inicialización de la clase base con la clase
derivada.

pág. 324
Ejercicio: exploración de clases y objetos

En esta lectura, explorará el comportamiento de funciones, objetos y clases en Python y cómo

funciona el flujo de ejecución de diferentes sentencias de programa para permitir una mejor
comprensión.

Realizará modificaciones menores en el código dado para observar cómo cambia la salida.

Primero, configure un archivo denominado class_explore.py que contenga la siguiente pieza de

código. Alternativamente, puede utilizar el entorno interactivo aquí.

class A:
def __init__(self, c):
print("---------Inside class A----------")
self.c = c
print("Print inside A.")

def alpha(self):
c = self.c + 1
return c

print(dir(A))
print("Instantiating A..")
a = A(1)
print(a.alpha())

class B:
def __init__(self, a):
print("---------Inside class B----------")
self.a = a

print(a.alpha())
d = 5
print(d)
print(a)

print("Instantiating B..")
b = B(a)
print(a)

pág. 325
Ahora, modifique el código según las instrucciones a continuación y observe los cambios.

Paso 1: ejecute el código y observe su salida. Tome nota de cada línea en el resultado y de cómo
es diferente del resultado que esperaba.

Desde el punto de vista algorítmico, podemos ver el programa que consta de lo siguiente:

1. Definición de clase A

• 1.1 Constructor para A

• 1.2 Definición del método local alpha()

2. Creación de una instancia objeto "a" sobre la clase A

3. Llamada al método "alpha()" sobre el objeto de la clase A

4. Definición de clase de B

5. Constructor para B

• 5.1 Llamada al método "alpha()" sobre objeto de clase A

• 5.2 Crear instancia del objeto "a" sobre la clase B *.

Sentencias "print" adicionales distribuidas a través del código.

Paso 2: comente líneas #13, 14, 21, 24, 27 y 28. Vuelva a ejecutar el código.

La salida es:

Hello World!

Print inside A.

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',

'__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__',
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__', '__weakref__', 'alpha']

Instantiating A..

Instantiating B..

pág. 326
Aunque haya comentado la creación de instancias para ambas clases A y B, la salida sigue
mostrando “Print inside A” y “Print inside B” y también el valor de la variable "d", que es 5. ¿Cómo
es eso posible?

Es porque las sentencias dentro de un cuerpo de clase se ejecutan independientemente de la

creación de la instancia. También verá cómo la sentencia "print" “Inside class A”, que está dentro
del constructor, no se ejecuta porque está dentro de una función.

El valor de d=5 que se imprime demuestra que el espacio de nombres y el alcance de la variable
se determinan por el intérprete antes de crear cualquier instancia de la clase o llamar a cualquier
función dentro de ella. Si observa la lista que obtiene llamando a la función "dir()", notará que la
última entrada es la función "alpha()" agregada al espacio de nombres de A.

Paso 3: ahora quite el comentario de las líneas 21 y 24.

Si ejecuta el código en este punto, arrojará un error, "NameError: name 'a' is not defined" (Nombre
de error: el nombre "a" no está definido). Tome nota de cómo pasó el objeto a un constructor de
clase B y el código aún funcionó bien antes. Solo cuando intentó 'utilizar' el objeto "a", obtuvo un
error porque no se ha creado una instancia. En otras palabras, Python aún no sabe lo que significa
'a'. Lo mismo sucederá si se quita el comentario junto a la línea 28.

Para que el código funcione, elimine el # delante de la línea 14 y vuelva a ejecutarlo.

La salida es:

Hello World!

Print inside A.

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',

'__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__',
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__', '__weakref__', 'alpha']

Instantiating A..

---------Inside class A----------

pág. 327
 2

<submission.A object at 0x7fcab3ef6940>

Instantiating B..

Paso 4: eliminar el comentario para las líneas 27 y 28.

La variable "c" de la clase A se modifica sobre el objeto "a" dentro de la clase B. Aunque la instancia
de clase B aún no se crea, el valor de "a.c" se actualiza, incluso fuera de la clase, como lo demuestra
la línea final en la salida que muestra que el resultado es 2.

Paso 5: por último, elimine todos los comentarios restantes y ejecute el código una vez más.

A continuación, algunas observaciones:

• Cuando intente imprimir el 'objeto' de la clase A como en las líneas 21 y 28, obtendrá la
dirección del objeto en lugar de los contenidos.

• Observe cómo la dirección del objeto es la misma tanto dentro de la clase B como en el
ámbito global del programa. Sigue siendo la misma independientemente de donde se la
llame.

• La función "alpha()" se llama dos veces en el programa, pero usted sigue obteniendo el
resultado como 2 cada vez y no 3. Eso se debe a que el valor se actualiza temporalmente
y no se asigna a nada.

Revise los elementos sobre clases, llamadas a funciones y alcance en caso de confusión.

pág. 328
Clases y métodos abstractos

En este video, aprenderá sobre clases y métodos abstractos. Si tiene una clase abstracta, puede
garantizar la funcionalidad de cada clase que se deriva de ella. Por ejemplo, un vehículo podría ser
una clase abstracta. No puede crear un vehículo, pero puede derivar un auto, un tractor, o un
barco desde un vehículo. Los métodos en los que ponemos la clase abstracta están garantizados
para que se presenten en la clase derivada porque deben implementarse. Si un vehículo tiene un
método de encendido del motor, entonces aseguramos que cualquier método que llama a una
clase derivada, es decir que buscando "encender motor" lo encontrará.

Esto podría ser por razones de interoperabilidad, consistencia, y evitar duplicación de código en
general. En la programación orientada a objetos, la clase abstracta es un tipo de clase para la que
no se puede crear una instancia. Python tampoco admite abstracción directamente. Necesita
imponer un módulo solo para definir una clase abstracta.

pág. 329
Además, los métodos en una clase abstracta necesitan ser definidos antes de que se puedan
implementar. Con todas estas limitaciones, uno se podría preguntar por qué utilizar clases
abstractas. Una de las principales ventajas es la capacidad de ocultar los detalles de la
implementación sin sacrificar la funcionalidad. La implementación en clases abstractas se puede
hacer de dos formas. Una es que, como base, las clases abstractas carecen de implementación
propia, los métodos se deben ser implementar por la clase derivada. Otra posibilidad es que se
puede utilizar la función "super". Pero ese es un tema para otro curso. Por ahora, centrémonos en
el módulo para definir una clase abstracta. Es posible que no esté familiarizado con los módulos
en este momento, pero se van a tratar con más detalle más adelante. Por ahora, continuemos.

El módulo se conoce como la clase base abstracta o ABC, y necesita importarse con algún código.
Después de eso, puede crear una clase denominada "SomeAbstractClass" y pasar en el módulo
ABC para que herede esa clase.

El siguiente paso es importar el decorador de método abstracto dentro del mismo módulo. Un
decorador es una función que requiere otra función como sus argumentos y da una nueva función

pág. 330
como su salida. Se denota con el signo "add". Es posible que no esté familiarizado con los
decoradores, pero por ahora, es suficiente saber que los decoradores son como funciones
ayudantes que agregan funcionalidad a una función ya existente. Por último, aquí definirá un
método abstracto que no se puede llamar en un objeto de esta clase. Podrá llamar a este método
sobre objetos de clases que heredan de esta clase. Del mismo modo, podemos definir métodos
abstractos con la ayuda de lo que denominamos un decorador de método abstracto presente
dentro del mismo módulo. Cualquier clase abstracta puede consistir en uno o más métodos
abstractos. Sin embargo, una clase que tiene una clase abstracta como su padre no se puede
instanciar a menos que anule todos los métodos abstractos presentes al principio. Con eso en
mente, imagine un escenario en el que un empleador quiere para recolectar donaciones de los
empleados por una causa benéfica. Con sus nuevos conocimientos, escribamos algún código para
hacerlo posible. Primero, importo el módulo ABC y su método abstracto, luego creo la clase
abstracta "empleado" denominada "método abstracto" para definir un método denominado
"donación". Tenga en cuenta que no hay implementación para este método aquí. Luego, creo la
donación de clase que derivó de la clase abstracta. Tenga en cuenta que esta clase también anula
el método abstracto.

Escribo una implementación para la función "donate", que toma la entrada del usuario, la
almacena en una variable "a" y la devuelve. A continuación, creo dos instancias de empleados

pág. 331
denominadas John y Peter y llamo a la función sobre cada una de ellas. También creo una lista de
montos, a la que se anexarán los valores devueltos.

Por último, tengo una sentencia "print" para los importes que darán el valor del total de
donaciones de ambos empleados. En este video, aprendió sobre clases abstractas y métodos, y
cómo implementarlos en su código.

pág. 332
Clases y métodos abstractos

pág. 333
pág. 334
Tareas de programación: Clases y métodos abstractos

Introducción

En esta tarea, creará una clase abstracta para un banco que se utilizará para crear una clase regular
para un banco específico. Esta clase contendrá la implementación del método abstracto de la clase
abstracta.

Instrucciones

1. Cree una clase llamada Banco y pásele ABC.

2. Dentro de la clase tiene que definir dos métodos:

• 2.1 Defina una función llamada basicinfo() y agregue una sentencia "print" dentro de ella
diciendo "This is a generic bank" y devolviendo la cadena "Generic bank: 0"

• 2.2 Defina una segunda función llamada "withdraw" y manténgala vacía agregando una
palabra clave pass debajo de ella. Haga que esta función sea abstracta agregando
'@abstractMethod' justo encima.

3. Cree otra clase denominada Swiss y pase la clase Bank dentro de ella. Esto significa que hereda
de class Bank.

• 3.1 Cree un constructor para esta clase que inicialice una variable de clase "bal" a 1000

4. Anule ambas funciones de la clase Bank: básicinfo() y withdraw().

• 4.1 Defina una función llamada Basicinfo() y agregue un extracto impreso dentro de ella
indicando "This is the Swiss Bank" (Este es el banco suizo) y devuelve una cadena con "Swiss
Bank: " (Banco suizo: ) seguido del saldo actual del banco. Por ejemplo, si self.bal = 80,
devolvería "Swiss Bank: 80" (Banco suizo: 80)

• 4.2 Defina una segunda función, llamada "withdraw" y pase un parámetro a él (distinto de
uno mismo): cantidad. El importe representa el importe que se retirará.

• 4.2.1 Actualice la variable de clase bal deduciendo el valor de la cantidad.

pág. 335
 • 4.2.2 Imprima el valor del importe dando una salida como: "Withdrawn amount:
30" (Importe retirado: 30)

• 4.2.3 Imprima el nuevo saldo dando un resultado como: "New balance: 970"
(Balance nuevo: 970)

• 4.2.4 Devuelva el nuevo saldo

• Nota: Asegúrese de verificar que haya suficiente dinero para retirar. Si el importe
es mayor que el saldo, no deduzca ningún dinero del importe variable de la clase,
imprima un extracto que diga "Insufficient funds" y devuelva el saldo original de la
cuenta.

SOLUCION:

# Import ABC and abstractmethod from the module abc (which stands for abstract ba
se classes)
from abc import ABC, abstractmethod

# Class Bank
class Bank(ABC):
""" An abstract bank class

[IMPLEMENT ME]
1. This class must derive from class ABC
2. Write a basicinfo() function that prints out "This is a generic bank"
and
returns the string "Generic bank: 0"
3. Define a second function called withdraw and keep it empty by
adding the `pass` keyword under it. Make this function abstract by
adding an '@abstractmethod' tag right above the function declaration.
"""
### YOUR CODE HERE
# 2.1 Definir el método basicinfo()
def basicinfo(self):
print("This is a generic bank")
return "Generic bank: 0"

# 2.2 Definir el método abstracto withdraw()

@abstractmethod
def withdraw(self, amount):

pág. 336
 pass
# Class Swiss
class Swiss(Bank):
""" A specific type of bank than derives from class Bank

[IMPLEMENT ME]
1. This class must derive from class Bank
2. Create a constructor for this class that initializes a class
variable `bal` to 1000
3. Implement the basicinfo() function so that it prints "This is the
Swiss Bank" and returns a string with "Swiss Bank: " (don't forget
the space after the colon) followed by the current bank balance.

For example, if self.bal = 80, then it would return "Swiss Bank: 80"

4. Implement withdraw so that it takes one argument (in addition to

self) that is an integer which represents the amount to be withdrawn
from the bank. Deduct the withdrawn amount from the bank bal, print
the withdrawn amount ("Withdrawn amount: {amount}"), print the new
balance ("New Balance: {self.bal}"), and return the new balance.

Note: Make sure to verify that there is enough money to withdraw!

If amount is greater than balance, then do not deduct any
money from the class variable `bal`. Instead, print a
statement saying `"Insufficient funds"`, and return the
original account balance instead.
"""
### YOUR CODE HERE
# 3.1 Constructor para inicializar la variable de clase bal
def __init__(self):
self.bal = 1000

# 4.1 Sobrescribir el método basicinfo()

def basicinfo(self):
print("This is the Swiss Bank")
return f"Swiss Bank: {self.bal}"

# 4.2 Sobrescribir el método withdraw()

def withdraw(self, amount):
if amount > self.bal:
print("Insufficient funds")
return self.bal
else:
self.bal -= amount

pág. 337
 print(f"Withdrawn amount: {amount}")
print(f"New balance: {self.bal}")
return self.bal

# Driver Code
def main():
assert issubclass(Bank, ABC), "Bank must derive from class ABC"
s = Swiss()
print(s.basicinfo())
s.withdraw(30)
s.withdraw(1000)

if __name__ == "__main__":
main()

SALIDA:

pág. 338
Prueba de Escritorio

Código a probar:

from abc import ABC, abstractmethod

class Bank(ABC):
def basicinfo(self):
print("This is a generic bank")
return "Generic bank: 0"

@abstractmethod
def withdraw(self, amount):
pass

class Swiss(Bank):
def __init__(self):
self.bal = 1000

def basicinfo(self):
print("This is the Swiss Bank")
return f"Swiss Bank: {self.bal}"

def withdraw(self, amount):

if amount > self.bal:
print("Insufficient funds")
return self.bal
else:
self.bal -= amount
print(f"Withdrawn amount: {amount}")
print(f"New balance: {self.bal}")
return self.bal

# Ejemplo de uso
if __name__ == "__main__":
bank = Swiss()
print(bank.basicinfo())

new_balance = bank.withdraw(30)
print(f"Final balance: {new_balance}")

insufficient_balance = bank.withdraw(1000)
print(f"Final balance: {insufficient_balance}")

pág. 339
pág. 340
pág. 341
pág. 342
Método Orden de resolución
Hasta el momento, ha visto las relaciones de clase relativamente sencillas.

¿Pero qué pasa cuando las cosas se complican? ¿Cómo sabrá qué clases heredan de cuáles?
Afortunadamente, el orden de resolución de métodos o MRO proporciona reglas que pueden
ayudar a dar sentido a eso. Al final de este video, sabrá cómo explicar las reglas básicas de orden
de método, resolución y cómo se aplican a las clases de herencia. Explicar el concepto de
linealización de código, herencia múltiple y orden de método de implementación, funciones de
resolución en Python. Es probable que haya encontrado algunos ejemplos de herencia única
donde una clase hija solo hereda de una sola clase padre. Pero es importante saber que Python
tiene muchos tipos de herencia. Los tipos de categorización se basan en el número de clases padre
e hija, así como el orden jerárquico, incluida la herencia simple.

A grandes rasgos, existen cuatro tipos de herencia. El primer tipo se denomina herencia simple,
con la que ya hemos tratado.

pág. 343
También existe la herencia múltiple, que involucra una clase hija que hereda de más de una clase
padre.

También existe la herencia de varios niveles, que es heredar en varios niveles.

Luego aparece la herencia jerárquica, lo que se refiere a cómo varias subclases heredan de un
padre común.

pág. 344
Y por último, se podría decir que existe un quinto tipo denominado herencia híbrida, que mezcla
las características de las demás. Como demuestran estos tipos de herencia, la herencia se vuelve
cada vez más compleja a medida que el número de clases en un proyecto crece y las clases son
más interdependientes. Entonces, el modo en que resolvieron este problema los desarrolladores
con el uso de MRO determina el orden de un método dado o los atributos se pasan a través de
una búsqueda de la jerarquía de clases para su resolución; o en otras palabras, de donde
pertenece, el orden de la resolución se denomina linealización de una clase. Y MRO define las
reglas que sigue.

El orden predeterminado en Python es de abajo a arriba, de izquierda a derecha, cuando imagine

la herencia de estas clases de Python en una estructura de árbol. Tomemos el ejemplo simple de
herencia única. El objeto se busca por primera vez en la clase de ese objeto y luego en su súper
clase. ¿Qué pasa en un ejemplo, en el que las clases se heredan de dos clases? Supongamos que
la Z se hereda de las clases X e Y. En este caso, el MRO será Z, Y, y luego X.

pág. 345
En otras palabras, el MRO funciona de
abajo a arriba y luego de izquierda a
derecha. Pero las cosas se vuelven
mucho más complicadas cuando se
agregan más niveles a la jerarquía. Así
que los desarrolladores confían en
algoritmos para construir MRO. Las
clases de estilo antiguo utilizaban
algoritmos en profundidad, primer
algoritmo de búsqueda o DFS desde
Python versión tres en adelante. Las
versiones de Python se han movido al nuevo estilo de clases que dependen del algoritmo de
linealización C tres.

La implementación del algoritmo de linealización C3 es complejo y va más allá del alcance de esta
lección, pero por ahora esta es una descripción general de algunas reglas que sigue. El algoritmo
sigue la monotonicidad, lo que significa ampliamente que una propiedad heredada no puede
omitir clases padre directas. También sigue la herencia gráfica de la clase, y la súper clase se visita
solo después de visitar los métodos de las clases locales.

pág. 346
Esta lógica tendrá más sentido cuando explore relaciones de clase más complejas en una lección
futura. A continuación, tomemos un momento para ver algunos métodos para encontrar el MRO
de una clase. Primero, empezaré con la demostración de los atributos o función de MRO.
Tomemos un ejemplo de multinivel de herencia compuesto por tres clases, clase A, clase B y clase
C. La clase A es la clase padre con B y C, las respectivas clases hija. En otras palabras, B hereda de
A y C hereda de B. Cuando imprimo la devolución para llamar a la función MRO sobre la clase C, la
salida de hecho confirma que este es el orden que se siguió. Entonces ¿por qué esto es
importante? Bueno, imagine que la clase A tiene una variable "num" con valor de cinco y entonces
la Clase B también tiene una variable de número con un valor de nueve.

Aquí, la función le indica rápidamente que la clase C heredará el valor nueve de la clase B.
Finalmente, examinemos una función más que es la función "help". Si tomo el código de antes y

pág. 347
reemplazo la función MRO en la sentencia "print" con la función "help", proporciona una salida
mucho más detallada con información de MRO en la parte superior.

También contiene información sobre los descriptores de datos y los tipos utilizados dentro del
código.

pág. 348
En este video, recibió una breve introducción al orden de resolución del método y cómo afecta la
herencia en diferentes escenarios. Ambos son temas muy amplios, pero espero que lo ayuden a
comprender la complejidad del código posible en Python.

pág. 349
Trabajar con métodos: ejemplos
Ha aprendido a utilizar objetos, clases y métodos dentro de ellos. Usted vio los casos en los que
solo hay una clase, y también los que contienen varias clases. También ha explorado cómo
funciona la herencia múltiple en Python y el papel que juega el MRO (Method Resolution Order,
Orden de resolución de método) en la determinación de la llamada al método.

Los siguientes ejemplos demuestran cómo se resuelve la llamada a la función en casos de herencia
múltiple en diferentes escenarios. Tenga en cuenta que todas las funciones tienen los mismos
nombres en todos los ejemplos.
Ejemplo 1:
# Example 1
class A:
def a(self):
return "Function inside A"

class B:
def a(self):
return "Function inside B"

class C(B,A):
pass

# Driver code
c = C()
print(c.a())

Salida

La clase "C" hereda de las clases "B" y "A". Cuando no encuentro ninguna función "a()" dentro de
la clase "C", debo buscar en las clases "B" y "A", y es importante que lo haga en ese orden.
Ahora agregaré un nivel más y observaré el resultado.

pág. 350
Ejemplo 2:
class A:
def b(self):
return "Function inside A"

class B:
def b(self):
return "Function inside B"

class C(A, B):

def b(self):
return "Function inside C"
pass

class D(C):
pass

d = D()
print(d.b())

La clase "D" hereda de la clase "C", que a su vez hereda de las clases "A" y "B". La clase "D" accede
a la superclase inmediata de la clase "D", que es la clase "C" y resuelve el valor de la variable una
vez que se encuentra en esa superclase.
Ahora digamos que comento la declaración dentro de la clase "C".

Y reemplazo por la palabra clave pass para mantener el código funcional.

Dado que tampoco había ningún valor presente dentro de la clase "C", la llamada a la función
anterior iría a "A". Esto se debe a que la clase "C" señalará a la clase "A" como de mayor prioridad
al heredar.
Ahora veamos otro ejemplo de un escenario similar.

pág. 351
class A:
def c(self):
return "Function inside A"

class B:
def c(self):
return "Function inside B"

class C(A, B):

def c(self):
return "Function inside C"

class D(A, C):

pass

d = D()
print(d.a)

Tenga en cuenta que esto genera un error. En el código anterior, la clase "D" hereda tanto de la
clase "A" como de la clase "C".
La clase "C" es su superclase inmediata, pero dado que se trata de una herencia múltiple, las reglas
son más complicadas y también tiene que comprobar la prioridad de las clases que se le pasan.
En este caso concreto, la clase "D" es incapaz de resolver el orden que se debe seguir, al tiempo
que resuelve el valor de la variable en los casos en que la variable no está presente en la clase del
objeto dado.
El resultado es un "TypeError" porque es incapaz de crear una orden de resolución de método
(MRO). La MRO es la forma de Python de resolver el orden de prioridad de las clases mientras se
trata de herencia.
Veamos otro último ejemplo.

pág. 352
Ejemplo 4:
class A:
def d(self):
return "Function inside A"

class B:
def d(self):
return "Function inside B"

class C:
def d(self):
return "Function inside C"

class D(A, B):

def d(self):
return "Function inside D"

class E(B, C):

def d(self):
return "Function inside E"

class F(E,D,C):
pass

f = F()
print(f.d())
print(F.mro())

pág. 353
El código aquí es sencillo. La clase "F" hereda directamente de su superclase inmediata y de la
primera clase que se le pasa. A continuación, la segunda línea muestra lo que devuelve la función
"mro()".
Los ejemplos de esta lectura demuestran cómo el código en el que se utiliza la herencia múltiple
se puede complicar y ser muy desordenado, muy rápido. La herencia múltiple, con todas las
ventajas y flexibilidad que proporciona, solo se debe utilizar si se tiene un comando sólido de
Python como lenguaje para evitar crear "código spaghetti" que sea difícil de entender y actualizar.

Ejercicio: trabajar con métodos

1. Averigüe la salida para el siguiente bloque de código e intente ejecutar el código una vez que
tenga una solución en mente:

class A:
def b(self):
return "Function inside A"

class B:
pass

class C:
def b(self):
return "Function inside C"

class D(B, C, A):

pass

class D(C):
pass

d = D()
print(d.b())

pág. 354
pág. 355
pág. 356
2. Averigüe la salida para el siguiente bloque de código e intente ejecutar el código una vez que
tenga una solución en mente:

class A:
def c(self):
return "Function inside A"

class B(A):
def c(self):
return "Function inside B"

class C(A,B):
pass

class D(C):
pass

d = D()
print(d.a)

pág. 357
pág. 358
pág. 359
3. Averigüe el resultado del siguiente bloque de código e intente ejecutar el código una vez que
tenga en cuenta una solución:

class A:
pass

class B(A):
pass

class C(B):
pass

c = C()
print(c.a())

pág. 360
Autorrevisión: trabajar con métodos
Revisar los objetivos de aprendizaje

pág. 361
pág. 362
pág. 363
Resumen del módulo: paradigmas de programación
Bien hecho. Ha llegado al final de este módulo sobre paradigmas de programación. En este
módulo, aprendió sobre programación de procesos, programación funcional y programación
orientada a objetos.

Comenzamos el módulo diciendo que la programación de procesos se considera la más sencilla y

un paso básico hacia la programación orientada a objetos. y la primera opción para los
desarrolladores nuevos. Luego, ha explorado la programación funcional, que en esencia es un
paradigma de programación que utiliza la creación de funciones para un código limpio, coherente
y de fácil mantenimiento. Por último, aprendió que la programación orientada a objetos trata
sobre la creación de objetos que contienen datos y métodos. Estos conceptos deberían ahora
tener sentido para usted. Es hora de recapitular sobre las principales lecciones aprendidas y la
capacitación que obtuvo. Con esto en mente, vamos a resumir los puntos clave que ha aprendido
en este módulo. Deberá ser capaz de describir el concepto de programación de procesos. Describir
qué son los algoritmos, y cómo se pueden utilizar para resolver problemas. Identificar cómo se
calcula la complejidad algorítmica, y reconocer cómo la complejidad algorítmica puede ayudar a
mejorar el rendimiento. También debe ser capaz de describir la notación Big O. Explicar qué es la
programación funcional, explicar cómo son las funciones puras utilizadas en la programación
funcional, y explicar la recursión y que se pueden utilizar para solucionar problemas. Lo que ha
aprendido, sin embargo, no es todo. Por lo tanto, también debería poder utilizar diferentes
métodos para invertir una cadena en Python. Explicar la diferencia entre el mapa y las funciones
de filtro. Explicar la programación orientada a objetos y los cuatro conceptos sobre los que se

pág. 364
construye, y describir la relación entre clases e instancias en Python. Por último, tras haber
estudiado los puntos clave restantes en este módulo, debería poder crear clases, crear instancias
para clases, acceder a sus variables y métodos, y cambiar el estado de objetos intensos mediante
variables de instancia y métodos. Este módulo ofrece una introducción completa a diferentes
paradigmas de programación en Python. Se trata de conocimientos esenciales que lo preparan
para que pueda crear un código de programación aún mejor.

pág. 365
Cuestionario del módulo: paradigmas de programación

pág. 366
pág. 367
Recursos adicionales
Los siguientes recursos serán útiles como referencias adicionales para tratar los diferentes
conceptos relacionados con los temas que se han tratado en esta lección.
• Principios de la OOP
• Comprensión detallada de la MRO
• Principios de programación orientada a objetos/ Clases y objetos

pág. 368
MODULO 4

MÓDULOS, PAQUETES, BIBLIOTECAS Y HERRAMIENTAS

Mejore su entorno de programación con bibliotecas de módulos y herramientas populares para
Python. También aprenderá sobre los diferentes tipos de pruebas y cómo escribir una prueba.
Objetivos de aprendizaje

• Encontrar, importar y utilizar módulos y paquetes populares de Python

• Aprovechar las potentes herramientas para optimizar el flujo de trabajo de programación
• Explicar los tipos de pruebas y sus características
• Utilizar herramientas de prueba para escribir una prueba

pág. 369
MODULOS
¿Qué es un Módulo en Python?
Los automóviles son una parte importante de nuestras vidas que hacen que sea más fácil moverse.

Pero si necesita que su automóvil haga más cosas, como la conducción en la nieve o el transporte
de objetos grandes, entonces, probablemente podríamos modificarlo agregando neumáticos de
invierno o un remolque. De manera similar, Python es un lenguaje potente que permite a los
desarrolladores construir cosas increíbles, pero puede ganar aún más funcionalidad con el uso de
módulos. Aprenderá sobre módulos en Python y por qué se utilizan. También explorará los
diferentes tipos de módulos y podrá explicar dónde se pueden encontrar. Ahora, puede que se
pregunte qué es un módulo de Python. Imagine que los módulos funcionan como instrucciones
para hacer una tarta. En lugar de tratar de averiguar cuáles son los pasos para crear su tarta, siga
las instrucciones. Los módulos funcionan de la misma manera.

Construyen bloques para agregar funcionalidad a su código, para que no tenga que rehacer todo
continuamente. Un módulo de Python contiene sentencias y definiciones.

pág. 370
Un archivo como "sample.py" puede ser un módulo denominado "sample", y se puede importar.
Los módulos en Python pueden contener tanto sentencias ejecutables como funciones. Pero antes
de explorar cómo se utilizan, es importante que comprenda su valor, su propósito y sus ventajas.
Los módulos proceden de la programación modular. Esto significa que la funcionalidad del código
es dividida en partes o bloques de código. Estas partes o bloques tienen grandes ventajas: alcance,
reutilización, y simplicidad.

Vamos a profundizar en este tema. Todo en Python es un objeto, es así que los nombres que utiliza
para las funciones, las variables, etc. se vuelven importantes. "Scoping" significa que los módulos
crean un espacio de nombres separados. Dos módulos diferentes pueden tener funciones con el
mismo nombre, e importar un módulo hace que esto forme parte del espacio global en el código
que se está ejecutando. La reutilización es la ventaja más importante de la modularidad.

pág. 371
Cuando escribe una parte del código, los módulos lo ayudan a evitar la necesidad de escribir todas
las funcionalidades que pueda necesitar. La duplicación de código, duplicación de esfuerzos, utiliza
más memoria de la computadora y es menos eficiente. Por ejemplo, si desea importar un paquete
matemático, obtendrá automáticamente acceso a una pérdida de funcionalidades como factorial,
el máximo común divisor, el uso de este GCD y demás, que se vuelven a usar sin definir.

Otra característica que ofrecen los módulos es que aportan simplicidad. Cuando los módulos
tienen poca dependencia entre sí, aumenta la simplicidad. Cada módulo se ha creado con un
propósito sencillo. Los módulos se definen por su uso. También puede utilizar una expresión

pág. 372
regular o módulo "RE" para la gestión de expresiones regulares. La sencillez también ayuda a evitar
la interdependencia entre estos módulos. Si trabaja en la visualización de datos, la importación de
un único módulo como Matplotlib es suficiente para visualizar sus datos.

Existen diferentes tipos de módulos en Python. La principal diferencia entre estos módulos es la
forma en que se accede a ellos. Vamos a ver los módulos integrados. Algunos módulos ya están
integrados en la biblioteca estándar de Python.

Cuando utiliza una sentencia como "import math" (importar matemática) en su código Python,
por ejemplo, el intérprete primero intenta encontrar módulos integrados. ¿Cómo se importan y
ejecutan módulos en Python? Lo primero importante que debe saber es que los módulos solo se
importan una vez durante la ejecución. Si, por ejemplo, importa un módulo que contiene
sentencias "print", imprime abrir corchetes, cerrar corchetes, puede comprobar que solo se
ejecuta la primera vez que importa el módulo, aunque el módulo se importe varias veces. Puesto
que los módulos son construidos para ayudar al usuario, los módulos independientes albergan
todas las funciones, pero probablemente no contenga funciones que ejecutan sin llamar.

pág. 373
Solo cuando el usuario ejecuta las diferentes funciones dentro de ese módulo encontrará la
utilidad de esas funciones en el código. El módulo normalmente se define al principio del código,
pero puede definirlo en cualquier punto del código. Dado que la ejecución del código en Python
es en serie, debe importar el módulo primero antes de ejecutar cualquier función en su interior.

Los módulos también se pueden ejecutar desde la función. Esto significa que el código dentro de
ese módulo solo se puede utilizar una vez que se ejecute la función. Resumen: se ha hablado sobre
los módulos en Python. Aprendió sobre los diferentes tipos de módulos y cómo se puede utilizar
para ahorrar tiempo, y hacer que su trabajo sea más eficiente.

pág. 374
Acceder a los módulos
En Python, puede acceder a diferentes tipos de módulos, como módulos integrados y módulos
definidos por el usuario desde diferentes ubicaciones. Piense en los módulos integrados como una
casa que quiere construir a partir de pisos, paredes y un techo pre-construidos y empaquetados
que simplemente tiene que montar. Así no tendrá que buscar martillos, ladrillos, yeso ni trapos
para construir paredes y pisos.

Ahorrará tiempo y su trabajo será más eficiente. Los módulos de acceso integrado y definido por
el usuario en Python funcionan del mismo modo y ayudan a ahorrar tiempo y a construir con
eficiencia mientras se encuentra codificando. Recuerde que cualquier archivo Python puede ser
un módulo.

Los módulos se buscan por el intérprete y la siguiente secuencia. En primer lugar, la ruta de
directorio actual. En segundo lugar, el directorio de módulos integrados. Tercero, la ruta de Python
variable de entorno con una lista de directorios, y, por último, se investiga el directorio dependiente
por defecto de la instalación.

pág. 375
Vamos a investigarlos con más detalle. Se demostrará cómo acceder a diferentes tipos de
módulos, como módulos integrados y módulos definidos por el usuario desde diferentes
ubicaciones. Vamos a escribir algunos códigos y aprender cómo acceder a algunos módulos
integrados. Comencé por crear un nuevo archivo denominado "mycalendar" (mi calendario) en
Visual Code. Luego utilizo la función de ruta de puntos sys y devuelvo el valor que obtengo en una
variable denominada "ubicaciones". Por último, imprimo los valores mediante la función de
impresión. Ahora intento ejecutar este código. Desafortunadamente, no funciona. Python no tiene
idea de lo que es sys. Para resolverlo, voy a probar e importar la función sys integrada. Volveré a
ejecutar el código. La función de impresión devuelve todas las ubicaciones posibles que el
intérprete buscará para encontrar módulos, incluido el directorio de trabajo actual. Pero esto no
parece muy claro. Sé que tengo una lista de valores, así que voy a ejecutar un bucle "for" que
atraviesa cada ubicación a su vez. Esto devuelve resultados más limpios al imprimir cada ubicación
en su propia línea en la terminal. Ahora, siempre es bueno practicar para importar todos los
módulos requeridos justo al principio. Pero puedo hacerlo de otra manera. Voy a importar un
módulo aquí en medio del código. Voy a importar otro módulo integrado denominado
"calendario". Ahora utilizaré un par de funciones que tiene el calendario. Ahora utilizaré una
función denominada "días bisiestos", que tiene dos entradas. año 1 y año 2, y devolverá otro valor
entero. Así que lo que voy a hacer es escribir la función de días bisiestos, escribir los años de
entrada y devolver el valor en una variable denominada "días bisiestos". Voy a imprimir el valor de
una variable. Recibo un valor de devolución de 13, lo que significa que existen 13 días bisiestos
entre 2000 y 2050, Ahora, utilizaré otra función. Esta función se denomina "easily" (fácilmente).
Toma uno de los años como una entrada y devuelve un valor booleano. Le dice si un año dado es

pág. 376
un año bisiesto. Veamos qué ocurre con 2036 y devolvamos el valor en otra variable denominada,
¿es bisiesto?

Esta vez, obtengo el valor "true" (verdad) porque 2036 es un año bisiesto. Si decide investigar un
poco, puede pasar el cursor sobre el calendario. Si utiliza una MacBook, presione la tecla de
comando. Si utiliza Windows, presione la tecla Control, lo que lo llevará al archivo calendario al
hacer clic en él. Observe cómo el propio módulo "calendario" importó otros módulos, y además
de eso, contiene todas las funcionalidades. Ahora encuentro la ubicación del calendario dentro
del paquete Python 3.9, que es una de las ubicaciones listadas en la terminal por el bucle de
ubicaciones de impresión que ejecuté antes. Acaba de aprender a acceder a módulos integrados
y módulos definidos por el usuario desde diferentes ubicaciones. Le recomiendo que comience a
utilizar módulos en su código para que su trabajo sea más eficiente.

pág. 377
La sentencia "import"
En este video, aprenderá a utilizar sentencias de importación para acceder a módulos de
diferentes directorios. También aprenderá a crear paquetes a partir del índice de paquetes de
Python mediante pip. Todos los archivos Python, lo que significa cualquier archivo con extensión
.py que contiene un "script" es efectivamente un módulo. El archivo "check imports" que estoy
creando actualmente, es por lo tanto un módulo para algunos de los archivos. El código con el que
se trabaja suele denominarse módulo principal. En este caso, "check imports" es el módulo
principal presente en el directorio donde se está trabajando. También denominado alcance del
proyecto, puede importar cualquier archivo de Python que esté presente en el alcance actual. Por
ejemplo, puedo importar el archivo .py de muestra escribiendo importar, seguido por el nombre
de archivo sin la extensión. Luego hago clic, ejecuto en el menú superior. El sistema devuelve un
mensaje en el pin de terminal donde dice que la importación fue exitosa. Si intento importar un
archivo con una extensión .txt, la importación no se realizará correctamente. Por ejemplo, si
vinculo la importación seguida del texto de muestra y hago clic en ejecutar, el sistema devolverá
un mensaje de error en el pin de terminal, ya que no es un archivo Python.

pág. 378
Python tiene una biblioteca de módulos estándar denominados módulos integrados. Estos
módulos están integrados directamente en el intérprete de Python y no tienen que instalarse por
separado. Puedo importar un módulo como "Json" escribiendo "import Json". Una vez ejecutado
el comando, puedo comenzar a utilizar sus funciones directamente. La lista de módulos integrados
se puede consultar en la biblioteca estándar de Python. Puede pensar en los paquetes como la
estructuración de módulos de Python como una colección. Se necesitan archivos especiales
denominados "init.py" para que Python trate los directorios que contienen el archivo como
paquetes. Python cuenta con una gran colección de paquetes creados por la comunidad que pude
encontrar en el índice de paquetes de Python, o pyPI. Pyp o pyp3 es el instalador del paquete
predeterminado para Python, y ayuda a la instalación de paquetes desde pyPI. Como ya he
instalado "numpy", puedo importarlo directamente en Python. Lo hago escribiendo "import
numpy", limpiando mi terminal y pulsando ejecutar, si intento importar un paquete que no está
instalado, aparecerá un mensaje de error.

Por ejemplo, si escribo "import seaborn" y hago clic en ejecutar el mensaje, se devuelve el error
de módulo no encontrado. Si se instaló el paquete "seaborn", podría ejecutar el comando de
nuevo en Python sin mensajes de error. Para ello, ejecutaría "pip install seaborn" en la terminal
para descargar el paquete desde el índice pyPI. También puedo importar archivos que he creado

pág. 379
en una de las carpetas dentro del actual directorio de trabajo. Tengo una carpeta denominada
"workplace" que contiene un archivo denominado "trial.py". El archivo consta de una lista con los
nombres de las variables y dos entradas. Voy a importar este archivo y acceder a su contenido.
Empiezo por importar el módulo "sys". A continuación, utilizo una función "path" en sys
escribiendo "sys.path.insert". Ahora, debo introducir el nombre de la ruta para mi paquete de
"workplace" en la primera ubicación del índice. Para ello, hago clic con el botón derecho en el
directorio "workplace" y selecciono "copy path". Ingresé este nombre de ruta como la primera
ubicación del índice, al pasar la ruta de acceso como argumento. Debo utilizar comillas simples y
escribir la letra R delante de la cadena de la ruta. La lista "sys.path" ahora tiene un nuevo directorio
donde buscará módulos. Ahora debo importar mi archivo de prueba aquí escribiendo "import trial"
y al pulsar "enter", aparece una línea garabateada debajo de la palabra "trial". Esto se debe a que
el IDE no conoce la ruta que he agregado dentro de "sys.path". Sin embargo, puedo continuar, ya
que el intérprete sabrá sobre esta ruta.

Para imprimir la salida escribo, "print" seguido de "trial.names" y hago clic en el botón Ejecutar
para ejecutar.

pág. 380
Se imprimen los valores de Adrián y María de la variable de lista de nombres. En este video, ha
aprendido cómo los módulos se pueden importar desde cualquier lugar dentro de su sistema; sin
embargo, insertar el nombre de la ruta puede ser muy específico y a menudo complicado y
confuso. No se preocupe demasiado por esto por ahora. Es más importante centrarse en la
importación de archivos desde su directorio actual. Es bueno saber que importar módulos desde
otros directorios es una opción, si lo necesita. Sin embargo, se recomienda mover los archivos
necesarios al directorio en el que está trabajando.

pág. 381
Escribir sentencias "import"
Exploremos cómo utilizar módulos con la sentencia "import". Ya he creado un archivo denominado
"imports.py". Ahora importaré el módulo matemático integrado escribiendo "import math". Para
estar seguros de que este código funciona, utilizaré una sentencia "print". Escribo "print", e
importo el módulo de matemáticas. A continuación, ejecutaré el código. Se ha ejecutado la
sentencia "print". La mayoría de los módulos que encontrará, en particular los módulos
integrados, no tendrán sentencias "print", y simplemente los cargará el intérprete. Ahora que he
importado el módulo de matemáticas, quiero utilizar una función dentro de él. Elijamos la función
raíz cuadrada, "sqrt". Para ello, escribo las palabras "math.sqrt". Cuando escribo la palabra
matemáticas, seguida por el punto, aparece una lista de funciones en un menú desplegable y
puede seleccionar "sqrt" en esta lista. Pasé 9 como argumento a la función "math.sqrt". Asigno
esto a una variable denominada raíz, y luego lo imprimo.

El número 3, la raíz cuadrada de 9 se imprimió en la terminal, que es la respuesta correcta. En

lugar de importar todo el módulo matemático como hicimos anteriormente, hay una mejor
manera de manejar esto importando directamente la función de raíz cuadrada dentro del ámbito
del proyecto. Esto evitará sobrecargar al intérprete importando todo el módulo matemático. Para

pág. 382
ello, escribo "from math import sqrt". Cuando ejecuto esto, se muestra un error. Ahora quito la
palabra "math" de la declaración de la variable y vuelvo a ejecutar el código.

Esta vez funciona. A continuación, hablemos de algo denominado ALIAS, que es una excelente
forma de importar diferentes módulos. Aquí firmo un alias denominado m al módulo matemático.
Hago esto al escribir "import math" como m. Luego, escribo coseno = m. A continuación,
selecciono cos, C-O-S de la lista de funciones, y agrego el número 0 entre paréntesis. En la
siguiente línea, imprimiré coseno y luego ejecutaré el código.

pág. 383
El resultado es el valor del coseno de 0, que es 1. Esto es posible porque utilicé el alias denominado
m. Si hubiera escrito "math.cos", no hubiera funcionado porque el módulo matemático ahora se
reconoce como m. Permítame eliminar este código de la pantalla y borrar la terminal antes de
continuar. También se puede utilizar un alias para una función importada. Por ejemplo, puedo
escribir desde "math import" factorial como f para aliar con la función factorial. Ahora seno f de
10, escrito como f abro paréntesis, el número 10 y cierro paréntesis a una variable denominada
factorial_10. Voy a imprimir la variable y ver si funciona.

Cuando ejecutamos el código, vemos que funciona bien. Utilizar un alias de esta manera reduce
el esfuerzo de escribir factorial cada vez. Luego de eliminar el alias, puedo importar tantas
funciones como quiera de un módulo determinado. Voy a importar "log" y "sqrt". Creo una
variable utilizando la función "log" para encontrar el valor de log base 10 de 50. Lo hago
escribiendo x = log 10, paréntesis de apertura 50, y paréntesis de cierre. De nuevo, imprimo la
variable en la siguiente línea. Luego hago clic en "Ejecutar", veré si funciona o no. Una vez más, ha
funcionado bien.

pág. 384
Ahora, ¿qué ocurre si quiero importar todas las funciones dentro de un módulo determinado?
Puedo eliminar las funciones que agregué antes y reemplazarlas por un asterisco [*]. Esto
básicamente se traduce en importar todo del módulo de matemáticas.

Cuando ejecuto el código nuevamente, veamos si funciona, y funciona. Sin embargo, este
procedimiento de utilizar un asterisco no es el mejor enfoque en ciertos casos. Por ejemplo, este
es un archivo pequeño y sé que la función log 10 está presente dentro del módulo matemático.
Pero cuando trabajamos con una base de códigos grande, puede ser difícil rastrear de dónde
proviene la función log 10. Además, al importar otros módulos, puede ser confuso. La importación
de paquetes es muy similar a la importación de módulos en Python. Así como puede tener

pág. 385
funciones importadas, también podría importar variables y clases de un módulo determinado.
Ahora, reemplazo el asterisco con una variable denominada al_variable, que puede estar presente
dentro del módulo dado. Déjeme intentar ejecutar el código nuevamente. Dado que el módulo
matemático no tiene tal variable, se produce un error al imprimirlo. El intérprete no puede
importar algunas variables de matemáticas. En este video, conoció diferentes métodos que se
pueden utilizar para importar módulos en Python mediante palabras clave como "import from"
"asterisco" y "as". Esto le permite utilizar la estructura modular de Python en programación
orientada a objetos en general.

pág. 386
Espacio de nombres y ámbito
Ahora debería estar bastante familiarizado con cómo funcionan los módulos. Echemos un vistazo
a otro concepto relacionado en Python, espacios de nombres y ámbitos.

La documentación oficial de Python define espacio de nombres como asignación de los nombres
a los objetos, y el alcance es la región textual de un programa Python donde se puede acceder
directamente al espacio de nombres. En este punto, el diccionario con sus pares de valores clave
sirve como la estructura de datos ideal para el mapeo de nombres y objetos. También aprendió
cómo todo archivo de Python puede ser un módulo. Puede ver el mismo módulo como un lugar
donde Python crea un objeto de módulo. Un objeto módulo contiene los nombres de diferentes
atributos definidos dentro de él. De esta manera, los módulos son un tipo de espacio de nombres.
Los espacios de nombres y los ámbitos pueden llegar a ser muy confusos muy rápidamente y así
es importante para conseguir tanta práctica de alcances como para garantizar un estándar de
calidad.

pág. 387
Existen cuatro tipos principales de ámbitos que se pueden definir en Python: local, cerrado, global
e integrado. La práctica de intentar determinar en qué ámbito una cierta variable pertenece se
conoce como resolución de ámbito.

La resolución del ámbito sigue lo que se conoce comúnmente como la regla LEGB. Vamos a
explorarlo. Local, esto es donde la primera búsqueda de una variable está en el ámbito local.
Cerrado, esto se define dentro de una función cerrada o anidada Global se define en el nivel
superior o simplemente las funciones externas, e integrado, que son las palabras clave presentes
en el módulo integrado. En términos más simples, una variable declarada en el interior de una
función es local, y las que están fuera del ámbito de cualquier función generalmente es global.
Aquí tenemos un ejemplo, las salidas para el código en pantalla muestran el mismo nombre de
variable, griego, en diferentes ámbitos. Existen tres declaraciones posibles de la variable.

pág. 388
A nivel global, dentro de la función "b" o dentro de la función anidada "c", h que se llama desde
"b". La función "id" se utiliza aquí en las sentencias "print", que devuelve la identidad de los
objetos. Puede hacer algunas observaciones de la salida. La "id" para la variable global alfa de la
variable permanece igual, como se define después de que el código se ejecuta completamente. La
"id" para la variable local beta en el interior de la función b permanece sin cambios antes y después
de la ejecución de la función anidada "c". La "id" para gamma solo está asignada dentro del ámbito
de la función anidada.

La "id" para las tres variables es diferente, aunque todas tengan el mismo nombre de variable. Las
variables en Python son declaradas implícitamente cuando las define. Eso significa, a diferencia de
otros lenguajes de programación, que no existe una declaración especial hecha en Python para la
variable que especifica su tipo de datos. Lo que también implica es que una variable dada es local
y no global cuando se declara, a menos que se indique lo contrario. Esto contrasta con la mayoría
de otros lenguajes de programación donde las variables son globales por defecto. Cuando se

pág. 389
declara una variable en un espacio global, también es local para ese espacio. Esto se puede
comprender con un ejemplo sencillo. Si nos fijamos en el contenido de estos dos diccionarios, se
puede ver cómo el valor para la clave "país" es diferente en ambos casos.

También ha utilizado dos funciones especiales integradas denominadas locales y globales que
enumeran el contenido del diccionario en el interior de ambos de estos ámbitos.

Aquí puede ver la salida. En este ejemplo, puede ver que la variable global declarada permanece
sin cambios.

pág. 390
Aunque las variables globales son aceptables, se desaconsejan por una serie de razones. Cuando
trabaja con código de producción, la estructura del proyecto puede ser compleja, y trabajar con
las variables globales puede ser difícil de diagnosticar, lo que lleva a lo que se denomina el código
"spaghetti". Otros paradigmas, como los modificadores de acceso, la concurrencia, y la asignación
de memoria se manejan mejor con variables locales. Al principio del recorrido con Python, siempre
es una buena idea integrar buenas prácticas en su código. Existen dos palabras clave que se
pueden usar para cambiar el ámbito de las variables: "global" y "no local". La palabra clave "global"
nos ayuda a acceder las variables globales desde dentro de la función. No local es un tipo especial
de ámbito definido en Python que se utiliza dentro las funciones anidadas solo en la condición que
se ha definido antes en las funciones cerradas. Ahora puede escribir un fragmento de código que
lo ayudará mejor a entender la idea del ámbito para un atributo. Ya ha creado un archivo
denominado "animalfarm.py". Definirá una función denominada "d" dentro de la que creará otra
función anidada, "e". Vamos a escribir el resto del código. Puede comenzar por definir un par de
variables, que se denominarán "animales". La primera en el interior de la función "d" y la segunda
dentro de la función "e". Tenga en cuenta cómo debe declarar primero la variable dentro de la
función "e" como no local. Ahora agregará algunas sentencias "print" para aclarar desde cuándo
se ven los resultados. Por último, ha llamado la función "e" aquí, y puede agregar una variable
"animal" más fuera de la función "d". Esta será una variable global. Puede agregar una llamada
para la función "d" y una sentencia "print" para la variable global. Puede guardar este archivo y
ejecutar el código. En primer lugar, a la variable global "animal" se le asigna "camello". Entonces
llame a esta función, y una vez dentro de ella, asigne "elefante" al "animal" local. A continuación,

pág. 391
declaramos la función interna "e" e imprimiremos antes de llamar a las funciones "animal" donde
el valor de "animal" será el valor local que es "elefante". Una vez que se encuentre dentro de la
función interna "e", utilice la palabra clave "no local" para declarar que va a utilizar la variable
"animal" y cambia el valor a "jirafa", y aquí puede ver que la sentencia "print" se dará dentro de la
función anidada. El valor es "jirafa", que se mantiene uniforme incluso luego de que salga de la
función interna. Cuando imprima después de la función anidada, el valor permanece como "jirafa".
Una vez que la función se ejecuta en su totalidad, observe que el valor global de "animal" será
"camello" que tuvo asignado al inicio.

Para que pueda ver que los cambios que ha hecho por dentro no afectarán el valor de la variable
global. Veamos una última cosa. Si comenta la variable local, esto generará un error. Se puede ver
que no existe unión presente de un "animal" no local dentro de la función "d" que se requería
aquí.

pág. 392
Tareas de programación: Importar y ámbito
Introducción
Hasta ahora, ha aprendido las diferentes formas en las que puede utilizar las sentencias "import"
para importar otros archivos, módulos y paquetes de Python. También ha visto las diferentes
formas en que puede importar funciones específicas utilizando diferentes formatos de import.
Objetivo
• Utilizar la sentencia "import" para importar un paquete incorporado en Python.
• Utilizar la sentencia "import" para llamar a una función presente en otro archivo de
Python.
Objetivos
• Aprender a utilizar la importación para incluir código externo en el ámbito directo del
proyecto.
Instrucciones:
Paso 1: Abra el archivo jsongenerator.py presente dentro de la carpeta del proyecto.
Paso 2: Importe un paquete integrado denominado json.
Paso 3: Importe lo siguiente de un archivo denominado employee.py:
• Una función denominada details (detalles )
• Variables denominadas employee_name, age and title ( nombre_empleado, edad y título )
Paso 4: Implemente la función create_dict() que devuelve un diccionario dada la información del
empleado.
4.1 Cree y devuelva un diccionario con tres pares clave-valor donde
• las claves son variables de cadena - "nombre", "edad" y "título" y sus respectivos valores
son las variables nombre_empleado, edad y título que hemos importado del módulo de
empleado. Asegúrese de convertir los valores a los tipos esperados.
Paso 5:
Utilice una función denominada "dumps()" del módulo "json" utilizando la notación por puntos y
pásele el diccionario employee_dict que hemos creado. Devuelva su valor a una variable
denominada json_object.
El formato del mismo debe ser el siguiente:

pág. 393
variable = json.dumps(dict)
Paso 6: Complete la función write_json_to_file()
6.1 Utilice una función integrada denominada "open()" y pásele el argumento output_file y "w".
Devuelva el valor de esta función a una variable denominada newfile.
6.2 Llame a una función denominada "write()" sobre esta variable "newfile". Pase la variable
json_object que creó en el paso 5 dentro de ella.
6.3 Cierre este archivo llamando a una función integrada "close()" directamente en un archivo
nuevo. No necesita pasar ningún argumento aquí.
Paso 7: Guarde los archivos.
Paso 8: Abra la terminal para ejecutar los archivos.

Paso 9: Ejecute el código utilizando el comando (dentro del directorio del proyecto)
python3 jsongenerator.py

pág. 394
SOLUCIÓN:
'''
Import statements:
1. Import the built-in json python package
2. From employee.py, import the details function and the employee_name, age, title variables
'''
### WRITE IMPORT STATEMENTS HERE
import json
from employee import details, employee_name, age, title

def create_dict(name, age, title):

""" Creates a dictionary that stores an employee's information

[IMPLEMENT ME]
1. Return a dictionary that maps "first_name" to name, "age" to age, and "title" to title

Args:
name: Name of employee
age: Age of employee
title: Title of employee

Returns:
dict - A dictionary that maps "first_name", "age", and "title" to the
name, age, and title arguments, respectively. Make sure that
the values are typecasted correctly (name - string, age - int,
title - string)
"""
### WRITE SOLUTION HERE
employee_dict = {
"first_name": str(name),
"age": int(age),
"title": str(title)
}
return employee_dict

pág. 395
 raise NotImplementedError()

def write_json_to_file(json_obj, output_file):

""" Write json string to file

Args:
json_obj: json string containing employee information
output_file: the file the json is being written to

[IMPLEMENT ME]
1. Open a new file defined by output_file
2. Write json_obj to the new file

Args:
json_obj: json string containing employee information
output_file: the file the json is being written to
"""
### WRITE SOLUTION HERE
try:
# Open the file in write mode
with open(output_file, "w") as newfile:
# Write the JSON object to the file
newfile.write(json_obj)
print(f"JSON data successfully written to {output_file}")
except Exception as e:
print(f"An error occurred while writing to the file: {e}")

def main():
# Print the contents of details() -- This should print the details of an employee
details()

# Create employee dictionary

employee_dict = create_dict(employee_name, age, title)
print("employee_dict: " + str(employee_dict))

'''
Use a function called dumps from the json module to convert employee_dict
into a json string and store it in a variable called json_object.
'''
### WRITE YOUR CODE BY MODIFYING THE LINE BELOW
# In the line below replace the None keyword with your code.
# The format should look like: variable = json.dumps(dict)

# Convert employee_dict to a json string

json_obj = json.dumps(employee_dict)
print("json_object: " + str(json_obj))

# Write out the json object to file

write_json_to_file(json_obj, "employee.json")

pág. 396
if __name__ == "__main__":
main()

pág. 397
Función "reload()"
En este video, veremos la función de recarga que se utiliza con las sentencias "import". La función
de recarga vuelve a cargar un módulo importado en Python. La única condición previa es que el
argumento que se le pasa debe ser un módulo que ya ha importado con éxito dentro del programa.
Anteriormente, aprendió cómo la sentencia "import" solo es cargada una vez por el intérprete de
Python, pero la función de recarga permite importarla y recargarla varias veces. Lo demostraré.
Primero, creo un archivo nuevo, "sample.py", y agrego una sentencia "print" simple denominada
"Hello world" (Hola mundo). Recuerde que cualquier archivo en Python se puede utilizar como
módulo. Voy a utilizar este archivo dentro de otro nuevo. El archivo nuevo se denomina mediante
"reloads.py". Ahora importo el módulo "sample.py". Puedo agregar la sentencia "import" varias
veces, pero el intérprete solo lo carga una vez. De haber sido recargada, habríamos visto "Hello
world" varias veces.

Sin embargo, lo puedo modificar con ayuda de la función de recarga. Permítame eliminar este
código y agregar el módulo "importLib" donde se encuentra la función de recarga. Luego paso el
nombre del módulo como argumento a esta función. Observe que el módulo de muestra se ha
importado más de una vez y podría hacerlo tantas veces como quisiera.

pág. 398
Ahora, para demostrar mejor cómo se puede utilizar la función de recarga, creo otro archivo
denominado "filechanges.py". Este archivo va a enumerar el contenido de un directorio concreto.
En el siguiente código, actualizaré el contenido del directorio y podré supervisar los cambios
mediante un archivo que importaré. Dado que el intérprete carga el archivo una sola vez, la
función de recarga nos permitirá recargar esa importación y actualizar eficazmente los cambios
cada vez sin detener la ejecución del código en ejecución. Comienzo por importar el módulo
integrado del sistema operativo, y utilizo una función denominada "os.listdir" dentro de ella. A
continuación, paso la ruta actual como argumento haciendo clic con el botón derecho de la
pestaña "Archivos" en la parte superior y seleccionando "Copy path" (Copiar ruta). Lo pego como
argumento para la función "listdir" y agrego una "R" antes de la ruta. Como busco un directorio y
no un archivo, elimino "filechanges.py" de aquí. Veré si la salida de la función "listdir" en una
variable denominada contenido. En la siguiente línea, agrego una función de impresión para la
variable de contenido. Antes de ejecutar el programa, borraré la terminal para aclarar las cosas, el
valor de retorno debe enumerar los archivos presentes en un directorio determinado.

pág. 399
Notará que en la "dirlist" se imprimieron todos los archivos presentes en este directorio.
Ahora vuelvo al "reloads.py" y borro el archivo. A continuación, vuelvo a importar el módulo
"importLib". Luego, importo los cambios del archivo y creo una función denominada "changes"
(cambios). Como ejemplo de buena práctica, agrego un bloque "try" y utilizo la función de recarga
para pasar "filechanges" como argumento. Vuelvo al archivo "filechanges.py" y creo una función
que imprimirá la variable de contenidos.

Esto ya está completo, pero agregaré otra sentencia "print" para mayor claridad. Guardo este
archivo y luego vuelvo a usar "reloads.py". Llamo a esta función que acabo de crear dentro del
módulo "filechanges" y como quiero hacer un trabajo "try-block", agrego "except" y "just pass for"
ahora. A continuación, ejecuto el código mediante un bucle "for". Como quería hacerlo más de
una vez, utilizo la función de rango y llamo a la función que acabo de escribir. Para controlar de

pág. 400
algún modo el programa, agregaré una sentencia "input" aquí. Ahora el programa se ejecutará
cinco veces y cada vez cargará el módulo "file changes" (cambios de archivo) y enumerará el
contenido del directorio.

Para hacerlo más interesante, creo unos archivos de texto dentro del directorio. Ahora volví a
utilizar el archivo "reloads.py" para ejecutar este código. Tenga en cuenta que el contenido del
directorio actual aparece aquí, pero ahora eliminaré el archivo de texto denominado "text3.text".
Cuando vuelvo a ejecutar el código pulsando "Enter" (Intro), notará que se ha eliminado el archivo
de texto concreto. Ahora, sin cambiar nada más, ejecutaré el resto del código. Si también cambio
el contenido de "filechanges.py", por ejemplo, cambiando la sentencia "print" antes de los
nombres de archivo, puedo ver el código reflejado luego de pulsar "Enter" (Intro) de nuevo. Como
he demostrado, la función de recarga se puede utilizar para hacer cambios dinámicos en el código
con la ayuda de las sentencias "import".

pág. 401
Casos de uso del módulo
Hasta ahora ha aprendido sobre módulos, paquetes y bibliotecas en el contexto del uso de
módulos en Python. Los paquetes de terceros en Python son, en la mayoría de los casos, de código
abierto, gratuitos y disponibles para una gran variedad de dominios. Estos recursos amplían la
funcionalidad de los programas de Python más allá de los módulos integrados y son una de las
principales razones por las que Python es popular en la actualidad.
Antes de aprender a instalar y utilizar estos paquetes, veamos brevemente la diferencia entre un
módulo, un paquete y una biblioteca.
Módulos, bibliotecas y paquetes
Los módulos y paquetes se pueden confundir fácilmente debido a sus similitudes, pero existen
algunas diferencias. Los módulos son similares a los archivos, mientras que los paquetes son como
directorios que contienen diferentes archivos. Los módulos generalmente se escriben en un solo
archivo, pero es más una práctica que una definición.
Los paquetes son esencialmente un tipo de módulo. Cualquier módulo que contenga la definición
__path__ es un paquete. Los paquetes, cuando se ven como un directorio, pueden contener
subpaquetes y otros módulos. Por otro lado, los módulos pueden contener clases, funciones y
miembros de datos como cualquier otro archivo Python.
Biblioteca es un término que se utiliza indistintamente con los paquetes importados. Pero en la
práctica general, se refiere a una colección de paquetes.
A pesar de las diferencias entre módulos, paquetes y bibliotecas, puede importar cualquiera de
ellos mediante sentencias "import".
Los complementos de paquetes de terceros de Python se pueden encontrar en el índice de
paquetes de Python. Para instalar paquetes que no forman parte de las bibliotecas estándar, los
programadores utilizan 'pip' (instalador de paquetes para Python). Se instala con Python por
defecto. Para utilizar pip, debe estar familiarizado con la terminal si utiliza una Mac o con la interfaz
de línea de comandos si utiliza Windows.
Como alternativa, también puede utilizar la ventana de terminal presente en su IDE. Cuando utilice
la línea de comandos o la terminal, se debe asegurar de instalar los paquetes en el mismo
intérprete de Python con el que trabaja dentro de su IDE.

pág. 402
Aunque pip suele venir instalado con Python por defecto, puede ser necesario comprobar el
estado de la instalación de pip. Si utiliza una Mac, ejecute el siguiente comando en la terminal:
Python -m ensurepip --upgrade

Si utiliza Windows, ejecute el siguiente comando:

py -m ensurepip --upgrade

Una vez que verifique su instalación, puede instalar los paquetes utilizando pip en su máquina.
El formato estándar para utilizar el comando pip en MacOS es:

python3 -m install pip "SomeProject"

En el caso de Windows, es:

py -m pip install "SomeProject"

Veamos un ejemplo. Si desea instalar un paquete de terceros como "solicitudes", ejecute el

siguiente comando en una Mac:
python3 -m pip install requests

Para Windows ejecutará el siguiente comando:

py -m pip install requests

Nota: los nombres de los paquetes, así como la línea de comandos o la terminal, distinguen entre
mayúsculas y minúsculas.
Una vez que haya instalado el paquete, podrá utilizarlo directamente dentro del código Python.
Esta es una instalación única y el paquete estará presente como parte del intérprete de Python
hasta que decida desinstalarlo.
Los paquetes que puede instalar suelen tener varias clases, funciones, subpaquetes y miembros.
Se pueden entender al utilizar el paquete y buscar ejemplos que otros programadores hayan
publicado en diferentes sitios web. Esto le permitirá comprender mejor qué funciones de ese
paquete necesitan más atención que otras.

pág. 403
Además, también es buena práctica buscar la documentación de los paquetes. En algunos casos,
puede utilizar el sitio web PyPI Índice de Paquetes de Python. En otros casos, las comunidades de
código abierto construyen y mantienen los paquetes y puede encontrar su información en un sitio
web independiente creado para ello o en un sistema de control de versiones como GitHub. En la
actualidad, la documentación en la mayoría de las bibliotecas populares de Python es bastante
elaborada y debe tener buenos ejemplos para comenzar.
Subpaquetes
Si decimos que los paquetes son similares a una carpeta o directorio en nuestro sistema operativo,
entonces el paquete también puede contener otros directorios. Los paquetes, tanto los
incorporados como los definidos por el usuario, pueden contener otras carpetas dentro de ellos a
las que es necesario acceder. Se denominan subpaquetes. La notación de puntos se utiliza para
acceder a los subpaquetes de un paquete que ha importado. Por ejemplo, en un paquete como
"matplotlib", los contenidos más utilizados están presentes dentro del subpaquete "pyplot".
Pyplot puede eventualmente consistir en varias funciones y atributos.
El código para importar un subpaquete es:

import matplotlib.pyplot

Para que sea aún más conveniente, a menudo se importa utilizando un alias. Así que lo más común
es que se encuentre con códigos como:
import matplotlib.pyplot as plt

Podría utilizar cualquier otra palabra como alias en lugar de plt, pero es una convención común.
Puede explorar la estructura de directorios de dichos paquetes normalmente buscando en el
índice de módulos de ese paquete.

pág. 404
Verificación de conocimientos: módulos

pág. 405
Recursos adicionales
Obtenga más información Esta es una lista de recursos que pueden ser útiles a medida que avanza
en el proceso de aprendizaje.
Cómo importar módulos en Python 3 (Digital Ocean)
Importar módulos en Python
Módulos Python (Programiz)
Módulos en Python
Paquetes de Python (Real Python)
Paquetes en Python

pág. 406
PAQUETES, BIBLIOTECAS Y MARCOS POPULARES
Paquetes populares: NumPy, Pandas, Matplotlib, etc.
Los paquetes son colecciones de módulos en Python con un propósito específico. En Python,
existen en la actualidad decenas de miles de paquetes para elegir, y en este video, aprenderá
sobre algunos de los más populares. Puede pensar en esta colección de paquetes como una
biblioteca tradicional del mundo real.

Cada paquete es un libro o una revista, y esta biblioteca crece

todos los días. En programación, un paquete es un directorio o
carpeta, y de la misma manera, un módulo es un archivo o

documento. Puede importar paquetes de la misma manera que los módulos, con la sentencia
"import". Como con la sentencia "import", es importante recordar que a menos que se defina
correctamente, la importación no sirve para nada. Por ejemplo, supongamos que quiere importar
un paquete denominado Wufoo: la sentencia "import" por sí misma no servirá para ningún
propósito. Debe estar en un formato similar a "foo import a" donde "foo" es el paquete y "a" es el
módulo que contiene las funciones que desea.

pág. 407
Al explorar la estructura de directorio de los paquetes o refiriéndose a bloques de código en línea
puede ahorrar tiempo.

Para trabajar con paquetes en Python, es importante saber que PIP es el gestor de paquetes
predeterminado, y Python Package Index, o PyPI, es el índice del paquete donde puede encontrar
paquetes no publicados. Python tiene una extensa colección de paquetes. Como desarrollador
principiante, pueden ser abrumadoras, pero es importante comprender para qué se utiliza más en
la actualidad Python.

pág. 408
Las principales áreas de aplicación para Python son la ciencia de los datos, AI y aprendizaje
automático, marcos web, desarrollo de aplicaciones, automatización e interfaz de hardware.

Con esto en mente, los paquetes se pueden agrupar en categorías. Por ejemplo, paquetes
integrados, ciencia de los datos, aprendizaje automático y AI, y desarrollo de GUI. Analicemos
brevemente cada uno de ellos, comenzando con paquetes integrados.

Estos son paquetes que no es necesario que se instalen por separado y se pueden utilizar en
cuanto instaló Python. Casi todos los proyectos utilizan uno o más de estos paquetes integrados,
así que, vale la pena conocerlos bien. Los más populares son OS, SYS, CSV, JSON, importlib, re,
math e intertools.

pág. 409
En el mundo de la ciencia de los datos, los paquetes Python más populares son NumPy, SCiPy,
NLTK y Pandas. Esto es lo que usamos para la exploración y manipulación de datos. Otros paquetes
como Open CV y matplotlib se utilizan para procesamiento de imágenes y visualización de datos.

Dentro del campo del aprendizaje automático o ML y la inteligencia artificial o AI, los paquetes
más populares son TensorFlow, PyTorch y Keras. PyTorch y Keras son actualmente los más
populares para aprendizaje profundo e implementación de red neuronal.

pág. 410
Existen otros paquetes como SciPy, Scikit-learn y Theano. Elegir qué paquete usar dependerá de
la escala y el alcance del proyecto y cuán familiarizado está con los paquetes.

Hablemos sobre desarrollo web. Python en la actualidad se utiliza principalmente para ML, AI y
desarrollo web. Los paquetes más populares son "flask", un micromarco liviano, y Django, que es
un marco "fullstack".

pág. 411
Otros paquetes populares de desarrollo web incluyen "cherry pie", "pyramid", "beautiful soup", y
"selenium". También existen otros paquetes de robótica, desarrollo de juegos y otros dominios
especializados. Para cualquier dominio en el que quiera trabajar, encontrará varios paquetes
Python relevantes. Aunque ningún paquete sea ideal para sus proyectos, la comunidad de código
abierto de desarrolladores de Python está trabajando sin descanso para resolver este problema.
Cuando comienzo un codificador Python, la mayoría de las funciones que necesita estarán
cubiertas por un paquete. Para continuar expandiendo su conocimiento de los paquetes Python,
debería pensar en un proyecto en el que le gustaría crear un experimento con los paquetes que
he mencionado en este video. En este video, ha aprendido sobre los paquetes en Python. Ha visto
los paquetes integrados y algunos de los paquetes más populares en uso en la actualidad.

pág. 412
Paquetes populares: ejemplos

Cuando hablo de paquetes populares en Python, incluyo tanto las bibliotecas integradas como las
de terceros. Una vez importados dentro del programa, el uso de estos paquetes sigue la misma
estructura y las mismas reglas que el código normal que se encontraría sin la importación. Ya ha
explorado algunos de los nombres de paquetes más populares en los dominios de la ciencia de los
datos, el aprendizaje automático y la Web en los primeros días del curso. A continuación, le
presentamos algunos ejemplos de uso de estos paquetes que lo ayudarán a sentirse cómodo con
la idea.

Antes de utilizar cualquier paquete, el primer código que siempre debe utilizar es la sentencia
import. Esto es así incluso en el caso de los paquetes integrados. Por ejemplo, si desea utilizar el
paquete json, primero agregará una línea como:

import json

Numpy
Si se piensa que ya existe una instalación para el paquete numpy, el código para ello puede ser el
siguiente:

import numpy as np

a = np.zeros(10)
print(a)

b = np.full((2,10), 0,7)
print(b)

c = np.linspace(0,25,7)
print(c)

print(type(c))

La salida del código anterior es:

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[[0.7 0.7 0.7 0.7 0.7 0.7 0.7 0.7 0.7 0.7]
[0.7 0.7 0.7 0.7 0.7 0.7 0.7 0.7 0.7 0.7]]

pág. 413
 [ 0. 4.16666667 8.33333333 12.5 16.66666667 20.83333333 25. ]
<class 'numpy.ndarray'>

• La función zeros() dentro de numpy crea un array con n número de ceros en su interior.
• La función full() crea una matriz bidimensional de dimensiones 2 x 10 que consta solo de
los valores 0.7.
• En el ejemplo, la función linspace() divide los valores entre 0 y 25 en 7 partes iguales. La
matriz resultante está en la salida.
• Finalmente, cuando vea el tipo de datos de c, verá es un tipo de datos especial creado y
utilizado en numpy denominado ndarray. Si prueba la salida para a y b, también será
ndarray. ya que numpy trata exclusivamente con ndarray, que sustituye a las listas y es
mucho más eficiente.
• Estas son algunas de las funciones proporcionadas por numpy.

Pandas
Ahora explorará el uso de otra biblioteca que trabaja estrechamente con numpy y otras
bibliotecas de ciencia de los datos denominadas pandas.

import pandas as pd

a = pd.DataFrame({'Animals': ['Dog','Cat','Lion','Cow','Elephant'],
'Sounds':['Barks','Meow','Roars','Moo','Trumpet']})

print(a)
print(a.describe())

b = pd.DataFrame({
"Letters" : ['a', 'b', 'c', 'd', 'e', 'f'],
"Numbers" : [12, 7, 9, 3, 5, 1] })

print(b.sort_values(by="Numbers"))

b = b.assign(new_values = b['Numbers']*3)
print(b)

pág. 414
Salida:
Animals Sounds
0 Dog Barks
1 Cat Meow
2 Lion Roars
3 Cow Moo
4 Elephant Trumpet

Animals Sounds
count 5 5
unique 5 5
top Dog Barks
freq 1 1

Letters Numbers
5 f 1
3 d 3
4 e 5
1 b 7
2 c 9
0 a 12

Letters Numbers new_values

0 a 12 36
1 b 7 21
2 c 9 27
3 d 3 9
4 e 5 15
5 f 1 3

En las cuatro salidas de este código, creé un DataFrame de pandas en el código anterior
denominado a.
• La primera salida es para el DataFrame denominado a que muestra la salida en un
formato muy sistemático.
• La segunda salida utiliza la función describe() en pandas que dará el conteo, la frecuencia,
los valores superiores y la frecuencia entre otros valores.
• En el segundo DataFrame, b consta de letras y números en orden aleatorio.

pág. 415
 • La tercera salida es una función de ordenación que proporcionará una tabla ordenada
que llevará a barajar las entradas de datos en la tabla.
• Por último, la función assign() toma los valores presentes en tabla, realiza una operación
sobre ellos y crea una nueva variable denominada new_values que luego se agrega a la
tabla.
Pandas, al igual que Numpy, es muy utilizado y tiene una gran variedad de funcionalidades
presentes además de las mencionadas.

NLKT
NLTK, como se ha mencionado anteriormente, es una biblioteca en Python utilizada para el
procesamiento del lenguaje natural. A continuación, presentamos algunas cosas que se pueden
realizar con esta biblioteca.

import nltk

text = "Lorem Ipsum is simply dummy text of the printing and typesetting i
ndustry. Lorem Ipsum has been the industry's standard dummy text ever sinc
e the 1500s, when an unknown printer took a galley of type and scrambled i
t to make a type specimen book."
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords

# Print statement 1
print(word_tokenize(text))
# Print statement 2
print(nltk.tokenize.sent_tokenize(text))

stopwords = stopwords.words("english")
new_text = []
for i in text.split():
if i not in stopwords:
new_text.append(i)

# Print statement 3
print(new_text)

pág. 416
Salida:

['Lorem', 'Ipsum', 'is', 'simply', 'dummy', 'text', 'of', 'the', 'printing', 'and
', 'typesetting', 'industry', '.', 'Lorem', 'Ipsum', 'has', 'been', 'the', 'indus
try', "'s", 'standard', 'dummy', 'text', 'ever', 'since', 'the', '1500s', ',', 'w
hen', 'an', 'unknown', 'printer', 'took', 'a', 'galley', 'of', 'type', 'and', 'sc
rambled', 'it', 'to', 'make', 'a', 'type', 'specimen', 'book', '.']

['Lorem Ipsum is simply dummy text of the printing and typesetting industry.', "L
orem Ipsum has been the industry's standard dummy text ever since the 1500s, when
an unknown printer took a galley of type and scrambled it to make a type specime
n book."]

['Lorem', 'Ipsum', 'simply', 'dummy', 'text', 'printing', 'typesetting', 'industr

y.', 'Lorem', 'Ipsum', "industry's", 'standard', 'dummy', 'text', 'ever', 'since'
, '1500s,', 'unknown', 'printer', 'took', 'galley', 'type', 'scrambled', 'make',
'type', 'specimen', 'book.']

NLTK es una enorme biblioteca y es aconsejable importar todos sus paquetes y subpaquetes. Si
examina el código, se dará cuenta de que sólo se importan las funcionalidades necesarias de los
subpaquetes como corpus y tokenize dentro del código.
• Primero se copia un bloque de texto dentro del bloque de código y se asigna a una
variable denominada texto.
• La primera función utilizada es word_tokenize(). Toma este texto y produce la primera
parte de la salida en la que las palabras están "tokenizadas" o simplemente separadas por
un espacio en blanco. Lo mismo se puede hacer con la función Split() en la cadena, pero
el uso del paquete es mucho más eficiente cuando se trata de bloques de código más
grandes.
• La segunda función sent_tokenize() toma este bloque de texto y lo tokeniza por
"oraciones".
• Para la tercera salida, primero divido el código y elimino lo que se denomina "palabras
vacías". Las palabras vacías son palabras que pueden considerarse redundantes y que
aportan poco valor al realizar el procesamiento del lenguaje natural. Se trata de palabras
como "un", "el", "él". Primero voy a crear una lista de estas palabras vacías y luego las
eliminaré mediante un for loop para formar una nueva lista denominada new_text.
Observará la diferencia al comparar la primera salida y la salida final del código.

pág. 417
Hemos cubierto aquí sólo un par de ejemplos de un par de bibliotecas, aunque existe un
sinnúmero de opciones disponibles con diferentes paquetes en Python. La mejor manera de
aprender es mediante la práctica y la exploración.
Paquetes de análisis de datos
Python es uno de los mejores lenguajes que se pueden utilizar para varios proyectos y aplicaciones
de ciencia de los datos. En este video, aprenderá sobre algunas de las bibliotecas de Python más
utilizadas en análisis de datos y ciencia de los datos.

La última década ha visto un crecimiento exponencial en todas las áreas de ciencia de los datos.
La demanda de análisis de datos y científicos aumentan continuamente, ya que es un requisito
que los desarrolladores incorporen científicos y análisis de los datos en su código. Python se ha
convertido en uno de los los lenguajes más populares entre los científicos de datos. Una de las
principales razones de su popularidad es el gran número de paquetes de código abierto diferentes.
Miles de personas han colaborado en su desarrollo para ofrecer recursos gratuitos y útiles.
Muchos paquetes están mejor valorados porque son eficientes y proporcionan una funcionalidad
excepcional.

pág. 418
Sin ningún orden de preferencia en particular, estos paquetes incluyen NumPy, Scipy, Matplotlib
y Scikit-Learn. Por ejemplo, Scikit-learn se utiliza para el aprendizaje predictivo, y se basa en otros
paquetes populares. Consta de varios algoritmos de aprendizaje automático supervisados y no
supervisados para clasificación, regresión y SVM (Máquinas de Vector Soporte). La modelización
de datos es el principal objetivo de esta biblioteca, que ofrece modelos populares como la
agrupación, la extracción y la selección de características, la validación y la reducción de
dimensionalidad.

Pandas es un acrónimo para el análisis de datos Python, y esta es una herramienta de análisis y
manipulación de datos. Se utiliza principalmente para trabajar con conjuntos de datos y ofrece
funciones para limpiar, analizar y manipular datos. Al utilizarla, puedo comparar diferentes
columnas y encontrar la media aritmética, valores máx. y mín. Las estructuras de datos principales
utilizadas en pandas o series y Dataframes. Mientras que las series o unidimensionales se pueden
comparar con una columna de una tabla, los dataframes son multidimensionales y pueden
potencialmente almacenar tablas de manera eficiente.

pág. 419
Son independientes de los tipos de datos almacenados. Las aplicaciones más comunes de Pandas
son la lectura de archivos CSV y objetos JSON y utilizarlos dentro del código Python para una
recuperación más rápida.

Los pandas son conocidos por aportar velocidad y flexibilidad al análisis de datos. La biblioteca
Pandas normalmente se importa mediante el código "import pandas as pd".

"NumPy" significa "numerical Python" y es una potente biblioteca que forma la base para
bibliotecas como Scikit-learn, Scipy, Ploly y Matplotlib. Los científicos de Python utilizan las
capacidades de NumPy, especialmente cuando se trabaja en dominios científicos como la señal,
el procesamiento de imágenes, la computación estadística y la computación cuántica. NumPy
realiza los cálculos necesarios para áreas algebraicas como las transformadas de Fourier y las
matrices. La estructura troncal de datos en NumPy se denomina matriz ND o matriz N-dimensional,
que sustituye al uso convencional de listas en Python, y es una solución mucho más rápida que las
listas. Las dimensiones en NumPy se denominan ejes y el número de estos ejes se denomina
clasificación.

pág. 420
Convencionalmente, NumPy se importa con "import NumPy as np".

Matplotlib es la biblioteca de visualización que se utiliza en Python. Se puede usar para crear
visualizaciones estáticas, interactivas y animadas. Muchas herramientas de terceros como
"ggplot" y "seaborn" extiende las funciones de "matplotlib". Estas funciones se encuentran dentro
del paquete "stub".

pág. 421
Matplotlib se importa con "import matplotlib.pyplot as plt" Un ejemplo como "libraries to0" utiliza
las bibliotecas "matplotlib" y "NumPy" para, por ejemplo, mostrar una representación gráfica de
los estudiantes en una clase o la distribución de sus calificaciones.

Para resumir lo que ha aprendido en este video, debería saber ahora sobre el análisis de datos de
Python más utilizado y los paquetes de ciencia de los datos.

pág. 422
Aprendizaje automático, aprendizaje profundo e AI: PyTorch, TensorFlow

La Inteligencia Artificial o IA consiste, en general, en hacer que las máquinas piensen como los
humanos. La ciencia de los datos se centra principalmente en el manejo y la exploración de datos
que puede incluir medios como texto, audio, imágenes y video. El aprendizaje automático o Ml es
una subsección de IA y se ocupa de algoritmos para entrenar y generar ideas a partir de los datos.
Muchos campos utilizan el aprendizaje automático. Algunas de las áreas más utilizadas son el
procesamiento del lenguaje natural, el aprendizaje profundo, el análisis de pronósticos, los motores
recomendados, la visión por computadora y el reconocimiento del habla. Con la cantidad de datos
de texto, imagen y video disponibles hoy en día, la ciencia de los datos y la IA en particular tienen
más demanda que nunca. Python es uno de los lenguajes más populares que se utiliza en estos
dominios. Las razones son: ver la eficiencia táctica y legibilidad, la flexibilidad con diferentes
lenguajes, los marcos y sistemas operativos fáciles de usar y la gran comunidad de desarrolladores.
La capacidad para construir modelos de aprendizaje automático sin que tenga que comprender
las particularidades. Y utilizar una herramienta de depuración y prueba, y una estructura modular
fáciles de usar.

Todas estas promoverán el desarrollo de muchas bibliotecas y marcos principalmente de código

abierto. Es importante no confundirse con los términos paquetes, biblioteca y marcos. Un paquete

pág. 423
es una colección de módulos, y tanto la biblioteca como el marco se suelen usar indistintamente
como sinónimos de paquetes. Las bibliotecas también pueden ser una colección de paquetes con
un propósito específico, mientras que el término marco se utiliza generalmente donde se involucra
cierto flujo y arquitectura. Es importante recordar que todas estas piezas de código Python se
utilizan con la ayuda de las sentencias "import". Algunas de las bibliotecas de aprendizaje
automático más populares que se utilizan hoy en día están en las áreas de aprendizaje y redes
neuronales. Visión por computadora y reconocimiento por imagen. Procesamiento del lenguaje
natural, visualización de datos y web scraping.

Es importante comprender que estas son categorías amplias. La mayoría de las bibliotecas
asociadas a ellas no se limitan a un campo concreto. Cada proyecto es único y se debe tratar como
tal. La correcta selección de la biblioteca puede ahorrar un tiempo valioso al codificar.

pág. 424
En este video, ha aprendido sobre bibliotecas de aprendizaje automático. Muchos campos utilizan
el aprendizaje automático y esos campos como el aprendizaje profundo y las redes neuronales se
basan en bibliotecas de aprendizaje automático de código abierto que facilitan el trabajo de los
desarrolladores. Estas bibliotecas son colecciones de paquetes y la selección de la biblioteca
adecuada puede ahorrarle tiempo al codificar. Así que, en el futuro, piense cuidadosamente sobre
qué biblioteca debe elegir para un proyecto para asegurarse de que se adapte a sus necesidades.

pág. 425
Big Data y análisis con Python

Con la llegada de las redes sociales y su amplia aceptación surgió una necesidad sin precedentes
de gestión de datos. Ahora se producen miles de millones de gigabytes de datos todos los días y
gran parte de ellos son generados por los usuarios finales. Las organizaciones vieron el enorme
potencial de aprovechar estos datos utilizando algoritmos predictivos y de aprendizaje automático
para generar información estratégica. Pero antes de enfrentar ese desafío, llegó el reto de
almacenar y manejar de manera eficiente y sistemática los datos de manera que estuvieran
disponibles para un acceso rápido.

Big Data es la gestión de grandes conjuntos de datos, tanto estructurados como no estructurados.
Hoy, esta gran cantidad de datos se almacena en forma de almacenes de datos y lagos de datos,
tanto en servidores como en la nube. Las principales características que se identifican
comúnmente para el uso de herramientas de Big Data son Volumen, Variabilidad y Velocidad.

El volumen es el tamaño de los datos en cuestión y, si es lo suficientemente grande, puede requerir

un manejo diferente al almacenamiento y administración de datos tradicionales.

La Variabilidad o veracidad se refiere a la inconsistencia que puede estar presente en estos datos.
En enormes repositorios de datos, es difícil intervenir manualmente en cada entrada incorrecta y,
por lo tanto, se debe definir y establecer suficiente alcance para la variabilidad mientras se
manejan dichos datos.

La velocidad es la velocidad de manejo de estos datos. Con fuentes de datos como las redes
sociales que están continuamente activas, hay una necesidad de actualizaciones constantes, así
como de almacenamiento sólido. Cuando se necesita procesar, no se debe crear un cuello de
botella en el que la recuperación de datos tarde más. Por eso, la velocidad juega un papel muy
importante en Big Data.

Esta es la capacidad de manejar una gran cantidad de datos heterogéneos con facilidad de acceso
y procesamiento veloz. El siguiente paso en este proceso es cuando se analizan estos datos, lo que
se denomina "análisis de datos". El paso final es publicar estos datos en forma de informes,
visualizaciones y páginas web, según el requisito.

pág. 426
El "pipeline" completo se puede resumir como se indica a continuación:

Secuencia procesal de acciones en big data

Aquí hay varias razones por las que Python ha encontrado un lugar en el dominio del Big Data:

Facilidad de uso: la facilidad de uso es un requisito previo para cualquier tecnología y lenguaje de
gran escala y uso común. Python ayuda a configurar y ejecutar la infraestructura con unas pocas
líneas de código.

Estructura de licencias y naturaleza de código abierto: el paradigma de código abierto ha

experimentado un gran auge en los últimos años. Python proporciona muchas bibliotecas y
marcos de código abierto muy bien desarrollados, incluso para aplicaciones a gran escala. Algunas
organizaciones prefieren esto, ya que disminuye los costos, además de brindar licencias más
fáciles.

Comunidad activa: la comunidad Python hoy en día es vasta y muy solidaria. Esto ayuda a resolver
rápidamente los problemas que puede enfrentar un usuario, y colabora con el desarrollo de
nuevas funciones cuando es necesario.

Bibliotecas: posiblemente la razón más fuerte para la aceptación de Python es el anfitrión de

bibliotecas que brindan soporte directo para Big Data. Además, hay muchos paquetes que también
ayudan a cerrar la brecha entre Python y otros lenguajes y herramientas, lo que permite una rápida
implementación de servicios.

Alta compatibilidad con Hadoop y Spark: Hadoop y su sistema de archivos distribuidos Hadoop es
posiblemente una de las mejores soluciones para almacenamiento a gran escala. El soporte
disponible en Python también ayudó a una mayor aceptación de Python. Lo mismo puede decirse
de Spark, ya que Python tiene bibliotecas de apoyo como PySpark y host de bibliotecas API que
facilitan su uso.

pág. 427
Alta velocidad de procesamiento: Python tiene soporte para la creación de prototipos, y con su
metodología orientada a objetos, el procesamiento en Python es mucho mejor en comparación
con otros lenguajes. Con su aumento en la velocidad, Python también es capaz de proporcionar
una estabilidad adecuada en su uso.

Portabilidad y escalabilidad: como se mencionó anteriormente, el soporte de Python para

plataformas y operaciones multilingües, su facilidad de extensibilidad, varias bibliotecas, soporte
para marcos y API en general, facilita la ampliación y flexibilidad.

Herramientas y bibliotecas de Python: la mayoría de las bibliotecas de Python que se utilizan para
Big Data son muy comunes y están asociadas con las ciencias de los datos y el aprendizaje
automático. Big Data incluye el uso a gran escala y aceptación de bibliotecas como: Numpy,
Pandas, Scikit-learn y Scipy, para nombrar solo algunos.

Además, aquí existen algunas bibliotecas más que son más específicas para un dominio de Big Data
como:

RedShift y S3: los servicios de Amazon se utilizan con sus servicios en la nube. S3 es un servicio de
almacenamiento y RedShift es un servicio de almacenamiento de datos.

BigQuery: desarrollado por Google, BigQuery es una biblioteca de servicios en la nube que es útil
con API RESTful.

PySpark: este es un marco de código abierto utilizado para el procesamiento de datos a gran escala
y funciona con conjuntos de datos distribuidos resilientes.

Kafka: este es un sistema de mensajería apublish-subscribe que recibe registros en forma de

paquetes y se almacena en espacios particionados.

Pydoop: Pydoop proporciona una interfaz entre Hadoop y Python y soporte para manejar sus
sistemas de archivos distribuidos de Hadoop.

pág. 428
¿Cuál considera que es la diferencia entre aprendizaje automático y AI?

Comparta sus ideas sobre este tema con sus compañeros.

En la conversación, considere lo siguiente:

• ¿Qué es Inteligencia Artificial (AI)?

• ¿Qué es aprendizaje automático?

• ¿Cómo están conectados la AI y el aprendizaje automático?

• ¿Cómo trabajan juntos la AI y el aprendizaje automático?

pág. 429
Marcos web de Python

Los marcos web son aplicaciones de software diseñados para proporcionarnos una forma estándar
de construir, desplegar y soportar aplicaciones web que podemos utilizar en la web. Ayudan a los
desarrolladores a enfocarse en la lógica de la aplicación y rutinas automatizando tareas
redundantes, que ayuda a reducir el tiempo de desarrollo. También proporcionan una estructura
fácil y el modelo predeterminado para que sean confiables, estables y fáciles de mantener,
mediante el ahorro de tiempo y esfuerzo. Los marcos web se escriben principalmente en códigos
de alto nivel, lo que elimina la sobrecarga necesaria para comprender conceptos como "sockets",
"threading" y "protocols". Como resultado, el tiempo se gasta mejor al trabajar en la lógica de
aplicación en lugar de rutinas. Python es un marco popular en desarrollo web, gracias a varias
funciones como la buena documentación, abundantes bibliotecas y paquetes, facilidad de
implementación, reutilización de código, un marco seguro e integraciones sencillas. Los diferentes
marcos web en Python son eficientes y hacen que sea fácil manejar tareas como el procesamiento
de formularios, solicitudes de enrutamiento, conexión con bases de datos y autenticación de
usuarios.

También proporcionan depuración y herramientas de prueba para manejar perfiles, cobertura de

prueba, automatización de pruebas, etc. Existen principalmente tres tipos de marcos web en
Python. Son "fullstack", micromarcos y asincrónicos.

pág. 430
Veamos ahora cada uno brevemente. Los marcos "fullstack" se consideran una solución integral y
generalmente incluyen todas las funcionalidades requeridas. Esto puede incluir formar
generaciones y validadores, diseños de plantillas, manejo de solicitudes HTTP, interfaces WSGI
para conexión con servidores web y manejo de conexión de bases de datos. Algunos de los marcos
Python más populares son Django, Web2py y Pyramid.

Los micromarcos son una versión más ligera de los "fullstacks" que no ofrecen muchos patrones y
funcionalidades.

Generalmente se utilizan en proyectos web más pequeños y construcción de API. Flask, Bottle,
Dash, y CherryPy son algunos de los micromarcos populares. Como el nombre sugiere, los tipos de
marco asincrónicos se utilizan para manejar grandes conjuntos de conexiones concurrentes. Se
construyen principalmente mediante bibliotecas de redes de IO asincrónicas. Growler, AIOHTTP,
y Sanic son algunos de los nombres que encontrará. Elegir un marco puede depender de muchos
factores. Esto puede incluir cosas como documentación disponible, escalabilidad, flexibilidad e
integración. Si bien esta categorización es bastante amplia, es importante recordar que cada
marco en Python tiene su propio conjunto único de características y funcionalidades. Esto puede
hacer que ciertos marcos sean más adecuados que otros para un proyecto específico. Dos de los
que más se utilizan son flask y Django. Veamos ahora cada uno brevemente. Django es un marco
de alto nivel que fomenta el diseño limpio y desarrollo rápido. Es un marco "fullstack" con muchas
características y bibliotecas. Es seguro y tiene sistemas de plantillas y soportes de terceros. Es
popular principalmente debido a su rápida velocidad de implementación. Puede crear
rápidamente aplicaciones escalables sin amplio conocimiento de programación de bajo nivel. Flask
es un micromarco y es mejor utilizado para proyectos más pequeños. Es fácil de aprender, fácil de
usar, y como una gran biblioteca de complementos.

pág. 431
En esta lección, aprenderá sobre marcos web y los diferentes tipos. También aprenderá sobre los
diferentes marcos web en Python como Flask y Django.

pág. 432
Comprobación de conocimientos: paquetes, bibliotecas y marcos populares

pág. 433
Recursos adicionales

Los siguientes recursos serán útiles como referencias adicionales para tratar los diferentes
conceptos relacionados con los temas incluidos en este módulo.

• Paquetes populares en Python

• Paquetes populares de Python para el desarrollo web

• Bibliotecas MI e IA en Python

• Bibliotecas de ciencia de los datos en Python

pág. 434
HERRAMIENTAS DE PRUEBA

¿Qué son las pruebas?

Las pruebas son un componente esencial en la garantía de calidad y aseguran que su software,
aplicaciones y sitios web funcionen como se espera. Por ejemplo, supongamos que ha creado su
propio sitio web y cuenta con unos 100 negocios todos los días. Un día un artículo que ha publicado
se vuelve viral, y de repente hay un millón de personas que visitan su sitio y el sitio web se bloquea.
Otro escenario son los formularios en línea.

Todos enfrentamos situaciones en las que llenamos un formulario y aparece un mensaje diciendo
que cometimos un error. Por ejemplo, ingresar accidentalmente letras en el espacio
proporcionado para números de tarjetas de crédito o caracteres especiales y contraseñas
faltantes. Este tipo de validación de datos es aún más crítico, especialmente en los dominios de
los bancos y las finanzas. En este video, aprenderá sobre pruebas y es importante en el ciclo de
vida del desarrollo de software. Pero, ¿qué es exactamente la prueba? Las pruebas de software

pág. 435
son un proceso de evaluación y de verificación de las varias aplicaciones de software y productos
en términos de rendimiento, corrección e integridad.

Ayuda a identificar errores, brechas en el producto, defectos, y los requisitos faltantes con
expectativas establecidas. En los primeros tiempos de las computadoras, los desarrolladores de
software dependían en gran medida de la depuración, un proceso para eliminar y detectar posibles
errores. Luego de la década del 80, el software creció en tamaño, y varios tipos de prueba de
productos también crecieron en paralelo según los requisitos. Las pruebas se realizaron
principalmente en las últimas etapas del ciclo de vida del software. Ahora ha evolucionado para
integrarlo en las etapas tempranas también. La eficiencia de cualquier tipo de prueba depende de
lo bien escrita que esté.

El escenario de prueba ideal es tener las menor cantidad de pruebas escritas para encontrar el
número más grande de defectos. Si bien las pruebas de software son importantes en cualquier

pág. 436
 situación, la prueba real de los productos se produce cuando se lanza al
mercado, allí, lo juzgan las partes interesadas y los usuarios. Vivimos en
era de Internet, los productos con errores, especialmente en las primeras
etapas hacen que los consumidores pierdan interés muy rápido dado que
aparecen varias alternativas. Aquí es donde las pruebas desempeñan un
papel importante. He aquí algunas razones por las que puede ayudar. Las pruebas ayudan a
detectar diseños deficientes, cambiar flujo o funcionalidad ineficientes, abordar los problemas de
escalabilidad, y encontrar vulnerabilidades de seguridad.

Las pruebas ayudan a proporcionar pruebas AB para encontrar los mejores opciones adecuadas,
abordar la compatibilidad con plataformas y dispositivos, ofrecer garantías a las partes
interesadas, y brindar una mejor experiencia a los usuarios finales. Existen algunas buenas
prácticas que se deben seguir en pruebas para lograr resultados óptimos. El código de prueba
permite la reutilización de las pruebas. Las pruebas deben ser rastreables a los requisitos
establecidos. Las pruebas escritas deben basarse en un propósito, ser eficientes y permitir la
repetibilidad. Estas técnicas de prueba pueden luego seguir un enfoque procedimental según el
tipo de prueba utilizada.

pág. 437
 El ciclo de vida de las pruebas en general puede describirse en
términos generales como planeación, preparación, ejecución, y
presentación de informes. Los pasos involucrados para lograr esto
pueden incluir escribir "scripts" y casos de prueba, compilar los
resultados de las pruebas, corregir los defectos basados en ellos,
y generar informes a partir de los resultados de nuestras pruebas.
Ya aprendió sobre los casos de prueba. Son un conjunto general
de acciones que contienen pasos, datos, y condiciones previas y
posteriores escritas para un propósito específico. Este propósito
puede mejorar la funcionalidad, el flujo y encontrar defectos.

Un caso de prueba bien escrito eventualmente proporciona buena cobertura, reutilización, mejor
experiencia del usuario, reducción de costos y aumento de la satisfacción general.

Como la industria tecnológica es cada vez mayor, varias pruebas y categorías, tipos, herramientas,
y los productos han evolucionado y se diseñan para cumplir mejor los requisitos del software en
cuestión. Por ejemplo, una página web tendrá diferentes necesidades de prueba que un juego

pág. 438
basado en Android. Incluso entre las páginas web, por ejemplo, una página de redes sociales
puede diferir digamos, en la gestión financiera. Las pruebas pueden clasificarse en varios factores
diferentes. Por ejemplo, según la cantidad que conocemos sobre la implementación interna,
podemos llamarla prueba de caja negra o caja blanca. También hay muchos tipos de pruebas que
usan práctica. Estas incluyen compatibilidad, ad hoc, utilidad, y pruebas de regresión. No se
preocupe demasiado por estos términos por el momento. Luego, obtendrá más información sobre
esos temas. Por ahora, solo quiero que sepa que, con las pruebas, no hay una única solución para
todo. Al probar productos, también es importante
comprender cuándo detenerse. Nunca habrá una
aplicación 100 % perfecta. De lo contrario, un
desarrollador puede sentir que el producto está bien
probado, pero se da cuenta de que está lleno de errores
y defectos tan pronto como se lanza a los usuarios finales.
Se pueden establecer algunas métricas para este
propósito, dado que existen casos de prueba bien escritos
en su lugar. Estos incluyen un cierto número de ciclos de
pruebas, el porcentaje de casos de prueba, plazos de tiempo, e intervalos de tiempo entre fallas
posteriores de prueba. Las pruebas en el desarrollo de software pueden verse como el ancla de
un barco o seguro para su vehículo. Espera que todo funcione sin problemas, pero muy a menudo
no es así y si bien puede buscar la perfección, siempre existe la posibilidad de errores humanos.

pág. 439
Tipos de pruebas

Hoy en día, la garantía de calidad se ha convertido en un componente importante de los ciclos de

vida de desarrollo de software. Gran parte del crédito se debe al desarrollo de herramientas y
técnicas de prueba. La pregunta es, ¿qué tipo de pruebas se
deben usar? En este video, aprenderá sobre los tipos de
pruebas, incluidos los cuatro niveles principales o categorías
de pruebas que son unidades, integración, sistema y pruebas
de aceptación. Existen diferentes maneras en las que puede
categorizar los diferentes tipos de pruebas. Existen pruebas
de caja blanca y caja negra. La prueba de caja blanca en que
el evaluador conozca el diseño del código y las
funcionalidades. Las pruebas de cajas negras funcionan sin
dicha información y el evaluador no tiene idea sobre la implementación interna. También existen
otras formas de categorizar diferentes pruebas como funcionales, no funcionales, y pruebas de

mantenimiento. Vamos a explorarlo. Las pruebas funcionales se basan en los requisitos del negocio
establecidos. Determinan si las características y las funcionalidades están alineadas con las
expectativas. Las pruebas no funcionales son más complejas de definir e implican métricas como
el rendimiento general y la calidad del producto. Se producen pruebas de mantenimiento cuando
el sistema y su entorno operativo se corrige, cambia o extiende. Pero también existen métodos
manuales y de prueba automatizados que dependen de la escala del software. La categorización
más ampliamente aceptada es en términos de los niveles de pruebas a medida que se avanza en
el ciclo de vida del software. Profundicemos en estos niveles de pruebas.

pág. 440
Los cuatro niveles principales de pruebas son pruebas unitarias o de componentes, pruebas de
integración, pruebas del sistema y pruebas de aceptación. Los cuatro tipos de niveles de prueba
se basan entre sí y tienen un flujo secuencial. Veamos esto ahora.

En pruebas unitarias o de componentes, el programa prueba componentes de individuo específico

aislándolos. Los componentes son de nivel bajo, lo que significa que están más cerca del código
escrito real. A menudo implican el uso de automatización para integración continúa debido a su
tamaño pequeño. Por lo general, escribe estas pruebas mientras escribe el código. Por ejemplo, si
el código está en Python, las pruebas unitarias se pueden escribir con paquetes tales como prueba
pi.

Pruebas de integración, combinan las pruebas unitarias y prueban el flujo de datos de un

componente a otro. La palabra clave aquí es "interface".

pág. 441
Esto significa que prueba si los datos se obtienen correctamente de una base de datos dentro del
código Python, y si lo ha enviado a la página web. Existen diferentes enfoques, como arriba abajo,
abajo arriba y sandwich. Su enfoque depende de las interfaces de nivel de código que intente
primero. Se basa en las pruebas unitarias y un evaluador se ocupa de ello.

A continuación, se realizan pruebas del sistema que evalúan todo el software que probó con los
requisitos del conjunto y expectativas para asegurar la integridad. Esto incluye mediciones de la
ubicación de componentes desplegados, como confiabilidad, rendimiento, seguridad y equilibrio
de carga.

pág. 442
También mide la operabilidad en el ambiente de trabajo, como la plataforma y el sistema
operativo. Esta es la etapa más importante manejada por el equipo de evaluadores. También es la
etapa más crítica, ya que el envío de software a las partes interesadas y el usuario final ocurre
después de esta fase.

El tipo final de prueba es la prueba de aceptación. Cuando el producto llega a esta etapa,
generalmente se considera que está listo para el despliegue. Se espera que esté libre de errores y
que cumpla con los estándares establecidos. Los grupos de interés y los pocos usuarios finales
selectos están involucrados en las pruebas de aceptación.

pág. 443
Normalmente involucra pruebas alfa, beta y de regresión. Una forma de acercarse a esto es dar
situaciones escritas a los usuarios con antelación. Utilice los resultados para realizar mejoras y
tratar de encontrar errores que se perdieron antes. Todos los diferentes niveles de prueba están
diseñados para optimizar el software en en fases diferentes. La clave para realizar pruebas es
realizar pruebas tempranas y con frecuencia. Aunque cada una de las fases de prueba es
importante, la detección temprana ahorra tiempo, esfuerzo y dinero.

pág. 444
A medida que el código se vuelve cada vez más complejo, los errores se vuelven más difíciles de
corregir. No necesariamente significa que las pruebas de la unidad solo se realizarán en el
comienzo y la aceptación en una etapa posterior. Existen muchos ciclos de prueba donde estos
niveles son abordados iterativamente.

Un ejemplo típico es el modelo de desarrollo ágil, aquí lanzamos diferentes versiones del producto
de forma iterativa y realizamos pruebas de aceptación cada cierto número de semanas. En este
video, aprendió algunos de los tipos de pruebas, como pruebas unitarias, pruebas de integración,
pruebas del sistema y pruebas de aceptación. Es importante recordar que el propósito de estos
métodos de prueba es construir un enfoque sistemático para probar e identificar fallas y mejoras
lo antes posible. Esto da como resultado una mejora general desempeño y experiencia. ¡Bien
hecho!

pág. 445
Prueba de nivel

pág. 446
pág. 447
Paquetes de automatización de prueba

Avances en tecnología y los crecientes impulsos hacia la automatización de código. En este video,
aprenderá sobre los paquetes de automatización de prueba y la importancia de las pruebas
automatizadas. En el pasado, las máquinas sustituyeron el esfuerzo humano en la fabricación de
bienes, lo que nos ayuda a ahorrar tanto tiempo como esfuerzo.

En programación, las pruebas elegidas para automatización son las que tienen gran repetibilidad
y volumen, entornos predecibles, y datos y resultados determinantes. Existe un número de tipos
de pruebas que se pueden automatizar. Estos incluyen unidades, regresión e integración. Un
código de prueba ideal debe formar un puente entre los códigos de programación y los casos de
prueba. Python lo logra a la perfección, además de su manera concisa y limpia de codificar. Existen
algunos marcos bien escritos en Python, y algunos son mejor aceptados que otros. Los pasos
ideales para la automatización de pruebas suelen ser preparar el entorno de prueba, ejecutar los
"scripts" de prueba, y analizar los resultados. Examinemos ahora algunos marcos de prueba
importantes de Python que han ido ganando popularidad a lo largo de los años.

pág. 448
Primero, exploraremos el paquete de pruebas integrado por unidad o "unittest". El marco unittest
brinda soporte para la automatización de pruebas, módulos de pruebas independientes e
incorporación de pruebas en colecciones.

La primera es Pytest y la biblioteca nativa de Python que es sencilla, fácil de usar y razonablemente
escalable. Pytest se mostrará más adelante en este curso. Puede manejar varios tipos de pruebas
funcionales como unidad, integración y de extremo a extremo. Existe soporte para pruebas
parametrizadas que nos permite ejecutar pruebas unitarias varias veces con diferentes
parámetros pasados. Puede ejecutar pruebas paralelas y generar HTML, XML o informes de texto
sin formato. También puede integrarlo con otros marcos como Pyunits y Nose, y marcos web como
Flask y Django. Aunque se utiliza principalmente con las API de prueba, también se usa bien con la
UI (interfaz de usuario), conexiones de base de datos y otras aplicaciones Web.

pág. 449
La creación sencilla y las correcciones rápidas de errores justifican que Pytest sea el marco de
pruebas más popular para la automatización.

El siguiente es Robot, que es popular principalmente por sus capacidades de desarrollo basadas
en palabras clave Estas palabras clave se utilizan en casos de prueba y el usuario las puede
predefinir o definir. Robot es muy versátil y se utiliza para pruebas de aceptación, automatización
de procesos robóticos o RPA y desarrollo basado en pruebas. Se puede utilizar para muchos
dominios, incluido Android, APIs y "mainframes".

Selenium es otro marco de pruebas de código abierto que ha ganado popularidad con el tiempo,
y está dirigido principalmente a aplicaciones web. Es compatible con la mayoría de los
navegadores y sistemas operativos. Existen controladores web específicos del navegador que
permiten funciones de prueba como iniciar sesión, pulsar botones y completar formularios.

pág. 450
Permite al conjunto de pruebas seleccionar la velocidad y la ejecución de pruebas y tiene una
opción para ejecutar pruebas específicas o "tests suites". Además de los populares marcos Pytest,
robot y selenio, existen muchos más. Es importante saber que varios de estos marcos de prueba
se suelen utilizar con otras herramientas, como "plug-ins", "widgets", extensiones, corredores de
prueba y controladores.

Estas herramientas
ayudan a integrar las
piezas de software que se
prueban y agregan
funcionalidad. A veces
más de un marco ha
empleado el código que se está probando. En este video ha aprendido sobre paquetes de
automatización de pruebas. Recapitulemos rápidamente.

Las pruebas de
automatización
son una razón
importante por la
que la industria
del software es
capaz de avanzar
con mayor
rapidez y fluidez. Las pruebas manuales proporcionan una atención centrada y la capacidad de
manejar matices y problemas complejos con mayor sofisticación. Este tipo de pruebas no se
pueden reemplazar por pruebas automatizadas todavía. Falta algún tiempo para que las pruebas
puedan automatizarse por completo, pero, el desarrollo de todos estos marcos va en esa
dirección.

pág. 451
Escribir pruebas con PyTest

En este video, demostraré cómo utilizar "py test" para crear pruebas sencillas para pruebas
unitarias.

"PyTest" es uno de los módulos más populares para realizar pruebas unitarias en Python. Esto se
debe a que le permite realizar pruebas simples con un esfuerzo mínimo y también tiene un código
sencillo y limpio con buena documentación. Primero creo un archivo denominado "addition.py".
A continuación, agrego una función y paso dos variables "A" y "B" dentro de ella. Solo voy a hacer
un simple cálculo que devolverá la suma de estas dos variables. Del mismo modo, creo otra función
denominada "sub" que realizará la resta entre las dos variables. Segundo, creo otro archivo
denominado "testedition.py" en el que voy escribir mis casos de prueba. Ahora importo el archivo
que consta de las funciones que se deben probar. A continuación, importo también el módulo "py
test". Luego defino un par de casos de prueba con las funciones de adición y sustracción. Cada
caso de prueba se debe nombrar "testunderscore" y luego el nombre de la función que se va a
probar. En nuestro caso tendremos "testunderscoreadd" y "testunderscoresub". Utilizaré la
palabra clave "assert" dentro de estas funciones porque las pruebas se basan principalmente en
esta palabra clave. Comprueba las condiciones de su código y espera un valor booleano de
verdadero o falso. Cuando el valor devuelto es verdadero, la prueba se supera, cuando es falso, la
prueba falla. Vamos a agregar ciertas sentencias a nuestras pruebas. En nuestra primera prueba
se afirmará que la adición de 4 y 5 es 9. Y en la segunda prueba se afirmará que la resta de 4 - 5 es
-1. A continuación, hago una pantalla dividida para poder ver ambos archivos. Ahora ejecuto la
prueba "py" y especifico el archivo sobre el que voy a hacer la prueba. Para ello, abro una nueva
terminal e introduzco la prueba de Python "dash m py" y el nombre del archivo de prueba "test
edition dot py".

pág. 452
Ejecuté el código y ambas pruebas han sido superadas. Esto significa que se ha confirmado que las
dos sentencias "assert" son verdaderas. 4+5 es 9 y 4-5 es -1. Estos dos puntos después de "test
edition dot py" en la terminal también indican que ambas pruebas han sido superadas. Ahora voy
a hacer que una de estas pruebas falle. Lo hago al cambiar la respuesta -1 a -2. Me aseguro de
haber guardado el archivo, borro mi terminal y vuelvo a ejecutar la prueba. Observe que la primera
prueba se superó, pero la segunda no.

pág. 453
Observe también que ahí había antes dos puntos. Ahora solo hay uno y una "f" para indicar que la
segunda prueba falló. La facilidad al principio de las líneas muestra dónde falló la prueba y
proporciona la posible razón de por qué falló. También puedo escribir estas pruebas sin la
sentencia "assert" y simplemente agregar "pass", con lo que la prueba se supera
independientemente de cualquier error. Cuando vuelvo a ejecutar el código, se indica que ambas
pruebas han sido superadas. Verá que utilicé un operador de igualdad aquí, pero podría haber
utilizado un operador menor que mayor que o palabras clave como "es", "en" o "no". ¿Será que la
sentencia "assert" obtiene un valor booleano?

También puedo agregar varias sentencias "assert" dentro de una única función. Así que, si escribo
"assert true", eso es lo que devuelve el resultado. Y cuando ejecuto el código de nuevo, se superan
ambas pruebas.

pág. 454
Pero si lo hago falso, se mostrará que una prueba ha fallado. Esto indica que todas las sentencias
"assert" dentro de una función dada deben devolver un valor verdadero para que se supere la
prueba. Tenga en cuenta que el uso del prefijo "test underscore" para el nombre del archivo y el
nombre de la función es una buena práctica. Ahora restauraré mi código y guardaré el archivo.

Si quiero ejecutar mi prueba sobre una función específica, solo tengo que agregar dos puntos al
final del nombre del archivo y luego escribir el nombre de la función. Primero borro mi terminal.
Luego ejecuto mi código. Observe que solo se ha ejecutado la función que especifiqué.
Felicitaciones. Ahora conoce sobre funciones simples. En este video aprendió que podía utilizar
"py test" para implementar pruebas unitarias y cómo crear y utilizar pruebas sencillas para las
pruebas unitarias.

pág. 455
Cheat sheet de PyTest

Instalación

Ejecute lo siguiente en la terminal:

pip3 install pytest (Mac)

pip install pytest (Windows)

# Nomenclatura

• Agregue el sufijo 'test_' al archivo que se debe probar.

• Agregue el sufijo 'test_' a las funciones que se van a probar.

Ejecutar pytest

Este es el comando que se debe ejecutar en el indicador de la Terminal:

Python3 -m pytest test_file.py

Método alternativo

py.test buscará la palabra clave "test" y ejecutará las pruebas sobre esos archivos y funciones
automáticamente.

py.test test_file.py

Cuando ejecute pytest para una función específica, agregue :: para ejecutar una función específica
en un archivo determinado.

Banderas utilizadas

Por ejemplo, -v es el marcador:

python3 -m pytest abc.py -v

Otras opciones de indicadores son:

pág. 456
 -v para verbose
-q quiet mode
-s permite que la sentencia print dentro de las funciones se ejecute
-x marca las pruebas para detener la ejecución después de la primera falla
-m se utiliza para marcar una función específica
-k es un indicador de búsqueda y ejecución de pruebas con una palabra clave específica
--tb es para desactivar el código de rastreo de errores
--maxfail n especifica el número máximo de fallas de prueba permitidas

Consejos

• La regla general es que la sentencia "assert" busca un resultado booleano. Puede utilizar
"in, not in, is, <, >, other than ==" para comprobar valores booleanos.

• Puede añadir varias sentencias "assert" dentro de una única función de prueba.

Lectura adicional

"Fixtures"

Los "fixtures" son un tipo de función que se aplica a las funciones que se va a probar. Estas
funciones se deben ejecutar antes de que se ejecute la prueba. El propósito de los "fixtures" es
suministrar datos de varias fuentes, incluidas URL y bases de datos, a la prueba antes de ejecutarla.
Los "fixtures" se utilizan en casos en los que el código repite la inicialización.

Formato:

@pytest.fixture

Marcadores

Los marcadores se utilizan para "marcar" funciones específicas que se van a ejecutar y permitir a
los usuarios crear nombres especiales. Hay muchos marcadores incorporados como xfail, xpass,
skip, etc.

Seguirán un formato como:

@pytest.mark.<markername>

pág. 457
Por ejemplo:

@pytest.mark.alpha

La ejecución de la prueba específica marcada en la línea de comandos se puede realizar con el

siguiente comando:

pytest -m <markername> -v

que será como se muestra a continuación para un marcador denominado alfa:

pytest -m alfa -v

pág. 458
Tareas de programación: Escribir una prueba

Introducción

En este ejercicio, comprobará la precisión de una entrada de cadena a una función dada contra
algunas condiciones. Escribirá dos funciones. La primera función comprobará si la longitud de la
cadena de entrada está dentro de un límite específico de palabras y caracteres. La segunda función
comprobará si la gramática básica de la cadena está bien definida.

Objetivo

• Aprender cómo crear casos de prueba para un bloque de código determinado mediante
PyTest.

Objetivos

• Asegúrese de que las variables de cadena que se pasarán como argumentos al código estén
dentro de una longitud especificada y tengan una estructura bien definida.

Instrucciones

Paso 1: Abra el archivo test_spellcheck.py dentro de la carpeta del proyecto.

Paso 2: Importe pytest y módulo de revisión ortografía.

Paso 3: Comente la variable "beta" usando el símbolo # por ahora.

Paso 4: A continuación, complete las funciones test_length() y test_struc(). Estas dos funciones
utilizan input_value para comprobar si las funciones definidas en la revisión ortográfica se
comportan correctamente.

Paso 5: En la función test_length(), debe agregar dos afirmaciones "assert". En cada sentencia
"assert" primero necesita llamar a la función requerida desde el archivo "spellcheck" (corrector
ortográfico) que importó, y luego verificar con algunas condiciones.

Por ejemplo, el formato será similar a:

assert spellcheck.some_function(input_value) contra alguna condición

pág. 459
 • 5.1 Agregue la primera sentencia "assert" sobre la función word_count() del código
principal que afirma que el valor devuelto es menor que 10.

• 5.2 Agregue la segunda sentencia "assert" sobre la función char_count() del código
principal que afirma que el valor devuelto es menor que 50.

Paso 6: En la segunda función test_struc(), debe agregar dos sentencias "assert". La primera
sentencia "assert" comprueba si el primer caracter está en mayúscula. La segunda sentencia
"assert" comprueba si la oración o la variable de cadena pasada termina con un punto (".")

• 6.1 Agregue la primera sentencia "assert" sobre la función first_char() del código principal.
Ahora llame a una función incorporada isupper () directamente sobre ella, como
function_name.isupper ().

• La función isupper() devuelve Verdadero si se llama sobre un caracter en mayúscula y Falso

si se llama sobre un caracter en minúsculas. Por ejemplo, "A".isupper() devuelve Verdadero
y "a".isupper() devuelve Falso.

• 6.2 Agregue la segunda sentencia "assert" sobre la función last_char() del código principal
y compártala con "."

Paso 7: Guarde los archivos.

Paso 8: Abra la terminal para ejecutar los archivos.

pág. 460
Paso 9: Ejecute el código mediante el siguiente comando (dentro del directorio del proyecto):

• python3 -m pytest test_spellcheck.py

Paso 10: Ambas pruebas deben superarse en este caso.

Paso adicional: Pase la variable "beta" en lugar de "alpha"(alfa) en las cuatro funciones. El
resultado ahora debería mostrar una prueba aprobada y otra fallida.

Consejos

• Los errores comunes cometidos en este proceso pueden ser los siguientes:

• Olvidar importar el archivo pytest y el código principal.

• No pasar los nombres de variables correctamente.

pág. 461
SOLUCION:

### WRITE IMPORT STATEMENTS HERE

#Importamos los modulos
import pytest
import spellcheck

# String variables to be tested

#alpha = "Checking the length & structure of the sentence."
beta = "This sentence should fail the test"

# Do not delete this function. You may change the value assigned to input to test
different inputs to your test functions.
@pytest.fixture
def input_value():
input = alpha
return input

# First test function test_length()

def test_length(input_value):
### WRITE SOLUTION CODE HERE

#Afirmar que el recuento de palabras es inferior a 10

assert spellcheck.word_count(input_value) < 10, "La cadena tiene 10 o más pal
abras"

#Afirmar que el número de caracteres es inferior a 50

assert spellcheck.char_count(input_value) < 50, "La cadena tiene 50 o más car
acteres"

# Second test function test_struc()

def test_struc(input_value):
### WRITE SOLUTION CODE HERE

#Afirmar que el primer carácter está en mayúscula

assert spellcheck.first_char(input_value).isupper(), "El primer caracter no e
stá en mayúscula"

#Afirmar que el último carácter es un punto

assert spellcheck.last_char(input_value) == '.', "La cadena no termina con un
punto"

pág. 462
# Run these tests with `python3 -m pytest test_spellcheck.py`

pág. 463
Desarrollo dirigido por pruebas (TDD)

Las pruebas han sido una entrada relativamente reciente en el ciclo de vida del desarrollo de
software, pero su importancia ha crecido a medida que pasa el tiempo. El desarrollo de software
es sensible al tiempo y en el proceso, los desarrolladores a menudo se encuentran con que las
pruebas se reducen al tiempo que queda tras escribir el código. Esto no deja suficiente tiempo
para probar y puede generar que el software tenga errores que necesitan corregirse con el paso
del tiempo.

El desarrollo dirigido por pruebas o TDD, es una alternativa práctica de programación en la que las
pruebas se escriben primero y el código se escribe para que las pruebas no fallen. Esto difiere de
la convención de escribir primero el código y probar la aplicación progresivamente. El TDD sigue
un enfoque iterativo que comienza con la escritura de los casos de prueba. El trabajo inicial
requiere que el equipo planifique las funciones y las pruebas. Con variaciones pequeñas, vamos a
explorar los pasos estándar. Paso uno, escriba una prueba para una característica que falla. En el
paso dos, escriba código de acuerdo con las pruebas. El paso tres requiere que realice la prueba
con la intención de que falle. En el paso cuatro, se evalúa el error y se refactoriza el código si es
necesario. Por último, en el paso cinco, reinicia el proceso.

pág. 464
Este proceso también se denomina el ciclo de refactorización rojo-verde. El color rojo implica las
pruebas fallidas, y el verde muestra las pruebas aprobadas después de la refactorización. El
objetivo de seguir este ciclo es no superar las pruebas y reescribir hasta que no sea necesario.

Una función está completa cuando todo es verde y ya no necesita volver a ejecutar. Puede utilizar
un paquete bibliotecas como pytest cuando la automatización se convierte en una prioridad.
Pytest solo requiere funciones de escritura mientras que una prueba unitaria requiere clases. Esto
significa que pytest tiene la ventaja de ser más sencillo porque requiere menos esfuerzo.

Bien, ahora vamos a explorar algunas de las ventajas que obtiene del TDD. Las pruebas de escritura
primero y el código de refactorización basado en él, aseguran que la prueba cubra el código. Ahora
puede escribir pruebas con una función específica y el resultado en mente. La necesidad de esta
previsión proporciona claridad desde el principio. La previsión también desempeña una función
en la integración de diferentes componentes donde se agregan nuevas funciones y la interfaz está
en consonancia con los componentes que ya existen. Trabajar en ciclos sobre el código, nos

pág. 465
permite desarrollar una competencia que fácilmente refactoriza en términos de cambios
adicionales.

En general, el código más pequeño con correcciones de errores tempranas, la extensibilidad del
código y la eventual facilidad de depuración son las principales razones por las que el TDD crece y
se acepta.

Finalmente, exploremos brevemente algunas de las diferencias entre el TDD y las pruebas
tradicionales.

La principal diferencia es que, con el TDD, los requisitos y los estándares se destacan desde el
principio, lo que hace que tenga un propósito. El desarrollo moderno diario a menudo emplea una

pág. 466
combinación de ambas formas de prueba, según las diferentes partes del software y etapas del
ciclo de su desarrollo. Existen varios subtipos y variaciones de desarrollo dirigido por pruebas.
Entre ellas figuran las siguientes: dirigidas por el comportamiento, aceptación dirigida por prueba,
escalar y desarrollar un desarrollo dirigido por pruebas.

Estos son todas opciones que se pueden utilizar en el proceso de desarrollo de software.
Felicitaciones, en este video, aprendió sobre el proceso de desarrollo dirigido por pruebas.

pág. 467
Aplicar TDD

En este video, recibirá información sobre cómo aplicar la metodología de desarrollo basada en
pruebas. En las pruebas convencionales, se sigue el proceso de escribir el código y luego escribir
casos de prueba para garantizar la integridad de ese código.

En el desarrollo basado en pruebas o TDD, el enfoque es inverso, y el caso de prueba es donde

debe comenzar a pensar. Los pasos involucrados son los siguientes. Escriba casos de prueba con
alguna funcionalidad en mente. Escriba el código de acuerdo con los casos de prueba
asegurándose de que pasen, y vuelva a factorizar el código en caso de que fallen las pruebas.
Permítame demostrar un ejemplo para diseñar un caso de prueba que comprueba la inscripción
de estudiantes con datos almacenados en una base de datos. La prueba debe comprobar la
integridad de los nombres ingresados. En primer lugar, voy a demostrar cómo diseñar el caso de
prueba, y luego escribo algún código. Digamos que estoy verificando las inscripciones de
estudiantes para un examen en comparación con la lista de nombres que ya tengo. Para no
complicar las cosas, voy a utilizar una lista de Python con nombres en lugar de una base de datos.
Quiero asegurarme de que los nombres que ingreso figuran en la lista. También quiero garantizar
la integridad de los datos, lo que significa que debo estar seguro de que los nombres se ingresan
en el formato correcto. He creado dos archivos. El primero es "test_findstring", que es mi archivo

pág. 468
de prueba, y el segundo "findstring", que es mi archivo principal. Ya tengo instalado el paquete
"pytest", y como se trata de desarrollo basado en pruebas, escribiré mi función de prueba primero.
Comienzo por importar un módulo "curses" que me ayudará a comprobar los caracteres A-S-C-I-I
que están presentes. Luego importo el módulo "pytest", así como el módulo "findstring", que es
mi archivo principal. Defino la función denominada "test_ispresent", y agrego una sentencia
"assert" para comprobar si la función "ispresent" funciona, porque voy a utilizarla para validar mi
entrada de datos. Contrariamente al enfoque convencional de escribir el código, primero escribo
"test_findstring.py", y luego agrego la función de prueba denominada "test_ispresent". De
acuerdo con la prueba, creo otro archivo denominado "findstring.py", en la que escribiré la función
"ispresent". Defino la función denominada "ispresent", y paso un argumento denominado
"person" (persona) en ella. Luego hago una lista de nombres escritos como valores. Después de
eso, creo una condición "if else" simple para comprobar si los argumentos pasados están dentro
de la lista. La función denominada "ispresent" comprobará si el nombre pasado está presente en
la lista.

Voy a probar mi código. Observe que la prueba ha sido superada porque el nombre Al está en la
lista.

pág. 469
Pero esto no garantiza la integridad de las entradas que puedo agregar. Por ejemplo, puedo no,
querer caracteres numéricos en los nombres. Para abordar este problema, Escribo otra función
denominada "test_nodigit" Voy a actualizar algunos de los códigos en mi programa principal,
"findcaden.py", de acuerdo con la prueba recién agregada. Para ello, creo una función
denominada no digit que coincida con mis pruebas. De nuevo, creo una condición "if else" simple.
Ejecuto el código, y notará que se ha superado una de las pruebas y el otra ha fallado. El nombre
"Al" pasa porque está en la lista de nombres. Pero el valor de N7 no pasa porque contiene un
caracter numérico.

pág. 470
También podría agregar más casos de prueba y modificar mi código para que sea adecuado para
los casos de prueba. Puedo repetir el ciclo hasta que no tenga más pruebas fallidas. Felicitaciones.
Ya ha explorado la metodología de desarrollo basada en pruebas.

pág. 471
Resumen del módulo: módulos, paquetes, bibliotecas y herramientas

Ha llegado al final de este módulo en módulos Python, paquetes, bibliotecas y herramientas,

excelente trabajo. Durante este módulo, aprendió que Python es un lenguaje potente que le
permite construir cosas increíbles. Pero puede ganar incluso más funcionalidad con el uso de
módulos, bibliotecas y herramientas. Tal vez recuerde que empezamos con módulos y aprendió
que son los bloques de construcción para agregar funcionalidad a su código, No necesita rehacer
todo continuamente. Luego, exploramos algunas de las bibliotecas de Python más utilizadas en
análisis de datos y ciencia de los datos. Por último, descubrió que probar como herramienta es un
componente esencial en la garantía de calidad y asegura que su software, aplicaciones y sitios web
funcionen como se esperaba. Es momento de recapitular sobre las principales lecciones
aprendidas y la capacitación que obtuvo. Con esto en mente, vamos a resumir los puntos clave
que ha aprendido en este módulo.

Ahora, usted debería poder explicar qué son los módulos en Python y por qué se utilizan.
Identificar los diferentes tipos de módulos y explicar dónde se pueden encontrar. Explicar cómo
acceder a los módulos integrados y definidos por el usuario o en distintas ubicaciones. y utilizar
sentencias "import" para acceder a módulos de diferentes directorios. También debe ser capaz de
crear paquetes del Índice de paquetes de Python mediante "pip", escribir módulos utilizando
sentencias "import", y explicar y utilizar la función "reload" en Python. Ahora ha aprendido que
Python tiene una amplia colección de paquetes, y debería poder describir los casos de uso típicos
del módulo, a diferenciar entre paquetes Python integrados y definidos por el usuario, enumerar

pág. 472
algunos paquetes populares de Python y enumerar algunas bibliotecas comunes de Python
mediante el análisis de datos y la ciencia de los datos. En el módulo, también aprendió sobre
bibliotecas, marcos y pruebas. Por lo tanto, también debería poder reconocer bibliotecas
populares de Python utilizando aprendizaje automático e inteligencia artificial. explicar big data y
análisis con Python, definir marcos web de Python, y enumerar diferentes tipos de marcos web,
describir las pruebas y explicar los diferentes tipos de pruebas, enumerar cuatro niveles principales
o categorías de pruebas, describir paquetes de prueba en Python, como PyTest, Selenio, robot, y
explorar la importancia de las pruebas automatizadas. Ahora debe ser capaz de explicar el
desarrollo dirigido por pruebas, metodología TDD, y enumerar las características del desarrollo
dirigido por pruebas. Este módulo fue una introducción a a los módulos, las bibliotecas y las
herramientas. Este conocimiento le permite ampliar la capacidad de su código de programación.

pág. 473
Preguntas del módulo: módulos, paquetes, bibliotecas y herramientas

pág. 474
pág. 475
Recursos adicionales

Los siguientes recursos serán útiles como referencias adicionales para tratar los diferentes
conceptos relacionados con los temas incluidos en este módulo.

• Desarrollo basado en pruebas

• Desarrollo basado en pruebas con PyTest

• Sitio web oficial de Pytest

• Paquetes de automatización de pruebas en Python

pág. 476
MODULO 5

EVALUACIÓN CALIFICADA DE FINAL DEL CURSO

Ponga en práctica y reflexione sobre las habilidades que ha adquirido en este curso.

Objetivos de aprendizaje

• Sintetizar las habilidades y los conocimientos de este curso sobre el uso de Python

• Reflexionar sobre el contenido de este curso y la trayectoria de aprendizaje futura

pág. 477
EVALUACIÓN CALIFICADA

Resumen del curso: programar en Python

En este curso, le presentaron las bases del desarrollo Python. Hagamos una breve recapitulación
de los temas que tratamos El Módulo 1 se refería a la Introducción a Python.

En este primer módulo aprendió sobre las diferentes formas en que los desarrolladores utilizaron
Python en el mundo real, y descubrió la justificación de la existencia de Python.

Verificó su hardware y software ejecutando Visual Studio Code y llevando a cabo comprobaciones
del entorno del sistema operativo, identificando las dependencias necesarias. Exploró variables y
tipos de datos y trabajó con cadenas de texto y archivos de datos.

pág. 478
Esto lo llevó a la sección de flujo de control y condicionales, donde tiene que utilizar operadores
Python y construir bucles y controles de flujo en su código. En El Módulo 2, pasó a algunas
habilidades básicas de programación con Python, incluidas la exploración de funciones y
estructuras de datos, ámbitos, listas, tuplas, juegos y diccionarios. Con toda esa codificación
creada, era hora de comprobar si existen errores.

Finalizó el Módulo 2 examinando errores, excepciones y manejo de archivos y considerando

enfoques para el manejo de errores.

Casi a la mitad del curso, en El Módulo 3, descubrió todo sobre los paradigmas de funcional y
programación orientada a objetos y conceptos lógicos asociados. También tuvo una introducción
a los algoritmos y a clases e instancias de Python.

pág. 479
Casi al final del curso en El Módulo 4, aprendió cómo podría impulsar su entorno de codificación
mediante el uso de módulos, bibliotecas y herramientas en Python. Además, aprendió sobre los
diferentes tipos de pruebas y cómo escribir una prueba. Felicitaciones por finalizar la
recapitulación de este curso, casi es momento de poner a prueba su conocimiento en una mayor
evaluación. ¿Está listo para mostrar todas sus capacidades de Python?

pág. 480
Acerca de la evaluación calificada de final del curso

El objetivo de la evaluación calificada

El objetivo principal de una evaluación calificada es comprobar que entiende los objetivos clave
de aprendizaje del curso que acaba de completar. Lo más importante es que las evaluaciones
calificadas lo ayudan a establecer qué temas ha dominado y qué temas requieren más atención,
antes de poder completar el curso. En última instancia, la evaluación calificada está diseñada para
ayudarlo a que se asegure de que está preparado para el próximo curso de este programa.
Prepárese para la evaluación calificada Ha encontrado ejercicios, comprobaciones de
conocimientos, preguntas embebidas y otras evaluaciones a medida que avanzaba en el curso.
Todo que esté en la evaluación calificada será algo que ya haya visto, y es por eso que se encuentra
en condiciones de alcanzar el éxito.

Revise la evaluación calificada Revise los comentarios después de realizar la evaluación y, de ser
necesario, vuelva a trabajar en los temas que considere que requieren más atención.

¡Buena suerte!

pág. 481
Evaluación calificada de final del curso: utilizar Python

pág. 482
pág. 483
pág. 484
pág. 485
pág. 486
pág. 487
RESUMEN DEL CURSO

Felicitaciones, ha finalizado Programación en Python

Felicitaciones por haber finalizado el curso de programación y de Python. Ha trabajado duro para
llegar hasta aquí y adquirió muchas competencias importantes durante el curso. Ahora debería
tener una gran base de conocimientos de desarrollo web back-end.

Esta es una visión preliminar para continuar construyendo en el futuro. También ha demostrado
sus competencias en la evaluación calificada. Tras la finalización de este primer curso, deberá
poder: completar la programación básica con Python, distinguir entre programación de
paradigmas de procedimiento, programación funcional y programación orientada a objetos.
Demostrar cómo utilizar módulos, paquetes, y bibliotecas, y cómo trabajar dentro de un entorno
de desarrollo basado en pruebas. ¿Cuáles son los siguientes pasos? Bueno, este es uno de los
cursos del certificado profesional de desarrollador back-end. Aunque ya tiene una buena base,
todavía hay más para aprender. Así que si ha disfrutado este curso y quiere descubrir más, ¿por
qué no se anota en los otros cursos?

pág. 488
A lo largo de cada uno de estos cursos, continuará desarrollando sus habilidades, cuando esté
comenzando como un profesional técnico o estudiante, este proyecto le dará el conocimiento de
prácticas de desarrollo back-end como se utilizan en muchas áreas de negocio como:

Desarrollo web, inteligencia artificial, aprendizaje automático, análisis de datos y muchas otras
aplicaciones. Ha escrito un portafolio de código Python que demostrará sus habilidades a los
posibles empleadores. Esto les muestra a los empleadores que usted es emprendedor e
innovador. También habla mucho de usted como persona y su necesidad de seguir creciendo. Una
vez que haya finalizado todos los cursos de este certificado, recibirá una certificación de Coursera
de desarrollador back-end. Estas certificaciones proporcionan una prueba mundialmente
reconocida y avalada por la industria sobre el dominio de competencias técnicas. Felicitaciones
una vez más por llegar al final de este curso. Ha sido un placer embarcarse en este viaje de
descubrimiento con usted. ¡Mucha suerte! Continúe con su viaje de aprendizaje.

pág. 489
¿Qué es lo que más le ha costado aprender a programar en Python?

¿Qué es lo que más le ha costado aprender a programar en Python?

Comparta su opinión sobre este curso con sus compañeros.

Puede utilizar lo siguiente para guiar la conversación:

• ¿Qué le ha resultado más difícil y por qué?

• Explíqueles a sus compañeros por qué aprender más sobre programación en Python será
una ventaja.

• ¿Sobre qué le gustaría obtener más información?

• ¿Qué temas le han parecido interesantes y por qué?

Lo más difícil que me ha resultado ha sido la estructuración de las funciones y como se llaman las
variables para que sean leídas. El aprendizaje se debe profundizar y tomarle el control en la codificación.
Me gustaría obtener más información sobre cómo llevar un programa, una aplicación web o un juego
desde el comienzo hasta su puesta en marcha. Me gusta mucho el tema de pruebas y desarrollo web,
he queridos implementarlas en mi mundo real.

pág. 490
Próximos pasos después de programar en Python

¡Felicitaciones! Ha completado este curso y ha dado otro paso para mejorar sus conocimientos,
habilidades y calificaciones.

En el siguiente curso, aprenderá sobre el control de versiones. El control de versiones es un

sistema que registra todos los cambios y las modificaciones de los archivos con fines de
seguimiento. En el siguiente curso, aprenderá los principales objetivos y ventajas del control de
versiones. También descubrirá cómo colaboran los ingenieros de Meta en proyectos de la vida real
y aprenderá a trabajar con un historial de revisiones de código y a experimentar cómo utilizan los
desarrolladores el control de versiones para resolver conflictos. Por último, explorará el concepto
de colaboración en software centrándose en el control de versiones mediante GitHub, donde
creará un repositorio con bifurcación.

Asegúrese de tomar el siguiente curso. Es su oportunidad de profundizar en el mundo del

desarrollo de software.

pág. 491
APENDICE
Ejemplos de programas con pruebas de escritorio

Ejemplo 1: Factorial

Código:

def factorial(n):
if n == 0 or n == 1: # Caso base
return 1
else:
return n * factorial(n - 1) # Caso recursivo

print(factorial(5)) # 120

Prueba de Escritorio:

| Llamada | `n` | `n == 0 or n == 1` | Valor devuelto |

|-----------------|-----|------------------------|-------------------------|
| `factorial(5)`| 5 | False | `5 * factorial(4)` |
| `factorial(4)`| 4 | False | `4 * factorial(3)` |
| `factorial(3)`| 3 | False | `3 * factorial(2)` |
| `factorial(2)`| 2 | False | `2 * factorial(1)` |
| `factorial(1)`| 1 | True | `1` |

Explicación:
1. `factorial(5)` llama a `factorial(4)`.
2. `factorial(4)` llama a `factorial(3)`.
3. `factorial(3)` llama a `factorial(2)`.
4. `factorial(2)` llama a `factorial(1)`.
5. `factorial(1)` devuelve `1` (caso base).
6. Luego, se resuelven las multiplicaciones hacia atrás:
- `2 * 1 = 2`
- `3 * 2 = 6`
- `4 * 6 = 24`
- `5 * 24 = 120`.

pág. 492
Ejemplo 2: Fibonacci

Código:

def fibonacci(n):
if n == 0: # Caso base
return 0
elif n == 1: # Caso base
return 1
else:
return fibonacci(n - 1) + fibonacci(n - 2) # Caso recursivo

print(fibonacci(6)) # 8

Prueba de Escritorio:

| Llamada | `n` | `n == 0` | `n == 1` | Valor devuelto |

|-------------------|-----|-----------|------------|-------------------------------------|
| `fibonacci(6)` | 6 | False | False | `fibonacci(5) + fibonacci(4)` |
| `fibonacci(5)` | 5 | False | False | `fibonacci(4) + fibonacci(3)` |
| `fibonacci(4)` | 4 | False | False | `fibonacci(3) + fibonacci(2)` |
| `fibonacci(3)` | 3 | False | False | `fibonacci(2) + fibonacci(1)` |
| `fibonacci(2)` | 2 | False | False | `fibonacci(1) + fibonacci(0)` |
| `fibonacci(1)` | 1 | False | True | `1` |
| `fibonacci(0)` | 0 | True | False | `0` |

Explicación:
1. `fibonacci(6)` llama a `fibonacci(5)` y `fibonacci(4)`.
2. `fibonacci(5)` llama a `fibonacci(4)` y `fibonacci(3)`.
3. `fibonacci(4)` llama a `fibonacci(3)` y `fibonacci(2)`.
4. `fibonacci(3)` llama a `fibonacci(2)` y `fibonacci(1)`.
5. `fibonacci(2)` llama a `fibonacci(1)` y `fibonacci(0)`.
6. `fibonacci(1)` devuelve `1` y `fibonacci(0)` devuelve `0`.
7. Luego, se resuelven las sumas hacia atrás:
- `fibonacci(2) = 1 + 0 = 1`
- `fibonacci(3) = 1 + 1 = 2`
- `fibonacci(4) = 2 + 1 = 3`
- `fibonacci(5) = 3 + 2 = 5`
- `fibonacci(6) = 5 + 3 = 8`.

pág. 493
Ejemplo 3: Suma de una lista

Código:

def suma_lista(lista):
if not lista: # Caso base: lista vacía
return 0
else:
return lista[0] + suma_lista(lista[1:]) # Caso recursivo

print(suma_lista([1, 2, 3, 4])) # 10

Prueba de Escritorio:

| Llamada | `lista` | `not lista` | Valor devuelto |

|--------------------------------|---------------|--------------|-----------------------------------|
| `suma_lista([1, 2, 3, 4])` | [1, 2, 3, 4] | False | `1 + suma_lista([2, 3, 4])` |
| `suma_lista([2, 3, 4])` | [2, 3, 4] | False | `2 + suma_lista([3, 4])` |
| `suma_lista([3, 4])` | [3, 4] | False | `3 + suma_lista([4])` |
| `suma_lista([4])` | [4] | False | `4 + suma_lista([])` |
| `suma_lista([])` | [] | True | `0` |

Explicación:
1. `suma_lista([1, 2, 3, 4])` llama a `suma_lista([2, 3, 4])`.
2. `suma_lista([2, 3, 4])` llama a `suma_lista([3, 4])`.
3. `suma_lista([3, 4])` llama a `suma_lista([4])`.
4. `suma_lista([4])` llama a `suma_lista([])`.
5. `suma_lista([])` devuelve `0` (caso base).
6. Luego, se resuelven las sumas hacia atrás:
- `4 + 0 = 4`
- `3 + 4 = 7`
- `2 + 7 = 9`
- `1 + 9 = 10`.

pág. 494
Ejemplo 4: Invertir una cadena

Código:

def invertir_cadena(cadena):
if len(cadena) == 0: # Caso base
return cadena
else:
return invertir_cadena(cadena[1:]) + cadena[0] # Caso recursivo

print(invertir_cadena("hola")) # "aloh"

Prueba de Escritorio:

| Llamada | `cadena` | `len(cadena) == 0` | Valor devuelto |

|-----------------------------------|-------------|--------------------------|--------------------------------------|
| `invertir_cadena("hola")` | "hola" | False | `invertir_cadena("ola") + "h"`|
| `invertir_cadena("ola")` | "ola" | False | `invertir_cadena("la") + "o"` |
| `invertir_cadena("la")` | "la" | False | `invertir_cadena("a") + "l"` |
| `invertir_cadena("a")` | "a" | False | `invertir_cadena("") + "a"` |
| `invertir_cadena("")` | "" | True | `""` |

Explicación:
1. `invertir_cadena("hola")` llama a `invertir_cadena("ola")`.
2. `invertir_cadena("ola")` llama a `invertir_cadena("la")`.
3. `invertir_cadena("la")` llama a `invertir_cadena("a")`.
4. `invertir_cadena("a")` llama a `invertir_cadena("")`.
5. `invertir_cadena("")` devuelve `""` (caso base).
6. Luego, se concatenan los caracteres hacia atrás:
- `"" + "a" = "a"`
- `"a" + "l" = "al"`
- `"al" + "o" = "alo"`
- `"alo" + "h" = "aloh"`.

pág. 495
Ejemplo 5: Potencia de un número

Código:

def potencia(base, exponente):

if exponente == 0: # Caso base
return 1
else:
return base * potencia(base, exponente - 1) # Caso recursivo

print(potencia(2, 3)) # 8

Prueba de Escritorio:

| Llamada | `base` | `exponente` | `exponente == 0` | Valor devuelto |

|-----------------------|---------|------------------|-----------------------|---------------------------|
| `potencia(2, 3)` | 2 |3 | False | `2 * potencia(2, 2)` |
| `potencia(2, 2)` | 2 |2 | False | `2 * potencia(2, 1)` |
| `potencia(2, 1)` | 2 |1 | False | `2 * potencia(2, 0)` |
| `potencia(2, 0)` | 2 | | True | `1` |

Explicación:
1. `potencia(2, 3)` llama a `potencia(2, 2)`.
2. `potencia(2, 2)` llama a `potencia(2, 1)`.
3. `potencia(2, 1)` llama a `potencia(2, 0)`.
4. `potencia(2, 0)` devuelve `1` (caso base).
5. Luego, se resuelven las multiplicaciones hacia atrás:
- `2 * 1 = 2`
- `2 * 2 = 4`
- `2 * 4 = 8`.

pág. 496
Ejemplo 6: Contar elementos en una lista

Código:

def contar_elementos(lista):
if not lista: # Caso base: lista vacía
return 0
else:
return 1 + contar_elementos(lista[1:]) # Caso recursivo

print(contar_elementos([1, 2, 3, 4])) # 4

Prueba de Escritorio:

| Llamada | `lista` | `not lista` | Valor devuelto |

|------------------------------------------|--------------|-------------|--------------------------------------------|
| `contar_elementos([1, 2, 3, 4])`| [1, 2, 3, 4] | False | `1 + contar_elementos([2, 3, 4])` |
| `contar_elementos([2, 3, 4])` | [2, 3, 4] | False | `1 + contar_elementos([3, 4])` |
| `contar_elementos([3, 4])` | [3, 4] | False | `1 + contar_elementos([4])` |
| `contar_elementos([4])` | [4] | False | `1 + contar_elementos([])` |
| `contar_elementos([])` | [] | True | `0` |

Explicación:
1. `contar_elementos([1, 2, 3, 4])` llama a `contar_elementos([2, 3, 4])`.
2. `contar_elementos([2, 3, 4])` llama a `contar_elementos([3, 4])`.
3. `contar_elementos([3, 4])` llama a `contar_elementos([4])`.
4. `contar_elementos([4])` llama a `contar_elementos([])`.
5. `contar_elementos([])` devuelve `0` (caso base).
6. Luego, se resuelven las sumas hacia atrás:
- `1 + 0 = 1`
- `1 + 1 = 2`
- `1 + 2 = 3`
- `1 + 3 = 4`.

pág. 497
Ejemplo 7: Máximo común divisor (MCD)

Código:

def mcd(a, b):

if b == 0: # Caso base
return a
else:
return mcd(b, a % b) # Caso recursivo

print(mcd(48, 18)) # 6

Prueba de Escritorio:

| Llamada | `a` | `b` | `b == 0` | Valor devuelto |

|-------------------|------|-----|-----------|--------------------------|
| `mcd(48, 18)` | 48 | 18 | False | `mcd(18, 48 % 18)`|
| `mcd(18, 12)` | 18 | 12 | False | `mcd(12, 18 % 12)`|
| `mcd(12, 6)` | 12 | 6 | False | `mcd(6, 12 % 6)` |
| `mcd(6, 0)` | 6 | 0 | True | `6` |

Explicación:
1. `mcd(48, 18)` llama a `mcd(18, 12)`.
2. `mcd(18, 12)` llama a `mcd(12, 6)`.
3. `mcd(12, 6)` llama a `mcd(6, 0)`.
4. `mcd(6, 0)` devuelve `6` (caso base).

pág. 498
Ejemplo 8: Búsqueda binaria recursiva

Código:

def busqueda_binaria(lista, objetivo, inicio=0, fin=None):

if fin is None:
fin = len(lista) - 1
if inicio > fin: # Caso base: elemento no encontrado
return -1
medio = (inicio + fin) // 2
if lista[medio] == objetivo: # Caso base: elemento encontrado
return medio
elif lista[medio] < objetivo:
return busqueda_binaria(lista, objetivo, medio + 1, fin) # Buscar en la mitad derecha
else:
return busqueda_binaria(lista, objetivo, inicio, medio - 1) # Buscar en la mitad izquierda

lista = [1, 3, 5, 7, 9]
print(busqueda_binaria(lista, 7)) # 3

Prueba de Escritorio:

| Llamada | `lista` | `objetivo` | `inicio` | `fin` | `medio` | `lista[medio]` | Valor

devuelto |
|-------------------------------------------------|-----------------|--------------|-----------|------|------------|-------------------|-------------
------------------------|
| `busqueda_binaria([1, 3, 5, 7, 9], 7)` | [1, 3, 5, 7, 9]| 7 |0 |4 |2 |5 |
`busqueda_binaria(lista, 7, 3, 4)` |
| `busqueda_binaria(lista, 7, 3, 4)` | [1, 3, 5, 7, 9]| 7 |3 |4 |3 |7 | `3`
|

Explicación:
1. `busqueda_binaria([1, 3, 5, 7, 9], 7)` calcula `medio = 2` y compara `lista[2] = 5` con `7`.
2. Como `5 < 7`, busca en la mitad derecha: `busqueda_binaria(lista, 7, 3, 4)`.
3. `busqueda_binaria(lista, 7, 3, 4)` calcula `medio = 3` y compara `lista[3] = 7` con `7`.
4. Como `7 == 7`, devuelve `3` (índice del elemento encontrado).

pág. 499
Ejemplo 9: Torres de Hanoi

Código:

def hanoi(n, origen, destino, auxiliar):

if n == 1: # Caso base
print(f"Mover disco 1 de {origen} a {destino}")
else:
hanoi(n - 1, origen, auxiliar, destino) # Mover n-1 discos a la torre auxiliar
print(f"Mover disco {n} de {origen} a {destino}")
hanoi(n - 1, auxiliar, destino, origen) # Mover n-1 discos a la torre destino

hanoi(3, 'A', 'C', 'B')

Prueba de Escritorio:

| Llamada | `n` | `origen` | `destino` | `auxiliar` | Acción realizada |

|----------------------------------|-----|------------|-------------|------------|------------------------------------------------|
| `hanoi(3, 'A', 'C', 'B')` |3 |A |C |B | Llama a `hanoi(2, 'A', 'B', 'C')` |
| `hanoi(2, 'A', 'B', 'C')` |2 |A |B |C | Llama a `hanoi(1, 'A', 'C', 'B')` |
| `hanoi(1, 'A', 'C', 'B')` |1 |A |C |B | Imprime "Mover disco 1 de A a C" |
| `hanoi(2, 'A', 'B', 'C')` |2 |A |B |C | Imprime "Mover disco 2 de A a B" |
| `hanoi(1, 'C', 'B', 'A')` |1 |C |B |A | Imprime "Mover disco 1 de C a B" |
| `hanoi(3, 'A', 'C', 'B')` |3 |A |C |B | Imprime "Mover disco 3 de A a C" |
| `hanoi(2, 'B', 'C', 'A')` |2 |B |C |A | Llama a `hanoi(1, 'B', 'A', 'C')` |
| `hanoi(1, 'B', 'A', 'C')` |1 |B |A |C | Imprime "Mover disco 1 de B a A" |
| `hanoi(2, 'B', 'C', 'A')` |2 |B |C |A | Imprime "Mover disco 2 de B a C" |
| `hanoi(1, 'A', 'C', 'B')` |1 |A |C |B | Imprime "Mover disco 1 de A a C" |

Explicación:
1. El problema de las Torres de Hanoi se resuelve moviendo `n-1` discos a la torre auxiliar, luego moviendo el disco
más grande a la torre destino, y finalmente moviendo los `n-1` discos a la torre destino.
2. Cada llamada recursiva reduce el problema a un caso más pequeño hasta llegar al caso base (`n = 1`).

pág. 500
Ejemplo 10: Generar combinaciones de una lista

Código:

def combinaciones(lista, k):

if k == 0: # Caso base
return [[]]
if not lista: # Caso base
return []
cabeza = lista[0]
cola = lista[1:]
return combinaciones(cola, k) + [[cabeza] + comb for comb in combinaciones(cola, k - 1)]

print(combinaciones([1, 2, 3], 2)) # [[2, 3], [1, 3], [1, 2]]

Prueba de Escritorio:

| Llamada | `lista` | `k` | `k == 0` | `not lista` | Valor devuelto |

|-------------------------------------|------------|-----|----------|---------------|---------------------------------------------------------------------------------
--------------------|
| `combinaciones([1, 2, 3], 2)`| [1, 2, 3] | 2 | False | False | `combinaciones([2, 3], 2) + [[1] + comb for comb in
combinaciones([2, 3], 1)]`|
| `combinaciones([2, 3], 2)` | [2, 3] | 2 | False | False | `combinaciones([3], 2) + [[2] + comb for comb in combinaciones([3],
1)]` |
| `combinaciones([3], 2)` | [3] | 2 | False | False | `combinaciones([], 2) + [[3] + comb for comb in combinaciones([],
1)]` |
| `combinaciones([], 2)` | [] | 2 | False | True | `[]` |
| `combinaciones([3], 1)` | [3] | 1 | False | False | `combinaciones([], 1) + [[3] + comb for comb in combinaciones([],
0)]` |
| `combinaciones([], 1)` | [] | 1 | False | True | `[]` |
| `combinaciones([], 0)` | [] | 0 | True | True | `[[]]` |

Explicación:
1. `combinaciones([1, 2, 3], 2)` genera combinaciones que incluyen el primer elemento (`1`) y combinaciones que no
lo incluyen.
2. Las combinaciones que no incluyen `1` son `combinaciones([2, 3], 2)`.
3. Las combinaciones que incluyen `1` son `[[1] + comb for comb in combinaciones([2, 3], 1)]`.
4. Este proceso se repite recursivamente hasta llegar a los casos base.

pág. 501
Ejemplo 11: Recorrer un árbol binario

Código:

class Nodo:
def __init__(self, valor):
self.valor = valor
self.izquierda = None
self.derecha = None

def recorrer_arbol(nodo):
if nodo is None: # Caso base
return
print(nodo.valor) # Visitar el nodo
recorrer_arbol(nodo.izquierda) # Recorrer subárbol izquierdo
recorrer_arbol(nodo.derecha) # Recorrer subárbol derecho

# Crear un árbol binario

raiz = Nodo(1)
raiz.izquierda = Nodo(2)
raiz.derecha = Nodo(3)
raiz.izquierda.izquierda = Nodo(4)
raiz.izquierda.derecha = Nodo(5)

recorrer_arbol(raiz)

Prueba de Escritorio:

| Llamada | `nodo` | `nodo is None` | Acción realizada |

|-------------------------------------|-----------|--------------------|--------------------------------------------------------------|
| `recorrer_arbol(raiz)` | Nodo(1)| False | Imprime `1`, llama a `recorrer_arbol(Nodo(2))` |
| `recorrer_arbol(Nodo(2))` | Nodo(2)| False | Imprime `2`, llama a `recorrer_arbol(Nodo(4))`|
| `recorrer_arbol(Nodo(4))` | Nodo(4)| False | Imprime `4`, llama a `recorrer_arbol(None)` |
| `recorrer_arbol(None)` | None | True | Retorna |
| `recorrer_arbol(Nodo(2))` | Nodo(2)| False | Llama a `recorrer_arbol(Nodo(5))` |
| `recorrer_arbol(Nodo(5))` | Nodo(5)| False | Imprime `5`, llama a `recorrer_arbol(None)` |
| `recorrer_arbol(None)` | None | True | Retorna |
| `recorrer_arbol(raiz)` | Nodo(1)| False | Llama a `recorrer_arbol(Nodo(3))` |
| `recorrer_arbol(Nodo(3))` | Nodo(3)| False | Imprime `3`, llama a `recorrer_arbol(None)` |
| `recorrer_arbol(None)` | None | True | Retorna |

Explicación:
1. El recorrido en profundidad (preorden) visita el nodo actual, luego el subárbol izquierdo y finalmente el subárbol
derecho.
2. Cada llamada recursiva procesa un nodo y sus hijos hasta llegar a los nodos hoja (`None`).

pág. 502
Ejemplo 12: Palíndromo recursivo

Código:

def es_palindromo(cadena):
if len(cadena) <= 1: # Caso base
return True
else:
return cadena[0] == cadena[-1] and es_palindromo(cadena[1:-1]) # Caso recursivo

print(es_palindromo("anilina")) # True

Prueba de Escritorio:

| Llamada | `cadena` | `len(cadena) <= 1` | `cadena[0] == cadena[-1]` | Valor devuelto |

|------------------------------------|--------------|-------------------------|------------------------------------|----------------------------------
------------|
| `es_palindromo("anilina")` | "anilina" | False | 'a' == 'a' | `True and es_palindromo("nilin")`
|
| `es_palindromo("nilin")` | "nilin" | False | 'n' == 'n' | `True and es_palindromo("ili")`
|
| `es_palindromo("ili")` | "ili" | False | 'i' == 'i' | `True and es_palindromo("l")`
|
| `es_palindromo("l")` | "l" | True |- | `True` |

Explicación:
1. `es_palindromo("anilina")` compara el primer y último carácter (`'a' == 'a'`).
2. Luego, llama a `es_palindromo("nilin")`.
3. Este proceso se repite hasta que la cadena tiene longitud 1 o menos, momento en el que se devuelve `True`.

pág. 503
Ejemplo 13: Multiplicación recursiva

Código:

def multiplicar(a, b):

if b == 0: # Caso base
return 0
else:
return a + multiplicar(a, b - 1) # Caso recursivo

print(multiplicar(5, 3)) # 15

Prueba de Escritorio:

| Llamada | `a` | `b` | `b == 0` | Valor devuelto |

|----------------------------------|-----|-----|-----------|----------------------------|
| `multiplicar(5, 3)` | 5 | 3 | False | `5 + multiplicar(5, 2)`|
| `multiplicar(5, 2)` | 5 | 2 | False | `5 + multiplicar(5, 1)`|
| `multiplicar(5, 1)` | 5 | 1 | False | `5 + multiplicar(5, 0)`|
| `multiplicar(5, 0)` | 5 | 0 | True | `0` |

Explicación:
1. `multiplicar(5, 3)` suma `5` tres veces: `5 + 5 + 5 = 15`.
2. Cada llamada recursiva reduce `b` en 1 hasta llegar al caso base (`b == 0`).

pág. 504
Ejemplo 14: Convertir número a binario

Código:

def a_binario(n):
if n == 0: # Caso base
return ""
else:
return a_binario(n // 2) + str(n % 2) # Caso recursivo

print(a_binario(10)) # "1010"

Prueba de Escritorio:

| Llamada | `n` | `n == 0` | Valor devuelto |

|--------------------- |-----|--------------- |--------------------------------- |
| `a_binario(10)` | 10 | False | `a_binario(5) + "0"` |
| `a_binario(5)` | 5 | False | `a_binario(2) + "1"` |
| `a_binario(2)` | 2 | False | `a_binario(1) + "0"` |
| `a_binario(1)` | 1 | False | `a_binario(0) + "1"` |
| `a_binario(0)` | 0 | True | `""` |

Explicación:
1. `a_binario(10)` divide `n` por 2 y concatena el residuo (`n % 2`).
2. Este proceso se repite hasta que `n` es 0.
3. Luego, se concatenan los residuos en orden inverso: `"1010"`.

pág. 505
Ejemplo 15: Encontrar el mínimo en una lista

Código:

def minimo(lista):
if len(lista) == 1: # Caso base
return lista[0]
else:
return min(lista[0], minimo(lista[1:])) # Caso recursivo

print(minimo([3, 1, 4, 1, 5, 9, 2])) # 1

Prueba de Escritorio:

| Llamada | `lista` | `len(lista) == 1` | Valor devuelto |

|-------------------------------------------- |--------------------------------- |----------------------|---------------------------------------------|
| `minimo([3, 1, 4, 1, 5, 9, 2])` | [3, 1, 4, 1, 5, 9, 2] | False | `min(3, minimo([1, 4, 1, 5, 9, 2]))` |
| `minimo([1, 4, 1, 5, 9, 2])` | [1, 4, 1, 5, 9, 2] | False | `min(1, minimo([4, 1, 5, 9, 2]))` |
| `minimo([4, 1, 5, 9, 2])` | [4, 1, 5, 9, 2] | False | `min(4, minimo([1, 5, 9, 2]))` |
| `minimo([1, 5, 9, 2])` | [1, 5, 9, 2] | False | `min(1, minimo([5, 9, 2]))` |
| `minimo([5, 9, 2])` | [5, 9, 2] | False | `min(5, minimo([9, 2]))` |
| `minimo([9, 2])` | [9, 2] | False | `min(9, minimo([2]))` |
| `minimo([2])` | [2] | True | `2` |

Explicación:
1. `minimo([3, 1, 4, 1, 5, 9, 2])` compara el primer elemento con el mínimo del resto de la lista.
2. Este proceso se repite hasta que la lista tiene un solo elemento, que es el mínimo.

pág. 506
Ejemplo 16: Suma de dígitos de un número

Código:

def suma_digitos(n):
if n < 10: # Caso base
return n
else:
return n % 10 + suma_digitos(n // 10) # Caso recursivo

print(suma_digitos(1234)) # 10

Prueba de Escritorio:

| Llamada | `n` | `n < 10` | Valor devuelto |

|--------------------------------- |---------- |---------- ----------- |-------------------------------- |
| `suma_digitos(1234)` | 1234 | False | `4 + suma_digitos(123)` |
| `suma_digitos(123)` | 123 | False | `3 + suma_digitos(12)` |
| `suma_digitos(12)` | 12 | False | `2 + suma_digitos(1)` |
| `suma_digitos(1)` |1 | True | `1` |

Explicación:
1. `suma_digitos(1234)` suma el último dígito (`4`) y llama a `suma_digitos(123)`.
2. Este proceso se repite hasta que `n` es menor que 10, momento en el que se devuelve `n`.

pág. 507
Ejemplo 17: Encontrar el máximo en una lista

Código:

def maximo(lista):
if len(lista) == 1: # Caso base
return lista[0]
else:
return max(lista[0], maximo(lista[1:])) # Caso recursivo

print(maximo([3, 1, 4, 1, 5, 9, 2])) # 9

Prueba de Escritorio:

| Llamada | `lista` | `len(lista) == 1` | Valor devuelto |

|-------------------------------------------- |--------------------------------- |--------------------- |-------------------------------------------- |
| `maximo([3, 1, 4, 1, 5, 9, 2])` | [3, 1, 4, 1, 5, 9, 2] | False | `max(3, maximo([1, 4, 1, 5, 9, 2]))`|
| `maximo([1, 4, 1, 5, 9, 2])` | [1, 4, 1, 5, 9, 2] | False | `max(1, maximo([4, 1, 5, 9, 2]))` |
| `maximo([4, 1, 5, 9, 2])` | [4, 1, 5, 9, 2] | False | `max(4, maximo([1, 5, 9, 2]))` |
| `maximo([1, 5, 9, 2])` | [1, 5, 9, 2] | False | `max(1, maximo([5, 9, 2]))` |
| `maximo([5, 9, 2])` | [5, 9, 2] | False | `max(5, maximo([9, 2]))` |
| `maximo([9, 2])` | [9, 2] |False | `max(9, maximo([2]))` |
| `maximo([2])` | [2] | True | `2` |

Explicación:
1. `maximo([3, 1, 4, 1, 5, 9, 2])` compara el primer elemento con el máximo del resto de la lista.
2. Este proceso se repite hasta que la lista tiene un solo elemento, que es el máximo.

pág. 508
Ejemplo 18: Contar ocurrencias de un elemento en una lista

Código:

def contar_ocurrencias(lista, elemento):

if not lista: # Caso base
return 0
else:
return (1 if lista[0] == elemento else 0) + contar_ocurrencias(lista[1:], elemento) # Caso recursivo

print(contar_ocurrencias([1, 2, 3, 2, 4, 2], 2)) # 3

Prueba de Escritorio:

| Llamada | `lista` | `elemento` | `not lista` | Valor devuelto

|
|-------------------------------------------------------------- |----------------------- |----------------------- |----------------------- |---------------------------
------------------- |
| `contar_ocurrencias([1, 2, 3, 2, 4, 2], 2)` | [1, 2, 3, 2, 4, 2] |2 | False | `(0) +
contar_ocurrencias([2, 3, 2, 4, 2], 2)` |
| `contar_ocurrencias([2, 3, 2, 4, 2], 2)` | [2, 3, 2, 4, 2] |2 | False | `(1) +
contar_ocurrencias([3, 2, 4, 2], 2)` |
| `contar_ocurrencias([3, 2, 4, 2], 2)` | [3, 2, 4, 2] |2 | False | `(0) +
contar_ocurrencias([2, 4, 2], 2)` |
| `contar_ocurrencias([2, 4, 2], 2)` | [2, 4, 2] |2 | False | `(1) +
contar_ocurrencias([4, 2], 2)` |
| `contar_ocurrencias([4, 2], 2)` | [4, 2] |2 | False | `(0) +
contar_ocurrencias([2], 2)` |
| `contar_ocurrencias([2], 2)` | [2] |2 | False | `(1) +
contar_ocurrencias([], 2)` |
| `contar_ocurrencias([], 2)` | [] |2 | True | `0`
|

Explicación:
1. `contar_ocurrencias([1, 2, 3, 2, 4, 2], 2)` cuenta cuántas veces aparece `2` en la lista.
2. Si el primer elemento es igual a `2`, suma 1; de lo contrario, suma 0.
3. Este proceso se repite hasta que la lista está vacía.

pág. 509
Ejemplo 19: Eliminar duplicados en una lista

Código:

def eliminar_duplicados(lista):
if not lista: # Caso base
return []
else:
cabeza = lista[0]
cola = lista[1:]
return [cabeza] + eliminar_duplicados([x for x in cola if x != cabeza]) # Caso recursivo

print(eliminar_duplicados([1, 2, 2, 3, 4, 4, 5])) # [1, 2, 3, 4, 5]

Prueba de Escritorio:

| Llamada | `lista` | `not lista` | Valor devuelto

|
|-------------------------------------------------------- |--------------------------------- |--------------------- |-----------------------------------
--------------------- |
| `eliminar_duplicados([1, 2, 2, 3, 4, 4, 5])` | [1, 2, 2, 3, 4, 4, 5] | False | `[1] +
eliminar_duplicados([2, 3, 4, 5])` |
| `eliminar_duplicados([2, 3, 4, 5])` | [2, 3, 4, 5] | False | `[2] +
eliminar_duplicados([3, 4, 5])` |
| `eliminar_duplicados([3, 4, 5])` | [3, 4, 5] | False | `[3] +
eliminar_duplicados([4, 5])` |
| `eliminar_duplicados([4, 5])` | [4, 5] | False | `[4] +
eliminar_duplicados([5])` |
| `eliminar_duplicados([5])` | [5] | False | `[5] +
eliminar_duplicados([])` |
| `eliminar_duplicados([])` | [] | True | `[]`
|

Explicación:
1. `eliminar_duplicados([1, 2, 2, 3, 4, 4, 5])` toma el primer elemento (`1`) y lo concatena con el resultado de eliminar
duplicados en el resto de la lista.
2. Este proceso se repite hasta que la lista está vacía.

pág. 510
Ejemplo 20: Generar secuencia de Fibonacci hasta un límite

Código:

def fibonacci_hasta_limite(limite, a=0, b=1):

if a > limite: # Caso base
return []
else:
return [a] + fibonacci_hasta_limite(limite, b, a + b) # Caso recursivo

print(fibonacci_hasta_limite(20)) # [0, 1, 1, 2, 3, 5, 8, 13]

Prueba de Escritorio:

| Llamada | `limite`| `a` | `b` | `a > limite` | Valor devuelto

|
|-------------------------------------------------------- |----------|-----|-----|-------------------- |-----------------------------------------------
--------- |
| `fibonacci_hasta_limite(20)` | 20 | 0 | 1 | False | `[0] + fibonacci_hasta_limite(20, 1,
1)` |
| `fibonacci_hasta_limite(20, 1, 1)` | 20 | 1 | 1 | False | `[1] + fibonacci_hasta_limite(20, 1,
2)` |
| `fibonacci_hasta_limite(20, 1, 2)` | 20 | 1 | 2 | False | `[1] + fibonacci_hasta_limite(20, 2,
3)` |
| `fibonacci_hasta_limite(20, 2, 3)` | 20 | 2 | 3 | False | `[2] + fibonacci_hasta_limite(20, 3,
5)` |
| `fibonacci_hasta_limite(20, 3, 5)` | 20 | 3 | 5 | False | `[3] + fibonacci_hasta_limite(20, 5,
8)` |
| `fibonacci_hasta_limite(20, 5, 8)` | 20 | 5 | 8 | False | `[5] + fibonacci_hasta_limite(20, 8,
13)` |
| `fibonacci_hasta_limite(20, 8, 13)` | 20 | 8 | 13 | False | `[8] + fibonacci_hasta_limite(20, 13,
21)` |
| `fibonacci_hasta_limite(20, 13, 21)` | 20 | 13 | 21 | True | `[]`
|

Explicación:
1. `fibonacci_hasta_limite(20)` genera la secuencia de Fibonacci hasta que `a` supera el límite.
2. Cada llamada recursiva avanza en la secuencia sumando `a` y `b`.

pág. 511
Ejemplo 21: Verificar si una lista está ordenada

Código:

def esta_ordenada(lista):
if len(lista) <= 1: # Caso base
return True
else:
return lista[0] <= lista[1] and esta_ordenada(lista[1:]) # Caso recursivo

print(esta_ordenada([1, 2, 3, 4, 5])) # True

print(esta_ordenada([1, 3, 2, 4, 5])) # False

Prueba de Escritorio:

| Llamada | `lista` | `len(lista) <= 1` | `lista[0] <= lista[1]` | Valor devuelto

|
|------------------------------------------------- |------------------------ |------------------------ |-------------------------------------|---------------------------
-----------------------|
| `esta_ordenada([1, 2, 3, 4, 5])` | [1, 2, 3, 4, 5] | False | `1 <= 2` | `True and
esta_ordenada([2, 3, 4, 5])`|
| `esta_ordenada([2, 3, 4, 5])` | [2, 3, 4, 5] | False | `2 <= 3` | `True and
esta_ordenada([3, 4, 5])` |
| `esta_ordenada([3, 4, 5])` | [3, 4, 5] | False | `3 <= 4` | `True and
esta_ordenada([4, 5])` |
| `esta_ordenada([4, 5])` | [4, 5] | False | `4 <= 5` | `True and
esta_ordenada([5])` |
| `esta_ordenada([5])` | [5] | True |- | `True`
|

Explicación:
1. `esta_ordenada([1, 2, 3, 4, 5])` verifica si el primer elemento es menor o igual que el segundo.
2. Este proceso se repite hasta que la lista tiene un solo elemento, momento en el que se devuelve `True`.

pág. 512
Ejemplo 22: Encontrar el índice de un elemento en una lista

Código:

def indice(lista, elemento, inicio=0):

if inicio >= len(lista): # Caso base: elemento no encontrado
return -1
elif lista[inicio] == elemento: # Caso base: elemento encontrado
return inicio
else:
return indice(lista, elemento, inicio + 1) # Caso recursivo

print(indice([1, 2, 3, 4, 5], 3)) # 2

Prueba de Escritorio:

| Llamada | `lista` | `elemento` | `inicio` | `inicio >= len(lista)` | `lista[inicio] ==

elemento` | Valor devuelto |
|---------------------------------|-------------------- |--------------------- |----------|------------------------|-------------------------|-------
---------------------------|
| `indice([1, 2, 3, 4, 5], 3)` | [1, 2, 3, 4, 5] |3 |0 | False | `1 == 3` |
`indice(lista, 3, 1)` |
| `indice(lista, 3, 1)` | [1, 2, 3, 4, 5] |3 |1 | False | `2 == 3` |
`indice(lista, 3, 2)` |
| `indice(lista, 3, 2)` | [1, 2, 3, 4, 5] |3 |2 | False | `3 == 3` | `2`
|

Explicación:
1. `indice([1, 2, 3, 4, 5], 3)` busca el índice de `3` en la lista.
2. Si el elemento en la posición `inicio` es igual a `3`, devuelve `inicio`.
3. De lo contrario, incrementa `inicio` y llama recursivamente a la función.

pág. 513
Ejemplo 23: Reemplazar un elemento en una lista

Código:

def reemplazar(lista, viejo, nuevo):

if not lista: # Caso base: lista vacía
return []
else:
cabeza = lista[0]
cola = lista[1:]
return ([nuevo if cabeza == viejo else cabeza] + reemplazar(cola, viejo, nuevo)) # Caso recursivo

print(reemplazar([1, 2, 3, 2, 4, 2], 2, 99)) # [1, 99, 3, 99, 4, 99]

Prueba de Escritorio:

| Llamada | `lista` | `viejo` | `nuevo`| `not lista` | Valor devuelto

|
|-------------------------------------------------------- |--------------------- |--------- |--------- |--------------------- |------------------------
-------------------- |
| `reemplazar([1, 2, 3, 2, 4, 2], 2, 99)` | [1, 2, 3, 2, 4, 2] | 2 | 99 | False | `[1] +
reemplazar([2, 3, 2, 4, 2], 2, 99)|
| `reemplazar([2, 3, 2, 4, 2], 2, 99)` | [2, 3, 2, 4, 2] | 2 | 99 | False | `[99] +
reemplazar([3, 2, 4, 2], 2, 99)|
| `reemplazar([3, 2, 4, 2], 2, 99)` | [3, 2, 4, 2] |2 | 99 | False | `[3] +
reemplazar([2, 4, 2], 2, 99) |
| `reemplazar([2, 4, 2], 2, 99)` | [2, 4, 2] |2 | 99 | False | `[99] + re

pág. 514
Ejemplo 23: Reemplazar un elemento en una lista

Código:

def reemplazar(lista, viejo, nuevo):

if not lista: # Caso base: lista vacía
return []
else:
cabeza = lista[0]
cola = lista[1:]
return ([nuevo if cabeza == viejo else cabeza] + reemplazar(cola, viejo, nuevo)) # Caso recursivo

print(reemplazar([1, 2, 3, 2, 4, 2], 2, 99)) # [1, 99, 3, 99, 4, 99]

Prueba de Escritorio:

Llamada lista viejo nuevo not lista Valor devuelto

reemplazar([1, 2, 3, 2, 4, 2], 2, [1, 2, 3, 2, 4, 2 99 False `[1] + reemplazar([2, 3, 2, 4, 2], 2, 99)`
99) 2]
reemplazar([2, 3, 2, 4, 2], 2, [2, 3, 2, 4, 2] 2 99 False `[99] + reemplazar([3, 2, 4, 2], 2, 99)`
99)
reemplazar([3, 2, 4, 2], 2, 99)` [3, 2, 4, 2] 2 99 False `[3] + reemplazar([2, 4, 2], 2, 99)`
reemplazar([2, 4, 2], 2, 99)` [2, 4, 2] 2 99 False `[99] + reemplazar([4, 2], 2, 99)`
reemplazar([4, 2], 2, 99) [4, 2] 2 99 False `[4] + reemplazar([2], 2, 99)`
reemplazar([2], 2, 99)` [2] 2 99 False `[99] + reemplazar([], 2, 99)`
reemplazar([], 2, 99)` [] 2 99 True []

Explicación:
1. `reemplazar([1, 2, 3, 2, 4, 2], 2, 99)` reemplaza todas las ocurrencias de `2` por `99`.
2. Si el primer elemento es igual a `viejo`, lo reemplaza por `nuevo`.
3. Este proceso se repite hasta que la lista está vacía.

pág. 515
Ejemplo 24: Generar todas las permutaciones de una lista

Código:

def permutaciones(lista):
if len(lista) <= 1: # Caso base
return [lista]
else:
resultado = []
for i, cabeza in enumerate(lista):
cola = lista[:i] + lista[i+1:]
for p in permutaciones(cola):
resultado.append([cabeza] + p)
return resultado

print(permutaciones([1, 2, 3]))

Prueba de Escritorio:

| Llamada | `lista` | `len(lista) <= 1` | Valor devuelto

|
|----------------------------------------- |------------ |--------------------------- |------------------------------------------------------------------------------------------------------
-------------------------- |
| `permutaciones([1, 2, 3])` | [1, 2, 3] | False | `[[1] + p for p in permutaciones([2, 3])] + [[2] + p for p in permutaciones([1, 3])]
+ [[3] + p for p in permutaciones([1, 2])]`
|
| `permutaciones([2, 3])` | [2, 3] | False | `[[2] + p for p in permutaciones([3])] + [[3] + p for p in permutaciones([2])]`
|
| `permutaciones([3])` | [3] | True | `[[3]]`
|
| `permutaciones([2])` | [2] | True | `[[2]]`
|
| `permutaciones([1, 3])` | [1, 3] | False | `[[1] + p for p in permutaciones([3])] + [[3] + p for p in permutaciones([1])]`
|
| `permutaciones([1])` | [1] | True | `[[1]]`
|
| `permutaciones([1, 2])` | [1, 2] | False | `[[1] + p for p in permutaciones([2])] + [[2] + p for p in permutaciones([1])]`
|

Explicación:
1. `permutaciones([1, 2, 3])` genera todas las permutaciones de la lista.
2. Para cada elemento, lo coloca al principio y genera permutaciones con el resto de la lista.
3. Este proceso se repite hasta que la lista tiene un solo elemento, momento en el que se devuelve la lista misma.

pág. 516
Ejemplo 25: Encontrar el producto de los elementos de una lista

Código:

def producto_lista(lista):
if not lista: # Caso base: lista vacía
return 1
else:
return lista[0] * producto_lista(lista[1:]) # Caso recursivo

print(producto_lista([1, 2, 3, 4])) # 24

Prueba de Escritorio:

| Llamada | `lista` | `not lista` | Valor devuelto |

|-------------------------------------------- |--------------------- |--------------------- |-------------------------------------------- |
| `producto_lista([1, 2, 3, 4])` | [1, 2, 3, 4] | False | `1 * producto_lista([2, 3, 4])` |
| `producto_lista([2, 3, 4])` | [2, 3, 4] | False | `2 * producto_lista([3, 4])` |
| `producto_lista([3, 4])` | [3, 4] | False | `3 * producto_lista([4])` |
| `producto_lista([4])` | [4] | False | `4 * producto_lista([])` |
| `producto_lista([])` | [] | True | `1` |

Explicación:
1. `producto_lista([1, 2, 3, 4])` multiplica el primer elemento por el producto del resto de la lista.
2. Este proceso se repite hasta que la lista está vacía, momento en el que se devuelve `1`.

pág. 517
Ejemplo 26: Verificar si un número es primo

Código:

def es_primo(n, divisor=2):

if n <= 1: # Caso base: números menores o iguales a 1 no son primos
return False
elif divisor * divisor > n: # Caso base: no hay divisores mayores que sqrt(n)
return True
elif n % divisor == 0: # Caso base: n es divisible por divisor
return False
else:
return es_primo(n, divisor + 1) # Caso recursivo

print(es_primo(17)) # True

Prueba de Escritorio:

| Llamada |`n` | `divisor` | `n <= 1` | `divisor * divisor > n` | `n % divisor == 0` | Valor devuelto |
|------------------------ |------|-------------- |---------- |----------------------- |-------------------- |------------------------|
| `es_primo(17)` | 17 | 2 | False | False | `17 % 2 == 0` | `es_primo(17, 3)` |
| `es_primo(17, 3)` | 17 | 3 | False | False | `17 % 3 == 0` | `es_primo(17, 4)` |
| `es_primo(17, 4)` | 17 | 4 | False | True |- | `True` |

Explicación:
1. `es_primo(17)` verifica si `17` es divisible por algún número entre `2` y `sqrt(17)`.
2. Si no encuentra divisores, devuelve `True`.

pág. 518
Ejemplo 27: Encontrar el máximo común divisor (MCD) de dos números

Código:

def mcd(a, b):

if b == 0: # Caso base
return a
else:
return mcd(b, a % b) # Caso recursivo

print(mcd(48, 18)) # 6

Prueba de Escritorio:

| Llamada |`a` | `b` | `b == 0` | Valor devuelto |

|--------------------- |------ |------ |---------- |--------------------------------- |
| `mcd(48, 18)` | 48 | 18 | False | `mcd(18, 48 % 18)` |
| `mcd(18, 12)` | 18 | 12 | False | `mcd(12, 18 % 12)` |
| `mcd(12, 6)` | 12 |6 | False | `mcd(6, 12 % 6)` |
| `mcd(6, 0)` |6 |0 | True | `6` |

Explicación:
1. `mcd(48, 18)` utiliza el algoritmo de Euclides para encontrar el MCD.
2. Si `b` es 0, devuelve `a`.
3. De lo contrario, llama a `mcd(b, a % b)`.

pág. 519
Ejemplo 28: Suma de los primeros `n` números naturales

Código:

def suma_naturales(n):
if n == 0: # Caso base
return 0
else:
return n + suma_naturales(n - 1) # Caso recursivo

print(suma_naturales(5)) # 15

Prueba de Escritorio:

| Llamada | `n` | `n == 0` | Valor devuelto |

|--------------------------------- |-----|--------------- |-------------------------------- |
| `suma_naturales(5)` | 5 | False | `5 + suma_naturales(4)` |
| `suma_naturales(4)` | 4 | False | `4 + suma_naturales(3)` |
| `suma_naturales(3)` | 3 | False | `3 + suma_naturales(2)` |
| `suma_naturales(2)` | 2 | False | `2 + suma_naturales(1)` |
| `suma_naturales(1)` | 1 | False | `1 + suma_naturales(0)` |
| `suma_naturales(0)` | 0 | True | `0` |

Explicación:
1. `suma_naturales(5)` suma `5` con el resultado de `suma_naturales(4)`.
2. Este proceso se repite hasta que `n` es 0, momento en el que se devuelve `0`.

pág. 520
Ejemplo 29: Convertir un número decimal a binario

Código:

def decimal_a_binario(n):
if n == 0: # Caso base
return ""
else:
return decimal_a_binario(n // 2) + str(n % 2) # Caso recursivo

print(decimal_a_binario(10)) # "1010"

Prueba de Escritorio:

| Llamada | `n` | `n == 0` | Valor devuelto |

|--------------------------------- |---------- |--------------------- |---------------------------------------------|
| `decimal_a_binario(10)` | 10 | False | `decimal_a_binario(5) + "0"` |
| `decimal_a_binario(5)` | 5 | False | `decimal_a_binario(2) + "1"` |
| `decimal_a_binario(2)` | 2 | False | `decimal_a_binario(1) + "0"` |
| `decimal_a_binario(1)` | 1 | False | `decimal_a_binario(0) + "1"` |
| `decimal_a_binario(0)` | 0 | True | `""` |

Explicación:
1. `decimal_a_binario(10)` divide `n` por 2 y concatena el residuo (`n % 2`).
2. Este proceso se repite hasta que `n` es 0.

pág. 521
Ejemplo 30: Encontrar el mínimo común múltiplo (MCM) de dos números

Código:
def mcm(a, b):
return a * b // mcd(a, b) # Usa la función mcd definida anteriormente

print(mcm(12, 18)) # 36

Prueba de Escritorio:

| Llamada | `a` | `b` | `mcd(a, b)` | Valor devuelto |

|--------------------- |--------- |---------- |--------------------- |--------------------------------- |
| `mcm(12, 18)` | 12 | 18 |6 | `12 * 18 // 6 = 36` |

Explicación:
1. `mcm(12, 18)` utiliza la fórmula `mcm(a, b) = (a * b) // mcd(a, b)`.
2. Primero calcula el MCD de `12` y `18`, que es `6`.
3. Luego, calcula el MCM como `(12 * 18) // 6 = 36`.

pág. 522
Ejemplo 31: Encontrar el número de combinaciones de `n` elementos tomados de `k` en `k`

Código:
def combinaciones(n, k):
if k == 0 or k == n: # Caso base
return 1
else:
return combinaciones(n - 1, k - 1) + combinaciones(n - 1, k) # Caso recursivo

print(combinaciones(5, 2)) # 10

Prueba de Escritorio:

| Llamada | `n` | `k` | `k == 0 or k == n` | Valor devuelto

|
|--------------------------------- |----------|---------- |--------------------------------- |----------------------------------------------------------
----------|
| `combinaciones(5, 2)` | 5 |2 | False | `combinaciones(4, 1) + combinaciones(4, 2)`
|
| `combinaciones(4, 1)` | 4 |1 | False | `combinaciones(3, 0) + combinaciones(3, 1)`
|
| `combinaciones(3, 0)` | 3 |0 | True | `1`
|
| `combinaciones(3, 1)` | 3 |1 | False | `combinaciones(2, 0) + combinaciones(2, 1)`
|
| `combinaciones(2, 0)` | 2 |0 | True | `1`
|
| `combinaciones(2, 1)` | 2 |1 | False | `combinaciones(1, 0) + combinaciones(1, 1)`
|
| `combinaciones(1, 0)` | 1 |0 | True | `1`
|
| `combinaciones(1, 1)` | 1 |1 | True | `1`
|
| `combinaciones(4, 2)` | 4 |2 | False | `combinaciones(3, 1) + combinaciones(3, 2)`
|
| `combinaciones(3, 2)` | 3 |2 | False | `combinaciones(2, 1) + combinaciones(2, 2)`
|
| `combinaciones(2, 2)` | 2 |2 | True | `1`
|

Explicación:
1. `combinaciones(5, 2)` utiliza la fórmula recursiva `C(n, k) = C(n-1, k-1) + C(n-1, k)`.
2. Este proceso se repite hasta llegar a los casos base (`k == 0` o `k == n`).

pág. 523
Ejemplo 32: Encontrar el número de permutaciones de `n` elementos tomados de `k` en `k`

Código:
def permutaciones(n, k):
if k == 0: # Caso base
return 1
else:
return n * permutaciones(n - 1, k - 1) # Caso recursivo

print(permutaciones(5, 2)) # 20

Prueba de Escritorio:

| Llamada |`n` |`k` |`k == 0` | Valor devuelto |

|--------------------------------- |----------|----------|---------- |--------------------------------- |
| `permutaciones(5, 2)` | 5 |2 | False | 5 * permutaciones(4, 1) |
| `permutaciones(4, 1)` | 4 |1 | False | 4 * permutaciones(3, 0) |
| `permutaciones(3, 0)` | 3 |0 | True | 1` |

Explicación:
1. `permutaciones(5, 2)` utiliza la fórmula recursiva `P(n, k) = n * P(n-1, k-1)`.
2. Este proceso se repite hasta llegar al caso base (`k == 0`).

pág. 524
Ejemplo 33: Encontrar el número de Fibonacci en la posición `n`

Código:
def fibonacci(n):
if n == 0: # Caso base
return 0
elif n == 1: # Caso base
return 1
else:
return fibonacci(n - 1) + fibonacci(n - 2) # Caso recursivo

print(fibonacci(6)) # 8

Prueba de Escritorio:

| Llamada |n | n == 0 | n == 1 | Valor devuelto |

|--------------------- |----------|---------- |------------|-----------------------------------|
| `fibonacci(6)` | 6 | False | False | fibonacci(5) + fibonacci(4) |
| `fibonacci(5)` | 5 | False | False | fibonacci(4) + fibonacci(3) |
| `fibonacci(4)` | 4 | False | False | fibonacci(3) + fibonacci(2) |
| `fibonacci(3)` | 3 | False | False | fibonacci(2) + fibonacci(1) |
| `fibonacci(2)` | 2 | False | False | fibonacci(1) + fibonacci(0) |
| `fibonacci(1)` | 1 | False | True |1 |
| `fibonacci(0)` | 0 | True | False | 0 |

Explicación:
1. `fibonacci(6)` utiliza la fórmula recursiva `F(n) = F(n-1) + F(n-2)`.
2. Este proceso se repite hasta llegar a los casos base (`n == 0` o `n == 1`).

pág. 525