Programacion en Python

Introducción a la Programación en Python
SONIA JARAMILLO VALBUENA

SERGIO AUGUSTO CARDONA TORRES
ROBINSON PULGARÍN GIRALDO
Profesores adscritos al
Programa de Ingeniería de Sistemas y Computación
Facultad de Ingeniería
Universidad del Quindío
Armenia 2019
SONIA JARAMILLO VALBUENA

SERGIO AUGUSTO CARDONA TORRES
ROBINSON PULGARÍN GIRALDO
No está permitida la reproducción total o parcial de este libro, ni su

Tratamiento informático, ni la transmisión de ninguna forma o por
cualquier medio, ya sea electrónico, mecánico, por fotocopia, por
registro u otros métodos, sin el permiso previo y por escrito de los
Autores del copyright
Derechos Reservados
Armenia - Quindío
Primera edición, diciembre de 2019
ISBN
978-958-8801-95-7
Elizcom
NIT 18497593-4
Armenia, Quindío – Colombia
Tel. 7369378
TABLA DE CONTENIDO
CAPÍTULO 1 ........................................................................................................... 15
FUNDAMENTOS DEL LENGUAJE .................................................................... 15
Objetivos: ................................................................................................................. 15
1.1 Dato.............................................................................................................. 11
1.1.1 Tipos de datos.................................................................................. 11
1.2 Identificadores ............................................................................................ 16

1.3 Palabras reservadas ................................................................................... 18
1.4 Variables...................................................................................................... 19
1.5 Operadores ................................................................................................. 21
1.5.1 Operadores matemáticos ............................................................... 21
1.5.2 Operadores relacionales ................................................................. 22
1.5.3 Operadores lógicos ......................................................................... 23
1.6 Expresiones ................................................................................................. 24
1.6.1 Expresión matemática .................................................................... 24

1.6.2 Expresión relacional ....................................................................... 29
1.6.3 Expresión lógica .............................................................................. 30
1.6.4 Expresión de asignación ................................................................ 31
1.7 Comentarios................................................................................................ 34
1.8 Entrada y salida de datos.......................................................................... 34
1.8.1 Función print( ) ................................................................................ 34

1.8.2 Función input( ) ............................................................................... 39
1.9 Primeros programas .................................................................................. 42

CAPÍTULO 2 ........................................................................................................... 50
2 FUNCIONES ................................................................................................... 50
2.1 Funciones propias de Python ................................................................... 51
2.2 Funciones definidas por el usuario o programador ............................. 63
2.3 Funciones lambda ...................................................................................... 83

2.4 Módulos ...................................................................................................... 86
CAPÍTULO 3 ........................................................................................................... 90
3 ESTRUCTURA DE DECISIÓN..................................................................... 90
3.1.1 if sin else ........................................................................................... 97

3.1.2 Decisiones anidadas ..................................................................... 100
3.1.3 Instrucción elif................................................................................ 106

CAPÍTULO 4 ......................................................................................................... 119
4 ESTRUCTURAS DE REPETICIÓN ............................................................ 119
4.1 Instrucción while ....................................................................................... 120

4.1.1 Validación de datos de entrada .................................................. 136
4.2 Instrucción for ........................................................................................... 145

CAPÍTULO 5 ......................................................................................................... 160
5 COLECCIONES ............................................................................................ 160

5.1 Tupla .......................................................................................................... 161
5.1.1 Impresión de una tupla ................................................................ 162
5.1.2 Funciones y métodos para tuplas ............................................... 166
5.1.3 Desempaquetado de tuplas ......................................................... 170

5.1.4 Múltiples valores de retorno ....................................................... 171
5.1.5 Uso del ciclo for ............................................................................. 175
5.2 Listas .......................................................................................................... 182

5.2.1 Impresión de una lista .................................................................. 183
5.2.2 Modificación de un item ............................................................... 184

5.2.3 Mezcla de listas ............................................................................. 184
5.2.4 Usando índices para acceder a los ítems ................................... 186
5.2.5 Funciones y métodos usados en listas ....................................... 187

5.3 Listas en dos dimensiones ...................................................................... 208
5.3.1 Lectura de ítems de una lista de dos dimensiones ................... 211
5.3.2 Impresión en forma de matriz para una lista de dos dimensiones
215
5.4 Diccionarios .............................................................................................. 239
5.4.1 Impresión de los elementos de un diccionario ......................... 240

5.4.2 Anexando datos al diccionario.................................................... 245
5.4.3 Modificando el valor asociado a una clave ............................... 246
5.4.4 Funciones y métodos para diccionarios..................................... 246
5.4.5 Usando el ciclo for con diccionarios ........................................... 249

PRESENTACIÓN
Python es un lenguaje de programación que se disputa los primeros lugares de

popularidad al lado de Lenguaje C, Java y C++. Fue creado por el holandés Guido van
Rossum, a comienzos de los años 90. Para el desarrollo de los programas de esta obra,
se hizo uso de Python 3.
Debido a la importancia y versatilidad de este lenguaje, fue que se escribió

Introducción a la Programación en Python. Este libro está diseñado para aquellas
personas que quieren incursionar en el mundo de la programación de una manera
fácil y con una guía que los oriente paso a paso en los aspectos básicos de
programación, siguiendo el paradigma de programación estructurada.
Para el entendimiento de esta obra, no se requieren conocimientos previos en

programación. Al finalizar su estudio, el lector estará preparado para abordar otros
niveles de este lenguaje, así como también, iniciar con otros lenguajes de
programación.
Cada capítulo inicia con los conceptos básicos del tema a tratar, acompañados de
varios ejemplos que permiten comprender mejor y afianzar la teoría estudiada, de
igual manera, se introducen actividades que deben ser desarrolladas por el lector.
Algo importante a tener en cuenta es que, cada ejemplo tiene una amplia explicación
que hace más fácil el entendimiento de la lógica aplicada. Así mismo, su desarrollo se
hace de una manera progresiva, donde algunos ejemplos son una versión mejorada
de la anterior, esto con el propósito de que el lector analice como se van
incorporando nuevos conceptos para lograr mejores funcionalidades.
El texto está organizado en cinco capítulos, que corresponden a los contenidos que
se desarrollan en los cursos iniciales de programación del Programa de Ingeniería de
Sistemas y Computación de la Universidad del Quindío. Cada uno de los cuales
estudia lo siguiente:
Capítulo 1 – Fundamentos del lenguaje. En este capítulo se abordan las

generalidades del lenguaje y se estudian temas tales como: datos, identificadores,
palabras reservadas, operadores, expresiones, instrucciones de entrada y salida y se

desarrollan los primeros programas.
Capítulo 2 – Funciones. Se busca introducir al lector, desde sus inicios en

programación en el uso de funciones tanto del lenguaje como de programador.
Inicialmente se abordan funciones para el manejo de cadenas y operaciones
matemáticas; luego se explica el uso y construcción de funciones propias del
programador con y sin retorno. El capítulo termina con las funciones lambda y el
tema sobre módulos.
Capítulo 3 – Estructura de decisión. Este es uno de los temas que no pueden faltar
en el estudio de la programación. Se estudia las diferentes formas que se presentan
en el lenguaje, como la tradicional decisión simple, la decisión anidada y el uso de if-
elif.
Capítulo 4 – Estructuras repetitivas. En este capítulo se aborda el ciclo while y el ciclo

for. Se utilizan en diferentes programas que, requieren repetir procesos para lograr
la solución de algún tipo de problema. Con el ciclo while se explica, entre otros temas,
como validar la entrada de un dato y así evitar posibles errores o resultados
equivocados. Con el ciclo for se estudia su forma más sencilla de iterar ya que, el uso
de elementos iteradores se deja para el capítulo 5.
Capítulo 5 – Colecciones. En este capítulo se estudiarán las tuplas, las listas y los
diccionarios, elementos que fueron definidos de manera parcial en el capítulo uno.
Estos tipos de datos nos permitirán manejar la información de una manera más
ordenada. El tema inicia con las tuplas, luego continúa con las listas en 1 y 2
dimensiones, finalizando con el estudio de los diccionarios.
Por último, es de resaltar que, los programas fueron construidos abordando las
buenas prácticas de programación. Entre las cuales se destacan: uso de funciones de
usuario o programador en la mayoría de los ejemplos, en las cuales se estableció un
único retorno; para las variables y demás identificadores se usaron nombres
nemotécnicos que facilitan el entendimiento del código.
14
CAPÍTULO 1
FUNDAMENTOS DEL
LENGUAJE
Objetivos:
 Comprender los fundamentos del lenguaje para utilizarlo

adecuadamente.
 Conocer los operadores que proporciona el lenguaje para la
construcción de diferente tipo de expresiones
 Evaluar expresiones de acuerdo a la precedencia de operación.
 Conocer instrucciones básicas del lenguaje para construir los primeros
programas.
Fundamentos del lenguaje
Python es un lenguaje de programación que se disputa los primeros lugares de

popularidad al lado de Lenguaje C, Java y C++. Fue creado por el holandés Guido van
Rossum, a comienzos de los años 90. El nombre de Python se debe al homenaje que
su autor le hizo a un grupo humorista Monty Python.
Las características que hacen de Python un lenguaje popular y muy utilizado son las
siguientes:
 Es un lenguaje de alto nivel, es decir, que trata de parecerse a un lenguaje natural.

 Es multiparadigma. Se pueden trabajar diferentes paradigmas o estilos de
programación. Por ejemplo, programación orientada a objetos, imperativa y
funcional. Sin embargo, Python es orientado a objetos, todos los datos son
tratados como objetos.
 Es versátil. Al ser un lenguaje de propósito general se pueden programar desde
soluciones sencillas, aplicaciones de escritorio y aplicaciones web hasta
aplicaciones para inteligencia artificial y ciencia de datos.
 Es multiplataforma. Los programas creados en Python pueden ser ejecutados o
interpretados en cualquier sistema operativo.
 Es un lenguaje simple y minimalista, lo cual lo hace fácil para entender y
aprender. Por ejemplo, no usa el carácter de punto y coma para terminar sus
líneas de instrucciones, ni tampoco es necesario declarar variables.
 Es de tipado fuerte y dinámico. Un tipado fuerte permite diferenciar muy bien el
tipo de dato de una variable. Con el tipado dinámico, se puede establecer el tipo
de dato de una variable en el momento de ejecución.
 Está en continuo desarrollo. Cuenta con una comunidad de programadores
(www.python.org). Gracias a esto, Python tiene una librería bastante amplia que
permite realizar diferentes tareas de forma sencilla.
 Es un lenguaje interpretado. Los programas se ejecutan instrucción por
instrucción mediante un intérprete.
A continuación, se estudiarán los elementos básicos que hacen parte de este

lenguaje.
10
1.1 Dato
Es una pieza de información, mediante la cual se hace la representación simbólica de

una cualidad de un elemento u objeto. Tal es el caso de un número, letra, palabra o
frase que hagan referencia a una característica de algo. Por ejemplo, 2020, negro y
Chevrolet podrían ser características o datos de un vehículo que es modelo 2020, de
color negro y marca Chevrolet.
Analizando el anterior ejemplo, si a usted le dan el dato 2020 o negro de forma

independiente y sin ubicarlos en un contexto específico, esos datos por sí solos no
representarían ninguna información útil. 2020 podría ser el año de una fecha, así
como también, negro podría ser el color de un caballo.
Así las cosas, se debe tener presente que la información está compuesta por un
conjunto de datos agrupados y ubicados dentro de un contexto.
Los computadores o dispositivos de procesamiento reciben datos de entrada, luego

los procesan para organizarlos en salidas de información útil para los usuarios.
1.1.1 Tipos de datos
Los tipos de datos permiten clasificar los datos de una manera adecuada para su
manejo; además le indican al computador o al dispositivo de procesamiento cuánta
11
memoria debe reservar, ya que el tamaño en bits de cada uno de ellos es diferente.
Python maneja los siguientes tipos de datos:
 Numéricos
 int (enteros)
 float (reales)
 complex (Complejos)
 Boolean
 bool (Booleano)
 Secuencias
 str (String)
 tuple (Tuplas)
 list (Listas)
 Diccionarios
 dict
NUMÉRICOS
Son aquellos datos con los cuales se pueden realizar operaciones de tipo matemático.
Están compuestos por la combinación de los números del 0 al 9, el carácter punto (.)
para separar los decimales y el signo + o – que se usan para indicar si el número es
positivo o negativo. En el caso de los números positivos no se requiere el empleo del
signo +.
Los datos numéricos a su vez se subdividen en: enteros, reales y complejos.
Numérico entero. Un número entero es de tipo int. En esta categoría se encuentran

los números positivos o negativos que no tienen parte fraccional (decimal). Por
ejemplo: 4, -20, 2020, 1650045. Observe que no se usa ni punto ni coma para separar
las unidades de mil.
Numérico real. Un número real es de tipo float, también son conocidos como
números de punto flotante. Ellos están compuestos por números positivos o
negativos que contienen parte entera y fraccional (decimal) los cuales se separan
12
mediante un punto. Por ejemplo: 4.0, -20.56, 16.456. Observe que este último valor,
no es el número Dieciséis mil cuatrocientos cincuenta y seis, sino el número entero
16 con una parte fraccional o decimal de 456.
Número complejo. Un número complejo es de tipo complex. Son aquellos que están
compuestos por una parte real y otra imaginaria. Son una extensión de los float. Por
ejemplo: -2+3.3j, 7.7+3j. Observe que para su representación se usa la letra j y no la
letra i como se acostumbra en las matemáticas.
Este tipo de dato es poco común en otros lenguajes de programación. Son muy
usados para cálculos científicos o de ingeniería.
bool - BOOLEAN.
Los datos booleanos, también llamados lógicos solo permiten uno de dos valores:
False o True (Falso o Verdadero en español).
str - STRING.
Comúnmente se le conocen como datos de tipo cadena. Son de tipo str. Están
representados por todas las letras, números, el espacio en blanco y los caracteres
especiales. Una cadena se identifica porque los caracteres están encerrados entre
comillas. Por ejemplo: "Gato", "Calle 78 Norte 15-451", "Juan Pablo Correa Guzmán",
"74454548".
Diferente a Lenguaje C y a otros lenguajes, los datos string, en Python, también

pueden ir entre comillas simples.
'Gato', 'Calle 78 Norte 15-451', 'Juan Pablo Correa Guzmán', '74454548'.
Como buena práctica de programación se aconseja que, dentro de un mismo

programa se utilice solo una de las dos formas, es decir, todo con comillas dobles o
todo con comillas sencillas.
13
SECUENCIAS
Una secuencia es un contenedor de cero o varios objetos ordenados que, pueden ser
de diferentes tipos de datos y fácilmente accedidos utilizando la posición que ocupen
dentro de ella. Las secuencias que están presenten en Python son las tuplas y listas.
Por el momento solo se van a definir, posteriormente se abordarán con más detalle.
Listas. Una lista es de tipo list. Al estar dentro de la categoría de secuencias, se define
como un contenedor de objetos que pueden ser modificables. Los objetos que hacen
parte de la lista pueden ser todos del mismo tipo o una combinación de ellos. Una
lista se identifica porque sus elementos están encerrados entre corchetes [ ]. Por
ejemplo:
Lista vacía:
[]
Listas con un solo objeto o elemento:
[2018]
["Luna"]
Lista con varios elementos numéricos de tipo entero:
[10, 12, -20]
Las listas también pueden estar compuesta por elementos de diferente tipo de dato:
[1.5, "Niña", 17, -3, "Luna", "Benji"]
Una lista puede contener otra lista:
["Benji", [2014, "Canela", 12]]
14
Tupla. Una tupla es de tipo tuple. Es similar a una lista, con la diferencia que sus
objetos no son modificables. Los objetos que hacer parte de la lista pueden ser del
mismo tipo o de una combinación de ellos. Una lista se identifica porque sus
elementos están encerrados entre paréntesis ( ), aunque también pueden omitirse.
Por ejemplo:
Tupla vacía:
()
Tuplas con un solo objeto o elemento:
(2018, )
("Luna", )
A diferencia de las listas, las tuplas de un solo elemento deben ir acompañadas de

una coma (,) después del único elemento presente. Si se dejara sin la coma, el tipo
de dato ya sería diferente:
(2018) sin la coma, sería de tipo int.
("Luna") sin la coma, sería de tipo str.
Tupla con varios elementos numéricos de tipo entero:
(10, 12, -20)
Las tuplas también pueden estar compuesta por elementos de diferente tipo de dato:
(1.5, "Niña", 17, -3, "Luna", "Benji")
Una tupla puede contener otra tupla:
("Benji", (2014, "Canela", 12))
15
Diccionarios. Un diccionario es de tipo dict. Está conformado por una estructura de

datos, cuyos elementos pueden ser de diferente tipo, incluidas las tuplas, las listas y
otros diccionarios. Cada uno de los elementos que conforman al diccionario tienen
una clave o llave que permite su asociación. A diferencia de las tuplas y las listas, los
elementos de un diccionario no están organizados, ni pueden sea accedidos por su
posición.
Para definir un diccionario se debe utilizar un nombre y los caracteres de llaves { }.

Entre ellas van las parejas que conforman la clave y su valor, separadas mediante dos
puntos (:); cada uno de los elementos del diccionario se separan con comas. Ejemplo:
paises = {"Colombia": "Bogotá", "Estados Unidos": "Washington", "México": "Ciudad

de México"}
Hay que notar que, en el anterior ejemplo se le dio el nombre de paises al diccionario.
En él se aprecia que hay parejas de clave y valor. Las claves son los nombres de los
países y los valores sus capitales, ambos se separan mediante dos puntos. Cada pareja
(clave: valor) se separa de las demás mediante una coma.
Basados en este ejemplo, se mostrará el uso de una lista en la cual se tienen más
datos de cada país (capital, moneda, idioma, población), de esta forma la pareja
clave: valor, la conforma el nombre del país y su lista de datos.
paises = {"Colombia": ["Bogotá", "Peso colombiano", "Español", 50000000],

"Estados Unidos": ["Washington D.C", "Dólar", "Inglés", 331000000],
" México": ["Ciudad de México", "Peso mexicano", "Español", 129000000]}
1.2 Identificadores
Un identificador es el nombre que el programador le asigna a una variable, función,

clase, etc., con el propósito de referirse a dicho elemento dentro del programa.
16
Existen algunas reglas que deben respetarse al definir un identificador, así como
también, hay recomendaciones que han resultado de las buenas prácticas de
programación.
En este libro, se trabajarán las siguientes reglas y recomendaciones.
Reglas: como su nombre lo indica deben respetarse. En caso de omitirse, el programa

no funcionará y generará un error.
 El primer carácter de un identificador debe ser una letra o un subrayado (_).

 Los dígitos del 0 al 9 son caracteres válidos dentro de un identificador.
 No pueden usarse caracteres especiales en el identificador (&, %, $, ¿, entre
otros).
 No se pueden incluir espacios en blanco dentro del identificador.
 El uso de las palabras reservadas está prohibido.
 Python es sensible al tamaño, lo cual quiere decir que, diferencia letras
mayúsculas de minúsculas. Así, el identificador Precio es diferente a los
identificadores precio y PRECIO.
Recomendaciones: son buenas prácticas que se han establecido con el fin de facilitar
el trabajo de mantenimiento de un programa. Si se omiten, el programa funcionará
sin ningún inconveniente.
 Python soporta la letra ñ y las vocales con tildes en los identificadores, pero no
es aconsejable su uso.
 Se deben usar identificadores nemotécnicos, es decir, que sean muy descriptivos
con relación a lo que hacen dentro del programa.
 Cuando se define el identificador para un valor que va a permanecer durante toda
la ejecución del programa, se aconseja escribirlo en mayúsculas.
 No se deben incluir artículos como parte del identificador (el, la, los, de, un, unos,
de, etc.).
 Cuando se tienen identificadores con más de dos palabras, debe seguirse una
misma convención dentro de todo el programa. Las convenciones más conocidas
en Python son:
17
1. Snake Case: todas las palabras inician en minúscula y se unen con un

subrayado. Así, precio_libro.
2. Camel Case: la inicial de la primera palabra se escribe en minúscula y las
iniciales del resto en mayúscula. Las palabras van juntas. Así, precioLibro.
3. Pascal Case: la inicial de todas las palabras se escribe en mayúscula. Las
palabras van juntas. Así, PrecioLibro.
Dentro de los programadores de Python, las convenciones 1 y 2 son las más

usadas. A medida que se vayan utilizando, se explicarán en detalle.
1.3 Palabras reservadas
Las palabras reservadas son aquellas que, se emplean de acuerdo con su tarea
específica dentro del lenguaje de programación. Como se dijo en el apartado
anterior, ningún identificador puede ser denominado con el nombre de una palabra
reservada.
En la siguiente tabla, se encuentran las palabras reservadas de Python.
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
True None False
18
Actividad 1.1 Dados los siguientes identificadores, determine si son o no válidos, de

acuerdo con las reglas estudiadas en el numeral 1.2 Identificadores. En el caso de no
ser válido, justifique su respuesta.
Identificador ¿Es válido? Justificación

a) 1suma
b) _1suma
c) suma1
d) nombre_profesor
e) nombre profesor
f) numero#primo
g) placa_vehiculo
h) return
1.4 Variables
Se denomina variable a un contenedor en la memoria del computador, en donde se

guardan los datos para luego ser usados. Los valores que se almacenan en una
variable pueden cambiar, es por eso por lo que se llama variable.
Toda variable debe tener un identificador o nombre. A diferencia de los demás

lenguajes, en Python no es necesario declararle un tipo de dato a las variables. Al
asignarles un valor, se crean automáticamente tomando el tipo de acuerdo con la
naturaleza del valor que almacenan. Como se expresó al inicio de este capítulo,
Python es un lenguaje de tipado dinámico.
Para asignar un valor a una variable se utiliza el signo igual (=). La sintaxis es la
siguiente:
identificador = valor
19
Ejemplo: suponga la siguiente secuencia de instrucciones dentro de un programa en

Python.
1) x=5
2) x = "Armenia"
3) x = 3.6
Para una mejor explicación se ha numerado cada instrucción. Por lo cual, se puede
apreciar que en la línea uno se ha definido una variable llamada x con un valor inicial
de tipo int (entero) de 5. En la línea dos se conserva la misma variable, pero en esta
ocasión su valor es de tipo str (string o cadena). Ya en la línea tres su valor es de 3.6,
que corresponde a un tipo float (flotante).
Del anterior ejemplo, se puede inferir entonces que:
 No se requiere definir un tipo explícito para las variables a utilizar.

 Las variables van adoptando el tipo, de acuerdo con el valor que almacenen.
 Teniendo en cuenta que la anterior es una secuencia válida de programación, se
observa que no es necesario ningún signo al final de cada línea.
Actividad 1.2 Dadas las siguientes variables, determine a qué tipo de dato pertenece.
Variable Tipo de dato

a) suma = 589.9
b) contador = 45
c) placa_moto = "ABS-2343"
d) es_valido = True
e) tipo_producto = "A"
f) numero = 4 + 3j
20
1.5 Operadores
Un operador es un carácter o una cadena de caracteres que se utilizan en conjunto

con uno o más operandos para lograr un resultado. Hay operadores binarios, los
cuales actúan sobre dos operandos:
operando1 Operador operando2
Así mismo, se encuentran los operadores unarios, es decir, actúan sobre un solo
operando:
Operador operando
1.5.1 Operadores matemáticos
Son operadores binarios, se utilizan para realizar operaciones con valores numéricos.
Python maneja los siguientes operadores matemáticos:
Operador Operación que realiza

+ Suma
- Resta
* Multiplicación
/ División
** Potencia
// División entera
% Módulo o resto
Los primeros cuatro operadores representan las operaciones básicas que

aprendemos desde la época escolar. Con relación a los tres últimos se tiene que:
El operador ** es usado para calcular una potencia de la forma xn, la cual se

expresaría así: x ** n.
21
Para explicar los otros dos operadores, tengamos en cuenta los conceptos que se
muestran a continuación:
Con el operador // se obtiene como resultado la parte entera de una división

(cociente entero), es decir, sin decimales. Por ejemplo:
13 / 3 = 4.333333333, esta operación se realizó con el operador normal de la división

(/), dando como resultado un valor con decimales. En Python no sucede que al dividir
dos enteros se obtiene un resultado entero.
Ahora, al usar el operador para división entera: 13 // 3 = 4, se obtiene un resultado

entero, es decir, los decimales no son tenidos en cuenta.
Por su parte, el operador % permite encontrar el módulo o resto de una división. Para
el caso del ejemplo anterior, se tendría: 13 % 3, dando como resultado el valor de 1.
1.5.2 Operadores relacionales
Son operadores binarios que permiten hacer comparaciones entre dos operandos.
En Python se trabaja con los siguientes operadores relacionales:
Operador Significado
> Mayor que
< Menor que
== Igual a
!= Diferente de
>= Mayor o igual a
<= Menor o igual a
22
Es importante tener en cuenta que, el operador relacional == (dos iguales) indica una
comparación entre dos operandos y es diferente a = (un solo igual) que es usado para
asignar un valor a una variable.
1.5.3 Operadores lógicos
Se usan para construir expresiones lógicas. Su resultado es de tipo lógico (verdadero

o falso).
Python trabaja con los siguientes operadores lógicos:
 and Conjunción.
 or Disyunción.
 not Negación.
Operador and. También conocido como conjunción (y lógica). Es un operador binario

que devuelve el resultado True (verdadero) solo cuando ambos operandos son True.
Operando 1 Operando 2 Resultado

True True True
True False False
False True False
False False False
Operador or. También conocido como disyunción (o lógica). Es un operador binario

que devuelve un resultado True cuando al menos uno de los dos operandos tenga ese
valor.
Operando 1 Operando 2 Resultado

True True True
True False True
False True True
False False False
23
Operador not. También conocido como negación. Es un operador unario, es decir,

actúa sobre un solo operando cambiando su valor lógico. Si su estado es True,
devolverá False y viceversa.
Operando Resultado
True False
False True
1.6 Expresiones
Las expresiones son un conjunto de operadores, variables, números y otros

elementos que permiten obtener resultados de tipo numérico o lógico. Estos
resultados dependen del tipo de expresión. A continuación, se analizarán en detalle
varias de ellas.
1.6.1 Expresión matemática
Es aquella que está conformada por operadores matemáticos, variables, números y

otros elementos que arrojan resultados de tipo numérico.
En la siguiente tabla se ilustra el uso de estas expresiones.
Expresión Operación Resultado

5+2 Suma 5 con 2 7
5–2 Resta 2 de 5 3
12 * 4 Multiplica 12 por 4 48
15 / 6 Divide 15 entre 6 2.5
8 ** 3 Eleva 8 a la 3 512
15 // 6 Divide 15 entre 6 (división entera) 2
15 % 6 Resto de 15 entre 6 3
24
Este tipo de expresiones también pueden conformarse por variables. Por ejemplo, a
+ b, en este caso suma el valor que tenga la variable a con el valor que tenga la
variable b, el resultado dependerá de los valores almacenados en estas variables.
Precedencia de operación. Cuando en una expresión se encuentran varios

operadores, se debe tener en cuenta cuál de ellos se ejecuta primero. En la siguiente
tabla se observa el orden de ejecución de los operadores matemáticos:
Operador Precedencia
** Prioridad más alta
*, /, //, % Prioridad media
+, - Prioridad más baja
Lo expresado en la tabla indica que, lo primero que se debe calcular en una expresión
matemática es la potencia, luego las operaciones de división, multiplicación y
módulo, finalmente se realizan las sumas y restas. Cuando los operadores tienen igual
prioridad, se procede de izquierda a derecha. Además, si por alguna circunstancia se
tiene que cambiar la prioridad de la operación se usan los paréntesis, los cuales
asumen la prioridad más alta.
Para ilustrar lo anteriormente descrito, observe las siguientes operaciones y su

explicación.
4+5*2
Si esta instrucción se calcula en el orden en que está escrita, sin tener en cuenta la
precedencia de los operadores, se obtendrá un resultado de 18.
4+5*2
Se obtiene un 9 de la suma de 4 + 5
9*2
Al efectuar la nueva expresión, el resultado es 18.
25
A simple vista ya se tiene el resultado. Pero es una solución errónea. Si observa

detenidamente se tiene que, hay dos operaciones suma y multiplicación (+, *); al
analizar la tabla de precedencia, la multiplicación está por encima de la suma. Esto
significa entonces que, se debe realizar en primer lugar la multiplicación:
4+5*2
Para un resultado de 10
4 + 10
Luego se realiza la suma, para un resultado final de 14.
Si lo que usted buscaba era que el resultado fuera 18, la expresión correcta sería:
(4 + 5) * 2
Recuerde que los paréntesis tienen la máxima precedencia:
(4 + 5) * 2
9*2
18
Ahora se analizará una expresión donde hay operaciones con la misma precedencia.
Entonces, ¿cuál será el resultado de la siguiente expresión?
7+4/8*3
La expresión presenta una suma, una división y una multiplicación. La máxima

precedencia se encuentra en la división y en la multiplicación. Ambas tienen la misma
26
prioridad. En este caso se ejecutan entonces, de izquierda a derecha y por último se

realiza la suma. Paso a paso, se desarrolla así:
7+4/8*3
7 + 0.5 * 3
7 + 1.5
8.5
Actividad 1.3 Realice las siguientes operaciones, paso a paso, teniendo en cuenta la
precedencia de los operadores:
a. 7 + 4 / (8 * 3)
b. (7 + 4) / 8 * 3
c. (7 + 4) / (8 * 3)
d. 10 * (10 + (-5)) % (8 + (-1)) // 10
e. 5 // 2 * 3 + 4 ** (3 * 2) // 3 + (4 – 2)
f. 10 * (10 + 4) % (8 + 3) // 3
g. 3 % 2 - 4 // 1 * 4 + 3
Escritura de fórmulas. Como ha podido analizar, es muy importante escribir

correctamente las fórmulas a empezar. Generalmente las expresiones siempre se
encuentran en notación matemática y para que el lenguaje Python pueda
interpretarlas debe escribirse en notación algorítmica. Este procedimiento no es
complicado, sin embargo, deben aplicarse las siguientes reglas.
1. Cuando se tenga una cantidad expresada en potencia y el exponente presente

alguna operación, se debe escribir entre paréntesis dicho exponente:
Notación matemática Notación en Python

z3x z ** (3 * x)
b5-a b ** (5 - a)
27
2. Cuando se tenga una división y en alguno de sus términos (numerador,

denominador) se presente una operación, debe encerrarse entre paréntesis
dicho término:

𝐱+𝐲
(x + y) / z
𝐳
𝐱+𝐲
𝐚 (x + y) / (z - a / (b + 2))
𝐳−
𝐛+𝟐
3. Toda raíz se debe expresar como una potencia:

𝟑
√𝟏𝟖 18 ** (1 / 3)
𝟓 𝟒 (69 ** (1 / 4)) ** (1 / 5)
√ √𝟔𝟗
Actividad 1.4. Dadas las siguientes expresiones en notación matemática, conviértalas

en expresiones válidas para Python.
𝑥
a. 𝑟
𝑦+
𝑙
𝑥
𝑦
b.
𝑦+ 𝑐
4 𝑏 34
c. √ − 𝑥+4
2𝑥
28
5
d. √ 2√3(𝐵 + 4)(5 − 𝐴)
20∗ 42 +7∗4−6
4
e. 4
−52
42
1.6.2 Expresión relacional
Es aquella que está conformada por operadores relacionales, variables, números y

otros elementos que arrojan resultados de tipo booleano o lógico.
En la siguiente tabla se ilustra el uso de estas expresiones.
Expresión Operación Resultado

5>2 Compara si 5 es mayor que 2 True
5<2 Compara si 5 es menor que 2 False
12 >= 4 Compara si 12 es mayor o igual a 4 True
15 <= 6 Compara si 15 es menor o igual a 6 False
8 == 3 Compara si 8 es igual a 3 False
15 != 6 Compara si 15 es diferente de 6 True
Al igual que las expresiones matemáticas, las relacionales también pueden estar
conformadas por variables. Observe las siguientes situaciones.
numero > 6, en este caso se compara si el valor de la variable numero es mayor a 6,

el resultado dependerá del valor que llegue a almacenar la variable.
Así mismo, se pueden encontrar expresiones más complejas como la siguiente:
5 + 4 * 2 >= 30 – 20 / 5
29
Para poder obtener el resultado, se debe tener en cuenta que primero se realizan las
operaciones matemáticas y luego se evalúa la relación. En el caso de haber
paréntesis, estos se ejecutan primero.
Ahora bien, retomando el ejemplo se tiene:
5 + 4 * 2 >= 30 – 20 / 5
En la anterior expresión, se presentan dos términos que están delimitados por el

operador mayor o igual a (>=)
5 + 4 * 2 >= 30 – 20 / 5
Al analizar cada uno de los lados de la expresión, se observa que hay operaciones
matemáticas, las cuales se deben desarrollar según la prioridad de operación, así:
5 + 4 * 2 >= 30 – 20 / 5
5 + 8 >= 30 – 4
13 >= 26
Una vez se hayan efectuado todas las operaciones matemáticas, se evalúa la

expresión relacional final, obteniendo así, el resultado de False.
1.6.3 Expresión lógica
Es aquella que está conformada por operadores lógicos, expresiones relacionales,

variables, números y otros elementos que arrojan resultados de tipo booleano o
lógico.
Para ilustrar el uso de este tipo de expresiones, se analizará la siguiente:
((2 > 3) or (5 < 10)) and ((12 == 7) or (2 >= 3))
30
Los paréntesis delimitan muy bien los términos de esta expresión:
((2 > 3) or (5 < 10)) and ((12 == 7) or (2 >= 3))
Así las cosas, la solución es como sigue:
((2 > 3) or (5 < 10)) and ((12 == 7) or (2 >= 3))

( False or True ) and ( False or False )
True and False
True
1.6.4 Expresión de asignación
Cuando se estudió el concepto de variable, se escribieron expresiones como estas:
1) a=5
2) b = 2.5
3) nombre = "Adriana"
Todas ellas son expresiones de asignación, ya que a cada una de las variables se les
estaba asignando un valor, a la variable a se le asignó el valor de 5, a la variable b se
le asignó el valor de 2.5 y a la variable nombre se le asignó el valor de Adriana.
De este modo se puede concluir que, una expresión de asignación tiene la siguiente
forma general:
variable = valor
Donde, variable es un identificador válido y valor puede ser otra variable, un número,
una cadena de caracteres, un carácter, el resultado de una operación o de una
función que se haya ejecutado, entre otros. El tema de funciones será tratado con
más detalle en el siguiente capítulo.
31
Ahora bien, esta forma general de realizar una asignación tiene algunas variantes que
son interesantes de analizar. Python permite la asignación de valores de manera
agrupada. Para ello se usa la siguiente forma general:
variable1, variable2, variable_ n = valor1, valor2, valor_n
A cada variable le corresponderá respectivamente, uno de los valores del lado

derecho del operador =.
Un ejemplo de ello es el siguiente:
1) numero = 100
2) ciudad = "Armenia"
3) nota = 3.6
4)
5) numero, ciudad, nota = 100, "Armenia", 3.6
En las líneas 1, 2 y 3, a las variables numero, ciudad y nota le son asignados los valores
100, Armenia y 3.6 respectivamente de manera independiente. Con la instrucción
que hay en la línea 5, se logra el mismo resultado. Tenga presente que las
asignaciones se hacen de derecha a izquierda.
Otra variante de esta forma de asignación es la siguiente:
variable1 = variable2 = variable_ n = valor
Con esta forma se puede asignar un mismo valor a múltiples variables:
a=b=c=1
En este caso en particular, las variables a, b y c toman el mismo valor, 1.
32
En Python, como en otros lenguajes existen los operadores aumentados de

asignación. Reciben este nombre porque combinan los operadores matemáticos con
el operador de asignación. En la siguiente tabla se listan y se ejemplifica su uso.
El valor de la variable x será de 4 (x = 4).
Operador Operación Ejemplo Resultado Equivalente a

**= Potencia asignación x **= 3 64 x = x ** 3
*= Producto asignación x *= 5 20 x=x*5
/= División asignación x /= 3 1.3333333 x=x/3
//= División entera asignación x //= 3 1 x = x // 3
%= Módulo asignación x %= 2 0 x=x%2
+= Suma asignación x += 8 12 x=x+8
-= Resta asignación x -= 7 -3 x=x-7
En el uso de este operador se debe tener especial precaución en cuanto a que, la

variable a la que se le asigna el resultado debe tener un valor previo a su uso en la
expresión.
Actividad 1.5. Determine si el resultado es False o True para las siguientes

expresiones lógicas, teniendo en cuenta las asignaciones previas para las variables:
a, b, c, d, e = 12, 3, 24, 60, 9
a. (a > b) and (b < c)

b. (12 + b == e) and (c + e < d)
c. (a > 3) or (d < 24)
d. (8 * 3 < d) or (c < 12)
e. (c > 9) and (a > d)
f. not (a == b)
g. not (a * 9 + c == d)
33
1.7 Comentarios
Un comentario es una explicación o anotación que se hace dentro del cuerpo del
programa. No hacen parte de la lógica de este y son ignorados en el momento de su
ejecución.
Para escribir comentarios en Python se usa el carácter # (numeral). Pueden ubicarse

al inicio de cada línea:
# Este es un comentario desde el inicio de la línea
También pueden ir luego de una expresión o instrucción:
x = x + 2 # Esto también es un comentario
Aunque no es obligatorio incluir comentarios dentro de un programa, estos son muy

útiles en el momento en que se requiera hacerle mantenimiento, o para ayudar a
entender la lógica de este.
1.8 Entrada y salida de datos
Hasta el momento, se han dado ejemplos donde los valores de las variables se han
asignado previamente a través del operador igual (=), pero, generalmente los datos
deben ser dados por el usuario a los programas.
En este apartado se establecerá una comunicación entre el usuario y el programa, es

decir, el usuario le dará unos datos y el programa le dará una respuesta. Para lograr
esto, se deben trabajar las funciones print( ) e input( ).
1.8.1 Función print( )
Una función es una instrucción que el lenguaje reconoce y ejecuta para desarrollar
una tarea determinada. En el caso de la función print( ), Python la utiliza para
desplegar mensajes en pantalla.
34
Su forma general es la siguiente:
print(mensaje)
Donde, la función print( ) debe escribirse en minúsculas y le indica a Python que se

va a mostrar un dato en pantalla. Así mismo, el argumento llamado mensaje
representa lo que se mostrará. Por ejemplo:
Instrucción Salida por pantalla

