Lógica, algoritmos y programación en Python

Un enfoque práctico e intuitivo para aprender a

programar

Roberto Enrique Alberto Lira

ii
Acerca del autor

Roberto Enrique Alberto Lira. Egresado de la Licenciatura en Computación

por parte de la Universidad Juárez Autónoma de Tabasco. Cuenta con una
Maestría en Ciencias en Computación por parte del Centro de Investigación y de
Estudios Avanzados del Instituto Politécnico Nacional.
Del año 2010 a la fecha, se ha desempeñado como profesor-investigador en institu-
ciones de educación superior a nivel nacional. Entre ellas su alma mater la Universidad
Juárez Autónoma de Tabasco.
Cuenta con algunas publicaciones en áreas de las Ciencias en Computación. Una
de estas publicaciones es un libro y las otras son artículos de revista. Entre sus áreas
de interés se encuentran: Algoritmos y programación, Programación de dispositivos
móviles, Programación Concurrente, Programación Estructurada y Orientada a Ob-
jetos.

iii
iv
 Dedicado a
mi familia

v
vi
Índice general

Prefacio 1

Convenciones usadas en este libro 3

1. Pensamiento Lógico 5
1.1. Habilidades del pensamiento . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.1. Lógica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.2. Tablas de verdad . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.3. Ejercicios Lógica . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.1.4. Habilidades Lógico Matemáticas . . . . . . . . . . . . . . . . . 14
1.1.5. Ejercicios de habilidades lógico-matemáticas . . . . . . . . . . 19
1.1.6. Teoría de conjuntos . . . . . . . . . . . . . . . . . . . . . . . . 21
1.1.7. Ejercicios de conjuntos . . . . . . . . . . . . . . . . . . . . . . 26
1.2. Aritmética en la lógica . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.2.1. Los números naturales . . . . . . . . . . . . . . . . . . . . . . 27
1.2.2. Ejercicios de números naturales . . . . . . . . . . . . . . . . . 30
1.2.3. Los números enteros . . . . . . . . . . . . . . . . . . . . . . . 30
1.2.4. Ejercicios de números enteros . . . . . . . . . . . . . . . . . . 36
1.2.5. Mínimo común múltiplo . . . . . . . . . . . . . . . . . . . . . 36
1.2.6. Ejercicio mcm . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1.2.7. Máximo común divisor . . . . . . . . . . . . . . . . . . . . . . 38
1.2.8. Ejercicios MCD . . . . . . . . . . . . . . . . . . . . . . . . . . 39

2. Fundamentos de algoritmos y de Python 41

2.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.2. Definición y características de los algoritmos . . . . . . . . . . . . . . 41
2.3. Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
2.3.1. Constante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
2.3.2. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
2.4. Entradas y salidas de información . . . . . . . . . . . . . . . . . . . . 44
2.5. Pseudocódigo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.6. Un ejemplo que aplica todos los conceptos vistos . . . . . . . . . . . . 45
2.7. Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
2.7.1. El zen de Python . . . . . . . . . . . . . . . . . . . . . . . . . 46

vii
viii ÍNDICE GENERAL

2.7.2. Instalación de Python y PyCharm en Windows . . . . . . . . 47

2.7.3. Estructura de un algoritmo en Python . . . . . . . . . . . . . 54
2.7.4. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
2.7.5. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
2.7.6. Jerarquía de operadores . . . . . . . . . . . . . . . . . . . . . 57
2.7.7. Palabras reservadas . . . . . . . . . . . . . . . . . . . . . . . . 58
2.7.8. Comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

3. Estructuras secuenciales 61
3.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
3.2. Estructuras de control . . . . . . . . . . . . . . . . . . . . . . . . . . 61
3.3. Estructuras secuenciales . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.3.1. Ejemplo suma de dos números . . . . . . . . . . . . . . . . . . 62
3.3.2. Ejemplo área y perímetro de un rectángulo . . . . . . . . . . . 64
3.3.3. Bibliotecas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
3.3.4. Ejemplo área de una circunferencia . . . . . . . . . . . . . . . 67
3.3.5. Ejemplo intercambio de variables . . . . . . . . . . . . . . . . 68
3.3.6. Ejemplo producción de leche . . . . . . . . . . . . . . . . . . . 69
3.3.7. Ejemplo sueldo semanal . . . . . . . . . . . . . . . . . . . . . 70
3.4. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

4. Estructuras selectivas 73
4.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.2. Estructuras selectivas . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.2.1. Ejemplo: Dados dos valores determinar el mayor . . . . . . . . 75
4.2.2. Ejemplo: Determinar si un número es positivo o negativo . . . 76
4.2.3. Ejemplo: “CompuMax” . . . . . . . . . . . . . . . . . . . . . . 78
4.3. Estructuras if-elif-else . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
4.3.1. Ejemplo: Calculadora . . . . . . . . . . . . . . . . . . . . . . . 80
4.3.2. Ejemplo: Las brisas del caracol . . . . . . . . . . . . . . . . . 82
4.4. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

5. Estructuras repetitivas 85
5.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
5.2. Estructuras repetitivas o de ciclo . . . . . . . . . . . . . . . . . . . . 85
5.2.1. Ejemplo: Suma diez cantidades con ciclo “Mientras que” . . . . 86
5.2.2. Ejemplo suma diez cantidades con ciclo “Desde” . . . . . . . . 87
5.2.3. Ejemplo cálculo de promedio de números . . . . . . . . . . . . 89
5.2.4. Ejemplo cálculo de promedio sin conocer la cantidad de números 91
5.2.5. Ejemplo cálculo de ahorro en un año . . . . . . . . . . . . . . 92
5.2.6. Ejemplo serie Fibonacci . . . . . . . . . . . . . . . . . . . . . 94
5.2.7. Ejemplo número primo . . . . . . . . . . . . . . . . . . . . . . 95
5.2.8. Ejemplo dibuja triángulo numérico . . . . . . . . . . . . . . . 97
5.3. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
ÍNDICE GENERAL ix

6. Cadenas y colecciones 101

6.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.2. Cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.2.1. Índices y slicing . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.2.2. Longitud de una cadena . . . . . . . . . . . . . . . . . . . . . 104
6.2.3. Métodos para cadenas . . . . . . . . . . . . . . . . . . . . . . 105
6.2.4. Recorrido de una cadena . . . . . . . . . . . . . . . . . . . . . 109
6.3. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
6.3.1. Crear listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
6.3.2. Mostrar elementos de la lista . . . . . . . . . . . . . . . . . . . 110
6.3.3. Listas con elementos de diferentes tipos de datos . . . . . . . . 111
6.3.4. Determinar la cantidad de elementos en una lista . . . . . . . 112
6.3.5. Insertar nuevos elementos en la lista . . . . . . . . . . . . . . 112
6.3.6. Buscar elementos en la lista . . . . . . . . . . . . . . . . . . . 113
6.3.7. Contar cuantas veces aparece un elemento en la lista . . . . . 114
6.3.8. Eliminar elementos de la lista . . . . . . . . . . . . . . . . . . 115
6.3.9. Invertir la lista . . . . . . . . . . . . . . . . . . . . . . . . . . 116
6.3.10. Ordenar elementos de la lista . . . . . . . . . . . . . . . . . . 116
6.3.11. Recorrer listas con for . . . . . . . . . . . . . . . . . . . . . . 117
6.4. Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
6.4.1. Crear tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
6.4.2. Mostrar elementos de una tupla . . . . . . . . . . . . . . . . . 118
6.4.3. Buscar elementos en la tupla . . . . . . . . . . . . . . . . . . . 119
6.4.4. Contar la aparición de un elemento en la tupla . . . . . . . . . 120
6.4.5. Conocer la longitud de la tupla . . . . . . . . . . . . . . . . . 120
6.4.6. Transformar tuplas en lista . . . . . . . . . . . . . . . . . . . . 120
6.4.7. Transformar listas en tuplas . . . . . . . . . . . . . . . . . . . 121
6.4.8. Recorrer tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . 121
6.4.9. Ventajas de utilizar tuplas . . . . . . . . . . . . . . . . . . . . 121
6.5. Diccionarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
6.5.1. Crear un diccionario . . . . . . . . . . . . . . . . . . . . . . . 122
6.5.2. Acceder al valor de un elemento del diccionario . . . . . . . . 122
6.5.3. Agregar nuevos elementos al diccionario . . . . . . . . . . . . 123
6.5.4. Modificar un elemento . . . . . . . . . . . . . . . . . . . . . . 123
6.5.5. Eliminar un elemento . . . . . . . . . . . . . . . . . . . . . . . 124
6.5.6. Cuando la clave no existe . . . . . . . . . . . . . . . . . . . . 124
6.5.7. Búsqueda directa . . . . . . . . . . . . . . . . . . . . . . . . . 125
6.5.8. Mostrar los valores del diccionario . . . . . . . . . . . . . . . . 125
6.5.9. Cantidad de elementos del diccionario . . . . . . . . . . . . . . 126
6.5.10. Vaciar el diccionario . . . . . . . . . . . . . . . . . . . . . . . 126
6.5.11. Recorrer un diccionario con for . . . . . . . . . . . . . . . . . 126
6.6. Conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
6.6.1. Crear un conjunto . . . . . . . . . . . . . . . . . . . . . . . . 127
x ÍNDICE GENERAL

6.6.2. Eliminar elementos del conjunto . . . . . . . . . . . . . . . . . 129

6.6.3. Buscar un elemento . . . . . . . . . . . . . . . . . . . . . . . . 129
6.6.4. Igualdad de conjuntos . . . . . . . . . . . . . . . . . . . . . . 130
6.6.5. Conocer la cantidad de elementos de un conjunto . . . . . . . 130
6.6.6. Unión de conjuntos . . . . . . . . . . . . . . . . . . . . . . . . 131
6.6.7. Intersección de conjuntos . . . . . . . . . . . . . . . . . . . . . 131
6.6.8. Diferencia de conjuntos . . . . . . . . . . . . . . . . . . . . . . 132
6.6.9. Diferencia simétrica . . . . . . . . . . . . . . . . . . . . . . . . 132
6.6.10. Determinar si un conjunto es subconjunto de otro . . . . . . . 132
6.6.11. Recorrer un conjunto con for . . . . . . . . . . . . . . . . . . . 133
6.7. Ejercicios cadenas y colecciones . . . . . . . . . . . . . . . . . . . . . 133

7. Funciones 135
7.1. Funciones con y sin retorno de valor . . . . . . . . . . . . . . . . . . . 136
7.1.1. Funciones sin retorno de valor . . . . . . . . . . . . . . . . . . 136
7.1.2. Funciones con retorno de valor . . . . . . . . . . . . . . . . . . 137
7.2. Argumentos y parámetros . . . . . . . . . . . . . . . . . . . . . . . . 138
7.3. Argumentos por valor y por referencia . . . . . . . . . . . . . . . . . 139
7.4. Funciones recursivas . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
7.4.1. Función recursiva sin retorno . . . . . . . . . . . . . . . . . . 140
7.4.2. Función recursiva con retorno . . . . . . . . . . . . . . . . . . 141
7.5. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

8. Introducción a la complejidad computacional 143

8.1. Análisis de algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . 143
8.1.1. Tiempo de ejecución . . . . . . . . . . . . . . . . . . . . . . . 144
8.2. Complejidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
8.2.1. Notación asintótica . . . . . . . . . . . . . . . . . . . . . . . . 146
8.2.2. Reglas útiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
8.2.3. Complejidad exponencial y conclusiones del capítulo . . . . . . 149
8.3. Bonus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
8.4. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

9. Ejercicios de programación competitiva 151

9.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
9.1.1. Anatomía de un problema . . . . . . . . . . . . . . . . . . . . 152
9.2. Dólares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
9.3. Escribir al revés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
9.4. El excursionista mayor . . . . . . . . . . . . . . . . . . . . . . . . . . 154
9.5. Ordena a los alumnos . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
9.6. 888 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
9.7. La panza lanzadora . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
9.8. Edades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
9.9. Cuenta letras al vector . . . . . . . . . . . . . . . . . . . . . . . . . . 159
ÍNDICE GENERAL xi

9.10. Acomodando zapatillas . . . . . . . . . . . . . . . . . . . . . . . . . . 161

9.11. Un anagrama sencillo . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
9.12. Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
9.12.1. Cuántas mayúsculas y minúsculas . . . . . . . . . . . . . . . . 165
9.12.2. Regalos de Rodrigo . . . . . . . . . . . . . . . . . . . . . . . . 166
9.12.3. Crucigrama . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
9.12.4. A pares y nones . . . . . . . . . . . . . . . . . . . . . . . . . . 167
9.12.5. Encuentra el tesoro . . . . . . . . . . . . . . . . . . . . . . . . 168

Bibliografía 171

Índice alfabético 171

xii ÍNDICE GENERAL
Prefacio

Este libro es el resultado de la experiencia docente del autor, quien ha impartido

diferentes cursos de programación en distintas universidades públicas de México; entre
ellas su alma mater: la Universidad Juárez Autónoma de Tabasco.
Debido a las dificultades que presentan los estudiantes de los primeros cursos de
programación, el autor se dio a la tarea de observar y analizar en donde tienen sus
orígenes esas dificultades; llegando a la conclusión de que en muchos casos no hay
bases sólidas en lógica y aritmética. Estas disciplinas son sumamente importantes
para que un estudiante pueda realizar fluidamente un curso básico de programación.
Por lo que en esta obra se abordan la lógica y la aritmética antes de empezar a
programar.
También el autor ha notado que muchos libros de programación se centran en
la sintaxis de un lenguaje en particular, dejando de lado la parte fundamental de la
programación, la cual es la lógica. De igual modo, algunos libros resultan sumamente
complejos de seguir para los estudiantes que aún inician en este maravilloso mundo
de la programación. Por lo anterior, en esta obra se presenta un enfoque un tanto
diferente de los libros tradicionales que enseñan a programar, esperando aportar un
granito de arena para mejorar la comprensión de la programación.
Para el desarrollo de esta obra se ha empleado el lenguaje de programación Python
(en su versión 3), el cual se seleccionó por su simpleza y su intuitiva sintaxis. Estas
bondades del lenguaje permiten que el estudiante de programación se centre más en
la lógica del problema que en la sintaxis en sí. Cabe señalar que Python es uno de los
lenguajes más empleados actualmente y con mucho futuro por delante.
El contenido de este libro está sobre la base de que se parte sin conocimiento
alguno de programación, por lo que se ha tratado de explicar cada concepto desde
el nivel más básico posible. Cabe señalar que se espera que el lector tenga cierto
conocimiento del funcionamiento de una computadora. En particular, son necesarios
conocimientos básicos, como instalar y ejecutar programas, conocer y saber moverse
por la estructura de directorios de su sistema operativo, etc.
Este libro se ha escrito usando Windows y Mac, por lo que la instalación de las
herramientas de desarrollo presentada en el capítulo 2 se centra principalmente en
Windows. Sin embargo, es importante mencionar que el código que aquí se muestra
funciona en cualquier sistema operativo.
El contenido de este libro se ha dividido en 9 capítulos. El primer capítulo sienta las
bases para que el lector desarrolle habilidades de lógica, principalmente habilidades del

1
2 PREFACIO

pensamiento y de aritmética. Estas habilidades son necesarias para la implementación

y comprensión de programas. El capítulo 2 proporciona los fundamentos tanto de
algoritmos como de Python, con la finalidad de que el lector pueda dar seguimiento
(de forma fluida) a los conceptos que se presentan posteriormente. Los tres capítulos
siguientes abordan las estructuras de control de flujo con las que se puede realizar
cualquier programa de computadora. El capítulo 6 muestra las posibles formas de
estructurar los datos con los que se trabaja al momento de programar. El capítulo 7
nos presenta el concepto en programación de funciones, las cuales permiten mejorar la
calidad de nuestro código. El capítulo 8 es muy importante en esta sección se realiza un
breve análisis de la complejidad de los algoritmos con la finalidad de determinar cuáles
podrían darnos mejores resultados al programar. Finalmente, unas vez adquiridas las
habilidades de lógica y el conocimiento básico de un lenguaje como Python, se procede
a aplicar estas habilidades en programas enfocados a la programación competitiva.
 Convenciones usadas en este libro

Cuando se mencione en el texto algún elemento del lenguaje, éste aparecerá resal-
tado como la palabra hola.
Los ejemplos de código se muestran del siguiente modo:
1 def saludo () :
2 print ( " Hola mundo ... " )
3 print ( " Esta es mi primera función ... " )
4
5 saludo ()

Cuando ejecutamos el programa, tenemos como salida:

Hola mundo ...
Esta es mi primera función ...

Cada programa cuenta con números de línea para una mejor referencia. Siempre
que sea posible, los ejemplos de código van seguidos por la salida del programa (es
decir, el resultado de ejecutar el código).
Debido a su extensión, en el primer capítulo se van proponiendo ejercicios para el
lector por cada tema visto. En los siguientes capítulos, los ejercicios se proponen al
final.

3
4
Capítulo 1

Pensamiento Lógico

1.1. Habilidades del pensamiento

El concepto de habilidad del pensamiento está asociado a la capacidad de de-
sarrollo de procesos mentales que permitan resolver distintas situaciones. Existen
habilidades del pensamiento para expresar ideas con claridad, argumentar a partir de
la lógica, simbolizar situaciones, recuperar experiencias pasadas, etc. Cada habilidad
puede describirse en función del desempeño que puede alcanzar el sujeto.
“Desarrollar las habilidades básicas de pensamiento implica que el individuo logre
tanto la fase cognitiva —vivir el proceso— como las fase metacognitiva —darse cuenta
del proceso—. Su utilidad es doble: por un lado, sirven para la mayoría de los asuntos
cotidianos; por el otro, sirven de base para los asuntos que deseamos comprender de
manera más profunda, rigorosa, completa y clara.” 1

1.1.1. Lógica
Conceptos básicos
Lógica. Disciplina que estudia los métodos y principios que se usan para distinguir
el razonamiento bueno (correcto) del malo (incorrecto).

Inferencia. Proceso de razonamiento, compuesto por proposiciones, por el cual se

deriva o extrae una conclusión de una o varias premisas.

Enunciado. Entidad lingüística conformada por palabras.

Proposición. Información contenida en un enunciado que es verdadera o falsa.

Argumento. Conjunto de proposiciones que sirven de premisas que conducen a una

conclusión.
1
https://erikagh18.wixsite.com/ledama-y-asociados/single-post/2016/03/30/twitter-turns-10

5
6 Capítulo 1

Premisa. Proposición aseverada o supuesta que sirve de apoyo o razón para aceptar
la conclusión de un argumento.

Conclusión. Es la proposición aseverada con base en otras proposiciones (premi-

sas) del argumento.

Lógica proposicional
La lógica proposicional es el nivel más básico de la lógica, se encarga de analizar
las relaciones entre proposiciones, así como la verdad o la falsedad de éstas.

Elementos de la lógica proposicional

Variables.Las variables proposicionales son los símbolos que sustituyen a las pro-
posiciones. Se llaman de ese modo porque su significado cambia en las diferentes
argumentaciones o expresiones donde se utilicen.

Las letras más comunes para asignar las variables son p, q, r, s, t.

Conectores.Alteran, relacionan o conectan enunciados simples haciéndolos comple-

jos. Los más frecuentes son la negación (q), la conjunción (∧), la disyunción (∨), el
condicional (−→) y el bicondicional (←→).

Auxiliares.Cuando los enunciados complejos en un solo reglón son muchos, se utili-

zan los símbolos auxiliares. No tienen ningún significado lógico, pero se usan con el
objetivo de clarificar la comprensión de los enunciados. Los símbolos auxiliares son
los paréntesis (. . . ) y los corchetes [. . . ].

Inferencia lógica
Inferencia. Es un razonamiento, compuesto por proposiciones, por el cual se deriva
o extrae una conclusión de una o varias premisas.

El término Inferencia es considerado como sinónimo de “predicción”, “derivación”

o “deducción”.

Tipos de inferencia
1. Según el número de premisas
Inferencia inmediata. Es una forma de razonamiento que presenta una sola
premisa, de la cual derivamos una conclusión.
P: Si Lucía siempre es puntual
C: entonces, es falso que llegue tarde.
 Pensamiento Lógico 7

Inferencia mediata. Es una forma de razonamiento compuesto por dos o más

premisas de las cuales se deriva la conclusión.
P1. Todos los cuerpos se atraen.
P2. La Tierra y Venus son cuerpos.
C. La Tierra y Venus se atraen.

2. Según la forma de razonamiento

Inferencia deductiva. Es una forma de razonamiento cuya conclusión se deri-
va del contenido directo de las premisas enunciadas, haciendo referencia expresa
de los términos enunciados.
P1. Ningún mamífero nace del huevo.
P2. Toda ave nace del huevo.
C. Ningún ave es mamífero.

Inferencia inductiva. Es un razonamiento cuyas premisas representan casos

particulares de las cuales se deriva una conclusión que resulta un principio ge-
neral.
P1. El tucán tiene pico.
P2. La guacamaya tiene pico.
P3. La codorniz tiene pico.
C. Toda ave tiene pico.

1.1.2. Tablas de verdad

Conjunción
En razonamiento formal, una conjunción lógica (∧) entre dos proposiciones es
un conector lógico cuyo valor de la verdad resulta en cierto solo si ambas proposicio-
nes son ciertas, y en falso de cualquier otra forma.

Ejemplo
P=Está lloviendo
Q=Hace frío

P Q P∧Q
V V V
V F F
F V F
F F F

Tabla 1.1: Conjunción

8 Capítulo 1

Disyunción
En razonamiento formal, una disyunción lógica (o) entre dos proposiciones es
un conector lógico (∨), cuyo valor de la verdad resulta en falso solo si ambas propo-
siciones son falsas, y en cierto de cualquier otra forma.

Ejemplo
P=Está lloviendo
Q=Hace frío

P Q P∨Q
V V V
V F V
F V V
F F F

Tabla 1.2: Disyunción

Condicional
El condicional es una conectiva lógica que conecta dos proposiciones, representa-
do usualmente −→. En lógica proposicional, el condicional es una función de verdad
binaria, que se vuelve falso cuando Q es falsa siendo P verdadera, y se vuelve verda-
dero en cualquier otro caso.

Sea:
P=Está lloviendo
Q=Hace frío

P Q P−→Q
V V V
V F F
F V V
F F V

Tabla 1.3: Condicional

Bicondicional
El valor de verdad de un bicondicional «p si y solo si q» es verdadero cuando
ambas proposiciones (p y q) tienen el mismo valor de verdad, es decir, ambas son
verdaderas o falsas simultáneamente; de lo contrario, es falso.
 Pensamiento Lógico 9

Sea:
P=Está lloviendo
Q=Hace frío

P Q P←→Q
V V V
V F F
F V F
F F V

Tabla 1.4: Bicondicional

Negación
La negación, también llamada complemento lógico, es una operación sobre
proposiciones, valores de verdad, o en general, valores semánticos. Intuitivamente, la
negación de una proposición es verdadera cuando dicha proposición es falsa, y vice-
versa.

Ejemplo
P=Está lloviendo

P qP
V F
F V

Tabla 1.5: Negación

Construcción de las tablas de verdad

Ejemplo 1:
Construir la tabla de verdad de la siguiente proposición:
P−→(P∧qP)

P qP P∧qP P−→(P∧qP)
V F F F
F V F V

Tabla 1.6: Tabla de verdad de ejemplo 1

10 Capítulo 1

En la proposición solo se tiene una variable (es decir, P), esta variable puede tomar
dos valores: verdadero o falso (ver Tabla 1.6 columna 1). Cabe destacar que el número
de filas de una tabla se encuentra relacionado con el número de variables. Y la relación
es mediante la fórmula 2n , en donde n es el número de variables. Por ejemplo, si se
tienen 3 variables (P, Q, R), el número de filas de la tabla sería de 23 = 8.
Ya que se tienen definidos los valores de las variables (ver Tabla 1.6 columna 1),
como primer paso, se realiza lo que se encuentra entre paréntesis. Lo que implica
que se debe obtener la negación de P (segunda columna de Tabla 1.6). Teniendo la
negación de P, se procede a realizar lo que falta de la expresión que se encuentra
entre paréntesis (tercera columna de Tabla 1.6). Finalmente se realiza la expresión
completa (cuarta columna de Tabla 1.6).

Ejemplo 2:
Construir la tabla de verdad de la siguiente proposición:
(P∨Q)∨qQ

P Q P∨Q qQ (P∨Q)∨qQ
V V V F V
V F V V V
F V V F V
F F F V V

Tabla 1.7: Tabla de verdad de ejemplo 2

Primero vemos cuántas variables tiene la proposición, en este caso, son 2 (P y Q).
Utilizamos la fórmula 2n para determinar el número de filas de la tabla, que sería
22 = 4 (ver Tabla 1.7 columnas 1 y 2). En seguida, realizamos lo que se encuen-
tra entre paréntesis en la proposición, es decir, P ∨ Q (ver Tabla 1.7 columna 3).
Posteriormente, obtenemos la negación de Q (ver Tabla 1.7 columna 4). Finalmen-
te, resolvemos la expresión (ver Tabla 1.7 columna 5) con los datos obtenidos en las
columnas anteriores de la tabla.

Circuitos lógicos
Un circuito digital es aquel que maneja la información en forma binaria, es decir,
con valores de "1 y 0".

Estos dos niveles lógicos de voltaje fijos representan:

"1"nivel alto o "high"

"0"nivel bajo o "low"

 Pensamiento Lógico 11

Lógica y circuitos eléctricos

Podemos ver los valores "verdadero - falso", del predicado P, como valores "1 y
0". En donde un 0 equivale a falso y un 1 a verdadero.

Figura 1.1: Circuito eléctrico

Conjunción

La conjunción se representa mediante un circuito en serie. Recordemos que en la

conjunción para que un estado sea verdadero, ambas proposiciones deben ser verdade-
ras; para todos los demás casos, es falsa. Partiendo de esta definición de conjunción,
podemos representarla mediante un canal en el cual fluye corriente eléctrica. Este
canal tiene dos “puentes”, si los dos puentes están cerrados fluye la corriente hasta su
punto final. En cualquier otro caso, la energía deja de fluir.

Figura 1.2: Circuito eléctrico de la conjunción

Disyunción

Se representa mediante un circuito conectado en paralelo. Recordemos que en

la disyunción para que un estado sea falso, ambas proposiciones deben ser falsas;
para todos los demás casos, es verdadero. Partiendo de esta definición de disyunción,
12 Capítulo 1

podemos representarla mediante un canal en paralelo, en el cual fluye electricidad.

Este canal tiene dos “puentes”, si los dos puentes están abiertos deja de fluir la energía.
En cualquier otro caso, la energía fluye hasta el final del canal.

Figura 1.3: Circuito eléctrico de la disyunción

En resumen

Figura 1.4: Representación de los circuitos eléctricos

 Pensamiento Lógico 13

Ejemplo 1

Representar la siguiente proposición a su respectivo circuito lógico.

(qr∨qp) ∧ p

Solución:

Figura 1.5: Solución ejemplo 1

Ejemplo 2

Determinar la proposición lógica a partir del circuito lógico siguiente:

Figura 1.6: Circuito ejemplo 2

Solución

(p∨qq) ∧ [(qp∨qq) ∨ p] ∧ [(p ∧ p) ∨ r]

1.1.3. Ejercicios Lógica

1. Construye la tabla de verdad para la siguiente proposición:
14 Capítulo 1

(p ∧ q) −→ (q∧qp)

2. Construye la tabla de verdad para la siguiente proposición:

((p ∧ (q −→ r)) ∨ ((q∧qr) ←→qr)

3. Construye el circuito lógico para la siguiente proposición:

[(p ∨ q) ∧ ((r∧qq) ∨ (q∨qr))] ∨ [(qp ∨ (r∧qp))]

4. Construye el circuito lógico para la siguiente proposición:

[(r∨qq) ∧ ((p∧qq) ∨ (q∨qr))] ∧ r

5. Construye la proposición a partir del circuito lógico

Figura 1.7: Circuito lógico

1.1.4. Habilidades Lógico Matemáticas

Estas habilidades pueden ser definidas como nuestra capacidad de razonamiento
formal para resolver problemas relacionados con los números y las relaciones que se
pueden establecer entre ellos, así como para pensar siguiendo las reglas de la lógica.
“En la Inteligencia lógico-matemática se dan la mano la matemática y la lógica
porque pensar a través de ambas requiere seguir las normas de un sistema formal,
desprovisto de contenidos: uno más uno es igual a dos, sean lo que sean las unidades
con las que se trabaja, al igual que algo que es no puede no ser, independientemente de
lo que se trate. En definitiva, estar dotados en mayor o menor medida de inteligencia
lógico-matemática nos permite reconocer y predecir las conexiones causales entre las
 Pensamiento Lógico 15

cosas que pasan (si le añado 3 unidades a estas 5, obtendré 8 porque las he sumado,
etc.)” 2
Gracias a estas habilidades somos capaces de pensar de manera más o menos cohe-
rente, detectar regularidades en las relaciones entre las cosas y razonar lógicamente.

Acertijos
Los acertijos lógicos son pasatiempos o juegos que consisten en hallar la solución
de un enigma o encontrar el sentido oculto de una frase. Para resolver los acertijos
más comunes hay que hacer uso de la imaginación y de la capacidad de deducción[1].

La tienda misteriosa

Un hombre entra a una tienda y se produce la siguiente conversación con el tendero:

¯ ¿Cuánto cuesta 3? – pregunta el cliente.

¯ 400 pesos – responde el tendero.

¯ ¿Y cuánto cuesta 100? – pregunta el cliente.

¯ 400 pesos, también – responde el tendero.

¯ ¿Y cuánto cuesta 13? – pregunta el cliente.

¯ 500 pesos – responde el tendero.

¯ Está bien, me llevaré 22 – dice el cliente.

¯ Muy bien, van a ser 900 pesos – responde el tendero.

¿Qué se vende en esa tienda?

Solución:

En la tienda se venden letras (o rótulos con letras). Cada letra de cada palabra
cuesta 100 pesos.

El camión grande

Estás conduciendo un camión de 20 toneladas y 6 m de altura. De repente te

quedas atascado frente a un puente que tiene una altura máxima admitida de 5.98 m
(esto es: tu camión sobrepasa por 2 cm la altura permitida).

La carga que llevas es urgente y caduca (imaginémonos un cargamento de leche).

2
https://psicologiaymente.com/inteligencia/inteligencia-logico-matematica
16 Capítulo 1

Tienes que pasar necesariamente al otro lado del puente. Cerca del puente hay tien-
das donde venden sierras, taladradoras, pulidoras y otras herramientas.

¿Cuál es la solución más rápida?

Solución:

Lo más rápido fue desinflar las ruedas del camión.

El camino perdido

Conduces tu coche biplaza por una carretera perdida y nada transitada bajo una
intensa lluvia. De repente, encuentras a 3 personas refugiadas en un pequeño cobertizo
de 1 m2 : un antiguo amigo que una vez te salvó la vida y no tenías manera de volver
a contactar, una señora mayor de 60 años que necesita asistencia médica urgente o
morirá y la que, seguramente, podría ser la mujer de tu vida.

Nunca volverás a pasar por esa carretera, así que probablemente nunca vuelvas
a ver a esas personas. En tu coche solo puedes llevar a una persona más. ¿Qué harías?

Solución:

Idealmente, le pedirías a tu amigo que llevase a la anciana enferma al hospital mien-

tras te quedas esperando con la mujer de tu vida debajo del cobertizo a que tu amigo
te envíe un taxi.

Sudoku
Es un juego matemático que se inventó a finales de la década de 1970, adquirió
popularidad en Japón en la década de 1980 y se dio a conocer en el ámbito interna-
cional en 2005 cuando numerosos periódicos empezaron a publicarlo en su sección de
pasatiempos. El objetivo del sudoku es rellenar una cuadrícula de 9 × 9 celdas (81
casillas) dividida en subcuadrículas de 3 × 3 (también llamadas “cajas” o “regiones”)
con las cifras del 1 al 9 partiendo de algunos números ya dispuestos en algunas de las
celdas. Aunque se podrían usar colores, letras, figuras, se conviene en usar números
para mayor claridad, lo que importa es que sean nueve elementos diferenciados, que
no se deben repetir en una misma fila, columna o subcuadrícula. Un sudoku está bien
planteado si la solución es única, algo que el matemático Gary McGuire ha demos-
trado que no es posible si no hay un mínimo de 17 cifras de pista al principio.

Reglas y terminologías

El sudoku se presenta normalmente como una tabla de 9 × 9, compuesta por sub-

tablas de 3 × 3 denominadas “regiones” (también se le llaman “cajas” o “bloques”).
 Pensamiento Lógico 17

Algunas celdas ya contienen números, conocidos como “números dados” (o a veces

“pistas”). El objetivo es rellenar las celdas vacías, con un número en cada una de ellas,
de tal forma que cada columna, fila y región contenga los números 1–9 solo una vez.

Además, cada número de la solución aparece solo una vez en cada una de las tres
“direcciones”, de ahí el “los números deben estar solos” que evoca el nombre del juego.

Ejemplo:

Figura 1.8: Ejemplo sudoku

Conteo de figuras
Determinar cuántos cuadrados se encuentran en cada una de las figuras.

La respuesta es 5, puesto que hay 4 cuadros pequeños (digamos de dimensiones 1 ×

1), los cuales están contenidos dentro de un cuadro más grande (dimensiones 2 × 2).
18 Capítulo 1

La respuesta es 14, porque hay 9 cuadros pequeños (digamos de dimensiones 1×1).

Tenemos también 4 cuadros medianos (digamos de dimensiones 2×2). Finalmente, un
cuadro grande que contiene todos los cuadros (de dimensiones 3×3).

9 + 4 + 1 = 14

Determinar cuántos rectángulos hay en cada figura

En total hay 3 rectángulos, dos contenidos en uno más grande

2+1

En total hay 10 rectángulos

4+3+2+1

Completar valores
Completa los valores que faltan, sabiendo que el valor en cada círculo corresponde a
la suma de los valores en los dos círculos debajo.

Letras en desorden
Reto: Descubre los nombres de países que están escritos por las letras en desorden.
 Pensamiento Lógico 19

Ejemplo:

tagriarlne: Inglaterra

urpe: Perú

omlaiboc: Colombia

xmioec:

iaalit:

aiusr:

ianhc:

anadac:

1.1.5. Ejercicios de habilidades lógico-matemáticas

1. Resuelve el siguiente acertijo.

Homicidio en primer grado

Unos hábiles detectives llegaron a la escena de lo que parecía ser un homicidio y

hallaron a la víctima tendida en un camino rural. Las únicas pistas eran rodadas
de neumáticos marcadas en el barro de la poco transitada carretera. La pareja
de detectives, muy astutos ellos, siguieron las rodadas hasta un caserío, distante
alrededor de 1 km.

Había tres hombres sentados frente a la entrada y nada más de verlos dedujeron
quién era el sospechoso, aunque ninguno tenía coche ni las botas manchadas de
barro.

¿Cómo pudieron los detectives resolver el caso tan rápido?

2. Resuelve el siguiente sudoku.

20 Capítulo 1

3. Determina cuántos cuadrados se encuentran en la siguiente figura.

4. Determina cuántos rectángulos se encuentran en la siguiente figura.

5. Completa los valores que faltan, sabiendo que el valor en cada círculo corres-
ponde a la suma de los valores en los dos círculos debajo.
 Pensamiento Lógico 21

1.1.6. Teoría de conjuntos

La teoría de conjuntos se entiende como un contenido del área de matemáti-
cas, pero sus utilidades van mucho más allá del desarrollo del pensamiento lógico-
matemáticas. Comprender la teoría de conjuntos nos permite utilizar los conjuntos
como herramienta para analizar, clasificar y ordenar los conocimientos adquiridos
desarrollando la compleja red conceptual en la que almacenamos nuestro aprendizaje.

Conceptos básicos

CONJUNTO. Un conjunto es la agrupación, clase, o colección de objetos o

elementos que pertenecen y responden a la misma categoría. Los conjuntos se
pueden definir de cuatro formas:

1. Extensión o enumeración: Sus elementos son encerrados entre llaves

y separados por comas. Cada conjunto describe un listado de todos sus
elementos. Además, sus elementos no se repiten.
A = {a, e, i, o, u}
B = {0, 2, 4, 6, 8, 10}
2. Compresión: Sus elementos se determinan a través de una condición que
se establece entre llaves.
A = {x/x es una vocal}
B = {x/x es un número par menor que 11}
3. Diagramas de Venn: Regiones cerradas que nos permiten visualizar las
relaciones entre los conjuntos.
22 Capítulo 1

4. Descripción verbal: Se trata de un enunciado que describe una caracte-

rística común a todos los elementos del conjunto.

“A contiene a todos los animales que tienen esqueleto interno”.

ELEMENTO. Es cada uno de los objetos por los cuales está conformado un
conjunto. x ∈ A (El elemento x pertenece al conjunto A). El símbolo ∈
/ se utiliza
cuando un elemento no pertenece al conjunto.

SUBCONJUNTO. Sean los conjuntos A={ 0, 1, 2, 3, 5, 8 } y B={ 1, 2, 5

} En este caso decimos que B está contenido en A, o que B es subconjunto de
A. En general, si A y B son dos conjuntos cualesquiera, decimos que B es un
subconjunto de A si todo elemento de B lo es de A también.

∴ si B es un subconjunto de A se escribe B ⊆ A.

Si B no es subconjunto de A se indicará con una diagonal B * A.

TIPOS DE CONJUNTOS
Conjunto universo (U, Ω)

Se denomina así al conjunto formado por todos los elementos del tema de referen-
cia.
U = {x/x es un animal}
A = {x/x es un mamífero}
B = {x/x es un reptil}

Conjunto vacío ( { }, ∅ )

Se denomina así al conjunto que no tiene ningún elemento. A pesar de no tener

elementos se le considera como conjunto.
 Pensamiento Lógico 23

Ejemplos:
Conjunto de los meses del año que terminan en a.
Conjunto de números impares múltiplos de 2.

Conjunto unitario

Es el conjunto que tiene un solo elemento.

Ejemplo: Conjunto de los meses del año que tiene menos de treinta días, solamente
febrero pertenece a dicho conjunto.

Conjuntos disjuntos

Se llaman conjuntos disjuntos aquellos que no tienen ningún elemento que perte-
nezca a ambos al mismo tiempo.
Ejemplo: Los dos conjuntos siguientes:
{x/x es un número natural}
{x/x es un día de la semana}
Son disjuntos ya que no tienen ningún elemento común.

Conjuntos iguales

Los conjuntos son iguales, si tienen los mismos elementos, por ejemplo: El conjun-
to { a, b, c } también puede escribirse:
{ a, c, b }, { b, a, c }, { b, c, a }, { c, a, b }, { c, b, a }
En teoría de conjuntos se acostumbra a no repetir los elementos, por ejemplo:
El conjunto { b, b, b, d, d } simplemente será { b, d }.

Conjunto infinito

Es aquel conjunto cuya cantidad de elemento no se puede contar, es decir, es aquel

conjunto en que sus elementos no se pueden nombrar o enumerar. Son ejemplos de
conjuntos infinitos, los conjuntos numéricos: los naturales, los enteros, los reales, los
racionales, los imaginarios, los complejos.

OPERACIONES CON CONJUNTOS

Unión

La unión de dos conjuntos A y B es el conjunto A ∪ B que contiene cada elemento

que está por lo menos en uno de ellos.
24 Capítulo 1

Ejemplo:
U={1,2,3,4,5,6,7,8,9,10,11}
A={5,6,7,8,9,10}
B={2,4,6,8,10}
A ∪ B={2,4,5,6,7,8,9,10}

Figura 1.9: Gráfico de la unión de conjuntos

Intersección

La intersección de dos conjuntos A y B es el conjunto A ∩ B que contiene todos

los elementos comunes de A y B.
Ejemplos:
U={1,2,3,4,5,6,7,8,9,10,11}
A={5,6,7,8,9,10}
B={2,4,6,8,10}
A ∩ B={6,8,10}

Figura 1.10: Gráfico de la intersección de conjuntos

 Pensamiento Lógico 25

Resta

La diferencia entre dos conjuntos A y B es el conjunto A - B que contiene todos

los elementos de A que no pertenecen a B.
Ejemplos:
U={1,2,3,4,5,6,7,8,9,10,11}
A={5,6,7,8,9,10}
B={2,4,6,8,10}
A-B={5,7,9}

Figura 1.11: Gráfico de la resta de conjuntos

Complemento

El complemento de un conjunto A es el conjunto A que contiene todos los elemen-

tos (respecto de algún conjunto referencial) que no pertenecen a A.
Ejemplos:
U=1,2,3,4,5,6,7,8,9,10,11
A=5,6,7,8,9,10
A=1,2,3,4,11
26 Capítulo 1

Figura 1.12: Gráfico del complemento de conjuntos

1.1.7. Ejercicios de conjuntos

1. Dados los conjuntos A y B
A = {2,4,6,8,10,11,12,14,16}
B = {1,3,5,7,9,11,13,15,17}

Encuentre:
A∩B
A∪B
A-B
B-A

2. Dados los conjuntos A y B A = x/x es una letra del abecedario, a≤x≤m

B = x/x es una vocal
Encuentre:
A∩B
A∪B
A-B
B-A

3. Encuentre A ∪ B
A = {2,4,6,8,10,11,12,14,16}
B = {1,3,5,7,9,11,13,15,17}
U = {x/x es un número natural}, 1 ≤ x ≤ 25

4. Encuentre A ∩ B
A = {2,4,6,8,10,11,12}
B = {1,3,5,7,9,11,13}
U = x/x es un número natural, 1 ≤ x ≤ 15

5. En una clase se presentó un examen de dos preguntas:

15 personas respondieron bien la primera pregunta.
 Pensamiento Lógico 27

10 personas respondieron bien la segunda pregunta.

8 personas respondieron bien las dos preguntas.
5 personas no respondieron ninguna.
¿Cuántas estudiantes presentaron el examen? Represente gráficamente

1.2. Aritmética en la lógica

La aritmética3 es la rama de la matemática cuyo objeto de estudio son los números
y las operaciones elementales hechas con ellos: adición, sustracción, multiplicación y
división. Originalmente, la aritmética se desarrolló de manera formal en la Antigua
Grecia, con el refinamiento del rigor matemático y las demostraciones, y su exten-
sión a las distintas disciplinas de las «Ciencias Naturales». En la actualidad, puede
referirse a la aritmética elemental, enfocada a la enseñanza de la matemática básica;
también al conjunto que reúne el cálculo aritmético y las operaciones matemáticas,
específicamente, las cuatro operaciones básicas aplicadas, ya sea a números (números
naturales, números enteros, números fraccionarios, números decimales, etc.) como a
entidades matemáticas más abstractas (matrices, operadores, etc.).

1.2.1. Los números naturales

Los números naturales son una de las primeras herramientas matemáticas que usó
el ser humano; más concretamente cuando tuvo la necesidad de contar y ordenar4 .

Representación de los números naturales

El conjunto de los números naturales se puede representar en una recta. Partiendo
de un punto inicial, el 0, debes hacer marcas equidistantes (es decir, que haya la misma
distancia entre todas las marcas) a la derecha del 0. Las marcas se corresponderán
con los números 1, 2, 3, 4, . . .

De esta manera, puedes comparar dos elementos cualesquiera, pues al colocarlos

sobre la recta anteriormente dibujada, el que quede a la derecha será el mayor. Como
consecuencia, el número que queda a la izquierda es el menor.
Ejemplo:
5 es mayor que 2 y se representa 5>2
O también podemos decir que:
3
https://es.wikipedia.org/wiki/Aritmética
4
http://unarubiamatematica.com
28 Capítulo 1

2 es menor que 5 y se representa 2<5

OPERACIONES BÁSICAS CON NÚMEROS NATURALES

Suma o adición de números naturales

Operación interna: La suma de dos números naturales es otro número natural.

Propiedad conmutativa: El orden de los sumandos no altera el resultado: a + b

=b+a
Ejemplo
3+4=4+3=7

Propiedad asociativa: Para sumar tres o más números naturales, el orden en que
se haga no modifica el resultado: a + (b + c) = (a + b) + c
Ejemplo
2+(7+1) = (2+7)+1 = 10

El elemento neutro es el 0: a + 0 = 0 + a
Ejemplo
4+0=0+4=4

Resta o sustracción de números naturales

Operación no interna: La resta de dos números naturales no siempre es otro

número natural. Para que así fuera, el orden tiene que ser número mayor –
número menor.
Ejemplo:
6 – 9 no es un número natural porque no tiene sentido (hasta el momento)
quitarle 9 unidades a un conjunto cuando solo hay 6.

No se cumple la propiedad conmutativa: El orden de los factores altera el re-

sultado: a – b 6= b – a, pues una de esas operaciones no da como resultado un
número natural (por la propiedad anterior).
Ejemplo:
12 – 5 6= 5 – 12 porque 12 – 5 = 7 mientras que 5 – 12 no se puede hacer.

No se cumple la propiedad asociativa: Al restar tres o más números naturales,

el orden en que se haga modifica el resultado.
Ejemplo:
10 – (4 – 1) 6= (10 – 4) – 1
10 – 3 6= 6 – 1
7 6= 5
 Pensamiento Lógico 29

No hay elemento neutro: Al no darse la propiedad conmutativa, no existe ningún

elemento que la satisfaga, pero se puede decir que el 0 es el elemento neutro por
la derecha, pues a – 0 = a.
Ejemplo:
6 – 0 6= 0 – 6 porque 6 – 0 = 6 mientras que 0 – 6 no se puede hacer.

Multiplicación o producto de números naturales

Operación interna: El producto de dos números naturales es otro número natu-

ral.

Propiedad conmutativa: El orden de los factores no altera el producto: a · b =

b·a
Ejemplo:
5·4=4·5

Propiedad asociativa: Para multiplicar tres o más números naturales, el orden

en que se haga no modifica el resultado: a · (b · c) = (a · b) · c
Ejemplo:
6 · (2 · 5) = (6 · 2) · 5

El elemento neutro es el 1: a · 1 = 1 · a
Ejemplo:
12 · 1 = 1 · 12 = 12

Propiedad distributiva: Un factor que multiplica a una suma puedes escribirla

como la suma de los productos de dicho factor con los sumandos, es decir, a ·
(b + c) = a · b + a · c
Ejemplo:
3 · (6 + 2) = 3 · 6 + 3 · 2

Factor común: Una suma en la que los sumandos tienen un elemento en común,
puedes escribirla como el producto de dicho elemento y la suma de los sumandos
sin ese elemento. Es decir, a · b + a · c = a · (b + c)
Ejemplo:
2 · 5 + 2 · 7 = 2 · (5 + 7)

División o cociente de números naturales

Operación no interna: La división de dos números naturales no siempre es otro

número natural. Para que así fuera, el resto debería ser 0 o lo que es lo mismo,
la división exacta.
Ejemplo:
El resultado de dividir 3 entre 5 no es un número natural porque la división no
es exacta.
30 Capítulo 1

No se cumple la propiedad conmutativa: El orden de los factores altera el resul-

tado: a / b 6= b / a.
Ejemplo:
10 / 5 6= 5 / 10

No se cumple la propiedad asociativa: Al dividir tres o más números naturales,

el orden en que se haga modifica el resultado.
Ejemplo:
24 / (6 / 2) 6= (24 / 6) / 2
24 / 3 6= 4 / 2
8 6= 2

No hay elemento neutro: al no darse la propiedad conmutativa, no existe ningún

elemento que la satisfaga pero puedes decir que el 1 es el elemento neutro por
la derecha, pues a / 1 = a
Ejemplo:
25 / 1 = 25 pero 1 / 25 6= 25

No existe la división entre 0: Dividir entre 0 significaría repartir algo en 0 grupos;

al no haber grupos entre los que repartir, no tiene sentido hacer la división.

1.2.2. Ejercicios de números naturales

1. Un teatro tiene una capacidad máxima de 300 localidades. El día del estreno
de una obra se vendieron la mitad por teléfono y 50 a pie de taquilla.
¿Cuántas entradas quedaron por vender?
Si las entradas en taquilla cuestan $50.00 y las de venta telefónica $30.00. ¿Cuán-
to dinero habrá recaudado el teatro el día del estreno?

2. Elisa ha comprado 140 vestidos a $100.00 cada uno y los pone en venta a $150.00
la unidad.
Como solo consigue vender 30, los rebaja a $120.00, de modo que consigue
venderlos todos.
¿Qué beneficio ha obtenido por la venta de los vestidos?

3. Un restaurante tiene 20 docenas de huevos para hacer 10 bizcochos para una

tarta de boda y, con los huevos que sobren harán flanes.
Para cada bizcocho se emplean 6 huevos y para cada flan 5 huevos.
¿Cuántos flanes podrán hacerse?

1.2.3. Los números enteros

Cuando estudiamos los números naturales, viste que la resta no es una operación
interna pues no siempre el resultado será un número natural.
 Pensamiento Lógico 31

Y es que no es lo mismo quitarle 3 a 5 (es decir, 5 - 3 = 2), que a 3 quitarle

5 porque ¿cómo quitarle a un número una cantidad mayor? Para los casos en los
que la cantidad por sustraer es mayor, tendrás que hacer uso de los números enteros
negativos.
Los números enteros están formados por los números naturales, sus opuestos (es
decir, con un signo «-» delante) y el cero 0.
Por tanto, podemos definir un número entero como un elemento del conjunto.

Z = {...-3, -2, -1, 0, 1, 2, 3...}

Ampliando el conjunto de los números naturales, la aritmética va un paso más allá

para ofrecernos nuevas herramientas matemáticas con las que cubrir las necesidades
de nuestra vida diaria que los números naturales no pueden hacer.

Representación y orden de los números enteros

Al igual que el conjunto de los números naturales, un número entero se puede

representar en una recta. Partiendo de un punto inicial, el 0, debes hacer marcas
equidistantes (es decir, que haya la misma distancia entre todas las marcas) a la
derecha y a la izquierda del 0. Las marcas de la derecha se corresponderán con los
números 1, 2, 3, 4, . . . y las de la izquierda con el -1, -2, -3, -4, . . .

De esta manera, puedes comparar dos elementos cualesquiera, pues al colocarlos

sobre la recta anteriormente dibujada, el que quede a la derecha será el mayor.
Ejemplo:

2 es mayor que -3 y se representa 2 >-3.

Observa que cuando ambos enteros son negativos, el criterio es el mismo:
Ejemplo:

-5 es mayor que -8, -5 >-8, pues al dibujarlos en la recta queda a la derecha:

32 Capítulo 1

Valor absoluto
El valor absoluto de un número es la distancia de dicho número al 0 y se representa
con el número entre las llamadas barras de valor absoluto ||.
Ejemplo:
Así pues, el valor absoluto de 5, |5|, es 5 pues dista 5 unidades del 0 y el valor absoluto
de -8, | − 8|, es 8 porque la distancia es de 8 unidades respecto al 0.
Observa que el valor absoluto de un número es positivo pues las distancias siempre
son positivas.

OPERACIONES BÁSICAS CON NÚMEROS ENTEROS

Suma o adición de números enteros

Si ambos sumandos tienen el mismo signo, se suman los valores absolutos y se man-
tiene el signo:
Ejemplo:

5 + 9 = 14, siendo ambos positivos,

-3 + (-4) = -7, si los dos son negativos.

Observa que en el segundo ejemplo -4 está entre paréntesis. La razón es que no puede
haber nunca dos signos seguidos.
Si los sumandos tienen diferente signo, se restan los valores absolutos y se pone el
signo del sumando que tiene mayor valor absoluto.
Ejemplo:

Para hacer 5 + (-9) tienes que calcular los valores absolutos |5|=5, |-9|=9, restar-
los 9 – 5 = 4 y como -9 tiene mayor valor absoluto, el resultado será negativo, es
decir, 5 + (-9) = -4.

Y si tuvieras -3 + 4, restando los valores absolutos 4 – 3 = 1 el resultado sería -

3 + 4 = 1, con signo positivo pues 4 tiene mayor valor absoluto.

Propiedades de la suma de números enteros

Operación interna: La suma de dos números enteros es otro número entero.

Propiedad conmutativa: El orden de los sumandos no altera el resultado: a + b

= b + a.
Ejemplo:
-5 + 4 = 4 + (-5)

Propiedad asociativa: Para sumar tres o más números enteros, el orden en que
se haga no modifica el resultado: a + (b + c) = (a + b) + c
 Pensamiento Lógico 33

Ejemplo:
5 + (-7 + 4) = (5 + (-7)) + 4
5 + (-3) = -2 + 4
2=2

El elemento neutro es el 0: a + 0 = 0 + a
Ejemplo:
-5 + 0 = 0 + (-5)

El elemento opuesto de un número es aquel que hace que la suma valga 0: a +

(-a) = -a + a = 0
Ejemplo:
3 + (-3) = -3 + 3 = 0

Resta o sustracción de números enteros

Para restar dos números enteros no tienes más que transformar la resta en una
suma, a – b = a + (-b) y operar como en el paso anterior:
Ejemplo:
6 – 10 = 6 + (-10) = -4
-2 – 5 = -2 + (-5) = -7

Propiedades de la resta de números enteros

Operación interna: La resta de dos números enteros es otro número entero.

No se cumple la propiedad conmutativa: El orden de los factores altera el resul-

tado: a – b 6= b – a.
Ejemplo:
12 – 5 6= 5 – 12
7 6= -7

No se cumple la propiedad asociativa: Al restar tres o más números naturales,

el orden en que se haga modifica el resultado.
Ejemplo:
10 – (-4 – 1) 6= [10 – (-4)] – 1
10 – (-5) 6= 14 – 1
15 6= 13

No hay elemento neutro: Al no darse la propiedad conmutativa, no existe ningún

elemento que la satisfaga, pero puedes decir que el 0 es el elemento neutro por
la derecha, pues a – 0 = a
Ejemplo:
-3 – 0 = -3 pero 0 – (-3) = 3
34 Capítulo 1

Multiplicación o producto de números enteros

Para multiplicar dos números enteros tienes que multiplicar los valores absolutos
de ambos factores. El signo vendrá determinado por la siguiente regla:

Regla de los signos

Ejemplo:
4 · 8 = 32
4 · (- 8) = -32
-4 · 8 = -32
-4 · (- 8) = 32

Propiedades de la multiplicación de números enteros

Operación interna: El producto de dos números enteros es otro número entero.

Propiedad conmutativa: El orden de los factores no altera el producto: a · b =

b·a
Ejemplo:
6 · (-3) = -3 · 6

Propiedad asociativa: Para multiplicar tres o más números enteros, el orden en

que se haga no modifica el resultado: a · (b · c) = (a · b) · c
Ejemplo:
8 · [(-3) · 2] = [(8 · (-3)] · 2
8 · (-6) = -24 · 2
-48 = -48

El elemento neutro es el 1: a · 1 = 1 · a
Ejemplo:
-12 · 1 = 1 · (-12) = -12
 Pensamiento Lógico 35

Propiedad distributiva: Un factor que multiplica a una suma puedes escribirla

como la suma de los productos de dicho factor con los sumandos, es decir, a ·
(b + c) = a · b + a · c
Ejemplo:
-9 · (-6 + 5) = -9 · (-6) + (-9) · 5

Factor común: Una suma en la que los sumandos tienen un elemento en común,
puedes escribirla como el producto de dicho elemento y la suma de los sumandos
sin ese elemento. Es decir, a · b + a · c = a · (b + c)
Ejemplo:
2 · 5 + 2 · (-7) = 2 · [5 + (-7)]

División o cociente de números enteros

Para dividir dos números enteros tienes que dividir los valores absolutos de ambos
factores. El signo vendrá determinado por la siguiente regla:

Regla de los signos

Ejemplo:
54 / 6 = 9
54 / (- 6) = -9
-54 / 6 = -9
-54 / (- 6) = 9

Propiedades de la división de números enteros

Operación no interna: La división de dos números enteros no siempre es otro

número entero. Para que así fuera, el resto debería ser 0 o lo que es lo mismo,
la división exacta.
Ejemplo:
El resultado de dividir 5 entre 2 no es un número entero porque la división no
es exacta.
36 Capítulo 1

No se cumple la propiedad conmutativa: El orden de los factores altera el resul-

tado: a / b 6= b / a.
Ejemplo:
12 porciones de pizza divididas en 4 grupos dan como resultado 3 porciones en
cada grupo. Sin embargo, 4 porciones de pizza divididas entre 12 grupos no se
puede hacer porque hay más grupos que porciones.

No se cumple la propiedad asociativa: Al dividir tres o más números enteros, el

orden en que se haga modifica el resultado.
Ejemplo:
54 / (-9 / 3) 6= [54 / (-9)] / 3
54 / (-3) 6= -6 / 3
-18 6= -2

No hay elemento neutro: Al no darse la propiedad conmutativa, no existe ningún

elemento que la satisfaga pero puedes decir que el 1 es el elemento neutro por
la derecha, pues a / 1 = a.
Ejemplo:
-21 / 1 = -21; pero 1 / (-21) 6= -21

No existe la división entre 0: Dividir entre 0 significaría repartir algo en 0 grupos;

al no haber grupos entre los que repartir, no tiene sentido hacer la división.

1.2.4. Ejercicios de números enteros

1. Pedro tiene $2345.00 en el banco y le pasan una factura de $5351.00. ¿En qué
situación queda su cuenta bancaria?

2. Arquímedes fue uno de los matemáticos más importantes de la historia.

2225 años después de su nacimiento se inventó el primer ordenador, el Z1, en
1938. ¿En qué año nació Arquímedes?

3. La temperatura de un lugar descendió entre las 20:00 y las 2:00 del día siguiente
3 ºC cada hora.

a) ¿Cuántos grados bajó la temperatura en ese tiempo?

b) Si a las 20:00 hacía 7 ºC, ¿qué temperatura había a las 2:00?

4. Si salgo de casa con $30.00, compro tres entradas para un concierto de $7.00
cada una, recibo el dinero de las entradas de mis dos amigos y me gasto $4.00
en refrescos durante el concierto, ¿cuánto dinero me quedará?

1.2.5. Mínimo común múltiplo

En matemáticas, el mínimo común múltiplo (abreviado m.c.m.) de dos o más
números naturales es el menor número natural distinto de cero que es múltiplo común
 Pensamiento Lógico 37

de todos ellos (o el ínfimo del conjunto de los múltiplos comunes). Este concepto ha
estado ligado históricamente con números naturales, pero se puede usar para enteros
negativos o número complejo.

Cálculo del mínimo común múltiplo

Partiendo de dos o más números y por descomposición en factores primos, expre-
sados como producto de factores primos, su mínimo común múltiplo será el resultado
de multiplicar todos los factores comunes y no comunes elevados a la mayor potencia,
por ejemplo, el mcm de 72 y 50 será:

Tomando los factores con su mayor exponente, tenemos que:

mcm(72, 50) = 23 · 32 · 52 = 1800

Ejemplo:

1. Por motivos de trabajo David va a Zaragoza cada 15 días. Su compañera Pa-

tricia va cada 18 días. ¿Cada cuántos días coinciden?

Solución

David va a Zaragoza cada 15, 30, 45, 60,. . .

Patricia va a Zaragoza cada 18, 36, 54,. . .
Aplicamos el mcm(15,18)
38 Capítulo 1

Tomando los factores con su mayor exponente, tenemos que:

mcm(15, 18) = 2 · 32 · 5 = 90
En 90 días volverán a coincidir.

1.2.6. Ejercicio mcm

1. En una universidad hay dos actividades extraescolares:
un grupo de música, que se reúne a ensayar cada tres días y,
un equipo de fútbol, que entrena cada dos días.
¿Cada cuántos días coinciden los dos grupos?

1.2.7. Máximo común divisor

En matemáticas, se define el máximo común divisor (MCD) de dos o más números
enteros al mayor número entero que los divide sin dejar residuo alguno.

Cálculo del máximo común divisor

El máximo común divisor de dos números puede calcularse determinando la des-
composición en factores primos de los dos números y tomando los factores comunes
elevados a la menor potencia, el producto de los cuales será el MCD.
Ejemplo: para calcular el máximo común divisor de 48 y de 60 se obtiene de su
factorización en factores primos.

El MCD son los factores comunes con su menor exponente, esto es:
MCD(48,60) = 22 · 3 = 12

Ejemplo:
En una frutería se desea empaquetar 90 manzanas y 42 naranjas en bandejas. Cada
bandeja contiene el mismo número de piezas de fruta del mismo tipo. Además,
cada bandeja debe contener el mayor número posible de cada fruta.
 Pensamiento Lógico 39

1. a) Halla el número de piezas de fruta que debe ir en cada bandeja.

b) Halla el número de bandejas de manzanas y naranjas que se pueden obte-
ner.

Solución

1. Calculamos el MCD(90,42)

El MCD son los factores comunes con su menor exponente, esto es:
MCD(90,42) = 2 · 3 = 6

1. 6 frutas deben ir en cada bandeja

Para el inciso b), dividimos entre 6 que es el MCD de 90 y 42. Así, 90 manzana
entre 6 piezas por bandeja es igual a 15 y 42 naranjas entre 6 piezas por bandeja
es igual a 7.

2. Son 15 bandejas de manzanas y 7 bandejas de naranjas.

1.2.8. Ejercicios MCD

Se desea transportar 30 perros y 24 gatos en jaulas iguales de forma que todos
lleven el mismo número de animales.
Por todos es conocido que perros y gatos no pueden ir en la misma jaula porque
pueden surgir peleas entre ambas especies.
Para ahorrar en la compra de jaulas, se ha decidido que las jaulas sean lo más
grandes posibles.

1. ¿Cuántos animales irán en cada jaula?

2. ¿Cuántas jaulas se necesitarán para transportar a los perros? ¿Y para transpor-

tar a los gatos?
40 Capítulo 1
Capítulo 2

Fundamentos de algoritmos y de
Python

2.1. Introducción
En este capítulo se proporcionan los fundamentos tanto de algoritmos como de
Python, con la finalidad de tener bases sólidas que permitan dar seguimiento al libro.
Si te estás iniciando en el mundo de la programación se recomienda que no te saltes
este capítulo.

2.2. Definición y características de los algoritmos

Para implementar la solución de un problema mediante el uso de una computadora
es necesario establecer una serie de pasos que permitan resolver el problema. A este
conjunto de pasos se le denomina algoritmo, el cual debe tener como característica
final la posibilidad de transcribirlo fácilmente a un lenguaje de programación, para
esto se utilizan herramientas de programación, que son métodos que permiten la
elaboración de algoritmos escritos en un lenguaje entendible.
Un algoritmo, aparte de tener como característica la facilidad para transcribirlo,
debe ser[2]

1. Preciso. Debe indicar el orden en el cual debe realizarse cada uno de los pasos
que conducen a la solución del problema.

2. Definido. Esto implica que el resultado nunca debe cambiar bajo las mismas
condiciones del problema, éste siempre debe ser el mismo.

3. Finito. No se debe caer en repeticiones de procesos de manera innecesaria;

deberá terminar en algún momento.

Por consiguiente, el algoritmo es una serie de operaciones detalladas y no ambiguas

que se ejecutan paso a paso, que conducen a la resolución de un problema, y se

41
42 Capítulo 2

representan mediante una herramienta o técnica. O bien, es una forma de describir

la solución de un problema planteado en forma adecuada y de manera genérica.
Además de esto, se debe considerar que el algoritmo, que posteriormente se trans-
formará en un programa de computadora, debe considerar las siguientes partes:

Entrada: información de partida

Procesos: operaciones y cálculos por realizar

Salida: resultados obtenidos

Los pasos necesarios para realizar un algoritmo son:

1. Análisis del problema

2. Diseño del algoritmo para resolver el problema

3. Verificación del algoritmo

4. Implementación del algoritmo en algún lenguaje de programación

Hoy en día, el uso de la palabra algoritmo se refiere a cualquier procedimiento que

permita resolver un problema dado.

2.3. Identificadores
Los identificadores son los nombres que se les asignan a los objetos, los cuales se
pueden considerar como variables o constantes, éstos intervienen en los procesos que
se realizan para la solución de un problema, por consiguiente, es necesario establecer
qué características tienen.

2.3.1. Constante
Un identificador se clasifica como constante cuando el valor que se le asigna a este
identificador no cambia durante la ejecución o proceso de solución del problema. Por
ejemplo, en problemas donde se utiliza el valor de PI, si el lenguaje que se utiliza para
codificar el programa y ejecutarlo en la computadora no lo tiene definido, entonces
se puede establecer de forma constante estableciendo un identificador llamado PI y
asignarle el valor correspondiente de la siguiente manera:

PI = 3.1416.

De igual forma, se pueden asignar valores constantes para otros identificadores

según las necesidades del algoritmo que se esté diseñando.
 Fundamentos de algoritmos y de Python 43

2.3.2. Variables
Los identificadores de tipo variable son todos aquellos objetos cuyo valor cambia
durante la ejecución o proceso de solución del problema. Por ejemplo, el sueldo, el
pago, el descuento, etcétera, que se deben calcular con un algoritmo determinado, o,
en su caso, contar con el lado (L) de un cuadrado que servirá para calcular y obtener
su área.
A las variables del algoritmo se les identifica con un nombre. El nombre es una
cadena de caracteres alfanuméricos que debe empezar con una letra y pueden ser
mayúsculas o minúsculas. Dentro del nombre puede haber números o guiones bajos.
Es muy recomendable que los nombres de las variables tengan un nombre que tenga
relación con lo que representa. No puede haber dos variables con nombres iguales
dentro de un algoritmo. Dado que una letra mayúscula es distinta de una minúscula,
la variable VAR1 es distinta a var1 [3].
En todos los lenguajes de programación existe un conjunto de palabras reservadas
que no se pueden utilizar como nombres de variables. En el transcurso del libro iremos
conociendo muchas de las palabras reservadas de Python.

Tipos de variables
Los elementos que cambian durante la solución de un problema se denominan
variables y se clasifican dependiendo de lo que deben representar en el algoritmo,
por lo que pueden ser de tipo entero, real, lógica y string. Sin embargo, existen otros
tipos de variables que son permitidos con base en el lenguaje de programación que
se utilice para crear los programas, por consiguiente, al estudiar algún lenguaje de
programación se deben dar a conocer esas clasificaciones.
Para el caso de este libro, se denominará variables de tipo entero a todas
aquellas cuyo valor no tenga valores decimales. Por ejemplo: a=7 y b=-8 son variables
enteras.
Por su parte, las variables de tipo real podrán tomar valores con decimales. Por
ejemplo: a1=3.1416, b2=-30.23. También son variables reales aquellas que incluyen
una potencia como a_real=1.23 ×103 .
En caso de que las variables tomen valores de caracteres, se designarán string o
de cadena, por ejemplo: nombre=“Juan Pérez”, ocupación=“estudiante”, etc.
Una variable lógica es aquella que solamente toma los valores Verdadero o
Falso. Ejemplo de variables lógicas son:

Y=Verdadero
X=Falso

Inicialización de variables
Una manera de inicializar una variable es darle valor desde el inicio del algoritmo.
Esto lo podemos hacer al declarar las variables. Por ejemplo, una variable llamada
44 Capítulo 2

contador que inicialmente va a tener un valor de 0, la podemos declarar de la siguiente

forma:
Inicio
contador =0
hacer algo
Fin

Asignación de valores a variables

Las operaciones básicas se realizan de la manera tradicional. El resultado se asigna
a la variable donde se almacena el resultado. Por ejemplo, para almacenar la suma
de las variables a y b en la variable c, se realizaría de la siguiente manera:

c=a+b

Operaciones con variables enteras

Las operaciones (con excepción de la división), que se realizan con variables ente-
ras producen resultados enteros. Ejemplo, sea a=5 y b=2

a+b es 7
a-b es 3
a*b es 10

El resultado de la división en Python nos da un número real con punto decimal:

a/b es 2.5

Si deseamos obtener un resultado entero debemos usar doble símbolo de división:

a//b es 2

Usando la división entera nuestro resultado solo toma parte entera.

Operaciones con enteros y reales

A diferencia de otros lenguajes (como C, C++, Java, etc.), Python permite el
cambio de tipo de una variable. Por ejemplo, al guardar un resultado real en una
variable que era entera, ésta se cambia a tipo real.

2.4. Entradas y salidas de información

Los cálculos que realizan las computadoras requieren de entrada de datos para
ejecutar las operaciones que posteriormente se convertirán en resultados, es decir,
salidas.
 Fundamentos de algoritmos y de Python 45

Las operaciones de entrada (Leer) permiten leer valores y asignarlos a determina-

das variables.
Las operaciones de salida (Escribir) permiten mostrar los resultados que produce
el programa.

2.5. Pseudocódigo
Sin duda, en el mundo de la programación el pseudocódigo es una de las herra-
mientas más conocidas para el diseño de solución de problemas por computadora.
Esta herramienta permite pasar casi de manera directa la solución del problema a un
lenguaje de programación específico. El pseudocódigo es una serie de pasos claros y
bien detallados que conducen a la resolución de un problema.
La facilidad de pasar casi de forma directa el pseudocódigo a la computadora ha
dado como resultado que muchos programadores implementen de forma directa los
programas en la computadora, lo cual no es muy recomendable, sobre todo cuando
no se tiene la suficiente experiencia para tal aventura, pues se podrían tener errores
propios de la poca experiencia acumulada con la solución de diferentes problemas.
Por ejemplo, el pseudocódigo para determinar el área de un cuadrado se puede
establecer de la siguiente forma:
Inicio
Leer lado
area = lado * lado
Escribir area
Fin

Como se puede ver, se establece de forma precisa la secuencia de los pasos por
realizar; además, si se le proporciona siempre el mismo valor a la variable lado, el
resultado del volumen será el mismo y, por consiguiente, se cuenta con un final.

2.6. Un ejemplo que aplica todos los conceptos vistos

1. Escribir un algoritmo para calcular el área de un triángulo dada la base y la
altura. (Esta parte corresponde al análisis del problema).
Este problema ya se encuentra bien definido, el análisis consiste en determinar
las entradas y las salidas.
Como podemos ver, el ejercicio nos pide calcular el área de un triángulo dada la
base y la altura. Entonces, la palabra clave aquí es “dada”, ya que eso significa que
nuestras entradas serán la base y la altura. Con la base y con la altura, que nos
proporcionen podemos calcular el área del triángulo, la cual será nuestra salida.
Además, debemos definir los tipos de variables (entero, real, string) de nuestras
entradas y salidas. En este caso, es conveniente que tanto nuestras entradas como las
salidas sean reales. Es decir, que puedan considerar la parte fraccionaria.
46 Capítulo 2

2. Diseño del algoritmo

Entradas: base (real), altura (real)
Salidas: area (real)
1: Inicio
2: Leer base
3: Leer altura
4: area=(base*altura)/2
5: Escribir area
6: Fin
3. Comprobamos nuestro algoritmo mediante una prueba de escritorio.
Nos vamos al paso 2 del pseudocódigo. Entonces, supongamos que a la variable base
le asignamos un valor de 5.5, esto es base=5.5
Vamos al paso 3 del pseudocódigo. Ahora a nuestra variable altura le asignamos
un valor de 7.6, esto es altura=7.6
Continuamos con el paso 4 y calculamos el área mediante la fórmula ya bien
conocida: area = (5.5*7.6) / 2=20.9. El área para esta prueba es de 20.9. Finalmente,
escribimos el área y terminamos.

2.7. Python
Python es un lenguaje interpretado, de alto nivel y enfocado principalmente a la
legibilidad y facilidad de aprendizaje y uso.
Python es un lenguaje multiplataforma, lo que significa que puede usarse en mul-
titud de sistemas distintos. Funciona en computadoras con sistemas operativos Linux,
BSD, Windows, etc[4].
Python es software libre , y se distribuye bajo la licencia “Python Software Foun-
dation License”. Esto significa que se distribuye gratuitamente y no necesita del pago
de licencias para su uso, ya sea privado o comercial.
Guido van Rossum es el creador de Python; y la filosofía que quiso darle es que
el código debe ser limpio y legible, simple sin ser limitado. Dicha filosofía hace que
Python sea un lenguaje ideal para aprender e iniciarse en la programación.
Python es un lenguaje completo perfectamente funcional, muy potente, y viene
acompañado por una serie de paquetes que facilitan funciones para el trabajo con casi
cualquier cosa.

2.7.1. El zen de Python