1 print("Esto es Python.") Esto es Python.
2 print('Esto es Python.') Esto es Python.
3 print(5 * 4) 20
Python interpreta que todo lo que está entre comillas dobles o sencillas es una
cadena de caracteres (mensaje) que debe mostrarse en pantalla. Observe que en la
instrucción de la fila uno, se usaron comillas dobles y en la fila dos se usaron comillas
sencillas. En ambos casos, se obtuvieron los mismos resultados. En la fila tres el
mensaje corresponde a una operación matemática, por lo tanto, Python la ejecuta e
imprime su resultado.
En ocasiones, será necesario que dentro del mensaje que se va a imprimir se

muestren las comillas, en ese caso, se debe proceder usando los dos tipos de comillas.
Si el mensaje debe mostrarse con comillas sencillas, entonces se escribe todo el
mensaje entre comillas dobles y lo que se va a mostrar entre comillas, se escribe entre
las sencillas y viceversa, así:

1 print("Esto es 'Python'.") Esto es 'Python'.
2 print('Esto es "Python".') Esto es "Python".
35
La función print() también permite que, en el mensaje se combinen diferentes tipos

de datos:
1) nombre = "Niña"
2) edad = 6
3)
4) print ("Mi mascota se llama", nombre,"y tiene", edad,"años.")
En las líneas 1 y 2 se asignan valores a las variables nombre y edad. En la línea 4 se

usa la función print() para imprimir un mensaje acompañado de los valores de las
variables. En pantalla se visualizaría lo siguiente:
Mi mascota se llama Niña y tiene 6 años.
Observe que lo que está entre comillas se imprime tal cual está escrito, las variables
son separadas de los mensajes mediante la coma, en el lugar que ellas están se
muestra el valor que tienen almacenado.
Otra forma de mostrar en pantalla el anterior mensaje, es la siguiente:
print("Mi mascota se llama" + nombre,"y tiene", edad,"años")
Note que para imprimir un dato de tipo str (nombre), en lugar de la coma se usó el
signo +, el cual al ser usado con cadenas de caracteres realiza la operación de
concatenación, es decir, las une. Para el dato de tipo int (edad) se debe utilizar la
coma como se hizo en el ejemplo anterior a este. A continuación, se muestra el
resultado que se verá en pantalla:
Mi mascota se llama Niña y tiene 6 años
Observe que, en la concatenación las cadenas se unen sin dejar espacio.
Una variante adicional de la función print( ), se puede observar con el uso de la

interpolación de cadenas. De esta manera se puede especificar el lugar que tendrá el
dato dentro la cadena que se va a mostrar por pantalla. Su uso es sencillo y se basa
en utilizar los caracteres de llaves ({ }) para indicar el lugar donde quedará el dato.
Estos caracteres se usan en conjunto con el método format() que contendrá los datos
36
que ubicará dentro de esas llaves. Suena un poco complejo, pero es fácil de utiliza.
Veamos el siguiente ejemplo:
print("Mi mascota se llama { } y tiene { } años".format(nombre, edad))
Dentro de la cadena de caracteres hay dos pares de llaves ({ }), las cuales serán
reemplazadas respectivamente por los argumentos que hay en el método format( ),
dicho de otra forma, las primeras llaves se reemplazarán por el contenido que hay en
la variable nombre y el segundo par de llaves se reemplazará por el valor de la variable
edad, obteniendo así el siguiente mensaje:
Todas las anteriores instrucciones son válidas, pero pueden prestarse a un poco de
confusión. A partir la versión 3.6 de Python, se introdujeron las f-strings o literals
strings.
print(f"Mi mascota se llama {nombre} y tiene {edad} años")
De esta forma se usó la variable, directamente en la posición que va a quedar. Para

el uso de f-strings es importante no olvidar incluir la letra f antes de iniciar la cadena.
La anterior instrucción produce la siguiente impresión:
Continuando con las posibilidades que ofrece la función print( ) se tiene que, se
pueden incluir expresiones matemáticas. En este caso, Python realiza la operación e
imprime el resultado:

1 print(f"El resultado es: {10 / 3}") El resultado es: 3.3333333333333335
2 print(f"El resultado es: {10 / 3:.2f}") El resultado es: 3.33
3 print(f"El resultado es: {10 / 3:8.2f}") El resultado es: 3.33
Observando detenidamente se aprecia que, el formato del resultado de la línea dos

es diferente al de la línea uno. En la segunda línea se usó un formateo por tipo, el cual
se especificó usando la letra f dentro de las llaves, indicando así que se trata de un
dato de tipo float. El valor de punto dos (.2f) que acompaña la letra f, establece que
se debe imprimir un número con dos decimales.
37
De igual forma, en la línea tres se definió el formato 8.2f para la impresión del dato.
En este caso, Python interpreta que se debe imprimir un dato de tipo float en un
espacio de ocho caracteres, de los cuales dos son para decimales, uno para el punto
y los restantes cinco para la parte entera.
De la misma manera como se hace con los datos de tipo float, se puede trabajar con
los datos de tipo int, en este caso se usa la letra d para especificar el formato. Suponga
la inicialización de la variable z con un valor de 7 y observe las líneas de código en la
siguiente tabla.
z=7

1 print(f"El valor de la variable Z es: {z}") El valor de la variable Z es: 7
2 print(f"El valor de la variable Z es: {z:5d}") El valor de la variable Z es: 7
Algo semejante se puede hacer con el manejo de los datos de tipo str (string –
cadena). En este tipo de dato se emplea la letra s. Para ejemplarizar su uso, se
inicializará la variable nombre, con la cadena “María Camila”.
nombre = "María Camila"

1 print(f"Hola {nombre} ¿cómo estás?") Hola María Camila ¿cómo estás?
2 print(f"Hola {nombre:20s} ¿cómo estás?") Hola María Camila ¿cómo estás?
Paralelamente a las diferentes formas que puede tener la función print( ), en ella se
pueden incluir las secuencias de escape para realizar tareas o imprimir caracteres
determinados. Su funcionalidad se describe en la siguiente tabla:
Secuencia de escape Descripción

\n Hace un salto de línea
\t Inserta varios espacios en blanco
\\ Inserta la barra invertida
\’ Inserta comilla sencilla
\” Inserta comillas dobles
38
Para ilustrar el uso de estas secuencias de escape, se inicializará la variable nombre,

con la cadena “María Camila” y en la siguiente tabla se mostrarán cuatro ejemplos.
nombre = "María Camila"

1 print(f"Hola {nombre} \n¿cómo estás?") Hola María Camila
¿cómo estás?
2 print(f"Hola \t {nombre} \t ¿cómo estás?") Hola María Camila ¿cómo estás?
3 print(f"\"Hola\" {nombre} ¿cómo estás?") "Hola" María Camila ¿cómo estás?
4 print(f"\'Hola\' {nombre} ¿cómo estás?") 'Hola' María Camila ¿cómo estás?
1.8.2 Función input( )
Esta función permite que el usuario introduzca datos desde el teclado al computador.
variable = input( )
En el objeto llamado variable se almacena el valor digitado por el usuario.
Generalmente, esta función debe ir acompañada de un mensaje que solicite la

entrada de un dato, así:
1) print("Digite su nombre: ")

2) nombre = input()
3)
4) print("Digite su edad: ")
5) edad = input()
En las líneas 1 y 4, mediante una función print( ) se solicitan los datos por pantalla.
Mediante las funciones input( ) que hay en las líneas 2 y 5 se almacenan en las
variables nombre y edad, los valores digitados por el usuario.
39
Suponga que a la petición que hace el programa, el usuario digita el nombre María
Camila y en la edad digita un 26. En pantalla se vería así:
Digite su nombre:
María Camila
Digite su edad:
26
Esto obedece a que cuando la función print( ) se ejecuta, finaliza con un salto de línea.
Debe tener especial cuidado con estas lecturas de datos ya que, la función input( )
almacena en las variables los datos como de tipo cadena. Esto quiere decir que,
aunque se haya digitado un valor numérico a la petición del ejemplo anterior (Digite
su edad:), este será tratado como cadena y no como un valor float o int. Si se
intentara hacer alguna operación de tipo matemático con él, se generará un error.
Ahora, ¿qué se debe hacer para que el dato sea pedido en la misma línea y para que
la edad digitada sea tratada como un valor numérico y no como una cadena?
Se planteará la solución empezando por la segunda parte de la pregunta. Es decir,

para que la edad sea tratada como un valor numérico, debe ser almacenado como un
número, así:
1) print("Digite su edad: ")

2) edad = int(input( ))
En este caso, el dato será tratado como un número int (entero) y podrá hacerse
operaciones matemáticas con la variable edad. Si se quisiera que el dato fuera de tipo
float, aunque las edades generalmente se trabajan de tipo int, se procedería de
manera similar:
edad = float (input ( ))
Pero aún, el dato se sigue solicitando en una línea independiente. Ahora bien, para
dar solución a la primera parte de la pregunta planteada anteriormente (¿qué se debe
40
hacer para que el dato sea pedido en la misma línea?), se procede de la siguiente
manera:
1) nombre = input( "Digite su nombre: ")

2) edad = int(input( "Digite su edad: "))
De esta forma, en pantalla se visualizaría así:
Digite su nombre: María Camila

Digite su edad: 26
La función input( ), ha sido usada tanto para leer el dato que digita el usuario y
también para mostrar un mensaje en pantalla, por lo tanto se ahorra el uso de la
función print( ) en la entrada de datos.
Así las cosas, se han solucionado las dos partes de la pregunta planteada. Los datos
se piden en la misma línea y el valor digitado para la variable edad, será tratado como
un dato numérico, con el cual se pueden realizar operaciones matemáticas.
Para finalizar con la función input(), se mostrará cómo se puede usar para entrar
datos y a la vez para mostrar valores de otras variables.
1) nombre = input( "Digite su nombre: ")

2) edad = int(input(f"{nombre} digite su edad: "))
En la línea uno se solicita el nombre, luego en la línea dos, de acuerdo al nombre que
le hayan digitado muestra ese valor y le solicita la edad. Continuando con el ejemplo
de María Camila que tiene 26 años, se vería así:
Digite su nombre: María Camila

María Camila digite su edad: 26
41
1.9 Primeros programas
Con todos los elementos que se han estudiado hasta el momento, el lector ya está en
capacidad de solucionar problemas sencillos, usando la programación en Python.
Ejemplo 1.1 Se leerán dos números de los cuales se hallará la suma y luego se
mostrará el resultado.
1) # Suma de dos números

2)
3) numero1 = input("Ingrese un número: ")
4) numero2 = input("Ingrese otro número: ")
5)
6) suma = numero1 + numero2
7)
8) print(suma)
Explicación:
 En la línea uno se escribió un comentario que indica que hace el programa.

 En las líneas 3 y 4 se solicitan y leen dos números, respectivamente.
 Con la expresión de la línea seis se realiza la suma de los valores contenidos en
las variables numero1 y numero2.
 La línea ocho contiene la instrucción print(), con la cual se imprime el resultado
de la operación.
Es conveniente señalar que, aunque aparentemente la solución está bien formulada,

existe un error. Consideremos que los datos de entrada serán 12 y 10 para cada uno
de los números. Al efectuar la operación suma = numero1 + numero2, se espera que
el resultado sea 22, pero no es así, el programa mostrará por pantalla: 1210.
¿Qué sucedió? Recuerde que con anterioridad se dijo que los datos que son leídos
con la función input( ) son tratados como cadenas. En este ejemplo en particular,
Python no hizo una suma matemática, sino una concatenación de cadenas; la cadena
12 fue concatenada con la cadena 10, dando como resultado la cadena 1210.
42
Hecha esta aclaración, ¿entonces cuál sería la solución para que el programa sume
los valores como números y no como cadenas? La respuesta a este interrogante tiene
varias soluciones, a continuación, se analizarán dos de ellas.
Primera solución:

2)
3) numero1 = input("Ingrese un número: ")
4) numero2 = input("Ingrese otro número: ")
5)
6) suma = float(numero1) + float(numero2)
7)
8) print(suma)
La entrada de los datos (líneas 3 y 4) siguen siendo exactamente las mismas. El

cambio se realizó sobre la expresión que hay en la línea seis. Se hizo una conversión
de tipo, los datos de tipo str (cadena) que están almacenados en las variables
numero1 y numero2, mediante la función float( ) se convierten a datos de tipo
flotante.
Esta solución, a pesar de que funciona correctamente no es óptima. Si se necesitara

volver a realizar operaciones matemáticas con los valores de las variables numero1 o
numero2, se tendrían que volver a convertir a tipo float ya que, siguen siendo de tipo
cadena (str). La conversión a tipo float solo se hizo en el momento de realizar la suma.
Segunda solución:

2)
3) numero1 = float(input("Ingrese un número: "))
4) numero2 = float(input("Ingrese otro número: "))
5)
7)
8) print(suma)
43
Si se compara esta solución con la anterior se observa que, el cambio se realizó en la

entrada de datos, esto es, sobre las líneas 3 y 4 y ya no se utilizó la función float( ) en
la operación de la suma (línea seis). De esta forma los valores que se almacenen en
las variables numero1 y numero2 serán de tipo flotante y podrán ser usados, de ahí
en adelante, en operaciones matemáticas sin necesidad de volver a hacerles ningún
tipo de conversión.
Ejemplo 1.2. Este programa calcula el valor total de la venta de un artículo,

incluyendo el valor del IVA, que para este caso se tomará como el 19%. El programa
solicitará el código del artículo, el costo por unidad y la cantidad de artículos
vendidos. Como salida se mostrará el costo total del producto, el valor del IVA y el
total de la venta con el IVA incluido.
1) # Calcula el valor de una venta de productos, incluyendo el IVA

2)
3) IVA = 0.19
4)
5) print("\nDigite los siguientes datos del producto\n")
6) codigo = input("Código: ")
7) costo_unitario = float(input("Costo por unidad: "))
8) cantidad = int(input ("Cantidad: "))
9)
10) costo_total = costo_unitario * cantidad
11) valor_iva = costo_total * IVA
12) valor_venta = costo_total + valor_iva
13)
14) print("El costo de todos los productos es: ", costo_total)
15) print("El valor del IVA es: ", valor_iva)
16) print("El precio total de la venta con IVA es: ", valor_venta)
Explicación:
 En la línea tres se define una variable llamada IVA con un valor de 0.19, la cual
será tratada como si fuera una “constante”. Este valor representa el 19%,
resultado de dividir 19 entre 100. Es importante tener en cuenta que, en Python
no existen las constantes definidas por el usuario, pero conservando las buenas
prácticas de programación, que se aplican en los otros lenguajes, los
identificadores de las constantes se escriben en mayúsculas.
44
 La función print() de la línea cinco, imprime el mensaje “Digite los siguientes

datos”. Las secuencias de escape \n, indican que se debe dejar una línea en
blanco antes y después de imprimir el mensaje.
 Las instrucciones de las líneas 6, 7 y 8, son las encargadas de leer los datos que
proporciona el usuario. Esos datos son almacenados en las variables codigo,
costo_unitario y cantidad respectivamente.
Para la variable codigo se usa la función input(), que permite capturar un dato de
tipo str. Para costo_unitario se usa la combinación de la función input() junto con
la función float(), la primera muestra el mensaje “Costo por unidad”, a la vez que
lee el dato como una cadena; con la función float() se convierte esta cadena a
dato numérico de tipo float. Para leer la cantidad, se usó la función int(), con la
cual el dato es convertido a entero (int). Estas conversiones deben hacerse para
poder usar las variables dentro de las expresiones matemáticas con las cuales se
realizan los cálculos.
 Una vez leídos los datos, en las líneas 10, 11 y 12 se realizan los cálculos
respectivos. Observe que la expresión de la línea 11 usa la “constante” llamada
IVA:
valor_iva = costo_total * IVA
Es también válido haber usado directamente su valor, así:
valor_iva = costo_total * 0.19
 Finalmente se muestran los resultados (líneas 14, 15 y 16). Para ello, se usó la
función print(), donde se muestra un mensaje, acompañado del valor de la
variable. El mensaje se separa del valor de la variable usando una coma, por
ejemplo:
print("El costo de todos los productos es: ", costo_total)
 Las líneas 14, 15 y 16, pueden ser reemplazadas por las siguientes instrucciones:
print(f"El Costo de todos los productos es: {costo_total}")

print(f"El valor del IVA es: {valor_iva}")
print(f"El precio total de la venta con IVA es: {valor_venta}")
45
Anteriormente se explicó que a partir de la versión 3.6 de Python, se incluyeron

estas f-strings o literals strings, las cuales son la mejor opción para mostrar los
resultados. A partir de este momento todos los ejemplos usarán este tipo de
impresión.
Ejemplo 1.3 Escriba un programa en Python que, permita hallar y conocer la suma de
los cuadrados de los números desde 1 hasta un valor n, utilizando la siguiente
fórmula:
𝑛(𝑛 + 1)(2𝑛 + 1)
𝑠𝑢𝑚𝑎 =
6
Antes de plantear cualquier solución, conviene tener presente que se debe hacer un
análisis del problema. En este caso en particular, es importante entender cómo
funciona la fórmula y corroborar si efectivamente es una solución al problema
planteado. Para este propósito entonces ilustremos el enunciado, hallando la suma
de los cuadrados de los números desde 1 hasta 10. Es decir, se debe realizar la
siguiente suma:
𝑠𝑢𝑚𝑎 = 12 + 22 + ⋯ + 𝑛2
Donde n indica el número de términos que se sumarán.
𝑠𝑢𝑚𝑎 = 12 + 22 + 32 + 42 + 52 + 62 + 72 + 82 + 92 + 102
𝑠𝑢𝑚𝑎 = 1 + 4 + 9 + 16 + 25 + 36 + 49 + 64 + 81 + 100
𝑠𝑢𝑚𝑎 = 385
46
Al aplicar la fórmula se debe obtener igual resultado:
10 ∗ (10 + 1) ∗ (2 ∗ 10 + 1)
𝑠𝑢𝑚𝑎 =
6
10 ∗ 11 ∗ 21
𝑠𝑢𝑚𝑎 =
6
2310
𝑠𝑢𝑚𝑎 =
6
𝑠𝑢𝑚𝑎 = 385
Una vez entendido el procedimiento y el cálculo a realizar, se puede diseñar la

solución al problema. En esta ocasión se requiere un solo dato de entrada, el cual se
representará con la variable n, en donde se almacenará la cantidad de números a
sumar.
De igual manera, se requiere convertir la fórmula a una expresión matemática que

pueda ser entendida por Python. Lo cual nos conlleva a la siguiente expresión:
suma = (n * (n + 1) * (2 * n + 1)) // 6
Se usará el operador // ya que se trata de una división entera (sin decimales).
Una vez realizado el análisis, se plantea la siguiente solución en Python:
1) # Suma de cuadrados desde 1 hasta n

2)
3) print("Suma de cuadrados")
4) n = int(input("¿Hasta cuál término desea calcular la suma?: "))
5)
6) suma = (n * (n + 1) * (2 * n + 1)) // 6
7)
8) print(f"La suma de los cuadrados desde 1 hasta {n} es: {suma}")
47
Explicación.
 En la línea uno se hizo un comentario de lo que realiza el programa. Este no será

tenido en cuenta por el intérprete de Python en el momento de su ejecución.
 La instrucción de la línea tres, muestra en pantalla el siguiente mensaje: Suma de

cuadrados
 La línea cuatro se encarga de la entrada de los datos, mediante la siguiente

instrucción:
n = int(input("¿Hasta cuál término desea calcular la suma?: "))
En la variable n se almacena el valor que digite el usuario. La función int()

convierte el valor digitado en un dato de tipo entero, recuerde que la función
input() captura los datos como una cadena de caracteres. En pantalla se mostrará
el siguiente mensaje como solicitud al usuario: ¿Hasta cuál término desea
calcular la suma?:.
 En la línea seis, se encuentra la fórmula para hallar la suma. El resultado de la

operación es almacenado en la variable suma.
 Finalmente, en la línea ocho se imprime el resultado mediante la siguiente

instrucción:
print(f"La suma de los cuadrados desde 1 hasta {n} es: {suma}")
 Suponiendo que el usuario digite el número 10, como la cantidad de términos a

sumar, en pantalla se vería el siguiente resultado:
La suma de los cuadrados desde 1 hasta 10 es: 385
 Tenga en cuenta que este programa queda en capacidad de hallar la suma de

cualquier cantidad de términos. El valor de 10 se tomó para ilustrar su
funcionamiento.
48
Actividad 1.6 Construya un programa en Python para cada uno de los siguientes
enunciados. No olvide realizar el respectivo análisis.
a. Un vendedor de oro requiere calcular y conocer el total de ventas en un día. Para

ello, él posee la cantidad de gramos vendidos y el precio por gramo.
b. Tres hermanos forman una sociedad para comprar una propiedad. Cada uno de
ellos invierte una suma diferente de dinero. Se necesita conocer el porcentaje
que cada uno invirtió con relación al total de dinero invertido.
c. El área de un trapecio se obtiene, de la mitad de su altura por la suma de sus

bases (base mayor y base menor). Lea los datos necesarios para calcular e
informar su área.
Base menor
Altura
Base mayor
d. Dada una cantidad en pesos colombianos, obtenga e informe la equivalencia en

dólares y en euros, de acuerdo con la cotización del día.
e. Halle e informe la suma de los cubos de los números desde 1 hasta un valor n,
para ello use la siguiente fórmula:
2
𝑛(𝑛 + 1)
𝑠𝑢𝑚𝑎 = ( )
2
49
CAPÍTULO 2
2 FUNCIONES
Objetivos:
 Identificar la importancia del uso de funciones en la construcción de

programas.
 Conocer los tipos de funciones presentes en Python para utilizarlas de acuerdo
con los requerimientos que se presenten.
 Crear programas usando funciones del lenguaje y de programador para
reutilizar código y ahorrar tiempo.
 Conocer la funcionalidad de los módulos para darle aplicación en la
construcción de programas
Funciones
Una función es un bloque de líneas de código que realizan una tarea específica. Al
igual que todos los elementos de Python, las funciones también son objetos.
La más grande ventaja que presenta el uso de funciones es la Reutilización de código.

El tener que usar un bloque de instrucciones en reiteradas ocasiones dentro de un
programa, sin el uso de una función, obligaría al programador a repetir dicho bloque
las veces que sea requerido; al utilizar funciones, bastaría con escribirlo una sola vez
y llamarlo cuando sea necesario.
2.1 Funciones propias de Python
Hasta ahora, se han usado varias de las funciones propias del lenguaje, entre las que
se destacan las funciones print(), input(), float(), int(). Python ofrece un gran número
de funciones que, realizan tareas que le permiten ahorrar tiempo a los
programadores en sus desarrollos de software. Para ilustrar el uso de las funciones
propias del lenguaje, se estudiarán algunas para el manejo de cadenas y otras para
realizar operaciones matemáticas.
Funciones para cadenas. Estas funciones operan sobre datos de str. Las más
destacadas se pueden visualizar en la siguiente tabla.
Función Descripción
len(cadena) Devuelve la longitud de la cadena
cadena.upper() Convierte el contenido de cadena en mayúsculas
cadena.lower() Convierte el contenido de cadena en minúsculas
cadena.capitalize() Devuelve la primera letra de la cadena en mayúscula
cadena.swapcase() Convierte las mayúsculas en minúsculas y viceversa
cadena.title() Convierte en mayúsculas la primera letra de cada palabra de
la cadena
Centra la cadena en n espacios, usando un carácter específico
cadena.center(n, “a”)
(a) de relleno
Devuelve el número de ocurrencias de un carácter (a) dentro
cadena.count(“a”)
de la cadena
51
Ejemplo 2.1. Este programa en Python lee un nombre de una persona y una letra a
buscar dentro de ese nombre. Luego informará la cantidad de caracteres que tiene y
el número de ocurrencias de la letra dentro del nombre digitado, igualmente se les
dará aplicación a las demás funciones relacionadas en la tabla anterior.
Para la solución de este enunciado, se presenta el siguiente programa:
1) # Funciones para datos de tipo str (cadena)

2)
3) nombre = input("Digite un nombre: ")
4) letra = input("Digite la letra a buscar: ")
5)
6) print(f"\n{nombre} tiene {len(nombre)} caracteres")
7) print(f"La letra \'{letra}\' se encuentra {nombre.count(letra)} veces\n")
8) print(nombre.upper())
9) print(nombre.lower())
10) print(nombre.capitalize())
11) print(nombre.swapcase())
12) print(nombre.title())
13) print(nombre.center(30, "*"))
Explicación:
 Inicialmente en las líneas 3 y 4 se pide un nombre y la letra a la que se le hallará

la cantidad de ocurrencias dentro del nombre digitado.
 En la línea seis se usa la siguiente instrucción:
print(f"\n{nombre} tiene {len(nombre)} caracteres")
La secuencia de escape (\n) se usa para dejar una línea en blanco antes de
imprimir el mensaje. Luego se escribe el nombre que se haya digitado, seguido
del número de caracteres que posea.
52
 La línea seis presenta la siguiente instrucción:
print(f"La letra \'{letra}\' se encuentra {nombre.count(letra)} veces\n")
Ella se encarga de imprimir la letra que se haya digitado para ser buscada dentro
del nombre, acompañada de la cantidad de ocurrencias que tenga dentro de la
cadena digitada. La secuencia de escape \’ se emplea para mostrar comillas
simples.
 Las demás funciones actúan sobre la cadena de caracteres que se ha almacenado

en la variable nombre. A continuación, se observa un ejemplo de la ejecución de
este programa:
Digite un nombre: Michelle Bastos Guzmán

Digite la letra a buscar: e
Michelle Bastos Guzmán tiene 22 caracteres

La letra 'e' se encuentra 2 veces
MICHELLE BASTOS GUZMÁN

michelle bastos guzmán
Michelle bastos guzmán
mICHELLE bASTOS gUZMÁN
Michelle Bastos Guzmán
****Michelle Bastos Guzmán****
Instrucción import
En el anterior programa se puede observar que, las funciones se usaron con solo
escribir su nombre acompañado de la cadena sobre la cual deben ejecutar la acción
que les corresponde. Pero, no todas las funciones están disponibles de forma
inmediata. Muchas de ellas se encuentran organizadas dentro de módulos, los cuales
se deben cargar en el programa para que sean reconocidas y ejecutadas.
53
Consecuente con la anterior afirmación, la siguiente instrucción permite cargar un

módulo dentro de un programa:
import nombre_módulo
Cuando los módulos contienen muchas funciones y no se requiere cargar (importar)

tantas instrucciones dentro de un programa, se pueden relacionar únicamente las
funciones que se van a utilizar, para ello, se debe escribir la siguiente instrucción:
from nombre_módulo import función1, función2, …, función_n
Tomemos como ejemplo el módulo math, en él se encuentran varias funciones que

como su nombre lo indica, se usan para realizar operaciones matemáticas, entre ellas
están: sqrt() y sin(), que sirven para obtener la raíz cuadrada de un número y el seno
de un ángulo, respectivamente. Para poder utilizarlas dentro de un programa, se
debe importar el módulo math, así:
import math
De esta forma, todas las funciones presentes en este módulo, quedan disponibles
para ser usadas por el programador.
Pero, si lo que se desea es solo importar las funciones sqrt() y sin() del módulo math,
se debe escribir la siguiente instrucción:
from math import sqrt, sin
Hay otra función que resulta de utilidad en el manejo de este tema, con ella se puede
obtener el listado de funciones que hay dentro de un módulo:
dir(nombre_modulo)
Previamente a su uso, se debe importar el módulo a consultar. Ejemplo:
import math
dir(math)
54
Al usar estas dos instrucciones, se visualizará un listado de funciones, similar a este:
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh',

'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees',
'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum',
'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'ldexp', 'lgamma',
'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'perm', 'pi', 'pow', 'prod', 'radians',
'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
Así mismo, para conocer la sintaxis de cualquier función se emplea la siguiente

instrucción:
help(nombre_módulo.nombre_función)
Por ejemplo:
help(math.sqrt)
El resultado se muestra a continuación:
Help on built-in function sqrt in module math:
sqrt(x, /)
Return the square root of x.
Hasta este punto solo le hemos indicado al intérprete de Python que se van a usar
funciones, pero aún no se le ha dado la instrucción de ejecutarla. Para ello, se procede
con la siguiente sintaxis:
nombre_módulo.nombre_función()
Para ejemplarizar esta teoría, se va a hacer uso del módulo math.
55
Módulo math. En este módulo se encuentran algunas constantes y funciones para

realizar cálculos matemáticos. Las más usadas son:
Función Cálculo a realizar

pow(x, n) Encuentra el valor de x elevado a la n.
sqrt(x) Calcula la raíz cuadrada de x
ceil(x) Redondea un número hacia arriba hasta el próximo número entero
floor(x) Devuelve el valor entero redondeado más alto de x
modf(x) Devuelve la parte entera y fraccional de x
cos(x) Devuelve el coseno de x radianes
tan(x) Devuelve la tangente de x radianes
sin(x) Devuelve el seno de x radianes
pi Es una constante con el valor de 3.141592653589793
Ejemplo 2.2. En el siguiente programa se usarán algunas funciones del módulo math.
1) # Funciones del módulo math

2)
3) import math
4)
5) x = 5.2
6) y = 3.8
7)
8) print(pow(3,4))
9) print(math.sqrt(25))
10) print(math.ceil(x))
11) print(math.floor(y))
12) print(math.modf(x))
13) print(math.cos(y))
14) print(math.tan(x))
15) print(math.sin(y))
56
Explicación:
 En la línea número tres se le indica al programa que importe el módulo math, de

esta forma ya se pueden usar las funciones que hacen parte de él. Si trata de
usarlas sin hacer esta importación, el intérprete de Python mostrará un error en
el momento de su ejecución.
 Entre las líneas 8 a la 15, se usan varias funciones matemáticas. Observe con
detalle que desde las líneas 9 a la 15, al nombre de las funciones se les antepuso
el nombre del módulo. Sin él generarían un error en el momento de su ejecución.
No obstante, la función pow() no lo lleva, esto obedece a que ella, además de

pertenecer al módulo math, también hace parte de un grupo denominado
funciones integradas o funciones nativas, la cuales siempre están disponibles
para ser usadas.
 No olvide que si no quiere anteponer el nombre del módulo cuando se vaya a

usar la función, deberá importar directamente las funciones requeridas, así:
from math import sqrt, ceil, floor, modf, cos, tan, sin
Esto, en lenguaje natural se interpretaría así: desde el módulo math importe las
funciones sqrt, ceil, floor, modf, cos, tan, sin
Así las cosas, el código desde la línea 8 hasta la 15 queda de la siguiente manera:
8) print(pow(3,4))
9) print(sqrt(25))
10) print(ceil(x))
11) print(floor(y))
12) print(modf(x))
13) print(cos(y))
14) print(tan(x))
15) print(sin(y))
57
 Suponiendo que el valor de x = 5.2 y el de y = 3.8, los resultados del anterior

programa son los siguientes:
Función Resultado
pow(3, 4) 81
sqrt(25) 5.0
ceil(x) 6
floor(y) 3
modf(x) (0.20000000000000018, 5.0)
cos(y) -0.7909677119144168
tan(x) -1.8856418775197639
sin(y) -0.6118578909427189
Ejemplo 2.3. En el Teorema de Pitágoras se establece que, en todo triángulo

rectángulo el cuadrado de la hipotenusa es igual a la suma de los cuadrados de los
catetos.
h
a
ℎ2 = 𝑎2 + 𝑏 2
Donde:
h: hipotenusa
a y b: catetos
En este ejemplo se codificará un programa en Python que permita calcular el valor de

la hipotenusa de un triángulo, del cual se conoce la longitud de cada uno de sus
catetos.
58
Una posible solución a este enunciado, se plantea a continuación.
1) # Calcula el valor de la hipotenusa de un triángulo rectángulo

2)
3) from math import sqrt
4)
5) a = float(input("Ingrese el valor del primer cateto: "))
6) b = float(input("Ingrese el valor del segundo cateto: "))
7)
8) h = sqrt(a ** 2 + b ** 2)
9)
10) print(f"\nEl valor de la hipotenusa es: {h}")
Explicación:
 En la línea tres se importa desde el módulo math, la función sqrt() que permite
calcular la raíz cuadrada de un número.
 En las líneas 5 y 6, se leen los valores para los catetos y se convierten a datos de
tipo float.
 La línea ocho presenta la fórmula a emplear, en ella se usa la función sqrt(),

recuerde que para poder usarla se importó desde el módulo math (línea tres).
 Finalmente, en la línea diez se imprime el resultado. La secuencia de escape \n

se usa para saltar una línea, es decir, dejar una línea en blanco antes de la
siguiente impresión.
 Vale la pena resaltar que, el módulo math también cuenta con la función hypot(),
con la cual se puede realizar el cálculo de la hipotenusa. Para ello debe hacer los
siguientes ajustes en el programa:
59
La instrucción de la línea tres, se debe reemplazar por:
from math import hypot
La fórmula de la línea ocho, quedaría así:
h = hypot(a, b)
Donde los argumentos a y b, representan los valores de los catetos.
El resto del programa continúa exactamente igual.
Ejemplo 2.4. Para calcular el perímetro de una elipse, se utilizan diferentes fórmulas
que arrojan resultados aproximados.
s
r
Donde: r representa el semieje mayor y s el semieje menor.
Una de las fórmulas más utilizadas para hallar el perímetro de una elipse es:
𝑟2 + 𝑠2
𝑝 ≈ 2𝜋√
2
Así mismo, el matemático indio Ramanujan planteó la siguiente expresión, que hace
un cálculo más aproximado:
𝑝 ≈ 𝜋[3(𝑟 + 𝑠) − √(3𝑟 + 𝑠)(𝑟 + 3𝑠)]
60
Teniendo en cuenta la anterior información, se codificará un programa en Python que

lea los datos de entrada necesarios y calcule e informe el perímetro de la elipse,
usando las dos fórmulas.
Para la solución de este enunciado, se plantea el siguiente programa.
1) # Calcula el perímetro de una elipse

2)
3) from math import sqrt, pi
4)
5) r = float(input("Ingrese el valor del semieje mayor: "))
6) s = float(input("Ingrese el valor del semieje menor: "))
7)
8) formula1 = 2 * pi * sqrt((r ** 2 + s ** 2) / 2.0)
9) formula2 = pi * (3 * (r + s) - sqrt ((3 * r + s) * (r + 3 * s)))
10)
11) print(f"\nFórmula 1: {formula1:.2f}")
12) print(f"Fórmula 2 (Ramanujan): {formula2:.2f}")
Explicación:
 En la línea tres, desde el módulo math se importa la función sqtr() y la constante

pi. Cuando se habla de una constante en programación, se hace referencia a un
elemento cuyo valor no cambia. En Python no existen las constantes, acá
simplemente se está incluyendo una variable llamada pi que ya tiene un valor
predeterminado dentro del módulo math. Esto facilita la programación, ya que
es más fácil escribir pi que el valor de 3.141592653589793 cada que se requiera
hacer un cálculo que involucre a π.
 En las líneas 5 y 6 se leen los datos de tipo float.
 En las líneas 8 y 9 se aplican las dos fórmulas que se proporcionaron en el

enunciado.
61
 Finalmente, en las líneas 11 y 12, se muestran los resultados que arrojan estas
fórmulas.
 No olvide que al usar el formato .2f, en los resultados, se está condicionando la

salida a dos decimales.
 Una vez se ejecute el programa se observará lo siguiente, suponiendo que los

datos de entrada son 3 y 2 respectivamente:
Ingrese el valor del semieje mayor: 3

Ingrese el valor del semieje menor: 2
Fórmula 1: 16.02
Fórmula 2 (Ramanujan): 15.87
Actividad 2.1. Construya un programa en Python que lea los datos correspondientes
para calcular e informar el área de un círculo.
Área de un circulo
Radio
á𝑟𝑒𝑎 = 𝜋 𝑟 2
Para calcular su área, se usa la siguiente fórmula:
á𝑟𝑒𝑎 = 𝜋 𝑟 2
Donde: r es el radio.
62
2.2 Funciones definidas por el usuario o programador
Al llegar a este punto, se hará la inclusión de un nuevo concepto dentro de los

programas. Hasta ahora los ejemplo que se han construido están estructurados para
que sean ejecutado en una forma secuencial, es decir, se ejecuta la primera línea del
programa y así se continúa línea tras línea hasta llegar a la última. Adicionalmente,
todas las instrucciones están juntas. A partir de este momento, se harán programas,
cuyas instrucciones están agrupadas por bloques, los cuales se conocen como
funciones de usuario o programador.
En la parte inicial de este capítulo, se estudiaron algunas funciones que proporciona

el lenguaje Python y para usarlas basta solo con hacerles un llamado, teniendo en
cuenta su sintaxis, en algunos casos hay que importar el módulo al cual pertenecen.
Las funciones que se estudiarán a partir de este momento, ya no son parte de Python,
son funciones creadas por el usuario del lenguaje de acuerdo a las necesidades de la
solución que requiera codificar.
Para escribir una función se deben tener en cuenta la siguiente sintaxis general:
def nombre_función(parámetro1, parámetro2, … , parámetro_n):
Instrucción_1
Instrucción_2
.
.
Instrucción_n
return(valor)
La palabra def, es una de las palabras reservadas y se usa para indicar que lo que
viene a continuación de ella es una función.
nombre_función. Es el identificador que se le da a la función, debe cumplir con las

reglas establecidas para asignar los nombres, estudiadas en el capítulo 1.
63
(parámetro1, parámetro2, … , parámetro_n):. La función puede tener 0, 1 o varios

parámetros separados mediante una coma. En el caso de no tener parámetros, se
deben escribir los paréntesis vacíos. Un parámetro es un identificador que recibe un
valor enviado en el momento que se hace el llamado a la función. Observe que esta
línea debe terminar con dos puntos (:).
Luego de los dos puntos, en la siguiente línea, se encuentran las diferentes

instrucciones que ejecutará la función. Es importante tener en cuenta que estas
instrucciones tienen que escribirse respetando la indentación o sangría que se
aprecia en la anterior forma general, esta parte es conocida como el bloque o cuerpo
de la función. En el caso de no respetar esta sangría el funcionamiento no será el
esperado. Más adelante, se explicará con más detalle esta situación.
return(valor). La palabra reservada return, se usa para devolver valores. En este caso,
el valor es retornado al sitio donde se hizo el llamado a la función. No todas las
funciones tienen que tener un return. Generalmente cuando una función no devuelve
valores, se le conoce con el nombre de procedimiento o subrutina.
Una función puede devolver más de un valor en un mismo return, contrariamente,

también puede usarse un return sin ningún valor, en este caso solo devuelve el
control al sitio donde fue llamada la función.
Como complemento a esta forma general, el manejo de las funciones definidas por
el usuario tiene algunas particularidades que se van a analizar con los siguientes
ejemplos, es por eso que le recomendamos leer atentamente las explicaciones que
se darán en cada programa presentado.
Funciones sin parámetros y sin retorno
Es la forma más básica de una función, se les conoce con el nombre de subrutinas.
Aunque no van a ser muy usadas en este libro es necesario que sean conocidas ya
que, es una herramienta que podría necesitarse en alguna futura implementación.
def nombre_función():
Instrucción_1
Instrucción_2
.
.
64
Instrucción_n
Ejemplo 2.5. Se tomará el ejemplo 1.1, que se trabajó en el capítulo anterior. En él se

leen dos números y se calcula su respectiva suma. Aunque es un ejemplo básico, es
muy práctico para explicar el concepto de funciones y algunos aspectos que son
fundamentales en el manejo de ellas.
La solución que se planteó en el ejemplo 1.1 fue la siguiente:

2)
6) print(suma)
Ahora, aplicando el concepto de función, la solución se aprecia así:
1) # Ejemplo de función. Suma de dos números

2)
3) def sumar():
7) print(suma)
8)
9) sumar()
10)
Explicación:
 En la línea tres se usa la palabra reservada def para definir una función llamada
sumar(). Esta función está compuesta por las instrucciones que hay desde la línea
4 a la 7, en ellas se definen las variables y se leen los datos que proporcione el
usuario. Se ejecuta la operación donde se suman los dos valores almacenados en
las variables numero1 y numero2. Finalmente, se imprime el resultado en la línea
siete.
65
 Hasta este punto del programa, a excepción de la línea tres de esta nueva
solución, las instrucciones son las mismas que las del ejemplo 1.2. Sin embargo,
la función no se ejecuta por sí sola; se debe hacer un llamado o invocación a ella,
esto se logra con la instrucción que hay en la línea nueve: sumar().
 En el momento que el intérprete de Python encuentre la instrucción sumar() de

la línea nueve, se dirige a la cabecera de la función (línea tres) y ejecuta todas las
instrucciones desde la línea 4 a la 7. Seguidamente el control es devuelto al lugar
donde fue llamado y ejecuta lo que haya por debajo, en este caso no hay ninguna
instrucción a ejecutar, dando así fin a la ejecución del programa (línea 10).
Ahondemos un poco más en estas líneas de código:
 Observe que, el bloque de instrucciones que conforman la función sumar(), tiene

indentación, es decir tienen sangría (líneas 4 al 7). Todo lo que esté de esa forma
se conoce como el bloque o cuerpo de la función se ejecutará únicamente cuando
se haga el llamado a la función.
 Ahora suponga que, las líneas de código se escribieron así:
1) # Ejemplo de función. Suma dos números

2)
3) def sumar():
7)
8) print(suma)
9)
10) sumar()
La diferencia con la solución que se viene analizando se encuentra en la línea ocho

de este ejemplo, observe que en la solución anterior esta instrucción print(suma)
ocupaba la línea siete y estaba con la sangría de las demás variables, lo cual indicaba
que era parte del bloque de la función sumar().
66
Con esta nueva estructura del programa, la instrucción print(suma), ya no es un

componente de la función, ahora es una línea independiente dentro del cuerpo del
programa. Si se tratara de ejecutar este programa, se mostraría el siguiente mensaje
de error, señalando que el identificador llamado suma no está definido:
NameError: name 'suma' is not defined
Esta situación obedece a que, la variable suma fue definida dentro de la función (línea
seis) y no puede ser reconocida por fuera de ella, es una variable local a la función.
Esto nos lleva a los conceptos de variable local y global que se analizarán después de
que realice la siguiente actividad.
Actividad 2.2. Usando funciones, escriba la solución en Python para los siguientes
enunciados.
a. Construya un programa que contenga una función llamada pote() que calcule la
potencia de xn.
b. La fórmula para la velocidad es:
𝑥
𝑣=
𝑡
Donde: v = velocidad, x = distancia y t = tiempo.
Construya un programa que le permita calcular la velocidad de un cuerpo del cual

se conoce la distancia y el tiempo empleado.
Variable local y global.
Se denomina variable local, aquella que está definida dentro de una función. Tiene la
característica que solamente es reconocida dentro de la función a la cual pertenece,
por lo tanto, no podrá ser usada en otra parte del programa.
De otro lado una variable global, puede ser reconocida en cualquier parte del
programa.
67
Para ilustrar estos conceptos, revisemos los siguientes ejemplos.
Ejemplo 2.6. Este programa muestra el uso y alcance de una variable local y una
global.
1) # Ejemplo de variable local y global

2)
3) def funcion_uno():
4) var_ejemplo = "Soy local"
5)
6) var_ejemplo = "Soy global"
7) print(var_ejemplo)
8) funcion_uno()
10)
Explicación:
 Para hacer más fácil la explicación, en la línea tres se define una función llamada
funcion_uno(), dentro de ella se ha definido una variable local llamada
var_ejemplo de tipo str. Como valor inicial se le ha asignado la frase "Soy local".
 En la línea seis se define una variable global llamada var_ejemplo donde se

almacena la cadena "Soy global".
 Aunque la variable de la línea cuatro y la variable de la línea seis tienen el mismo

nombre, se trata de dos variable diferentes, la primera (línea cuatro) es local a la
funcion_uno(), es decir, solo es reconocida dentro de esta función. La segunda
(línea seis), es una variable global, o sea, es reconocida en todo el programa.
 Cuando el intérprete de Python inicie con la ejecución del Programa lo primero

que hace es identificar que en la línea tres se definió una función, pero no la
ejecuta hasta que no encuentre el respectivo llamado.
Luego en la línea seis, encuentra la expresión de asignación:
var_ejemplo = "Soy global"
68
En este momento, a la variable var_ejemplo se le asigna el valor de la frase "Soy

global". Como lo puede observar, esta variable no hace parte de ninguna función,
es una variable global.
 La instrucción de la línea siete imprime el valor de var_ejemplo, es decir, en

pantalla se visualiza la frase: Soy global.
 En la línea ocho, se hace el llamado a la función con la instrucción:
funcion_uno()
En esta parte del programa, el control pasa a la cabecera de la función (línea tres)
e inicia ejecutando la siguiente instrucción:
var_ejemplo = "Soy local"
Es así como la variable var_ejemplo, almacena la cadena "Soy local". Recuerde

que esta variable solo es reconocida dentro de la función donde fue definida.
 Una vez se haya ejecutado esta instrucción, el control del programa regresa a la
siguiente instrucción de donde fue llamada, es decir, regresa a ejecutar lo que
hay en la línea nueve.
 En la línea nueve, una vez más se encuentra la instrucción print(var_ejemplo), la

cual imprime en pantalla el siguiente mensaje:
Soy global
Algunos se estarán preguntando, ¿por qué imprimió Soy global y no imprimió Soy
local?
Si retomamos la explicación que se dio en el punto anterior, la asignación de la

frase "Soy local" se hizo sobre la variable que está dentro de funcion_uno() y solo
es reconocida en ella, mientras que la impresión de la línea nueve, hace
referencia a la variable global que tiene almacenado el valor "Soy global".
 Es importante hacer énfasis en las instrucciones que hay entre las líneas 6 y 9,
inclusive, ellas conforman la lógica principal del programa, con ello se quiere
69
significar que, la ejecución del programa se realizará de acuerdo con la secuencia

que allí se muestra.
Ejemplo 2.7. Se modificará el anterior ejemplo para que se imprima el valor de la

variable local.

2)
6)
9) funcion_uno()
Explicación:
 La diferencia con el ejemplo anterior está en la línea cinco, en ella se usó la

instrucción:
print(var_ejemplo)
Esta instrucción hace parte de la función funcion_uno(), por lo tanto, la impresión

se realiza con base al contenido de la variable local var_ejemplo, que para este
punto del programa es la cadena "Soy local".
El resto de las instrucciones del programa permanecen sin modificación alguna.
 Una vez se ejecute el programa se obtiene la siguiente salida:
Soy global
Soy local
Soy global
El primer mensaje "Soy global", corresponde al print de la línea ocho del

programa. El mensaje "Soy local", es producto de la ejecución de la función. En la
línea nueve se hace el llamado a la función funcion_uno() y al ejecutarla, se hace
70
la impresión con la función print() de la línea cinco. El último mensaje "Soy global"
es de la función print() de la línea diez que, corresponde al valor de la variable
global.
Convirtiendo una variable local en variable global
Una variable que haya sido definida dentro de una función y que por naturaleza es
una variable local, puede dársele la característica de variable global. Para ello se usa
la siguiente sintaxis:
global nombre_variable
La palabra reservada global permite que una variable local, se convierta en una
variable global y de esa forma pueda ser utilizada en cualquier parte del programa.
Ejemplo 2.8. Este programa muestra el uso de la palabra reservada global.

2)
4) global var_ejemplo
7)
10) funcion_uno()
Explicación:
 En este ejemplo se incluyó la palabra reservada global. Con ella se definen

variables globales para que sean reconocidas no solo dentro de la función, sino
también, en todo el programa.
 En la línea cuatro se usó la siguiente sentencia:
global var_ejemplo
71
Así las cosas, la variable var_ejemplo a pesar de estar dentro de la función

funcion_uno(), podrá ser utilizada en todo el programa, por lo tanto, sus
resultados son diferentes a los ejemplos anteriores. Una vez sea ejecutado, en
pantalla se visualizará lo siguiente:
Soy global
Soy local
Soy local
Las dos primeras impresiones tienen la misma explicación dada en el ejemplo

anterior, el último mensaje "Soy local", obedece a la situación que cuando se hizo
el llamado a la función funcion_uno(), la variable tomó ese valor y al ser global,
permanecerá con él hasta el momento en que sea cambiado por otra expresión
de asignación.
Funciones con parámetros
Es el momento de dar un paso más en la construcción de funciones. Los siguientes

ejemplos incluirán el uso de parámetros.
Ya se había dicho que, un parámetro es un identificador que recibe un valor enviado

en el momento que se hace el llamado a la función.
Así mismo, anteriormente se dio la forma general para definir una función, acá se
hará énfasis en lo que refiere a los parámetros:
def nombre_función(parámetro1, parámetro2, …, parámetro_n)

instrucción
Para que la función se ejecute se debe hacer el llamado, en este caso, se deben incluir
los valores que recibirán los parámetros de la función, así:
nombre_función(argumento1, argumento2, …, argumento_n)
72
A la función debe enviársele los argumentos1 en el mismo orden en que se

encuentren los parámetros en la definición, es decir, el valor del argumento1 pasará
al parámetro1, el valor del argumento2 pasará al parámetro2 y así sucesivamente.
Aunque este orden puede cambiarse, como se verá más adelante.
Ejemplo 2.9. Se retomará el ejemplo 2.5, donde se suman dos números, pero esta
vez se le agregarán parámetros a la función.
1) # Suma con parámetros

2)
3) def sumar(num1, num2):
4) suma = num1 + num2
5) print(suma)
6)
9)
10) sumar(numero1, numero2)
11)
Explicación:
 La definición de la función presenta dos parámetros, num1 y num2. Ellos se

encargarán de recibir los valores que sean envidos en el momento de hacer el
llamado a la función.
 En las líneas 7 y 8 se hace la lectura de los datos de entrada y se almacenan en

las variables numero1 y numero2, respectivamente.
 Luego, en la línea diez se hace el llamado de la función sumar(). Es importante

resaltar que, a diferencia de los ejemplos anteriores, en este llamado se incluyen
1 Algunos autores no hacen distinción entre parámetros y argumentos. En este libro se hablará de
argumentos para referirse a los valores que se envían a los parámetros de la función que se invoque.
73
dos variables, en ellas están almacenados los datos que digitó el usuario cuando
se le solicitaron los dos números como datos de entrada.
sumar(numero1, numero2)
Estas variables reciben el nombre de argumentos de la función. Los valores que

hay en ellas, son entregados a los parámetros num1 y num2 que se definieron en
la línea tres. Nótese que, al efectuar la operación de adición en la línea cuatro de
la función, se usan estos dos parámetros en la expresión matemática, los cuales
son tratados como variables locales.
 La función print() de la línea cinco, informa el resultado de la operación. El control

del programa regresa al sitio donde fue llamado y ejecuta la siguiente instrucción,
en este caso, al no haber más se da por terminado el programa.
Ejemplo 2.10. Aprovechando el ejemplo anterior, se explicará el uso de la instrucción

return dentro de una función.
1) # Suma con parámetros y retorno

2)
3) def sumar(num1, num2):
4) suma = num1 + num2
5) return suma
6)
9)
10) resultado = sumar(numero1, numero2)
11) print(f"El resultado de la suma es: {resultado}")
74
Explicación:
 Las diferencias con ejemplo anterior son las siguientes:
1. La función print() del ejemplo anterior, fue reemplazada por la instrucción:
return(suma)
Esta palabra reservada retorna o devuelve el valor que haya contenido en la

variable suma, al sitio donde fue llamada la función.
2. En la línea diez, se hizo el llamado a la función, pero en esta ocasión se hizo

de la siguiente manera:
resultado = sumar(numero1, numero2)
Cuando se llama la función se hace con dos argumentos, numero1 y numero2,

ellos se encargan de llevar los valores que tengan almacenados y
entregárselos a los parámetros de la función (num1 y num2).
Cuando se ejecute la función, se realiza la suma en la línea cuatro. Luego en

la línea cinco la instrucción return suma, se encarga de retornar el valor al
lugar donde fue llamada la función. Ese valor es asignado a la variable
resultado.
3. La última diferencia está en la línea once, en ella se imprime el resultado de

la suma. Recuerde que, en el ejemplo anterior esa salida de resultados se
encontraba dentro de la función, ahora hace parte de la lógica principal del
programa.
 Por otro lado, la salida de este programa se puede simplificar; para ello observe
como las líneas 10 y 11 se pueden reemplazar por una sola instrucción:
print(f"El resultado de la suma es: {sumar(numero1, numero2)}")
75
La función sumar() está siendo usada dentro de la función print(), de esta forma
el resultado de la operación se imprime directamente sin necesidad de usar la
variable resultado.
Ejemplo 2.11. Aunque en el módulo math existe la función pow() para calcular la
potencia de un número, se va a construir una función de usuario para realizar el
cálculo de xn.
1) # Calcula la potencia de x elevado a la n

2)
3) def pote(x, n):
4) resultado = x ** n
5) return resultado
6)
7) base = float(input("Digite la base: "))
8) exponente = float(input("Digite el exponente: "))
9)
10) potencia = pote(base, exponente)
11) print(f"{base} elevado a la {exponente} es: {potencia}")
Explicación:
 Se define la función pote(x, n), con los parámetros x y n. Dentro de ella se realiza
el cálculo y se retorna el valor que se almacene en la variable resultado.
 En las líneas 7 y 8 se leen dos números de tipo float, que representan la base y el
exponente de la operación.
 En la línea diez se hace el llamado a la función, enviando como argumentos los

valores leídos.
 La función de la línea once imprime el resultado. Suponiendo que los datos de

entrada son: base = 5 y exponente = 3, el resultado se visualizaría así:
5.0 elevado a la 3.0 es: 125.0
76
Ejemplo 2.12. Se tomará el mismo ejemplo anterior para ilustrar que los argumentos
pueden estar en diferente orden a los parámetros.
1) # Los argumentos tienen un orden diferente a los parámetros

2)
3) def pote(x, n):
5) return resultado
6)
9)
10) potencia = pote(n = exponente, x = base)
11) print(f"{base} elevado a la {exponente} es: {potencia}")
Explicación:
 La única diferencia entre el ejemplo anterior y este, se encuentra en la línea diez.

En este los argumentos tienen diferente orden a los parámetros definidos en la
función. Para poder hacer esto, es necesario que en el llamado se incluyan los
nombres de los parámetros, así:
potencia = pote(n = exponente, x = base)
Se llama a la función pote() y en los argumentos se hace una asignación. Usando

el nombre que tienen los parámetros se especifica que valor deben tomar.
Ejemplo 2.13. En este ejemplo se mostrará cómo implementar una función de

usuario para leer un dato de tipo flotante, adicionalmente, se usarán dos funciones
en un solo programa. Se continuará con el mismo ejemplo de la potencia que se viene
trabajando.
77
El programa planteado es el siguiente:
1) # Potencia usando retorno. Se implementa una función para leer un float

2)
3) def pote(x, n):
5) return resultado
6)
7) def leer_float(mensaje):
8) numero = float(input(mensaje))
9) return numero
10)
11) base = leer_float("Digite la base: ")
12) exponente = leer_float("Digite el exponente: ")
13)
14) print(f"{base} elevado a la {exponente} es: {pote(base, exponente)}")
Explicación:
 No se entrará en detalle con varios de los aspectos que ya fueron explicados con
el ejemplo 2.11.
La explicación se concentrará en la nueva función, definida en la línea siete:
defleer_float(mensaje):
numero=float(input(mensaje))
return numero
 Se define una función leer_float(mensaje):
Tiene un parámetro llamado mensaje, este recibirá una cadena de caracteres

cuando la función sea llamada desde otro sitio del programa.
La siguiente línea de la función, lee un dato str que es convertido a float. La

función input(mensaje), tiene como parámetro a mensaje; con él se busca que, al
78
ejecutarse se imprima la cadena de caracteres que le llegue cuando se haga el

Finalmente, la instrucción return, retorna el valor de la variable numero, que

corresponde a un dato de tipo float que ha sido digitado por el usuario del
programa.
Aunque analizando a fondo esta función, es casi igual a leer el dato como se venía
haciendo hasta el ejemplo anterior. La idea con ella es usarla como apoyo
didáctico para comprender mejor el uso de las funciones; además, para que el
lector se vaya familiarizando con estas instrucciones, ya que cuando se estudie el
tema de ciclos, se le anexarán otras funcionalidades.
 Las instrucciones de las líneas 11 y 12, se encargan de llamar a la función, así:
Leer_float()
base=leer_float("Digite la base: ")
exponente = leer_float("Digite el exponente: ")
Cada una de ellas tiene una cadena como argumento, la cual es entregada al
parámetro denominado mensaje, que se encuentra en la función
leer_float(mensaje) (línea siete).
Los valores que retorne la función leer_float(), en cada llamado, son asignados a
las variables base y exponente, respectivamente.
 Algo que se debe tener en cuenta es que, cuando se hace el llamado a una
función, ésta ya debe estar definida.
Ejemplo 2.14. Una empresa de buses urbanos, desea un programa que permita
calcular cuánto devenga en total un conductor en un día domingo. El turno dominical
se paga con un incremento del 30% sobre el valor de turno normal, además por cada
pasajero que movilice, al conductor se le otorga un bono de $200.
1) # Calcula el valor a devengar de un conductor de bus

2)
3) def calcular_devengado(pasajeros, valor_turno):
4) BONO = 200
79
5) bono_pasajeros = BONO * pasajeros

6) devengado = valor_turno * 1.30 + bono_pasajeros
7) return devengado
8)
11) return numero
12)
13) def leer_int(mensaje):
14) numero = int(input(mensaje))
15) return numero
16)
17) def leer_cadena(mensaje):
18) cadena = input(mensaje)
19) return cadena
20)
21) print("Digite los siguientes datos\n")
22) nombre = leer_cadena("Nombre del conductor: ")
23) valor_turno = leer_float("Valor turno normal: ")
24) pasajeros = int(input("Cantidad de pasajeros: "))
25)
26) devenga = calcular_devengado(pasajeros, valor_turno)
27) print(f"\n{nombre}, usted devengará ${devenga}")
Explicación:
Este ejemplo es importante en el sentido que involucra un número mayor de

funciones, adicionalmente maneja datos de varios tipos. Como el manejo de las
funciones que se implementan es similar a lo que ya se ha explicado con anterioridad
en los otros programas, solamente se hará énfasis en algunos nuevos aspectos.
 Se definen cuatro funciones, cuyas instrucciones están entre las líneas 3 y 19:
def calcular_devengado(pasajeros, valor_turno). Permite calcular el total

devengado del conductor. Recibe en sus parámetros, el número de pasajeros y el
valor de un turno normal.
ɷ En la línea cuatro se hizo la siguiente declaración:
80
BONO = 200
Se usó una “constante” para definir el valor del bono que recibirá el
conductor por cada pasajero movilizado, en este caso es de $200.
Recuerde que Python no tiene constantes propiamente dichas. Este valor

puede ser cambiado y no se presentará ningún error en la ejecución.
Por convención, o buena práctica, se acostumbra que los identificadores que

vayan a ser usados como “constantes” se escriban en mayúsculas.
ɷ En la línea seis, se usó el valor literal de 1.30, esto con el fin de incrementar
el valor del turno normal en un 30%.
Las otras tres funciones definidas son las siguientes:
 def leer_float(mensaje). Permite leer un dato str y convertirlo en float.
 def leer_int(mensaje). Permite leer un dato str y convertirlo en int.
 def leer_cadena(mensaje). Permite leer una cadena de caracteres.
Como se dijo anteriormente, estas funciones son muy similares a leer el dato de
forma normal, pero al llegar al tema de ciclos se implementarán otras
funcionalidades.
 Entre las líneas 21 a 27, se encuentra la lógica principal del programa.
ɷ Se solicitan y se leen los datos:
print("Digite los siguientes datos\n")

nombre = leer_cadena("Nombre del conductor: ")
valor_turno = leer_float("Valor turno normal: ")
pasajeros = int(input("Cantidad de pasajeros: "))
81
ɷ Se hace el llamado a la función calcular_devengado(pasajeros, valor_turno),

pasando como argumentos los valores leídos. El valor retornado por la
función es almacenado en la variable devenga.
devenga = calcular_devengado(pasajeros, valor_turno)
ɷ Finalmente, se imprime el nombre del conductor con el valor devengado:
print(f"\n{nombre}, usted devengará ${devenga}")
 Una posible ejecución del programa podría verse así:
Digite los siguientes datos
Nombre del conductor: Juan

Valor turno normal: 70000
Cantidad de pasajeros: 225
Juan, usted devengará $136000.0
Actividad 2.3. Usando funciones con parámetros y retorno, escriba la solución en

Python para los siguientes enunciados.
a. Lea un número de dos cifras y halle la suma entre los dos dígitos que lo
conforman. Por ejemplo, si el número leído es 59 el resultado será 14 (5 + 9).
Nota: se supone que el número leído está en el rango 10 a 99.
b. La siguiente fórmula permite hallar y conocer la suma de los cuadrados de los

números desde 1 hasta un valor n:
𝑛(𝑛 + 1)(2𝑛 + 1)
𝑠𝑢𝑚𝑎 =
6
Este ejercicio se desarrolló como ejemplo en el capítulo anterior. Reescríbalo

usando una función llamada calcular_cuadrado(), la cual debe recibir como
parámetro el valor de n y retornar la sumatoria.
82
c. Para calcular el porcentaje de crecimiento de ventas en un negocio de un

periodo dado a otro, se aplica la siguiente fórmula:
𝑣𝑓
𝑝𝑐 = ( ∗ 100) − 100
𝑣𝑖
Donde:
pc: porcentaje de crecimiento

vf: ventas finales
vi: ventas iniciales.
d. Lea la fecha actual en el formato dd-mm- aaaa, luego lea un número entero
positivo, el cual representará una cantidad de días futuros. Calcule e informe la
fecha futura, partiendo de la fecha inicial y teniendo en cuenta la cantidad de
días leídos. Ejemplo:
Fecha de hoy: día 1, mes 3, año 2019

Días futuros: 45
Fecha futura: 16-04-2019
Nota: se tomarán 360 días por año.
e. Reescriba los ejercicios propuestos en la actividad 1.6 del capítulo anterior,

aplicando el tema de funciones del presente capítulo.
2.3 Funciones lambda
Es un tipo de función de usuario o programador. Tienen una escritura simplificada. Al

igual que las anteriores funciones estudiadas, consta de nombre, parámetros y una
operación sencilla; la palabra reservada return no está presente, pero el resultado es
retornado de forma automática. Para definir una función lambda se usa la siguiente
sintaxis:
nombre_función = lambda parámetro1, parámetro2, …, parámetro_n: instrucciones
83
Como se puede observar, la sintaxis es muy simple. Se escribe el nombre de la

función, respetando las reglas establecidas para el nombre de identificadores, note
que el nombre no requiere de los paréntesis. Seguidamente va el operador de
asignación igual (=) junto con la palabra reservada lambda, indicando así que se trata
de este tipo de función; posteriormente se escriben los parámetros, separados con
comas (,) y finalizan con los dos puntos (:). Por último, va la instrucción (operación)
que asignará el resultado a la función, para que sea retornado de manera automática.
Ejemplo 2.15. Con el propósito de ser más didácticos, se retomará el ejemplo 2.10
que se ha solucionado de diferentes maneras; de esta forma el lector puede ir viendo
su evolución y la diversidad de soluciones de cualquier problema. Recuerde que el
ejercicio consiste en leer dos números y realizar la suma entre ellos.
La solución propuesta, usando una función lambda es la siguiente:
1) # Suma usando una función lambda

2)
3) sumar = lambda num1, num2: num1 + num2
4)

7)
8) resultado = sumar(numero1, numero2)

9) print(f"El resultado de la suma es: {resultado}")
Explicación:
 En la línea tres se definió una función lambda llamada sumar. Al contrario de los
ejemplos anteriores este tipo de funciones no requiere de los paréntesis. La
función presenta dos parámetros num1 y num2 que se separan de una expresión
matemática mediante dos puntos (:).
 La expresión num1 + num2, realiza la suma de los dos números. El resultado se

asigna a la función sumar, que en este caso actúa como si fuera una variable.
84
 El valor que se almacena en la función sumar se retorna al lugar donde fue

llamada.
 El resto del programa es exactamente igual al del ejemplo 2.10. El llamado a la

función se hace de la misma forma como se ha venido explicando en los
anteriores programas:
resultado = sumar(numero1, numero2)
Ejemplo 2.16. En este ejemplo se calcula el valor de una potencia (xn), usando una
función lambda.
El programa propuesto es el siguiente:
1) # Cálculo de una potencia usando una función lambda

2)
3) pote = lambda x, n: x ** n
4)
7)
8) resultado = pote(base, exponente)
9) print(f"{base} elevado a la {exponente} es: {resultado}")
Explicación:
 En la línea tres se define una función lambda llamada pote, tiene como
parámetros a x y n, que recibirán los valores cuando sea llamada la función. La
potencia la calcula mediante la expresión x ** n. El resultado es asignado a pote
y retornado al sitio donde sea llamada.
 Al igual que todos los programas anteriores, se hace la lectura de los datos (líneas
5 y 6).
85
 En la línea ocho, se hace el llamado a la función, enviando como argumentos los

valores almacenados en las variables base y exponente. El valor que retorne la
función se asigna a la variable resultado.
Actividad 2.4. Usando funciones lambda, solucione los siguientes enunciados.
a. Calcule el área de un triángulo usando la siguiente fórmula:
𝑏∗ℎ
á𝑟𝑒𝑎 =
2
Donde:
b: base
h: altura
b. Se tienen una cantidad de dinero en dólares, determinar su equivalente en pesos

colombianos. Tenga en cuenta la tasa de cambio actual.
2.4 Módulos
Al inicio de este capítulo se explicó el uso de los módulos, pero se hizo para usar las
funciones propias del lenguaje. Ahora se dará un ejemplo de cómo crear y usar un
módulo creado por el usuario del lenguaje.
Si olvidó los conceptos vistos anteriormente, es importante que los estudie

nuevamente.
Ejemplo 2.17. Este ejemplo consiste en construir un módulo que contendrá tres
funciones. Con ellas se podrá calcular el área de alguna de las siguientes figuras
geométricas: cuadrado, rectángulo o triángulo.
86
En primer lugar, se creará el módulo con el nombre de areas.py. Este es el nombre

que debe tener el archivo (módulo) que contendrá las funciones. Este archivo tendrá
la siguiente estructura:
1) # Módulo de áreas de figuras geométricas

2)
3) def cuadrado(lado):
4) return lado * lado
5)
6) def rectangulo(base, altura):
7) return base * altura
8)
9) def triangulo(base, altura):
10) return (base * altura) / 2.0
Explicación:
 Se han creado tres funciones de usuario dentro de un archivo llamado areas.py,

denominadas cuadrado(), rectangulo() y triangulo(). Este archivo es el módulo
con el cual trabajar.
 Cada función dentro del módulo calcula el área de una figura geométrica. Los
valores para realizar el cálculo los reciben a través de los parámetros que tienen
definidos.
 Una vez realicen el cálculo respectivo, retornan el valor obtenido al sitio de donde
se les haga el llamado.
Al crear este módulo, ya no va a ser necesario que el programa que lo use tenga la
función escrita dentro de él, solo basta con importarlo y hacer el llamado a la función
requerida.
El segundo paso de este ejemplo es crear el programa que hará uso del módulo
llamado areas.py.
87
El siguiente es el programa propuesto:
1) # Ejemplo del uso de módulos

2)
3) import areas
4)
5) print(f"El área del triángulo es: {areas.triangulo(10, 5)}")
6) print(f"El área del cuadrado es: {areas.cuadrado(6)}")
7) print(f"El área del rectángulo es: {areas.rectangulo(3, 10)}")
Explicación:
 El programa permite calcular el área de un triángulo, un cuadrado y un

rectángulo.
 En la línea tres se hace la importación del módulo llamado areas. Con esto se
logra que, las funciones que hay escritas dentro de él, queden disponibles para
que el programa pueda usarlas.
 En las líneas 5, 6 y 7 se hace el llamado a las funciones: triangulo(), cuadrado() y

rectángulo().
Para este llamado a cada función se le debe anteponer el nombre del módulo:
areas.triangulo(10, 5)
areas.cuadrado(6)
areas.rectangulo(3, 10)
En este ejemplo, los argumentos se han enviado como valores literales, pero
también funcionará correctamente si el usuario los proporciona a través de una
entrada de datos y en su lugar se envían los valores capturados.
88
Actividad 2.5. Con esta actividad practicará el uso de módulos.
a. En los anteriores ejemplos se han trabajado las siguientes funciones de

programador para leer los datos de entrada:
leer_float(mensaje)
leer_int(mensaje)
leer_cadena(mensaje)
Con ellas debe crear un módulo llamado leer.py. Si desea puede cambiar el
nombre de las funciones.
b. Modifique el programa del ejemplo 2.17, de tal forma que los datos para calcular
las figuras geométricas sean solicitados al usuario del programa. En la lectura de
esos datos, debe hacer uso del módulo leer.py creado en el punto anterior de esta
actividad.
89
CAPÍTULO 3
3 ESTRUCTURA DE
DECISIÓN
Objetivos:
 Conocer las diferentes estructuras de decisión que proporciona el
lenguaje.
 Determinar que estructura de decisión usar dependiendo del problema
a resolver.
 Construir programa en Python utilizando estructuras de decisión.
Estructuras de decisión
Una decisión en programación es una estructura condicional que, le permite al

computador elegir las instrucciones que ejecutará dependiendo del resultado de una
expresión relacional o lógica. En el capítulo 1 se estudiaron este tipo de expresiones,
las cuales arrojaban un resultado True o False.
En Python las decisiones se programan con la instrucción if, la cual presenta la

siguiente forma general:
if condición:
Instrucciones_T
else:
Instrucciones_F
La palabra reservada if le indica al intérprete del lenguaje que, debe evaluar una
condición donde se obtendrá un resultado True (verdadero) o False (falso). Esta
condición está representada por una expresión relacional o lógica. Si el resultado es
True, ejecutará a Instrucciones_T; por el contrario, si es False, ejecutará a
Instrucciones_F. Observe que la condición finaliza con dos puntos (:).
Instrucciones_T: representa la instrucción o bloque de instrucciones que ejecutará el

programa cuando la condición es True (verdadera). Todas las instrucciones que
pertenezcan a este bloque, deben conservar la misma sangría.
La palabra reservada else, es interpretada como “en caso contrario”, indicando así
que en el caso de que la condición del if, sea False, se ejecuta Instrucciones_F.
Instrucciones_F: representa la instrucción o bloque de instrucciones que ejecutará el

programa cuando la condición es False (falsa). Todas las instrucciones que
pertenezcan a este bloque, deben conservar la misma sangría.
Si se ejecuta Instrucciones_T, no se ejecutará Instrucciones_F, o viceversa.
91
De manera gráfica, la forma general de esta estructura se visualiza así:
Conviene subrayar que, esta forma general puede presentar algunas variaciones que
se estudiarán a lo largo del capítulo.
A continuación, se plantean varios enunciados para ejemplarizar la forma de operar

de esta estructura condicional.
Ejemplo 3.1 Se considera que un número es positivo si es mayor o igual a 0. Este

ejemplo lee un número dado por el usuario e informa si es positivo o negativo.
Aunque el cero se considera un número neutro, para este ejemplo se tomará dentro
del conjunto de los negativos.
El programa que se propone como solución a este enunciado, es el siguiente:
1) # Lee un número y determina si es positivo o negativo

2)
3) numero = int(input("Ingrese un número: "))
4)
5) if numero > 0:
6) print("Es positivo")
7) else:
8) print("Es negativo")
92
Explicación:
✧ En la línea tres se hace la lectura de un número int.
✧ Sobre la línea cinco se plantea la siguiente condición, utilizando la instrucción if:
if numero > 0:
Esta condición corresponde a una expresión relacional, donde se compara si el

número digitado es mayor a 0. Dicha expresión termina con dos puntos (:)
Si esta condición arroja un resultado True (verdadero), ejecutará la instrucción

que hay en la línea seis:
print("Es positivo")
✧ En la línea siete se escribió la siguiente instrucción:
else:
Ella indica “en caso contrario”, es decir, en caso de que la condición no sea
verdadera se ejecuta la instrucción de la línea ocho:
print("Es negativo")
✧ Una vez se haya ejecutado la instrucción de la línea seis o la instrucción de la línea

ocho, el control del programa se sale de la estructura de decisión y se da por
terminada su ejecución.
Ejemplo 3.2. El siguiente programa lee un número entero y determina si es un

número par o impar.
Los números pares son aquellos que tienen división exacta entre 2, lo cual quiere
decir que al dividirlos entre 2, no queda residuo.
93
De acuerdo con la anterior definición, se plantea la siguiente solución:
1) # Determina si un número es par o impar

2)
3) def es_par(numero):
4) if(numero % 2 == 0):
5) es_num_par = True
6) else:
7) es_num_par = False
8) return es_num_par
9)
12) return numero
13)
14) numero = leer_int("Digite un número entero: ")
15)
16) if(es_par(numero)):
17) print(f"{numero} es un número par")
18) else:
19) print(f"{numero} es un número impar")
Explicación:
La explicación se hará conforme a como el intérprete de Python ejecuta el programa.
✧ En este ejemplo se ha retomado el uso de funciones. Se definieron leer_int() que

se trabajó en el capítulo anterior y la función es_par().
✧ En la línea 14 se solicita un número entero, mediante la función leer_int(), la cual

se explicó detalladamente en el capítulo 2.
✧ La línea 16 presenta la instrucción if, con la cual se tomará una decisión:
if es_par(numero):
94
Analizando con detalle esta sentencia, se observa que la expresión está

conformada por el llamado a la función es_par(), la cual devolverá el valor True
o False.
Cuando el intérprete de Python llegue a este punto, dirigirá el control a la

función es_par(numero), que se encuentra entre las líneas 3 a 8. Este llamado
tiene como argumento el valor que hay almacenado en la variable numero, dato
que es digitado por el usuario del programa.
 Ahora bien, revisando las instrucciones de la función es_par(), se tiene:
def es_par(numero):
if(numero % 2 == 0):
es_num_par = True
else:
es_num_par = False
return es_num_par
El cuerpo de la función está compuesto por la siguiente instrucción if:
if numero % 2 == 0:
Esta expresión relacional está compuesta a su vez, por una expresión matemática:
numero % 2
Ella calcula el módulo de numero dividido entre 2. Recuerde que el módulo es el

residuo entero de una división. Este resultado es comparado con el 0.
if numero % 2 == 0:
Así las cosas, esta expresión se debe interpretar de la siguiente manera: si al dividir
a numero entre 2, el módulo es igual a 0.
Se deduce entonces que, si el módulo es igual a 0, la división es exacta. Por lo

tanto, el valor almacenado en la variable numero es par.
95
Si esta expresión es verdadera, se ejecuta la instrucción de la línea cinco, en la cual

se asigna el valor True a la variable local es_num_par.
En la línea seis, se encuentra la palabra reservada else, que se interpreta como “en
caso contrario”, o sea, en caso de que la condición sea falsa, ejecute la instrucción
de la línea siete, en la cual se asigna el valor de False a la variable es_num_par.
Una vez sea asignado el valor True o False, se ejecuta la línea ocho, de donde se
retorna el valor que tenga la variable es_num_par al sitio donde fue llamada la
función.
✧ Seguidamente, es analizado el resultado de la condición de la instrucción if de la

línea 16 y dependiendo de este, se ejecuta la parte verdadera o la parte falsa.
Si se retornó un valor True, se ejecutará la instrucción de la línea 17, informando

que es un número par. En caso contrario, se ejecutará la instrucción de la línea 19,
donde informa que es un número impar.
Luego de ejecutar una de estas dos instrucciones, se termina la ejecución del

programa.
✧ Como parte de las buenas prácticas que se deben tener en programación, analice
que los dos bloques de instrucciones que se muestran a continuación producen
iguales resultados, pero se recomienda usar el de la columna derecha.
Evitar esta práctica Se sugiere utilizar esta forma

def es_par(numero): def es_par(numero):
if numero % 2 == 0: if(numero % 2 == 0):
return True es_num_par = True
else: else:
return False es_num_par = False
return es_num_par
Una buena práctica de programación es utilizar un solo retorno dentro de las

funciones y debe localizarse como la última instrucción.
96
Actividad 3.1. Construya un programa para cada uno de los siguientes enunciados.
a. Lea un número positivo de dos cifras y encuentra la suma entre ellas. En el

caso de no ser positivo o de dos cifras, se debe informar dicha situación.
b. Lea dos números y halle la división del primero entre el segundo. En caso de
que el segundo sea un 0, imprima un mensaje que diga que la división entre
0 es indeterminada.
3.1.1 if sin else
Ahora bien, continuando con la instrucción if se tiene que, en una decisión no

necesariamente debe estar presente la palabra else:
if condición:
Instrucciones_T
De esta forma, solo se ejecutará Instrucciones_T en el caso de que la condición sea

True. Si la condición es False, no se realizará ninguna acción relacionada con la
instrucción if. Gráficamente, se visualiza así:
97
A continuación, se desarrollará un ejemplo usando esta variación de la instrucción if.
Ejemplo 3.3 En este programa se calcula el valor a pagar por la compra de un artículo.
Si el precio del artículo es mayor o igual a $1500000 se aplicará un descuento del 13%
sobre el precio, en caso contrario no tendrá descuento. Se debe informar: el precio
del artículo, el valor del descuento y el valor a pagar.
A continuación, se plantea una posible solución.
1) # Determina el valor a pagar por una compra de un artículo