El zen de Python (https://www.python.org/dev/peps/pep-0020/) viene a ser la
filosofía del lenguaje. Describe una serie de reglas que deberían seguirse tanto en el
desarrollo del propio lenguaje, como en los programas que se hagan con él.

Bello es mejor que feo

 Fundamentos de algoritmos y de Python 47

Explícito es mejor que implícito

Simple es mejor que complejo

Complejo es mejor que complicado

Plano es mejor que anidado

Disperso es mejor que denso

La legibilidad importa

Los casos especiales no son lo suficientemente especiales como para romper las
reglas

Aunque la practicidad gana a la pureza

Los errores nunca deberían pasar en silencio

A menos que se silencien explícitamente

Frente a la ambigüedad, evita la tentación de adivinar

Debería haber una (y preferiblemente solo una) manera obvia de hacerlo

Aunque pueda no ser obvia al principio, salvo que seas holandés

Ahora es mejor que nunca

Aunque nunca es mejor que el ahora correcto

Si la implementación es difícil de explicar, es una mala idea

Si la implementación es fácil de explicar, podría ser una buena idea

Los espacios de nombres son una idea genial. ¡Hagamos más de eso!

2.7.2. Instalación de Python y PyCharm en Windows

Antes de poder trabajar con Python necesitamos algunas herramientas. La pro-
gramación puede ser una labor compleja que requiere muchas herramientas, pero,
para comenzar a trabajar, nos bastará con el propio intérprete de Python y un editor
de texto adecuado (PyCharm).
48 Capítulo 2

Parte 1: Instalar Python

1. Ingresa a https://www.python.org/downloads/
2. Haz clic en Download Python 3.x.x

3. Ejecuta el instalador y selecciona ambas casillas, luego procede a instalarlo.

4. Comprueba la instalación escribiendo “python -V” en el CMD. De ser exitoso

deberías ver la versión instalada.
 Fundamentos de algoritmos y de Python 49

Parte 2: Instalar Pycharm

1. Ingresa a https://www.jetbrains.com/pycharm/download/#section=windows

2. Haz clic en Download Community

3. Ejecuta el instalador, selecciona las siguientes casillas y procede a instalarlo.

4. Inicia PyCharm, aparecerá este cuadro:

50 Capítulo 2

5. Deja la opción marcada y da clic en OK.

6. Dependiendo de tus gustos, selecciona el tema claro u oscuro.

7. Haz clic en Skip Remaining and Set Defaults

8. Aparecerá el siguiente cuadro:

9. Haz clic en la opción Create New Project. Aparece un cuadro donde pondrás lo
siguiente: Location: C:\...\PycharmProjects\NombreProyecto
 Fundamentos de algoritmos y de Python 51

Deja seleccionada la opción por default (New environment using), solo asegúrate
que en Base interpreter se encuentra la ubicación donde se instaló Python.

10. Aparece una ventana como la siguiente:

11. Haz clic en el menú File y selecciona la opción New.

52 Capítulo 2

12. Aparecerá otro menú donde debes seleccionar la opción Python File. Asigna
como nombre al archivo “saludo”.

Parte 3: Probar que Python funciona bien con Pycharm

1. Si realizaste los pasos anteriores, entonces tendrás una vista como la siguiente:
 Fundamentos de algoritmos y de Python 53

2. En el panel principal escribe el comando print(“Hola mundo”), haz clic dere-

cho en el mismo panel y selecciona la opción Run “saludo”.

3. En el panel inferior se despliega el resultado.

54 Capítulo 2

2.7.3. Estructura de un algoritmo en Python

Un algoritmo en Python tiene la misma estructura que hemos presentado para
un algoritmo en pseudocódigo. Lo único que cambia son las palabras reservadas y
algunos otros signos de sintaxis.
Al igual que en pseudocódigo, un algoritmo empieza con un nombre, que en este
caso no forma parte del código de Python y por lo tanto debe ser escrito como
comentario.
La estructura de un algoritmo en Python está en un algoritmo principal. Los
renglones de comentario deben principiar con un símbolo de numeral #. Para mostrar
datos se usa la instrucción print. Para recibir datos se tiene la instrucción input.

2.7.4. Variables
Las variables en Python son de cuatro tipos: enteras, reales, alfanuméricas y ló-
gicas, para las que se usan las palabras reservadas int, float, str y bool, respectiva-
mente.
Cada variable debe tener un nombre, el cual debe empezar con una letra y sola-
mente acepta letras, números y guiones bajos. El nombre de una variable no puede
tener acentos ni espacios.
Cada variable del programa consta de tres partes: nombre, tipo y valor. En
Python, una variable puede cambiar de tipo dentro del mismo algoritmo. En un
principio puede ser entera y más adelante podemos redefinirla como cadena o como
real. Por eso decimos que Python usa tipos dinámicos.
Una operación básica de un algoritmo es la asignación. Ésta consiste en asignarle
un valor a una variable. En Python para la asignación usamos el signo de igual =,
por ejemplo:
a =3.14 # Define una variable flotante
b =3 # Define una variable entera
cadena =" Juan " # Define una cadena o string
letra = ’a ’ # Define un caracter
booleano = True # Define un valor booleano
Para saber qué tipo de variable se está empleando usamos la instrucción type de
la siguiente manera:

>>>type(cadena)
<class ‘str’>
 Fundamentos de algoritmos y de Python 55

Donde vemos que la variable cadena es del tipo string. En las variables a, b,
cadena, letra, booleano hemos asignado valores a estas variables. Al mismo tiempo
que Python designa el tipo de la variable (con base al valor que asignamos).

2.7.5. Operadores
Los operadores indican las operaciones que deseamos realizar sobre las variables
y los datos. Existen cuatro tipos de operadores:

1. Aritméticos

2. Relacionales

3. Lógicos

4. De asignación

Operadores aritméticos

Los operadores aritméticos requieren dos datos para poder efectuarse. La tabla
2.1 proporciona una lista de los operadores aritméticos básicos

Operación Operador Ejemplo

Suma + a+b
Resta - a-b
Multiplicación * a*b
División / a/b
División entera // a // b
Potencia ** a ** b

Tabla 2.1: Operadores aritméticos

Las operaciones indicadas dan un resultado del mismo tipo si es que ambos opera-
dores son del mismo tipo. En el caso de que uno sea entero y otro sea real el resultado
es real.

Operadores relacionales

Los operadores relacionales aparecen cuando comparamos. La tabla 2.2 describe

los operadores relacionales.
56 Capítulo 2

Operación Operador Ejemplo

Mayor que > a >b
Menor que < a <b
Mayor o igual que >= a >= b
Menor o igual que <= a <= b
Igual a == a == b
Distinto a != a != b

Tabla 2.2: Operadores relacionales

Operadores lógicos

Los operadores lógicos se usan con variables lógicas (que también reciben el nombre
de variables boolenas). En estos operadores ambos datos deben ser datos lógicos. Si
a y b son variables lógicas, los operadores lógicos son los que se muestran en la tabla
2.3.

Operación Operador Ejemplo

not not not b
and and a and b
or or a or b

Tabla 2.3: Operadores lógicos

Operadores de asignación

Otros operadores de asignación de uso frecuente en Python se muestran en la tabla

2.4.

Python Operador Ejemplo

a=b = a=b
a=a+1 += a += 1
a=a-1 -= a -= 1
a=a*1 *= a *= 1
a=a/1 /= a /= 1
a = a% 1 %= a %= 1

Tabla 2.4: Operadores de asignación

En la tabla anterior, la columna 1 equivale a la columna 3 en Python, claro, la

notación cambia, pero es lo mismo.
 Fundamentos de algoritmos y de Python 57

El operador % obtiene el residuo de la división de dos números enteros y se conoce

como la función módulo. Solamente se puede usar con números enteros. Por ejemplo,
el resultado de 5 % 2 es 1 que es el residuo de 5/2.

2.7.6. Jerarquía de operadores

En Python las expresiones se evalúan normalmente de izquierda a derecha.
La excepción son las asignaciones ya que, lógicamente, la parte derecha de una
asignación debe resolverse antes de hacer dicha asignación. Dentro de cada expresión,
se evalúan las operaciones según la siguiente lista, de arriba abajo:

() (Paréntesis)
** (Potencia)
* (multiplicación), / (división), // (división entera), % (módulo)
+ (suma), - (resta)
>(mayor que), <(menor que), >= (mayor o igual que),
<= (menor o igual que), == (igualdad), != (desigualdad)
“not” (negación)
“and” (y lógica)
“or” (o lógica)

Tabla 2.5: Jerarquía de operaciones

Ejemplo
¿Cuál es el resultado de la siguiente expresión?
-4 * 7 + 2 ** 3 / 4 – 5

De acuerdo con la jerarquía de operaciones presentada en la tabla anterior, en esta

expresión primero se realiza la potencia. Quedándonos de la siguiente manera:
-4 * 7 + 8 / 4 - 5

Seguimos con multiplicaciones y divisiones que tienen igual jerarquía. En este ca-
so, se empieza de izquierda a derecha, así tenemos entonces:
-28 + 2 – 5

Finalmente, realizamos la suma y la resta que tienen igual jerarquía, pero tomando
en cuenta que se va a empezar a operar de izquierda a derecha. Quedando el resultado
siguiente:
-31

Si quisiéramos representar en Python la siguiente expresión:

a+b
dato = (2.1)
2
58 Capítulo 2

Una manera incorrecta de representar esa fórmula en Python es expresarlo de la

forma siguiente:

dato = a + b / 2

Es incorrecto porque por la jerarquía de operaciones, primero se realizaría la divi-

sión antes que la suma; y en realidad queremos que primero se haga la suma y después
se divida sobre 2. La forma correcta de expresar la fórmula anterior es:

dato =( a + b )/2

2.7.7. Palabras reservadas

Las palabras reservadas o keywords de Python son aquellos nombres que incorpora
el lenguaje los cuales no pueden ser reemplazados por un valor determinado (funcio-
nes, clases, variables) o alterar su funcionamiento. Por lo tanto, la lista de keywords
en Python 3 resulta ser la siguiente.

False None True and as assert async await break

class continue def del elif else except finally
for from global if import in is lambda nonlocal
not or pass raise return try while with yield

Tabla 2.6: Palabras reservadas

2.7.8. Comentarios
En Python existen dos maneras de escribir líneas de comentarios. La primera es
usando el símbolo de numeral # al principio de cada renglón de comentario, como en:

# Este es un reglón de comentario.

Otra forma de usar los comentarios es después de una instrucción, por ejemplo:

a = b + c #Ejemplo de suma

Lo que aparece después del símbolo de numeral # no se ejecuta.

La segunda manera es por lo general más usada cuando hay varias líneas de co-
mentarios. El párrafo de comentarios abre con tres apóstrofos “ ‘ y se termina con tres
apóstrofos ” ’, por ejemplo:
 Fundamentos de algoritmos y de Python 59

“‘Este es un conjunto de líneas

de comentarios que usan la forma
alternada de indicar comentarios.”’
60 Capítulo 2
Capítulo 3

Estructuras secuenciales

3.1. Introducción
Para la solución de cualquier problema que se vaya a representar mediante pseu-
docódigo o código de Python, siempre tendremos que representar mediante letras,
abreviaciones o palabras completas los elementos que intervienen en el proceso de so-
lución. A estos elementos se les denomina variables o constantes. Por ejemplo: precio,
horas_trabajadas, edad, etc.
Con base en esto, para facilitar la lectura de un algoritmo se recomienda crear una
tabla donde se declaran las variables que se utilizarán y sus características o tipo, tal
y como se muestra en la tabla 3.1, que muestra las variables que se utilizarían para
obtener el área de un cuadrado.

Nombre de la variable Descripción Tipo

lado Lado del cuadrado Real, Float
area Área del cuadrado Real, Float

Tabla 3.1: Declaración de las variables que se utilizarán para obtener el área de un
rectángulo.

Como se puede ver en la tabla 3.1, se utilizará la variable lado para representar el
lado del cuadrado, a la cual se les podrán asignar diferentes valores. Al utilizar esos
valores y aplicar la fórmula correspondiente se podrá obtener el área del cuadrado,
la cual es asignada a la variable denominada area. Además, se describe que esas
variables son de tipo real, lo cual implica que podrán tomar valores fraccionarios,
pero también pudieron haber sido enteras.

3.2. Estructuras de control

Sin importar qué herramienta o técnica se utilice para la solución de un problema
dado, ésta tendrá una estructura, que se refiere a la secuencia en que se realizan

61
62 Capítulo 3

las operaciones o acciones para resolver el problema; esas estructuras pueden ser:
secuenciales, de selección y de repetición, las cuales se analizarán en su momento.
Debe tenerse presente que la solución de un problema dado mediante el uso de
una computadora es un sistema, por lo que debe tener una entrada de datos que serán
procesados para obtener una salida, que es la solución o información que se busca.
En la figura 3.1 se muestra el esquema de un sistema que transforma los datos en
información mediante un proceso.

Figura 3.1: Sistema de transformación

3.3. Estructuras secuenciales

En este tipo de estructura las instrucciones se realizan o se ejecutan una después

de la otra y, por lo general, se espera que se proporcione uno o varios datos, los
cuales son asignados a variables para que con ellos se produzcan los resultados que
representen la solución del problema que se planteó. Los algoritmos tienen como fin
actuar sobre los datos proporcionados por el usuario, a los que se les aplican procesos
con el objetivo de generar la información o un resultado. El algoritmo es realmente
la representación funcional de un sistema, como el que se muestra en la figura 3.1.
Para resolver un problema mediante la utilización de cualquier herramienta es
necesario entender y establecer con qué datos se cuenta, los procesos que se deben
realizar y la secuencia apropiada para obtener la solución que se desea.

3.3.1. Ejemplo suma de dos números

Se desea implementar un algoritmo para obtener la suma de dos números cuales-

quiera. Se debe partir de que para poder obtener la suma es necesario contar con dos
números, pues el proceso que debemos realizar es precisamente la suma de éstos, la
cual se asigna a una variable que se reporta como resultado del proceso.
Los pasos por seguir son los mostrados en el pseudocódigo 1, que corresponde al
 Estructuras secuenciales 63

algoritmo que permite determinar la suma de dos números cualesquiera.

Algoritmo 1: Suma de dos números
Entradas: a (entero), b (entero)
Salidas: suma (entero)
1: Inicio
2: Leer a
3: Leer b
4: suma=a+b
5: Escribir suma
6: Fin
Al representar la solución del problema con pseudocódigo, se está utilizando un
lenguaje común, sólo que de una forma ordenada y precisa.
Es recomendable indicar mediante una tabla las variables que se utilizan, seña-
lando lo que representan y sus características, esta acción facilitará la lectura de la
solución de un problema dado. Para el problema de la suma de dos números, la tabla
3.2 muestra las variables utilizadas en la solución.

Nombre de la variable Descripción Tipo

a Primer número a sumar Entero, Int
b Segundo número a sumar Entero, Int
suma Resultado de la suma Entero, Int

Tabla 3.2: Variables utilizadas para determina la suma de dos números cualesquiera

La representación del algoritmo en Python sería como el que se muestra en el

programa 3.1.
1 a = int ( input ( " Introduce el primer valor a sumar : " ) )
2 b = int ( input ( " Introduce el segundo valor a sumar : " ) )
3 suma = a + b
4 print ( f " La suma es : { suma } " )
Programa 3.1: Suma de dos enteros
Cuando se ejecuta el programa se tiene como salida:
Introduce el primer valor a sumar : 12
Introduce el segundo valor a sumar : 20
La suma es : 32

Entradas en Python
La función input nos permite leer los datos que se introducen mediante el teclado.
Dicha función recibe como argumento una cadena, la cual le indica al usuario lo que
debe realizar. En el programa 3.1, los argumentos de la función input son las cadenas:
“Introduce el primer valor a sumar: ” e “Introduce el segundo valor a sumar: ”. La
función input devuelve una cadena, que corresponde al dato que el usuario introdu-
ce. Para este ejemplo el valor devuelto por input no se puede asignar directamente
64 Capítulo 3

a las variables a y b, ya que como dijimos anteriormente, dichos valores son cadenas.
Entonces, lo que se tiene que hacer es convertir las cadenas a enteros mediante la
función int, la cual recibe como argumento el dato que queremos convertir a entero.
Con la conversión realizada procedemos a almacenar los datos proporcionados por el
usuario en sus respectivas variables, quedando de la siguiente forma:

a=int(input(“Introduce el primer valor a sumar: ”))

b=int(input(“Introduce el segundo valor a sumar: ”))

Salidas en Python

Una vez que la información introducida por el usuario fue procesada, es necesario
mostrarla de alguna forma. Al proceso de mostrar dicha información se le denomina
salida. En Python la salida estándar se muestra en la pantalla de la computadora, y
dicha salida es mostrada gracias a la función print, la cual recibe como argumento
la información que se quiere mostrar.
Con base en el programa 3.1, tenemos que la salida queda de la siguiente forma:

print(f“La suma es: {suma}”)

Analicemos como funciona print. Primero, vemos que recibe como argumento la
cadena f“La suma es: {suma}”. Donde suma es la variable que almacenó la suma
de los dos números introducidos por el usuario. La f y las llaves {} que están en la
cadena permiten que se puedan imprimir los valores de las variables. Esto quiere decir
que si, por ejemplo, en print se hubiera puesto como argumento la cadena “La suma
es: suma”, en lugar de mostrar el valor de la variable suma, se hubiera mostrado la
palabra suma. Entonces, es indispensable poner la f antes de introducir la cadena y
usar las llaves para incluir el valor de la variable que se quiere mostrar.

3.3.2. Ejemplo área y perímetro de un rectángulo

Se requiere conocer el área y el perímetro de un rectángulo. Realiza un algoritmo

para tal fin y represéntalo mediante un diagrama de flujo y el pseudocódigo para
realizar este proceso.
Como se sabe, para poder obtener el área del rectángulo, primero se tiene que
conocer la base y la altura, y una vez obtenidas se calcula el resultado.
La tabla 3.3 muestra las variables que se van a utilizar para elaborar el algoritmo
correspondiente.
 Estructuras secuenciales 65

Nombre de la variable Descripción Tipo

base Base del rectángulo Real, Float
altura Altura del rectángulo Real, Float
area Área del rectángulo Real, Float
perimetro Perímetro del rectángulo Real, Float

Tabla 3.3: Área y perímetro de un rectángulo

Fórmulas para calcular área y perímetro del rectángulo:

Área=base*altura
Perímetro=2*base+2*altura

La estructura del pseudocódigo 2 muestra el algoritmo que permite obtener el área

y el perímetro del rectángulo.
Algoritmo 2: Rectángulo
Entradas: base (real), altura (real)
Salidas: area (real), perimetro (real)
1: Inicio
2: Leer base
3: Leer altura
4: area=base*altura
5: perimetro=2*base+2*altura
6: Escribir perimetro
7: Escribir area
8: Fin
La representación del algoritmo en Python sería como el que se muestra en el
programa 3.2.
1 # Entradas
2 base = float ( input ( " Introduce la base : " ) )
3 altura = float ( input ( " Introduce la altura : " ) )
4 # Proceso
5 area = base * altura
6 perimetro =2* base +2* altura
7 # Salidas
8 print ( f " El área del rectángulo es : { area } " )
9 print ( f " El perímetro del rectángulo es : { perimetro } " )
Programa 3.2: Rectángulo
Cuando ejecutamos el programa, tenemos como salida:
Introduce la base : 15
Introduce la altura : 7
El área del rectángulo es : 105.0
El perímetro del rectángulo es : 44.0
66 Capítulo 3

La función float

Ya habíamos explicado el uso de la función int, la cual recibe como argumento

un elemento (por ejemplo, una cadena, un valor real, etc.) y convierte ese elemento a
entero. La función float tiene el mismo objetivo, que es convertir un elemento que
recibe como argumento. Cabe señalar que dicha conversión será a un valor real.
Dado el análisis que se realizó en el pseudocódigo 2, se llega a la conclusión de
que la base y la altura del rectángulo son de tipo real. Por lo que en programa 3.2 se
utiliza la función float, para convertir a real los valores que el usuario introduzca.

3.3.3. Bibliotecas
Muy a menudo, Python requiere usar funciones que vienen en bibliotecas (el con-
cepto es similar a una biblioteca de la vida real, por ejemplo, si se necesita una in-
formación vamos a la biblioteca y consultamos el libro que tiene dicha información).
Estas bibliotecas deben llamarse antes de usar las funciones de ella. Por ejemplo, las
funciones trigonométricas, la raíz cuadrada, los logaritmos, etc., vienen incluidos en la
biblioteca de funciones matemáticas denominada math. Para poder usar sus funciones
en nuestro programa usamos al principio del programa lo siguiente:
import math

Y para usar las funciones usamos, por ejemplo, para obtener el coseno de π:

math.cos(math.pi)

Lo que da como resultado:

-1.0

Donde hemos usado la función cos y la constante pi que son parte de la biblioteca
math. Otra forma de importar las funciones de una biblioteca es usando:

from math import *

Al hacer esto ya no necesitamos escribir el nombre de la biblioteca cada vez que

usamos una función. Ya simplemente escribimos la función como en:

cos(pi)

Algunas funciones de la biblioteca math se dan en la siguiente tabla:

 Estructuras secuenciales 67

Función Ejemplo
Valor absoluto math.abs(-5)
Función exponencial math.exp(1)
Potencia ab math.pow(2,3)
Raíz cuadrada math.sqrt(9.0)
Coseno de un ángulo en radianes math.cos(0.7)
Seno de un ángulo en radianes math.sin(0.707)
Tangente de un ángulo en radianes math.tan(1)
Obtención de valor de pi math.pi
Obtención de valor de e math.e
... ...

3.3.4. Ejemplo área de una circunferencia

Se requiere obtener el área de una circunferencia. Realizar el algoritmo correspon-
diente y representarlo mediante pseudocódigo y código en Python.
De igual forma que en los problemas anteriores, es importante establecer la tabla
de variables que se utilizarán para la solución del problema, pero previamente se
analizará qué se requiere para obtener el área de la circunferencia.
Si se analiza la fórmula que se utiliza para tal fin, se puede establecer que se
requiere solamente un valor de radio y que se debe dar un valor constante, que es
el valor de PI (3.14. . . ). Con esto se puede establecer la tabla 3.4 con las variables
correspondientes.

Nombre de la variable Descripción Tipo

radio Radio de la circunferencia Real, Float
pi El valor de 3.141... Real, Float
area Área de la circunferencia Real, Float

Tabla 3.4: Área de la circunferencia

Fórmulas para calcular área de la

circunferencia:
area = P I ∗ radio2

La estructura del pseudocódigo 3 muestra el algoritmo que permite obtener el área

 68 Capítulo 3

de la circunferencia.
Algoritmo 3: Área circunferencia
Entradas: radio (real)
Salidas: area (real)
1: Inicio
2: Leer radio
3: area=pi*radio2
4: Escribir area
5: Fin
La representación del algoritmo en Python sería como el que se muestra en el
programa 3.3.
1 from math import pi
2
3 radio = float ( input ( " Introduce el radio de la circunferencia : " ) )
4 area = pi *( radio **2)
5 print ( f " El área de la circunferencia es : { area } " )
Programa 3.3: Circunferencia

Cuando ejecutamos el programa, tenemos como salida:

Introduce el radio de la ci rcunfe rencia : 10
El área de la ci rcunfe rencia es : 3 1 4 . 1 5 9 2 6 5 3 5 8 9 7 9 3

Previamente se mencionó el uso de la biblioteca math, la cual se incorpora a este

programa. Para este ejemplo en particular solo se necesita el uso de la constante pi,
por ese motivo es lo único que se importa de math (ver la primera línea del programa).
Si se hubieran requerido más funcionalidades de math, entonces hubiera sido necesario
usar la línea siguiente al inicio del programa.

from math import *

3.3.5. Ejemplo intercambio de variables

Se requiere intercambiar el valor de dos variables, que almacenan valores introdu-
cidos por el usuario. Por ejemplo, si a=10 y b=20, entonces el resultado debe ser a=20
y b=10. Realizar el algoritmo correspondiente y representarlo mediante pseudocódigo
y código en Python.
Primero, establecemos nuestra tabla de variables que utilizaremos para la solución
del problema.

Nombre de la variable Descripción Tipo

a Almacena el primer valor Entero, Int
b Almacena el segundo valor Entero, Int

Tabla 3.5: Variables

 Estructuras secuenciales 69

El pseudocódigo 4 muestra el algoritmo que permite hacer el cambio de valores

de las variables.
Algoritmo 4: Intercambia variables
Entradas: a (entero), b (entero)
Salidas: a (con el nuevo valor), b (con el nuevo valor)
1: Inicio
2: Leer a
3: Leer b
4: copia=a
5: a=b
6: b=copia
7: Escribir a
8: Escribir b
9: Fin
Se leen los valores de a y b, posteriormente se saca una copia a la variable a (línea
4 del pseudocódigo 4). Esta copia es indispensable porque en la línea 5 se sobreescribe
el valor de a con el valor de b. Eso quiere decir que tanto a como b tienen el mismo
valor. Sin embargo, como ya se había guardado el valor original de a (en la variable
copia), simplemente se asigna este valor a la variable b (línea 6). Finalmente, se
escriben los valores intercambiados de a y b.
El programa 3.4 es la codificación en Python del algoritmo anterior:
1 # Entradas
2 a = int ( input ( " Introduce el valor de a : " ) )
3 b = int ( input ( " Introduce el valor de b : " ) )
4 # Proceso
5 copia = a
6 a=b
7 b = copia
8 # Salidas
9 print ( f " El nuevo valor de a es : { a } " )
10 print ( f " El nuevo valor de b es : { b } " )
Programa 3.4: Intercambia variables

Cuando ejecutamos el programa, tenemos como salida:

Introduce el valor de a : 10
Introduce el valor de b : 20
El nuevo valor de a es : 20
El nuevo valor de b es : 10

3.3.6. Ejemplo producción de leche

Un productor de leche lleva el registro de lo que produce en litros, pero cuando
entrega, le pagan en galones. Realiza un algoritmo, represéntalo en pseudocódigo y
escribe un programa en Python que ayude al productor a saber cuánto recibirá por
la entrega de su producción de un día (1 galón = 3.785 litros).
 70 Capítulo 3

Si se analiza el problema se puede establecer que los datos que se necesitan para
resolver el problema son los que se muestran en la tabla 3.6.
Nombre de la variable Descripción Tipo
litros_producidos Cantidad de litros producidos Real, Float
precio_galon El precio del galón Real, Float
galones Cantidad de galones que produce Real, Float
pago_total Ganancia por la entrega de la leche Real, Float

Tabla 3.6: Variables

El pseudocódigo 5 muestra el algoritmo que permite al productor saber cuánto

recibirá por la entrega de su producción de un día.
Algoritmo 5: Producción de leche
Entradas: litros_producidos (real), precio_galon (real)
Salidas: pago_total (real)
1: Inicio
2: Leer litros_producidos
3: Leer precio_galon
4: galones = litros_producidos / 3.785
5: pago_total = galones * precio_galon
6: Escribir pago_total
7: Fin
El programa 3.5 es la codificación en Python del algoritmo anterior:
1 litro s_produc idos = float ( input ( " Introduce los litros producidos : " ) )
2 precio_galon = float ( input ( " Introduce el precio del galón : " ) )
3 galones = litro s_produc idos /3.785
4 pago_total = galones * precio_galon
5 print ( f " La ganancia por la entrega de la leche es : { pago_total :.2 f } "
)
Programa 3.5: Producción leche
Para este programa solo se desea mostrar dos decimales, por esa razón después
de la variable pago_total (última línea del programa) se incluye la notación :.2f.
Si se requirieran más decimales solo se cambia el 2 por el valor de decimales que se
necesitan.
Como salida se obtiene lo siguiente:
Introduce los litros producidos : 10
Introduce el precio del galón : 20
La ganancia por la entrega de la leche es : 52.84

3.3.7. Ejemplo sueldo semanal

Se requiere determinar el sueldo semanal de un trabajador con base en las horas
que trabaja y el pago por hora que recibe. Realiza el pseudocódigo y el programa en
Python que representen el algoritmo de solución correspondiente.
 Estructuras secuenciales 71

Para obtener la solución de este problema es necesario conocer las horas que labora
cada trabajador y cuánto se le debe pagar por cada hora de trabajo, con base en esto
se puede determinar que las variables que se requieren utilizar son las que se muestran
en la tabla 3.7.

Nombre de la variable Descripción Tipo

horas_trabajadas Horas trabajadas Real, Float
pago_hora El pago por hora Real, Float
sueldo_semanal Sueldo semanal Real, Float

Tabla 3.7: Variables sueldo semanal

El pseudocódigo 6 muestra el algoritmo que permite determinar el sueldo semanal

de un trabajador.
Algoritmo 6: Sueldo semanal
Entradas: horas_trabajadas (real), pago_hora (real)
Salidas: sueldo_semanal (real)
1: Inicio
2: Leer horas_trabajadas
3: Leer pago_hora
4: sueldo_semanal = horas_trabajadas * pago_hora
5: Escribir sueldo_semanal
6: Fin
El siguiente programa es la codificación en Python del algoritmo 6.
1 horas_trabajadas = float ( input ( " Introduce las horas trabajadas : " ) )
2 pago_hora = float ( input ( " Introduce el pago por hora : " ) )
3

4 sueldo_semanal = horas_trabajadas * pago_hora

5
6 print ( f " El sueldo semanal del trabajador es de : { sueldo_semanal :.2 f }
")
Programa 3.6: Intercambia variables

El programa 3.6 tiene como salida:

Introduce las horas trabajadas : 23
Introduce el pago por hora : 34.765
El sueldo semanal del trabajador es de : 799.60

3.4. Ejercicios
1. Se tienen tres variables A, B y C. Escribir las instrucciones necesarias para
intercambiar sus valores entre sí del modo siguiente:

B toma el valor de A
72 Capítulo 3

C toma el valor de B
A toma el valor de C

2. Una modista, para realizar sus prendas de vestir, encarga las telas al extranjero.
Para cada pedido, tiene que proporcionar las medidas de la tela en pulgadas,
pero ella generalmente las tiene en metros. Realice un algoritmo para ayudar
a resolver el problema, determinando cuántas pulgadas debe pedir con base en
los metros que requiere. Represéntalo mediante pseudocódigo y programa en
Python (1 pulgada = 0.0254 m).

3. Una empresa importadora desea determinar cuántos dólares puede adquirir con
equis cantidad de dinero mexicano. Realiza el pseudocódigo y el programa en
Python.

4. Una empresa que contrata personal requiere determinar la edad de las personas
que solicitan trabajo, pero cuando se les realiza la entrevista sólo se les pregunta
el año en que nacieron. Realiza el pseudocódigo y el programa en Python que
representen el algoritmo para solucionar este problema.
Capítulo 4

Estructuras selectivas

4.1. Introducción
Los problemas que se han presentado hasta el momento no implican cuestiona-
mientos como: “qué pasa si quiere comprar golosinas”, o bien, “qué pasa si no hay
lugares para la película que quería ver”, esto en el algoritmo de ir al cine, donde se
puede seguir haciendo muchos cuestionamientos que conducen a tomar una decisión.
Por consiguiente, los algoritmos, en determinados momentos, requieren ser selectivos
en lo que respecta a las acciones que deben seguir.
Es por eso que las estructuras selectivas son importantes para los algoritmos, de
modo que en la mayoría de los problemas se tiene presente una estructura selectiva
que implica seguir o no un determinado flujo de secuencia del problema en cuestión.

4.2. Estructuras selectivas

En los algoritmos para la solución de problemas donde se utilizan estructuras
selectivas se emplean frases que están estructuradas de forma adecuada dentro del
pseudocódigo. Existen dos tipos de estructuras selectivas: simples y compuestas.
La estructura de una selectiva simple tiene la forma:
Algoritmo 7: Estructura selectiva simple
1: si condicion es verdadera entonces
2: Hacer acción 1
3: fin_si

Como se muestra en la estructura selectiva, ésta devuelve un valor verdadero

o falso, a partir de la condición que se establezca. Si es verdadero se realizan las
acciones que se encuentren dentro de la estructura, las cuales son aquellas que tengan
un espaciado mayor (ver línea 2 de algoritmo 7) al de dicha estructura.

73
 74 Capítulo 4

Ejemplo: Se requiere determinar si una persona es mayor de edad.

Algoritmo 8: Selectiva simple ejemplo
Entradas: edad
Salidas:
1: Leer edad
2: si edad>=18 entonces
3: Escribir “Eres mayor de edad”
4: fin_si

El programa 4.1 muestra la codificación en Python del algoritmo para saber si una
persona es mayor de edad. Primero, se pide al usuario que introduzca su edad, la cual
es almacenada en la variable edad. Posteriormente, mediante una selectiva simple (if)
analizamos si la edad es mayor o igual a 18 (condición). Si edad es mayor o igual a
18 se imprime una cadena con el texto “Eres mayor de edad”.
1 edad = int ( input ( " Escribe tu edad : " ) )
2
3 if edad >=18:
4 print ( " Eres mayor de edad ... " )
Programa 4.1: Mayor de edad
El programa 4.1 tiene como salida:
Escribe tu edad : 24
Eres mayor de edad ...

Por su parte, una selectiva compuesta tiene la forma:

Algoritmo 9: Estructura selectiva compuesta
1: si condicion es verdadera entonces
2: Hacer acción 1
3: de_lo_contrario
4: Hacer acción 2
5: fin_si

En la estructura selectiva compuesta si la condición es verdadera se realizan las

acciones dentro del si. Si no es verdadera, se realizan las acciones que se encuentran
en el de_lo_contrario.
Ejemplo: Determinar si una persona es mayor o menor de edad.
Algoritmo 10: Selectiva compuesta ejemplo
Entradas: edad
Salidas:
1: Leer edad
2: si edad>=18 entonces
3: Escribir “Eres mayor de edad”
4: de_lo_contrario
5: Escribir “Eres menor de edad”
6: fin_si
 Estructuras selectivas 75

El programa 4.2 muestra la codificación en Python del algoritmo para saber si

una persona es mayor o menor de edad. Primero se pide al usuario que introduzca
su edad, la cual es almacenada en la variable edad. Posteriormente, mediante una
selectiva compuesta (if-else) analizamos si la edad es mayor o igual a 18 (mayoría de
edad en México). Si edad es mayor o igual a 18 se imprime una cadena con el texto
“Eres mayor de edad”. En caso contrario, se imprime la cadena “Eres menor de edad”.

1 edad = int ( input ( " Escribe tu edad : " ) )

2
3 if edad >=18:
4 print ( " Eres mayor de edad ... " )
5 else :
6 print ( " Eres menor de edad ... " )

Programa 4.2: Mayor y menor de edad

El programa 4.2 tiene como salida:

Escribe tu edad : 12
Eres menor de edad ...

4.2.1. Ejemplo: Dados dos valores determinar el mayor

Se desea implementar un algoritmo para determinar cuál de dos valores propor-

cionados es el mayor. Representarlo con pseudocódigo y programa en Python.
Como primer paso elaboramos la tabla de variables (Tabla 4.1), para tener la idea
clara de las variables que utilizaremos en este ejemplo.

Nombre de la variable Descripción Tipo

a Primer valor para comparar Entero, Int
b Segundo valor para comparar Entero, Int
mayor Resultado de la comparación Entero, Int

Tabla 4.1: Variables del ejemplo

Como se puede ver en el pseudocódigo 11, se comparan los dos valores leídos (a y
b) mediante una estructura selectiva compuesta. Si el valor a es mayor a b, entonces
la variable mayor toma el valor de a. En caso contrario, la variable mayor toma el
 76 Capítulo 4

valor de b. Finalmente, se imprime el valor de la variable mayor.

Algoritmo 11: Ejemplo determinar el valor mayor
Entradas: a (entero), b (entero)
Salidas: mayor (entero)
1: Inicio
2: Leer a
3: Leer b
4: si a>b entonces
5: mayor=a
6: de_lo_contrario
7: mayor=b
8: fin_si
9: Escribir mayor
10: Fin
El programa 4.3 muestra la codificación del algoritmo para obtener el mayor de dos
valores. Primero se leen los valores de a y b. Posteriormente, mediante la instrucción
if se realiza una comparación para determinar el valor mayor. Si a es mayor que b,
entonces la variable mayor toma el valor de a. De lo contrario (else, línea 6), mayor
toma el valor de b. Finalmente, se imprime el valor de la variable mayor.
1 a = int ( input ( " Escribe el valor de a : " ) )
2 b = int ( input ( " Escribe el valor de b : " ) )
3
4 if a > b :
5 mayor = a
6 else :
7 mayor = b
8

9 print ( f " El valor mayor es : { mayor } " )

Programa 4.3: Determina el valor mayor de a y b

El programa 4.3 tiene como salida:

Introduce el valor de a : 10
Introduce el valor de b : 2
El valor mayor es : 10

4.2.2. Ejemplo: Determinar si un número es positivo o nega-

tivo
Como se ha venido trabajando, para resolver cualquier problema se debe partir
de la base de conocer qué variables son necesarias, sobre todo en aquéllos problemas
que no requieren de muchos identificadores en el proceso de solución. Cuando esto
sucede se puede generar la tabla de variables, aunque es posible establecerla al final
o paralelamente al momento de la solución del problema, ya que a medida que se
avanza con la solución surge la necesidad de utilizar nuevas variables.
 Estructuras selectivas 77

La tabla 4.2 muestra las variables que se requieren en la solución del problema.

Nombre de la variable Descripción Tipo

n Valor a verificar Entero, Int
R Guarda el resultado Cadena, String

Tabla 4.2: Variables del ejemplo valor positivo o negativo

El pseudocódigo 12 representa el algoritmo que permite determinar si el número

que se proporciona es positivo o negativo.
Algoritmo 12: Ejemplo determinar si un número es positivo o negativo
Entradas: n (entero)
Salidas: R (entero)
1: Inicio
2: Leer n
3: si n>=0 entonces
4: R=“POSITIVO”
5: de_lo_contrario
6: R=“NEGATIVO”
7: fin_si
8: Escribir R
9: Fin
Como se puede ver, para determinar si un número es positivo o negativo, solo es
necesario establecer si éste es mayor o igual a cero; si el resultado de la comparación
es afirmativa, a la variable R se le asignará el valor de “POSITIVO”, si resulta una
negación, por consiguiente, el valor que tome R será de “NEGATIVO”.
Ahora, el programa 4.4 muestra el algoritmo que permite obtener la solución del
problema.
1 n = int ( input ( " Introduce el número a verificar : " ) )
2
3 if n >= 0:
4 R = " POSITIVO "
5 else :
6 R = " NEGATIVO "
7
8 print ( f " El valor { n } es { R } " )
Programa 4.4: Determina si es POSITIVO o NEGATIVO

El programa 4.4 tiene como salida:

Introduce el número a verificar : -2
El valor -2 es NEGATIVO
 78 Capítulo 4

4.2.3. Ejemplo: “CompuMax”

La tienda de computadoras “CompuMax” tiene una promoción: a todas las compu-
tadoras con un precio superior a $15,500.00 se les aplicará un descuento de 16 %. A
todos los demás equipos se les aplicará sólo el 7 %. Realiza un algoritmo para de-
terminar el precio final que debe pagar una persona por la compra de un equipo y
de cuánto es el descuento que obtendrá. Represéntalo mediante el pseudocódigo y el
código en Python.
El pseudocódigo 13 representa el algoritmo para determinar el descuento y el
precio final que tendrá un determinado equipo de cómputo.
Algoritmo 13: Ejemplo CompuMax
Entradas: costo_equipo (real)
Salidas: descuento (real), precio_final (real)
1: Inicio
2: Leer costo_equipo
3: si costo_equipo>15500 entonces
4: descuento=costo_equipo * 0.16
5: de_lo_contrario
6: descuento=costo_equipo * 0.07
7: fin_si
8: precio_final=costo_equipo-descuento
9: Escribir precio_final
10: Escribir descuento
11: Fin
Con base en el pseudocódigo que se estableció se puede obtener la tabla 4.3, que
contiene las variables que intervienen en el proceso de solución del problema.

Nombre de la variable Descripción Tipo

costo_equipo Precio del equipo de Cómputo Real, Float
descuento Descuento a aplicar al equipo Real, Float
precio_final Precio final del equipo Real, Float

Tabla 4.3: Variables del ejemplo CompuMax

El código en Python que da solución a este ejercicio se muestra a continuación:

1 costo_equipo = float ( input ( " Introduce el costo del equipo : " ) )
2
3 if costo_equipo >15500:
4 descuento = costo_equipo *0.16
5 else :
6 descuento = costo_equipo *0.07
7
8 precio_final = costo_equipo - descuento
9 print ( f " El precio a pagar es : { precio_final } " )
 Estructuras selectivas 79

10 print ( f " El descuento es : { descuento } " )

Programa 4.5: CompuMax

El programa 4.5 tiene como salida:

Introduce el costo del equipo : 23456
El precio a pagar es : 19703.04
El descuento es : 3752.96

4.3. Estructuras if-elif-else

Hasta ahora, los problemas vistos solo presentan una decisión para realizar un
determinado proceso; sin embargo, en algunas ocasiones es necesario elaborar es-
tructuras selectivas en cascada, esto significa que después de haber realizado una
comparación selectiva es necesario realizar otras comparaciones selectivas.
Ejemplo: se requiere saber si un número es positivo, negativo o cero.
El pseudocódigo 14 nos muestra la solución a este ejercicio. Primero se lee el núme-
ro que se va a procesar. Posteriormente, se inicia con la estructura si-delocontrarioSi-
delocontrario, donde primero se evalúa si numero es mayor que cero. Si el número
es mayor que cero, entonces se escribe el texto “el número es positivo”, y termi-
namos. En caso contrario, pregunta si numero es igual a cero, si esto es verdadero,
entonces se escribe el texto “El número es cero” y finalizamos. Si numero no es
mayor que cero ni es cero, entonces se va al último caso donde se imprime el texto
“El número es negativo” y terminamos.
Algoritmo 14: Positivo, negativo o cero
Entradas: numero (entero)
Salidas:
1: Inicio
2: Leer numero
3: si numero>0 entonces
4: Escribir “El número es positivo”
5: de_lo_contrario si numero==0 entonces
6: Escribir “El número es cero”
7: de_lo_contrario
8: Escribir “El número es negativo”
9: fin_si
10: Fin
El código en Python muestra el funcionamiento de la estructura if-elif-else (si-
delocontrarioSi-delocontrario, en pseudocódigo). Primero se lee el número que se
va a analizar y se evalúa, si es mayor a cero se imprime el texto “El número es
positivo’’ y terminamos, si no, si numero es igual a cero se imprime “El número
es cero” y termina. De lo contrario (si no es mayor que cero ni es cero), se escribe
el texto “El número es negativo” y fin.
 80 Capítulo 4

1 numero = int ( input ( " Escribe un número : " ) )

2

3 if numero > 0:
4 print ( " El número es positivo " )
5 elif numero == 0:
6 print ( " El número es cero " )
7 else :
8 print ( " El número es negativo " )
Programa 4.6: Positivo negativo o cero

El programa 4.6 tiene como salida:

Escribe un número : 0
El número es cero

4.3.1. Ejemplo: Calculadora

Construir un programa que simule el funcionamiento de una calculadora que pue-
de realizar las cuatro operaciones aritméticas básicas (suma, resta, multiplicación y
división). El usuario debe especificar la operación con el primer carácter del nombre
de la operación.

S o s para la suma

R o r para la resta

P o p o M o m para la multiplicación

D o d para la división

Procedemos a identificar las variables que utilizaremos para resolver este ejercicio.
Para este fin, la tabla 4.4 describe dichas variables.

Nombre de la variable Descripción Tipo

num1 Primer número a operar Real, Float
num2 Segundo número a operar Real, Float
operacion Operación por realizar Cadena, String
resultado Almacena el resultado Real, Float

Tabla 4.4: Variables del ejemplo calculadora

Con la tabla anterior, procedemos a diseñar nuestro pseudocódigo (ver pseudocó-

digo 15). Primero leemos los valores para operar (num1 y num2), así como la operación
por realizar con ellos (suma, resta, multiplicación o división). El carácter almacenado
 Estructuras selectivas 81

en la variable operación se convierte a mayúsculas, con la finalidad de que el usua-

rio pueda escribir S o s en el caso de la suma; y así para cualquier otra operación.
Evidentemente también dicha operación se pudo convertir a minúsculas.
Algoritmo 15: Calculadora
Entradas: num1 (real), num2 (real)
Salidas: resultado (real)
1: Inicio
2: Leer num1
3: Leer num2
4: Leer operacion
5: Convertir operacion a mayúsculas
6: si operacion==‘S’ entonces
7: resultado=num1+num2
8: Escribir resultado
9: de_lo_contrario si operacion==‘R’ entonces
10: resultado=num1-num2
11: Escribir resultado
12: de_lo_contrario si operacion==‘P’ or operacion== ‘M’ entonces
13: resultado=num1*num2
14: Escribir resultado
15: de_lo_contrario si operacion==‘D’ entonces
16: resultado=num1/num2
17: Escribir resultado
18: de_lo_contrario
19: Escribir “Operación incorrecta”
20: fin_si
21: Fin
Ahora, mediante la estructura si-delocontrarioSi-delocontrario, se procede
a evaluar los posibles casos. Si operación es “S”, entonces en la variable resultado se
almacena el valor de la suma de los números leídos al inicio y se imprime él resultado.
De lo contrario, si operación es “R”, la variable resultado almacena la resta de num1
y num2 e imprime el resultado. De lo contrario, si operación es P o M, realiza la
multiplicación de ambos números, almacena el resultado en la variable resultado
e imprime dicha variable. De lo contrario, si operación es “D”, realiza la división de
num1 sobre num2, almacena el resultado y lo imprime. Si operación no es ninguno de
los casos descritos anteriormente, entra al último caso e imprime el texto “Operación
incorrecta”.
El código en Python de este ejercicio se describe a continuación:
1 num1 = float ( input ( " Escribe el primer número : " ) )
2 num2 = float ( input ( " Escribe el segundo número : " ) )
3 operacion = input ( " Escribe la operación a realizar : " ) . upper ()
4
5 if operacion == ’S ’:
6 resultado = num1 + num2
 82 Capítulo 4

7 print ( f " El resultado es : { resultado :.2 f } " )

8 elif operacion == ’R ’:
9 resultado = num1 - num2
10 print ( f " El resultado es : { resultado :.2 f } " )
11 elif operacion == ’P ’ or operacion == ’M ’ :
12 resultado = num1 * num2
13 print ( f " El resultado es : { resultado :.2 f } " )
14 elif operacion == ’D ’:
15 resultado = num1 / num2
16 print ( f " El resultado es : { resultado :.2 f } " )
17 else :
18 print ( " Operación incorrecta " )
Programa 4.7: Calculadora

El programa 4.7 tiene como salida:

Escribe el primer número : 5
Escribe el segundo número : 6
Escribe la operación a realizar : h
Operación incorrecta

4.3.2. Ejemplo: Las brisas del caracol

“Las brisas del caracol” es una empresa dedicada a ofrecer banquetes; sus tarifas
son las siguientes: el costo de platillo por persona es de $95.00, pero si el número de
personas es mayor a 200 pero menor o igual a 300, el costo es de $85.00. Para más de
300 personas el costo por platillo es de $75.00. Se requiere un algoritmo que ayude a
determinar el presupuesto que se debe presentar a los clientes que deseen realizar un
evento. Mediante pseudocódigo y un programa en Python que represente su solución.
Procedemos a establecer la tabla de variables (ver tabla 4.5).

Nombre de la variable Descripción Tipo

can_personas Cantidad de personas Entero, Int
costo_platillo Costo del platillo Real, Float
pago_total El pago por el banquete Real, Float

Tabla 4.5: Variables del ejemplo “Las brisas del caracol”

El pseudocódigo 16 representa la solución a este ejercicio. Primero se necesita sa-

ber la cantidad de personas que asistirán al banquete, este paso se realiza en la línea
2. Posteriormente, mediante una estructura si-delocontrarioSi-delocontrario, procede-
mos a evaluar los posibles casos que se pueden presentar. El primer caso (línea 3), nos
dice si el número de personas está entre 1 y 200, el costo de platillo es de 95. De lo
contrario, si el número de personas es superior a 200 pero menor o igual a 300 (línea
5), entonces el costo del platillo es de 85. En caso contrario (línea 7), si el número de
personas es mayor de 300 el costo del platillo es de 75. Finalmente, si la cantidad de
 Estructuras selectivas 83

personas no cae en ningún caso (por ejemplo, se digita un valor negativo), entonces
se notifica que se ha producido un error.
Algoritmo 16: Las brisas del caracol
Entradas: can_personas (Entero)
Salidas: pago_total (Entero)
1: Inicio
2: Leer can_personas
3: si can_personas>=1 and can_personas<=200 entonces
4: costo_platillo=95
5: de_lo_contrario si can_personas>200 and can_personas<=300 entonces
6: costo_platillo=85
7: de_lo_contrario si can_personas>300 entonces
8: costo_platillo=75
9: de_lo_contrario
10: Escribir “Error: cantidad de personas incorrecto”
11: fin_si
12: pago_total=costo_platillo*can_personas
13: Escribir pago_total
14: Fin
El programa en Python 4.8 es la solución al este ejercicio:
1 can_personas = int ( input ( " Introduce la cantidad de personas : " ) )
2

3 costo_platillo =0
4 if can_personas >=1 and can_personas <=200:
5 costo_platillo =95
6 elif can_personas >200 and can_personas <=300:
7 costo_platillo =85
8 elif can_personas >300:
9 costo_platillo =75
10 else :
11 print ( " Error : cantidad de personas incorrecto " )
12
13 pago_total = can_personas * costo_platillo
14 print ( f " El costo del banquete es : { pago_total } " )
Programa 4.8: Calculadora
El programa 4.8 tiene como salida:
Introduce la cantidad de personas : 245
El costo del banquete es : 20825

4.4. Ejercicios
1. Realiza un algoritmo para determinar cuánto se debe pagar por equis cantidad
de lápices considerando que si son 500 o más el costo es de 75¢; de lo contrario,
el precio es de 80¢. Represéntalo con el pseudocódigo y el programa en Python.
84 Capítulo 4

2. Realiza un algoritmo para determinar el sueldo semanal de un trabajador con

base en las horas trabajadas y el pago por hora, considerando que después de las
40 horas cada hora se considera como excedente y se paga el doble. Construye
el pseudocódigo y el programa en Python.

3. El dueño de un estacionamiento requiere un pseudocódigo con el algoritmo

que le permita determinar cuánto debe cobrar a sus clientes por el uso del
estacionamiento. Las tarifas que se tienen son las siguientes:

Las dos primeras horas a $5.00 c/u.

Las siguientes tres a $4.00 c/u.
Las cinco siguientes a $3.00 c/u.
Después de diez horas el costo por cada una es de dos pesos.

4. Se requiere un algoritmo para determinar cuál de tres cantidades proporcionadas

es la mayor. Represéntalo mediante pseudocódigo y programa en Python.

5. El director de una escuela está organizando un viaje de estudios, y requie-

re determinar cuánto debe cobrar a cada alumno y cuánto debe pagar a la
compañía de viajes por el servicio. La forma de cobrar es la siguiente: si son 100
alumnos o más, el costo por cada alumno es de $65.00; de 50 a 99 alumnos, el
costo es de $70.00, de 30 a 49, de $95.00, y si son menos de 30, el costo de la
renta del autobús es de $4000.00, sin importar el número de alumnos. Realiza un
algoritmo que permita determinar el pago a la compañía de autobuses y lo que
debe pagar cada alumno por el viaje (representa en pseudocódigo y programa
en Python la solución).

6. La asociación de vinicultores tiene como política fijar un precio inicial al kilo

de uva, la cual se clasifica en tipos A y B, y además en tamaños 1 y 2. Cuando
se realiza la venta del producto, ésta es de un solo tipo y tamaño, se requiere
determinar cuánto recibirá un productor por la uva que entrega en un embarque,
considerando lo siguiente: si es de tipo A, se le cargan 20¢ al precio inicial
cuando es de tamaño 1, y 30¢ si es de tamaño 2. Si es de tipo B, se rebajan
30¢ cuando es de tamaño 1, y 50¢ cuando es de tamaño 2. Realiza un algoritmo
para determinar la ganancia obtenida y represéntalo mediante pseudocódigo y
programa en Python.
Capítulo 5

Estructuras repetitivas

5.1. Introducción
Hasta el momento, las soluciones planteadas a los problemas propuestos han sido
para una persona, un objeto o cosa, pero siempre de manera unitaria, tanto en las
soluciones que se plantearon con estructuras secuenciales como con las selectivas;
sin embargo, debemos considerar que, cuando se plantean problemas como calcular
un sueldo, cabe la posibilidad de que el cálculo se tenga que hacer para dos o más
empleados, un proceso de cálculo que por lógica debe ser el mismo para cada uno,
pero donde existe la posibilidad de que los parámetros que determinan ese sueldo sean
los que cambien. Por tal motivo se emplean estructuras denominadas repetitivas, de
ciclo o de bucle, e independientemente del nombre que se les aplique, lo que importa
es que permiten que un proceso pueda realizarse N veces, donde solo cambien los
parámetros que se utilizan en el proceso.

5.2. Estructuras repetitivas o de ciclo

Cuando se requiere que un proceso se efectúe de manera cíclica, se emplean es-
tructuras que permiten el control de ciclos. Esas estructuras se emplean con base en
las condiciones propias de cada problema, los nombres con los que se conocen éstas
son: “Mientras que” y “Desde, hasta que”. En la figura 5.1 se presentan las formas de
estas estructuras mediante pseudocódigo.

Figura 5.1: Estructuras repetitivas

Para el caso de la estructura “Mientras que”, el ciclo se repite hasta que la condición
lógica resulta ser falsa; además, como se puede ver en la figura 5.1, en dicha estructura

85
86 Capítulo 5

primero se evalúa y luego se realiza el proceso.

Las estructuras de tipo “Desde” se aplican cuando se tiene definido el número de
veces que se realizará el proceso dentro del ciclo; lo que la hace diferente de las otras
es que aquellas se pueden utilizar hasta que las condiciones cambien dentro del mismo
ciclo. Estas condiciones pueden deberse a un dato proporcionado desde el exterior,
o bien, al resultado de un proceso ejecutado dentro de éste, el cual marca el final.
Además, en el ciclo “Desde”, su incremento es automático, por lo cual no se tiene que
efectuar mediante un proceso adicional, como en los otros dos tipos.
En los siguientes ejemplos se mostrará la aplicación de los dos tipos de ciclos antes
mencionados.

5.2.1. Ejemplo: Suma diez cantidades con ciclo “Mientras que”

Se requiere un algoritmo para obtener la suma de diez cantidades mediante la
utilización de un ciclo “Mientras que”. Realiza el pseudocódigo y el programa en
Python para representarlo.
Con base en lo que se requiere determinar se puede establecer que las variables
requeridas para la solución del problema son las mostradas en la tabla 5.1.

Nombre de la variable Descripción Tipo

con Contador Entero, Int
n Valor por sumar Real, Float
suma Suma de valores Real, Float

Tabla 5.1: Variables del ejemplo suma cantidades

La solución de este problema mediante el ciclo Mientras, que también es conocido

como ciclo while en Python, se puede establecer mediante el pseudocódigo 17.
Algoritmo 17: Ejemplo suma diez cantidades
Entradas: n (real)
Salidas: suma (real)
1: Inicio
2: con=1
3: suma=0
4: mientras con<=10 hacer
5: Leer n
6: suma=suma+n
7: con=con+1
8: fin_mientras
9: Escribir suma
10: Fin
De esta solución planteada se puede ver, primero que el contador del ciclo con se
inicializa en uno, posteriormente, se verifica que éste sea menor o igual a diez, que es
 Estructuras repetitivas 87

lo que debe durar el ciclo (diez veces), ya dentro del ciclo el contador se incrementa
por cada vuelta que dé y se realice el proceso de leer un valor y acumularlo en la
suma.
En general, todo ciclo debe tener un valor inicial, un incremento y un verificador
que establezca el límite de ejecución.
El código en Python para este ejemplo se muestra a continuación (ver Programa
5.1):

1 con =1
2 suma =0
3
4 while con <=10:
5 n = float ( input ( " Introduce un valor a sumar : " ) )
6 suma = suma + n
7 con = con +1
8

9 print ( f " La suma total es : { suma } " )

Programa 5.1: Suma diez cantidades

El programa 5.1 tiene como salida:

Introduce un valor a sumar : 1

Introduce un valor a sumar : 2
Introduce un valor a sumar : 3
Introduce un valor a sumar : 4
Introduce un valor a sumar : 5
Introduce un valor a sumar : 6
Introduce un valor a sumar : 7
Introduce un valor a sumar : 8
Introduce un valor a sumar : 9
Introduce un valor a sumar : 10
La suma total es : 55.0

5.2.2. Ejemplo suma diez cantidades con ciclo “Desde”

Se requiere un algoritmo para obtener la suma de diez cantidades mediante la

utilización de un ciclo Desde. Realiza el pseudocódigo y el programa en Python para
representarlo.
El ciclo Desde también es conocido como ciclo for en Python. Se utilizarán las
mismas variables mostradas en la tabla 5.1. El pseudocódigo 18 muestra la solución
 88 Capítulo 5

correspondiente utilizando el ciclo Desde.

Algoritmo 18: Ejemplo Suma diez cantidades con “Desde”
Entradas: n (real)
Salidas: suma (real)
1: Inicio
2: suma=0
3: desde con=1 hasta 10 hacer
4: Leer n
5: suma=suma+n
6: fin_desde
7: Escribir suma
8: Fin
El código en Python para este ejemplo se muestra a continuación (ver programa
5.2):
1 suma =0
2
3 for con in range (1 ,11) :
4 n = float ( input ( " Introduce un valor a sumar : " ) )
5 suma = suma + n
6
7 print ( f " La suma total es : { suma } " )
Programa 5.2: suma diez cantidades con Desde

El programa 5.2 tiene como salida:

Introduce un valor a sumar : 1
Introduce un valor a sumar : 2
Introduce un valor a sumar : 3
Introduce un valor a sumar : 4
Introduce un valor a sumar : 5
Introduce un valor a sumar : 6
Introduce un valor a sumar : 7
Introduce un valor a sumar : 8
Introduce un valor a sumar : 9
Introduce un valor a sumar : 10
La suma total es : 55.0

Como se mencionó, este tipo de estructura para el control de ciclos se utiliza

exclusivamente cuando el número de veces que se realizará el ciclo está bien definido;
sin embargo, como se pudo ver en los dos ejemplos anteriores, esta condición está
presente y no fue un impedimento para utilizarlos en la solución del problema.
Además, se debe observar que el incremento de la variable que controla el ciclo no
se indica en este tipo de estructura, ya que el incremento o decremento de la variable
se realiza de manera automática. Esta automatización se logra gracias a la función
range. Los tres argumentos del tipo range(m, n, p) son:

m: el valor inicial

n: el valor final -1 (es -1 porque finaliza un valor anterior al establecido)

 Estructuras repetitivas 89

p: el paso (la cantidad que se avanza cada vez)

Si se escriben solo dos argumentos, Python le asigna a p el valor 1. Es decir

range(m, n) es lo mismo que range(m, n, 1).
Si se escribe solo un argumento, Python le asigna a m el valor 0 y a p el valor 1.
Es decir, range(n) es lo mismo que range(0, n, 1).
El tipo range() solo admite argumentos enteros. Si se utilizan argumentos deci-
males, se produce un error.

5.2.3. Ejemplo cálculo de promedio de números

Se requiere un algoritmo para obtener el promedio de un conjunto de números.
Realiza el pseudocódigo y el programa en Python para representarlo, utilizando los
dos tipos de estructuras de ciclo.
La tabla 5.2 muestra las variables que se van a utilizar para la solución del pro-
blema, sin importar qué estructura de ciclo se utilice; por consiguiente, es la misma
para los dos tipos de ciclo para los que se dará la solución.

Nombre de la variable Descripción Tipo

con Contador Entero, Int
n Cantidad de números Entero, Int
num Valor de un elemento Entero, Int
suma Suma de los números Entero, Int
promedio Valor promedio Real, Float

Tabla 5.2: Variables del ejemplo promedio

La solución de este problema mediante el ciclo Mientras se puede establecer me-

diante el pseudocódigo 19:
Algoritmo 19: Obtiene el promedio
Entradas: n (entero), num (entero)
Salidas: promedio (real)
1: Inicio
2: con=1
3: suma=0
4: Leer n
5: mientras con<=n hacer
6: Leer num
7: suma=suma+num
8: con=con+1
9: fin_mientras
10: promedio=suma/n
11: Escribir promedio
12: Fin
 90 Capítulo 5

El código en Python para este ejemplo se muestra a continuación (ver programa

5.3):
1 con =1
2 suma =0
3 n = int ( input ( " Introduce la cantidad de elementos a promediar : " ) )
4
5 while con <= n :
6 num = int ( input ( " Introduce un elemento : " ) )
7 suma = suma + num
8 con = con +1
9
10 promedio = suma / n
11 print ( f " La suma total es : { promedio } " )
Programa 5.3: Promedio con Mientras

El programa 5.3 tiene como salida:

Introduce la cantidad de elementos a promediar : 5
Introduce un elemento : 10
Introduce un elemento : 9
Introduce un elemento : 8
Introduce un elemento : 9
Introduce un elemento : 7
La suma total es : 8.6

La solución de este problema mediante el ciclo Desde se puede establecer mediante

el pseudocódigo 20:
Algoritmo 20: Ejemplo Obtiene promedio con “Desde”
Entradas: n (entero), num (entero)
Salidas: promedio (real)
1: Inicio
2: suma=0
3: Leer n
4: desde con=1 hasta n hacer
5: Leer num
6: suma=suma+num
7: fin_desde
8: promedio=suma/n
9: Escribir promedio
10: Fin
El código en Python para este ejemplo utilizando la estructura Desde es el siguiente
(ver código 5.4):
1 suma =0
2 n = int ( input ( " Introduce la cantidad de elementos a promediar : " ) )
3

4 for con in range (1 , n +1) :

5 num = int ( input ( " Introduce un elemento : " ) )
6 suma = suma + num
7
 Estructuras repetitivas 91

8 promedio = suma / n
9 print ( f " La suma total es : { promedio } " )

Programa 5.4: Promedio con Desde

El programa 5.4 tiene como salida:

Introduce la cantidad de elementos a promediar : 5
Introduce un elemento : 10
Introduce un elemento : 9
Introduce un elemento : 8
Introduce un elemento : 9
Introduce un elemento : 7
La suma total es : 8.6

5.2.4. Ejemplo cálculo de promedio sin conocer la cantidad de

números

Se requiere un algoritmo para obtener el promedio de un conjunto de números,

cuyo número de elementos se desconoce, el ciclo debe efectuarse siempre y cuando los
elementos del conjunto de números sean mayores que cero. Realiza el pseudocódigo y
el programa en Python para representarlo, utilizando el ciclo apropiado.
Como se puede ver, para resolver este problema no se puede utilizar el ciclo Desde,
ya que no se tiene el número de elementos exacto, que es lo que determinaría el número
de veces que se ejecuta el proceso que se encuentra dentro del ciclo.
El ciclo apropiado para la solución de este problema es Mientras, ya que este
ciclo se realiza siempre y cuando se cuente con un elemento mayor a cero, de una
manera natural sin forzar el proceso en ningún momento, y en caso de que no se
tenga elemento registrado el promedio es cero, y se debe indicar que no existe ningún
elemento registrado.

Nombre de la variable Descripción Tipo

con Contador de elementos Entero, Int
elemento Valor de un elemento Real, Float
suma Suma de los elementos Real, Float
promedio Valor promedio Real, Float

Tabla 5.3: Variables del ejemplo promedio sin número exacto de elementos

La tabla 5.3 muestra las variables que se van a utilizar para la solución de este
 92 Capítulo 5

problema.
Algoritmo 21: Obtiene el promedio sin número exacto de elementos
Entradas: elemento (real)
Salidas: promedio (real)
1: Inicio
2: con=0
3: suma=0
4: Leer elemento
5: mientras elemento>0 hacer
6: suma=suma+elemento
7: con=con+1
8: Leer elemento
9: fin_mientras
10: promedio=suma/con
11: Escribir promedio
12: Fin
La representación del algoritmo para este problema se presenta mediante el pseu-
docódigo 21 y el programa en Python 5.5, en los cuales se utiliza el ciclo Mientras.
1 con =0
2 suma =0
3 elemento = float ( input ( " Introduce un elemento a promediar : " ) )
4
5 while elemento >0:
6 suma = suma + elemento
7 con = con + 1
8 elemento = float ( input ( " Introduce un elemento a promediar : " ) )
9

10 promedio = suma / con

11 print ( f " El promedio de los números es : { promedio } " )
Programa 5.5: Variante del promedio

El programa 5.5 tiene como salida:

Introduce un elemento a promediar : 10
Introduce un elemento a promediar : 9
Introduce un elemento a promediar : 8
Introduce un elemento a promediar : 9
Introduce un elemento a promediar : 7
Introduce un elemento a promediar : 0
El promedio de los números es : 8.6

5.2.5. Ejemplo cálculo de ahorro en un año

Se requiere un algoritmo para determinar cuánto ahorrará una persona en un año,
si al final de cada mes deposita cantidades variables de dinero; además, se requiere
saber cuánto lleva ahorrado cada mes. Realiza el pseudocódigo y el programa en
Python para representarlo, utilizando un ciclo apropiado.
 Estructuras repetitivas 93

La tabla 5.4 muestra las variables que se requieren para plantear la solución del
problema.

Nombre de la variable Descripción Tipo

ahorro_mes Ahorro mensual Real, Float
con_mes Contador de meses Entero, Int
cantidad Cantidad que se va a ahorrar Real, Float

Tabla 5.4: Variables del ejemplo ahorro

Este problema se puede resolver mediante la utilización de cualquiera de los ciclos,

dado que se conoce el número de veces que se debe efectuar el ciclo.
Algoritmo 22: Ejemplo Cálculo de ahorro con “Desde”
Entradas: cantidad (real)
Salidas: ahorro_mes (real)
1: Inicio
2: con_mes=1
3: ahorro_mes=0
4: desde con_mes=1 hasta 12 hacer
5: Leer cantidad
6: ahorro_mes=ahorro_mes+cantidad
7: Escribir ahorro_mes
8: fin_desde
9: Escribir ahorro_mes
10: Fin
La solución para este problema utilizando el ciclo Desde se plantea mediante el
pseudocódigo 22 y el código 5.6.
1 ahorro_mes =0
2
3 for con_mes in range (1 ,13) :
4 cantidad = float ( input ( " Introduce la cantidad a ahorrar : " ) )
5 ahorro_mes = ahorro_mes + cantidad
6 print ( f " El ahorro del mes { con_mes } es { ahorro_mes } " )
7

8 print ( f " El total ahorrado en el año es : { ahorro_mes } " )

Programa 5.6: Ahorro anual
El programa 5.6 tiene como salida:
Introduce la cantidad a ahorrar : 100
El ahorro del mes 1 es 100.0
Introduce la cantidad a ahorrar : 100
El ahorro del mes 2 es 200.0
Introduce la cantidad a ahorrar : 100
El ahorro del mes 3 es 300.0
Introduce la cantidad a ahorrar : 100
El ahorro del mes 4 es 400.0
Introduce la cantidad a ahorrar : 100
El ahorro del mes 5 es 500.0
94 Capítulo 5

Introduce la cantidad a ahorrar : 100

El ahorro del mes 6 es 600.0
Introduce la cantidad a ahorrar : 100
El ahorro del mes 7 es 700.0
Introduce la cantidad a ahorrar : 100
El ahorro del mes 8 es 800.0
Introduce la cantidad a ahorrar : 100
El ahorro del mes 9 es 900.0
Introduce la cantidad a ahorrar : 100
El ahorro del mes 10 es 1000.0
Introduce la cantidad a ahorrar : 100
El ahorro del mes 11 es 1100.0
Introduce la cantidad a ahorrar : 100
El ahorro del mes 12 es 1200.0
El total ahorrado en el año es : 1200.0

5.2.6. Ejemplo serie Fibonacci

Elabora un algoritmo para generar N elementos de la sucesión de Fibonacci (1, 1,
2, 3, 5, 8, 13,...). Realiza el pseudocódigo y el programa en Python para representarlo,
utilizando el ciclo apropiado.
El planteamiento del algoritmo correspondiente se hace a partir del análisis de la
sucesión, en la que se puede observar que un tercer valor de la serie está dado por la
suma de los dos valores previos, de aquí que se asignan los dos valores para sumar (1,
1), que dan la base para obtener el siguiente elemento que se busca, además, implica
que el ciclo se efectué dos veces menos.
Algoritmo 23: Obtiene la serie Fibonacci
Entradas: N (entero)
Salidas: suma (entero)
1: Inicio
2: p1=1
3: p2=1
4: con=3
5: Leer N
6: Escribir P1, P2
7: mientras con<=N hacer
8: suma=p1+p2
9: Escribir suma
10: p1=p2
11: p2=suma
12: con=con+1
13: fin_mientras
14: Fin

Las variables que se requieren para la solución de este problema se muestran en

la tabla 5.5. En lo que respecta a qué tipo de ciclo se debe utilizar, es indistinto.
 Estructuras repetitivas 95

Nombre de la variable Descripción Tipo

p1 Puntero uno Entero, Int
p2 Puntero dos Entero, Int
suma Suma punteros Entero, Int
con Contador Entero, Int
N Elementos de la serie Entero, Int

Tabla 5.5: Variables del ejemplo serie Fibonacci

La solución para este problema utilizando el ciclo Desde se plantea mediante el

pseudocódigo 23 y el código 5.7.
1 p1 =1
2 p2 =1
3 con =3
4 N = int ( input ( " Introduce la cantidad de elementos de la serie : " ) )
5 print ( p1 )
6 print ( p2 )
7
8 while con <= N :
9 suma = p1 + p2
10 print ( suma )
11 p1 = p2
12 p2 = suma
13 con = con +1
Programa 5.7: serie Fibonacci

El programa 5.7 tiene como salida:

Introduce la cantidad de elementos de la serie : 6
1
1
2
3
5
8

5.2.7. Ejemplo número primo

Un número primo es un número natural mayor que 1 que tiene únicamente dos
divisores distintos: él mismo y el 1. Por ejemplo, el número 4 no es un número primo,
porque lo divide el 1, 2 y el mismo 4. Sin embargo, el número 5 si es primo, ya que
únicamente es divisible entre 1 y 5.
El reto en esta ocasión es desarrollar un algoritmo que diga si un número propor-
cionado por el usuario es primo o no lo es. Represéntalo mediante pseudocódigo y
código en Python.
La idea es este algoritmo es analizar todos los números desde 1 hasta el número
que queremos determinar si es primo o no, es decir, N. Dicho análisis consistirá en
ver si alguno de los valores desde 1 hasta N divide a N, si es así se cuenta el divisor.
 96 Capítulo 5

Si es primo, solo debe haber dos divisores (1 y N), en caso contrario, el número no es
primo.
La tabla 5.6 muestra las variables que se necesitan para resolver este ejercicio.

Nombre de la variable Descripción Tipo

N Número a verificar si es primo Entero, Int
con Contador Entero, Int
conDivisores Cuenta divisores Entero, Int
R Resultado Cadena, String

Tabla 5.6: Variables del ejemplo número primo

El pseudocódigo que representa el algoritmo que determina si un número es primo

es el siguiente (ver pseudocódigo 24):
Algoritmo 24: Determina si un número es primo o no
Entradas: N (entero)
Salidas: R (cadena)
1: Inicio
2: con=1
3: conDivisores=0
4: Leer N
5: mientras con<=N hacer
6: si N %con==0 entonces
7: conDivisores=conDivisores+1
8: fin_si
9: con=con+1
10: fin_mientras
11: si conDivisores==2 entonces
12: R=“Es primo”
13: de_lo_contrario
14: R=“No es primo”
15: fin_si
16: Escribir R
17: Fin
La solución para este problema utilizando el ciclo Mientras se plantea mediante
el código 5.8.
1 con =1
2 conDivisores =0
3
4 N = int ( input ( " Introduce el número a verificar : " ) )
5
6 while con <= N :
7 if N %con ==0:
8 conDivisores +=1
 Estructuras repetitivas 97

9 con +=1
10

11 if conDivisores ==2:
12 R = " Es primo "
13 else :
14 R = " No es primo "
15
16 print ( R )

Programa 5.8: Número primo

El programa 5.8 tiene como salida:

Introduce el número a verificar : 11
Es primo

5.2.8. Ejemplo dibuja triángulo numérico

Hasta ahora, los ejemplos que hemos visto solo emplean un bucle o ciclo. Sin
embargo, en la práctica muchos programas requieren ciclos anidados, es decir, ciclos
dentro de ciclos. Tal como se muestra en el siguiente ejemplo, en donde el usuario
introduce un número y el programa debe generar un triángulo de números:
Introduce un número : 10
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9 10

La tabla 5.7 muestra las variables que se necesitan para resolver este ejercicio.

Nombre de la variable Descripción Tipo

filas Número de filas Entero, Int
columnas Número de columnas Entero, Int
n Tamaño del triángulo Entero, Int

Tabla 5.7: Variables del ejemplo dibuja triángulo

Cualquiera de los bucles que hemos visto se pueden utilizar; sin embargo, por
elegancia, trabajaremos este ejercicio con un bucle Desde. El pseudocódigo 25 muestra
 98 Capítulo 5

la representación del algoritmo.

Algoritmo 25: Ejemplo Dibuja triángulo
Entradas: n (entero)
Salidas:
1: Inicio
2: Leer n
3: desde filas=1 hasta n hacer
4: desde columnas=1 hasta filas hacer
5: Escribir columnas y un espacio o tabulador
6: fin_desde
7: Saltar línea
8: fin_desde
9: Fin
La solución para este problema utilizando el ciclo Desde se plantea mediante el
código 5.9.
1 n = int ( input ( " Introduce un número : " ) )
2
3 for filas in range (1 , n +1) :
4 for columnas in range (1 , filas +1) :
5 print ( f " { columnas } " , end = " \ t " )
6 print ()
Programa 5.9: Dibuja triángulo

5.3. Ejercicios
1. Se requiere un algoritmo para determinar, de N cantidades, cuántas son menores
o iguales a cero y cuántas mayores a cero. Realiza el pseudocódigo y el programa
en Python para representarlo, utilizando el ciclo apropiado.
2. Realiza un algoritmo para generar e imprimir los números pares que se en-
cuentran entre 100 y 200. Realiza el pseudocódigo y programa en Python para
representarlo, utilizando el ciclo apropiado.
3. Una empresa tiene el registro de las horas que trabaja diariamente un empleado
durante la semana (seis días) y requiere determinar el total de éstas, así como el
sueldo que recibirá por las horas trabajadas. Realiza un algoritmo para deter-
minar esto y represéntalo mediante el pseudocódigo y el programa en Python,
utilizando el ciclo apropiado.
4. Un profesor tiene un salario inicial de $1500, y recibe un incremento de 10 %
anual durante 6 años. ¿Cuál es su salario al cabo de 6 años? ¿Qué salario
ha recibido en cada uno de los 6 años? Realiza el algoritmo y representa la
solución mediante el pseudocódigo y el programa en Python, utilizando el ciclo
apropiado.
 Estructuras repetitivas 99

5. Realiza un programa que genere la figura siguiente:

Introduce el tamaño del triángulo : 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7
1 2 3 4 5 6
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
100 Capítulo 5
Capítulo 6

Cadenas y colecciones

6.1. Introducción
Las colecciones son objetos relacionados que pueden ser caracterizados por su
organización y las operaciones que se pueden hacer sobre ellos. Se entiende por objeto
cualquier tipo de dato.
Una colección permite agrupar varios objetos bajo un mismo nombre. Por ejemplo,
si necesitamos almacenar los nombres de alumnos de un curso de programación, sería
más conveniente ubicarlos a todos dentro de una misma colección de nombre alumnos.

6.2. Cadenas
6.2.1. Índices y slicing
Una cadena está conformada por caracteres (es decir, letras, números y símbolos),
a los cuales se puede acceder a través de sus índices. En el índice 0 se encuentra el
primer carácter y el último carácter de la cadena se encuentra en la posición menos
uno de la longitud de la cadena.

Figura 6.1: Ejemplo cadena

Veamos un ejemplo, tenemos la cadena “Estela”, la cual mediante una asignación

101
 102 Capítulo 6

es almacenada en la variable cad (ver línea 1 de programa 6.1). Si queremos el primer

caracter de la cadena, basta con escribir cad[0] en un print y se muestra el caracter
“E” (ver línea 3 de programa 6.1).
1 cad = " Estela "
2
3 print ( cad [0])
Programa 6.1: Ejemplo cadena 1

El programa 6.1 tiene como salida:

E

Python, a diferencia de otros lenguajes de programación, permite trabajar con

índices negativos. Un índice negativo sirve para iniciar a partir del final de la cadena,
por ejemplo, en la misma cadena “Estela” si queremos el último carácter, podemos
tener acceso mediante el índice -1, el cual devuelve el valor “a” (ver programa 6.2 y
su salida). La lógica nos dice que si quisiéramos el penúltimo caracter de la cadena
tendríamos que escribir cad[-2], lo cual es complemente correcto, y así para los
demás elementos de la cadena.
1 cad = " Estela "
2
3 print ( cad [ -1])
Programa 6.2: Ejemplo cadena 2

El programa 6.2 tiene como salida:

a

Teniendo claro el concepto de índices, podemos pasar a algo un poco más avan-
zado como son los slicing, los cuales permiten obtener una subcadena de la cadena
principal.
En resumen, éstas son sus principales opciones:

cadena[inicio:final] desde el índice ‘inicio’ hasta el índice ‘final’-1

cadena[inicio:] desde el índice ‘inicio’ hasta el final de la cadena

cadena[:final] desde el índice 0 hasta elemento ‘final’-1

cadena[:] todos los elementos de la cadena

Además de estos cuatro casos que son los más comunes, también puedes utilizar
un tercer valor opcional llamado step o salto:

cadena[inicio:final:salto] desde el elemento ‘inicio’ hasta ‘final’ pero sal-

tando el número de elementos indicado por ‘salto’
 Cadenas y colecciones 103

Otra de las opciones más interesantes del slicing es que el principio, el final y
el salto pueden ser números negativos. Esto indica que se empieza a contar desde el
final de la cadena.
En el mismo ejemplo de la cadena “Estela", si quisiéramos los caracteres desde el
segundo elemento hasta el cuarto, tendríamos que realizar lo siguiente:
1 cad = " Estela "
2
3 print ( cad [1:5])
Programa 6.3: Ejemplo cadena 3

El programa 6.3 tiene como salida:

stel

Nota que el segundo carácter se encuentra a partir del índice 1, y el quinto elemento
se encuentra en el índice 4, el slicing va desde 1 hasta 5 ([1:5]); sin embargo, se detiene
una posición anterior a la que se le indica. Es decir, si el final es 5 se detiene en la
posición 4. Por eso, obtenemos la subcadena “stel”.
A continuación, un último ejemplo del uso de slicing, en donde partiendo de
la cadena “Estela”, queremos obtener la subcadena “stela”. Para ello realizamos lo
siguiente:
1 cad = " Estela "
2
3 print ( cad [1:])
Programa 6.4: Ejemplo cadena 4

El programa 6.4 tiene como salida:

stela

En este punto es importante mencionar que las cadenas son inmutables, es decir,
no se pueden modificar, al menos no directamente. Veamos el siguiente ejemplo, en el
cual se intenta modificar el primer carácter de la cadena. Al ejecutarse este programa,
produce una excepción (un tipo de error).
1 cad = " Estela "
2
3 cad [0]= " e "
4
5 print ( cad )
Programa 6.5: Ejemplo cadena 5

El programa 6.5 tiene como salida:

Traceback ( most recent call last ) :
File "/ Users / cadenaEstela5 . py " , line 3 , in < module >
cad [0]=" e "
TypeError : ’str ’ object does not support item assignment

Si quisiéramos modificar la cadena en la posición 0, tendríamos que hacer algo

como lo siguiente:
 104 Capítulo 6

1 cad = " Estela "

2

3 cad = " e " + cad [1:]

4
5 print ( cad )
Programa 6.6: Ejemplo cadena 5

El programa 6.6 tiene como salida:

estela

El operador + permite concatenar (unir) cadenas.

6.2.2. Longitud de una cadena

La función len() devuelve la longitud de una cadena de caracteres. El argumento
de la función len() es la cadena que queremos “medir”.
1 fruta = " manzana "
2
3 print ( len ( fruta ) )
Programa 6.7: Funcíon len

El programa 6.7 tiene como salida:

7

Como podemos observar en el programa 6.7 la palabra manzana (almacenada en

la variable fruta), tiene siete caracteres. Al pasar la variable fruta a la función len
se tiene como resultado el valor 7.
Para obtener la última letra de una cadena, podríamos sentirnos tentados a probar
algo como esto:
1 fruta = " manzana "
2 longitud = len ( fruta )
3 ultima = fruta [ longitud ]
4 print ( ultima )
Programa 6.8: Función len última letra de cadena incorrecto

El código del programa 6.8 provoca un error en tiempo de ejecución IndexError:

string index out of range. La razón es que no hay una siete-ésima letra en “man-
zana”. Como empezamos a contar desde cero, las siete letras están numeradas del 0
al 6. Para obtener el último carácter tenemos que restar 1 a la longitud:
1 fruta = " manzana "
2 longitud = len ( fruta )
3 ultima = fruta [ longitud -1]
4 print ( ultima )
Programa 6.9: Función len última letra de cadena correcto
 Cadenas y colecciones 105

6.2.3. Métodos para cadenas

Los métodos son funcionalidades que, en este caso de las cadenas, ya vienen bien
definidos en Python. Podemos decir que un método recibe datos de entrada y devuelve
salidas. A los datos que recibe como entrada, se les conoce como argumentos. Ademas
podemos decir que un método tiene un nombre bien definido, lo que no se sabe es
cómo implementa su funcionalidad.
Son muchos los métodos que Python tiene para el manejo de cadenas; sin embargo,
en esta subsección nos centraremos en los que consideramos los mas importantes.

Método upper
Este método permite cambiar una cadena a mayúsculas. Su uso es muy simple:

“cadena a convertir”.upper()

Ejemplo
1 cadena = " hola mundo " . upper ()
2
3 print ( cadena )
Programa 6.10: Ejemplo cadena a mayúsculas

El programa 6.10 tiene como salida:

HOLA MUNDO

En este caso, la cadena “hola mundo” invoca al método upper, con lo que se
convierte a mayúsculas y se almacena en la variable cadena, la cual se muestra con
la función print.

Método lower
Este método sirve para cambiar una cadena a minúsculas. Su función es igual de
sencilla y tiene el siguiente formato:

“cadena a convertir”.lower()

Ejemplo:
1 cadena = " HOLA MUNDO " . lower ()
2
3 print ( cadena )
Programa 6.11: Ejemplo cadena a minúsculas

El programa 6.11 tiene como salida:

hola mundo
 106 Capítulo 6

En este ejemplo se emplea la cadena “HOLA MUNDO”, en mayúsculas. Dicha

cadena invoca al método lower() que la convierte a minúsculas. La cadena convertida
en minúsculas se almacena en la variable cadena. Esta variable se muestra a través
de print en pantalla.

Método count
Este método sirve para saber cuántas veces aparece un carácter en una cadena.
Su formato es:

cadena.count(caracter)

Donde cadena es una cadena de caracteres o una variable que tenga almacenada
una cadena; y caracter es el argumento que se quiere determinar cuántas veces
aparece en la cadena. Este método devuelve el número de apariciones del carácter en
la cadena.
Veamos su uso a través de un ejemplo:
1 cadena = " hola mundo " . count ( ’o ’)
2
3 print ( cadena )
Programa 6.12: Ejemplo count
El programa 6.12 tiene como salida:
2

En este ejemplo se determina el número de veces que aparece el carácter “o” en la

cadena “hola mundo”. Como podemos ver, dicho carácter aparece dos veces, que es la
salida que nos devuelve Python.

Método find
Sirve para conocer el índice de la cadena donde aparece una palabra o carácter
determinado. Veamos su funcionamiento a través de un ejemplo:
1 cadena = " hola hola hola hola mundo " . find ( ’ mundo ’)
2
3 print ( cadena )
Programa 6.13: Ejemplo find
El programa 6.13 tiene como salida:
20

En este ejemplo tenemos la cadena “hola hola hola hola mundo”, y a través del
método find queremos determinar en qué índice de dicha cadena aparece la palabra
“mundo” (pasada como argumento a find). Si contamos de izquierda a derecha, em-
pezando desde 0, llegamos a la posición 20, que es donde se encuentra el inicio de la
palabra “mundo”. En caso de que la palabra o carácter que se busca no se encuentre,
el método find devuelve -1.
 Cadenas y colecciones 107

Método islower
Este método devuelve un valor True si la cadena que lo invoca está completamente
en minúsculas. En caso contrario, devuelve False. Ejemplo:
1 cadena = " hola mundo " . islower ()
2
3 print ( cadena )
Programa 6.14: Ejemplo islower

El programa 6.14 tiene como salida:

True

Método startswith
Este método recibe como argumento una palabra o carácter y devuelve True si en
la cadena que invoca al método, dicha palabra o carácter aparece al inicio. Veamos el
ejemplo:
1 cadena = " hola mundo " . startswith ( ’ hola ’)
2
3 print ( cadena )
Programa 6.15: Ejemplo startswith

El programa 6.15 tiene como salida:

True

La cadena “hola mundo” llama al método startswitch, al cual se le pasa como

argumento la palabra “hola”. En este caso, dicho método devuelve True, ya que la
cadena “hola mundo” inicia con la palabra “hola”.

Método endswith
Este método sirve para verificar si la cadena termina con una palabra o carácter
que recibe como argumento. En caso de que sí termine con dicha palabra o carácter,
devuelve True, si no, devuelve False. Veamos el ejemplo:
1 cadena = " hola mundo " . endswith ( ’ mundo ’)
2
3 print ( cadena )
Programa 6.16: Ejemplo endswith

El programa 6.16 tiene como salida:

True

La cadena “hola mundo” llama al método endswith y le pasa como argumento la

palabra “mundo”. Como efectivamente dicha cadena termina con la palabra “mundo”,
este método devuelve True.
 108 Capítulo 6

Método split
Este método separa los elementos de una cadena cada vez que encuentra un carác-
ter que se le pase como argumento. Devuelve una lista con los elementos separados,
por ejemplo:
1 cadena = " hola mundo " . split ()
2
3 print ( cadena )
Programa 6.17: Ejemplo split
El programa 6.17 tiene como salida:
[ ’ hola ’ , ’ mundo ’]

La cadena “hola mundo” invoca al método split sin pasarle ningún argumento; lo
cual quiere decir que separará la cadena por espacios en blanco que encuentre. Como
podemos ver en la salida, devuelve una lista (un concepto que veremos más adelante
en este capítulo) con los elementos separados.
Para dejar más claro el método split veamos otro ejemplo:
1 cadena = " hola - hola - mundo " . split ( ’ - ’)
2
3 print ( cadena )
Programa 6.18: Ejemplo split 2
El programa 6.18 tiene como salida:
[ ’ hola ’ , ’ hola ’ , ’ mundo ’]

Ahora la cadena “hola-hola-mundo” invoca al método split, al cual se le pasa

como argumento el caracter “-”, que significa que cuando encuentre este carácter en
la cadena separará la palabra y la almacenará en una lista, tal cual se muestra en la
salida del programa.

Método join
Retorna una cadena resultante de concatenar la cadena que recibe como argumen-
to, separada por la cadena (S) sobre la que se llama al método.

S.JOIN(secuencia)

1 cadena = " ," . join ( " roberto " )

2
3 print ( cadena )
Programa 6.19: Ejemplo join
En este ejemplo, a la cadena “roberto” (que se le pasa como argumento al método
join) se le concatena a cada elemento de la cadena el carácter “,”. Lo cual genera la
salida siguiente:
r ,o ,b ,e ,r ,t , o
 Cadenas y colecciones 109

Método replace
Este método reemplaza un elemento por otro en una cadena de caracteres (la
que invoca al método replace). Tanto el elemento que se va a reemplazar como
el elemento reemplazado son pasados como argumentos. Este método devuelve una
cadena con el elemento reemplazado. Ejemplo:
1 cadena = " hola mundo " . replace ( ’o ’ , ’9 ’)
2
3 print ( cadena )
Programa 6.20: Ejemplo replace

En la cadena “hola mundo” se reemplaza el caracter “o” por el “9”. Finalmente, se

tiene la salida que se muestra a continuación:
h9la mund9

6.2.4. Recorrido de una cadena

Muchos cálculos implican procesar una cadena carácter por carácter. A menudo
se empieza por el principio, se selecciona cada carácter por turno, se hace algo con
él y se sigue hasta el final. Este patrón de proceso se llama recorrido. Una forma de
codificar un recorrido es con una sentencia while:
1 fruta = " manzana "
2 indice = 0
3 while indice < len ( fruta ) :
4 letra = fruta [ indice ]
5 print ( letra )
6 indice += 1
Programa 6.21: Recorrido de una cadena con while

Este bucle recorre la cadena y muestra cada letra en una línea distinta. La con-
dición del bucle es indice < len(fruta), de modo que cuando indice es igual a la
longitud de la cadena, la condición es falsa y no se ejecuta el cuerpo del bucle. El
último carácter al que se accede es el que tiene el índice len(fruta)-1, que es el
último carácter de la cadena.
Usar un índice para recorrer un conjunto de valores es tan común que Python
proporciona una sintaxis alternativa más simple — el bucle for:
1 fruta = " manzana "
2
3 for carac in fruta :
4 print ( carac )
Programa 6.22: Recorrido de una cadena con for

Cada vez que recorremos el bucle, se asigna a la variable carac el siguiente carácter
de la cadena. El bucle continúa hasta que no quedan más caracteres.
Para los recorridos con while y con for la salida es la siguiente:
 110 Capítulo 6

m
a
n
z
a
n
a

6.3. Listas
Las listas en Python son una secuencia de valores que pueden ser de cualquier
tipo: cadenas, enteros, flotantes, contenido mixto o cualquier otro. En esta sección
hablaremos sobre los métodos de listas de Python y cómo crear, agregar elementos,
agregar al final, invertir y muchas otras funciones de listas de Python.

6.3.1. Crear listas

Las listas pueden ser creadas con datos y sin datos. Veamos un ejemplo donde
crearemos una lista vacía:
1 lista =[]
2
3 print ( lista )
Programa 6.23: Ejemplo lista vacía
La salida del programa 6.23 es:
[]

Como podemos observar en el ejemplo anterior, para crear una lista se deben
usar los corchetes []. Al imprimir la lista anterior, ésta nos muestra únicamente los
corchetes, los cuales son distintivos de una lista.
También podemos agregar datos a la lista al momento de crearla, por ejemplo:
1 lista =[ " Lunes " ," Martes " ," Miércoles " ," Jueves " ," Viernes " ]
2
3 print ( lista )
Programa 6.24: Ejemplo lista con datos
La salida del programa 6.24 es:
[ ’ Lunes ’ , ’ Martes ’ , ’ Miércoles ’ , ’ Jueves ’ , ’ Viernes ’]

6.3.2. Mostrar elementos de la lista

Podemos mostrar un elemento de la lista a través de sus índices. En el índice 0 se
encuentra el primer elemento de la lista. A diferencia de las cadenas, los elementos de
las listas no son solo caracteres, como ya se mencionó anteriormente, estos elementos
pueden ser cadenas, números u otras listas, por ejemplo. Veamos cómo acceder al
primer elemento de una lista que tiene los días de la semana:
 Cadenas y colecciones 111

1 lista =[ " Lunes " ," Martes " ," Miércoles " ," Jueves " ," Viernes " ]
2

3 print ( lista [0])

Programa 6.25: Ejemplo primer elemento de la lista
La salida del programa 6.25 es:
Lunes

A partir de una lista, se pueden obtener sublistas utilizando el concepto de slicing

que ya habíamos abordado en el tema de cadenas. Por ejemplo, en la lista que tiene
los días de la semana, si quisiéramos únicamente los primeros tres días de la semana,
podemos hacer lo siguiente:
1 lista =[ " Lunes " ," Martes " ," Miércoles " ," Jueves " ," Viernes " ]
2
3 print ( lista [0:3])
Programa 6.26: Ejemplo sublista
La salida del programa 6.26 es:
[ ’ Lunes ’ , ’ Martes ’ , ’ Miércoles ’]

Donde 0 es el inicio y 3 es el fin -1 de la sublista.

Veamos otro ejemplo, ahora se desea obtener una sublista que contenga los días
desde el martes hasta el jueves. Entonces, el código quedaría de la manera siguiente:
1 lista =[ " Lunes " ," Martes " ," Miércoles " ," Jueves " ," Viernes " ]
2
3 print ( lista [1:4])
Programa 6.27: Ejemplo sublista dos
La salida del programa 6.27 es:
[ ’ Martes ’ , ’ Miércoles ’ , ’ Jueves ’]

6.3.3. Listas con elementos de diferentes tipos de datos

Como ya se mencionó al inicio de este sección, las listas pueden contener elementos
de cualquier tipo de datos. Veamos un ejemplo para que quede más claro:
1 lista =[ " Lunes " ," Martes " ," Miércoles " ," Jueves " ," Viernes " , 40 , 5.67 ,
[1 ,2 ,3]]
2
3 print ( lista )
Programa 6.28: Ejemplo listas con elementos de diferentes tipos de datos
La salida del programa 6.28 es:
[ ’ Lunes ’ , ’ Martes ’ , ’ Miércoles ’ , ’ Jueves ’ , ’ Viernes ’ , 40 , 5.67 , [1 , 2 , 3]]

Como podemos observar, esta lista contiene cadenas, números enteros, números
con parte fraccionaria e incluso una lista.
 112 Capítulo 6

6.3.4. Determinar la cantidad de elementos en una lista

Para determinar la cantidad de elementos que tiene una lista, se puede usar la
función len. Ésta recibe como argumento la lista y devuelve la cantidad de elementos
que contiene dicha lista. Veamos un ejemplo:
1 lista =[ " Lunes " ," Martes " ," Miércoles " ," Jueves " ," Viernes " , 40 , 5.67 ,
[1 ,2 ,3]]
2
3 print ( len ( lista ) )
Programa 6.29: Ejemplo len
La salida del programa 6.29 es:
8

En total hay 8 elementos en la lista, incluso, la lista contenida dentro de la lista

cuenta como un solo elemento.

6.3.5. Insertar nuevos elementos en la lista

Podemos insertar nuevos elementos al final de la lista, para ello usaremos el método
append, el cual es invocado por la lista en la que se agregará el nuevo elemento.
Este método recibe como argumento el elemento por insertar en la lista. Veamos un
ejemplo:
1 lista =[1 ,2 ,3 ,4 ,5]
2
3 lista . append (6)
4
5 print ( lista )
Programa 6.30: Ejemplo append
La salida del programa 6.30 es:
[1 , 2 , 3 , 4 , 5 , 6]

Inicialmente, se tiene una lista con elementos enteros que van desde el 1 al 5.
Posteriormente, mediante el método append se agrega un nuevo elemento al final de
dicha lista como podemos ver en la salida del programa.
Puede darse el caso en que se necesita agregar un elemento en la lista, pero no
al final, si no en una posición específica. El método insert soluciona este problema.
Dicho método es invocado por la lista en la que se va a insertar un elemento, recibe
como argumentos la posición en la que se debe insertar el elemento, así como el
elemento que se va a agregar. Ejemplo:
1 lista =[1 ,2 ,4 ,5]
2

3 lista . insert (2 ,3)

4
5 print ( lista )
Programa 6.31: Ejemplo insert
 Cadenas y colecciones 113

La salida del programa 6.31 es:

[1 , 2 , 3 , 4 , 5]

Inicialmente se tiene una lista con cuatro elementos [1,2,4,5], el método insert
agrega el elemento 3 en la posición 2 (son datos que insert recibe como argumentos).
El primer argumento es la posición en la que se va a insertar el elemento, y el segundo
argumento es el elemento que queremos insertar.
Para agregar varios elementos simultáneamente al final de la lista usaremos el
método extend. Este método recibe como argumento una lista con los elementos que
se quieren insertar en la lista que lo invoca. Su uso se ejemplifica a continuación:
1 lista =[1 ,2 ,3 ,4 ,5]
2
3 lista . extend ([6 ,7 ,8])
4

5 print ( lista )
Programa 6.32: Ejemplo extend

Inicialmente se tiene una lista con elementos enteros del 1 al 5. Mediante el método
extend se agregan tres elementos más a la lista, los cuales son: 6, 7 y 8. La salida nos
presenta la lista con todos los elementos integrados.
[1 , 2 , 3 , 4 , 5 , 6 , 7 , 8]

El operador + permite unir, en una sola lista, los elementos de las listas a las que
se aplica dicho operador. Veamos el siguiente ejemplo:
1 lista1 =[1 ,2 ,3 ,4 ,5]
2 lista2 =[6 ,7 ,8]
3
4 lista3 = lista1 + lista2
5
6 print ( lista3 )
Programa 6.33: Ejemplo suma listas

Inicialmente, se tienen dos listas (lista1 y lista2), en la lista1 hay cinco

elementos y en la lista2 hay tres elementos. Se aplica el operador más (+) a ambas
listas, y se almacena el resultado en lista3, al mostrarse observamos que ya integra
tanto los elementos de lista1 como de lista2.
[1 , 2 , 3 , 4 , 5 , 6 , 7 , 8]

6.3.6. Buscar elementos en la lista

La palabra reservada in nos permite saber si un elemento se encuentra en una
lista. Devuelve True en caso de que el elemento se encuentre en la lista y False si no
se encuentra. Ejemplo:
1 lista =[1 ,2 ,3 ,4 ,5 , " Juan " ]
2
 114 Capítulo 6

3 print (3 in lista )
Programa 6.34: Ejemplo in

Se tiene una lista con 6 elementos, cinco números enteros y una cadena. Poste-
riormente, en un print se pregunta si el elemento 3 se encuentra en la lista (3 in
lista). Como efectivamente el elemento 3 se encuentra en la lista, se imprime True.
Cabe aclarar que también se pudo almacenar en una variable el resultado de evaluar
3 in lista. La salida del programa 6.34 es:
True

El método index permite conocer la posición en la que se encuentra un elemento

en la lista. Para ello es necesario pasarle como argumento el elemento que queremos
conocer su posición. Si el elemento se encuentra, index devuelve la posición, en caso
contrario, manda un error. Veamos el siguiente ejemplo:
1 lista =[1 ,2 ,3 ,4 ,5 , " Juan " ]
2
3 print ( lista . index ( " Juan " ) )
Programa 6.35: Ejemplo index

La salida del programa 6.35 es:

5

En la misma lista con 6 elementos, lista invoca al método index y le pasa como
argumento el elemento “Juan”. Como efectivamente el elemento se encuentra en la
lista, index devuelve la posición 5 que es donde se encuentra dicho elemento.

6.3.7. Contar cuantas veces aparece un elemento en la lista

Las listas permiten tener elementos repetidos, por lo que en algunas ocasiones
nos encontraremos en la necesidad de conocer cuántas veces aparece un elemento en
una lista. Para este fin utilizamos el método count, el cual recibe como argumento el
elemento que queremos saber cuántas veces se encuentra repetido en la lista; count
devuelve las veces que se encontró el elemento en la lista. Veamos el siguiente ejemplo:
1 lista =[1 ,2 ,3 ,4 ,5 , " Juan " ,1 ,2 ,3 ,4 ,1 ,1]
2
3 print ( lista . count (1) )
Programa 6.36: Ejemplo count

La salida del programa 6.36 es:

4

Vemos una lista con varios elementos, dicha lista invoca al método count pasándole
como argumento el elemento 1. Como dicha invocación se encuentra en un print, se
imprime 4, que es el número de veces que aparece el elemento 1 en la lista.
 Cadenas y colecciones 115

6.3.8. Eliminar elementos de la lista

El método pop, si no recibe argumentos, tiene la peculiaridad de eliminar el último
elemento de la lista. Veamos el siguiente ejemplo:
1 lista =[1 ,2 ,3 ,4 ,5 , " Juan " ]
2
3 lista . pop ()
4
5 print ( lista )
Programa 6.37: Ejemplo pop
La salida del programa 6.37 es:
[1 , 2 , 3 , 4 , 5]

Se tiene una lista con seis elementos, esta lista invoca al método pop, el cual no
recibe argumentos. Por lo tanto, se elimina el último elemento de la lista (“Juan”).
Al imprimir la lista, muestra únicamente los elementos que quedaron (ver salida del
programa 6.37).
El método pop también puede recibir como argumento una posición, en la cual se
encuentra el elemento que se quiere eliminar. Veamos el siguiente ejemplo:
1 lista =[1 ,2 ,3 ,4 ,5 , " Juan " ]
2
3 lista . pop (3)
4
5 print ( lista )
Programa 6.38: Ejemplo pop con argumento
La salida del programa 6.38 es:
[1 , 2 , 3 , 5 , ’ Juan ’]

En este caso se tiene una lista con seis elementos. Al método pop que es invocado
por la lista se le pasa como argumento la posición 3, con lo que se le indica a pop que
elimine de la lista el elemento que se encuentra en esa posición. Recordemos que el
primer elemento de la lista se encuentra en la posición 0.
Para eliminar un elemento de la lista pasando como argumento el elemento, dispo-
nemos del método remove, el cual a diferencia de pop, no requiere conocer la posición
del elemento. Veamos un ejemplo:
1 lista =[1 ,2 ,3 ,4 ,5 , " Juan " ]
2
3 lista . remove ( " Juan " )
4
5 print ( lista )
Programa 6.39: Ejemplo remove
Tenemos la lista con seis elementos y queremos eliminar el elemento “Juan”. En-
tonces, la lista invoca a remove, el cual recibe como argumento a dicho elemento.
Finalmente, al mostrar la lista notamos que el elemento “Juan” ya no se encuentra en
la lista.
 116 Capítulo 6

[1 , 2 , 3 , 4 , 5]

En algunas ocasiones será necesario vaciar por completo la lista. Para este fin
disponemos del método clear, el cual al ser invocado realiza este vaciado. El método
clear no recibe argumentos. Veamos el siguiente ejemplo:
1 lista =[1 ,2 ,3 ,4 ,5 , " Juan " ]
2

3 lista . clear ()
4
5 print ( lista )
Programa 6.40: Ejemplo clear
Para este ejemplo, utilizamos la lista de los ejemplos anteriores. Dicha lista invoca
al método clear, el cual vacía por completo la lista.
[]

6.3.9. Invertir la lista

El método reverse permite invertir por completo una lista, es decir, el elemento
0 pasa a la ultima posición, y el que se encuentra en la última posición pasa a la
posición 0. El mismo proceso aplica para los demás elementos. Veamos su uso:
1 lista =[1 ,2 ,3 ,4 ,5 , " Juan " ]
2
3 lista . reverse ()
4

5 print ( lista )
Programa 6.41: Ejemplo reverse
La salida del programa 6.41 es:
[ ’ Juan ’ , 5 , 4 , 3 , 2 , 1]

6.3.10. Ordenar elementos de la lista

Otra operación interesante que podemos realizar con los elementos de una lista
es ordenarlos ascendentemente, es decir, de menor a mayor. Para llevar a cabo dicho
ordenamiento, utilizaremos el método sort, el cual es invocado por la lista. Veamos
un ejemplo:
1 lista =[5 ,4 , -7 ,9 ,0 ,1 ,3]
2
3 lista . sort ()
4
5 print ( lista )
Programa 6.42: Ejemplo sort
La salida del programa 6.42 es:
 Cadenas y colecciones 117

[ -7 , 0 , 1 , 3 , 4 , 5 , 9]

Inicialmente tenemos una lista completamente desordenada, la cual invoca al mé-

todo sort. No es necesario almacenar el resultado de ordenar la lista en una variable,
ya que sort modifica directamente la lista que lo invocó (ver salida del programa
6.42).
En algunas ocasiones será necesario ordenar la lista de manera descendente, es
decir, de mayor a menor. Para este fin, utilizamos de nueva cuenta el método sort,
pero pasando la instrucción reverse=True como argumento. Veamos el ejemplo:
1 lista =[5 ,4 , -7 ,9 ,0 ,1 ,3]
2

3 lista . sort ( reverse = True )

4
5 print ( lista )
Programa 6.43: Ejemplo sort 2

La salida del programa 6.43 es:

[9 , 5 , 4 , 3 , 1 , 0 , -7]

6.3.11. Recorrer listas con for

Supongamos que tenemos una lista sobre la que tenemos que realizar algún tipo
de acción que implique acceder secuencialmente a cada uno de sus elementos. Sin ir
más lejos, ¿cómo haríamos para imprimir, uno por uno, cada elemento que compone
la lista?
El bucle for nos permite solucionar esto de un modo elegante. Obsérvalo en acción:
1 semana = [ ’ Lunes ’ , ’ Martes ’ , ’ Miércoles ’ , ’ Jueves ’ , ’ Viernes ’ , ’
Sábado ’ , ’ Domingo ’]
2
3 for dia in semana :
4 print ( dia )
Programa 6.44: Recorre listas

El programa 6.44 tiene como salida:

Lunes
Martes
Miércoles
Jueves
Viernes
Sábado
Domingo

La variable dia, definida ad hoc en el propio bucle, va a tomar, uno a uno, todos
los elementos de la lista semana, comenzando por ‘Lunes’ y terminando en ‘Domingo’.
 118 Capítulo 6

6.4. Tuplas
Las tuplas son inmutables, es decir, no se pueden modificar. No se podrá añadir,
eliminar, ni modificar los elementos. Veamos entonces qué podemos hacer con las
tuplas y qué ventajas tiene el utilizarlas.

6.4.1. Crear tuplas

En las listas se utilizan los corchetes [] para crearlas, ahora en las tuplas utiliza-
remos los paréntesis (). Para crear una tupla vacía simplemente le asignamos a una
variable los paréntesis tanto de apertura como de cierre. Veamos el ejemplo:
1 tupla =()
2
3 print ( tupla )
Programa 6.45: Ejemplo tupla vacía

La salida del programa 6.45 es:

()

Al igual que en las listas, en una tupla puede haber elementos de diferentes tipos
de datos. Veamos el siguiente ejemplo:
1 tupla =(4 , " Hola " ,6.78 ,[1 ,2 ,3 ,4])
2
3 print ( tupla )
Programa 6.46: Ejemplo tupla con diferentes elementos

La salida del programa 6.46 es:

(4 , ’ Hola ’ , 6.78 , [1 , 2 , 3 , 4])

En el ejemplo, se crea una tupla con elementos de diferentes tipos de datos, entre
ellos: números, cadenas y listas.
Como ya habíamos mencionado, no se pueden agregar nuevos elementos a las tu-
plas. Por ejemplo, si intentamos usar el método append después de crear la tupla,
tendríamos como salida un error. Tampoco se pueden modificar, ni eliminar los ele-
mentos existentes, cualquier intento de realizar alguna de estas operaciones en la tupla
genera un error.
Entonces ¿qué podemos hacer con las tuplas?

6.4.2. Mostrar elementos de una tupla

A través de sus índices, se pueden mostrar los elementos de las tuplas. Como en las
listas, hay que tener presente que el índice 0 sirve para referenciar al primer elemento
de la tupla. Veamos el ejemplo:
1 tupla =(4 , " Hola " ,6.78 ,[1 ,2 ,3 ,4])
2
 Cadenas y colecciones 119

3 print ( tupla [1])

Programa 6.47: Mostrar elementos de la tupla

La salida del programa 6.47 es:

Hola

También podemos utilizar los slicing para desplegar simultáneamente más de un

elemento de la tupla, ejemplo:
1 tupla =(4 , " Hola " ,6.78 ,[1 ,2 ,3 ,4])
2
3 print ( tupla [1:])
Programa 6.48: Mostrar simultáneamente elementos de la tupla

La salida del programa 6.48 es:

( ’ Hola ’ , 6.78 , [1 , 2 , 3 , 4])

6.4.3. Buscar elementos en la tupla

A través del operador in podemos saber si un elemento se encuentra en la tupla.
Su uso es similar al que se manejó en las listas, es decir, elemento in tupla. En
donde elemento es el elemento que se buscará y tupla es en donde lo va a buscar. Si
el elemento se encuentra en la tupla, la expresión devuelve True. Veamos el ejemplo:
1 tupla =(4 , " Hola " ,6.78 ,[1 ,2 ,3 ,4])
2
3 print (4 in tupla )
Programa 6.49: Operador in

La salida del programa 6.49 es:

True

Para conocer qué posición ocupa un elemento en la tupla disponemos del método
index, el cual al ser invocado por la tupla devuelve dicha posición. Este método recibe
como argumento el elemento que queremos saber su posición. Veamos el ejemplo:
1 tupla =(4 , " Hola " ,6.78 ,[1 ,2 ,3 ,4])
2
3 print ( tupla . index ( " Hola " ) )
Programa 6.50: Método index

La salida del programa 6.50 es:

1
 120 Capítulo 6

6.4.4. Contar la aparición de un elemento en la tupla

En algunas ocasiones será necesario saber cuántas veces se repite un elemento en
la tupla. Para poder contar el número de repeticiones Python ofrece el método count,
el cual al ser invocado por la tupla recibe como argumento el elemento por contar, y
devuelve las veces que dicho elemento aparece en la tupla, ejemplo:
1 tupla =(4 , " Hola " ,6.78 ,[1 ,2 ,3 ,4] ,4)
2
3 print ( tupla . count (4) )
Programa 6.51: método count
La salida del programa 6.51 es:
2

6.4.5. Conocer la longitud de la tupla

La función len permite conocer la cantidad de elementos que se encuentran en
una tupla. Dicha función recibe como argumento la tupla y devuelve la cantidad de
elementos que ésta tiene. Veamos un ejemplo:
1 tupla =(4 , " Hola " ,6.78 ,[1 ,2 ,3 ,4] ,4)
2
3 print ( len ( tupla ) )
Programa 6.52: función len
La salida del programa 6.52 es:
5

6.4.6. Transformar tuplas en lista

En algún momento podemos requerir que nuestra tupla se convierta en una lista,
para este fin podemos utilizar la función list, la cual recibe como argumento la
colección (en este caso una tupla) que queremos convertir a lista. Veamos el ejemplo:
1 tupla =(4 , " Hola " ,6.78 ,[1 ,2 ,3 ,4] ,4)
2

3 lista = list ( tupla )

4
5 print ( lista )
Programa 6.53: función list
La salida del programa 6.53 es:
[4 , ’ Hola ’ , 6.78 , [1 , 2 , 3 , 4] , 4]

En este ejemplo, se crea la tupla con cinco elementos de todo tipo de datos. Luego
a la función list se le pasa como argumento dicha tupla y se almacena la lista que
nos devuelve list en la variable lista.
 Cadenas y colecciones 121

6.4.7. Transformar listas en tuplas

Podemos transformar una lista en una tupla mediante la función tuple. Su uso
es muy sencillo, únicamente le pasamos la lista que queremos convertir a tupla y esta
función devuelve la lista convertida en tupla. Veamos el ejemplo:
1 lista =[4 , " Hola " ,6.78 ,[1 ,2 ,3 ,4] ,4]
2
3 tupla = tuple ( lista )
4
5 print ( tupla )
Programa 6.54: función tuple
La salida del programa 6.54 es:
(4 , ’ Hola ’ , 6.78 , [1 , 2 , 3 , 4] , 4)

6.4.8. Recorrer tuplas

Una característica de las tuplas es que son objetos iterables; es decir, con un
sencillo bucle for podemos recorrer fácilmente todos los elementos.
1 t = ( " a " ," cadena de texto " ,20 ,5.2)
2
3 for i in t :
4 print ( i )
Programa 6.55: Recorrido de la tupla t
El programa 6.55 tiene como salida:
a
cadena de texto
20
5.2

La variable i, en el propio bucle, va a tomar, uno a uno, todos los elementos de

la tupla t.

6.4.9. Ventajas de utilizar tuplas

Se mencionan a continuación algunas ventajas de usar tuplas:

1. Las tuplas son más rápidas que las listas y consumen menos memoria.
2. Hace que el código sea más seguro ya que “protege contra escritura” los datos
que no necesitan ser cambiados. Usar un tupla en lugar de una lista es como
tener una declaración de afirmación implícita de que estos datos son constantes
y que se requiere un pensamiento especial (y una función específica) para anular
eso.
3. Algunas tuplas se pueden usar como claves de diccionario (específicamente,
tuplas que contienen valores inmutables como cadenas, números y otras tuplas).
 122 Capítulo 6

6.5. Diccionarios
Los diccionarios en Python, al igual que las listas y las tuplas, nos permiten
almacenar diferentes tipos de datos: cadenas, enteros, flotantes, booleanos, tuplas,
listas e inclusive otros diccionarios.
Los diccionario son mutables, es decir, es posible modificarlos, agregar o quitar
elementos de él.
A diferencias de las listas y de las tuplas, los diccionarios no se rigen por la regla
de los índices. En este caso, todos los valores que se almacenen en el diccionario no
corresponderán a un índice, sino a una clave.
Todos los valores necesitan tener una clave y cada clave necesita tener un valor.
Algo interesante para mencionar y a tener muy en cuenta es que una clave podrá
ser cualquier objeto inmutable en Python, ya sea una cadena, un entero, un flotante
o una tupla, etc.
Podemos decir entonces que un diccionario tiene dos elementos por posición: clave
y valor. Y es importante mencionar que las claves no pueden ser duplicadas.

6.5.1. Crear un diccionario

Los diccionarios son creados con las llaves {}, a continuación, se muestra cómo
crear un diccionario vacío.

diccionario={}

Para agregar elementos por default (es decir, elementos que no necesitan de un
método en particular para ser agregados) a un diccionario, es necesario indicar la
clave y el valor. Veamos un ejemplo en el que se requiere traducir un color de español
a inglés.
1 diccionario ={ " azul " : " blue " , " rojo " : " red " , " verde " : " green " }
2
3 print ( diccionario )
Programa 6.56: Diccionario
La salida del programa 6.56 es:
{ ’ azul ’: ’ blue ’ , ’ rojo ’: ’red ’ , ’ verde ’: ’ green ’}

En este ejemplo se crea un diccionario (que se pudo llamar de cualquier forma)

con tres elementos. El primer elemento tiene como clave la cadena “azul” y como
valor la cadena “blue”. La clave y el valor de un elemento son separados por dos
puntos (:). Al imprimir el diccionario vemos los elementos que éste contiene.

6.5.2. Acceder al valor de un elemento del diccionario

Una vez creado el diccionario y que éste tenga elementos agregados, se puede
acceder al valor de un elemento en particular a través de su clave. Para ello veamos
 Cadenas y colecciones 123

el siguiente ejemplo:
1 diccionario ={ " azul " : " blue " , " rojo " : " red " , " verde " : " green " }
2
3 print ( diccionario [ " azul " ])
Programa 6.57: Acceso a un elemento del diccionario
La salida del programa 6.57 es:
blue

El ejemplo presenta el diccionario con tres elementos que traducen un color de

español a inglés. En dicho ejemplo se muestra como se dice “azul” en inglés. El acceso
al valor del elemento se lleva a cabo utilizando [] corchetes y dentro de ellos la clave.

6.5.3. Agregar nuevos elementos al diccionario

En muchas ocasiones será necesario agregar elementos al diccionario posterior a
su creación. Esta operación de agregar un nuevo elemento es muy sencilla, veamos un
ejemplo:
1 diccionario ={ " azul " : " blue " , " rojo " : " red " , " verde " : " green " }
2
3 diccionario [ " amarillo " ]= " yellow "
4
5 print ( diccionario )
Programa 6.58: Agregar un elemento al diccionario
La salida del programa 6.58 es:
{ ’ azul ’: ’ blue ’ , ’ rojo ’: ’red ’ , ’ verde ’: ’ green ’ , ’ amarillo ’: ’ yellow ’}

En el ejemplo inicialmente se tiene un diccionario con tres elementos. Posterior-

mente, se anexa en el diccionario el color amarillo con su traducción al inglés (ver
línea 3 de programa 6.58). Finalmente se muestra el diccionario, el cual ya incluye al
nuevo elemento.
Nota que para agregar una nueva clave (con su respectivo valor), se utilizan los
corchetes “[]”.

6.5.4. Modificar un elemento

Una herramienta muy útil en los diccionarios es poder modificar su valor. Dicha
modificación es muy fácil, únicamente accedemos al elemento mediante su clave y
agregamos el nuevo valor. Veamos el ejemplo:
1 diccionario ={ " azul " : " blue " , " rojo " : " red " , " verde " : " green " }
2
3 diccionario [ " azul " ]= " BLUE "
4

5 print ( diccionario )
Programa 6.59: Modificar un elemento del diccionario
 124 Capítulo 6

La salida del programa 6.59 es:

{ ’ azul ’: ’ BLUE ’ , ’ rojo ’: ’red ’ , ’ verde ’: ’ green ’}

En este ejemplo, se modifica el valor del elemento que tiene como clave la cadena
“azul”. Dicha modificación consiste en cambiar el color de “blue” a “BLUE” (ver línea 3
de programa 6.59). Finalmente, se muestra el diccionario con modificación realizada.

6.5.5. Eliminar un elemento

Otra operación que podemos hacer con un diccionario es eliminar un elemento
mientras el programa se ejecuta. Para realizar dicha eliminación, utilizamos la función
del, la cual recibe como argumento el elemento por eliminar. Veamos un ejemplo:
1 diccionario ={ " azul " : " blue " , " rojo " : " red " , " verde " : " green " }
2
3 del ( diccionario [ " verde " ])
4
5 print ( diccionario )
Programa 6.60: Eliminar un elemento del diccionario
La salida del programa 6.60 es:
{ ’ azul ’: ’ blue ’ , ’ rojo ’: ’red ’}

Inicialmente se tiene un diccionario con tres elementos, del cual se quiere eliminar
el elemento que tiene como clave la cadena “verde”. Únicamente pasamos este elemen-
to como argumento a la función del y listo. Imprimimos el diccionario y observamos
que el elemento ya no se encuentra.

6.5.6. Cuando la clave no existe

Puede darse el caso de que se accede a un elemento que no se encuentra en el dic-
cionario. Al realizar dicho acceso Python devuelve una excepción, veamos el ejemplo:
1 diccionario ={ " alejandro " :{ " edad " :22 , " estatura " :1.73} , " jose "
:[21 ,1.75] , " maria " :[22 ,1.67]}
2
3 print ( diccionario [ " Luis " ])
Programa 6.61: Acceso a un elemento que no existe en el diccionario
La salida del programa 6.61 es:
Traceback ( most recent call last ) :
File "/ diccionario6 . py " , line 3 , in < module >
print ( diccionario [" Luis "])
KeyError : ’ Luis ’

En el ejemplo, se tiene un diccionario con tres elementos. Posteriormente, se inten-

ta acceder al elemento que tiene como clave la cadena “Luis”. Como dicho elemento
no se encuentra en el diccionario, Python manda una Excepción KeyError.
Podemos manejar el error que manda Python de una manera muy sencilla y más
elegante cuando el elemento no se encuentra en el diccionario. Veamos el ejemplo:
 Cadenas y colecciones 125

1 diccionario ={ " alejandro " :{ " edad " :22 , " estatura " :1.73} , " jose "
:[21 ,1.75] , " maria " :[22 ,1.67]}
2
3 print ( diccionario . get ( " Luis " ," No existe esa persona " ) )
Programa 6.62: Acceso a un elemento que no existe en el diccionario 2
La salida del programa 6.62 es:
No existe esa persona

Como ya habíamos visto anteriormente, el elemento con clave “Luis” no existe,

entonces podemos manejar esa excepción con el método get, el cual recibe como
argumentos la clave del elemento que queremos obtener y un mensaje que le dé alguna
indicación al usuario en caso de que dicho elemento no se encuentre.
La salida del programa ya no manda la excepción KeyError, en su lugar muestra
la cadena “No existe esa persona”.

6.5.7. Búsqueda directa

Podemos hacer una búsqueda para determinar si un elemento se encuentra en
el diccionario. Para realizar dicha búsqueda empleamos el operador in. Veamos el
ejemplo:
1 diccionario ={ " alejandro " :{ " edad " :22 , " estatura " :1.73} , " jose "
:[21 ,1.75] , " maria " :[22 ,1.67]}
2
3 print ( " alejandro " in diccionario )
Programa 6.63: Operador in en diccionarios
La salida del programa 6.63 es:
True

Como podemos ver en el ejemplo, se opera con in indicándole la clave que que-
remos buscar en el diccionario. Si dicha clave se encuentra, esta expresión devuelve
True, en caso contrario, devuelve False.

6.5.8. Mostrar los valores del diccionario

Para mostrar los valores de los elementos de un diccionario disponemos del método
values, el cual es invocado por el diccionario. Este método no requiere argumentos,
veamos el ejemplo:
1 diccionario ={ " alejandro " :{ " edad " :22 , " estatura " :1.73} , " jose "
:[21 ,1.75] , " maria " :[22 ,1.67]}
2
3 print ( diccionario . values () )
Programa 6.64: Método values
La salida del programa 6.64 es:
dict_values ([{ ’ edad ’: 22 , ’ estatura ’: 1.73} , [21 , 1.75] , [22 , 1.67]])
 126 Capítulo 6

6.5.9. Cantidad de elementos del diccionario

La función len determina la cantidad de elementos del diccionario, su uso es muy
simple. Esta función recibe como argumento el diccionario. Veamos el ejemplo:
1 diccionario ={ " alejandro " :{ " edad " :22 , " estatura " :1.73} , " jose "
:[21 ,1.75] , " maria " :[22 ,1.67]}
2
3 print ( len ( diccionario ) )
Programa 6.65: Función len en diccionarios
La salida del programa 6.65 es:
3

6.5.10. Vaciar el diccionario

Podemos eliminar todos los elementos del diccionario utilizando el método clear,
el cual es invocado por el diccionario que queremos vaciar. Dicho método no recibe
argumentos, veamos el ejemplo:
1 diccionario ={ " alejandro " :{ " edad " :22 , " estatura " :1.73} , " jose "
:[21 ,1.75] , " maria " :[22 ,1.67]}
2
3 diccionario . clear ()
4
5 print ( diccionario )
Programa 6.66: Método clear en diccionarios
La salida del programa 6.66 es:
{}

6.5.11. Recorrer un diccionario con for

En numerosas ocasiones necesitaremos iterar a través de un diccionario mediante
un bucle for.
El código 6.67 muestra como iterar sobre las claves de un diccionario:
1 diccionario = { ’ plátano ’: ’ amarillo ’ , ’ fresa ’: ’ roja ’ , ’ manzana ’: ’
verde ’}
2
3 frutas = diccionario . keys ()
4
5 for fruta in frutas :
6 print ( fruta )
Programa 6.67: Recorrido a través de las claves
La salida del programa 6.67 es:
plátano
fresa
manzana
 Cadenas y colecciones 127

Primero se crea el diccionario con algunos datos de frutas (ver línea 1 de código
6.67). En seguida, se almacenan las claves del diccionario en la variable frutas (llevar
a cabo este almacenamiento es posible gracias al método keys). Finalmente, mediante
el bucle for se van mostrando una por una las claves del diccionario.
Otra forma de iterar en un diccionario es a través de sus valores. El código 6.68
muestra como realizar dicha iteración.
1 diccionario = { ’ plátano ’: ’ amarillo ’ , ’ fresa ’: ’ roja ’ , ’ manzana ’: ’
verde ’}
2
3 frutas = diccionario . values ()
4
5 for fruta in frutas :
6 print ( fruta )
Programa 6.68: Recorrido a través de los valores
La salida del programa 6.68 es:
amarillo
roja
verde

Como puedes notar los dos últimos códigos son similares, lo único que cambia es
que para iterar a través de los valores del diccionario se emplea el método values.
Finalmente, si necesitamos iterar sobre las claves y sus correspondientes valores
simultáneamente utilizamos el método items:
1 diccionario = { ’ plátano ’: ’ amarillo ’ , ’ fresa ’: ’ roja ’ , ’ manzana ’: ’
verde ’}
2

3 elementos = diccionario . items ()

4
5 for fruta , color in elementos :
6 print ( fruta , " ->" , color )
Programa 6.69: Recorrido a través de los elementos del diccionario
La salida del programa 6.69 es:
plátano -> amarillo
fresa -> roja
manzana -> verde

6.6. Conjuntos
Los conjuntos son grupos de elementos desordenados, donde su principal caracte-
rística es que no puede haber elemento duplicados.

6.6.1. Crear un conjunto

Para crear un conjunto podemos hacerlo de la siguiente manera:
 128 Capítulo 6

conjunto=set()

Al igual que en los diccionarios, los conjuntos utilizan las llaves “{}’’ para contener
elementos; sin embargo, para poder diferenciarlos de los diccionarios es necesario
utilizar la función set al momento de crearlos.
Como ya habíamos mencionado, se crea con set un conjunto vacío. Sin embargo, si
al conjunto le agregas elementos desde su creación, ya no es necesario usar la función
set.
A continuación, veremos cómo crear un conjunto vacío:
1 conjunto = set ()
2
3 conjunto ={}
4

5 print ( conjunto )
Programa 6.70: Conjunto vacío

La salida del programa 6.70 es:

{}

En un conjunto se pueden agregar diferentes tipos de elementos (cadenas, enteros,

flotantes):
1 conjunto ={1 ,2 ,3 , " Hola " ,345.5}
2
3 print ( conjunto )
Programa 6.71: Conjunto con elementos

La salida del programa 6.71 es:

{1 , 2 , 3 , 345.5 , ’ Hola ’}

Sin embargo, en un conjunto no se pueden agregar otros tipos de colecciones como

las listas.
En los conjuntos no puede haber elementos duplicados, si agregamos elementos
duplicados, no se produce un error, pero el conjunto no los almacena.
1 conjunto ={1 ,2 ,3 , " Hola " ,345.5 ,1 ,2 ,3}
2
3 print ( conjunto )
Programa 6.72: Conjunto con elementos duplicados

La salida del programa 6.72 es:

{1 , 2 , 3 , ’ Hola ’ , 345.5}

Es importante notar que los elementos agregados al conjunto se muestran de forma

desordenada.
Para agregar más elementos al conjunto se dispone del método add, el cual recibe
como argumento el elemento que se va a agregar. Veamos el ejemplo:
 Cadenas y colecciones 129

1 conjunto ={1 ,2 ,3 , " Hola " ,345.5}

2

3 conjunto . add (5)

4
5 print ( conjunto )
Programa 6.73: Método add
La salida del programa 6.73 es:
{1 , 2 , 3 , 5 , ’ Hola ’ , 345.5}

Nota que el conjunto no necesariamente se agregó al final, recordemos que el

conjunto lo agrega de forma desordenada.

6.6.2. Eliminar elementos del conjunto

Para eliminar elementos del conjunto Python ofrece el método discard, el cual
recibe como argumento el elemento que se eliminará.
1 conjunto ={1 ,2 ,3 , " Hola " ,345.5}
2
3 conjunto . discard (3)
4
5 print ( conjunto )
Programa 6.74: Método discard
La salida del programa 6.74 es:
{1 , 2 , 345.5 , ’ Hola ’}

Ahora bien, para vaciar el conjunto, es decir, eliminar todos los elementos, Python
ofrece el método clear, sin argumentos. Veamos el ejemplo:
1 conjunto ={1 ,2 ,3 , " Hola " ,345.5}
2
3 conjunto . clear ()
4
5 print ( conjunto )
Programa 6.75: Método clear
La salida del programa 6.75 es:
set ()

6.6.3. Buscar un elemento

Se puede saber si un elemento existe en el conjunto, esto es posible gracias al
operador in. Su funcionamiento es tal cual lo hemos venido trabajando en otras
colecciones, es decir, elemento in conjunto. Donde elemento es el elemento que
queremos buscar, y conjunto el conjunto donde se realiza la búsqueda. Esta expresión
devuelve True si el elemento se encuentra, en caso contrario, devuelve False. Veamos
el ejemplo:
 130 Capítulo 6

1 conjunto ={1 ,2 ,3 , " Hola " ,345.5}

2

3 print (3 in conjunto )
Programa 6.76: Operador in en conjuntos
La salida del programa 6.76 es:
True

La búsqueda también se puede hacer a la inversa, es decir, determinar si el ele-

mento no se encuentra en el conjunto. Esta búsqueda es posible utilizando el operador
not in, el cual devuelve True si el elemento no se encuentra, y False si el elemento
se encuentra en el conjunto. Veamos el ejemplo:
1 conjunto ={1 ,2 ,3 , " Hola " ,345.5}
2
3 print (3 not in conjunto )
Programa 6.77: Operador not in en conjuntos
La salida del programa 6.77 es:
False

6.6.4. Igualdad de conjuntos

Se puede determinar si un conjunto es igual a otro conjunto mediante el operador
==. Veamos el ejemplo:
1 a ={1 ,2 ,3}
2
3 b ={3 ,4 ,5}
4
5 print ( a == b )
Programa 6.78: Operador de igualdad
La salida del programa 6.78 es:
False

Se tienen dos conjuntos (a y b), con el mismo número de elementos pero con
elementos diferentes. Al aplicar el operador ==, éste devuelve False, ya que son
conjuntos diferentes.

6.6.5. Conocer la cantidad de elementos de un conjunto

Para conocer la cantidad de elementos de un conjunto Python ofrece la función
len, la cual recibe como argumento el conjunto. Veamos el ejemplo:
1 a ={1 ,2 ,3}
2
3 b ={3 ,4 ,5}
4
 Cadenas y colecciones 131

5 print ( len ( a ) )
Programa 6.79: Función len en conjuntos

La salida del programa 6.79 es:

3

6.6.6. Unión de conjuntos

Como vimos en el capítulo 1, la unión de dos o más conjuntos es el conjunto
formado por todos los elementos que pertenecen a ambos conjuntos. En Python,
podemos realizar dicha unión empleando el operador barra (|). Veamos el ejemplo:
1 a ={1 ,2 ,3}
2
3 b ={3 ,4 ,5}
4
5 c=a|b
6
7 print ( c )
Programa 6.80: Unión de conjuntos

La salida del programa 6.80 es:

{1 , 2 , 3 , 4 , 5}

En este ejemplo, se tienen inicialmente dos conjuntos con tres elementos cada uno
(a y b), luego se crea el conjunto c, al cual se le asigna la unión de a y b. Finalmente,
se muestra el conjunto c con los elementos correspondientes.

6.6.7. Intersección de conjuntos

Recordando, la intersección de dos o más conjuntos es el conjunto formado por lo
elementos que tienen en común ambos conjuntos. En Python podemos realizar dicha
intersección empleando el operador &. Veamos el ejemplo:
1 a ={1 ,2 ,3}
2
3 b ={3 ,4 ,5}
4
5 c = a & b
6
7 print ( c )
Programa 6.81: intersección de conjuntos

La salida del programa 6.81 es:

{3}
 132 Capítulo 6

6.6.8. Diferencia de conjuntos

Podemos decir que la diferencia de dos conjuntos (a - b), nos devuelve el conjunto
con los elementos de a que no están en b. El operador resta (-) lleva a cabo dicha
función. Veamos un ejemplo:
1 a ={1 ,2 ,3}
2
3 b ={3 ,4 ,5}
4
5 c = a - b
6

7 print ( c )
Programa 6.82: Diferencia de conjuntos
La salida del programa 6.82 es:
{1 , 2}

6.6.9. Diferencia simétrica

Son los elementos que están en a y en b, pero no en ambos. El operador ∧ permite
realizar la diferencia simétrica. Veamos el ejemplo en Python:
1 a ={1 ,2 ,3}
2
3 b ={3 ,4 ,5}
4
5 c = a ^ b
6
7 print ( c )
Programa 6.83: Diferencia simétrica de conjuntos
La salida del programa 6.83 es:
{1 , 2 , 4 , 5}

6.6.10. Determinar si un conjunto es subconjunto de otro

Para determinar si un conjunto es subconjunto de otro, disponemos del método
issubset, el cual es invocado por el posible “subconjunto” y recibe como argumento
el conjunto en el que se quiere buscar al subconjunto. Su función es de la siguiente
manera:
1 a ={1 ,2 ,3}
2
3 b ={3 ,4 ,5}
4

5 c ={1 ,2 ,3 ,4 ,5}
6
7 print ( a . issubset ( c ) )
Programa 6.84: Método issubset
 Cadenas y colecciones 133

La salida del programa 6.84 es:

True

En el ejemplo tenemos el conjunto a, b, c; y se quiere determinar si a es subcon-

junto de c. Como efectivamente a es subconjunto de c, el método issubset devuelve
True.

6.6.11. Recorrer un conjunto con for

Dado que los conjuntos son colecciones desordenadas, en ellos no se guarda la
posición en la que son insertados los elementos como ocurre en los tipos list o
tuple. Es por ello que no se puede acceder a los elementos a través de un índice. Sin
embargo, sí se puede acceder y/o recorrer todos los elementos de un conjunto usando
un bucle for:
1 conjunto = {1 , 3 , 2 , 9 , 3 , 1}
2
3 for e in conjunto :
4 print ( e )
Programa 6.85: Recorrido de un conjunto

La salida del programa 6.85 es:

1
2
3
9

6.7. Ejercicios cadenas y colecciones

1. Hacer un programa donde se deberá imprimir por la consola la palabra con más
caracteres de dos palabras dadas. En el caso de que ambas palabras tengan la
misma cantidad de caracteres, deberás mostrar el mensaje “Son iguales”.

2. Hacer un programa en Python para detectar si una frase introducida por el

usuario finaliza con un punto “.” o no. Deberás imprimir por consola una de las
siguientes opciones; “Termina con un punto” o por el contrario “No termina con
un punto”.

3. Hacer un programa que determine si una palabra o frase es palíndroma. Una

cadena palíndroma se lee igual de izquierda a derecha que de derecha a izquierda.
Ejemplos:

oso
reconocer
anita lava la tina
134 Capítulo 6

4. Hacer un programa donde se cuente cada una de las vocales en una cadena,
mostrar el conteo de las apariciones de cada vocal.

5. Escribe un programa donde tenga una lista y que, a continuación, elimine los
elementos repetidos, por último, mostrar la lista.

6. Escribe un programa que tenga dos listas y que, a continuación, cree las siguien-
tes listas (en las que no debe haber repeticiones):

Lista de elementos que aparecen en las dos listas.

Lista de elementos que aparecen en la primera lista, pero no en la segunda.
Lista de elementos que aparecen en la segunda lista, pero no en la primera.
Lista de elementos que aparecen en ambas listas
 Capítulo 7

Funciones

Una función es un bloque de código que se puede usar varias veces en varios puntos
distintos de nuestro programa. Nos evita tener que repetir código y facilita la lectura
y el mantenimiento del programa.
Para declarar una función usamos la palabra reservada def seguida del nombre de
la función, un paréntesis para pasarle datos a la función (no en todos los casos requiere
datos) y dos puntos. A continuación de esto se encuentra el código de la función (es
importante dejar un espaciado donde inicia el código, ya que de esta manera Python
identifica que dicho código pertenece a la función).
Los nombres de las funciones siguen las mismas reglas que los nombres de las
variables. Es decir, deben comenzar por una letra o un guion bajo, no pueden contener
espacios ni pueden comenzar por un número, pero sí contener números. Se recomienda
usar nombres en minúsculas y, si constan de más de una palabra, éstas deberán estar
separadas por guiones bajos.
Una función debe ser invocada para que se ejecute. Para invocar a la función se
usa su nombre seguido de un paréntesis. Cada vez que se llama de este modo a la
función, se ejecuta su código:
1 def saludo () :
2 print ( " Hola mundo ... " )
3 print ( " Esta es mi primera función ... " )
4

5 saludo ()
Programa 7.1: Función saludo

Cuando ejecutamos el programa, tenemos como salida:

Hola mundo ...
Esta es mi primera función ...

En este ejemplo, cada vez que invoquemos en nuestro programa a la función

saludo(), se imprimirán esas dos líneas (ver salida de programa 7.1). Si hemos de
hacerlo varias veces, nos ahorramos escribir esos dos print cada vez (ver línea 2 y 3
de programa 7.1), lo que redunda además en un código más limpio, claro y legible.

135
 136 Capítulo 7

7.1. Funciones con y sin retorno de valor

Existen dos tipos de funciones, aquellas que realizan una tarea y no devuelven
ningún valor y aquellas que tras realizar la tarea devuelven un valor o resultado.
En esta sección analizaremos primero las funciones que no retornan ningún valor y
posteriormente las funciones que retornan un valor.

7.1.1. Funciones sin retorno de valor

Nada mejor que un ejemplo para poder ilustrar este tipo de funciones:
1 def saludar () :
2 print ( " Hola amigo " )
3
4 saludar ()
Programa 7.2: Ejemplo función sin retorno de valor
El código anterior muestra una función llamada saludar, la cual no recibe ningún
argumento o dato de entrada; y en su interior contiene una línea de código que imprime
un saludo. Posteriormente esta función es invocada generando la salida siguiente:
Hola amigo

Algunas funciones que no retornan un valor también pueden recibir datos de en-
trada como argumentos. Estos datos de entrada son procesados en el interior de la
función. Veamos el siguiente ejemplo:
1 def saludar ( nombre ) :
2 print ( f " Hola { nombre } " )
3
4 saludar ( " Carlos " )
Programa 7.3: Ejemplo función sin retorno de valor con argumento
La función saludar recibe como argumento una cadena, la cual es mostrada junto
con la palabra “Hola”. En este caso, la cadena que se pasa como argumento es la
palabra “Carlos”, que combinada con la palabra que se encuentra en la función genera
la salida siguiente:
Hola Carlos

Otro ejemplo más práctico del uso de funciones sin retorno de valor y con argu-
mento de entrada, lo visualizamos en la siguiente función, la cual tiene como finalidad
mostrar la tabla de multiplicar de un número pasado como argumento.
1 def tab la_multi plicar ( i ) :
2 for j in range (1 ,11) :
3 print ( f " { i } X { j } = { i * j } " )
4
5 tabla _multipl icar (8)
Programa 7.4: Tabla de multiplicar
Cuando ejecutamos el programa, tenemos como salida:
 Funciones 137

8 X 1 = 8
8 X 2 = 16
8 X 3 = 24
8 X 4 = 32
8 X 5 = 40
8 X 6 = 48
8 X 7 = 56
8 X 8 = 64
8 X 9 = 72
8 X 10 = 80

7.1.2. Funciones con retorno de valor

A diferencia de las funciones que no retornan un valor, las funciones con retorno
de valor hacen uso de la palabra reservada return para devolver un resultado, el cual
es producto de la tarea realizada por la función.
A continuación, se presenta una función llamada multiplicar, que recibe como
argumentos (datos de entrada) dos números, los cuales son multiplicados entre sí y el
resultado es devuelto por la función.
1 def multiplicar ( num1 , num2 ) :
2 mult = num1 * num2
3 return mult
4
5 print ( multiplicar (3 ,4) )
Programa 7.5: Multiplica dos números

Cuando ejecutamos el programa, tenemos como salida:

12

Se debe notar que la función es invocada dentro de un print, con los valores 3 y
4. Lo que genera que se imprima un 12. Es importante hacer notar que también el
valor devuelto por la función pudo haber sido almacenado en una variable en lugar
de mostrarlo directamente con print.
Una función también puede retornar más de un valor (de diferentes tipos, por
ejemplo, cadenas, enteros, listas, etc.), los cuales son separados por comas al momen-
to de realizar el retorno (return). Ademas, al realizar dicha separación con comas,
aunque no se utilicen los paréntesis, automáticamente los valores se integran en una
tupla. Veamos el siguiente ejemplo:
1 def funcion () :
2 return " Hola " , 45 , [1 ,2 ,3]
3
4 print ( funcion () )
Programa 7.6: Función retorna varios valores

Cuando ejecutamos el programa, tenemos como salida:

( ’ Hola ’ , 45 , [1 , 2 , 3])
 138 Capítulo 7

En el ejemplo anterior podemos ver la función funcion, la cual retorna varios

elementos de diferentes tipos (es decir, una cadena, un entero y una lista). Al ser
invocada dicha función, vemos los elementos integrados en una tupla.
Retomando el ejemplo anterior, en el cual la función retorna más de un valor,
también se pueden almacenar estos valores (al momento de invocar la función) en
variables. Es importante que haya tantas variables como valores retornados. Veamos
el siguiente ejemplo:
1 def funcion () :
2 return " Hola " , 45 , [1 ,2 ,3]
3
4 c ,n , l = funcion ()
5 print ( c )
6 print ( n )
7 print ( l )
Programa 7.7: Función retorna varios valores 2
Cuando ejecutamos el programa, tenemos como salida:
Hola
45
[1 , 2 , 3]

7.2. Argumentos y parámetros

Hasta el momento no se ha marcado una diferencia entre argumento y parámetro,
es decir, ambos términos se han manejado por igual. Sin embargo, existe una diferencia
sutil para diferenciar estos conceptos. Dicha diferencia es la siguiente:

1. Cuando la función es invocada, los datos que se proporcionan a la función se les

denomina argumentos.

2. En el prototipo de la función, es decir, en donde la función es creada, los valores

que recibe de entrada esta función se les denomina parámetros.

Veamos el siguiente ejemplo:

1 def restar ( num1 , num2 ) :
2 return num1 - num2
3
4 print ( restar (4 ,3) )
Programa 7.8: Ejemplo argumentos y parámetros
Cuando ejecutamos el programa, tenemos como salida:
1

En el ejemplo se presenta la función restar, la cual se encarga de restar los valores

proporcionamos como entradas. Cuando la función es invocada, se le proporcionan
los valores 4 y 3, a los cuales en ese momento se les denomina argumentos. Por su
 Funciones 139

parte, el prototipo de la función resta recibe como datos de entrada num1 y num2. A
estos datos se les denomina parámetros.
Es importante hacer notar que tanto argumentos como parámetros tienen un or-
den. En el ejemplo anterior, num1 toma el valor de 4 y num2 toma el valor de 3. En
dicho ejemplo, si se hubiera querido restar 4 de 3, se hubiera invocado la función se
la siguiente manera:

restar(3,4)

Lo que hubiera devuelto como resultado -1.

Podemos decir, entonces, que el primer argumento va a estar referenciado por el
primer parámetro; y así para los demás elementos que reciba como entrada la función.

7.3. Argumentos por valor y por referencia

Algunos lenguajes de programación soportan el paso de argumentos por valor y
por referencia. La idea detrás de estos conceptos es la siguiente:
1. Paso por valor: se pasa como argumento un dato o variable (por ejemplo,
un entero, un flotante, una cadena, etc.), la cual no se modifica su valor al
ejecutarse la función. Por ejemplo:
1 def doblar_valor ( numero ) :
2 numero *=2
3
4 n =5
5 doblar_valor ( n )
6 print ( n )
Programa 7.9: Paso valor

Cuando ejecutamos el programa, tenemos como salida:

5

En este ejemplo se pasa la variable n con un valor inicial de 5 a la función

doblar_valor. Cuando ese valor n entra en dicha función, se dobla su valor, es
decir, si n valía 5, en la función vale 10. Sin embargo, al regresar a la ejecución
después de salir de la función se imprime n, con el valor de 5. Esto quiere decir
que el valor de n solo fue modificado al interior de la función, pero no por toda
la ejecución del programa.
2. Paso por referencia: La idea detrás del paso por referencia es que al pasar
un valor como argumento a una función y modificarlo, dicha modificación se
mantenga aun cuando se salga de la función. Este concepto no aplica a todos
los tipos de datos en Python, por ejemplo, en los enteros si se quisiera modificar
el valor y que este valor modificado se mantenga se tendría que hacer algo como
lo siguiente:
140 Capítulo 7

1 def doblar_valor ( numero ) :

2 return numero *2
3
4 n =5
5 n = doblar_valor ( n )
6 print ( n )
Programa 7.10: Paso referencia con enteros

Cuando ejecutamos el programa, tenemos como salida:

10

Inicialmente n vale 5, este valor se pasa como argumento a la función, la cual

en su interior retorna (return) el doble de 5, o sea, 10. Ese valor retornado se
almacena en la variable n, con lo que n ya vale 10 al exterior de la función.
Las listas son estructuras que se pasan por referencia en su pleno concepto. Esto
significa que, si sus valores cambian al interior de una función, sin necesidad de
que los nuevos valores de la lista sean retornados, éstos se mantendrán al exterior
de la función. Veamos el ejemplo siguiente:
1 def doblar_valores ( numeros ) :
2 for i , n in enumerate ( numeros ) :
3 numeros [ i ]*=2
4

5 n =[5 ,10 ,15 ,20]

6 doblar_valores ( n )
7 print ( n )
Programa 7.11: Paso referencia con listas

Cuando ejecutamos el programa, tenemos como salida:

[10 , 20 , 30 , 40]

7.4. Funciones recursivas

Las funciones recursivas son funciones que se llaman a sí mismas durante su eje-
cución. Ellas funcionan de forma similar a las iteraciones, pero se debe de planificar
el momento en que dejan de llamarse a sí mismas o tendrá una función recursiva
infinita.
Estas funciones se estilan utilizar para dividir una tarea en subtareas más simples
de forma que sea más fácil abordar el problema y solucionarlo.

7.4.1. Función recursiva sin retorno

Un ejemplo de una función recursiva sin retorno es el de cuenta regresiva hasta
cero a partir de un número:
 Funciones 141

1 def cuenta_regresiva ( numero ) :

2 if numero >0:
3 print ( numero )
4 cuenta_regresiva ( numero -1)
5 else :
6 print ( " ¡Booom ! " )
7
8 cuenta_regresiva (5)
Programa 7.12: Cuenta regresiva
Cuando ejecutamos el programa, tenemos como salida:
5
4
3
2
1
¡Booom !

7.4.2. Función recursiva con retorno

Un ejemplo de una función recursiva con retorno es el del cálculo del factorial
de un número corresponde al producto de todos los números desde 1 hasta el propio
número. Es el ejemplo con retorno más utilizado para mostrar la utilidad de este tipo
de funciones:
1 def factorial ( n ) :
2 if n ==0 or n ==1:
3 return 1
4 else :
5 return n * factorial (n -1)
6
7 print ( factorial (5) )
Programa 7.13: Factorial recursivo
Cuando ejecutamos el programa, tenemos como salida:
120

7.5. Ejercicios
1. Se desea calcular independientemente la suma de los números pares compren-
didos entre n y m para m>n.
La estructura de la función es:

def suma_pares(n,m):

Devuelve la suma de los pares entre n y m

142 Capítulo 7

2. Crear una función que recibe un número N y escriba su cuadrado.

La estructura de la función es:

def cuadrado(N):

Devuelve el cuadrado de N

3. Crear una función que reciba como parámetro un número y diga si el número
es primo o no es primo.

4. Hacer un programa que pida la anchura y altura de un rectángulo y con ayuda

de una función lo dibuje con *.
Ejemplo:
ancho=7
alto=3

* * * * * * *
* * * * * * *
* * * * * * *
 Capítulo 8

Introducción a la complejidad
computacional

8.1. Análisis de algoritmos

El análisis de algoritmos es una herramienta para hacer la evaluación de un diseño.
Esta herramienta permite establecer la calidad de un programa y compararlo con otros
programas que resuelven un mismo problema.
Consideremos dos programas P1 y P2 para resolver el mismo problema, el cual
consiste en calcular la suma de los primeros n números naturales. ¿Cuál de los dos es
mejor?
Como primera aproximación podríamos implementar ambos programas y medir el
tiempo que cada uno de ellos consume en resolver el problema para diversos valores
de n.
El programa 8.1 implementa dos funciones (suma_P1 y suma_P2), cada una de
ellas resuelve el problema de sumar los primeros n números naturales.
1 import time
2

3 def suma_P1 ( n ) :
4 return ( n *( n +1) ) /2
5
6 def suma_P2 ( n ) :
7 con =1
8 suma =0
9
10 while ( con <= n ) :
11 suma = suma + con
12 con +=1
13
14 return suma
15
16 n =20000000
17 comienzo = time . time ()
18 suma_P1 ( n )

143
 144 Capítulo 8

19 final = time . time ()

20 print ( final - comienzo )
21
22 comienzo = time . time ()
23 suma_P2 ( n )
24 final = time . time ()
25 print ( final - comienzo )
Programa 8.1: Suma de primeros n números
Veamos entonces cuánto tiempo tarda cada una de ellas en resolver el problema,
para diversos valores de n.

Programa n=1000 n=10000 n=100000 n=1000000

P1 2.14e − 06 3.09e − 06 4.05e − 06 4.05e − 06
P2 9.39e − 05 0.0016 0.0190 0.1929

Tabla 8.1: Tiempos de ejecución de P1 y P2

Características del equipo donde se realizó la prueba a los programas P1

y P2
Macbook Air, con procesador Intel Core i5 de doble núcleo a 1.6 GHz y con 4
MB de caché L3 compartida.

8 GB de memoria SDRAM a 2133 MHz

SSD basado en PCIe de 256 GB

De acuerdo con el análisis realizado en esta primera aproximación, P1 es más
eficiente que P2. Sin embargo, si utilizamos esta estrategia de solución para determinar
la eficiencia de los algoritmos nos limitamos a depender de la computadora (tanto del
hardware como del software) donde se prueben los programas. Así mismo, sería poco
factible implementar todas las soluciones que puedan haber para el mismo problema
con el fin de determinar la más eficiente.
Lo ideal sería entonces establecer una medida de la calidad de los algoritmos,
que permita compararlos sin la necesidad de implementarlos y cronometrarlos. Esto
implica asociar a cada algoritmo una función matemática que mida su eficiencia.
Además del tiempo de ejecución, para medir la eficiencia se debe considerar la
cantidad de memoria utilizada por el programa. Sin embargo, en el breve análisis que
realizamos en este capítulo, nos centraremos exclusivamente a medir principalmente
el tiempo de ejecución.

8.1.1. Tiempo de ejecución

Se define como el tiempo empleado por un algoritmo en procesar una entrada
de tamaño n y producir una solución al problema. El ideal es encontrar una función
matemática T(n) que describa de manera exacta dicho tiempo empleado.
 Introducción a la complejidad computacional 145

Ejemplo: consideremos los programas P1 y P2 que suman los primeros n números

naturales
Supongamos que fijamos n=5 y que la evaluación de cada línea del programa tarda
t microsegundos. En el caso del programa P1 tendríamos lo siguiente:

(5 ∗ 6)/2 t ms
Total 1 t ms

Ahora veamos qué pasa con el programa P2:

con=1 t ms
suma=0 t ms
1<=5 t ms
suma=suma+con t ms
con+=1 t ms
2<=5 t ms
suma=suma+con t ms
con+=1 t ms
3<=5 t ms
suma=suma+con t ms
con+=1 t ms
4<=5 t ms
suma=suma+con t ms
con+=1 t ms
5<=5 t ms
suma=suma+con t ms
con+=1 t ms
Total 17 t ms

A partir de este análisis podemos decir que para P1 T(n)=1 y para P2 T(n)=3n+2
Aunque se conozca el tamaño de los datos de entrada, es imposible para muchos
problemas determinar el tiempo de ejecución para cada una de las posibles entradas.
Por esta razón se debe trabajar con el tiempo utilizado por el algoritmo en el peor de
los casos. Con este antecedente se redefine T(n).
T(n) = Tiempo que se demora el algoritmo en el peor de los casos, para encontrar
una solución a un problema de tamaño n.

8.2. Complejidad
La idea detrás del concepto de complejidad es tratar de encontrar una función
f (n), fácil de calcular y conocida, que acote el crecimiento de la función de tiempo,
para poder decir: “T (n) crece aproximadamente como f ” o más exacto “En ningún
caso T (n) se comportará peor que f al aumentar el tamaño del problema”.
146 Capítulo 8

La complejidad asintótica consiste en el cálculo de la complejidad temporal de

un algoritmo en función del tamaño de las entradas del problema, prescindiendo de
factores constantes y suponiendo valores de n muy grandes. Esta complejidad no sirve
para establecer el tiempo exacto de ejecución, sino que permite especificar una cota
(inferior, superior o ambas) para el tiempo de ejecución del algoritmo.
La eficiencia de un algoritmo se mide mediante el número de operaciones elemen-
tales que se deben ejecutar.
El Análisis del Peor Caso se define como el máximo costo (operaciones elemen-
tales) de aplicar el algoritmo a un problema de tamaño n. Este análisis se suele aplicar
para casos extremos en los que interesa saber cuánto, como máximo, va a costar la
aplicación del algoritmo.
Algunas reglas básicas para realizar dicho conteo:

Operaciones básicas (+, -, *, =, . . . ): Una unidad de tiempo o alguna constante.

Operaciones de entrada / salida: Otra unidad de tiempo o una constante dife-

rente.

Ciclos: Se pueden expresar como la sumatoria, con los límites del ciclo.

Condicionales: Estudiar lo que puede ocurrir, mejor caso y peor caso según la
condición.

Llamadas a procedimientos: Una constante de la llamada más el tiempo del

procedimiento.

8.2.1. Notación asintótica

Se denomina notación asintótica porque trata acerca del comportamiento de
funciones en el límite, esto quiere decir, para valores de entrada suficientemente gran-
des. Esto hace que los valores pequeños de las entradas no sean interesantes. Dicho de
otra manera, estamos interesados en las tasas de crecimiento en lugar de los valores
concretos.
La notación O Grande o cota superior es la encargada de dar una cota para el
peor caso y determinar las acotaciones superiores lo más exactas posible para valores
crecientes de la entrada. Por lo tanto, se puede asegurar que, conociendo la cota
superior, ningún tiempo empleado en resolver el problema dado será de un orden
superior al de la cota.
La notación asintótica clasifica las funciones de tiempo de los algoritmos (ver
fig. 8.1) para que puedan ser comparadas. A modo de ejemplo se pueden mencionar
algunas funciones típicas de complejidad de algoritmos (dicho de otra forma que
acotan superiormente el comportamiento del tiempo de ejecución). La línea de color
rojo, que se encuentra casi pegada al eje x, representa a la función f (n) = log(n). La
línea naranja (que sigue a la roja), representa a la función f (n) = n. Por su parte, la
línea azul marino (posterior a la naranja), representa la función f (n) = nlog(n). La
 Introducción a la complejidad computacional 147

función f (n) = n2 está representada por la línea verde. Finalmente, la línea que se
encuentra casi pegada al eje y de color azul turquesa representa la función f (n) = 2n .
El eje x representa los valores que toma n, y el eje y f(n).

Figura 8.1: Funciones de tiempo de los algoritmos

Esta representación gráfica de las funciones da la pauta para saber cómo “trans-
curre el tiempo” conforme el valor de n aumenta. Evidentemente un algoritmo que
implemente una solución exponencial no es adecuado para valores de n grandes.
Un problema se denomina Tratable si existe un algoritmo de complejidad poli-
nomial para resolverlo. En caso contrario se denomina Intratable.
Esta clasificación es importante porque, cuando el tamaño del problema aumenta,
los algoritmos de complejidad polinomial dejan de ser utilizables de manera gradual.

8.2.2. Reglas útiles

Consideremos las siguientes reglas aplicadas a la notación de complejidad O
Grande:

Regla de la suma:

O(f ) + O(g) = O(f + g) = O(max(f, g))

Regla del producto:

O(f )O(g) = O(f g)

Ejemplos regla de la suma:

 148 Capítulo 8

1 def f ( n ) :
2 for i in range ( n ) :
3 print ( i )
4
5 for i in range ( n ) :
6 print ( i )
Programa 8.2: Ejemplo regla de la suma

En el programa 8.2 podemos ver que existe una función f que recibe como argu-
mento a n. Dentro de esta función hay dos ciclos independientes, el primero va de 0
hasta n-1 y el segundo ciclo también. La complejidad tanto del primer ciclo como del
segundo es O(n). Pero al estar independientes ambos ciclos podemos utilizar la regla
de la suma, es decir:

O(n) + O(n) = O(n + n) = O(2n) = O(n)

Podemos decir entonces que la complejidad del código 8.2 es O(n), la cual es lineal.
Consideremos el siguiente fragmento de código:
1 def f ( n ) :
2 for i in range ( n ) :
3 print ( i )
4

5 for i in range ( n * n ) :
6 print ( i )
Programa 8.3: Ejemplo regla de la suma 2

Podemos ver que la función f que recibe como argumento a n. En esta función
existen dos ciclos independientes, el primero va desde 0 hasta n − 1, el segundo va
desde 0 hasta n2 − 1. Aplicando la regla de la suma tenemos que:

O(n) + O(n ∗ n) = O(n + n2 ) = O(n2 )

Podemos decir entonces que la complejidad del código 7.3, es O(n2 ), la cual es
polinomial.

Ejemplo regla del producto

Considera el siguiente fragmento de código:

1 def f ( n ) :
2 for i in range ( n ) :
3 for j in range ( n ) :
4 print (i , j )
Programa 8.4: Ejemplo regla del producto
 Introducción a la complejidad computacional 149

La función f recibe como argumento un valor n. Dentro de esta función hay dos
ciclos, de los cuales uno está anidado (es decir, el ciclo interno). Ambos van desde 0
hasta n − 1; sin embargo, el ciclo interno repite este proceso n veces.
Aplicando la regla de la multiplicación tenemos que:

O(n) ∗ O(n) = O(n ∗ n) = O(n2 )

Concluimos entonces que la complejidad de este programa es O(n2 ), es decir, tiene

una complejidad polinomial.

8.2.3. Complejidad exponencial y conclusiones del capítulo

Considera el siguiente fragmento de código:
1 def fibonacci ( n ) :
2 if n ==0 or n ==1:
3 return 1
4
5 return fibonacci (n -1) + fibonacci (n -2)
Programa 8.5: Ejemplo complejidad exponencial

En este ejemplo tenemos la función f ibonacci, la cual recibe como argumento a

n. Esta función realiza dos llamadas a sí misma, es decir, emplea una recursividad
múltiple. Es importante hacer notar que cada llamada genera dos llamadas más a la
función f ibonacci, por lo que la complejidad de este código es O(2n ). Si, por ejemplo,
hubiera tres llamadas recursivas, la complejidad sería O(3n ), pero, bueno, éste no es
el caso. Estamos hablando entonces de una complejidad exponencial, y este tipo de
algoritmos son los que debemos evitar para trabajar con valores de n grandes.
Retomando a los programas P1 y P2 del inicio del capítulo, podemos decir que
P1 tiene una complejidad constante, esto quiere decir que independientemente del
tamaño de n únicamente se ejecutarán a lo más un par de instrucciones. En el caso
de P2, podemos decir que tiene una complejidad lineal, ya que el ciclo que se encuentra
en dicho programa se ejecuta n veces.
En conclusión, P1 es más eficiente que P2, ya que una complejidad constante es
más rápida que una complejidad lineal, principalmente para valores de n muy grandes.

8.3. Bonus
Siempre que sea posible, se debe buscar la solución más rápida para resolver un
problema. Para este fin, te puedes guiar por la complejidad de los algoritmos.
Veamos cómo podemos pasar de una complejidad lineal a una complejidad cons-
tante mediante el siguiente ejercicio, el cual consiste en sumar los primeros n números
pares, empezando del 2.
Como primera aproximación para resolver este ejercicio se nos puede ocurrir una
implementación como la siguiente:
 150 Capítulo 8

1 def suma_pares ( n ) :
2 con =2
3 c =1
4 suma =0
5
6 while c <= n :
7 suma += con
8 con +=2
9 c +=1
10
11 return suma
12
13 n =100
14 print ( suma_pares ( n ) )
Programa 8.6: Suma pares 1
Este algoritmo tiene una complejidad lineal, la cual convertiremos en una comple-
jidad constante.
Partamos que la suma de los primeros n números naturales está definida por la
fórmula bien conocida (n ∗ (n + 1))/2.
Tomemos un valor de n pequeño, por ejemplo 3. Entonces la suma de los pares
sería de:
2 + 4 + 6 = 12
También podemos ver la expresión anterior como:
2(1 + 2 + 3) ⇒ 2(n(n + 1)/2) = n(n + 1)
Podemos decir que la suma de los pares está definida por la fórmula:
n(n + 1)
Entonces, la implementación queda de la siguiente manera:
1 def su m a _p a re s _ me j or a do ( n ) :
2 return n *( n +1)
3
4 n =100
5 print ( suma_pares ( n ) )
Programa 8.7: Suma pares 2

8.4. Ejercicios
1. Implementa una solución con complejidad constante para calcular la suma de n
números impares, partiendo de 1.
2. Implementa una solución con complejidad constante para calcular la suma de
los primeros n múltiplos de 4, partiendo de 4.
3. Investigar la complejidad del algoritmo de búsqueda binaria e implementarlo.
Capítulo 9

Ejercicios de programación
competitiva

9.1. Introducción
La palabra competitiva se lleva a un concepto de concurso, entonces, la programa-
ción competitiva es un deporte mental en donde los participantes deben de resolver
la mayor cantidad de problemas con ciertas especificaciones en un lapso determina-
do. Ganará aquel equipo que resuelva más problemas en menos tiempo. También se
evalúa, basándose en límites, el uso de la memoria y el tiempo de ejecución de un
programa.
¿Para qué me sirve la programación competitiva? Esta pregunta continúa sien-
do un debate abierto, pero entre las principales ventajas de realizar programación
competitiva están:

Amplio conocimiento de algoritmos y estructuras de datos, esencial para aplicar

a puestos de trabajo en Google, Facebook, Amazon o cualquier empresa grande
de tecnología.

Obtener conocimiento avanzado para nuestro ámbito con respecto a la reso-

lución y abstracción de problemas lo cual puede ser empleado en áreas como
inteligencia artificial, modelado matemático y simulación.

Obtener la habilidad de poder trabajar bajo presión y con límites de tiempo.

Generar redes de contactos para poder colaborar en proyectos futuros.

Vivir experiencias y viajes únicos por el país y por el mundo.

Disfrutar resolviendo problemas.

151
152 Capítulo 9

9.1.1. Anatomía de un problema

Un problema de un concurso de programación contiene normalmente los siguientes
elementos[5]
Enunciado del problema. Los problemas más sencillos se suelen escribir de forma
que engañen a los concursantes, aparentando ser difíciles, mediante la inclusión, por
ejemplo, de “información extra” para crear una distracción. Los concursantes deberán
ser capaces de filtrar los detalles sin importancia y centrarse en los esenciales.

Descripción de la entrada y la salida. En esta sección se proporcionan los deta-

lles del formato que tendrán los datos de entrada y del que deberán tener los de salida.

Ejemplos de entrada y salida. Los autores de los problemas suelen proporcionar

casos de prueba triviales a los concursantes. Los ejemplos de entrada y salida sirven
para verificar que los concursantes han entendido el problema en lo más básico y para
comprobar si el código es, al menos, capaz de procesar un caso mínimo, y proporcio-
nar la salida correcta en el formato indicado.

Pistas o notas al pie. En algunos casos, los autores del problema pueden incluir
pistas o notas al pie, para facilitar la comprensión del problema.

Los ejercicios que se presentan a continuación fueron tomados de la plataforma

OmegaUp1 y resueltos por el autor de este libro.

9.2. Dólares
Dentro de poco será Semana Santa y como vives en Coyoacán, sabes que habrá
muchos turistas pidiendo tu ayuda para ubicarse y para manejar dinero mexicano.
Como consideras que siempre es bueno practicar tu francés o inglés y eres buena
persona, decides ayudarlos y crear una aplicación que convierta dólares en pesos para
que no vayan a pagar de más –o de menos— en los museos y establecimientos.

Entrada
Un entero N que representa la cantidad en dólares y un entero K que representa el
tipo de cambio de dólares por pesos.

Salida
La equivalencia en pesos de los N dólares introducidos.

Ejemplos entrada
Caso 1
1
1
https://omegaup.com/
 Ejercicios de programación competitiva 153

13

Caso 2
54
12

Ejemplos salida
Caso 1
13

Caso 2
648

Restricciones
0 ≤ N ≤ 10000
0 ≤ K ≤ 100

Solución
Basta con multiplicar N ∗ K y esa será la solución.
1 N = int ( input () )
2 K = int ( input () )
3
4 equivalencia = N * K
5
6 print ( equivalencia )
Programa 9.1: Dólares

9.3. Escribir al revés

Pedirás una cadena de caracteres y la desplegarás al revés.

Entrada
cadena

Salida
cadena desplegada al revés

Ejemplo entrada
Pedro

Ejemplo salida
ordeP
 154 Capítulo 9

Solución
1 cadena = input ()
2
3 cad = cadena [ -1:: -1]
4 print ( cad )
Programa 9.2: Escribir al revés

9.4. El excursionista mayor

Los Falmos van de excursión, pero de todo el grupo de “humanitos”, el que tiene
la mayor edad es al que se le entregará el dinero para la compra del material de
campamento. Ayuda a mamá Falmo a saber quién es el que tiene la mayor edad.

Entrada
Preguntar cuántos van a ir de excursión y la edad de cada uno.

Salida
Mostrar solo la edad más grande.

Ejemplo entrada
5
15 16 5 13 12

Ejemplo salida
16

Límites
No especificado

Solución
Para esta solución se leen las edades, luego mediante un for, estas edades se
guardan como enteros en una lista llamada aux. Al salir del for, se utiliza la función
max para determinar el valor mayor de la lista aux.
1 n = int ( input () )
2 edades = input () . split ()
3
4 aux =[]
5 for edad in edades :
6 aux . append ( int ( edad ) )
7
8 print ( max ( aux ) )
Programa 9.3: El excursionista mayor
 Ejercicios de programación competitiva 155

9.5. Ordena a los alumnos

Los chicos de la escuela van a recibir un premio, pero tienen que estar formados
de la calificación mayor a la menor, ya que el profe Rayito quiere orden y dar el mejor
premio a la mejor calificación, y así sucesivamente.

Entrada
Primero hay que pedir la cantidad de alumnos y después las calificaciones

Salida
Mostrar las calificaciones ordenadas del mayor al menor

Ejemplo entrada
4
75 82 100 50

Ejemplo salida
100 82 75 50

Solución
Se leen las calificaciones de los alumnos, posteriormente mediante un for, estas
calificaciones se guardan como enteros en una lista llamada aux. En seguida, dicha
lista invoca al método sort (para ordenar los elementos de la lista) con el argumento
reverse=True, para ordenar los elementos de mayor a menor. Finalmente, en un
último for se imprimen los valores (ya ordenados de mayor a menor) de la lista aux.
1 cantidad_alumnos = int ( input () )
2 calificaciones = input () . split ()
3
4 aux =[]
5 for cal in calificaciones :
6 aux . append ( int ( cal ) )
7
8 aux . sort ( reverse = True )
9
10 for i in aux :
11 print (i , end = " " )
Programa 9.4: Ordena a los alumnos

9.6. 888
Directo al grano, tu trabajo es encontrar el N − esimo número cuyo cubo termina
en los dígitos 888.
 156 Capítulo 9

Entrada
Primero una línea con un número T la cantidad de casos de prueba. Las siguientes T
líneas contienen un entero N .

Salida
Para cada línea de entrada, una línea con el N − esimo número cuyo cubo termina
en 888.

Ejemplo entrada
1
1

Ejemplo salida
192

Límites
1 ≤ N ≤ 106

Solución
En primera instancia podemos pensar en hacer una búsqueda exhaustiva para
cada caso de prueba, desde 1 hasta el N − esimo número, el cual su cubo tiene una
terminación en 888. Sin embargo, dados los límites de N en este ejercicio esta solución
propuesta no es la adecuada.
Mediante una hoja de cálculo se puede ir visualizando aquellos números que cum-
plen con el requisito propuesto en el ejercicio. Posteriormente, analizar los patrones
que hay entre números elevados al cubo con terminación 888. A partir de este análisis
se puede llegar a un patrón o fórmula. En particular una fórmula encontrada para
resolver este ejercicio está definida de la siguiente manera:

formula=192+250*(N-1)

Se observó que cada 250 números a partir de 192 existe un número cuyo cubo
termina en 888.
Entonces el programa 9.5 resuelve el ejercicio de la siguiente forma:
Se lee el número T de casos de prueba, seguidamente en un while que va desde
1 hasta T se lee el valor de N , el cual se procesa en la fórmula y se guarda en una
lista. Al terminar el proceso en el while, en un for se van imprimiendo los valores
que hay almacenados en la lista.
1 T = int ( input () )
2

3 con =1
4 lista =[]
5 while con <= T :
6 N = int ( input () )
 Ejercicios de programación competitiva 157

7 formula =192+250*( N -1)

8 lista . append ( formula )
9 con +=1
10
11 for i in lista :
12 print ( i )
Programa 9.5: 888

9.7. La panza lanzadora

A Manolo le gustan mucho las competencias, pero desde que está en cuarentena
no ha podido hacer ninguna con sus amigos, por lo que se le ocurrió una gran idea:
El torneo de la panza lanzadora.
Consiste en lanzar una pluma, presionándola contra tu abdomen y dejando que
ésta salga expulsada, gana quien lance la pluma a mayor distancia. Pero sus amigos no
quieren quedarse únicamente con la satisfacción de ganar, quieren apostar. La persona
con mejor puntuación ganará un premio, mientras que la de menor puntuación será
el encargado de comprarlo (claramente en línea, ya que no puede salir de casa).
Confiando en que todos serán honestos, mandarán la distancia a la que lanzaron
la pluma y aquí es donde entras tú: debes ayudarlos a saber cuáles fueron la mayor y
la menor distancia en la que las plumas cayeron.

Entrada
La primera línea contendrá un n número de amigos (2 ≤ n ≤ 50).

La siguiente línea contiene n números enteros a1 , a2 , ..., an (0 ≤ ai ≤ 300) que repre-

sentarán la distancia en centímetros que recorrieron las plumas.

Salida
Dos enteros en una línea, la distancia menor y mayor.

Ejemplo entrada
5
4 2 6 10 3

Ejemplo salida
2 10

Solución
Primero se procede a leer las distancias, luego en la lista distancia_plumas me-
diante un for se almacenan convirtiendo a enteros dichas distancias. En seguida,
mediante las funciones max y min se obtiene la mayor y la menor distancia almace-
nada en la lista distancia_plumas. Finalmente, se imprimen la mayor y la menor
 158 Capítulo 9

distancia.
1 n = int ( input () )
2 lista = input () . split ()
3
4 distancia_plumas =[]
5 for i in lista :
6 distancia_plumas . append ( int ( i ) )
7
8 mayor = max ( distancia_plumas )
9 menor = min ( distancia_plumas )
10
11 print ( f " { menor } { mayor } " )
Programa 9.6: La panza lanzadora

9.8. Edades
En un salón de clases la maestra quiere saber cuántos alumnos hay con la misma
edad. Ayuda a la maestra a calcular la cantidad.

Entrada:
La primera línea contendrá un número n número de alumnos (1 ≤ n ≤ 50). Las
siguiente n entradas serán números enteros a1 , a2 , a3 , ..., an (1 ≤ ai ≤ 40), las edades
de los alumnos.

Salida
Imprime en orden ascendente por la edad y después la cantidad de alumnos corres-
pondiente.

Ejemplo entrada
6
12 12 8 6 9 8

Ejemplo salida
61
82
91
12 2

Solución
En este ejercicio se utiliza una lista y un diccionario para poder darle solución.
Primero se leen las edades de los alumnos. A continuación, se crea una lista y un
diccionario vacíos. Posteriormente, mediante un for se van analizando las edades una
por una, si una edad ya se encuentra en la lista claves entonces el diccionario (las
claves en el diccionario son las edades y los valores son las apariciones de cada edad)
 Ejercicios de programación competitiva 159

se incrementa en una unidad en la posición que tenga como clave dicha edad; en caso
contrario, la edad se agrega como clave al diccionario y se inicializa en 1, también se
agrega dicha edad en la lista claves. En seguida, se ordena la lista claves mediante
el método sort y finalmente, mediante un for se imprime la información contenida
en el diccionario (es decir, edad:apariciones) ordenadamente.
1 n = int ( input () )
2 lista = input () . split ()
3

4 claves =[]
5 diccionario ={}
6
7 for i in lista :
8 valor = int ( i )
9 if valor in claves :
10 diccionario [ valor ]= diccionario [ valor ]+1
11 else :
12 diccionario [ valor ]=1
13 claves . append ( valor )
14
15 claves . sort ()
16
17 for i in claves :
18 print ( f " { i } { diccionario [ i ]} " )
Programa 9.7: Edades

9.9. Cuenta letras al vector

Escribe un programa que lea una cadena (solo minúsculas, sin acentos, sin espa-
cios, sin la “ñ”) de máximo 1000. Y el programa nos dirá cuántas veces aparece cada
letra del alfabeto.

Entrada
Una cadena de caracteres del alfabeto en minúsculas, si acentos, sin espacios, sin la
“ñ” y entre 0 y 1000 caracteres.

Salida
La salida imprimirá, en la primera línea, una lista de números que indican el número
de veces que aparecen todas y cada una la letra del alfabeto (por orden alfabético).
Después se imprimirá una línea por cada una de las letras que sí aparecen en la cadena
(también por orden alfabético), de la siguiente forma: La letra x aparece n veces

Ejemplo entrada
Caso 1
programacion
 160 Capítulo 9

Caso 2
aaaaacccceeegghxxzzz

Ejemplo salida
Caso 1
20100010100011210200000000
La letra a aparece 2 veces
La letra c aparece 1 veces
La letra g aparece 1 veces
La letra i aparece 1 veces
La letra m aparece 1 veces
La letra n aparece 1 veces
La letra o aparece 2 veces
La letra p aparece 1 veces
La letra r aparece 2 veces

Caso 2
50403021000000000000000203
La letra a aparece 5 veces
La letra c aparece 4 veces
La letra e aparece 3 veces
La letra g aparece 2 veces
La letra h aparece 1 veces
La letra x aparece 2 veces
La letra z aparece 3 veces

Solución
Para resolver este ejercicio se necesita hacer uso de un diccionario, el cual tendrá
como clave las letras del abecedario y como valor inicial 0. Posteriormente, se procede
a leer la cadena que se quiere analizar.
En un primer for (que va desde el primer hasta el último carácter de la cadena
leída), se va contando mediante el método count las veces que aparece cada carácter
en la cadena; a su vez, este conteo se almacena en el diccionario en su correspondiente
clave. En seguida, en otro for se imprimen los valores del diccionario, que son las
veces que apareció cada letra del abecedario en la cadena leída. Finalmente, en un
último for se van imprimiendo solo las letras del abecedario que tuvieron por lo
menos una ocurrencia en la cadena introducida al inicio.
1 diccionario ={ ’a ’:0 , ’b ’:0 , ’c ’:0 , ’d ’:0 , ’e ’:0 , ’f ’:0 ,
2 ’g ’:0 , ’h ’:0 , ’i ’:0 , ’j ’:0 , ’k ’:0 , ’l ’:0 ,
3 ’m ’:0 , ’n ’:0 , ’o ’:0 , ’p ’:0 , ’q ’:0 , ’r ’:0 ,
4 ’s ’:0 , ’t ’:0 , ’u ’:0 , ’v ’:0 , ’w ’:0 , ’x ’:0 ,
5 ’y ’:0 , ’z ’ :0}
6
7 cadena = input ()
 Ejercicios de programación competitiva 161

8
9 for i in cadena :
10 diccionario [ i ]= cadena . count ( i )
11
12 for i in diccionario :
13 print ( diccionario [ i ] , end = " " )
14
15 print ()
16
17 for i in diccionario :
18 if diccionario [ i ]!=0:
19 print ( f " La letra { i } aparece { diccionario [ i ]} veces " )
Programa 9.8: Cuenta letras vector

9.10. Acomodando zapatillas

Ayla es una niña que tiene demasiadas zapatillas y un día decidió acomodarlas.
Mientras las acomodaba se dio cuenta de que tenía un desorden y así que decidió
reordenarlas y tirar a la basura todas las zapatillas que se habían quedado solas. Ayla
tiene un montón de zapateros en donde tiene una infinidad de zapatillas.

Problema:
Realiza un programa que dadas la cantidad de zapatillas que tenía y un identificador
de cada zapatilla, diga de cuántas zapatillas se puede deshacer Ayla, es decir, todas
las que han perdido su par. Dos zapatillas son del mismo par si tienen el mismo iden-
tificador.

Entrada
En la primera línea, un número N con la cantidad de zapatillas que tiene Ayla. En la
segunda línea, K números, el identificador de cada una de las zapatillas.

Salida
En la primera línea los identificadores de las zapatillas que puede tirar, en la segunda
línea la cantidad de zapatillas que puede tirar y en la tercera línea la cantidad de
zapatillas que Ayla se quedará. En caso de que Ayla haya encontrado todos los pares
de las zapatillas debes imprimir :D en lugar de los identificadores.

Ejemplo entrada
Caso 1
10
2 4 3 2 2 3 5 5 8 10

Caso 2
8
 162 Capítulo 9

44 33 12 44 33 12 20 20

Ejemplo salida
Caso 1
2 4 8 10
4
6

Caso 2
:D
0
8

Límites
Ninguna zapatilla tendrá un identificador mayor a 106
Todas las zapatillas para Ayla son iguales tanto la izquierda como la derecha
Ayla no tiene más de 1000 zapatillas
Solución
Una vez leídos los identificadores de las zapatillas, se crea un diccionario y una
lista vacíos. Posteriormente, mediante un for se va verificando si cada identificador
de zapatilla se encuentra en el diccionario (dichos identificadores son las claves del
diccionario y los valores son contadores que van contabilizando las apariciones de
cada identificador), en caso de que se encuentre un identificador de zapatilla en el
diccionario entonces se incrementa su contador (su valor en el diccionario); si no
se encuentra, entonces se agrega el identificador al diccionario y a una lista llamada
lista2. En seguida, se ordena la lista2 mediante el método sort. A continuación, en
un for que recorre la lista2 se va verificando si el valor de cada clave (el identificador
de zapatilla) del diccionario es impar, lo cual significa que la zapatilla no tiene su
pareja; por lo que se imprime dicho identificador y se contabiliza. Finalmente, se
imprime el contador con (representa la cantidad de zapatillas que no tienen pareja)
y el número de zapatillas que tienen su par.
1 n = int ( input () )
2 lista = input () . split ()
3
4 diccionario ={}
5 lista2 =[]
6 for i in lista :
7 valor = int ( i )
8 if valor in diccionario . keys () :
9 diccionario [ valor ]= diccionario [ valor ]+1
10 else :
11 diccionario [ valor ]=1
12 lista2 . append ( valor )
 Ejercicios de programación competitiva 163

13
14 lista2 . sort ()
15 con =0
16 for i in lista2 :
17 if diccionario [ i ] %2!=0:
18 print (i , end = " " )
19 con +=1
20

21 if con ==0:
22 print ( " : D " )
23 else :
24 print ()
25 print ( con )
26 print (n - con )
Programa 9.9: Acomodando zapatillas

9.11. Un anagrama sencillo

Un anagrama es una palabra o frase que resulta de la transposición de letras de
otra palabra o frase. Dicho de otra forma, una palabra es anagrama de otra si las
dos tienen las mismas letras, con el mismo número de apariciones, pero en un orden
diferente.
Escribe un programa que lea dos palabras en minúsculas y que determine si las
palabras tienen la misma longitud, si no tuvieran la misma longitud, cancelar el pro-
grama, de lo contrario, determinar si las palabras son anagrama una de otra.

Entrada
La primera línea de entrada contendrá la primera palabra (solo minúsculas, del alfa-
beto inglés (sin ñ) y a lo mucho contendrá 1000 letras). La segunda línea contendrá la
segunda palabra (solo minúsculas, del alfabeto inglés (sin ñ) y a lo mucho contendrá
1000 letras).

Ejemplos entrada
Caso 1
imperdonablemente
imponderablemente

Caso 2
bulliciosamente
escabullimiento

Caso 3
roca
coro
 164 Capítulo 9

Caso 4
enfriamiento
refinamientos

Ejemplos salida
Caso 1
SI es un ANAGRAMA!

Caso 2
SI es un ANAGRAMA!

Caso 3
NO es un Anagrama!

Caso 4
Las cadenas tienen longitud diferente.
Operacion Cancelada!

Solución
Se leen las dos cadenas por analizar y se compara la longitud de ambas (función
len), si las cadenas no tienen la misma longitud, entonces se manda el mensaje
“Operación cancelada”. De lo contrario, si las cadenas tienen la misma longitud, se
procede a analizarlas. Primero se crea una variable llamada ban (bandera) con el
valor de 0. Posteriormente, mediante un for que recorre cada carácter de la primera
cadena (cadena1) se va contando mediante el método count, el número de veces
que aparece el carácter en ambas cadenas. Si el número de apariciones del carácter
es diferente en ambas cadenas entonces, se establece ban=1 y se sale del ciclo con
el break. Finalmente, fuera del for se valida si la variable ban es igual a 0, lo que
significa que se recorrieron todos los caracteres de la cadena sin ningún problema,
y por lo tanto sí es un anagrama; por el contrario, si la variable ban es igual a 1,
entonces se concluye que no es un anagrama.
1 cadena1 = input ()
2 cadena2 = input ()
3

4 if len ( cadena1 ) != len ( cadena2 ) :

5 print ( " Las cadenas tienen longitud diferente . \ nOperacion
Cancelada ! " )
6 else :
7 ban =0
8 for caracter in cadena1 :
9 a = cadena2 . count ( caracter )
10 b = cadena1 . count ( caracter )
11 if a != b :
12 ban =1
 Ejercicios de programación competitiva 165

13 break
14

15 if ban ==0:
16 print ( " SI es un ANAGRAMA ! " )
17 else :
18 print ( " NO es un Anagrama ! " )
Programa 9.10: Anagrama sencillo

9.12. Problemas propuestos

9.12.1. Cuántas mayúsculas y minúsculas

Crear un programa que te diga cuántas letras mayúsculas y cuántas minúsculas
contiene una palabra.

Entrada
Una palabra.

Salida
En una primer línea el número de caracteres mayúsculas. En otra línea el número de
caracteres minúsculas.

Ejemplos entrada
Caso 1
Juan

Caso 2
CucHillo

Ejemplos salida
Caso 1
1
3

Caso 2
2
6

Límites
Podrías limitar las palabras a 30 caracteres
166 Capítulo 9

9.12.2. Regalos de Rodrigo

Rodrigo se encuentra en su fiesta de cumpleaños y sus padres invitaron N amigos
a su fiesta, cada uno de sus amigos le lleva X número de regalos, sus padres como son
muy organizados te pidieron ayuda para que programes un algoritmo que les ayude a
saber si todos los regalos llevados sumados es igual a la cantidad que llevo el último
invitado.

Entrada
En la primera línea N amigos que asisten a la fiesta seguido de número de regalos
que estos le han llevado.

Salida
En caso de que la cantidad de regalos sea equivalente a la suma del resto de números
de todos los regalos se deberá visualizar por pantalla un 1, en caso contrario mostrar
-1.

Ejemplos entrada
Caso 1
5
1 2 3 4 10

Caso 2
5
4 1 2 3 11

Ejemplos salida
Caso 1
1

Caso 2
-1

9.12.3. Crucigrama
Por semanas has estado resolviendo crucigramas. Ahora quieres ganar un poco de
dinero vendiéndole crucigramas a los periódicos diarios de la región. Como no quieres
perder tiempo haciéndolos a mano, vas a escribir un programa que los genere. Al
programa le das 2 palabras: palabra A y palabra B. La palabra A la debe escribir
horizontalmente, y la palabra B la debe escribir verticalmente; de tal manera que las
palabras se puedan cruzar; esto es deben compartir exactamente una letra. La letra
compartida debe ser la primera letra en A que aparece en B, mas preciso: debe ser la
primera ocurrencia de la letra, en ambas palabras. Por ejemplo: dadas las palabras A
= “ABBA” y B = “CCBBD”, el programa debe generar, en este caso, las 5 líneas que
 Ejercicios de programación competitiva 167

se muestran en el ejemplo mas abajo.

Entrada
La primera y única línea de entrada contiene dos palabras: A y B; de no mas de 30
letras cada una, separadas por un solo espacio. Ambas palabras están escritas con
letras mayúsculas del alfabeto español. En todos los casos habrá, al menos, una letra
común en ambas palabras.

Salida
Si la longitud de la palabra A es N, y la longitud de la palabra B es M. La salida deben
ser M líneas con N caracteres cada linea. La figura que se forme con la salida debe
contener a las 2 palabras cruzadas, como se describe en la explicación del problema
(por eso se llama crucigrama). El resto de los caracteres, en cada línea, deben ser
puntos (el carácter punto).

Ejemplo entrada
ABBA CCBBD

Ejemplo salida
.C..
.C..
ABBA
.B..
.D..

Límites
1 ≤ longituddeA ≤ 30
1 ≤ longituddeB ≤ 30

9.12.4. A pares y nones

Existe un juego de cartas muy divertido: dos amigos se sientan junto a un mazo
de cartas con números anotados y el primer jugador que logre agarrar la carta de
hasta arriba, se la queda. El proceso se repite hasta que se acaban las cartas del
mazo y después cada jugador suma los números que están anotados en sus cartas y
calcula su puntaje promedio (como entero). Gana el jugador cuyo puntaje promedio
sea el más grande. Aparicio y Nonila se disponen a jugar este mismo juego, pero por
alguna razón Aparicio buscará agarrar las cartas que tengan anotados números pares
y Nonila buscará agarrar las cartas que tengan anotados números impares. Escribe
un programa que determine quién ganará el juego.

Entrada
Un entero N seguido de los números anotados en las N cartas. Puedes suponer que
168 Capítulo 9

tanto N como los números anotados están en el rango de 1 a 10,000.

Salida
El nombre del jugador ganador (en mayúsculas) o la cadena EMPATE! en caso de
empate.

Ejemplos entrada
Caso 1
5
10 4 8 1 9

Caso 2
5
10 4 2 3 9

Caso 3
3
15 10 5

Ejemplos salida
Caso 1
APARICIO

Caso 2
NONILA

Caso 3
EMPATE!

9.12.5. Encuentra el tesoro

Pyke es un pirata muy desconfiado y posee mucho dinero, por lo cual el decidió
crear varias matrices de 3*3 en diferentes islas,el problema es que no recuerda en cual
matriz lo guardo, ayuda lo a ver si en la isla que esta es la correcta y encuentre su
tesoro.

Entrada
Siempre sera una solo matriz de 3*3, debes revisar si su diagonal principal y secun-
daria son iguales.

Salida Si esto es verdad imprimir “Tesoro encontrado” y si es falso imprimir “Sigue

buscando”.
 Ejercicios de programación competitiva 169

Ejemplos entrada
Caso 1
123
245
678

Caso 2
111
111
111

Caso 3
323
739
363

Ejemplos salida
Caso 1
Sigue buscando

Caso 2
Tesoro encontrado

Caso 3
Tesoro encontrado

Límites
0 ≤ x ≤ 1000
170 Capítulo 9
Bibliografía

[1] J. S. Caula. Los 100 mejores juegos de ingenio. Paidós, 1 edition, 2015.

[2] F. J. Pinales and C. E. Velázquez. Problemario de algoritmos resueltos con diagra-

mas de flujo y pseudocódigo. Departamento Editorial de la Universidad Autónoma
de Aguascalientes, 1 edition, 2014.

[3] O.D.C. Villagómez, D.B. López, A.A. Silva, and E.C. Juárez. Python con aplica-
ciones a las matemáticas, ingeniería y finanzas. Alfaomega, 1 edition, 2017.

[4] Á.P.H. Gutiérrez. Python Paso a paso. RA-MA, 2016.

[5] S. Halim and Halim F. Programación competitiva Manual para concursantes del
ICPC y la IOI. OJBooks, 1 edition, 2019.

171
Índice alfabético

←→, 9 and, 56, 57

−→, 8 análisis de algoritmos, 139
q, 9 Argumento, 5
∨, 8 argumento, 134
∧, 7, 128 aritmética, 27
” ’, 58
(), 57, 116 bilbiotecas, 66
*, 55, 57 binaria, 10
**, 55, 57
*=, 56 cadena, 101
+, 55, 57 Características de los algoritmos
+=, 56 definido, 41
-, 55, 57, 128 finito, 41
-=, 56 preciso, 41
/, 55, 57 ciclos anidados, 97
//, 55, 57 circuito digital, 10
/=, 56 circuitos eléctricos
:, 120 conjunción, 11
<, 56, 57 disyunción, 11
<=, 56, 57 clave, 119, 120
=, 56 clear, 124
==, 56, 57, 127 colecciones, 101
>, 56, 57 comentario, 54
>=, 56, 57 Comentarios, 58
[], 109 complejidad, 141
#, 54, 58 complejidad asintótica, 142
%, 57 completar valores, 18
%=, 56 computadora, 45, 62
&, 128 Conclusión, 6
{}, 120, 124 Conjunto, 21
“ ‘, 58 infinito, 23
unitario, 23
acertijos, 15 universo, 22
adición, 27 vacío, 22
algoritmo, 41, 54, 62 Conjuntos
anagrama, 159 disjuntos, 23

172
 ÍNDICE ALFABÉTICO 173

iguales, 23 int, 64
conjuntos, 124 intersección, 128
constante, 42 Intratable, 143
constantes, 42, 61
conteo de figuras, 17 Jerarquía de operadores, 57
cos, 66 keywords, 58
def, 131 len, 110, 118, 123, 127
Desde, hasta que, 85 lenguaje multiplataforma, 46
Diagramas de Venn, 21 letras en desorden, 18
diccionarios, 119 list, 118
diferencia, 128 listas, 108
diferencia simétrica, 128 Los números enteros, 30
división, 27 Los números naturales, 27
Lógica, 5
editor de texto, 47
lógica proposicional, 6
Elemento, 22
Elementos de la lógica proposicional math, 66, 68
Auxiliares, 6 Mientras que, 85
Conectores, 6 multiplicación, 27
Variables, 6 máximo común divisor, 38
Enunciado, 5 Método
estructuras secuenciales, 62 add, 125
estructuras selectivas, 73 append, 111
clear, 114, 126
Falso, 43
count, 105, 113, 118
Fibonacci, 94, 145
discard, 125
float, 66
endswith, 107
for, 87
extend, 111
funciones recursivas, 136
find, 105
función, 131
get, 122
habilidad index, 112
lógico matemática, 14 insert, 111
pensamiento, 5 islower, 106
join, 108
identificadores, 42 lower, 104
if, 74 pop, 113
if-elif-else, 79 remove, 114
if-else, 75 replace, 108
in, 112, 117, 123, 126 reverse, 115
Inferencia, 5, 6 sort, 115
input, 54, 63 split, 107
Instalar Python, 48 startswith, 106
InstalarPyCharm, 49 upper, 104
174 ÍNDICE ALFABÉTICO

values, 123 range, 88

método issubset, 129 recta, 27, 31
mínimo común múltiplo, 36 regla de la suma, 143
regla del producto, 144
Negación, 9 resolución de problema, 41
not, 56, 57 return, 133
not in, 126
notación asintótica, 142 salida, 64
número primo, 95 selectiva compuesta, 74
selectiva simple, 73
O Grande, 142 set, 124
Operaciones sistemas operativos, 46
entrada, 45 slicing, 102, 109, 117
salida, 45 software libre, 46
Operaciones con conjuntos Subconjunto, 22
complemento, 25 sudoku, 16
diferencia, 25 sustracción, 27
intersección, 24
unión, 23 Tablas de verdad
operadores, 55 Bicondicional, 8
aritméticos, 55 Condicional, 8
asignación, 56 Conjunción, 7
lógicos, 56 Disyunción, 8
Teoría de conjuntos, 21
relacionales, 55
Tipos de inferencia
or, 56, 57
deductiva, 7
palabras reservadas, 58 inductiva, 7
Partes de un algoritmos inmediata, 6
entrada, 42 mediata, 7
proceso, 42 Tipos de variables, 43
salida, 42 entero, 43
parámetro, 134 lógica, 43
Paso por referencia, 135 real, 43
Paso por valor, 135 string, 43
pi, 66, 68 Tratable, 143
Premisa, 6 tuplas, 116
print, 54, 64 tuple, 119
proceso, 62 unión, 127
programación competitiva, 147
Proposición, 5 valor, 119, 120
prueba de escritorio, 46 valor absoluto, 32
pseudocódigo, 45 variable, 43
PyCharm, 47 variables, 42, 61
Python, 46, 61 variables en Python, 54
 ÍNDICE ALFABÉTICO 175

bool, 54
float, 54
int, 54
str, 54
Verdadero, 43

while, 86

zen de Python, 46

índices, 101, 109