2)
5) return numero
6)
7) def valor_dcto(precio):
8) porcentaje_descuento = 0.0
9)
10) if precio >= 1500000:
12)
13) valor_descuento = precio * porcentaje_descuento
14) return valor_descuento
15)
16) precio = leer_float("Precio del artículo: ")
17)
18) valor_descuento = valor_dcto(precio)
19) valor_pagar = precio - valor_descuento
20)
21) print(f"El precio del artículo es: {precio}")
22) print(f"El valor del descuento es: {valor_descuento}")
23) print(f"El valor a pagar es: {valor_pagar}")
98
Explicación:
La explicación se hará conforme el intérprete de Python ejecuta el programa.
✧ Luego de solicitar el precio del artículo en la línea 16 y leerlo mediante la función

leer_float(), se ejecuta la siguiente expresión, ubicada en la línea 18:
valor_descuento = valor_dcto(precio)
Con ella se hace el llamado a la función valor_dcto(precio), enviando como

argumento el valor de la variable precio. En este momento el control del
programa se dirige hacia la función que se encuentra entre las líneas 7 y 14:
def valor_dcto(precio):
porcentaje_descuento = 0.0
if precio >= 1500000:

porcentaje_descuento = 0.13
valor_descuento = precio * porcentaje_descuento

return valor_descuento
El valor de la variable precio es entregado al parámetro de la función

valor_dcto(precio). Observe que el parámetro tiene el mismo nombre de la
variable global (precio) que se usó en la línea 16 para almacenar el valor digitado
por el usuario. En la línea 18 se envía como argumento el valor capturado en
dicha variable.
Analizando las instrucciones de la función se tiene que, la primera asigna un

valor inicial de 0.0 a la variable local porcentaje_descuento. Luego, en la línea
diez se plantea una condición, donde se pregunta que si el precio es mayor o
igual a 1500000. Si esta expresión es True, entonces se procede a asignar el valor
de 0.13 a la variable porcentaje_descuento; recuerde que el 13% debe
expresarse como 0.13. En el caso de que esta condición, sea False, resultado que
se da si el precio del artículo es menor a 1500000, no se ejecuta ninguna
instrucción relacionada con el if y la variable porcentaje_descuento conserva el
valor de 0.0, asignado en la línea ocho.
99
Independientemente del resultado de la condición del if, se procede a ejecutar

las siguientes instrucciones:
valor_descuento = precio * porcentaje_descuento

return valor_descuento
Con ellas se está calculando el valor del descuento y devolviendo, a la línea 18,
el resultado obtenido en la variable local valor_descuento. Este valor es
almacenado en la variable global valor_descuento. Recuerde que, aunque ambas
variables tengan el mismo nombre, se trata de dos variables diferentes, una es
local a la función y la otra es global al programa.
✧ En la línea 19 se hace el cálculo del valor a pagar y posteriormente, en las líneas

21, 22 y 23 se imprimen los resultados que solicita el enunciado.
3.1.2 Decisiones anidadas

Una instrucción if puede contener otra u otras instrucciones if. Las cuales dependen
de las decisiones más externas. Las decisiones anidadas pueden visualizarse de la
siguiente manera:
100
Para entender mejor este concepto, se analizarán los siguientes ejemplos.
Ejemplo 3.4. De acuerdo al ejemplo 3.1, se hará una modificación de tal forma que
se leerá un número entero y se determinará si es positivo, negativo o neutro.
A continuación, se presenta la solución:
1) # Lee un número y determina si es positivo, negativo o neutro

2)
4)
5) if numero > 0:
7) else:
8) if numero < 0:
10) else:
Explicación:
✧ Luego de leer un número en la línea tres, se procede a tomar la primera decisión,

la cual se encuentra en la línea cinco:
if numero > 0:
Con ella se pregunta si el número que ingresó el usuario es mayor a 0, es decir,

si se trata de un número positivo. En el caso de que esta expresión arroje un
resultado True, se imprime el mensaje Es positivo (línea seis). Si la condición es
False (línea siete), se procede a evaluar una segunda condición (línea ocho):
If numero < 0:
Esta condición está preguntando si el número es menor a 0, con ello se pretende

determinar si se trata de un número negativo. Si la condición arroja un resultado
101
True, imprime el mensaje Es negativo (línea nueve). De igual forma, si esta nueva
expresión es False (línea diez) se imprime el mensaje Es neutro (línea once).
✧ Es importante resaltar que el enunciado plantea tres alternativas como

resultado: Positivo, Negativo o Neutro, sin embargo, solamente se plantean dos
condiciones. En la primera se revisa si el número es positivo, si no es así, se
plantea la segunda donde la revisión corresponde a determinar si el número es
negativo. La condición de que sea neutro no se expresa, ya que se asume que, si
no es positivo, ni es negativo, por descarte es neutro.
Ejemplo 3.5. Al número de contracciones que presenta el corazón en un minuto se le

denomina frecuencia cardiaca. Relacionado a este concepto está la frecuencia
cardiaca máxima (FCmax), definida como el número más alto de latidos que puede
tener el corazón en un minuto.
Existe una fórmula que permite determinar la FCmax de manera aproximada,

dependiendo de la actividad física, la edad y el género de la persona, así:
1. Persona sedentaria: FCmax = 220 – edad.
2. Personas con actividad física:
a. Hombre: FCmax = 209 – (0,7 x edad).

b. Mujer: FCmax = 214 – (0,8 x edad).
Este programa determina la frecuencia cardiaca máxima, de acuerdo a las

condiciones planteadas.
1) # Calcula la frecuencia cardiaca máxima de una persona

2)
5) return numero
6)
7) def leer_booleano(mensaje):
8) respuesta = input(mensaje).upper()
9)
102
10) if respuesta == "S":

11) respuesta = True
12) else:
13) respuesta = False
14)
15) return respuesta
16)
17) edad = leer_int("¿Cuál es su edad?: ")
18) es_activo = leer_booleano("¿Practica actividad física regularmente [S] [N]?: ")
19)
20) if es_activo:
21) es_mujer = leer_boleano("Es usted mujer [S] [N]?: ")
22) if es_mujer:
23) fcmax = 214 - (0.8 * edad)
24) else:
25) fcmax = 220 - edad
26)
27) print(f"\nSu frecuencia cardiaca máxima es de: {fcmax}")
Explicación:
✧ En este programa se implementaron dos funciones y tres decisiones. La primera

función (línea tres) se usa para leer un dato de tipo entero. La función
leer_booleano() se implementó con el fin de leer datos donde la respuesta sea
una letra S o una letra N.
Analizando la función con más detalle se tiene que, se definió el identificador
mensaje como parámetro, el cual toma como valor lo que le sea enviado como
argumento en el momento que sea llamada la función:
def leer_booleano(mensaje):
respuesta = input(mensaje).upper()
Luego de ser definida la función, la variable local llamada respuesta almacena la

respuesta que le proporcione el usuario del programa. La función upper()
convierte cualquier letra que se digite en su respectiva mayúscula.
103
Una vez se tenga la respuesta del usuario, se toma la siguiente decisión:
if respuesta == "S":
respuesta = True
else:
respuesta = False
En este punto pasa algo bien particular con la variable respuesta, inicialmente se
pregunta que, si es igual a la letra S, en el caso de que esta expresión relacional
sea verdadera, a la misma variable respuesta se le asigna el valor True y en caso
de que sea falsa se le asigna el valor de False. Observe cómo se hace uso y se
aprovecha la ventaja que tiene Python de asignar diferentes tipos de datos a una
misma variable en diferentes momentos. Inicialmente la variable es de tipo str
(string), luego cuando se toma la decisión, pasa a ser de tipo boolean (booleano
o lógico).
✧ Una vez sea asignado el valor True o False a la variable respuesta, se retorna su
valor al sitio donde fue llamada la función, para ello se hace uso de la instrucción
return:
return respuesta
Ahora que se conoce como opera esta función, revisemos las demás instrucciones del
programa.
✧ En las líneas 17 y 18 se solicitan los datos. La edad se lee a través de la función

leer_int().
La instrucción de la línea 18 tiene como fin obtener la respuesta de si la persona
practica actividad física. En la variable es_activo se almacena el valor de True o
False, dependiendo del valor que retorne la función leer_booleano(), la cual se
explicó en los párrafos anteriores.
✧ Con el valor que haya obtenido la variable es_activo, se toma otra decisión en la
línea 20:
if es_activo:
es_mujer = leer_booleano("Es usted mujer [S] [N]?: ")
if es_mujer:
104
fcmax = 214 - (0.8 * edad)

else:
fcmax = 209 - (0.7 * edad)
else:
fcmax = 220 - edad
Esta estructura tiene la característica de ser una decisión anidada. La condición

que se plantea en la decisión de la línea 22 hace parte del cuerpo de una decisión
externa (línea 20), es decir que está anidada dentro de ella.
La condición planteada inicialmente (if es_activo:), corresponde a una expresión

lógica; haciendo una similitud con el lenguaje natural, equivale a la pregunta: ¿la
variable es_activo es igual a True?
Ahora bien, en el caso de que la variable es_activo tenga el valor de True, se pasa
a preguntar si es mujer (línea 21). Para la lectura de esta pregunta se vuelve a
hacer uso de la función leer_booleano(), que devolverá el valor de True o False a
la variable es_mujer.
Con el resultado de la anterior pregunta, se plantea la siguiente decisión (línea

22):
if es_mujer:
Si el valor es True se aplica la fórmula correspondiente: fcmax = 214 - (0.8 * edad).

Si el resultado es False se hace uso de la fórmula para hombres: fcmax = 209 -
(0.7 * edad).
Independientemente de cuál de las dos fórmulas se aplique, el flujo del

programa se sale de las decisiones y pasa a ejecutar la instrucción de la línea 29,
donde imprime el resultado.
✧ Ahora bien, no olvide que lo que se acabó de analizar corresponde solo al caso
cuando la condición de la línea 20 es True (cuando la persona es activa), pero
¿qué pasaría si la esta condición es False?
La respuesta es simple, si al evaluar dicha condición se encuentra que tiene un

valor False, el control del programa salta de la línea 20 a la línea 26 y ejecuta la
instrucción que le sigue, en este caso aplica la fórmula que corresponde a
personas que no tienen actividad física, por lo cual no ejecuta ninguna de las
105
instrucciones que hay entre las líneas 21 a 25. Finalmente se imprime el resultado
y termina la ejecución del programa.
Actividad 3.2 Los triángulos se pueden clasificar de la siguiente manera, según la

medida de sus ángulos:
✧ Acutángulo: tiene lo tres ángulos agudos (menos de 90 grados).
✧ Rectángulo: el ángulo interior es recto (90 grados) y los otros dos son ángulos
agudos.
✧ Obtusángulo: El ángulo interior es obtuso (más de 90 grados), los otros dos son
agudos.
De acuerdo con la siguiente información, construya un programa que determine la
clase de triángulo.
3.1.3 Instrucción elif
Esta instrucción es un método abreviado del conjunto de instrucciones if - else. Su

forma general es la siguiente:
if condición1:
Instrucción1
elif condición2:
Instrucción2
elif condición_n:
Instrucción_n
else:
Instrucción_F
La instrucción if evalúa a condición1, si el resultado es True ejecuta Instrucción1

(pueden ser 1 o varias instrucciones), si por el contrario, se obtiene un resultado False
se pasa el primer elif y se evalúa condición2, si esta es True se ejecuta Instrucción2,
pero si es False se pasa al siguiente elif y se evalúa condición_n; el proceso se repite
dependiendo de la cantidad de condiciones que se establezcan. Si ninguna de las
condiciones es True se ejecuta la Instrucción_F. Cuando cualquiera de las condiciones
106
sea True, se ejecuta la instrucción relacionada y el control del programa sale del
bloque de esta estructura if-elif.
Para comprender mejor el funcionamiento de esta instrucción, revisemos los

siguientes ejemplos.
Ejemplo 3.6. Retomando el enunciado del ejemplo 3.4, en el siguiente programa se

lee un número y determina si es positivo, negativo o neutro.
Esta solución ya se había planteado usando instrucciones if - else, ahora se codificará

con instrucciones if - elif con el propósito de que se aprecie la diferencia de estas
estructuras.
1) # Lee un número y determina si es positivo, negativo o neutro

2)
4)
5) if numero > 0:
7) elif numero < 0:
9) else:
10) print("Es neutro")
Explicación:
✧ Es la misma lógica explicada en el ejemplo 3.4, la diferencia radica en que esta

vez se hizo usando if - elif.
Ejemplo 3.7. Si se ingresa uno de los siguientes números: 1, 5, 10, 50, 100, 500 o
1000, se debe informar su equivalente valor romano. En caso de ser cero o negativo
se informará que estos números no existen dentro de los romanos; de igual manera,
si es un número diferente a los relacionados, debe informar la situación.
107
Una de las posibles soluciones se plantea a continuación:
1) # Programa números romanos

2)
4)
5) if numero == 1:
6) print("I")
7) elif numero == 5:
8) print("V")
10) print("X")
12) print("L")
14) print("C")
16) print("D")
18) print("M")
19) elif numero <= 0:
20) print("Es un número negativo o el 0, no existen en romano")
21) else:
22) print("No es uno de los valores válidos")
Explicación:
✧ El if con el que inicia el conjunto de condiciones (línea siete), revisa si el número

digitado es igual a 1, en caso de ser True esta condición, el programa imprime
como resultado su equivalente valor romano (I). Si el resultado es False, ejecuta
el primer elif que encuentra (línea nueve) donde se evalúa si el número es igual
a 5. Sucesivamente se siguen haciendo estas evaluaciones si los demás resultados
siguen siendo False. Si al llegar al elif de la línea 21 el resultado sigue con el mismo
valor de False, se procede a ejecutar la instrucción relacionada al else de la línea
23, en cuyo caso imprime “No es uno de los valores válidos”.
108
✧ Si en algún momento, una de las condiciones planteadas es True, se imprime el

valor correspondiente al número romano y el control del programa sale del
bloque de decisiones.
Ejemplo 3.8. Georg Simon Ohm, físico y matemático, estableció la ley de Ohm, la cual
determina las leyes de la corriente eléctrica. La fórmula general de la ley de Ohm es
la siguiente:
V=I*R
Donde:
V: voltaje.
I: corriente.
R: resistencia.
Construya un programa que permita calcular cualquiera de estas variables, partiendo

del hecho que se conocen las otras dos. El usuario podrá elegir cuál de ellas desea
calcular.
Antes de codificar el programa, se deben despejar las fórmulas que se van a utilizar.
I R
Observando la anterior figura se tiene:
V=I*R
I=V/R
R=V/I
109
Una vez conocidas las fórmulas, se plantea la siguiente solución.
1) # Este programa calcula las variables de la Ley de OHM

2)
3) # Calcula el voltaje
4) def v(i, r):
5) i=v/r
6) return v
7)
8) # Calcula la corriente
9) def i(v, r):
10) i=v/r
11) return i
12)
13) # Calcula la resistencia
14) def r(v, i):
15) r=v/i
16) return r
17)
20) return numero
21)
22) print("¿Qué valor desea calcular?")
23) print("\n[V]oltaje\n[R]esistencia\n[C]orriente\n ")
24) opcion = input().upper()
25)
26) if opcion == "V":
27) corriente = leer_float("Digite el valor de la corriente: ")
28) resistencia = leer_float("Digite el valor de la resistencia: ")
29) print(f"El voltaje es: {v(corriente, resistencia)}")
30) elif opcion == "R":
31) resistencia = leer_float("Digite el valor de la resistencia: ")
32) voltaje = leer_float("Digite el valor del voltaje: ")
33) print(f"La corriente es: {i(voltaje, resistencia)}")
34) else:
35) print("\n¡Error! Opción no disponible")
110
Explicación:
✧ En este programa se emplean cuatro funciones: una para leer los datos de tipo
float y las otras tres para el cálculo del voltaje, la corriente y la resistencia,
respectivamente.
✧ Con la funciones print() de las líneas 22 y 23 se imprimen las opciones disponibles

para el usuario:
print("¿Qué valor desea calcular?")

print("\n[V]oltaje\n[R]esistencia\n[C]orriente\n ")
La secuencia de escape (\n) produce un salto de línea. En pantalla se visualizará

lo siguiente:
¿Qué valor desea calcular?
[V]oltaje
[R]esistencia
[C]orriente
✧ Con la instrucción de la línea 24 se hace la lectura de la elección del usuario. La

función upper(), convierte a mayúscula la letra digitada:
opcion = input().upper()
✧ En este punto del programa, la variable opcion ya tiene un valor, por lo tanto, se
procede a tomar decisiones para determinar qué instrucciones ejecutar.
La primera condición que se plantea está en la línea 26, donde se pregunta si la

variable opcion es igual a V. Con esto se indaga si el usuario quiere calcular el
voltaje. Note que se usó solo la V mayúscula y no se contempló la minúscula, esto
obedece a que se usó la función upper() para hacer la conversión. Si esta
condición devuelve un resultado de True, se procede a leer la corriente y la
resistencia (líneas 27 y 28).
En la línea 29, se hace el llamado a la función que realizará el cálculo del voltaje
y a la vez se mostrará el resultado, usando la función print().
print(f"El voltaje es: {v(corriente, resistencia)}")
111
Si esta primera condición es False se pasa a evaluar la condición de la línea 30 y

así sucesivamente.
✧ En las líneas 30 y 34, se localizan las condiciones que revisan si el usuario eligió
calcular la resistencia o la corriente, respectivamente. Tenga presente que solo
se calculará la variable que el usuario haya elegido. Si se eligió una de estas
opciones, se pedirán los datos y se llamará a la función que hace el cálculo
correspondiente, finalizando en la impresión del resultado.
 Si el usuario no digitó las letras R, V o C cuando eligió la variable a calcular, el

flujo del programa llegará hasta la línea 38, en donde encuentra el else que tiene
asociada la siguiente instrucción que imprime un mensaje informando la
inconsistencia:
print("\n¡Error! Opción no disponible")
Ejemplo 3.9. En este ejemplo, se hará uso de las diferentes formas que puede tener
la estructura de decisión if, al igual que se aplicarán varios de los conceptos
estudiados hasta el momento.
Una empresa de alquiler de vehículos desea conocer cuánto debe pagar un cliente,
el valor del descuento y el valor de la cuenta antes del descuento.
La empresa ofrece dos tipos de vehículos: 1. Automóviles y 2. Camionetas. El valor

por cada hora de uso es de $10000, adicionalmente se cobra un incremento, por
kilómetro, de acuerdo con la cantidad de kilómetros que recorra, tal como se aprecia
en la siguiente tabla.
Tarifa de incremento
Kms recorridos Tipo de vehículo
1. Automóvil 2. Camioneta
0.0 .. 20.0 500 700
20.1 .. 40.0 600 800
40.1 .. 60.0 700 1.000
60.1 .. 800 1.200
112
Como incentivo, a los clientes que recorran más de 80 kilómetros, se les otorga un
descuento del 10% sobre el total de la cuenta.
1) # Alquiler de vehículos según su tipo y kms recorridos

2)
3) def valor_incremento(vehi, kms):
4) if vehi == 1:
5) if kms >= 0.0 and kms <= 20.0:
6) incremento = kms * 500
7) elif kms >= 20.1 and kms <= 40.0:
9) elif kms >= 40.1 and kms <= 60.0:
11) else:
13) else:
14) if kms >= 0.0 and kms <= 20.0:
16) elif kms >= 20.1 and kms <= 40.0:
18) elif kms >= 40.1 and kms <= 60.0:
20) else:
22)
23) return incremento
24)
25) def valor_descuento(kms, valor_bruto):
26) if kms > 80:
28) else:
30)
31) return valor_bruto * porcentaje_descuento
32)
35)
36) return numero
37)
113

40)
41) return numero
42)
43) print("Digite los siguientes datos")
44) vehiculo = input("\nTipo de vehículo \n[1] Automóvil\n[2]
Camioneta\n>>>")
45) horas = leer_int("Horas de alquiler: ")
46) kms = leer_float("Kilómetros recorridos: ")
47)
48) incremento = valor_incremento(vehiculo, kms)
49) valor_bruto = horas * 10000 + incremento
50) descuento = valor_descuento(kms, valor_bruto)
51) valor_neto = valor_bruto - descuento
52)
53) print(f"El valor a pagar antes de descuento es: {valor_bruto}")
54) print(f"El valor del descuento es: {descuento}")
55) print(f"El valor a pagar es: {valor_neto}")
Explicación:
✧ Para esta solución se escribieron cuatro funciones:
1. valor_incremento(vehi, kms):
2. valor_descuento(kms, valor_bruto):
3. leer_int(mensaje):
4. leer_float(mensaje):
✧ La función valor_incremento(vehi, kms), tienen como parámetros el tipo de

vehículo que alquile el cliente y la cantidad de kilómetros que recorra.
Inicia con una decisión principal (línea cuatro) y dentro de ella tiene una decisión
anidada (línea cinco). La condición inicial tiene como objetivo determinar si el
vehículo es de tipo automóvil:
if vehi == 1:
114
Si esta condición es True, quiere decir que se trata de un automóvil.

Seguidamente, se procede a determinar el rango de kilómetros que recorrió. Para
esta tarea, se hizo uso de un conjunto de decisiones if - elif, que se encuentran
dentro de la decisión principal. La primera condición de este bloque anidado
(línea cinco), pregunta si los kilómetros recorridos están en el rango de 0 a 20, en
cuyo caso el incremento a aplicar será de $500 por kilómetro (línea seis). En caso
contrario, se plantea una nueva pregunta para el siguiente rango de kilómetros
(línea siete), donde se aplicará un incremento de $600 por kilómetro (línea ocho)
y así sucesivamente.
Una vez se haya determinado el valor del incremento, el control del programa
salta a la línea 23, desde donde se hace el retorno del valor calculado. Observe
que ninguna de las decisiones que hay entre las líneas 14 y 21 son analizadas, ya
que hacen parte del else de la línea 13 que se analizará a continuación.
✧ Retomemos el if de la línea cuatro. En los párrafos anteriores es analizó en el caso

que la condición tuviera un resultado True, ahora veremos el comportamiento
cuando el resultado es diferente.
if vehi == 1:
Cuando el resultado es False, indica que el tipo de vehículo no es 1. Automóvil,

sino 2. Camioneta. Por el momento, se supone que el usuario del programa digitó
correctamente los datos solicitados; en el próximo capítulo se harán las
validaciones correspondientes para evitar datos de entrada erróneos.
Al intérprete de Python encontrar que esta condición es False, dirige el control a

la instrucción de la línea 13, donde se encuentra el else, correspondiente al if de
la línea cuatro. Acto seguido, en la línea 14 se plantea la siguiente condición:
if kms >= 0.0 and kms <= 20.0:
Al igual que se explicó en los párrafos anteriores, cuando el vehículo es un

automóvil, se procede a determinar el rango de kilómetros que recorrió. La
primera condición de este segundo bloque anidado (línea 14), pregunta si los
kilómetros recorridos están en el rango de 0 a 20, en cuyo caso el incremento a
aplicar será de $700 por kilómetro recorrido. El resto del procedimiento es igual
al narrado anteriormente.
115
✧ La segunda función codificada es valor_descuento(kms, valor_bruto), tiene como

parámetros los kilómetros recorridos y el valor bruto a cancelar, con ellos se debe
determinar el valor del descuento que se va a aplicar.
En la línea 26 se plantea una condición que tiene como propósito determinar si

los kilómetros del recorrido fueron más de 80. Si esta condición arroja un
resultado True, se establece como porcentaje de descuento el 10% (línea 27), en
caso contrario el porcentaje de descuento es 0.0 (línea 29). Luego de determinar
el porcentaje de descuento, se ejecuta el retorno de la línea 31, entregando el
resultado al sitio donde fue invocada la función.
✧ Las funciones leer_int() y leer_float(), funcionan de igual manera como se ha

explicado en los programas anteriores.
✧ Entre las líneas 43 y 46, se hace la solicitud de los datos requeridos: tipo de
vehículo, horas de alquiler y kilómetros recorridos.
En el caso del tipo de vehículo, recuerde que la secuencia de escape (\n) produce
un salto de línea:
vehiculo = input("\nTipo de vehículo \n[1] Automóvil\n[2] Camioneta\n>>>")
En pantalla se visualizará lo siguiente:
Tipo de vehículo
[1] Automóvil
[2] Camioneta
>>>
✧ Luego de leer los datos de entrada se realizan los cálculos. En el caso del
incremento y del descuento, se hace el llamado a las funciones que se explicaron
previamente. Las variables incremento y descuento, toman los valores que sean
retornados desde dichas funciones.
✧ Finalmente, se imprimen los resultados (líneas 53, 54 y 55) y se da por terminada

la ejecución del programa.
116
Actividad 3.3. Construya los programas necesarios para dar solución a los siguientes
enunciados.
a. La siguiente tabla presenta algunos de los últimos elementos de la tabla periódica.

Se requiere de un programa que lea el símbolo químico o el número atómico e
informe el nombre del elemento. Si el elemento no se encuentra en la tabla, debe
informar dicha inconsistencia.
Símbolo Químico Número atómico Nombre del elemento

Fl 114 Flerovio
Mc 115 Moscovio
Lv 116 Livermorio
Ts 117 Teneso
Og 118 Oganesón
b. Construya un programa que lea dos números y uno de los operadores de las cuatro
operaciones básicas (+ , - , / o *), calcule e imprima el resultado de la respectiva
operación.
Observaciones:
1. Tenga en cuenta que la división entre 0 es indeterminada.

2. En el caso de la multiplicación debe permitir que se ingrese una x o un punto
(.) como operador válido.
3. Si el usuario ingresa un operador diferente a los ya mencionados, no debe
realizar ninguna operación y deberá informar tal inconsistencia.
c. Una empresa colombiana que vende libros físicos a través de internet, desea un
programa que le permita conocer cuánto cobrará a un cliente por concepto de
envío de su pedido, teniendo en cuenta los siguientes criterios:
1. Cantidad de libros. Se estima su valor de acuerdo a la siguiente tabla.
Costo básico de envío

Cantidad de libros Nacionales Importados
De 1 a 3 $ 4.500 $ 6.000
De 4 a 6 $ 7.000 $ 12.000
7 o más $8.500 $ 15.000
117
Los anteriores precios, se aplican al total de libros, no de manera individual.

Los libros nacionales e internacionales se envían en paquetes separados.
2. Para los despachos la empresa tiene dividido el país en cinco zonas: centro,
norte, sur, oriente y occidente. Dependiendo de la zona se tiene un
incremento sobre el costo básico de envío, así:
✧ Centro = 2%
✧ Norte = 5%
✧ Sur = 7%
✧ Oriente y occidente = 4%
3. La entrega de los pedidos, está programada para hacerse a los 8 días

siguientes al pago. En el caso que el cliente desee una entrega rápida, deberá
asumir un sobrecosto de $1300 por cada libro, independientemente de la
región de envío. Esta modalidad solo aplica para los libros nacionales.
Construya el programa, que lea los datos necesarios para arrojar los
resultados que la empresa requiere.
118
CAPÍTULO 4
4 ESTRUCTURAS DE
REPETICIÓN
Objetivos:
 Conocer las diferentes estructuras de repetición que proporciona

el lenguaje.
 Determinar que estructura de repetición usar dependiendo del
problema a resolver.
 Construir programa en Python utilizando estructuras de
repetición.
ESTRUCTURAS DE REPETICIÓN
Los programas que se han hecho hasta el momento se ejecutan una sola vez, es decir,
solicitan los datos en el caso de ser necesarios, realizan un proceso y arrojan un
resultado. Si se quisiera volver a repetir estas actividades, sería necesario volver a
ejecutar el programa.
En este capítulo se estudiarán dos instrucciones que permiten que una instrucción o
inclusive todas las instrucciones que hacen parte del programa, se repitan la cantidad
de veces que sean necesarias, estas instrucciones son conocidas como ciclos, bucles
o instrucciones repetitivas.
En Python existen dos instrucciones repetitivas que, son conocidas como while y for.
A continuación, se estudiarán con más detalle y se realizarán varios ejemplos que
permitirán comprender su funcionamiento y la diferencia entre ellas.
4.1 Instrucción while
Permite implementar programas en los cuales, una instrucción o un conjunto de ellas

se puedan ejecutar cero o más veces, dependiendo de una condición.
La condición de este ciclo se plantea al inicio de las instrucciones que debe repetir,
razón por la cual se le conoce como un ciclo condicionado al comienzo.
while condición:
Instrucción1
Instrucción2
.
.
Instrucción_n
120
Gráficamente el funcionamiento de una instrucción while, se aprecia así:
De acuerdo con la anterior forma general se tiene que, mientras (while) la condición
sea True se ejecuta la Instrucción1, Instrucción2 hasta Instrucción_n. Este grupo de
instrucciones se conoce como el cuerpo del ciclo y al igual que el cuerpo de las
funciones y de las decisiones, temas vistos en los capítulos anteriores, deben
conservar la sangría.
Así las cosas, después de ejecutar a Instrucción_n (última instrucción del cuerpo del
ciclo), el control del programa regresa al while y evalúa nuevamente la condición, si
esta sigue siendo True se vuelve a ejecutar el cuerpo del ciclo. Este proceso continúa,
mientras la condición siga siendo True.
Es fundamental que el valor de la condición cambie de valor, es decir, tome un valor

False, de lo contrario se tendría un ciclo que se repetirá indefinidamente. El cambio
al valor de la condición debe hacerse dentro del cuerpo del ciclo.
121
Recordemos que, al tratarse de un ciclo condicionado al comienzo, puede suceder

que al evaluar por primera vez la condición arroje un resultado False, en cuyo caso el
cuerpo del ciclo no se ejecutaría ni una sola vez. Es por esto que, si se requiere que al
menos la ejecución se haga una vez, deben tomarse las medidas necesarias para que
la condición sea True en su primera evaluación.
Cuando la condición arroje un resultado False, no se ejecuta ninguna instrucción del

cuerpo del ciclo y se continúa con la instrucción que esté por debajo de Instrucción_n,
la cual deberá estar por fuera de la sangría de las demás instrucciones del ciclo.
Con el propósito de ejemplarizar los anteriores conceptos, se desarrollarán los

siguientes programas.
Ejemplo 4.1. El siguiente programa imprime los números del 1 al 10 usando el ciclo
while.
Si se pensara en una solución de acuerdo con los temas vistos en los capítulos
anteriores, tendría que hacerse algo similar a lo siguiente:
print("1")
print("2")
print("3")
print("4")
print("5")
print("6")
print("7")
print("8")
print("9")
print("10")
Note que se imprimieron uno a uno los números del 1 al 10, en este caso la solución
es sencilla al tratarse de poquitos números.
122
Si se pensara en el uso de una variable para otra solución del mismo problema, se
tendría un código similar al siguiente:
i=1
print(i)
i += 1
print(i)
i += 1
print(i)
i += 1
print(i)
i += 1
print(i)
i += 1
… y así sucesivamente.
En esta solución se utilizó una variable que se inicializó en 1, luego se imprime su

valor, posteriormente se incrementa en una unidad para que tome el valor de 2 y
nuevamente se hace la impresión de su valor, el proceso debe repetirse hasta
alcanzar el valor de 10.
Como se pudo apreciar, las dos soluciones anteriores, producen iguales resultados,
pero, ¿qué pasaría si en lugar de los números del 1 al 10, el enunciado solicitara la
impresión del 1 al 1000 o del 1 al 100000? Sería bastante tedioso hacer la impresión
de esta gran cantidad de números. Es aquí donde cobra importancia el uso de las
instrucciones repetitivas. Veámos la solución usando el ciclo while:
1) # Imprime los números del 1 al 10

2)
3) numero = 1
4)
5) while(numero <= 10):
6) print(numero)
7) numero += 1
123
Explicación:
 Se inicializa la variable numero con el valor de 1, que será el primer número a

imprimir.
 En la línea cinco, se codificó la instrucción while, cuya condición es numero <= 10.
Con ella se establece que debe ejecutarse mientras el valor de la variable numero
sea menor o igual a 10, como en este momento la variable tiene el valor de 1, esa
condición arroja un resultado True, indicando así que debe ejecutarse el cuerpo
del ciclo.
 El cuerpo del ciclo está conformado por dos instrucciones. La primera imprime el
valor de la variable, la segunda incrementa la variable en una unidad, esto lo hace
en cada ejecución del ciclo.
print(numero)
numero += 1
Observe que las dos instrucciones que conforman el cuerpo del ciclo, conservan
la misma sangría.
 Cuando el programa incrementa el valor de la variable (línea siete), el control

regresa a la línea cinco, donde se evalúa nuevamente la condición, este proceso
se repite hasta que numero alcance un valor de 11. En el momento de evaluar la
condición con el valor de 11, ella arroja un resultado de False y así termina la
ejecución del ciclo; al no encontrarse más instrucciones que ejecutar, se da por
terminado el programa.
 En esta solución, la variable numero recibe el calificativo de variable de control,

puesto que con ella se está haciendo la condición del while y es la que controla
las veces que debe ejecutarse el cuerpo del ciclo.
124
La variable de control debe modificarse dentro del cuerpo del ciclo, para que en
algún momento la condición tome el valor de False. En este programa la
modificación se hace en la línea siete.
Ejemplo 4.2 En este ejemplo se utiliza la instrucción continue. Con ella se logra que
las instrucciones que faltan por ser ejecutadas dentro del while, sean omitidas y se
regrese directamente a la evaluación de la condición para continuar con el proceso
correspondiente.
El siguiente programa imprime los números del 1 al 100, excluyendo los múltiplos de
4.
1) # Imprime los números del 1 al 100, exceptuando los múltiplos de 4

2)
3) contador = 0
4)
5) while contador < 100:
6) contador += 1
7) if contador % 4 == 0:
8) continue
9) print(contador)
Explicación:
 Se inicializa la variable contador con el valor de 0, esta es usada como variable de

control.
 En la línea cinco, se estableció la condición del ciclo while, la cual expresa que debe
ejecutarse el cuerpo del ciclo, mientras la variable contador sea menor o igual a
100. Como en este momento la variable tiene un valor de 0, el resultado de la
condición es True, por lo tanto, se ejecuta el cuerpo del ciclo.
 El cuerpo del ciclo está compuesto por las instrucciones que hay entre las líneas 6
y 9. Note que todas conservan la misma sangría.
125
 En la línea seis, al incrementar la variable contador, toma el valor de 1.

Seguidamente se evalúa la decisión de la línea siete:
if contador % 4 == 0:
continue
Con esta condición se está preguntando que, si la división del valor de la variable
contador entre 4, deja como residuo 0. En caso de ser True el resultado, se ejecuta
la instrucción continue. La cual automáticamente retorna el control del programa
a la línea cinco, donde se evalúa una vez más la condición del while para
determinar si se repite el cuerpo del ciclo o termina su ejecución.
En este preciso momento, como el valor de contador es 1, esta condición da un

resultado False, por lo tanto, la instrucción continue no se ejecuta.
El control del programa sigue hacia la línea nueve, donde se imprime el valor de
la variable contador, en esta primera ocasión, imprime el valor de 1.
Una vez impreso el valor de la variable contador, se retorna a la línea cinco y se

evalúa la condición del while (¿1 < 100?), dando un resultado True, una vez más
se repite el cuerpo del ciclo. Este proceso seguirá hasta que complete las 100
vueltas. La instrucción continue solo será ejecutada cada vez que el valor de
contador tenga un valor múltiplo de 4.
Ejemplo 4.3. El valor futuro en el interés compuesto es el resultado que se obtiene al

integrar el interés al capital original.
La fórmula que se emplea para calcular el valor futuro de una cantidad dada, en un
periodo de tiempo con interés compuesto es: 𝑣𝑓 = 𝑣𝑝 ∗ (1 + 𝑖)𝑛
Donde:
vf: valor futuro.

vp: valor presente o capital inicial.
126
i: tasa de interés por cada periodo invertido.

n: periodos de capitalización.
Este programa calcula el valor futuro de una cantidad invertida en un periodo de

tiempo n a una tasa de interés i. Debe mostrar el valor futuro en cada periodo de
tiempo hasta llegar al periodo final.
1) # Calcula el valor futuro de una cantidad en varios períodos de tiempo

2)
3) def valor_futuro(vp, i, n):
4) vf = vp * (1 + i / 100) ** n
5) return vf
6)
9) return numero
10)
13) return numero
14)
15) print("\nDigite los siguientes datos\n")
16) vr_presente = leer_float("Valor presente a invertir: ")
17) interes = leer_float("Tasa interés por período: ")
18) periodo = leer_int("Cantidad de períodos: ")
19)
20) print("\n", "Valor futuro por cada período".center(50, "-"),"\n")
21)
22) per = 1
23)
24) while per <= periodo:
25) vr_futuro = valor_futuro(vr_presente, interes, per)
26) print(f"Período {per}, valor futuro: {vr_futuro:.2f}")
27) per += 1
127
Explicación:
 Se implementaron tres funciones, dos para la lectura de datos y una más para el
cálculo del valor futuro.
La función valor_futuro(vp, i, n), recibe tres parámetros para poder realizar el

cálculo: el valor presente (vp), la tasa de interés (i) y el número de periodos (n).
Una vez aplicada la fórmula correspondiente, se procede a retornar el valor
calculado.
 Entre las líneas 15 y 18 se hace la solicitud y se invocan las funciones para la

lectura de los datos.
La función print() de la línea 20, imprime un título centrado en pantalla,

acompañado de varios caracteres “-” a ambos lados, así:
----------Valor futuro por cada período-----------
 En la línea 22 se inicializa con el valor de 1, la variable de control del ciclo

llamada per.
 Sobre la línea 24, se inicia el ciclo while, con la siguiente condición:
while per <= periodo:
Indicando así, que debe ejecutarse mientras la variable de control per sea menor
o igual al número de períodos que se desean capitalizar.
El cuerpo del ciclo está compuesto por tres instrucciones, ubicadas en las líneas
25, 26 y 27.
La primera instrucción (fila 25), asigna a la variable vr_futuro, el valor que retorne
la función valor_futuro(vr_presente, interes, i), de acuerdo a los valores de los
argumentos que se envían.
128
La siguiente instrucción (línea 26), imprime el número del periodo y el valor futuro
correspondiente.
Finalizando el cuerpo del ciclo (línea 27), se hace el incremento de la variable de

control, llamada per, de esta forma, se va aumentando en 1 esta variable, hasta
que llegue al valor en el cual la condición del ciclo (línea 24) se haga False, en dicho
momento se terminará la ejecución del ciclo y en consecuencia la del programa.
 En una de sus ejecuciones, se podría visualizar en pantalla lo siguiente:
Digite los siguientes datos
Valor presente a invertir: 155000

Tasa interés por período: 3.5
Cantidad de períodos: 6
----------Valor futuro por cada período-----------
Período 1, valor futuro: 160425.00

Ejemplo 4.4. El siguiente programa calcula el factorial de un número. El factorial de

un número 0 o positivo, es el producto de todos los números enteros positivos desde
1 hasta n. Por definición el factorial de 0 es 1.
El factorial se representa mediante el símbolo !. Ejemplo:
6! = 1 x 2 x 3 x 4 x 5 x 6 = 720
129
Una de las posibles soluciones se preseta a continuación:
1) # Calcula el factorial de un número

2)
3) def facto(tope):
4) if tope >= 0:
5) factorial = 1
6) numeros = 1
7) while numeros <= tope:
8) factorial = factorial * numeros
9) numeros = numeros + 1
10) else:
11) factorial = "¡Error!, la entrada es un número negativo"
12)
13) return factorial
14)
17) return numero
18)
19) numero = leer_int("Número a calcular el factorial: ")
20)
21) factorial = facto(numero)
22) print(f"Factorial = {factorial}")
Explicación:
 Entre las líneas 3 y 13, se definió la función facto(tope): con la cual se calcula el
valor del factorial de un número, cuyo valor será enviado cuando se haga el
En el cuerpo de la función, se encuentra una estructura de decisión if y una

estructura repetitiva while. La estructura while hace parte de la decisión if.
Analicemos detalladamente estas instrucciones:
130
 En la línea cuatro se plantea una decisión para determinar si el valor recibido

en el parámetro llamado tope, es positivo o 0. Con ello se determina que, si
es viable hacer el cálculo del factorial. Cuando esta condición tiene un valor
de True, se inicializan dos variables locales, la variable factorial en 1 y la
variable numeros en el mismo valor.
 En la línea siete se tiene el while, donde la condición establece que se debe

ejecutar el cuerpo del ciclo mientras numeros sea menor igual a tope. El
cuerpo está compuesto por dos instrucciones (línea 8 y 9). En la primera, la
variable factorial se encargará de ir acumulando el resultado de cada una de
las multiplicaciones sucesivas que se deben realizar. En la segunda, la variable
numeros va aumentando de 1 en 1 hasta llegar al valor de tope, el cual
representa el número al que se le calculará el factorial.
Cuando la condición del while se hace False, se termina la ejecución del ciclo
y el control del programa pasa a la línea 13, donde se retorna el valor
acumulado en la variable local factorial.
 Ahora bien, cuando la condición de la línea cuatro es False, es decir, que se

trata de un número negativo, el control pasa a la línea diez, sin ejecutar
ninguna instrucción entre las líneas 5 a 9. El else de la línea diez, tiene
asociada la siguiente instrucción (línea 11):
factorial = "¡Error!, la entrada es un número negativo"
Con ella se está asignando a la variable local factorial, la cadena con el

mensaje de error. Seguidamente el control pasa a la línea 13, con la cual se
retorna el valor almacenado.
 Note que independientemente del valor de la condición de la línea cuatro,

siempre se llega a la ejecución de la instrucción de la línea 13.
131
Ejemplo 4.5. Con este ejemplo se ilustra el uso de una variable centinela. Esta clase
de variables son usadas para controlar diferentes acciones dentro de un programa.
En este caso se usará como variable de control del ciclo.
El programa simulará un juego para niños en edad escolar, que les mostrará una
operación de suma de dos números aleatorios, entre 1 y 9; el niño deberá ingresar el
resultado de dicha suma. A medida que se realice el juego, se felicitará al niño por las
respuestas correctas o se le dará la retroalimentación en las respuestas erradas. El
juego finalizará cuando el jugador así lo determine.
Al final se informará la cantidad de respuestas correctas y de respuestas erradas.
Una de las posibles soluciones se presenta a continuación.
1) # Juego para niños practicar sumas con valores entre 1 y 9

2)
3) from random import randint
4)
7) return numero
8)
9)
12)
13) if respuesta == "S":
14) respuesta = True
15) else:
16) respuesta = False
17)
19)
20) def jugar():
21) buenas = malas = 0
22) pausa = True
23)
132
24) while pausa:

25) numero1 = randint(1, 9)
26) numero2 = randint(1, 9)
27)
29)
30) resultado = leer_int(f"\n{numero1} + {numero2} = ")
31)
32) if resultado == suma:
33) buenas += 1
34) print("Muy bien… ¡Felicitaciones!")
35) else:
36) malas += 1
37) print(f"¡Error!... La respuesta correcta es: {suma}")
38)
39) pausa = leer_booleano("\n¿Otra suma: [S][N]?: ")
40)
41) print(f"\nRespuestas acertadas: {buenas}")
42) print(f"Respuestas erradas: {malas}")
43)
44) jugar()
Explicación:
 En la línea tres se hace la importación de la función randint(), perteneciente al

módulo random. Recuerde que, al hacer una importación, se le está diciendo a
Python que dicha función podrá ser usada sin ningún problema dentro del
programa.
El módulo random contiene las funciones correspondientes a valores aleatorios.

Dentro de ellas se encuentra la función randint(), que presenta la siguiente forma
general:
randint(a, b)
133
randint genera de forma aleatoria un número entero con valores entre a y b,

ambos incluidos. El valor de a debe ser menor o igual al valor de b.
 En el programa se codificaron tres funciones de programador, dos de ellas realizan

la lectura de datos y la tercera ejecuta las instrucciones correspondientes al juego
de las sumas.
Como las funciones de lectura de datos han sido ampliamente explicadas en el

capítulo anterior, concentremos la atención en la función jugar().
 La función jugar() está escrita desde la línea 19 hasta la 38. No posee parámetros,
ni retorno.
La primera instrucción (línea 20) inicializa dos variables que harán el papel de
contadores dentro del ciclo, con ellas se contarán las respuestas correctas y las
erradas. Estos contadores inician con un valor de 0.
En la línea 21, se inicializa la variable centinela o de control llamada pausa. De

acuerdo a su inicialización en True, se deduce que es una variable de tipo
booleano. Ella es la encargada de permitir la repetición o terminación del ciclo.
El cuerpo del ciclo while, va desde la línea 23 hasta la línea 38. Su condición fue
definida con la siguiente expresión lógica:
while pausa:
Esta condición se interpreta como: mientras la variable pausa tenga un valor True,
ejecute el cuerpo del ciclo. En este caso la condición es verdadera, ya que en la
línea 21 le fue asignado este valor.
 Las dos primeras instrucciones del cuerpo del ciclo, asignan a las variables
numero1 y numero2, valores enteros aleatorios entre 1 y 9. Con estos valores,
en la fila 27 se realiza una operación de adición:
suma = numero1 + numero2
134
En la línea 29, se solicita que el usuario, en este caso el niño, que digite la
respuesta de la suma de estos números, la cual se almacenará en la variable
resultado:
resultado = leer_int(f"\n{numero1} + {numero2} = ")
Por ejemplo, suponga que a la numero1 = 5 y numero2 = 8, en pantalla se

vería así:
5+8=
Una vez el niño digite la respuesta, se procederá a evaluar la decisión de la

línea 31. El resultado de la variable suma (valor calculado en la línea 27) es
comparado con el valor digitado, el cual se almacena en la variable resultado
(respuesta del niño):
if resultado == suma:
Si esta condición es True se procede a incrementar el contador de respuestas

correctas y se imprime un mensaje de felicitación:
buenas += 1
print("Muy bien… ¡Felicitaciones!")
Si, por el contrario, la condición es False se incrementa el contador de

respuestas erradas y se hace la retroalimentación correspondiente:
malas += 1
print(f"¡Error!... La respuesta correcta es: {suma}")
Independientemente del valor de la condición del if, se continúa con la

ejecución de la línea 38, donde se le pregunta al usuario si quiere realizar otra
suma. El valor de la respuesta es almacenado en la variable centinela llamada
pausa, recuerde que la función leer_booleano() retorna un True o False.
135
pausa = leer_booleano("\n¿Otra suma: [S][N]?: ")
Como esta es la última instrucción del cuerpo del ciclo, se regresa al while
(línea 23) y se evalúa nuevamente la condición.
 Si la condición del while sigue siendo True, una vez más se repite el proceso.
Cuando la condición sea False, el control del programa lo asume la línea 40 donde
se imprime la cantidad de respuestas acertadas, seguidamente pasa a la línea 41
e imprime el total de respuestas erradas y finaliza la ejecución del programa.
4.1.1 Validación de datos de entrada
Las validaciones son controles que se ejercen a los datos en su entrada. Hasta el
momento se ha asumido que el usuario digita los valores correctamente, pero en la
vida real, es bien sabido que las cosas no son así; por esta razón es importante que,
desde el código del programa se establezcan los controles necesarios para que los
datos sean digitados correctamente.
Dentro de estas validaciones se pueden tener, por ejemplo, aquellas que controlen
que un número sea positivo o que esté dentro de un rango de valores; en el caso de
una cadena podría ser que se digite mínimo una cantidad de caracteres, entre otros.
A continuación, se desarrollarán algunos ejemplos que incluyen estas validaciones.
Ejemplo 4.6. El siguiente programa calcula la raíz cuadrada de un número. Se conoce

que, los números negativos no tienen raíz cuadrada dentro de los números reales,
por lo tanto, el programa evitará la entrada de números negativos e informará dicha
situación.
136
Una de las posibles soluciones a este enunciado, se presenta a continuación:
1) # Raiz cuadrada con validación

2)
3) from math import sqrt
4)
5) def leer_positivo(mensaje):
6) siga = True
7) while siga
9) if numero >= 0:
10) siga = False
11) else:
12) print(f"\n¡Error! El dato debe ser positivo\n")
13) return numero
14)
15) numero = leer_positivo("\nNúmero a calcular raíz: ")
16) raiz = sqrt(numero)
17) print(f"\nLa raíz de {numero} es: {raiz}")
Explicación:
 En la línea tres se hace la importación, desde el módulo math, de la función

sqrt(), que sirve para calcular la raíz cuadrada de un número.
 Desde la línea 5 a la 13 se define la función que valida la entrada de números

positivos.
La primera instrucción de la función, ubicada en la línea seis, inicializa la variable

centinela con el valor de True.
Acto seguido se establece un ciclo while. El cuerpo de este ciclo se encuentra entre
las líneas 8 y 12. Al evaluar la condición del while, el resultado que se obtiene es
verdadero:
137
while siga:
Así las cosas, se hace la lectura del dato en la línea ocho, el valor leído se almacena
en la variable numero.
Con el valor de la variable numero se plantea la siguiente condición:
if numero >= 0
Con esta expresión se evalúa que el número digitado sea mayor o igual a 0, es
decir, que no sea un número negativo. Si el resultado es True, se procede a
cambiarle el valor a la variable centinela:
siga = False
Luego de esta asignación, el control es devuelto a la cabecera del ciclo (línea siete)
donde se vuelve a evaluar la condición, dando un resultado False, con ello se
obliga a salir del ciclo y ejecutar la instrucción que está por debajo de él (línea 13).
En este punto se retorna el valor de la variable numero, el cual debe corresponder
a un 0 o a un número positivo.
Si la condición de la línea nueve, es False, el control pasa al else de la línea 11 y se

ejecuta la instrucción relacionada a él (línea 12), imprimiendo el mensaje: ¡Error!
El dato debe ser positivo. El control del ciclo regresa nuevamente a la línea siete y
evalúa una vez más la condición del while, dando como resultado un valor True,
ya que la variable siga no ha cambiado su valor inicial. De esta forma se vuelve a
solicitar y leer el dato. Todo el proceso se vuelve a repetir hasta que el usuario
digite un 0 o un número positivo.
La ejecución de esta función solo se termina con el ingreso de un 0 o un número

positivo.
 En la línea 15 se asigna a la variable numero el valor que digite el usuario, el cual

es devuelto por la función leer_positivo(), explicada en párrafos anteriores.
138
 Con la función sqrt(numero), se calcula el valor de la raíz cuadrada y se asigna a la

variable raiz el resultado (línea 16).
 Con la impresión del resultado en la línea 17 se termina la ejecución del programa.
Ejemplo 4.7. Una empresa de buses urbanos, desea un programa que permita
calcular cuánto devenga en total un conductor en un día domingo. El turno dominical
se paga con un incremento del 30% sobre el valor de turno normal, además por cada
pasajero que movilice, al conductor se le otorga un bono de $200.
Este enunciado corresponde al ejemplo 2.14, se había solucionado sin usar

validaciones en la entrada de datos.
En esta ocasión se tendrán en cuenta las siguientes consideraciones adicionales:
1) El nombre del conductor debe tener mínimo tres caracteres.

2) El valor del turno normal estará entre $25000 y $150000
3) La cantidad de pasajeros no puede ser negativa, ni sobrepasar los 5000
Teniendo en cuenta estas nuevas condiciones, se plantea la siguiente solución.
1) # Calcula el valor devengado por un conductor.

2) # Trabaja con validaciones
3)
4) def calcular_devengado(pasajeros, valor_turno):
5) BONO = 200
6) bono_pasajeros = BONO * pasajeros
7) devengado = valor_turno * 1.30 + bono_pasajeros
8) return devengado
9)
10) def leer_float(mensaje, minimo, maximo):
11) siga = True
12) while siga:
139
14) if numero >= minimo and numero <= maximo:

15) siga = False
16) else:
17) print(f"¡Error! El dato debe estar entre {minimo} y {maximo}")
18) return numero
19)
20) def leer_int(mensaje, minimo, maximo):
21) siga = True
22) while siga:
25) siga = False
26) else:
28) return numero
29)
30) def leer_cadena(mensaje, minimo):
31) siga = True
32) while siga:
34) if len(cadena) >= minimo:
35) siga = False
36) else:
37) print(f"¡Error! Debe digitar mínimo {minimo} caracteres")
38) return cadena
39)
40) print("Digite los siguientes datos\n")
41) nombre = leer_cadena("Nombre del conductor: ", 3)
42) valor_turno = leer_float("Valor turno normal: ", 25000, 150000)
43) pasajeros = leer_int("Cantidad de pasajeros: ",0,5000)
44)
45) devenga = calcular_devengado(pasajeros, valor_turno)
46)
47) print(f"\n{nombre}, usted devengará ${devenga}")
140
Explicación:
 Teniendo en cuenta que la lógica principal de este programa fue explicada en el

ejemplo 2.14, nos concentraremos en detallar el funcionamiento de las tres
funciones que se implementaron para validar datos de tipo int, float y str.
 La primera función de validación que se encuentra en el programa es leer_float().

En los programas anteriores se había empleado una función similar con un solo
parámetro, en esta ocasión se tendrán tres parámetros:
def leer_float(mensaje, minimo, maximo):
mensaje: recibe el mensaje para solicitar la entrada del dato al usuario.

minimo y maximo: reciben los valores mínimo y máximo que tendrá el número a
leer.
Las instrucciones de las líneas 11, 12 y 13, son exactamente las mismas del
ejemplo 4.6, anterior a este. En ellas se inicializa la centinela en True, se plantea
la condición del while, que es verdadera en su primera evaluación y se lee un
número float que se almacena en la variable numero.
Ya en la línea 14, donde se plantea la decisión del if, difiere un poco al ejemplo
4.6:
if numero >= minimo and numero <= maximo:
En este caso se pregunta qué si el número digitado es mayor o igual al valor

mínimo y menor o igual al valor máximo, ambos valores son enviados como
argumento en el momento de llamar a la función. En pocas palabras se indaga si
el valor digitado está en el rango de los números válidos.
Si esta condición es True se cambia el valor de la variable siga, que actúa como
centinela o control del while, de tal forma qué al evaluar nuevamente la condición
del ciclo, obliga a salir de él y hacer el retorno del valor digitado.
141
Si la condición es False, se imprime un mensaje informando que hay un error y

que el dato digitado debe estar entre un valor mínimo y máximo:
print(f"¡Error! El dato debe estar entre {minimo} y {maximo}")
Una vez se informe del error, se procederá a evaluar la condición del while, la cual
dará nuevamente True, ya que la variable centinela no ha cambiado su valor
inicial. El proceso se repite y termina cuando se digite un valor que esté dentro
del rango que se establezca.
 La siguiente función de validación que se codificó es leer_int(). Ella presenta tres

parámetros:
leer_int(mensaje, minimo, maximo):
Funciona exactamente igual a la anterior, la única diferencia radica en la

conversión de datos que hace en la línea 23, en esta se convierte a int, en la
anterior función la conversión se hace a datos de tipo float.
 La tercera función de validación es leer_cadena() que contiene dos parámetros:
leer_cadena(mensaje, minimo):
mensaje: recibe el mensaje para solicitar la entrada del dato al usuario.

minimo: recibe un valor numérico que indica la cantidad mínima de caracteres que
debe tener la cadena que se va a leer.
Al igual que las funciones anteriores, se procede a inicializar en True a la variable

siga, que actúa como centinela o variable de control del while. Luego se plantea
la condición del while, que es verdadera en su primera evaluación. Seguidamente
se hace la lectura de la cadena:
siga = True
while siga:
cadena = input(mensaje)
142
Luego de la lectura, se plantea la siguiente decisión:
if len(cadena) >= minimo:

siga = False
else:
print(f"¡Error! Debe digitar mínimo {minimo} caracteres")
Recuerde que la función len(), determina la longitud de una cadena. En esta

condición se está preguntando si la longitud o tamaño de la cadena es mayor o
igual al mínimo, es decir, al mínimo número de caracteres que debe tener.
Si esta condición es True, se trata de una cadena con una longitud válida, en cuyo
caso, se procede a cambiar el valor de la variable siga, con lo cual se saldrá del
ciclo en la próxima evaluación del while. Una vez se salga del ciclo se procede a
retornar el valor almacenado en la variable cadena.
Si la condición es False, se imprime el mensaje de error. La variable siga no cambia

de valor, por lo tanto, el control del programa sigue en el ciclo while y procede a
realizar una nueva lectura.
Cuando el control del programa salga del ciclo while, se procede a retornar el valor
de la variable cadena:
return cadena
 En cuanto a la solicitud de los datos, esta se hace en las líneas 41, 42 y 43. Analice
las tres instrucciones que se emplean:
1. nombre = leer_cadena("Nombre del conductor: ", 3)
Solicita el nombre del conductor y envía un 3 como argumento, esto significa

que la longitud de la cadena que se digite debe tener mínimo 3 caracteres.
143
2. valor_turno = leer_float("Valor turno normal: ", 25000, 150000)
Con el valor del turno se está indicando que mínimo debe ser de 25000 y
máximo 150000.
3. pasajeros = leer_int("Cantidad de pasajeros: ", 0, 5000)
Finalmente, la cantidad de pasajeros debe estar entre 0 y 5000. Recuerde

que el enunciado dice “la cantidad de pasajeros no puede ser negativa, ni
sobrepasar los 5000”.
 A pesar que el enunciado fue muy preciso en los valores que debe recibir el
programa, se hizo de manera genérica, de tal forma que pueda ser usado con
cualquier otro problema. Solamente bastaría con cambiar los argumentos al
momento de llamar las funciones.
Actividad 4.1. Usando el ciclo while y los demás temas vistos hasta ahora, si son
necesarios, escriba los programas que den solución a los siguientes enunciados.
a. Calcule la tabla de multiplicar de cualquier número. La tabla debe tener n filas. El

número para la tabla y la cantidad de filas será determinado por el usuario.
c. Calcule la sumatoria de los números pares e impares de una cantidad de números

dada por el usuario. El programa no debe permitir la entrada del número 0.
d. Construya un juego donde se generare un número aleatorio entre 1 y 15, que no

será mostrado al usuario hasta el final. El jugador deberá adivinar cuál número es,
para ello tendrá máximo cinco oportunidades. En cada respuesta errada, se
informará si el número digitado es mayor o menor al aleatorio.
El juego terminará por una de dos razones. La primera porque el usuario adivine
el número, en cuyo caso se le felicitará y a la vez se le informa en cuántos intentos
lo hizo. La segunda razón es porque se agotaron las cinco oportunidades. Cuando
144
el usuario pierda se le mostrará el siguiente mensaje: “Lo siento, será en una

próxima oportunidad”, se debe informar cuál era el número oculto.
e. De acuerdo con el enunciado del ejemplo 3.8, solucionado en el capítulo anterior,

el cual plantea que Georg Simon Ohm, físico y matemático, estableció la ley de
Ohm, la cual determina las leyes de la corriente eléctrica. La fórmula general de la
ley de Ohm es la siguiente:
V=I*R
Donde, V representa el voltaje, I representa la corriente y R la resistencia.
Construya un programa que permita calcular cualquiera de estas variables,

partiendo del hecho que se conocen las otras dos.
Tenga en cuenta las siguientes consideraciones:
1. El usuario podrá elegir, las veces que quiera, cuál de las variables desea
calcular.
2. El programa terminará cuando el usuario lo determine.
3. Las entradas de datos deben estar validadas.
4.2 Instrucción for
Al igual que la instrucción while, el for se usa para repetir una o un conjuntos de
instrucciones un determinado número de veces.
La forma general de esta instrucción es la siguiente:
for variable in iteración:

Instrucción1
Instrucción2
.
.
Instrucción_n
145
Esta forma general se interpreta de la siguiente manera:
 for: es una palabra reservada que se usa para codificar instrucciones que se
repetirán n veces.
 variable: almacena el ítem referenciado en iteración.
 in: palabra reservada que especifica la pertenencia de un elemento dentro de una

secuencia.
 iteración: son los elementos sobre los cuales actúa el ciclo, pueden ser un dato de
tipo secuencia o una función range().
 Instrucción1, Instrucción2, Instrucción_n: son las instrucciones que conforman el

cuerpo del ciclo. Se ejecutarán mientras el ciclo itere.
Antes de iniciar con los ejemplos de aplicación de este ciclo, vamos a analizar la
función range(), la cual será ampliamente usada con la instrucción for.
Función range()
Devuelve todos los datos entre dos valores, el primero incluido y el segundo excluido:
range(vi, vf, cambio)
vi: indica el valor inicial del rango
vf: es el valor final excluído, es decir, no será tenido en cuenta dentro de la lista de
valores generados.
cambio: indica cómo debe comportarse la lista de valores, puede ser un valor positivo
o negativo. Es opcional.
146
Por ejemplo, para generar los números entre el 10 y el 49, se usa así:
range(10, 50)
Para los números entre el 10 y el 50, pero de 2 en 2:
range(10, 51, 2)
Con la anterior expresión se generan los números: 10, 12, 14, … , 46, 48, 50
Ahora bien, también puede ser usada para generar los números en orden
descendente. La siguiente expresión genera los números del 10 al 1:
range(10, 0, -1)
El valor inicial también puede omitirse:
range(10)
En este caso la función range(), genera los números desde el 0 hasta el 9.
Ejemplo 4. 8. Este programa imprime los números del 1 al 10.

2)
3) for i in range(1, 11):
4) print(i)
Explicación:
 Se plantea el ciclo for con la siguiente cabecera:
for i in range(1, 11):
147
La variable i opera como control del ciclo, ella recorre y va tomando los valores
generados en la función range(), en este caso los números del 1 al 10.
En primera instancia la variable i toma el primer valor generado por range(1, 11),
o sea, toma el valor de 1, luego ejecuta el cuerpo del ciclo en donde imprime el
valor de i. Regresa nuevamente al for y la variable i toma el valor del 2, que es
parte del rango de valores generados por range(), nuevamente ejecuta el cuerpo
del ciclo donde imprime el número 2. El proceso continúa de esta misma manera,
hasta llegar al valor de 10, en cuyo caso hace la última impresión y se sale del ciclo,
terminando el programa.
 Recuerde que este ejemplo ya se había solucionado con el ciclo while, compare
las dos estructuras y podrá apreciar que el ciclo for es más simple en su
codificación:
Usando for Usando while
for i in range(1, 11): numero = 1

print(i)
while(numero <= 10):
print(numero)
numero += 1
Ejemplo 4.9. Con este ejemplo se mostrará que los valores generados por la función
range(), pueden ser asignados a una variable. Retomaremos el ejemplo anterior y se
imprimirán los números del 1 al 10.

2) # Usando for con range() en una variable
3)
4) numeros = range(1,11)
5)
6) for i in numeros:
7) print(i)
148
Explicación:
El funcionamiento y el resultado del programa, es el mismo del ejemplo anterior, solo

que la secuencia está almacenada en la variable numeros.
Ejemplo 4.10. Con este programa se mostrará como la iteración se hace usando una
cadena de caracteres.
1) # Usa una cadena como elemento de iteración

2)
3) palabra = input("Digite una palabra: ")
4)
5) print("\nLas letras de la palabra son:\n")
6)
7) for i in palabra:
8) print(i)
Explicación:
 La variable de control va tomando el valor de cada carácter de la palabra, a la vez

que ejecuta el cuerpo del ciclo en donde los imprime.
 En una ejecución del programa, donde se digite la palabra Python, se vería así:
Digite una palabra: Python
Las letras de la palabra son:
P
y
t
h
o
n
149
Ejemplo 4.11. Este programa solicita un número y calcula su correspondiente tabla

de multiplicar con 9 filas.
1) # Solicita un número y le calcula su tabla de multiplicar

2)
5) return numero
6)
7) tabla = leer_int("Ingrese la tabla a calcular: ")
8)
9) print(f"\nTabla del {tabla}\n")
10)
11) for fila in range(1, 10):
12) producto = tabla * fila
13) print(f"{tabla} * {fila} = {producto}")
Explicación:
 Luego de asignar a la variable tabla el valor de la tabla calcular (línea siete), se

imprime el mensaje que indica a cuál tabla se le está haciendo el cálculo (línea
nueve).
 En la línea 11, se codifica el ciclo for:
for fila in range(1, 10):
Con esta expresión la variable fila va tomando los valores entre 1 y 9.

Seguidamente se ejecuta el cuerpo del ciclo.
 El cuerpo del ciclo está conformado por dos instrucciones. La primera va

multiplicando el valor de la variable tabla que ingresó el usuario, por el valor de la
variable fila, que hace parte de la cabecera del ciclo for y va iterando sus valores
entre 1 y 9:
150
producto = tabla * fila
La segunda instrucción del ciclo, imprime en pantalla el valor de las variables tabla,
fila y producto.
print(f"{tabla} * {fila} = {producto}")
 Suponiendo que la tabla a calcular sea la del número 5, en una de las ejecuciones
del programa, se observaría lo siguiente:
Ingrese la tabla a calcular: 5
Tabla del 5
5*1=5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
Ejemplo 4.12. Un número primo, es un número mayor que 1 que es divisible por sí
mismo y por la unidad. Son ejemplos de números primos: 2, 3, 5, 7, 11, 41, 97, 157,
439, 521, 617, 809, 911.
Este programa captura un número dado por el usuario y determina si es o no un

número primo. Teniendo en cuenta la definición dada en el párrafo anterior, si el
número es 0 o negativo, se debe informar la situación.
Una posible solución se presenta a continuación:
151
1) # Dado un número mayor o igual a 1, determinar si es primo o no

2)
5) return numero
6)
7) def es_primo(numero):
8) divisiones = 0
9)
10) for i in range(1, numero + 1):
11) if numero % i == 0:
12) divisiones += 1
13)
14) if divisiones == 2:
15) es_num_primo = True
16) else:
17) es_num_primo = False
18)
19) return es_num_primo
20)
21) numero = leer_int("Digite un número mayor a 0: ")
22)
23) if numero <= 0:
24) print("Debe ser un número positivo")
25) else:
26) if es_primo(numero):
27) print(f"{numero} es número primo")
28) else:
29) print(f"{numero} no es un número primo")
Explicación:
Se dará la explicación de acuerdo a la ejecución que realiza el intérprete de Python.
 En la línea 21 a la variable numero se le asigna el valor que haya digitado el usuario.

Este valor es leído y devuelto por la función leer_int(), la cual ha sido ampliamente
explicada en los programas anteriores.
152
 En la línea 23 se plantea una decisión para determinar si el número digitado es un

número menor o igual a cero. En el caso de que la condición sea True, se informará
dicha situación para luego salir de la decisión y terminar así la ejecución del
programa.
Si la condición es False, se toma una segunda decisión donde se hace el llamado a

la función es_primo(numero), enviando como argumento el número leído. Si esta
condición es verdadera, se imprime el mensaje informando que, si es un número
primo, en caso contrario se informa que no lo es.
 En la decisión explicada en el párrafo anterior se hizo el llamado a la función

es_primo(numero), la cual se explicará a continuación:
El cuerpo de la función va desde la línea 8 a la 19. La primera instrucción inicializa

la variable divisiones en 0. Esta variable tendrá la tarea de contar el número de
divisiones exactas que se le pueden hacer al número, lo cual servirá para decidir
si es un primo o no.
En la línea diez, la variable i hace el recorrido dentro de la secuencia de valores

generada por la función range(), esta secuencia va desde 1 hasta el valor del
número que se está evaluando.
En cada iteración del ciclo se evalúa la condición del if que, pregunta si el número
dividido entre el valor de i deja como residuo 0, es decir, si es una división exacta.
Si la anterior condición es True, se adiciona una unidad a la variable divisiones:
for i in range(1, numero + 1):

if numero % i == 0:
divisiones += 1
Lo que se está haciendo con este ciclo es inicializar la variable i en 1 y llevarla hasta
el valor del número que se está evaluando. El número en cuestión, es divido entre
153
cada valor que tome la variable i, a la vez que se van contando las divisiones
exactas que se le puedan practicar.
Note que el cuerpo del ciclo consiste solamente en una instrucción if, y a la vez, el
cuerpo del if consta de una operación.
 Una vez se termine la ejecución del ciclo for, se procede a evaluar el if de la línea
14:
if divisiones == 2:
Esta pregunta verifica que si el número en evaluación obtuvo 2 divisiones exactas;

recuerde que un número primo solo soporta esta cantidad de divisiones, una
entre sí mismo y otra entre la unidad. Al ser True esta condición, se determina que
es un número primo, en caso contrario no lo es.
 Finalmente, la función retorna el valor de la variable es_num_primo.
En los ejemplos del for que se plantearon en este apartado, solo se mostró el manejo
con cadenas y con la función range(); en el siguiente capítulo se estudiarán programas
que usarán las tuplas, listas y diccionarios como elemento de iteración del for.
Actividad 4.2. Dados los siguientes enunciados, escriba las correspondientes

soluciones a través de un programa en Python.
a. Imprima los números desde el -100 al 0, en múltiplos de 4.
b. Calcule la potencia de un número mediante multiplicaciones sucesivas.
c. Lea un número desde el teclado e imprima todos los números primos menores al
número leído.
d. Encuentre la sumatoria de los números pares desde 1 hasta n.
154
e. Escriba un programa que imprima la siguiente serie de números:
f. 1 3 5 7 9 11 … n
g. Un número es perfecto si la suma de sus divisores propios positivos resulta igual

al número.
155
CAPÍTULO 5
5 COLECCIONES
Objetivos:
 Identificar los diferentes tipos de colecciones que ofrece Python.
 Incorporar las colecciones en la solución de un problema.
 Determinar qué tipo de colección usar dependiendo del problema
a resolver.
 Construir programas que combinen el uso de colecciones.
 Realizar operaciones de matrices matemáticas usando listas.
Colecciones
Todas las variables que se han trabajado hasta el momento reciben un único valor.
Sin embargo, existen variables que tienen la capacidad de almacenar colecciones de
datos de diferentes tipos. Con ellas se pueden agrupar varios objetos bajo un mismo
nombre.
En este capítulo se estudiarán las tuplas, las listas y los diccionarios, elementos que
fueron definidos en el capítulo uno de este libro. Estos tipos de datos nos permitirán
manejar la información de una manera más ordenada. El tema inicia con las tuplas,
luego continúa con las listas en 1 y 2 dimensiones, finalizando con el estudio de los
diccionarios.
5.1 Tupla
Una tupla es de tipo tuple. Es una colección organizada de objetos. Se les conoce
como objetos inmutables, es decir no son modificables. Los objetos que hacen parte
de la tupla pueden ser del mismo tipo o de una combinación de ellos. Una tupla se
identifica porque sus elementos están separados por comas, pueden o no estar
encerrados entre paréntesis.
A continuación, se presentan varios ejemplos de tuplas:
 Tupla vacía:
()
 Tuplas con un solo objeto o elemento:
(2018, )
("Luna", )
161
Cuando una tupla está conformada por un solo elemento, este debe ir
acompañado de una coma (,). Si se dejara sin la coma, el tipo de dato ya sería
diferente:
(2018): sin la coma, sería de tipo int.

("Luna"): sin la coma, sería de tipo str.
 Tupla con varios elementos numéricos de tipo entero:
(20, 42, -320)
 Las tuplas también pueden estar compuesta por elementos de diferente tipo de
dato:
(4.5, "Niña", 35, -8, "Luna", "Rocco")
 Una tupla puede contener otra tupla:
("Benji", (2010, "Bruno", 43))
 La tupla no necesariamente debe estar entre paréntesis, basta con separar los
elementos mediante comas:
4.5, "Niña", 35, -8, "Luna", "Rocco"
Pero es aconsejable hacer uso de ellos.
5.1.1 Impresión de una tupla
El contenido de una tupla se puede mostrar usando una instrucción print(). A

continuación, se construirán tres tuplas denominadas numeros, datos y combinada,
seguidamente se mostrará sus contenidos.
162
numeros = (10, 12, -20)

datos = (1.5, "Niña", 17, -3, "Luna", "Lola", "Gunther")
combinada = ("Benji", (2014, "Canela", 12))
Como se observa, la primera tupla está compuesta por datos numéricos de tipo
entero, la segunda presenta la combinación de tipos de datos float, int y str; por
último, se construyó una tupla que contiene otra tupla.
Para mostrar sus datos, basta con usar la función print():
print(numeros)
print(datos)
print(combinada)
El resultado que producen estas tres instrucciones, es el siguiente:
(10, 12, -20)

(1.5, 'Niña', 17, -3, 'Luna', 'Lola', 'Gunther')
('Benji', (2014, 'Canela', 12))
Usando subíndices
Los elementos dentro de una tupla ocupan una posición específica, que inicia desde
0 y va hasta n -1 elemento. Por ejemplo:
vehiculos = ("Automóvil", "Bicicleta", "Campero", "Motocicleta")
En el anterior caso de la tupla llamada vehiculos se tiene que, cada elemento ocupa
las siguientes posiciones:
Elemento Posición
Automóvil 0
Bicicleta 1
Campero 2
Motocicleta 3
163
Aunque son 4 elementos, las posiciones van desde el 0 al 3, es decir, desde 0 hasta n
- 1.
Si se quisiera mostrar el elemento Campero que se encuentra en la posción 2, se

usaría la siguiente instrucción print():
print(vehiculos[2])
Una misma instrucción print(), puede usarse para mostrar datos de diferentes tuplas.
Retomemos las tuplas que se usaron anteriormente:
numeros = (10, 12, -20)

Con base a estos valores, analice la siguiente instrucción:
print(numeros[0], datos[1], datos[4], datos[3], combinada[0], combinada[1][1)
Los resultados que se obtienen son:
10 Niña Luna -3 Benji Canela
Donde, el número 10 ocupa la posición 0 de la tupla numeros. Las cadenas Niña y

Luna y el número -3, ocupan las posiciones 1, 4 y 3 respectivamente, de la tupla
llamada datos. La cadena Benji, ocupa la posición 0 de la tupla llamada combinada.
Algo especial que se aprecia en esta instrucción, es el uso de dos índices en el último
argumentos de la instrucción print():
combinada[1][1]
164
Con relación a estos índices, hay que tener claro que la tupla combinada está
conformada por una cadena (Benji) y una tupla. En la posición 0 de combinada está
Benji, en la posición 1 está la tupla, que a su vez contiene 3 elementos, distribuidos
así:
Elemento Posición
2014 0
Canela 1
12 2
Para hacer referencia a los elementos de la tupla interna, se emplean los dos índices,
el primero indica la posición de la tupla interna dentro de combinada, el segundo es
la posición de los elementos referenciados en la tabla anterior. Por lo tanto,
combinada[1][1] hace referencia la cadena Canela.
Es importante resaltar que, también es válido usar los índices especificando los
valores de otra forma. Volvamos a la tupla datos para ver cómo funciona:
Esta tupla tiene siete elementos, que van desde la posición 0 a la 6. Si se emplea la
siguiente instrucción:
print(datos[1:4])
Se obtiene la impresión de los valores que se encuentren en la posición que se

indique con el primer número, hasta una menos de lo que señale el segundo valor.
En este caso se obtienen los elementos de las posiciones 1, 2 y 3:
('Niña', 17, -3)
Con el siguiente print(), se muestran los elementos desde la posición 0 hasta la

posición 5, con incrementos de 2 en 2. El último valor representa ese incremento:
print(datos[0:6:2])
165
De esta forma se obtiene la impresión por pantalla de los valores de las posiciones 0,
2 y 4:
(1.5, 17, 'Luna')
Así mismo, se puede usar solamente el valor del incremento. En el siguiente ejemplo
se muestran los valores desde la posición 0, hasta la última posición, con incrementos
de 2 en 2.
print(datos[::2])
El resultado de esta instrucción es:
(1.5, 17, 'Luna', 'Gunther')
Si el valor del incremento se usa con valor negativo, la impresión se hace de manera
inversa. Ejemplo:
print(datos[:: -1])
La salida se apreciaría así:
('Gunther', 'Lola', 'Luna', -3, 17, 'Niña', 1.5)
5.1.2 Funciones y métodos para tuplas
Algunas de las funciones que se aplican con otros tipos de datos, también pueden ser
usadas con las tuplas.
Para los ejemplos de las funciones que se estudiarán a continuación, recordemos los
valores de las tuplas que se vienen trabajando:
numeros = (10, 12, -20)

166
Función len()
La primera función que se aplicará, será la función len(), recuerden que esta función
se trabajó en el capítulo de funciones y se utiliza para determinar la longitud de un
objeto de tipo cadena, tupla o lista. Si se usa con una cadena, devuelve la cantidad
de caracteres que esta posea, en el caso de las tuplas, retorna el número de
elementos que la conforman. Ejemplos:
 print(len(combinada))
Devuelve el valor de 2, cantidad de elementos de la tupla llamada combinada.
 print(len(combinada[1]))
En la posición 1, de la tupla combinada hay otra tupla, la cual está conformada por
tres elementos y es precisamente este el resultado de esta instrucción.
 print(len(combinada[1][1]))
En este caso la función len(), opera sobre el elemento de la posición 1, de la tupla

que está dentro de combinada. El valor resultante es 6, correspondiente a la
cantidad de caracteres de la cadena Canela.
 print(len(datos))
La longitud o cantidad de elementos de la tupla datos es de 7.
 print(len(datos[1]))
La longitud del elemento de la posición 1, de la tupla datos es de 4, que

corresponde a la cantidad de caracteres de la cadena Niña.
167
 print(len(numeros))
La cantidad de elementos de la tupla numeros es de 3.
 print(len(numeros[1]))
En este caso, el resultado de esta instrucción será un mensaje de error:
TypeError: object of type 'int' has no len()
En el cual se indica que a un valor de tipo int (entero) no se le puede determinar

la longitud. Caso que también aplica para los datos de tipo float.
Método count()
Se usa para contar la cantidad de veces que se encuentra un elemento dentro de una
tupla. Ejemplo:
numeros = (5, 20, 30, 5, 4, 8, 3, 5, 6, 11)

veces = numeros.count(5)
print(veces)
Imprime como resultado el número 3, cantidad de veces que se encuentra el número

5 dentro de la tupla.
Método index()
Devuelve la posición, de la primera ocurrencia, de un elemento dentro de la tupla.

Ejemplo:
indice = numeros.index(3)
print(indice)
Imprime un número 6 como resultado, indicando con ello que el número 3 se

encuentra en la posición 6 de la tupla numeros.
168
Funciones max() y min()
Devuelven el mayor y menor valor dentro de una tupla. Ejemplo:
numeros = (5, 20, 30, 5, 4, 8, 3, 5, 6, 11)

maximo = max(numeros)
print(maximo)
Imprime como resultado el número 30.
Ahora usemos la función min con la misma tupla:
minimo = min(numeros)
print(minimo)
Imprime como resultado el número 3
Estas funciones también pueden ser usadas con valores de tipo str (string). Ejemplo:
datos = ("Emma", "Niña", "Benji", "Bruno", "Luna", "Lola", "Gunther")

maximo = max(datos)
print(maximo)
minimo = min(datos)
print(minimo)
En pantalla se visualiza Niña y luego Benji, ya que son el mayor y el menor valor entre
los datos de tipo cadena, respectivamente.
Con el uso de estas funciones, se debe tener precaución ya que no funcionan cuando
las tuplas tienen diferentes tipos de datos, por ejemplo:

maximo = max(datos)
169
La salida en este ejemplo sería:
TypeError: '>' not supported between instances of 'str' and 'float'
Se indica así que, la función no soporta la combinación de datos de tipo str y float,
aunque siendo más precisos no soporta la combinación de tipos. Todos los elementos
deben ser de tipo str o de tipo numérico.
5.1.3 Desempaquetado de tuplas
Cuando una tupla es asignada a una variable, realmente lo que sucede es que esa
variable guarda todos los elementos de la tupla, a esto se le conoce como
empaquetar. El proceso inverso, es decir, el desempaquetado se logra asignando el
valor de esa variable que contiene la tupla, a una cantidad de variables igual a lo
longitud de la tupla. Para mejor ilustración analicemos el siguiente programa:
Ejemplo 5.1. Almacena una tupla en una variable y luego la desempaqueta.
1) # Desempaquetar una tupla

2)
3) libro = ("Python",2019, "Programación")
4)
5) titulo, publicacion, area = libro
6)
7) print(f"El título del libro es: {titulo}")
8) print(f"Fue pubicado en el año: {publicacion}")
9) print(f"Pertenece al área de: {area}")
Explicación:
 A la variable libro, se le asigna una tupla conformada por tres elementos. En ese
momento la tupla es almacenada dentro de dicha variable. Esto es conocido como
empaquetar una tupla.
170
En la línea cinco se procede a desempaquetar la variable libro, para ello se usa la

siguiente expresión:
titulo, publicacion, area = libro
Con ella se logra que los valores almacenados en la variable libro, se asignen a las
variables titulo, publicacion y area. Estos valores son asignados de acuerdo al
orden que ocupan en la tupla (línea tres).
 Luego en las líneas 7, 8 y 9 se procede a hacer la siguiente impresión:
El título del libro es: Python

Fue publicado en el año: 2019
Pertenece al área de: Programación
5.1.4 Múltiples valores de retorno
Todos los programas que se han construido con la función return, han devuelto un
solo valor. Gracias a las tuplas podremos retornar múltiples valores desde una misma
función y al mismo tiempo. Ilustremos esta situación mediante el siguiente ejemplo.
Ejemplo 5.2. Este programa calcula la división entera y el módulo de dos valores entre
1 y 1000.
1) # Halla la división entera y el módulo entre dos números entre 1 y 1000

2)
4) seguir = True
5) while seguir:
8) seguir = False
9) else:
10) print(f"\n¡Error! El dato debe estar entre {minimo} y {maximo}\n")
11) return numero
171
12)
13) def cociente_modulo(dividendo, divisor):
14) cociente = dividendo // divisor
15) modulo = dividendo % divisor
16) return cociente, modulo
17)
18) dividendo1 = leer_int("Ingrese dividendo: ", 1, 1000)
19) divisor1 = leer_int("Ingrese divisor: ", 1, 1000)
20)
21) cociente1, modulo1 = cociente_modulo(dividendo1, divisor1)
22) print(f"\nEl cociente es: {cociente1}, el residuo es: {modulo1}")
Explicación:
 Este programa es similar a todos los que se han hecho con funciones con retorno.
La característica principal radica en que se usa una función que retorna dos valores
de manera simultánea. La función que realiza esta tarea se llama
cociente_modulo() y está escrita entre las líneas 13 y 16.
Es una función sencilla, recibe dos valores (dividendo y divisor), con los cuales se
procede a hacer una división entera y a calcular un residuo:
cociente = dividendo // divisor

modulo = dividendo % divisor
Lo interesante de esta función está en la siguiente línea, con la cual los valores
resultantes son retornados mediante un solo return:
return cociente, modulo
Al tener dos elementos separados por coma, estamos frente a la definición de una
tupla, entonces lo que en realidad se está retornando es una tupla empaquetada.
172
 En la línea 21 la expresión de asignación que se presenta, recibe los valores

retornados desde la función cociente_modulo():
cociente1, modulo1 = cociente_modulo(dividendo1, divisor1)
 Finalmente, en la línea 22 se imprimen los resultados.
Ejemplo 5.3. Este programa lee un número correspondiente a un número de un mes

del año y determina a qué estación pertenece, de acuerdo con la siguiente tabla:
Meses Estación
Diciembre, enero, febrero Invierno
Marzo, abril, mayo Primavera
Junio, julio, agosto Verano
Septiembre, octubre, noviembre Otoño
A continuación, se muestra una de las posibles soluciones:
1) # Determina la estación del año, dependiendo del mes que se digite

2)
4) seguir = True
5) while seguir:
8) seguir = False
9) else:
11) return numero
12)
13) def definir_estacion(mes):
14) estaciones = ("Invierno", "Primavera", "Verano", "Otoño")
15) meses = ("Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio",
16) "Agosto", "Septiembre", "Octubre" , "Noviembre", "Diciembre")
17)
173
18) if mes == 12 or mes == 1 or mes == 2:

19) estacion = 0
20) elif mes >= 3 and mes <= 5:
21) estacion = 1
22) elif mes >= 6 and mes <= 8:
23) estacion = 2
24) else:
25) estacion = 3
26)
27) mes = mes - 1
28)
29) return(meses[mes], estaciones[estacion])
30)
31) mes = leer_int("Escriba el número de un mes: ", 1, 12)
32) nombre_mes, estacion = definir_estacion(mes)
33) print(f"A {nombre_mes} le corresponde {estacion}")
Explicación:
 Teniendo en cuenta que la entrada de los datos y la función leer_int() ya se ha

trabajado ampliamente en el desarrollo del libro, la explicación se concentrará en
la función definir_estacion() y en su forma de operar.
Esta función va desde la línea 13 a la 29. Recibe como parámetro el número del
mes del año.
Inicialmente se definen dos tuplas. La primera está compuesta por los nombres
de las estaciones del año, la segunda contiene los nombres de los meses.
Entre las líneas 18 y 25 se encuentra un bloque de decisiones if-elif, con las cuáles
se verifica el número del mes y de acuerdo a eso, la variable estacion toma un
valor entre 0 y 3, que hacen referencia a la posición que ocupa la estación dentro
de la tupla. Por ejemplo, para los meses de diciembre (12), enero (1) o febrero (2),
corresponde la posición 0 de la tupla, es decir, Invierno.
174
La instrucción de la línea 27:
mes = mes - 1
Le resta 1 unidad al mes que el usuario digitó, esto debido a que en la tupla el mes
de enero se guarda en la posición 0, febrero en la posición 1 y así sucesivamente.
Como instrucción final de la función se encuentra el return:
return(meses[mes], estaciones[estacion])
Con ella se retorna el nombre del mes que se encuentre en la posición que indica
el valor de la variable mes y el nombre de la estación que se encuentre en la
posición del valor de la variable estacion.
 Estos valores son entregados a la instrucción de la línea 32, donde se produce la

acción de desempaquetar la tupla que se recibió:
nombre_mes, estacion = definir_estacion(mes)
A nombre_mes se le asigna el valor de la posición 0 de la tupla devuelta por la

función definir_estacion() y a la variable estacion se le asigna el valor de la posición
1.
5.1.5 Uso del ciclo for
En el capítulo anterior se estudió el ciclo for, donde la mayoría de los ejemplos se

hicieron utilizando la función range(). Sin embargo, quedó pendiente analizar su
funcionamiento con tuplas, listas y diccionarios como elemento de iteración.
En este momento se usará en conjunto con las tuplas, más adelante en este capítulo
se estudiarán los otros dos elementos.
175
La forma general del ciclo for se especificó de la siguiente manera:
for variable in iteración:

Instrucción1
Instrucción2
.
.
Instrucción_n
Donde iteración, hace mención a cualquier elemento que permita hacer un recorrido
dentro de él. Precisamente las tuplas, las listas y diccionarios tienen esa
característica.
Por ejemplo, suponga que tiene una tupla con el nombre de las últimas cuatro series
de televisión que ha visto:
series = ("Lucifer", "Blacklist", "Los 100", "La casa de papel")
Ahora se imprimirá este listado usando un ciclo for, así:
# Primera forma
for i in range(0, len(series)):

print(series[i])
La variable i va tomando valores desde 0 hasta la longitud de la tupla menos 1, o sea,

itera entre 0 y 3, ambos valores incluidos, con lo cual se obtiene el siguiente
resultado:
Lucifer
Blacklist
Los 100
La casa de papel
176
Seguidamente, se mostrará el mismo listado, pero, junto a la posición que ocupa cada
serie dentro de la tupla:
# Segunda forma
for i in range(0, len(series)):

print(i, series[i])
Resultado obtenido:
0 Lucifer
1 Blacklist
2 Los 100
3 La casa de papel
Aunque estas dos formas de obtener los resultados son válidas, no son las mejores,
ya que no se está aprovechando la potencialidad que tienen Python de usar las tuplas
como elemento iterador. Una mejor solución se puede apreciar a continuación:
# Tercera forma
for i in series:
print(i)
El resultado de estas líneas de código es exactamente el mismo obtenido con la

primera forma empleada:
Lucifer
Blacklist
Los 100
La casa de papel
Así mismo, la segunda forma que se codificó, se puede mejorar usando la función
enumerate().
177
Función enumerate()
Esta función se usa para enumerar colecciones. Su forma general es la siguiente:
enumerate(colección)
Donde, colección puede ser una colección de elementos, tal como una tupla, lista o
diccionario. La función retorna dos valores, el primero es la posición de un elemento
dentro de la colección, el segundo es el elemento en sí. Así las cosas, la cuarta forma
de imprimir los elementos de una tupla es:
# Cuarta forma
for i, dato in enumerate(series):

print(i, dato)
El resultado es el mismo de la segunda forma, muestra la posición y el nombre de la

serie en la tupla:
0 Lucifer
1 Blacklist
2 Los 100
3 La casa de papel
Ejemplo 5.4. Este programa imprime los números del 0 al 99 en cifras y en palabras.
1) # Muestra los números entre 0 y 99 en cifras y en palabras

2)
3) def convertir(valor):
4) unidades = ("Cero", "Uno", "Dos", "Tres", "Cuatro", "Cinco", "Seis", "Siete", "Ocho",
5) "Nueve", "Diez", "Once", "Doce", "Trece", "Catorce", "Quince",
6) "Dieciséis", "Diecisiete", "Dieciocho", "Diecinueve", "Veinte")
7)
8) decenas = ("Veinti", "Treinta", "Cuarenta", "Cincuenta", "Sesenta", "Setenta",
9) "Ochenta", "Noventa")
178
10)
11) if valor >= 0 and valor <= 20:
12) letras = unidades[valor]
13) else:
14) decena = valor // 10 - 2
15) unidad = valor % 10
16)
18) letras_decenas = decenas[decena]
19) letras_unidades = unidades[unidad].lower()
20)
21) letras = letras_decenas + letras_unidades
22) else:
24) letras = decenas[decena]
25) if unidad > 0:
26) letras = letras + " y " + unidades[unidad].lower()
27)
28) return(letras)
29)
30) print("\nNúmeros del 0 al 99\n")
31) for i in range(0, 100):
32) print(f"{i} ---> {convertir(i)}")
Explicación:
 Se define la función convertir(valor), la cual recibe valores numéricos entre 0 y 99

y retorna su equivalente en letras.
Inicialmente se definen dos tuplas. La primera se denomina unidades, que,

aunque la hemos definido así, está compuesta por las cadenas de texto con los
nombres de los números entre 0 y 20. Ya que ellos tienen una escritura única.
La segunda tupla, denominada decenas, contiene el nombre de los números que

conforman las decenas superiores a 20 (Veinti, Treinta, Cuarenta, etc), con ellas
y las unidades se conformarán los números superiores a 20.
179
Entre las líneas 11 y 26, se encuentra un bloque de decisiones que van

determinando el valor numérico al cual se le hallará su equivalente en letras. La
primera decisión evalúa los valores entre 0 y 20. El número que haya en la
variable llamada valor, indicará una posición dentro de la tupla llamada unidades.
A la variable letras se le asignará el nombre correspondiente que está
almacenado en la posición de la tupla. Por ejemplo, si la variable valor tiene el
número 5, entonces a la variable letras se le asignará la cadena que hay en la
posición 5 de la tupla:
letras = unidades[5]
Como resultado se obtiene que, en letras se almacena la cadena “Cinco”, la cual

ocupa la posición que se indicó.
Ahora bien, si el valor analizado no está entre 0 y 20, se aplica el else de la línea
13. Ejecutando así, las siguientes operaciones:
decena = valor // 10 - 2
unidad = valor % 10
El propósito de estas expresiones, es separar las decenas y las unidades del

número analizado y de esta forma determinar la posición que se usará dentro de
las tuplas.
Consecuentemente, la decisión de la línea 17 determina si el número está entre

21 y 29 ya que, estos números se deben tratar de forma diferente a los demás,
todos comienzan con el prefijo Veinti, seguido de una unidad (uno, dos, tres…)
sin dejar espacio.
Así mismo, los números que son mayores o iguales a 30 y menores o iguales a 99
(línea 23), tienen un comportamiento similar entre sí. Adicionalmente, con estos
valores se debe comprobar si se tienen unidades, para así adicionar la letra “y”
junto con la unidad correspondiente. Por ejemplo, si el número es 51, el
programa debe escribir en letras su equivalente: Cincuenta y uno.
180
La función finaliza en la línea 28, cuando retorne el valor de la variable letras, en

la cual está el número escrito en forma de texto.
 El for que se presenta en la línea 31, hace un recorrido desde el número 0 hasta
el 99. La variable de control i, va tomando estos valores.
El cuerpo de este ciclo imprime, en cada iteración, el valor de i junto con su

correspondiente valor en letras. Así:
Números del 0 al 99
0 ---> Cero
1 ---> Uno
2 ---> Dos
...
20 ---> Veinte
21 ---> Veintiuno
22 ---> Veintidos
...
97 ---> Noventa y siete
98 ---> Noventa y ocho
99 ---> Noventa y nueve
Actividades 5.1. Con el desarrollo de esta actividad se podrán afianzar algunos de los
conceptos que se acabaron de estudiar.
1. Dadas las siguientes tuplas, realice los programas correspondientes para dar
solución a los enunciados.
a) tupla = (34, 43, 56.5, 345, 23)

Mediante el uso de funciones, halle el promedio de sus elementos.
b) binario = (1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0)
Encuentre su equivalente valor decimal (base 10).
181
c) binario = (1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0)
Determine cuántos números 1 y cuántos números 0 hay en la tupla.
2. Teniendo en cuenta la siguiente tupla, ¿qué resultados arrojan las instrucciones

print() relacionadas?:
valores = (23, 12, "Gato", (45,"Perro", "Edificio", "Jirafa", "Burro"), 34, "Tortuga")
a. print(valores[0])
b. print(valores[2][2])
c. print(valores[3])
d. print(valores[0:3])
e. print(valores[3][2:4])
f. print(valores[5][2:4])
5.2 Listas
Una lista es de tipo list. Al estar dentro de la categoría de colecciones, se define como
un contenedor de objetos. A diferencia de las tuplas, estas sí pueden ser modificadas.
Los objetos que hacen parte de la lista pueden ser todos del mismo tipo o una
combinación de ellos. Una lista se identifica porque sus elementos están encerrados
entre corchetes [ ]. Por ejemplo:
 Lista vacía:
[]
 Listas con un solo objeto o elemento:
[2018]
["Luna"]
182
 Lista con varios elementos numéricos de tipo entero:
[10, 12, -20]
 Las listas también pueden estar compuesta por elementos de diferente tipo de
dato:
[1.5, "Igor", 17, -3, "Aghata", "Benji"]
 Una lista puede contener otra lista:
["Benji", [2014, "Canela", 12]]
 Una lista también puede contener una tupla o visceversa:
["Benji", [2014, "Canela", 12], (2017, "Igor", 23, 45)]
5.2.1 Impresión de una lista
El contenido de una lista se puede mostrar usando una instrucción print(). Suponga
una lista llamada viveres con los siguientes elementos:
viveres = ["Arroz", "Fríjol", "Lenteja", "Leche", "Panela"]
Para mostrar su contenido se puede hacer mediante la siguiente instrucción:
print(viveres)
El resultado en pantalla será:
['Arroz', 'Fríjol', 'Lenteja', 'Leche', 'Panela']
183
Así mismo, se puede hacer la impresión de un solo elemento. A cada elemento de

una lista se le conoce como item y tiene un índice mediante el cual puede ser
accedido. Por ejemplo:
print(viveres[2])
Mostrará el item que ocupa la posición 2 (Lenteja).
5.2.2 Modificación de un item
Las listas a diferencia de las tuplas si pueden modificarse. Ejemplo:
viveres[3] = "Huevos"
En este caso se está modificando el item de la posición 3 (Leche), con el valor de

“Huevos”, por lo tanto, la nueva lista quedará así:
['Arroz', 'Fríjol', 'Lenteja', 'Huevos', 'Panela']
5.2.3 Mezcla de listas
Se tienen las siguientes listas:
viveres = ["Arroz", "Fríjol", "Lenteja", "Huevos", "Panela"]

lacteos = ["Yogur", "Leche", "Kumis"]
Ahora se usará el operador + para tener una lista conformada con los items de ambas
listas:
mercado = viveres + lacteos
184
En este caso, al usar el operador +, se consigue que los items de la lista lacteos se
adicionen a los items de la lista viveres y se almacenen en la nueva lista llamada
mercado, quedando con estos valores:
['Arroz', 'Fríjol', 'Lenteja', 'Huevos', 'Panela', 'Yogur', 'Leche', 'Kumis']
Tenga en cuenta que el orden en que escriba las listas en la expresión, afecta el
resultado:
mercado = lacteos + viveres
Con este orden se obtiene un resultado diferente al anterior:
['Yogur', 'Leche', 'Kumis', 'Arroz', 'Fríjol', 'Lenteja', 'Huevos', 'Panela']
También pueden adicionarse en una de las listas originales
viveres = viveres + lacteos
Una vez efectuada esta operación, la lista lacteos no sufre ninguna modificación,
mientras que viveres queda así:
['Arroz', 'Fríjol', 'Lenteja', 'Huevos', 'Panela', 'Yogur', 'Leche', 'Kumis']
Otra forma de mezclar listas
Dadas las siguientes listas:

lacteos = ["Yogur", "Leche", "Kumis"]
Se usará la siguiente expresión:

mercado = ["Tomate", "Cebolla", "Carne", viveres, lacteos]
185
Obteniendo así una lista llamada mercado con los siguientes items:
['Tomate', 'Cebolla', 'Carne', ['Arroz', 'Fríjol', 'Lenteja', 'Huevos', 'Panela'], ['Yogur',

'Leche', 'Kumis']]
Al utilizar esta forma lo que se hace es adicionar las listas viveres y lacteos como items
tipo listas.
5.2.4 Usando índices para acceder a los ítems
Al igual que se hizo con las tuplas, los elementos de una lista se pueden acceder a
través de su índice. Por ejemplo, suponga la siguiente lista:
mercado = ['Tomate', 'Cebolla', 'Carne', ['Arroz', 'Fríjol', 'Lenteja', 'Huevos', 'Panela'],

['Yogur', 'Leche', 'Kumis']]
Partiendo de estos valores, analicemos las siguientes instrucciones print():
 print(mercado[0:3])
Resultado: ['Tomate', 'Cebolla', 'Carne']
 print(mercado[0:4])
Resultado: ['Tomate', 'Cebolla', 'Carne', ['Arroz', 'Fríjol', 'Lenteja', 'Huevos',

'Panela']]
 print(mercado[0:3], mercado[4][1])
Resultado: ['Tomate', 'Cebolla', 'Carne'] Leche
 print(mercado[0:3], mercado[4][0:2])
Resultado: ['Tomate', 'Cebolla', 'Carne'] ['Yogur', 'Leche']
186
5.2.5 Funciones y métodos usados en listas
Función len()
Se dijo anteriormente que esta función aplicada a una cadena mide la cantidad de
caracteres, pero, cuando se usa con una tupla o una lista retorna la cantidad de
elementos que las conforman. Por ejemplo:

print(len(viveres))
Retorna un 5 como resultado, cantidad de items de la lista viveres.
Método append()
Permite adicionar items al final de la lista.

viveres.append("Azúcar")
Resultado: ['Arroz', 'Fríjol', 'Lenteja', 'Huevos', 'Panela', 'Azúcar']
Método extend()
Permite adicionar varios items al final de la lista.
viveres = ['Arroz', 'Fríjol', 'Lenteja', 'Huevos', 'Panela', 'Azúcar']

viveres.extend(["Sal", "Avena"])
Resultado: ['Arroz', 'Fríjol', 'Lenteja', 'Huevos', 'Panela', 'Azúcar', 'Sal', 'Avena']
Método insert()
Inserta un item en la posición que se indique dentro la lista.
187
viveres = ['Arroz', 'Fríjol', 'Lenteja', 'Huevos', 'Panela', 'Azúcar', 'Sal', 'Avena']

viveres.insert(3, "Azúcar")
Resultado: ['Arroz', 'Fríjol', 'Lenteja', 'Azúcar', 'Huevos', 'Panela', 'Azúcar', 'Sal',

'Avena']
Método count()
Devuelve la cantidad de ocurrencias de un valor dentro de una lista.
viveres = ['Arroz', 'Fríjol', 'Lenteja', 'Azúcar', 'Huevos', 'Panela', 'Azúcar', 'Sal', 'Avena']
veces = viveres.count("Azúcar")
print(veces)
Resultado: 2
Método remove()
Remueve un item de la lista. En caso de estar repetido borra la primera ocurrencia. Si

el item a eliminar no está presente, se genera el siguiente error:
ValueError: list.remove(x): x not in list.
En la siguiente lista, el ítem Azúcar se encuentra repetido:
viveres = ['Arroz', 'Fríjol', 'Lenteja', 'Azúcar', 'Huevos', 'Panela', 'Azúcar', 'Sal', 'Avena']
Para eliminar ese ítem dentro de la lista, se procede de la siguiente manera:
viveres.remove("Azúcar")
Resultado: ['Arroz', 'Fríjol', 'Lenteja', 'Huevos', 'Panela', 'Azúcar', 'Sal', 'Avena']
188
Función del()
Borra el item que se encuentre en la posición que se indique.
viveres = ['Arroz', 'Fríjol', 'Lenteja', 'Pastas', 'Huevos', 'Panela', 'Sal', 'Avena', 'Azúcar']
del viveres[7]
Resultado: ['Arroz', 'Fríjol', 'Lenteja', 'Pastas', 'Huevos', 'Panela', 'Sal', 'Azúcar']
Método pop()
Permite borrar un item dentro de una lista. Si no se especifica un argumento, borra

el último item.
viveres.pop()
Resultado: ['Arroz', 'Fríjol', 'Lenteja', 'Pastas', 'Huevos', 'Panela', 'Sal', 'Avena']
Cuando se especifica el índice, borra el item de esa posición:
viveres.pop(2)
Resultado: ['Arroz', 'Fríjol', 'Pastas', 'Huevos', 'Panela', 'Sal', 'Avena', 'Azúcar']
Otra forma de borrar
Aunque no es una función de Python, esta acción permite dejar una lista sin ningún
item (vacía):
viveres[:] = []
189
Deja la lista vacía. Si se emplean los siguientes print() se puede observar su contenido:
print(viveres)
print(len(viveres))
Se obtiene el siguiente resultado:

[]
0
Método sort()
Permite ordenar los items de una lista.
viveres.sort()
Resultado: ['Arroz', 'Avena', 'Azúcar', 'Fríjol', 'Huevos', 'Lenteja', 'Panela', 'Pastas',

'Sal']
Método reverse()
Permite invertir los items de una lista.
viveres.reverse()
Resultado: ['Azúcar', 'Avena', 'Sal', 'Panela', 'Huevos', 'Pastas', 'Lenteja', 'Fríjol',

'Arroz']
Funciones max() y min()
Retornan el valor máximo y mínimo dentro de una lista. Recuerden que también
pueden usarse con tuplas.
190
maximo = max(viveres)
minimo = min(viveres)
print(f"Mínimo: {minimo} y máximo: {maximo}")
Resultado:
Mínimo: Arroz y máximo: Sal
Función sum()
Esta función suma el valor de los elementos de una lista o tupla.
numeros = [30, 12, 15, 43, 23]

suma = sum(numeros)
print(suma)
Resultado: 123
Usando el ciclo for
Al igual como se explicó en el tema de las tuplas, es válido usar una lista como
elemento iterador de un ciclo for. Analicemos los siguientes ejemplos.
Se tiene la siguiente lista y se desea imprimir su contenido:
lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for numero in lista:
print(numero)
Como resultado se obtiene un listado con los números del 1 al 10.
191
Si se desea imprimir el contenido, junto con la posición que ocupa, se procede así:
i=0
for numero in lista:
print(f"{numero} ocupa la posición {i}")
i += 1
El resultado obtenido es el siguiente:
1 ocupa la posición 0
…
Con el siguiente ciclo for, se obtiene igual resultado:
for i, numero in enumerate(lista):

print(f"{numero} ocupa la posición {i}")
Ejemplo 5.5. Este programa lee una cantidad de números y los almacena en una lista,
luego encuentra la sumatoria de ellos.
Aunque Python ofrece la función sum(), con la cual se puede lograr el procedimiento
de una manera más fácil, se utilizará un for para hacer el recorrido de los elementos
e irlos sumando, esto con un propósito didáctico.
1) # Calcula la sumatoria de los elementos de una lista

2)
3) cantidad = int(input("Digite la cantidad de elementos: "))
4)
5) numeros = []
6)
192
7) for i in range(cantidad):
8) numero = int(input(f"Elemento [{i}]: "))
9) numeros.append(numero)
10)
11) sumatoria = 0
13) sumatoria = sumatoria + numeros[i]
14)
15) print("\nLos datos de la lista son: \n")
17) print(numeros[i], end = " ")
18)
19) print(f"\n\nLa sumatoria de los elementos es: {sumatoria}")
Explicación:
 Una vez se solicite la cantidad de elementos, se define una lista vacía llamada
numeros (línea cinco). Si no se procede con esta definición, se generará un error
cuando se quiera adicionar algún item a la lista.
 Con las instrucciones del for que inicia en la línea siete, se van leyendo los items
de la lista y se van adicionando a ella.
 El for de la línea 12, tiene como objetivo recorrer la lista e ir sumando cada item
de forma acumulativa dentro de la variable sumatoria.
sumatoria = 0
for i in range(cantidad):
sumatoria = sumatoria + numeros[i]
Tal como se dijo en el enunciado, Python ofrece la función sum(), con la cual se
logra un proceso más eficiente. Las anteriores 3 líneas, pueden ser reemplazadas
por una sola instrucción:
sumatoria2 = sum(numeros)
193
 Luego, con las instrucciones del for de la línea 16, se imprimen los números que
se ingresaron a la lista:
print(numeros[i], end = " ")
Recuerde que la instrucción end = " ", se usa para lograr que el print() no ejecute
un salto de línea, de esta manera todos los items de la lista se imprimen en un
mismo renglón.
 Finalmente se imprime el resultado de la sumatoria (línea 19).
 Otra forma de hacer la definición de la lista y la entrada de los datos, es la

siguiente:
numeros = [0] * cantidad
for i in range(cantidad):
numeros[i] = int(input(f"Elementos: [{i}]: "))
Estas instrucciones reemplazan las de las líneas 5 a 9 del programa anterior. La

definición de la lista se logra llenando con el valor 0, la cantidad de posiciones
que el usuario haya digitado como cantidad de elementos, así:
numeros = [0] * cantidad
La lectura de los datos, no se hace con el módulo append(), en su lugar se va

reemplazando cada 0 inicial, con el valor digitado por el usuario en cada item:
numeros[i] = int(input(f"Elementos: [{i}]: "))
Aunque es una forma válida, le recomendamos utilizar la que se codificó en el

programa que se usó como ejemplo.
194
Ejemplo 5.6. Es el mismo ejemplo anterior, pero ahora se codificará usando funciones
de usuario. Adicionalmente, se tienen las siguientes condiciones: máximo 50 items,
cada item tendrá un valor entre 1 y 100.
1) # Lectura, proceso y salida de una lista.

2)
3) def leer_elementos(mensaje, cantidad):
4) numeros = []
6) numero = leer_int(f"{mensaje}[{i}]: ", 1, 100)
8) return numeros
9)
10) def sumar(numeros):
11) sumatoria = 0
12) for i in range(len(numeros)):
13) sumatoria = sumatoria + numeros[i]
14) return sumatoria
15)
16) def imprimir_elementos(mensaje, numeros):
17) print(f"\n{mensaje}")
20)
22) siga = True
23) while siga:
26) siga = False
27) else:
29) return numero
30)
31) cantidad = leer_int("\nDigite la cantidad de elementos: ", 1, 50)
32) numeros = leer_elementos("Elemento ",cantidad)
33)
34) sumatoria = sumar(numeros)
195
35)
36) print(f"\nLa sumatoria de los elementos es: {sumatoria}")
37) imprimir_elementos("Los datos de la lista son:", numeros)
Explicación:
 El programa contiene cuatro funciones de usuario:
1. leer_elementos(): recibe como parámetros un mensaje para solicitar los datos

y la cantidad de items a leer. La función retorna la lista denominada numeros,
en la cual fueron almacenados los items leídos.
2. sumar(): recibe como parámetro la lista donde están los números a sumar. Las
instrucciones son las mismas que se usaron en el ejemplo anterior para
realizar el proceso de la sumatoria. Al final retorna el valor calculado.
3. imprimir_elementos(): recibe como parámetros un mensaje y la lista con los

números almacenados.
Para el proceso de impresión se usó un ciclo for que hace el recorrido de los
items, desde la posición 0, hasta la longitud de la lista. En cada iteración
imprime un elemento.
4. leer_int(): es la función que se ha venido utilizando para leer valores de tipo

entero, tiene tres parámetos: un mensaje, el valor mínimo y el valor máximo
del número a leer. La función retorna el número capturado.
 En las líneas 31 se hace el llamado a la función leer_int(). Tiene tres argumentos,

el mensaje: “Digite la cantidad de elementos:” y los números 1 y 50, que indican
el valor mínimo y máximo de la cantidad de elementos que tendrá la lista.
 En la línea 32 se invoca la función leer_elementos(), donde sus argumentos son

el mensaje: “Elemento” y la variable cantidad, con la cual se indica el número de
items que tendrá la lista. Una vez sean leídos todos los elementos, la función
retornará la lista que será recibida por la variable numeros.
196
 La expresión de la línea 34, hace el llamado a la función sumar(), que lleva como
argumento la lista donde están los items leídos.
 Sobre la línea 36 se encuentra la impresión de la sumatoria. Finalmente, en la

línea 37 se hace el llamado a la función imprimir_elementos(), que se encarga de
mostrar el contenido de la lista.
Ejemplo 5.7. Con este programa se capturan los elementos de dos listas y luego se
fusionan en una nueva.
Los elementos de cada una de las listas, pasan a ser ítems independientes de la lista
nueva.
1) # Lee los elementos de dos listas y los fusiona en una nueva

2)
4) numeros = []
8) return numeros
9)
10) def fusionar(numeros1, numeros2):
11) tope = len(numeros1) + len(numeros2)
12) unidos = []
13) j=0
14)
15) for i in range(tope):
16) if i < len(numeros1):
17) unidos.append(numeros1[i])
18) else:
19) unidos.append(numeros2[j])
20) j += 1
21) return unidos
22)
197

27)
29) siga = True
30) while siga:
33) siga = False
34) else:
36) return numero
37)
38) cantidad = leer_int("\nDigite la cantidad de elementos primera lista: ", 1,
50)
39) numeros1 = leer_elementos("Lista 1 ", cantidad)
40)
41) cantidad = leer_int("\nDigite la cantidad de elementos segunda lista: ", 1,
50)
43)
44) unidos = fusionar(numeros1, numeros2)
45) imprimir_elementos("La lista fusionada es:",unidos)
Explicación:
 Al igual que el programa anterior, este ejemplo presenta cuatro funciones, de las
cuales la única diferente es la función denominada fusionar(), que será la
encargada de unir las dos listas en una sola y retornar el resultado de esta unión.
En este punto conviene subrayar que, este procedimiento se puede hacer de una
manera mucho más sencilla y rápida, la cual se mostrará al final de esta
explicación. La forma como se solucionó en este ejemplo, tiene como objetivo
practicar diferentes opciones y desarrollar competencias en el manejo de las
instrucciones del lenguaje.
198
 La función fusionar() presenta dos parámetros, que reciben las dos listas a unir.
 La expresión que se encuentra en la línea 11, determina la longitud total que

tendrá la lista donde se almacenará la unión de las dos listas de entrada. Esa
longitud está dada por la suma de la cantidad de los elementos de ambas listas:
tope = len(numeros1) + len(numeros2)
 En la línea 12, se define una lista vacía llamada unidos, que contendrá el resultado
del proceso.
 Se define una variable llamada j, que servirá como índice de la segunda lista
dentro del proceso de fusión.
Para hacer la fusión de las dos listas se trabaja un for. Inicia en la línea 15 y
termina en la línea 20. La cabecera de este ciclo controla su ejecución con la
variable i cuyo valor inicial es 0 y va hasta el valor de la longitud total definida en
la variable tope.
 En la línea 16, se plantea una decisión que tiene como fin controlar que primero
se adicionen los items de la lista numeros1 a la lista unidos. Cuando esta decisión
es false se procede a adicionar los items de la lista numeros2 a la lista unidos. En
este momento es donde se debe hacer uso de la variable j, ya que el recorrido en
la lista numeros2 debe iniciar desde 0 e ir incrementando una posición en cada
vuelta.
Cuando la variable i cumpla con el recorrido de la longitud dada en la variable

tope, todos los items de ambas listas, estarán contenidos dentro de la lista
unidos.
 Una vez termine la ejecución el ciclo for, se procede con el return de la línea 21
que devuelve la lista con los elementos fusionados.
199
 Para un mejor entendimiento de estas instrucciones suponga que, cuando el

usuario digite los elementos de las listas, estas queden conformadas así:
numeros1 = [2, 4, 6, 8]
numeros2 = [1, 3, 5]
Al ejecutar la función fusionar(), la lista resultante sería:
unidos = [2, 4, 6, 8, 1, 3, 5]
Al ejecutar la función imprimir_elementos(), en pantalla se observaría la siguiente

salida:
La lista fusionada es: 2 4 6 8 1 3 5
 El resto del programa es igual a la explicación dada en el ejemplo anterior.
Como se mencionó en los párrafos anteriores, hay una forma más sencilla de realizar
el proceso de fusión de las dos listas. Teniendo en cuenta esta afirmación, la anterior
función fusionar(), puede ser reemplazada por esta:
def fusionar(numeros1, numeros2):

unidos = numeros1 + numeros2
return unidos
Así mismo, hay que tener presente que alguien podría pensar en solucionar este
problema usando el método append(), así:
def fusionar(numeros1, numeros2):

unidos = []
unidos.append(numeros1)
unidos.append(numeros2)
return unidos
200
En este caso, se está creando una lista conformada por dos listas, lo cual cambia un
poco el resultado:
unidos = [[2, 4, 6, 8] [1, 3, 5]]
Al utilizar la función imprimir_elementos(), se obtiene:
[2, 4, 6, 8] [1, 3, 5]
Ejemplo 5.8. Este programa lee los elementos de dos listas de igual dimensión y luego
forma una tercera lista, en donde cada item es el resultado de la multiplicación de los
items que ocupan la misma posición en las listas capturadas.
1) # Lee los elementos de dos listas y los multiplica elemento a elemento

2)
4) numeros = []
5)
9)
10) return numeros
11)
12) def multiplicar(numeros1, numeros2):
13) producto = []
14)
15) for i in range(len(numeros1)):
16) producto.append(numeros1[i] * numeros2[i])
17)
18) return producto
19)
201
24)
26) siga = True
27) while siga:
30) siga = False
31) else:
33) return numero
34)
35) cantidad = leer_int("\nDigite la cantidad de elementos de las listas: ", 1, 50)
36) print("\nElementos de la primera lista\n")
38)
39) print("\nElementos de la segunda lista\n")
40) numeros2 = leer_elementos("Lista 2 ", cantida)
41)
42) imprimir_elementos("Elementos lista 1: ", numeros1)
43) imprimir_elementos("Elementos lista 2: ", numeros2)
44)
45) producto = multiplicar(numeros1, numeros2)
46) imprimir_elementos("La lista resultado es:", producto)
Explicación:
 Teniendo en cuenta que la estructura del programa es igual a la de los que se

explicaron en los párrafos anteriores, nos concentraremos en la función
multiplicar(), en la cual radica la diferencia.
Esta función tiene dos parámetros, en los cuales recibe las listas que se van a
multiplicar.
 Se define una lista vacía llamada producto (línea 13).
202
Para el proceso de la multiplicación se utiliza un ciclo for que, va adicionando en

cada posición de la lista producto, el resultado de multiplicar los elementos en la
posición i de las listas numeros1 y numeros2:
producto.append(numeros1[i] * numeros2[i])
 Una vez se haya terminado de ejecutar el for se retorna la lista producto (línea
18).
Ejemplo 5.9. En este ejemplo se lee un número entero positivo no mayor a 10000 y
se convierte en su equivalente número binario (base 2).
Para convertir un número entero a su equivalente valor binario, se toma el número

dado y se hacen divisiones enteras sucesivas entre 2 hasta que ya no sean posibles.
Luego se toman todos los residuos que se hayan obtenido, partiendo desde el último
hasta el primero. Seguidamente, se debe invertir esta serie de números y se obtiene
el correspondiente valor binario. Por ejemplo, para convertir el número 22 a binario
o base 2, se procede así:
Invirtiendo este resultado, se obtiene el correspondiente valor binario:
22 base 10 = 10110 base 2
203
Una solución a este ejercicio es la siguiente:
1) # Lee un número entero y lo convierte en su equivalente binario

2)
3) def convertir_binario(numero):
4) resultados = []
5)
6) while numero >= 1:
7) residuo = numero % 2
8) resultados.append(residuo)
9) numero = numero // 2
10)
11) invertido = []
12) j = len(resultados)
13) for i in range(len(resultados)):
14) j -= 1
15) invertido.append(resultados[j])
16)
17) return invertido
18)
23)
25) siga = True
26) while siga:
29) siga = False
30) else:
32) return numero
33)
34) numero = leer_int("\nDigite el número a convertir: ", 1, 10000)
35) num_binario = convertir_binario(numero)
36) imprimir_elementos("El número en binario es: ", num_binario)
204
Explicación:
 El ejemplo es similar a los tratados anteriormente, por eso nos concentraremos

en el proceso de conversión a binario, sin entrar a detallar las demás funciones
que lo conforman.
En la función convertir_binario(), se hace todo el proceso de conversión de base

10 (decimal) a base 2 (binario). En su único parámetro recibe el valor en base 10
que se va a convertir.
 En la línea cuatro, se define una lista vacía llamada resultados. En ella se

almacenan todos los residuos que se obtengan de las divisiones sucesivas.
 Entre las líneas 6 y 9 se encuentra un ciclo while que, tiene la función de ejecutar
las instrucciones que hacen las divisiones enteras entre 2. En cada división se
calcula el residuo y se va almacenando como un item dentro de la lista resultados.
Recuerde que para hallar el residuo se usa el operador módulo (%).
Así mismo, con la expresión numero = numero // 2, se va hallando el dividendo

que será usado en la siguiente división sucesiva. El ciclo se ejecuta mientras la
variable numero sea mayor o igual a 1, es decir que soporte divisiones entre 2.
 En este punto del programa, se tienen almacenados en la lista resultados todos

los residuos de las divisiones entre 2.
 Conforme a lo que se explicó en el enunciado, el proceso a seguir es invertir estos

valores. Para ello se define una nueva lista llamada invertido y un ciclo for.
 La variable j de la línea 12 se inicializa con el valor de la longitud de la lista

resultados, esto con el propósito de empezar a anexar en la primera posición de
la lista invertido la última posición de la lista resultados y así sucesivamente.
Mientras el índice de invertido va aumentando, el índice de resultados va
disminuyendo. El ciclo termina cuando se haya hecho el recorrido por todos los
items de la lista resultados.
205
 Para una mejor ilustración de este proceso, retomemos el caso de convertir el

número 22 decimal (base 10) a binario (base 2). Cuando se ejecute el ciclo while
se obtiene la lista resultados con los siguientes items:
resultados = [0, 1, 1, 0, 1]
Luego al ejecutarse el ciclo for, la lista invertido queda así:
invertido = [1, 0, 1, 1, 0]
 La función termina en la línea 17, con el retorno de la lista llamada invertido, en

la cual se encuentra el equivalente en binario del número ingresado.
 De igual forma, como se ha hecho con otros programas, existe una forma más
sencilla de hacer algunos procedimientos. En este ejemplo, las líneas que
invierten los elementos de la lista se pueden reemplazar por uno de los métodos
que ofrece Python.
206
Así las cosas, recordemos las líneas que hacen el proceso de invertir la lista:
invertido = []
j = len(resultados)
for i in range(len(resultados)):
j -= 1
invertido.append(resultados[j])
Estas cinco líneas pueden ser reemplazadas por las siguientes dos, que muestran
un proceso más sencillo:
resultados.reverse()
invertido = resultados
De esta forma, el programador se desentiende de la lógica que conlleva un

proceso para invertir una lista, ya que con el método reverse() se logra el mismo
resultado.
Actividad 5.2. Desarrolle los programas necesarios para solucionar los siguientes
enunciados.
a. Lea una cantidad de números no mayor a 100, con valores entre -1500 y 1500,
determine cuántas veces se encuentra cada número dentro de la lista.
b. Lea una cantidad de números no mayor a 100, con valores positivos no mayores
a 2000 y determine cuántos de ellos son pares y cuántos impares.
c. Basándose en la solución del ejercicio anterior, encuentre la sumatoria y el

promedio de los impares, la sumatoria de los pares y determine cuál de las dos
sumatorias es mayor.
d. Calcule la media armónica de un conjunto de números. La media armónica H de

una serie de números es el recíproco de la media aritmética de los recíprocos de
207
los números de la serie. Sean los números X1, X2, …, XN. La media armónica H se
obtiene de la relación:
1 1 1
1 𝑋1 + 𝑋2 +. . . + 𝑋𝑁
=
𝐻 𝑁
Ejemplo: calcular la media armónica de los números 4, 5 y 8.
1 1 1
1 4+5+8
=
𝐻 3
23
1
= 40
𝐻 3
1 23
= 𝐻 = 5.22
𝐻 120
e. Escriba una función que determine el valor de los dos ítems que más veces se
encuentran dentro de una lista.
5.3 Listas en dos dimensiones
Una lista en dos dimensiones, realmente es una lista conformada por listas. Este tipo
de colecciones, es muy usada para realizar cálculos y operaciones con matrices
matemáticas, aunque no es su único uso.
Siendo así, es procedente establecer que una matriz matemática es una formación
en dos dimensiones, conformada por filas y columnas.
En Python una matriz matemática se representa con una lista, dentro de la cuál hay
otras listas. La cantidad de listas internas indican el número de filas de la matriz. La
cantidad de ítems de las listas internas será el número de las columnas de la matriz,
208
por lo tanto, la cantidad de ítems de las listas internas debe ser la misma para todas
ellas.
Antes de entrar en detalles de programación, es indispensable conocer algunos

conceptos matemáticos. Para ello, tomaremos la siguiente formación bidimensional
o matriz matemática:
1 8 9
4 − 8 7 
A=
5 3 2
 
6 0 5 4  3
La anterior matriz, llamada A, tiene 4 filas y 3 columnas. Para referirse a su tamaño o

dimensión, se usa la notación m x n (m por n), en este ejemplo estamos ante una
matriz de dimensión 4 x 3.
Como se dijo anteriormente, para representarla en Python se usa una lista de listas,
así:
a = [[1, 8, 9], [4, -8, 7], [5, 3, 2], [6, 0, 5]]
Esta lista de dos dimensiones está conformada por 4 ítems que a su vez son listas y
representan las filas de la matriz. Para una mejor comprensión, la presentaremos de
la siguiente manera:
a = [ [1, 8, 9],
[4, -8, 7],
[5, 3, 2],
[6, 0, 5] ]
Cada una de estas listas internas, está compuesta por 3 ítems, indicando así el
número de columnas de la matriz que se quiere representar.
209
Gráficamente esta lista se puede observar de la siguiente manera:
1 8 9
4 -8 7
5 3 2
6 0 5
Para acceder a cada uno de estos elementos, se debe usar la siguiente notación:
nombre[fila][columna]
Donde:
nombre: es el identificador de la lista (matriz).

fila: índice numérico entero que indica la fila que ocupa el ítem dentro de la lista. La
primera fila de la lista es la 0.
columna: índice numérico entero que indica la columna que ocupa el ítem dentro de
la lista. La primera columna de la lista es la 0.
Las posiciones que ocupan los elementos de la anterior matriz son:
[0] [0] [0] [1] [0] [2]

[1] [0] [1] [1] [1] [2]
[2] [0] [2] [1] [2] [2]
[3] [0] [3] [1] [3] [2]
La combinación de la fila y columna, hacen referencia a un ítem específico. Por

ejemplo, para referirse a un elemento en específico de la matriz llamada a, se usa la
siguiente notación:
Notación Valor del ítem

a[0][1] 8
a[1][0] 4
a[2][2] 2
a[3][1] 0
210
Otro aspecto importante que se debe conocer es que, en las operaciones de listas en
dos dimensiones, generalmente se siguen los siguientes procedimientos: primero se
hace una lectura de los ítems, en segundo lugar se ejecuta un proceso con los datos
de la lista, que depende del problema a solucionar y por último hay una salida o
impresión de resultados.
5.3.1 Lectura de ítems de una lista de dos dimensiones
Para guardar los ítems en una lista de dos dimensiones se deben establecer dos ciclos.
Generalmente se trabaja con el ciclo for. Una de las posibles codificaciones para
realizar esta lectura es la siguiente:
1) dimensional = []
2)
3) for i in range(filas):
4) dimensional.append([])
5) for j in range(columnas):
6) numero = int(input(f"Elemento [{i}][{j}]: "))
7) dimensional[i].append(numero)
Explicación:
 Al igual que las listas de una dimensión, estudiadas anteriormente, se debe

definir una lista vacía en la cual se van a anexar los ítems. Para este ejemplo se
escogió el nombre bidimensional para la lista.
 Estas líneas de código presentan dos ciclos for, el primero controla la cantidad de
filas, el segundo la cantidad de columnas (filas 3 y 5). A estos ciclos se les conoce
como ciclos anidados, lo cual quiere decir que uno está dentro de otro.
En el ciclo de la línea tres, la variable de control, llamada i, toma valores que

inician en 0 e itera una cantidad de veces de acuerdo con el número de filas que
vaya a tener la lista llamada bidimensional. En cada ejecución del ciclo se adiciona
211
una nueva lista a la lista que se definió en la línea uno, para ello se usa la siguiente
instrucción:
dimensional.append([])
Aquí el método append() anexa un ítem de tipo list. Esta lista vacía, representa
una fila de la lista llamada dimensional, con lo cual se va formando una lista de
listas (matriz). En este momento la lista estaría así:
dimensional[ [ ] ]
Observe que esa nueva lista posee solo un elemento vacío. En este punto de las
instrucciones, el control lo asume el segundo for (línea cinco), donde la variable
de control j itera desde 0 hasta alcanzar la cantidad de columnas que tenga la
lista bidimensional. Cuando este for temine de hacer su primera iteración
completa, se habrán leído los números que ocuparán la primera fila de la matriz.
Cada que este ciclo se ejecute realiza la lectura de un ítem mediante la siguiente
instrucción:
numero = int(input(f"Elemento [{i}][{j}]: "))
Con ella se mostrará en la pantalla el siguiente mensaje:
Elemento[0][0]:
Estos valores irán cambiando acorde a la iteración de las variables i y j que

controlan los ciclos.
Suponga que se van a leer los ítems de la matriz que se ha venido trabajando
como ejemplo, cuya dimensión es de 4 x 3; en este caso los elementos se pedirían
así:
Elemento[0][0]: 1
212
Este primer elemento se almacena en la variable numero. Luego se adiciona a la

posición 0 del ítem de tipo list que ocupa la posición 0 de la lista llamada
bidimensional. Esto se logra con la siguiente instrucción:
dimensional[i].append(numero)
Ahora la lista dimensional estaría conformada por un elemento de tipo list en la

posición 0, que a su vez tiene un elemento de tipo int así:
[[1]]
Después de ejecutada la anterior instrucción (línea siete), se regresa a la cabecera

del ciclo for interno (línea cinco), donde la variable j todavía no ha alcanzado la
cantidad de columnas que debe recorrer. Por lo tanto, la condición sigue siendo
True, lo cual obliga a que se repita el cuerpo del ciclo, haciendo una nueva
solicitud del valor del elemento o ítem y adicionándolo a la lista llamada
dimensional:
Elemento[0][1]: 8
En este momento la lista de la posición 0 se conforma por dos elementos de tipo

int:
[[1, 8]]
El proceso se repite y solicita el siguiente elemento:
Elemento[0][2]: 9
Ahora la lista de la posición 0 se conforma por tres elementos:
[[1, 8, 9]]
Como se aprecia, se han leído los números o lementos que corresponden a la

priemera fila de la matriz. En este instante el ciclo for interno (línea cinco) deja
213
de ejecutarse, ya que la variable j alcanzó la cantidad de columnas de la matriz

(lista de dos dimensiones).
Así las cosas, el control lo vuelve a asumir el ciclo for de la línea tres, en donde i
toma el valor de 1. Como la condición de este ciclo sigue siendo True se repite su
cuerpo. De acuerdo con la instrucción de la línea 4, se adiciona una nueva lista a
la lista llamada bidimensional, es decir se adiciona una nueva fila a la matriz, así:
[[1, 8, 9], []]
Esta nueva fila (lista) ocupa la posición 1 de la lista dimensional. Una vez más se
repite el proceso de lectura de los tres elementos que la ocuparán. De acuerdo
con la matriz que se tiene de ejemplo, los elementos son: 4, - 8 y 7. Teniendo
entonces el siguiente comportamiento:
Entrada del nuevo elemento:
Elemento[1][0]: 4
Conformación de la lista dimensional una vez adicionado el nuevo ítem:
[[1, 8, 9], [4]]
Elemento[1][1]: -8
Conformación de la lista una vez adicionado el nuevo ítem:
[[1, 8, 9], [4, -8]]
Elemento[1][2]: 7
214
Conformación de la lista una vez adicionado el nuevo ítem:
[[1, 8, 9], [4, -8, 7]]
Hasta aquí se tienen entonces, los elementos de la segunda fila de la matriz. Este
proceso vuelve a repetirse hasta completar las 4 filas de la lista. Terminando
entonces con todos los números almacenados, así:
a = [[1, 8, 9], [4, -8, 7], [5, 3, 2], [6, 0, 5]]
Cuando la lista ya posee todos sus ítems se puede proceder a procesarlos o

simplemente consultarlos. A continuación, se explicará la forma de como
mostrarlos por pantalla en forma de matriz.
5.3.2 Impresión en forma de matriz para una lista de dos dimensiones
Al igual que en la entrada de los ítems de la lista de dos dimensiones, para la salida
se deben usar dos ciclos for, así:
1) print("\nLos datos de la matriz son: \n")

4) print(f"{dimensional[i][j]:7d}", end = " ")
5) print()
Explicación:
 Es una buena práctica incluir un mensaje que indique a qué corresponden los
datos que se mostrarán, por eso en la línea uno se imprime el mensaje que dice
“Los datos de la matriz son:”.
 El cuerpo de estos ciclos es más sencillo que el que se codificó en la entrada de

los ítems. El primer for (línea dos) hace la iteración de la variable i de acuerdo con
la cantidad de filas que tenga la lista a imprimir. El segundo for hace lo propio,
215
pero con las columnas, su iteración se hace con la variable de control j. En cada
ejecución del ciclo interno (línea tres) se imprime el contenido de la matriz
dimensional, para ello se emplea la siguiente instrucción:
print(f"{dimensional[i][j]:7d}", end = " ")
dimensional[i][j], va mostrando los valores almacenados en la posición que

especifiquen las variables i y j. La instrucción end = " " se usa para no permitir el
salto de línea, es decir se va imprimiendo ítem por ítem y fila por fila. El formato
7d, deja usa un espacio de 7 lugares enteros para la impresión. En la primera
iteración completa del ciclo for interno, se apreciaría en pantalla lo siguiente:
Los datos de la matriz son:
1 8 9
Una vez se haya terminado de ejecutar este ciclo, el control pasa a la instrucción
de la línea cinco, en donde se produce un salto de línea con la función print().
En este momento el control regresa a la línea dos de las instrucciones, en donde

se encuentra el for. La variable i itera tomando el valor de 1 y de nuevo se repite
todo el proceso para imprimir la fila dos de la lista.
 Una vez se hayan ejecutado por completo los dos ciclos, se obtendrá el siguiente
resultado:
Los datos de la matriz son:
1 8 9
4 -8 7
5 3 2
6 0 5
216
Ejemplo 5.10. Este programa lee los datos de una matriz de tamaño m x n y los
almacena en una lista de dos dimensiones. Luego determina cuál es el de mayor valor.
1) # Determina el mayor elemento de una matriz

2)
3) filas = int(input("Cantidad de filas: "))
4) columnas = int(input("Cantidad de columnas: "))
5)
6) dimensional = []
7)
11) numero = int(input(f"Elemento [{i}][{j}]: "))
13)
14) mayor = dimensional[0][0]
15)
18) if mayor < dimensional[i][j]:
19) mayor = dimensional[i][j]
20)
21) print(f"\nEl mayor elemento de la matriz es: {mayor}")
22)
23) print("\nLos datos de la matriz son: \n")
27) print()
Explicación:
 Inicialmente se hace la lectura de la cantidad de filas y columnas que tendrá la

matriz. Luego entre las líneas 6 y 12, se procede con la definición y lectura de los
ítems de la lista. Procedimiento que se explicó previamente a este ejemplo.
217
 Entre las líneas 14 y 19 se hace el proceso para averiguar cuál es el elemento que
tiene el mayor valor.
Se define la variable llamada mayor. Inicialmente se le asigna el valor que se

encuentre en la posición 0, 0 de la lista denominada dimensional. Con este valor
se empezará a comparar contra los demás valores almacenados en la lista, para
ello se usan dos ciclos for. A medida que se va avanzando entre los ítems de la
lista, se compara el valor de dicho elemento contra los demás:
if mayor < dimensional[i][j]:
En el caso de que esta instrucción sea True, a la variable mayor se le asigna el

nuevo valor que se haya encontrado en la posición i, j de la lista:
mayor = dimensional[i][j]
 Una vez se haya terminado la comparación contra todos los ítems de la lista
dimensional, se procede a ejecutar la instrucción de la línea 21, en donde se
imprime el mayor valor de los elementos de la lista.
 Finalmente, entre las líneas 23 y 27 se hace la impresión de la lista en forma de

matriz, procedimiento que ya fue explicado antes de este ejemplo.
Ejemplo 5.11. Este programa lee los datos de una matriz de tamaño m x n y los
almacena en una lista de dos dimensiones. Luego determina cuál es el de mayor valor.
Es el mismo ejemplo anterior, pero esta vez se desarrollará usando funciones y

teniendo en cuenta que se cumplan las condiciones planteadas a continuación:
1. La matriz tendrá una dimensión máxima de 5 x 5.

2. Cada elemento tendrá valores entre -1000 y 1000.
218
Una posible solución se muestra a continuación:
1) # Determina el elemento de mayor valor de una matriz

2)
3) def leer_elementos(mensaje, filas, columnas):
4) dimensional = []
8) numero = leer_int(f"{mensaje}[{i}][{j}]: ", -1000, 1000)
10) return dimensional
11)
12) def encontrar_mayor(dimensional):
13) mayor = dimensional[0][0]
14) for i in range(len(dimensional)):
15) for j in range(len(dimensional[0])):
16) if mayor < dimensional[i][j]:
17) mayor = dimensional[i][j]
18) return mayor
19)
20) def imprimir_elementos(mensaje, dimensional):
25) print()
26)
28) siga = True
29) while siga:
32) siga = False
33) else:
35) return numero
36)
219
37) filas = leer_int("Cantidad de filas: ", 1, 5)

38) columnas = leer_int("Cantidad de columnas: ", 1, 5)
39)
40) print("\nElementos de la matriz\n")
41) dimensional = leer_elementos("Elementos", filas, columnas)
42)
43) mayor = encontrar_mayor(dimensional)
44) print(f"\nEl mayor elemento de la matriz es: {mayor}")
45)
46) imprimir_elementos("Los datos de la matriz son:\n", dimensional)
Explicación:
 Se desarrollarán las siguientes funciones:
1. leer_elementos(): tiene como parámetros el mensaje que solicitará los datos,

la cantidad de filas y columnas que tendrá la matriz. Dichos valores serán
enviados como argumentos en el momento que se haga el llamado a la
función.
La lógica interna de esta función es la misma que se explicó para la lectura de

los ítems del programa anterior. En cuanto a instrucciones tiene dos
diferencias. La primera está en la línea ocho, donde se solicita cada ítem, en
ella se hace un llamado a la función leer_int(), que ha sido ampliamente
explicada en los ejemplos previos; con este llamado se logra la validación para
que los datos que se lean estén entre -1000 y 1000.
La segunda diferencia es el return de la línea diez, con él se retorna la lista

con los ítems que se hayan leído.
2. encontrar_mayor(): la función recibe como parámetro la lista de los ítems

que va a procesar. Se emplea el mismo procedimiento del programa anterior.
Pero hay dos diferencias significativas. La primera se encuentra en los
argumentos utilizados en la función range() de los ciclos for. En el programa
anterior los ciclos for están codificados así:
220
for i in range(filas):
for j in range(columnas):
En este ejemplo, se encuentran de la siguiente forma:
for i in range(len(dimensional)):
for j in range(len(dimensional[0])):
En la primera forma, la función range() utiliza como argumentos los valores

que hay en las variables llamadas filas y columnas, respectivamente, variables
que son globales, es decir, reconocidas en todo el programa.
En la segunda forma no se usan estas variables ya que, los for se encuentran

dentro de una función, la cual y atención a las buenas prácticas de
programación, no debe trabajar con variables globales. Para este caso es más
sencillo aprovechar la lista que se recibe como parámetro y determinar el
valor de las filas y las columnas que la componen, para ello es que se usó la
función len() dentro de la función range().
Así las cosas, los argumentos de la función range() son: len(dimensional) y

len(dimensional[0]). La función len() permite conocer la cantidad de
elementos de una tupla o de una lista. Al utilizar len(dimensional) se está
determinando la cantidad de elementos que tiene la lista dimensional y
teniendo en cuenta que cada uno de sus elementos es una fila, se consigue
así el valor correspondiente a la cantidad de filas de la lista dimensional
(matriz). Ahora bien, con la instrucción len(dimensional[0]) se determina la
cantidad de elementos que contiene la lista de la posición 0 de la lista
dimensional y ese resultado equivale a la cantidad de columnas.
Como conclusión, no olvide que si requiere determinar la cantidad de filas o

de columnas de una lista de dos dimensiones (matriz), lo consigue así:
filas = len(dimensional)
columnas = len(dimensional[0])
221
La segunda diferencia que se presenta en esta función encontrar_mayor()

está en el return de la línea 18, con el cual se retorna el mayor valor
encontrado.
3. imprimir_elementos(): esta función recibe como parámetros el mensaje que

se usa para indicar que es lo que se está imprimiendo (aunque puede tener
cualquier otra finalidad) y la lista que contiene la matriz a imprimir.
El procedimiento de impresión funciona exactamente igual a como se explicó

en el programa anterior. Así mismo, se hace uso de la función len() dentro de
la función range() para obtener el número de filas y columnas. Instrucciones
explicadas en el punto anterior.
4. leer_int(): esta es la última función y es la misma usada en muchos de los

ejemplos anteriores.
 Ahora bien, la ejecución del programa inicia en la línea 37 y 38 con el llamado de

la función leer_int(), que permitirá capturar la cantidad de filas y columnas de la
matriz. Se hace la validación para que estos valores estén entre 1 y 5, que es la
dimensión máxima establecida en el enunciado.
 En la línea 41 se invoca la función que leerá los elementos de la matriz. Se envía

como argumento el mensaje “Elementos” y la cantidad de filas y columnas que
tendrá la matriz. La lista que se retorne será almacenada en la variable
dimensional.
 Sobre la línea 43 se hace el llamado a la función que encuentra el mayor

elemento, el resultado retornado es almacenado en la variable mayor.
 Por último, en la línea 46 se hace el llamado a la función imprimir_elementos(),

enviando como argumentos el mensaje “Los datos de la matriz son:” y la lista
llamada dimensional. A diferencia de los anteriores llamados a las funciones, en
este no se espera un retorno.
222
Ejemplo 5.12. Este programa lee los elementos de una matriz y los almacena en una
lista de dos dimensiones, luego calcula su matriz transpuesta.
Antes de plantear una solución, repasemos el concepto de matriz transpuesta. Es

aquella que se logra al intercambiar las filas por columnas o las columnas por filas.
Por ejemplo, las filas pasan a ser las columnas de la matriz transpuesta:
 4 −3   4 2 −1 
A =  2 8   A = 
t 

− 1 5  3 x 2 − 3 8 5  23
Otro ejemplo puede ser cuando las columnas pasan a ser las filas de la matriz
transpuesta:
5 7 9  5 3 2
B = 3 1 0   B = 7 t
1 4 
2 4 10  33 9 0 10  33
En esencia, ambas situaciones son exactamente las mismas, todo depende de como
se haga el análisis.
Para solucionar este enunciado, se presenta el siguiente programa.
1) # Calcula la transpuesta de una matriz

2)
4) dimensional = []
223
11)
12) def calcular_transpuesta(dimensional):
13) transpuesta = []
14) for i in range(len(dimensional[0])):
15) transpuesta.append([])
16) for j in range(len(dimensional)):
17) transpuesta[i].append(dimensional[j][i])
18) return transpuesta
19)
25) print()
26)
28) siga = True
29) while siga:
32) siga = False
33) else:
35) return numero
36)
37) filas = leer_int("Cantidad de filas: ", 1, 5)
38) columnas = leer_int("Cantidad de columnas: ", 1, 5)
39)
40) print("\nElementos de la matriz\n")
41) dimensional = leer_elementos("Elementos", filas, columnas)
42)
43) transpuesta = calcular_transpuesta(dimensional)
44)
45) imprimir_elementos("Matriz original:\n", dimensional)
46) imprimir_elementos("Matriz transpuesta:\n", transpuesta)
224
Explicación:
 Como se puede observar, los programas para el manejo de listas en dos

dimensiones tienen la misma secuencia lógica:
1. Se obtienen los valores de la lista, bien sea que se digiten o que estén
previamente establecidos.
2. Con esos datos se procede a realizar algún proceso que arrojará un resultado.
3. Se muestran los datos que componen la lista, aunque este paso puede ser
opcional dependiendo de las características propias del problema que se está
solucionando.
Como los pasos 1 y 3, ya han sido cubiertos con explicaciones previas, en este
ejemplo nos concentraremos en el paso 2, en el cual se realiza el proceso de
calcular la transpuesta.
 Para obtener la transpuesta se ha definido la función calcular_transpuesta(), la

cual se detalla a continuación.
Esta función tiene un parámetro llamado dimensional, en el cual recibe la lista

que haya sido digitada por el usuario.
Luego se define una lista donde se almacena la matriz transpuesta (línea 13).
Para calcular la transpuesta se sigue un proceso similar al empleado en la lectura

de los ítems de la matriz (lista), pero, con la diferencia que el primer for itera de
acuerdo al número de columnas y el segundo for itera de acuerdo al número de
filas.
El primer for itera la variable i que se incrementa hasta alcanzar el número de

columnas de la matriz dimensional. A medida que hace cada iteración se anexa
una lista (fila) en la matriz llamada transpuesta. En el segundo for, que itera de
acuerdo a la cantidad de filas de la matriz dimensional, se van asignando los
valores de la matriz dimensional en la matriz transpuesta. El asunto clave en esta
asignación radica en que, mientras la matriz transpuesta itera de acuerdo con las
225
filas y columnas, la matriz dimensional lo hace en función de las columnas y filas,

es por eso que los índices de la matriz dimensional son j, i: dimensional[j][i]. Esta
operación está acorde con la definición que se tiene de matriz transpuesta: “la
matriz transpuesta se logra al intercambiar las filas por columnas”.
Una vez se tenga la matriz transpuesta, se procede a retornarla mediante la

instrucción return transpuesta (línea 18).
 En una de las ejecuciones de este programa, se podrían obtener los siguientes

resultados. Suponga que se tienen los siguientes datos en la lista:
dimensional = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
Los resultados de este programa se visualizarían así:
Matriz original:
1 2 3 4
5 6 7 8
9 10 11 12
Matriz transpuesta:
1 5 9
2 6 10
3 7 11
4 8 12
Ejemplo 5.13. Este programa lee los elementos de dos matrices y los almacena en
listas de dos dimensiones, luego calcula su producto.
Para poder realizar la operación de producto entre dos matrices hay que tener en
cuenta que el número de columnas de la primera matriz debe ser igual al número de
filas de la segunda matriz.
226
Por ejemplo: dadas las matrices A y B hallar A * B.
 6 −1 −5 8 
− 2 − 5
B =  2 − 3 
4
A= 4 0
0  2  3
y
 3 7
− 4 3 7 9  3  4
En este caso el producto de A * B sí está definido ya que, el número de columnas de

la primera matriz (n = 3) y el número de filas de la segunda matriz (m = 3) son iguales.
 6 −1 −5 8 
− 2 4 − 5  2 
AB =   4 0 −3 =
 3 7 02  3  
− 4 3 7 9  3  4
Para multiplicar matrices, se multiplican los componentes de la primera fila de la

matriz A con los componentes de la primera, segunda, tercera y cuarta columna de
la matriz B, sumando cada producto resultante, así:
C [1][1] = (-2)(6) + (4)(2) + (-5)(-4) = -12 + 8 + 20 = 16

C [1][2] = (-2)(-1) + (4)(4) + (-5)(3) = 2 + 16 – 15 = 3
C [1][3] = (-2)(-5) + (4)(0) + (-5)(7) = 10 + 0 – 35 = -25
C [1][4] = (-2)(8) + (4)(-3) + (-5)(9) = -16 – 12 – 45 = -73
Estos resultados representan la primera fila de la matriz resultante:
C = [16 3 - 25 – 73]
Ahora se procede a calcular los ítems de la segunda fila de la matriz.
227
Para ello, se multiplican los componentes de la segunda fila de la matriz A con los
componentes de la primera, segunda, tercera y cuarta columna de la matriz B
sumando cada producto resultante, así:
C [2][1] = (3)(6) + (7)(2) + (0)(-4) = 18 + 14 + 0 = 32

C [2][2] = (3)(-1) + (7)(4) + (0)(3) = -3 + 28 + 0 = 25
C [2][3] = (3)(-5) + (7)(0) + (0)(7) = -15 + 0 + 0 = -15
C [2][4] = (3)(8) + (7)(-3) + (0)(9) = 24 – 21 + 0 = 3
Finalmente se obtiene la matriz producto:
16 3 − 25 − 73
C=
32 25 − 15 3  2 4
Recuerde que la notación C[1][1], que se expresó en el anterior concepto

matemático, en Python se debe codificar como c[0][0], ya que la posiciones en este
tipo de datos (colecciones) inicia en 0,0.
Una de las posibles soluciones a este enunciado, se presenta a continuación:
1) # Calcula la multiplicación entre dos matrices

2)
4) dimensional = []
11)
228
12) def calcular_multiplicacion(dimensional_a, dimensional_b):

13) multiplicacion = []
14) for i in range(len(dimensional_a)):
15) multiplicacion.append([])
16) for j in range(len(dimensional_b[0])):
17) sumatoria = 0
18) for k in range(len(dimensional_b)):
19) sumatoria = sumatoria + dimensional_a[i][k] * dimensional_b[k][j]
20) multiplicacion[i].append(sumatoria)
21) return multiplicacion
22)
28) print()
29)
31) siga = True
32) while siga:
35) siga = False
36) else:
38) return numero
39)
40) filas_a = leer_int("\nFilas matriz A: ", 1, 5)
41) columnas_a = leer_int("Columnas matriz A: ", 1, 5)
42)
43) filas_b = leer_int("\nFilas matriz B: ", 1, 5)
44) columnas_b = leer_int("Columnas matriz B: ", 1, 5)
45)
46) if columnas_a == filas_b:
47) print("\nElementos matriz A\n")
48) lista_a = leer_elementos("Matriz A", filas_a, columnas_a)
49)
229
50) print("\nElementos matriz B\n")

51) lista_b = leer_elementos("Matriz B", filas_b, columnas_b)
52)
53) lista_c = calcular_multiplicacion(lista_a, lista_b)
54)
55) imprimir_elementos("Matriz A:\n", lista_a)
56) imprimir_elementos("Matriz B:\n", lista_b)
57)
58) imprimir_elementos("Matriz resultante producto:\n", lista_c)
59) else:
60) print("\nNo se puede realizar la multiplicación")
Explicación:
 Entre las líneas 40 y 44 se captura la dimensión de las dos matrices a multiplicar.
Con estos datos se debe verificar si es posible realizar la operación. Para

multiplicar matrices se tiene que, el número de columnas de la primera matriz,
debe ser igual al número de filas de la segunda; esta es la razón de la decisión
que se codificó en la línea 46:
if columnas_a == filas_b:
Si esta condición es True, se realiza entonces, la lectura de los ítems o elementos

de las dos listas o matrices. Luego se hace el llamado a la función
calcular_multiplicacion() en donde se realiza la operación y se retorna el
resultado.
Para finalizar el bloque de la parte verdadera de la anterior decisión if, se realiza

la impresión en pantalla de las dos matrices de entrada y la matriz resultante.
Si la condición es False, se procede con la instrucción de la línea 60 y se finaliza el

programa:
print("\nNo se puede realizar la multiplicación")
230
 Ahora bien, centraremos la explicación en la función calcular_multiplicacion(),

teniendo en cuenta que las demás funciones ya son conocidas.
A diferencia de los demás cálculos que se ha realizado en los otros programas, en

lugar de dos ciclos for, en esta solución se trabajaron tres ciclos. El primero
controla las filas de la matriz dimensional_a, el segundo controla las columnas de
dimensional_b y el tercero, que es el más interno (línea 18), controla las columnas
de dimensional_a y las filas de dimensional_b. Estos nombres corresponden a los
parámetros que reciben los valores de las matrices que se van a multiplicar.
El ciclo for más interno va iterando la variable k, que es usado como índice de las
columnas de dimensional_a y a la vez como índice de las filas de dimensional_b,
con ello se logra que cada ítem de la fila de dimensional_a se multiplique por
cada ítem de la columna de dimensional_b, este resultado se va acumulando en
la variable sumatoria. Cuando se termine de multiplicar cada ítem de la fila de
dimensional_a por cada elemento de la columna de dimensional_b, se anexa en
la posición i de la lista multiplicación el resultado de la variable sumatoria. Tenga
en cuenta que la expresión multiplicacion[i].append(sumatoria), se debe
interpretar como que, en la posición [i][j] de la lista multiplicacion se almacena el
valor de sumatoria. Luego, cuando la variable j tome el nuevo valor (se
incremente), la variable k se inicializa nuevamente en 0 y se procede a hacer la
multiplicación de la misma fila de dimensional_a por los ítems de la siguiente
columna de dimensional_b; cuando se termine de multiplicar los ítems de la fila
de dimensional_a por todos los ítems de las columnas de dimensional_b, se hace
el incremento de valor de la variable i y seguidamente se repite el mismo proceso
con la siguiente fila de dimensional_a.
Ejemplo 5.14. En este último ejemplo de listas de dos dimensiones, se mostrará que
ellas no solamente se usan en operaciones con matrices, también sirven para
almacenar y organizar información de manera temporal.
El programa leerá el producido diario de 3 vehículos que posee una persona. Esos
vehículos están identificados como Taxi, Bus y Uber. El valor producido de cada
vehículo se registrará durante una semana de lunes a viernes. Por último, se mostrará
231
en forma de tabla el producido de los tres vehículos por día y por semana, así mismo
se determinará cuál de ellos tiene mayor producción.
1) # Determina cuál vehículo obtienen mejores ganancias

2)
3) def leer_elementos(mensaje, vehiculos, filas, columnas):
4) dimensional = []
6) print(f"\n{mensaje[i]}\n")
9) numero = leer_float(f"{vehiculos[j]:7s}: ", 0, 999999)
12)
13) def calcular_producido(dimensional):
14) producido = [0] * len(dimensional[0])
17) producido[j] += dimensional[i][j]
18) return producido
19)
22) print(f"{mensaje[i]:10s}", end = "")
24) print(f"{dimensional[i][j]:11.1f}", end = " ")
25) print()
26)
27) def imprimir_totales(dimensional):
28) totales = calcular_producido(dimensional)
29) print(f"\nTotales $:", end = "")
30)
31) for i in range(0,len(dimensional[0])):
32) print(f"{totales [i]:11.1f}", end = " ")
33) return totales
34)
232
35) def encontrar_mayor(totales):

36) mayor = max(totales)
37) indice = totales.index(mayor)
38) return indice
39)
40) def leer_float(mensaje, minimo, maximo):
41) siga = True
42) while siga:
45) siga = False
46) else:
48) return numero
49)
50) vehiculos =("Taxi", "Bus ", "Uber")
51) dias = ("Lunes", "Martes", "Miércoles", "Jueves", "Viernes")
52)
53) columnas = len(vehiculos)
54) filas = len(dias)
55)
56) print("\nDigite el producido diario por cada vehículo")
57) dimensional = leer_elementos(dias, vehiculos, filas, columnas)
58)
59) print("\nVehículo --> Taxi Bus Uber\n")
60) imprimir_elementos(dias, dimensional)
61)
62) total = imprimir_totales(dimensional)
63)
64) indice = encontrar_mayor(total)
65)
66) print(F"\n\nEl {vehiculos[indice]} es el de mayor producido.")
Explicación:
 En las líneas 50 y 51 se definen dos tuplas. La primera la conforman los nombres

de los tres tipos de vehículos. La segunda almacena los días de la semana.
233
 En las líneas 53 y 54 se determina la dimensión de la lista donde se almacenarán

los datos del producido diario durante una semana. El número de columnas está
dado por la cantidad de vehículos y las filas por la cantidad de días. Por lo tanto,
estamos frente a una matriz de 5 x 3, 5 filas y 3 columnas.
 En la línea 57 se hace el llamado a la función leer_elementos(). Se envían cuatro

argumentos, representados por las tuplas dias y vehiculos, así como con, el
número de las filas y el de las columnas.
 En la línea 59 se muestra un título con el nombre de los tres vehículos,

seguidamente en la línea 60 se invoca la función imprimir_elementos(), llevando
como argumentos la tupla dias y la lista dimensional, en la cual se encuentra el
registro del producido diario de los tres vehículos durante una semana.
 La variable total de la línea 62, recibe como retorno desde la función

imprimir_totales(), una lista de 3 posiciones donde en cada una está el total
producido por cada vehículo durante la semana.
 En la línea 64 se encuentra la variable indice cuyo valor se obtiene desde la

función encontrar_mayor().
Por último, en la línea 66 se imprime el vehículo que tiene mayor producido. Note
que para ello se usa la siguiente instrucción teniendo en cuenta el indice que se
mencionó en el párrafo anterior:
print(f"\n\nEl {vehiculos[indice]} es el de mayor producido.")
Ahora entremos en detalle con las funciones anteriormente mencionadas.
 La lógica de la función leer_elementos(), es similar a la usada en los ejemplos que

se mostraron con las operaciones de las matrices. La única diferencia que
presenta es el parámetro vehiculos, que en este caso es la lista de los vehículos
que se van a trabajar.
234
No olvide que, en el llamado que se hizo a esta función desde la línea 57 se usaron
los siguientes argumentos:
dimensional = leer_elementos(dias, vehiculos, filas, columnas)
En la función son recibidos por los parámetros mensaje, vehiculos, filas y

columnas respectivamente, para ser usados de la siguiente manera:
 filas y columnas determinan la cantidad de veces que iteran las variables que
controlan los índices en los dos ciclos for.
 mensaje: va mostrando los días de la semana (línea seis).
 vehiculos: va mostrando los tipos de vehículos (línea nueve).
Por cada día de la semana, en pantalla se va desplegando algo similar a lo que se

muestra a continuación:
Lunes
Taxi :
Bus :
Uber :
Al finalizar con la lectura del producido de los vehículos durante los cinco días, se
retorna la lista dimensional con los valores registrados (línea 11).
 La segunda función mencionada es imprimir_elementos(). Ella a diferencia de la

usada en las operaciones con matrices, va imprimiendo los ítems de la tupla dias
en cada una de las filas de la lista de dos dimensiones. Cuando la función fue
llamada se hizo de la siguiente forma:
imprimir_elementos(dias, dimensional)
235
Note que se tiene como argumento la tupla días en donde están contenidos los
días de lunes a viernes. El contenido de esta tupla se imprime con la instrucción
de la línea 22 de la función imprimir_elementos():
print(f"{mensaje[i]:10s}", end = "")
Mientras que el contenido de la lista, se imprime con la instrucción de la línea 24:
print(f"{dimensional[i][j]:11.1f}", end = " ")
La salida que produce esta función es la siguiente:
Lunes 120000.0 200000.0 100000.0

Martes 105000.0 250000.0 80000.0
Miércoles 150000.0 270000.0 135000.0
Jueves 80000.0 310000.0 100000.0
Viernes 135000.0 305000.0 170000.0
 Como siguiente paso dentro del programa se tiene el cálculo del total
producido de cada vehículo, si observa la salida que se mostró en el anterior
punto, ese total se puede calcular sumando los valores relacionados a cada
vehículo, que son los que se visualizan en cada columna.
Para esta tarea se definió la función calcular_producido(), que recibe como

parámetro la lista que contiene el registro de los tres vehículos durante una
semana.
Observe con detenimiento la instrucción de la línea 14, con la cual se crea una
lista de una sola dimensión. La cantidad de ítems está dada de acuerdo a la
cantidad de columnas de la lista dimensional:
producido = [0] * len(dimensional[0])
En este ejemplo la cantidad de elementos es 3, que corresponde a la cantidad de

vehículos que se tienen; sin embargo, en la expresión se usó la función len() para
236
calcular esa cantidad, ya que el programa queda abierto para que adicionen más
vehículos a la tupla, sin necesidad de hacer modificaciones adicionales a las líneas
de programación. La expresión que se usó tiene como finalidad crear la lista en
donde cada ítem tiene el valor de 0, esto con el propósito de que sirvan de
acumuladores de la sumatoria del producido día tras día en cada vehículo.
Los dos ciclos for, van recorriendo la lista por filas y columnas, a medida que
avanza sobre las columnas, la expresión producido[j] += dimensional[i][j] va
acumulando el valor que se encuentre en ellas.
Al terminar el recorrido de la lista dimensional, en la lista producido se obtiene la

sumatoria de cada columna. Este resultado será usado por la función
imprimir_totales() para mostrar los resultados. A continuación, se explica esta
función.
 La función imprimir_totales(), tiene como tarea imprimir los totales que produce
cada vehículo durante una semana.
La variable totales, recibe los valores que sean enviados por la función
calcular_producido(), llamada que se hace en la línea 28.
El ciclo for de la línea 31, imprime los ítems de la variable totales, que equivalen
al producido semanal de cada vehículo. Cuando esta función se ejecute, la salida
en pantalla se estará visualizando así:
Vehículo --> Taxi Bus Uber
Lunes 120000.0 200000.0 100000.0

Martes 105000.0 250000.0 80000.0
Miércoles 150000.0 270000.0 135000.0
Jueves 80000.0 310000.0 100000.0
Viernes 135000.0 305000.0 170000.0
Totales $: 590000.0 1335000.0 585000.0
237
 La última función usada es encontrar_mayor(). Como su nombre lo indica

encuentra el mayor valor de los totales calculados y con él el índice
correspondiente al vehículo de mayor producido.
Para lograr ese cometido, en la línea 26 se hizo uso de la función max(), que
encuentra el mayor valor del elemento dentro de una lista o una tupla. Con este
dato se utilizó el método index(), que indica el índice del valor que se use como
argumento.
Finalmente se retorna el valor de dicho índice y se informa el nombre del vehículo

que lo ocupa.
Actividad 5.3. Escriba los programas que solucionen los siguientes enunciados.
a. Una matriz cuadrada es aquella donde el número de filas es igual a número de

columnas.
Los elementos diagonales de una matriz cuadrada tienen la característica que el

índice de la fila que ocupan, es igual al índice de la columna.
[0][0] [0][1] [0][2] [0][3]
[1][0] [1][1] [1][2] [1][3]
[2][0] [2][1] [2][2] [2][3]
[3][0] [3][1] [3][2] [3][3]
238
Construya una lista de dos dimensiones donde almacene los elementos de una
matriz cuadrada y encuentre la sumatoria de los elementos de la diagonal.
b. Lea los ítems de una matriz y construya con ellos dos listas de una dimensión, la
primera contendrá los elementos positivos (incluyendo el cero), la segunda
contendrá los elementos negativos.
c. Basándose en la solución del ejercicio anterior, debe convertir los elementos

positivos en negativos y los positivos en negativos, el cero queda igual.
d. Usando la función para generar números aleatorios, vista en un capítulo anterior,

genere una lista de dos dimensiones de tamaño m x n (máximo de 5 x 5) y llénela
con valores entre 1 y 99, encuentre la suma de los elementos en cada fila.
e. Se tiene una lista de dos dimensiones, donde se almacenan los elementos de una
matriz. Determine si es una matriz mágica. Una matriz mágica es aquella en que
la suma de cada una de sus filas, columnas y diagonales tienen el mismo valor.
Tenga presente que, las matrices mágicas tienen que ser cuadradas.
5.4 Diccionarios
Un diccionario es de tipo dict. Está conformado por una estructura de datos, cuyos
elementos pueden ser de diferente tipo, incluidas las tuplas, las listas y otros
diccionarios. Cada uno de los elementos que conforman al diccionario tienen una
clave o llave que permite su asociación con un valor. A diferencia de las tuplas y las
listas, los elementos de un diccionario no están organizados, ni pueden ser accedidos
por su posición.
Para definir un diccionario se debe utilizar un nombre y los caracteres de llaves { }.
Entre ellas van las parejas que conforman la clave y su valor, separadas mediante dos
puntos (:); cada uno de los elementos del diccionario se separan con comas. Ejemplo:
elementos = {"Cobre":"Cu", "Oro": "Au", "Helio": "He", "Plata":"Ag", "Oxígeno":"O"}
239
En el anterior ejemplo se le dio el nombre de elementos al diccionario. En él se aprecia

que cada elemento (ítem) está conformado por una pareja de clave y valor. Las claves
en este ejemplo, están representadas por los nombres que poseen los elementos de
la tabla periódica y los valores son sus símbolos químicos, ambos se separan
mediante dos puntos. Cada pareja (clave: valor) se separa de las demás mediante una
coma.
5.4.1 Impresión de los elementos de un diccionario
Para mostrar el contenido de un diccionario, se puede hacer mediante una función

print():
print(elementos)
En pantalla se visualiza así:
{'Cobre': 'Cu', 'Oro': 'Au', 'Helio': 'He', 'Plata': 'Ag', 'Oxígeno': 'O'}
Se puede hacer una consulta sobre un elemento específico utilizando la clave, el

resultado es el valor asociado a esa clave, por ejemplo:
print(elementos["Oro"])
En pantalla se muestra su símbolo químico: Au.
También se consigue el mismo resultado usando una variable para asignar el valor:
simbolo = elementos["Oro"]
print(simbolo)
En el caso de que se trate de buscar una clave que no existe, se genera un mensaje
de error. Para evitar esta situación, se puede usar el método get(), el cual presenta
dos parámetros.
240
Uso del método get() con un solo parámetro
El primer parámetro de este método es la clave, siempre debe estar presente.
simbolo = elementos.get("Oro")
print(simbolo)
Estas instrucciones muestran en pantalla el valor asociado a la clave, en este caso su

símbolo químico: Au.
Igual resultado se produce usándolo de forma directa dentro de la función print():
print(elementos.get("Oro"))
Si se usa una clave de un elemento que no exista, no se produce un error, sino que
su resultado será un objeto de tipo None:
print(elementos.get("Hidrógeno"))
Se muestra en pantalla la palabra None, que significa “nada”, “ninguna cosa”.
Uso del método get() con los dos parámetros
La otra manera de usar el método get() es con el uso de sus dos parámetros: la clave
y un mensaje.
print(elementos.get("Hidrógeno", "No registrado"))
Con esta forma, si la clave no se encuentra dentro del diccionario, se mostrará el

mensaje “No registrado”.
241
Un diccionario también puede contener otros diccionarios
elementos = {"Metales":{"Oro":"Au", "Plata": "Ag", "Zinc": "Zn", "Cobre":"Cu"},

"Gas noble":{"Helio":"He","Neón":"Ne","Argón":"Ar"},
"No-Metal":{"Oxígeno":"O", "Bromo":"Br", "Cloro":"Cl"}}
Recuerde que cada elemento de un diccionario está conformado por la pareja

clave:valor. Por lo tanto, dentro del diccionario llamado elementos, se encuentran
tres claves: Metales, Gas noble y No-Metal. Los valores de estas claves a su vez son
diccionarios. La clave Metales, tiene como valor el diccionario: {"Oro":"Au", "Plata":
"Ag", "Zinc": "Zn", "Cobre":"Cu"}, que, a su vez internamente, tiene 4 llaves (Oro,
Plata, Zinc y Cobre).
Así las cosas, si se quiere imprimir todo el contenido del diccionario llamado
elementos se usa la instrucción:
print(elementos)
De igual forma, si se quiere imprimir solo uno de los diccionarios que conforman el
diccionario elementos, basta con recurrir a la respectiva clave, así:
print(elementos["Metales"])
En pantalla se visualiza:
{'Oro': 'Au', 'Plata': 'Ag', 'Zinc': 'Zn', 'Cobre': 'Cu'}
Ahora bien, si se quiere el valor de una de las claves de los diccionarios que
conforman a elementos, se procede así:
print(elementos["Metales"]["Cobre"])
242
Esta instrucción imprime el valor de la clave Cobre, que hace parte del diccionario
que representa el valor asociado a la clave Metales del diccionario elementos. Por lo
tanto, el resultado en pantalla es:
Cu
Así mismo, las listas también pueden ser parte de un diccionario:
elementos = {"Oro":["Au", 79, "Metal"], "Plata":["Ag", 47, "Metal"], "Zinc":["Zn", 30, "Metal"],
"Helio":["He", 2, "Gas noble"], "Neón":["Ne", 10, "Gas noble"],
"Bromo":["Br", 35, "No-Metal"], "Cloro":["Cl", 17, "No-Metal"]}
El anterior diccionario se llama elementos. La clave de cada uno de los elementos

(ítem) que conforman el diccionario, está representada por el nombre de uno de los
elementos químicos (Oro, Plata, Helio, Cloro, entre otros). El valor de cada una de
estas claves es una lista, dentro de la cual se almacena el símbolo químico, el número
atómico y su clasificación.
Para visualizar el valor de la información asociado a una clave, se procede así:
print(elementos["Neón"])
Indica que se debe mostrar el valor asociado a la clave Neón. como resultado se
obtienen todos los ítems de la lista:
['Ne', 10, 'Gas noble']
Si se requiere solo un ítem de la lista, se debe indicar el índice de la posición que

ocupe:
print(elementos["Neón"][0])
En pantalla se visualiza Ne.
243
De igual forma, se puede usar un valor inicial y un valor final:
print(elementos["Neón"][0:2])
Este ejemplo muestra los ítems desde la posición 0 hasta la posición 1 de la lista:
['Ne', 10]
También, se puede hacer uso de un ciclo for para recorrer todos los ítems de la lista
asociada a la clave:
for i in range(len(elementos["Neón"])):
print(elementos["Neón"][i])
Con estas instrucciones se obtiene la siguiente salida:
Ne
10
Gas noble
Ahora bien, para mostrar todas las llaves del diccionario, se procede así:
for element in elementos:

print(element)
Esta será la salida de la anterior instrucción:
Oro
Plata
Zinc
Helio
Neón
Bromo
Cloro
244
Si en cambio, se requieren mostrar las llaves y sus valores, el for se codifica de la

siguiente forma:
for element in elementos:

print(element, elementos[element])
Obteniendo así estos resultados:
Oro ['Au', 79, 'Metal']

Plata ['Ag', 47, 'Metal']
Zinc ['Zn', 30, 'Metal']
Helio ['He', 2, 'Gas noble']
Neón ['Ne', 10, 'Gas noble']
Bromo ['Br', 35, 'No-Metal']
Cloro ['Cl', 17, 'No-Metal']
5.4.2 Anexando datos al diccionario
Los diccionarios al igual que las listas, son tipos de datos que pueden ser modificados.
Para anexar parejas de datos (llave y valor), se debe tener un diccionario definido, lo
cual se consigue así:
elementos = {}
Con esta instrucción se ha definido un diccionario vacío, llamado elementos. Note

que en esta ocasión se han usado las llaves, así como en las tuplas se usaron los
paréntesis y en las listas los corchetes.
Así que, una vez se tenga definido el diccionario, se puede procede a anexar las
parejas de datos. Como ejemplo vamos a adicionar los elementos Bromo y Cloro, con
sus respectivos símbolos.
elementos["Bromo"] = "Br"
elementos["Cloro"] = "Clor"
245
Al imprimir el diccionario, se tiene:
{'Bromo': 'Br', 'Cloro': 'Clor'}
Las claves son los nombres de los elementos y los valores asociados a esas claves son
los símbolos químicos.
Hemos cometido, a propósito, el error de ingresar mal el símbolo químico del Cloro,
puesto que es Cl y no Clor, esto con el fin de explicar cómo se hace una modificación.
5.4.3 Modificando el valor asociado a una clave
La modificación del valor de un elemento de un diccionario, se hace a través de su

clave:
elementos["Cloro"] = "Cl"
Con esta instrucción, se corrige el error que se había cometido al asignar el símbolo
químico del Cloro. El diccionario queda así:
{'Bromo': 'Br', 'Cloro': 'Cl'}
5.4.4 Funciones y métodos para diccionarios
Al igual como se mostró en las listas y en las tuplas, existen algunas funciones o
métodos que pueden ser trabajadas con los diccionarios. En párrafos anteriores se
hizo uso del método get(). Ahora se explicarán otros métodos y funciones de uso
común en este tipo de colecciones.
246
Función del
Permite el borrado de un elemento dentro de un diccionario. Retomemos el

diccionario que acabamos de crear y borremos el elemento Cloro:
elementos = {'Bromo': 'Br', 'Cloro': 'Cl'}

del elementos["Cloro"]
Con esto se borra tanto la clave, como el valor asociado a Cloro. El diccionario
quedaría así:
{'Bromo': 'Br'}
Método items()
Retorna la pareja que conforma a cada elemento (clave y valor):
element = elementos.items()
print(element)
Muestra en pantalla:
dict_items([('Cobre', 'Cu'), ('Oro', 'Au'), ('Helio', 'He'), ('Plata', 'Ag'), ('Oxígeno', 'O')])
El resultado del método items(), puede ser convertido a una lista de tuplas usando la
función list():
lista = list(elementos.items())
Como los elementos de un diccionario están conformados por la pareja clave:valor,

cada uno de ellos se almacena en una tupla y todas las tuplas, a su vez, conforman la
lista:
[('Cobre', 'Cu'), ('Oro', 'Au'), ('Helio', 'He'), ('Plata', 'Ag'), ('Oxígeno', 'O')]
247
Ya con esta estructura de tipo list, se pueden aplicar las diferentes formas de acceder
a sus elementos, por ejemplo:
print(lista[1])
Muestra en pantalla el elemento que hay en la posición 1 de la lista:
('Oro', 'Au')
Para mostrar el símbolo químico del Helio (He), que ocupa la posición 2 de la lista y
la posición 1 de la tupla, se escribe la siguiente instrucción:
print(lista[2][1])
Método keys()
Este método retorna las claves del diccionario. Retomemos el diccionario elementos:
elementos = {"Cobre":"Cu", "Oro": "Au", "Helio": "He", "Plata":"Ag", "Oxígeno":"O"}

claves = elementos.keys()
print(claves)
Se muestra en pantalla:
dict_keys(['Cobre', 'Oro', 'Helio', 'Plata', 'Oxígeno'])
Al igual que con el método items(), con keys() también se pueden llevar todas las
claves a una lista:
lista = list(elementos.keys())
print(lista)
248
La salida de estas instrucciones es la siguiente:
['Cobre', 'Oro', 'Helio', 'Plata', 'Oxígeno']
Método values()
Retorna los valores que hay asociados a cada clave dentro del diccionario:
valores = elementos.values()
print(valores)
Se obtiene como resultado:
dict_values(['Cu', 'Au', 'He', 'Ag', 'O'])
Si se quiere llevar estos valores a una lista, se procede así:
lista = list(elementos.values())
print(lista)
Obteniendo como resultado:
['Cu', 'Au', 'He', 'Ag', 'O']
5.4.5 Usando el ciclo for con diccionarios
En este caso, el elemento iterador del ciclo for es el diccionario. Se usa de la siguiente
manera.
Suponga el siguiente diccionario, que se quiere recorrer usando un ciclo for:
elementos = {"Cobre":"Cu", "Oro": "Au", "Helio": "He", "Plata":"Ag", "Oxigeno":"O"}
249
for elemento in elementos.items():

print(elemento[0], elemento[1])
Estas instrucciones dan el siguiente resultado:
Cobre Cu
Oro Au
Helio He
Plata Ag
Oxígeno O
Las claves y sus valores se están accediendo a través de un índice, esto se puede hacer
gracias a que se usó el método items(), no obstante, a pesar de ser una forma válida
no es la forma ideal, en su lugar, el ciclo for se debe escribir de la siguiente manera,
obteniendo los mismos resultados:
for element, simbolo in elementos.items():

print(element, simbolo)
A medida que el ciclo for va iterando, a la variable element se le asigna el valor de la

clave y a la variable simbolo el valor que hace pareja con ella.
Al llegar a este punto, se conoce el manejo básico de los diccionarios y las funciones
o métodos más utilizados con ellos; es hora entonces de ver algunos programas
completos.
A continuación, se creará un diccionario en el cual se almacenarán las selecciones

campeonas de mundiales de fútbol. En cada elemento, la clave será el año del
mundial y el valor asociado estará representado por el nombre de la selección. Para
la solución de este enunciado se crearán cuatro programas que, permitirán crear el
diccionario con las selecciones, consultar, modificar y borrar alguna selección.
250
Ejemplo 5.15. En este primer programa de diccionarios, se mostrará el proceso de

creación.
1) # Crear un diccionario con las selecciones campeonas mundiales de fútbol

2)
3) print("\nCampeones mundiales de fútbol")
4)
5) selecciones = {}
6) siga = "S"
7)
8) while siga == "S":
9) anio = int(input("\nAño: "))
10) equipo = input("Selección campeona: ")
11)
12) selecciones[anio] = equipo
13)
14) siga = input("\n¿Desea continuar adicionando [S][N]?: ").upper()
15)
16) print("\nEstas son las selecciones campeonas que se registraron:")
17) print(selecciones)
Explicación:
 En la línea cinco se define un diccionario vacío llamado selecciones. Una vez que
se haya definido, queda listo para que se puedan adicionar sus elementos.
 Se codifica un ciclo while con el propósito de repetir el proceso de lectura de los

elementos del diccionario, su ejecución está controlada por la respuesta del
usuario, quien decide cuándo terminar de adicionar elementos.
 Sobre las líneas 9 y 10 se piden los elementos. Recuerde que cada elemento en
un diccionario está formado por la pareja clave:valor. En la línea 9 se pide el año
del mundial, esta será la clave y en la línea diez se lee el equipo o selección, que
será el valor asociado a cada clave.
251
 Para ingresar esta pareja de datos o elemento al diccionario, se usa el nombre

del diccionario acompañado de las variables que representan la clave y su valor,
así:
selecciones[anio] = equipo
 El proceso se repite mientras que el usuario responda que sí desea continuar.
 El print de la línea 17 muestra los años y el nombre de las selecciones digitadas.
Ejemplo 5.16. Este programa realiza lo mismo que el anterior, crea un diccionario y
permite adicionar elementos a él.
Su objetivo es mostrar como se construye usando funciones de usuario para la

solución del enunciado.
1) # Crear un diccionario con las selecciones campeonas mundiales de fútbol

2)
3) def crear_selecciones():
4) print("\nCampeones mundiales de fútbol")
5)
6) selecciones = {}
7) siga = "S"
8)
10) anio = leer_int("\nAño: ", 1930, 2018)
11) equipo = leer_cadena("Selección campeona: ", 3)
12)
14)
15) siga = leer_booleano("\n¿Desea continuar adicionando [S][N]?: ")
16)
17) return selecciones
18)
252

20) siga = True
21) while siga:
24) siga = False
25) else:
27) return numero
28)
29) def leer_cadena(mensaje, minimo):
30) siga = True
31) while siga:
33) if len(cadena) >= minimo:
34) siga = False
35) else:
36) print(f"¡Error! Debe digitar mínimo {minimo} caracteres")
37) return cadena
38)
40) siga = True
41) while siga:
43) if respuesta == "S" or respuesta == "N":
44) siga = False
45) else:
46) print(f"¡Error! Debe digitar S o N")
48)
49) selecciones = crear_selecciones()
50) print("\nEstas son las selecciones campeonas que se registraron:")
51) print(selecciones)
Explicación:
 Se ha creado una función denominada crear_selecciones(), dentro de ella se crea

el diccionario llamado selecciones.
253
La forma de operar para la creación del diccionario y sus elementos, es casi la

misma que se explicó en el programa anterior. Algunas diferencias a resaltar son:
1. Se validó la entrada de los datos. El año debe ser un valor entre 1930 y 2018.
El nombre del equipo, mínimo, debe tener tres caracteres de longitud. De igual
forma, se validó la respuesta a si desea o no continuar.
2. Se usó un return para devolver el diccionario al sitio donde fue llamado.
 Se codificaron funciones para validar las lecturas de los datos. Estas ya han sido
utilizadas y explicadas con anterioridad en otros programas.
 En la línea 49 se hace el llamado a la función crear_selecciones(), desde la cual se

retorna el diccionario que es recibido y almacenado en la variable selecciones.
 Por último, en la línea 51 se imprimen todos los elementos del diccionario, es

decir, todos los años con su respectiva selección campeona.
Antes de continuar con los programas para la gestión del diccionario que almacena
las selecciones campeonas de mundiales de fútbol, es importante aclarar que, con el
fin de concentrar la explicación sobre el proceso de consulta, modificación y borrado,
los programas no se codificarán con funciones de usuario. Así mismo, se trabajará
sobre los siguientes elementos, previamente definidos en el diccionario llamado
selecciones:
Selecciones = {1994:"Brasil", 1998:"Francia", 2002:"Brasil", 2006:"Italia",

2010:"España", 2014:"Alemania", 2018:"Francia"}
Ejemplo 5. 17. Este programa permite consultar el nombre de la selección campeona,

utilizando el año como criterio de consulta.
254
A continuación, se muestra su codificación:
1) # Consultar una selección dentro del diccionario

2)
3) selecciones = {1994:"Brasil", 1998:"Francia", 2002:"Brasil", 2006:"Italia",
4) 2010:"España", 2014:"Alemania", 2018:"Francia"}
5)
6) siga = "S"
8) anio = int(input("\n¿De cuál año desea conocer la selección campeona?: "))
9)
10) equipo = selecciones.get(anio,"No")
11)
12) if equipo == "No":
13) print("No hay registro en esa fecha")
14) else:
15) print(f"La selección campeona en el {anio} fue {equipo}")
16)
17) siga = input("\n¿Desea continuar [S][N]?: ").upper()
Explicación:
 Se define el diccionario llamado selecciones, el cual contiene siete elementos con

valores predeterminados.
 Dentro del ciclo while se pide el año del mundial para, así conocer el nombre de
la selección campeona.
 Para la consulta se usó el método get(), que tiene como argumentos el año de
consulta y la palabra “No” (línea diez).
equipo = selecciones.get(anio,"No")
De esta forma, la variable equipo toma como valor el nombre de la selección que
corresponda al año de consulta, en el caso de no ser encontrado, el valor que se
le asigna a la variable equipo es la palabra “No”.
255
 La decisión de la línea doce compara si el valor de la variable equipo es igual a la

palabra “No”, en cuyo caso se muestra el mensaje “No hay registro en esa fecha”.
Si por el contario, el valor es diferente a la palabra “No”, se muestra el año y el
nombre de la selección campeona de ese año.
 El proceso termina por voluntad del usuario, al responder negativamente a la

pregunta: ¿Desea continuar [S][N]?: ", ubicada en la línea 17.
Ejemplo 5.18. Este programa permite modificar el nombre de la selección campeona,

utilizando el año como criterio de búsqueda.
1) # Modifica el nombre de una selección

2)
5)
6) print("\nModificar selección")
7) siga = "S"
10)
12)
14) print("\nNo hay registro en esa fecha")
15) else:
16) print(f"\nSelección a modificar: {equipo}")
17) equipo = input("\nNueva selección: ")
19) print("\nSe ha realizado el cambio satisfactoriamente")
20) equipo = selecciones.get(anio)
21) print(f"\nLa nueva selección para el año {anio} es: {equipo}")
22)
256
Explicación:
 Para realizar una modificación, primero se debe ubicar el elemento al cual se le

efectuará el proceso, por lo tanto, se hace una consulta dentro del diccionario.
De aquí se desprente la razón por la cual, este programa es similar al anterior
desde la línea 1 a la 15. Las instrucciones del else en este ejemplo, son las que
hacen la diferencia con el anterior.
La primera instrucción de la parte falsa de la condición del if, muestra el nombre

de la selección a modificar.
 Sobre la línea 17 se pide el nuevo nombre. En la línea 18 se procede a realizar el

cambio:
selecciones[anio] = equipo
Note que esta instrucción es igual a la que se usó en el programa de creación, con
ella se almacena la pareja conformada por clave:valor (año:selección).
Una vez realizado el cambio, se procede a informarlo:
print("\nSe ha realizado el cambio satisfactoriamente")
 Luego se realiza una nueva consulta en el diccionario para, corroborar que

efectivamente sí fue efectiva la operación de modificación:
equipo = selecciones.get(anio)
print(f"\nLa nueva selección para el año {anio} es: {equipo}")
 Por último, en la línea 23, se plantea la pregunta si se desea continuar con las
modificaciones, dependiendo de la respuesta, se repite o termina el proceso.
257
Ejemplo 5.19. Este programa permite borrar una selección del diccionario.
1) # Borra una selección del diccionario

2)
5)
6) print("\nBorrado de una selección")
7) siga = "S"
10)
12)
14) print("\nNo hay registro en esa fecha")
15) else:
16) print(f"\nSelección a borrar: {equipo}")
17) seguro = input("\n¿Desea proceder con el borrado [S][N]?: ").upper()
18) if seguro == "S":
19) del selecciones[anio]
20) print("\nSe ha realizado el borrado")
21) else:
22) print("\nNo se hizo borrado de la fecha seleccionada")
23)
Explicación:
 El procedimiento de borrado incluye una consulta previa del elemento a eliminar.

Las instrucciones desde la línea 1 hasta la 15, dode está el else, son similares a las
que se explicaron en el programa de consulta.
 La primera instrucción del else muestra el nombre de la selección a borrar. Antes

de realizar la eliminación se comprueba si efectivamente se quiere ejecutar, para
258
ello se planteó la pregunta que hay en la línea 17. Si la respuesta es afirmativa se

procede con la función del y se informa que se ha realizado la operación de
eliminación:
del selecciones[anio]
print("\nSe ha realizado el borrado")
Si, por el contrario, se responde que no se procederá con el borrado, el programa

mostrará el siguiente mensaje: “No se hizo el borrado de la fecha seleccionada”.
 Finalmente, en la línea 24 se pregunta si se desea continuar. Dependiendo de la

respuesta el proceso se repite o se termina.
Actividad 5.4. Realice las actividades que se plantean a continuación.
a. Tome los programas que se crearon anteriormente para el manejo del diccionario
de las selecciones y con todos ellos construya un solo programa que, debe ser
controlado a través de un menú con las siguientes opciones:
1. Crear las selecciones

2. Consultar una selección
3. Modificar el nombre de una selección
4. Borrar una selección
5. Terminar
Todas las entradas deben estar debidamente validadas, de acuerdo con los
valores solicitados. El programa terminará en el momento que elijan la opción 5
del menú.
b. Construya un programa similar al anterior para, gestionar un diccionario que

almacene una agenda con el teléfono y nombre de sus contactos.
259
c. Indique para que se utilizan las siguientes funciones y proponga un ejemplo de

su uso:
1. len()
2. append()
3. count()
4. extend()
5. index()
6. get()
7. insert()
8. keys()
9. max()
10. reverse()
d. ¿Qué es desempaquetar una tupla? y de un ejemplo de su uso.
260
INDICE
Anexando datos al diccionario, 245 Estructura de decisión, 91

append(), 187, 194 Expresión de asignación, 31
argumentos, 74 Expresión lógica, 30
bloque o cuerpo de la función, 64, 66 Expresión matemática, 24
BOOLEAN, 13 Expresión relacional, 29
cadena.capitalize(), 51 expresiones, 24
cadena.center(n, “a”), 51 extend(), 187
cadena.count(“a”), 51 False, 13
cadena.lower(), 51 float, 12, 38, 40
cadena.swapcase(), 51 floor(x), 56
cadena.title(), 51 for, 145, 176
cadena.upper(), 51 format( ), 37
Camel Case, 18 format(), 36
ceil(x), 56 from math import sqrt, sin, 54
clave: valor, 240 from nombre_módulo import, 54
Colecciones, 161 f-strings, 37
comentario, 34 Función del, 247
complex, 13 Función input( )., 39
constante, 81 Función len(), 167
contadores, 134 Función print( ), 34
continue, 125 Función range(), 146
cos(x), 56 Funciones, 51
count(), 168, 188 Funciones con parámetros, 72
Dato, 11 funciones integradas, 57
Decisiones anidadas, 100 funciones nativas, 57
def, 63 Funciones para cadenas., 51
del(), 189 Funciones propias de Python, 51
desempaquetar, 171 Funciones sin parámetros y sin retorno, 64
diccionario, 16 Funciones y métodos para diccionarios, 246
Diccionarios, 239 Funciones y métodos para tuplas, 166
dict, 16, 239 get(), 240
dir(nombre_modulo), 54 global, 71
elif, 106 global nombre_variable, 71
else, 91, 96 help, 55
empaquetar, 170 help(nombre_módulo.nombre_función), 55
Entrada y salida de datos, 34 hypot(), 59
enumerate, 192 identificador, 16
enumerate(), 178 if, 91
Escritura de fórmulas, 27 If sin else, 97
261
import, 53, 54 n, 59
import math, 54 número complejo, 13
Impresión de una tupla, 162 número entero, 12
indentación, 64 número real, 12
index(), 168 operador, 21
insert(), 187 Operador and, 23
Instrucción elif, 106 Operador not, 24
Instrucción for, 145 Operador or, 23
Instrucción while, 120 operadores lógicos, 23
int, 12, 38, 40 operadores matemáticos, 21
item, 184, 187, 193 operadores relacionales, 22
lambda, 83 palabras reservadas, 18
Lectura de ítems, 211 parámetro, 72
len(), 187 Pascal Case, 18
len(cadena), 51 pi, 56
lenguaje de alto nivel, 10 pop(), 189
lenguaje interpretado, 10 pow(), 57
list, 14, 182 pow(x, n), 56
list(), 247 Precedencia de operación, 25
lista, 14 procedimiento, 64
Lista vacía, 182 producto entre dos matrices, 226
Listas, 182 randint(), 133
Listas en dos dimensiones, 208 random, 133
literals strings, 37 Recomendaciones, 17
matemáticas, 208 Reglas, 17
math, 54, 56, 57 remove(), 188
matrices, 208 return, 64, 74
matriz, 215 return(valor), 64
matriz transpuesta, 223 reverse(), 190
max(), 169, 190 sangría, 64
método get(), 241 secuencia, 14
Método items(), 247 sin(), 54
Método keys(), 248 sin(x), 56
Método values(), 249 Snake Case, 18
Mezcla de listas, 184 sort(), 190
min(), 169, 190 sqrt(), 54, 137
modf(x), 56 sqrt(x), 56
Modificación de un item, 184 str, 13, 38
Modificación del valor de una clave, 246 STRING, 13
Módulos, 86 subíndices, 163
multiparadigma, 10 subrutina, 64
multiplataforma, 10 subrutinas, 64
Múltiples valores de retorno, 171 sum(), 191
262
tan(x), 56 Validación de datos de entrada, 136

tipado dinámico, 10 variable, 19
tipado fuerte, 10 variable centinela, 132, 134
tipos de datos, 11 variable de control, 124, 132
True, 13 variable global, 67, 68
tupla, 15 variable local, 67, 68
Tupla, 161 variable local en variable global, 71
tuple, 15, 161 Variable local y globlal, 67
Usando el ciclo for con diccionarios, 249 while, 120
Usando índices, 186
263
REFERENCIAS
Cevantes, O., Báez, D., Arízaga, A. & Castillo, E. (2017). Python con aplicaciones a las
matemáticas, ingeniería y finanzas. Ciudad de México, México: Alfaomega
Grupo Editor S.A.
Chazallet, S. (2016). Python 3, los fundamentos del lenguaje. Barcelona, España:

Ediciones ENI.
Cuevas, A. (2017). Python 3, Curso Práctico. Madrid, España: Ra-ma Editorial.
Herrera, O., Gutiérrez J. & Pulgarín, R. (2017). Introducción a la Lógica de

Programación. Armenia, Colombia: Editorial Elizcom.
Jaramillo, S., Cardona, S. & Castro, L. (2017). Lógica de Programación en Java.

Armenia, Colombia: Editorial Elizcom.
Pérez, A. (2016). Python Fácil. Ciudad de México, México: Alfaomega Grupo Editor
S.A.
Pulgarín, R., Herrera, O. & Gutiérrez J. (2018). Introducción a la Programación en C.

Armenia, Colombia: Editorial Elizcom.
Salazar, P. (2019). Empezando a Programar en Python. Bogotá, Colombia: Nuevas

Ediciones S.A.S.
264

Programacion en Python

Cargado por

Copyright:

Formatos disponibles

Programacion en Python

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Programacion en Python

Cargado por

Copyright:

Formatos disponibles

Introducción a la Programación en Python

SONIA JARAMILLO VALBUENA

SONIA JARAMILLO VALBUENA

No está permitida la reproducción total o parcial de este libro, ni su

1.2 Identificadores ............................................................................................ 16

1.5.3 Operadores lógicos ......................................................................... 23

1.6 Expresiones ................................................................................................. 24

1.6.1 Expresión matemática .................................................................... 24

1.8.1 Función print( ) ................................................................................ 34

1.9 Primeros programas .................................................................................. 42

2.2 Funciones definidas por el usuario o programador ............................. 63

2.3 Funciones lambda ...................................................................................... 83

3.1.1 if sin else ........................................................................................... 97

3.1.3 Instrucción elif................................................................................ 106

4 ESTRUCTURAS DE REPETICIÓN ............................................................ 119

4.1 Instrucción while ....................................................................................... 120

4.2 Instrucción for ........................................................................................... 145

5 COLECCIONES ............................................................................................ 160

5.1.2 Funciones y métodos para tuplas ............................................... 166

5.1.3 Desempaquetado de tuplas ......................................................... 170

5.1.5 Uso del ciclo for ............................................................................. 175

5.2 Listas .......................................................................................................... 182

5.2.2 Modificación de un item ............................................................... 184

5.2.4 Usando índices para acceder a los ítems ................................... 186

5.2.5 Funciones y métodos usados en listas ....................................... 187

5.4.1 Impresión de los elementos de un diccionario ......................... 240

5.4.4 Funciones y métodos para diccionarios..................................... 246

5.4.5 Usando el ciclo for con diccionarios ........................................... 249

Python es un lenguaje de programación que se disputa los primeros lugares de

Debido a la importancia y versatilidad de este lenguaje, fue que se escribió

Para el entendimiento de esta obra, no se requieren conocimientos previos en

Capítulo 1 – Fundamentos del lenguaje. En este capítulo se abordan las

palabras reservadas, operadores, expresiones, instrucciones de entrada y salida y se

Capítulo 2 – Funciones. Se busca introducir al lector, desde sus inicios en

Capítulo 4 – Estructuras repetitivas. En este capítulo se aborda el ciclo while y el ciclo

 Comprender los fundamentos del lenguaje para utilizarlo

Fundamentos del lenguaje

Python es un lenguaje de programación que se disputa los primeros lugares de

 Es un lenguaje de alto nivel, es decir, que trata de parecerse a un lenguaje natural.

A continuación, se estudiarán los elementos básicos que hacen parte de este

Es una pieza de información, mediante la cual se hace la representación simbólica de

Analizando el anterior ejemplo, si a usted le dan el dato 2020 o negro de forma

Los computadores o dispositivos de procesamiento reciben datos de entrada, luego

1.1.1 Tipos de datos

Los datos numéricos a su vez se subdividen en: enteros, reales y complejos.

Numérico entero. Un número entero es de tipo int. En esta categoría se encuentran

Diferente a Lenguaje C y a otros lenguajes, los datos string, en Python, también

'Gato', 'Calle 78 Norte 15-451', 'Juan Pablo Correa Guzmán', '74454548'.

Como buena práctica de programación se aconseja que, dentro de un mismo

Listas con un solo objeto o elemento:

Lista con varios elementos numéricos de tipo entero:

[10, 12, -20]

[1.5, "Niña", 17, -3, "Luna", "Benji"]

Una lista puede contener otra lista:

["Benji", [2014, "Canela", 12]]

Tuplas con un solo objeto o elemento:

A diferencia de las listas, las tuplas de un solo elemento deben ir acompañadas de

(2018) sin la coma, sería de tipo int.

("Luna") sin la coma, sería de tipo str.

Tupla con varios elementos numéricos de tipo entero: