CAPÍTULO III

Estructuras de Control

1. Estructuras condicionales.
Todo proceso de resolución de algún problema puede no solo contemplar un único
escenario(camino) posible para llegar a una solución, tal como se mostró anteriormen-
te, en el desarrollo de algoritmos suceden algunas circunstancias en que es necesario
evaluar cierto acontecimiento (o variable) a fin de tomar una decisión de que proceso
seguir desde el punto evaluado en adelante, este tipo de fenómeno procedimental se
trabaja mediante estructuras condicionales. En Python se puede observar tres tipos
de estructuras condicionales, una estructura simple, doble y múltiple:
Estructura simple: dada la evaluación de una variable se ejecuta un bloque de
actividades para luego volver al camino (escenario) original, esta ejecución de bloque
se dará solo si se cumple cierta condición, la cual será el motivo de la evaluación.
Un ejemplo se muestra a continuación:
Se desea ingresar los datos de una persona: nombre, edad, si la edad es 18 o mas de
18 años, se pedirá ingresar el documento de identidad (DNI), el programa mostrará
los datos ingresados.

ALGORITMO: datos de una persona

VARIABLES: nombre, edad, dni
INICIO:
Imprimir “Ingrese el nombre:”
Leer nombre
Imprimir “Ingrese edad:”
Leer edad
Si edad ≥ 18 entonces
Imprimir “Ingrese número de DNI:”
Leer dni
Fin si
Imprimir “Persona: ” + nombre
Imprimir “Edad: ” + edad
Si dni <> entonces
Imprimir “DNI: ” + dni
Fin si
FIN

Obsérvese que en el algoritmo se emplea dos veces una estructura condicional simple,
la primera evalúa la variable edad, si cumple con la condición (edad ≥ 18) entonces
pedirá que se ingrese el numero de DNI, en el segundo caso el algoritmo evalúa la
variable dni para saber si tiene algún valor (dni ̸= NULL) si es diferente de vacı́o
(NULO) quiere decir que se le asignó algún valor de contenido (porque la persona
tiene 18 o más de 18 años), el mismo algoritmo se refleja en el siguiente diagrama:
Gráficamente se puede observar como el algoritmo no contempla un solo escenario
de solución, la implementación en Python está a continuación:

nombre = input(”ingrese nombre:”)

edad = int(input(”ingrese edad:”))

1
if edad ≥ 18:
dni = input(”ingrese DNI:”)
print(”persona: ”+ nombre)
print(” edad”+ str(edad))
if dni:
print(”DNI: ”+ dni)

En el programa se sigue paso a paso el algoritmo diseñado (en seudocódigo y en

diagrama de flujo) como sabemos nombre es una variable que recibe un valor string
mediante input() al igual que la variable edad, sin embargo, edad es un numero
entero, es por eso que int(input()) transformará el valor ingresado en un numero
entero, nótese la sintaxis de la estructura condicional simple: En la comparación se
emplean el operador ≥ (mayor igual) luego los : (dos puntos), las actividades que
encierran si se cumple esta condición se denotan mediante la sangrı́a:

if edad ≥ 18:
dni = input(”ingrese DNI:”)

la operación de dar un valor tipo string a la variable dni se ejecutará solo si se

cumple que el valor asignado a edad (entero) es 18 o mayor a este número, el empleo
de la sangrı́a para denotar un bloque de ejecución se denomina Indentación. La
Indentación reemplaza el empleo de las . En otros lenguajes, se denotan los bloques
con el empleo de las llaves {} :

if (edad ≥ 18)
{
cout<<”Ingrese DNI:”;
cin>>dni;
}

Si solo existe una lı́nea de instrucción, es posible obviar las llaves y colocar la ins-
trucción en la lı́nea de abajo o en la misma lı́nea inclusive:

if(edad ≥ 18) cin>>dni;

Pero Python estable estrictamente el empleo de la sangrı́a (no confundir con ta-
bulaciones); volviendo al programa, luego de aplicar la estructura condicional, se
imprimen los valores de nombre y edad,

print(”persona: ”+ nombre)
print(”edad”+ str(edad))

en la primera lı́nea se concatena dos cadenas: “persona” (se imprime tal cual, es una
cadena [string], puesta esta compuesta por una secuencia de caracteres) y el valor de
la variable nombre (recuerda que esta variable tiene asignado un valor string) usando
el operador + ; en la segunda lı́nea se imprime una cadena: “edad” concatenada a el
valor de edad como string [str(edad)], esto no significa que estamos convirtiendo el
tipo de la variable, solo estamos presentándola (para la impresión) como una cadena.
A continuación, el programa hace otra comparación:

if dni:
print(”DNI: ”+ dni)

2
aquı́ se evalúa el valor de la variable dni, si dni tiene valor la condición se cumple y
se imprimirá la cadena “DNI” concatenada a el valor [string] de la variable dni.

Estructura doble: cuando sucede que dada cierta condición, esta se puede cumplir
o no, a diferencia del caso anterior la condición tiene dos escenarios a seguir, el
escenario TRUE (si la condición es verdadera) o el escenario FALSE si la condición
no se cumple (falso), en el desarrollo de software se denomina a este tipo de estructura
SI..SI..NO, para entender como funciona, obsérvese el siguiente ejemplo:

Se desea ingresar un valor numérico, el programa evaluará el valor ingresado, si es

mayor o igual a cero se imprimirá: “el valor ingresado pertenece al conjunto N”, si
el valor ingresado es menor a cero se imprimirá: “el valor ingresado pertenece a Z”.
NOTA: para el ejemplo se considera al cero (0) como valor natural.

La implementación en Python es la siguiente:

numero = int(input(”ingrese un numero entero:”))

if numero ≥ 0:
print(”el valor ingresado pertenece al conjunto N”)
else:
print(”el valor ingresado pertenece a Z”)

Una vez asignado el valor ingresado en la variable número, el programa evalúa el

valor capturado, si este valor es mayor o igual que cero imprime la primera cadena,
si esto no se cumple, la única opción que resta es que el valor sea menor a cero y
por tanto es negativo, es decir esta en el conjunto Z (valores enteros)
Como se aprecia, una estructura condicional doble, generará dos posibles escena-
rios de trabajo para el algoritmo diseñado, también se podrı́a usar dos estructuras
condicionales simples para resolver el problema, observa el siguiente programa:

numero = int(input(”ingrese un numero entero:”))

if numero ≥ 0:
print(”el valor ingresado pertenece al conjunto N”)
if numero < 0:
print(”el valor ingresado pertenece al conjunto Z”)

el razonamiento, refiere que se evalúa dos veces la variable número, el programa da

el mismo resultado, sin embargo, la segunda evaluación se convierte en un proceso
innecesario, pues, si el numero no cumple con la primera condición necesariamente,
se cumplirá la segunda, por eso, es mejor usar una estructura condicional doble.
Estructura condicional múltiple: muchas veces es necesario evaluar una variable
y de acuerdo al resultado será necesario construir múltiples escenarios de comporta-
miento para nuestro algoritmo. Por ejemplo:
Si se dese desarrollar un programa que permita el ingreso de un número entre 0 y 9
y nuestro el número en letras:
Algoritmo implementado con estructuras simples:

ALGORITMO: números
VARIABLES: numero
INICIO:
Imprimir “Ingrese un numero entre 0 y 9: ”

3
 Leer numero
Si numero = 0 entonces
Imprimir “cero”
Fin Si
Si numero = 1 entonces
Imprimir “uno”
Fin Si
Si numero = 2 entonces
Imprimir “dos”
Fin Si
Si numero = 3 entonces
Imprimir “tres”
Fin Si
Si numero = 4 entonces
Imprimir “cuatro”
Fin Si
Si numero = 5 entonces
Imprimir “cinco”
Fin Si
Si numero = 6 entonces
Imprimir “seis”
Fin Si
Si numero = 7 entonces
Imprimir “siete”
Fin Si
Si numero = 8 entonces
Imprimir “ocho”
Fin Si
Si numero = 9 entonces
Imprimir “nueve”
Fin Si
Si numero <0 o numero >9 entonces
Imprimir “numero fuera del rango solicitado”
Fin Si
FIN

La implementación en Python a continuación:

num = int(input(”ingrese un numero menor a 10 positivo:”))

if num == 0:
print(”cero”)
if num == 1:
print(”uno”)
if num == 2:
print(”dos”)

4
if num == 3:
print(”tres”)
if num == 4:
print(”cuatro”)
if num == 5:
print(”cinco”)
if num == 6:
print(”seis”)
if num == 7:
print(”siete”)
if num == 8:
print(”ocho”)
if num == 9:
print(”nueve”)
if num <0 or num >9:
print(”numero fuera del rango solicitado”)

las evaluaciones de variables emplean operadores (ver ı́tem 7 del capı́tulo I), para
generar intervalos se emplean los operadores lógicos y los operadores matemáticos:

ejemplo:
numero ∈ [0,9] numero ≥ 0 and numero ≤ 9 (intervalo cerrado)
numero >-1 and numero <10
numero ∈ ]-1,10[ numero >-1 and numero <10 (intervalo abierto)
numero ≥ 0 and numero ≤ 9

Para que la expresión será verdad, debe cumplirse ambos lados de la evaluación, el
valor ingresado debe ser mayor o igual que cero y al mismo tiempo menor o igual que
9, esto solo lo cumplen los valores [0,1,2,3,4,5,6,7,8,9], observa que esta comparación
es con valores enteros, se debe tener cuidado cuando se comparen los valores reales
(float)

ejemplo:
comprar una calificación numérica, si es mayor o igual que 11 es aprobado, de lo
contrario esta desaprobado (considera el redondeo).

nota = float(input(“ingrese nota:”))

if nota ≥ 10.5 :
print(“aprobado”)
else:
print(“desaprobado”)

También es posible unir rangos:

numero ∈ [0,5]U[11,20]
numero >= 0 and numero <= 5 or numero >10 and numero <21

5
Se llama operación de multiplicación lógica a and y suma lógica a or, por consi-
guiente, y bajo las reglas matemáticas se resolverá primero and y posteriormente
or.
Volviendo al caso inicial de este apartado, se resolverá el problema con estructuras
dobles, pero debemos considerar el concepto de estructuras anidadas.

Estructura condicional anidada: una anidación sucede cuando existe una o mas
estructuras condicionales, dentro de otra estructura condicional.
Este algoritmo es fácil de implementar en Python, se puede implementar de dos
maneras:
Primera implementación:
num = int(input(”ingrese un numero menor a 10 positivo:”))

if num == 0:
print(çero”)
else:
if num == 1:
print(üno”)
else:
if num == 2:
print (”dos”)
else:
if num == 3:
print(”tres”)
else:
if num == 4:
print(çuatro”)
else:
if num == 5:
print(çinco”)
else:
if num == 6:
print(”seis”)
else:
if num == 7:
print(”siete”)
else:
if num == 8:
print(.ocho”)
else:
if num == 9:
print(”nueve”)
else:
print(”numero fuera del rango solicitado”)

6
también se puede implementar con la sentencia elif, que combina las sentencias
if. . . else, y ahorra el empleo de la sangrı́a, a continuación, la segunda implementación
del algoritmo:

num = int(input(”ingrese un numero menor a 10 positivo:”))

if num == 0:
print(”cero”)
elif num == 1:
print(”uno”)
elif num == 2:
print(”dos”)
elif num == 3:
print(”tres”)
elif num == 4:
print(”cuatro”)
elif num == 5:
print(”cinco”)
elif num == 6:
print(”seis”)
elif num == 7:
print(”siete”)
elif num == 8:
print(”ocho”)
elif num == 9:
print(”nueve”)
else:
print(”numero fuera del rango solicitado”)

Es similar al empleo de la estructura simple, pero observa el final, ya no hay necesidad

de hacer la ultima comparación, pues se interpreta como si fuera estructuras dobles
anidadas.
Aunque en la mayorı́a de casos los desarrolladores de software están acostumbrados
a emplear una estructura switch. . . case, en Python esta estructura no existe, esto se
debió a diversos motivos propios de los desarrolladores de Python, sin embargo, se
puede generar una estructura tipo switch . . . case usando diccionarios, esta es una
alternativa al uso de las estructuras simple o dobles al desarrollar un algoritmo que
tras la evaluación de una variable se puede optar por diferentes escenarios.

Diccionarios en Python: un diccionario es una colección de posibles valores que

una variable puede tomar. Para hacer esto se debe crear una pequeña función, ob-
serva el siguiente código:
def numeroSwitch(i):
diccionarioNumeros ={
0:’cero’,
1:’uno’,
2:’dos’,
3:’tres’,
4:’cuatro’,

7
 5:’cinco’,
6:’seis’,
7:’siete’,
8:’ocho’,
9:’nueve’
}
return diccionarioNumeros.get(i,”numero fuera del rango solicitado”)

Obsérvese que se ha creado la función numeroSwitch(i), es un parámetro (variable)

que recibirá la función, dicha variable será el valor que se evaluará, diccionarioNume-
ros = . . . ,. . . ,. . . es la agrupación de posibles valores que i (el parámetro que recibe
la función numerosSwitch recibe), nótese que la agrupación de los posibles valores
se encuentra encerrada dentro de las llaves y separadas por una coma:

diccionarioNumeros = 0:’cero’, 1:’uno’, 2:’dos’, 3:’tres’, 4:’cuatro’, 5:’cinco’,

6:’seis’, 7:’siete’, 8:’ocho’, 9:’nueve’

Al designar el ultimo posible valor del diccionario no se coloca una coma ( 9:’nueve’ )
lo que se evaluará es la variable i versus el primer ı́ndice de cada valor del diccionario
y de acuerdo a esto se devolverá el valor que esta después de los dos puntos:

si i es 0, se devolverá la palabra “cero”,

si i es 1, se devolverá la palabra “uno”, etc

la instrucción: return diccionarioNumeros.get(i,”numero fuera del rango solicitado”)

indica lo que se explica en el párrafo precedente, se puede interpretar como retornar
el resultado de la evaluación de i en el diccionario, si i no coincide con ningún valor,
se debe devolver la cadena “numero fuera del rango solicitado”. Para ver el resultado
se imprimirá en pantalla el numero en letras empleando la instrucción print.

def numeroSwitch(i):
diccionarioNumeros={
0:’cero’,
1:’uno’,
2:’dos’,
3:’tres’,
4:’cuatro’,
5:’cinco’,
6:’seis’,
7:’siete’,
8:’ocho’,
9:’nueve’
}
return diccionarioNumeros.get(i,”numero fuera del rango solicitado”)

numero = float(input(ı̈ngrese un numero menor a 10 positivo:”))

print(numeroSwitch(numero))

Nota el empleo de las sangrı́as, la función numeroSwitch(i) tiene como ultima lı́nea
el retorno de valor. Por esto se puede decir que el concepto de una función es similar

8
al concepto manejado en las matemáticas, pues una función evalúa u opera un valor
y devuelve un resultado.

numero = float(input(ı̈ngrese un numero menor a 10 positivo:”))

print(numeroSwitch(numero))

en la primera lı́nea se lee el valor desde el teclado, dicho valor se transforma en valor
real (numérico) y se guarda en la variable número, en la segunda lı́nea se imprime
un valor, se imprime el valor que resulta de evaluar la variable número en la función
numeroSwitch.
Para entender mejor este acápite, obsérvese el siguiente ejemplo:

Se desea desarrollar un algoritmo que permita leer dos números desde teclado (en-
tero), el primer número indica el mes, por lo tanto, el algoritmo mostrará el nombre
del mes y la cantidad de dı́as tiene dicho mes (para esto considerar el segundo valor
ingresado, pues representa el año).

Primero se define el algoritmo de la función que simula una instrucción switch, se

llamará mesSwitch y recibirá un valor numero entero (el numero que representa el
mes) y está función devolverá el nombre del mes (esta ves evaluará si el valor esta
fuera de rango, eso se hará en el cuerpo principal del programa, es decir, se llamará
a esta función solo si el número del mes esta entre 1 y 12)

SUB ALGORITMO: mesSwitch

VARIABLES:
i (input)
INICIO:
Leer i (como parámetro de entrada)
Comparar i:
Si es 1 entonces “enero”,
Si es 2 entonces “febrero”,
Si es 3 entonces “marzo”,
Si es 4 entonces “abril”,
Si es 5 entonces “mayo”,
Si es 6 entonces “junio”,
Si es 7 entonces “julio”,
Si es 8 entonces “agosto”,
Si es 9 entonces “septiembre”,
Si es 10 entonces “octubre”,
Si es 11 entonces “noviembre”,
Si es 12 entonces “diciembre”
Fin comparar
Devolver nombreMes
FIN

Su implementación en Python, se escribe a continuación:

def mesSwitch(i):
diccionarioMes={

9
 1:’enero’,
2:’febrero’,
3:’marzo’,
4:’abril’,
5:’mayo’,
6:’junio’,
7:’julio’,
8:’agosto’,
9:’septiembre’,
10:’octubre’,
11:’noviembre’,
12:’diciembre’
}
return diccionarioMes.get(i)

Ahora hay que desarrollar el algoritmo principal:

ALGORITMO fecha
VARIABLES:
Mes, anio, bisiesto, nombreMes
INICIO:
Leer mes
Leer anio
bisiesto ← 1
Si anio MOD 4 = 0 entonces
Si anio MOD 100 = 0 entonces
Si anio MOD 400 = 0 entonces
bisiesto ← 1
Si no
bisiesto ← 0
Si no
bisiesto ← 1
Si no
bisiesto ← 0
Si mes <1 o mes >12 entonces
Imprimir “no es un mes valido”
Si no
nombreMes ← mesSwitch(mes)
imprimir mes + nombreMes + anio
Si mes = 2 y bisiesto = 1 entonces
Imprimir “29”
Si no
Si mes = 2 entonces
Imprimir “28”
Si no

10
 Si mes = 1 o mes = 3 o mes = 5 o mes = 7 o mes = 10 o
mes = 12
Imprimir “31”
Si no
Imprimir “30”
Si bisiesto = 1 entonces
Imprimir “año bisiesto”
Si no
Imprimir “año no bisiesto”
FIN

Luego de ingresar los valores de mes y anio, se asigna el valor 1 a la variable bisiesto,
para el algoritmo 1 significa que el año es bisiesto y 0 significa que el año no es
bisiesto, al inicio el algoritmo asume que el año es bisiesto, pero a continuación
procede a evaluar el valor de año leı́do, si el año cumple no cumple con lo necesario
para ser bisiesto (un año divisible por 4 es un año bisiesto, sin embargo, hay que
considerar que el calendario gregoriano menciona que un año que es divisible por
100 es un año bisiesto solo si se cumple que también es divisible por 400) la variable
bisiesto cambia de valor a 0. Luego se procede a evaluar si el número leı́do para la
variable mes es válido [1,12], de ser válido se continua, de lo contrario se muestra un
mensaje de error y el algoritmo acaba.
Si es un numero adecuado, se llama a la función mesSwitch, la cual devolverá el
nombre del mes, este nombre será asignado a la variable nombreMes, a continuación
se imprime los valores de mes, nombreMes y anio, el algoritmo continua evaluando
el número de mes y si la variable bisiesto es 1, de ser ası́ imprimirá 29 como cantidad
de dı́as, de lo contrario evaluará si el número del mes coincide con los meses que
traen 31 dı́as, de ser ası́ imprimirá 31 o de lo contrario imprimirá 30; por último, el
algoritmo evalúa si la variable bisiesto es 1, de se ası́, imprime “año bisiesto” de lo
contrario, imprimirá “año no bisiesto”.
A continuación, la implementación en Python:

mes = int(input(Ïngrese el número de mes: ”))

anio = int(input(Ïngrese el año: ”))
bisiesto = 1
if anio % 4 == 0:
if anio % 100 == 0:
if anio % 400 == 0:
bisiesto = 1
else:
bisiesto = 0
else:
bisiesto = 1
else:
bisiesto = 0
if mes <1 or mes >12:
print(”no es un mes valido”)
else:
nombreMes = mesSwitch(mes)

11
 print(”Fecha: ”+ str(mes) + ”de ”+ nombreMes + ”de ” + str(anio) + ”,can-
tidad de dias: ”, end=)
if mes == 2 and bisiesto == 1:
print(”29”, end=)
else:
if mes == 2:
print(”28”, end=)
else:
if mes == 1 or mes == 3 or mes == 5 or mes == 7 or mes == 10 or mes
== 12:
print(”31”, end=)
else:
print(”30”, end=)
if bisiesto == 1:
print(”[año bisiesto]”)
else:
print(”[año no bisiesto]”)

cuando se emplea la instrucción print en dos lı́neas seguidas imprime los valores de
igual forma en dos lı́neas seguidas:

print(“hola”)
print(“mundo”)

la salida de esto es:

hola
mundo
si se desea imprimir en la misma lı́nea (un retorno de lı́nea), es decir imprimir dos
valores distintos, pero que estos aparezcan en la misma lı́nea se empleará end=””
como segundo parámetro en print:

print(“hola”, end=””)
print(“mundo”)

la salida de esto es:

hola mundo

Ejemplos propuestos: la siguiente lista de problemas resueltos tiene por objetivo

que se comprenda el código, generes el algoritmo (describas el algoritmo: ingenierı́a
inversa) y mejores el programa (usar otras maneras de resolver el problema)
a) Desarrollar un algoritmo que lea 2 números y una operación matemática y a
continuación efectúe la operación, las operaciones son: adición, sustracción, mul-
tiplicación, división y modulo(residuo).

numero1 = float(input(ı̈ngrese el primer valor: ”))

numero2 = float(input(ı̈ngrese el segundo valor: ”))
operacion = input(ı̈ngrese la operacion: n”

12
 ”[+]adición n”
”[-]sustracción n”
”[*]multiplicación n”
”[/]división n”
”[ %]modulo: ”)
if operacion == -”:
print(str(numero1)+- -str(numero2)+- -str(numero1+numero2))
elif operacion == ”:
print(str(numero1) + - str(numero2) + - - str(numero1 - numero2))
elif operacion == ”*”:
print(str(numero1) + ”* - str(numero2) + - - str(numero1 * numero2))
elif operacion == /”:
print(str(numero1) + / - str(numero2) + - - str(numero1 / numero2))
elif operacion == ”
print(str(numero1) + ”
else:
print(.operacion no valida”)

b) Desarrolla el programa que permita ingresar dos números, el programa deberá

mostrar los valores en forma ascendente o descendente, según se indique desde
el teclado, considerar el caso en que ambos números son iguales.

numero1 = float(input(ı̈ngrese el primer valor: ”))

numero2 = float(input(ı̈ngrese el segundo valor: ”))
if numero1 != numero2:
orden = int(input(”Desea mostrarlos de manera Ascendente [1] o Des
cendente [2]:”))
numero1 = float(input(ı̈ngrese el primer valor: ”))
numero2 = float(input(ı̈ngrese el segundo valor: ”))
if numero1 != numero2:
orden = int(input(”Desea mostrarlos de manera Ascendente [1] o Descendente
[2]:”))
if numero1 >numero2:
mayor = numero1
menor = numero2
else:
mayor = numero2
menor = numero1
if orden == 1:
print(”:.0f,:.0f”.format(menor,mayor))
else:
print(”:.0f,:.0f”.format(mayor,menor))
else:
print(”los numeros ingresados son iguales”)

c) Desarrolla un programa que lea un carácter desde teclado, el programa debe

reconocer si el carácter ingresado es letra, numero o carácter especial, si es
letra, debe considerar si es mayúscula o minúscula.

caracter = input(ı̈ngrese un caracter:”)

if len(caracter)>1:
print(”se considerará solo el primer caracter de la cadena”)

13
 caracter = caracter[0]
print(”´”+caracter+”´”,end=)
if ord(caracter) >= 97 and ord(caracter)<= 122 or ord(caracter) == 241:
print(.es letra minuscula ”,end=)
elif ord(caracter) >= 65 and ord(caracter)<= 90 or ord(caracter) == 209:
print(.es letra mayuscula ”,end=)
elif ord(caracter) >= 48 and ord(caracter) <= 57:
print(.es un numero ”, end=)
else:
print(.es es un caracter especial ”, end=)
print( su codigo ASCII es: ”,end=)
2

if ord(caracter) == 241:
print (”164”)
elif ord(caracter) == 209:
print(”165”)
else:
print(str(ord(caracter)))

(*) nota: para que el Python reconozca la ‘Ñ’ o la ‘ñ’, es necesario trabajar
con los números 209 y 241 (solo para el reconocimiento), pero se sabe que el
verdadero código ASCII de ‘Ñ’ es 165 y de ‘ñ’ es 164.

d ) Desarrolla un programa que permita el ingreso de tres valores enteros, el progra-

ma debe ordenarlos de mayor a menor, se debe considerar si se ingresan valores
iguales (no usar conectores lógicos, comparar dos valores en cada condición).

num1 = int(input(”numero 1:”))

num2 = int(input(”numero 2:”))
num3 = int(input(”numero 3:”))
if num1 == num2:
if num3 == num1:
print(”son iguales”)
else:
if num3 >num1:
mayor = num3
medio = num2
menor = num1
else:
mayor = num1
medio = num2
menor = num3
else:
if num1 == num3:
if num1 == num2:
print(”son iguales”)
else:
if num2 >num1:
mayor = num2
medio = num3
menor = num1
else:

14
 mayor = num1
medio = num3
menor = num2
else:
if num2 == num3:
if num2 == num1:
print(”son iguales”)
else:
if num1 >num2:
mayor = num1
medio = num2
mayor = num3
else:
mayor = num3
medio = num2
menor = num1
else:
if num1 >num2:
if num1 >num3:
mayor = num1
if num2 >num3:
medio = num2
menor = num3
else:
medio = num3
menor = num2
else:
mayor = num3
medio = num1
menor = num2
else:
if num2 >num3:
mayor = num2
if num3 >num1:
medio = num3
menor = num1
else:
medio = num1
menor = num3
else:
if num3 >num1:
mayor = num3
medio = num2
menor = num1
print(mayor)
print(medio)
print(menor)

15
e) Modifica el programa anterior, para emplear comparaciones usando operadores
lógicos (comparaciones compuestas)

num1 = int(input(”numero 1:”))

num2 = int(input(”numero 2:”))
num3 = int(input(”numero 3:”))
if num1 == num2:
if num3 == num1:
print(”son iguales”)
mayor = menor = medio = num1
else:
if num3 >num1:
mayor = num3
medio = num2
menor = num1
else:
mayor = num1
medio = num2
menor = num3
else:
if num1 == num3:
if num1 == num2:
print(”son iguales”)
mayor = menor = medio = num1
else:
if num2 >num1:
mayor = num2
medio = num3
menor = num1
else:
mayor = num1
medio = num3
menor = num2
else:
if num2 == num3:
if num2 == num1:
print(”son iguales”)
mayor = menor = medio = num1
else:
if num1 >num2:
mayor = num1
medio = num2
mayor = num3
else:
mayor = num3
medio = num2
menor = num1
else:
if num1 >num2 and num1 >num3:
mayor = num1
if num2 >num3:

16
 medio = num2
menor = num3
else:
medio = num3
menor = num2
else:
if num2 >num1 and num2 >num3:
mayor = num2
if num1 >num3:
medio = num1
menor = num3
else:
medio = num3
menor = num1
else:
mayor = num3
if num2 >num1:
medio = num2
menor = num1
else:
medio = num1
menor = num2
print(mayor)
print(medio)
print(menor)

f ) Desarrolla un programa que lea un nombre y un apellido, permita seleccionar el

estilo del texto, color y color del fondo, y lo imprima en pantalla.
def estiloSwitch(i):
diccionarioEstilo={
1:’Negrita’,
2:’Debil’,
3:’Cursiva’,
4:’Subrayado’,
5:’Inverso’,
6:’Oculto’,
7:’Tachado’,
0:’ninguno’
}
return diccionarioEstilo.get(i)

def colorTextoSwitch(i):
diccionarioColorTexto={
30:’Negro’,
31:’Rojo’,
32:’Verde’,
33:’Amarillo’,
34:’Azul’,
35:’Morado’,
36:’Celeste’,
37:’Blanco’

17
 }
return diccionarioColorTexto.get(i)

def colorFondoSwitch(i):
diccionarioColorFondo={
40:’Negro’,
41:’Rojo’,
42:’Verde’,
43:’Amarillo’,
44:’Azul’,
45:’Morado’,
46:’Celeste’,
47:’Blanco’
}
return diccionarioColorFondo.get(i)

nombre = input(Ïngresa tu nombre: ”)

apellido = input (ı̈ngresa tu apellido: ”)
print(”selecciona el estilo: n[1]Negrita n[2]Debil n[3]Cursiva”
”n[4]Subrayado n[5]Inverso n[6]Oculto n[7]Tachado n[0]Ninguno”)
estilo = int(input(”>”))
nombreEstilo = estiloSwitch(estilo)
print(”Seleciona el color del texto: n[0]Negro n[1]Rojo n[2]Verde”
”n[3]Amarillo n[4]Azul n[5]Morado n[6]celeste n[7]Blanco”)
colorTexto = int(input(”>”))
if colorTexto <0 or colorTexto >7:
colorTexto = 0
colorTexto = colorTexto + 30
nombreColorTexto = colorTextoSwitch(colorTexto)
print(”Selecciona el color de fondo: n[0]Negro n[1]Rojo n[2]Verde”
”n[3]Amarillo n[4]Azul n[5]Morado n[6]celeste n[7]Blanco”)
colorFondo = int(input(”>”))
if colorFondo <0 or colorFondo >7:
colorFondo = 0
colorFondo = colorFondo + 40
nombreColorFondo = colorFondoSwitch(colorFondo)
print(chr(27)+”
[-str(estilo)+”;-str(colorTexto)+”;-str(colorFondo)+”m-nombre ++
apellido+ ’033[0;m’)
print(chr(27)+”[-str(estilo)+”;-str(colorTexto)+”;-str(colorFondo)+”m
estilo:-nombreEstilo+”, color de texto: - nombreColorTexto +”, color de
fondo: -
nombreColorFondo)
(*) la tabla de colores básicos se muestran en las funciones diccionarios, las dos
últimas lı́neas muestran la manera de imprimir a color, la primera lı́nea acota
el fondo solo a las palabras, nota que termina en: ’033[0;m’ Al contrario de la
segunda lı́nea que no termina con la cadena anterior y el fondo se extiende a lo
ancho de la pantalla.
g) Desarrolla un programa que permita califica 4 aspectos de una persona: interés,
puntualidad, conocimientos, comunicación, empatı́a; las calificaciones se dan en
letras: A, B, C, D y E (cada aspecto debe ser calificado), la nota final se calcula
siguiendo la siguiente tabla:

18
 A = 10 pts
B = 8 pts
C = 6 pts
D = 4 pts
E = 2 pts
El programa deberá mostrar la calificación por cada ı́tem, el puntaje general
obtenido y observación referida al puntaje:
40 – 50 pts excelente
30 - 39 pts bueno
20 – 29 pts regular
15 – 19 pts malo
Menos de 15 pts pésimo

def calificacion(i):
diccionarioCalificacion={
’A’: 10,
’B’: 8,
’C’: 6,
’D’: 4,
’E’: 2
}
return diccionarioCalificacion.get(i)

print(Çalififique interes: n[A] 10 pts n[B] 8 pts n[C] 6 pts n[D] 4 pts n[E] 2 pts”)
interes = input()
if len(interes) != 1:
interes = interes[0]
interes = interes.upper()
valorInteres = int(calificacion(interes))
print(Çalififique puntualidad: n[A] 10 pts n[B] 8 pts n[C] 6 pts n[D] 4 pts n[E]
2 pts”)
puntualidad = input()
if len(puntualidad) != 1:
puntualidad = puntualidad[0]
puntualidad = puntualidad.upper()
valorPuntualidad = int(calificacion(puntualidad))
print(Çalififique conocimientos: n[A] 10 pts n[B] 8 pts n[C] 6 pts n[D] 4 pts n[E]
2 pts”)
conocimientos = input()
if len(conocimientos) != 1:
conocimientos = conocimientos[0]
conocimientos = conocimientos.upper()
valorConocimientos = int(calificacion(conocimientos))
print(Çalififique comunicación: n[A] 10 pts n[B] 8 pts n[C] 6 pts n[D] 4 pts n[E]
2 pts”)
comunicacion = input()
if len(comunicacion) != 1:
comunicacion = comunicacion[0]
comunicacion = comunicacion.upper()
valorComunicacion = int(calificacion(comunicacion))
print(Çalififique empatia: n[A] 10 pts n[B] 8 pts n[C] 6 pts n[D] 4 pts n[E] 2
pts”)

19
 empatia = input()
if len(empatia) != 1:
empatia = empatia[0]
empatia = empatia.upper()
valorEmpatia = int(calificacion(empatia))
calificaciongeneral = valorInteres + valorPuntualidad + valorConocimientos +
valorComunicacion + valorEmpatia
if calificaciongeneral >= 40 and calificaciongeneral<= 50:
observacion = .exelente”
elif calificaciongeneral <40 and calificaciongeneral >= 30:
observacion = ”bueno”
elif calificaciongeneral <30 and calificaciongeneral >= 20:
observacion = regular”
elif calificaciongeneral <20 and calificaciongeneral >= 15:
observacion = ”malo”
else:
observacion = ”pesimo”
print(”CALIFICACION:”)
print(”INTERES: -interes+- - str(valorInteres))
print(”PUNTUALIDAD: -puntualidad+- - str(valorPuntualidad))
print(”CONOCIMIENTOS: -conocimientos+- - str(valorConocimientos))
print(”COMUNICACION: -comunicacion+- - str(valorComunicacion))
print(”EMPATIA: -empatia+- - str(valorEmpatia))
print(”TOTAL PUNTAJE: -str(calificaciongeneral)+”: -observacion)

h) Desarrollar un programa que determine si un numero de tres cifras [100,999] es

capicúa o no lo es.

numero = int(input(”ingrese un numero entre 100 y 999: ”))

if numero <100 or numero >999:
print(”no es un valor adecuado”)
else:
unidad = numero % 10
centena = int(numero / 100)
print(”el numero: - str(numero), end=)
if unidad == centena:
print(”es capicua”)
else:
print(”no es capicua”)

2. Estructuras repetitivas.
Se entiende como una estructura repetitiva a aquella que permite repetir un conjunto
de actividades de manera controlada, a esto se le denomina bucle, y la repetición
recibe el nombre de iteración, por ejemplo, si se desea mostrar la lista de números
del 1 al 50 y su respetiva suma, podrı́a escribirse el siguiente algoritmo:

ALGORITMO secuencia
Variables: suma
INICIO:
suma = 1+2+3+. . . 50

20
 Imprimir “1,2,3,. . . 50”
Imprimir suma
FIN

O quizás usar la fórmula matemática:

ALGORITMO secuencia
Variables: suma
INICIO:
suma = 50*51/2
Imprimir “1,2,3,. . . 50”
Imprimir suma
FIN

En todo caso, resulta tedioso mostrar la lista de números, es escribir desde el 1

hasta el numero 50, de manera literal, imaginar que se desea escribir hasta el 5000
o aun mucho más, por ello es mejor emplear una estructura repetitiva y que sea el
computador el que haga el trabajo.

En Python existen dos tipos de bucles básicamente, el bucle PARA (for) y el bucle
MIENTRAS (while), a continuación se desarrollará dos algoritmos que resuelven el
problema del ejemplo, con cada tipo de bucle.
ALGORITMO secuencia PARA
Variables: suma, contador
INICIO:
suma ← 0
PARA contador ← 1 hasta 50
suma ← suma + contador
imprimir contador
fin PARA
imprimir suma
FIN

Observa el algoritmo:
1. La variable suma empieza en 0 (la variable se debe iniciar en el valor neutro de
la operación a realizar, en este caso adición)
2. Al inicio del bucle la variable contador inicia en 1 y la condición es que la variable
contador avance en 1 en cada vuelta (iteración) del bucle hasta llegar al número 50
3. En cada iteración la variable suma va a ser igual al valor antiguo de suma mas el
valor actual del contador
4. En cada iteración se imprime el valor del contador
5. Al terminar las iteraciones del bucle la variable suma ha acumulado todos los
valores entre [1,50], por tanto, se imprime.

Observa el diagrama de flujo:

El código en Python es:

suma = 0

21
 for contador in range(1,51):
suma = suma + contador
print (str(contador)+,end=)
print(”nLa suma es: -str(suma))

for contador in range(1,51) marca el rango de conteo corresponde a un par de núme-

ros (inicio y final), donde el final es de intervalo abierto, es decir, contador correrá
desde el 1 hasta el 50, se puede probar la validez de este programa implementando
los algoritmos anteriores.
El problema descrito como ejemplo, también puede ser resuelto empleando la otra
estructura repetitiva (bucle while), a diferencia del bucle for, donde el contador se
incrementaba de manera implı́cita, en el bucle while es necesario iniciarlo en un valor
e incrementarlo de manera explicita dentro del bucle, en cada iteración la estructura
while (mientras) evaluará si el contador cumple o no con la condición, de ser cierta
efectuará las operaciones que están dentro del bucle, de no cumplir con la condición,
terminará la serie de repeticiones.

ALGORITMO secuencia MIENTRAS

Variables: suma, contador
INICIO:
suma ← 0
contador ← 1
MIENTRAS contador <= 50
suma ← suma + contador
imprimir contador
contador ← contador + 1
fin MIENTRAS
imprimir suma
FIN

Como se observa la diferencia entre esta estructura y la anterior, es la inicialización

del contador antes del bucle (porque while evalúa la condición desde el primer in-
greso), y el incremento en 1 que se da sobre esta variable dentro de la estructura
repetitiva.
Obsérvese el diagrama de flujo del algoritmo en cuestión, esta vez usando la estruc-
tura
mientras:

La implementación en Python es la siguiente:

suma = 0
contador = 0
while contador ¡= 50:
suma += contador
print(”0:d ”.format(contador),end=)
contador += 1
print(”nLa suma es: -str(suma))

sobre la impresión, es una manera de formatear valores, se puede hacer la prueba

usando la siguiente lı́nea.

22
 print(”decimal:0:d, binario:0:b, hexagesimal:0:x, octal 0:o”.format(64))

A esto se le conoce como mascara de formateo, lo mismo se usa para los números
reales:
print(real con 3 decimales::,.3f”.format(3))

A continuación, se muestra un programa que imprime la lista de códigos ASCII de

manera secuencial, para esto se ha empleado el bucle for:
for cont in range(1,256):
ascii = chr(cont)
print(ascii+- -str(cont))

este programa puede mejorarse (en la impresión) empleando un bucle ANIDADO, un

bucle anidado es aquel que esta dentro de otro bucle (de manera similar a las estruc-
turas condicionales anidadas), el bucle interno tiene mayor cantidad de iteraciones
que el bucle del exterior.

contador = 1
while contador ¡256:
for lugar in range(1,11):
ascii = chr(contador)

print(str(contador)+- [ -ascii+”]”,end=)
contador += 1
print(”n”)

el bucle for esta anidado en el bucle while, una vez dentro del while, se ejecutará 10
veces el bucle for (esto permite imprimir en una lı́nea los 10 primeros códigos ASCII)
luego volverá al bucle while, quien al evaluar la variable contador en el condición
encontrará si es TRUE (verdad, 1 ó se cumple) o FALSE (falso, 0 o no se cumple)
de ser TRUE, ingresará nuevamente a la estructura y otra vez se ejecutará el bucle
for permitiendo imprimir 10 valores ASCII siguientes, pues nota que el contador se
incrementa dentro de este segundo bucle.

Ejemplos propuestos: la siguiente lista de problemas resueltos tiene por objetivo

que se comprenda el código, generes el algoritmo (describas el algoritmo: ingenierı́a
inversa) y mejores el programa (usar otras maneras de resolver el problema)
a) Desarrolla un programa que genere las notas musicales de un piano, usando
las teclas superiores de tu teclado. Para elaborar el programa considera que las
notas musicales tienen frecuencias, a continuación, se muestran las notas y sus
frecuencias:

Emplear la escala 4, Python tiene un módulo llamado winsound con muchas ruti-
nas, una de ella se llama Beep, se emplea ası́: winsound.Beep(frecuencia,duracion)
Para el reconocimiento de las teclas del computador se instalará un módulo
llamado pynput, este se instalará (en Windows) usando el comando pip desde
el CMD En la lı́nea de comandos debe estar esto:
Luego escribir:
pip install pynput
pulsar “enter” y se instalará el módulo, ahora ya se podrá llamar desde el código
Python que se desarrollará.

from pynput import keyboard as kb

23
import winsound
import sys

ritmo = 180
def do4(tipo):
winsound.Beep(262,tipo*ritmo)
def do4s(tipo):
winsound.Beep(277,tipo*ritmo)
def re4(tipo):
winsound.Beep(294,tipo*ritmo)
def re4s(tipo):
winsound.Beep(311,tipo*ritmo)
def mi4(tipo):
winsound.Beep(330,tipo*ritmo)
def fa4(tipo):
winsound.Beep(349,tipo*ritmo)
def fa4s(tipo):
winsound.Beep(370,tipo*ritmo)
def sol4(tipo):
winsound.Beep(392,tipo*ritmo)
def sol4s(tipo):
winsound.Beep(415,tipo*ritmo)
def la4(tipo):
winsound.Beep(440,tipo*ritmo)
def la4s(tipo):
winsound.Beep(466,tipo*ritmo)
def si4(tipo):
winsound.Beep(494,tipo*ritmo)
def do5(tipo):
winsound.Beep(523,tipo*ritmo)
def do5s(tipo):
winsound.Beep(554,tipo*ritmo)
def re5(tipo):
winsound.Beep(584,tipo*ritmo)
def re5s(tipo):
winsound.Beep(622,tipo*ritmo)
def mi5(tipo):
winsound.Beep(659,tipo*ritmo)

def pulsa(tecla):
if tecla == kb.KeyCode.from char(’w’):
re4(2)
print(rRE”)
if tecla == kb.KeyCode.from char(’e’):
mi4(2)
print(rMI”)
if tecla == kb.KeyCode.from char(’r’):
fa4(2)
print(rFA”)
if tecla == kb.KeyCode.from char(’t’):
sol4(2)

24
 print(rSOL”)
if tecla == kb.KeyCode.from char(’y’):
la4(2)
print(rLA”)
if tecla == kb.KeyCode.from char(’u’):
si4(2)
print(rSI”)
if tecla == kb.KeyCode.from char(’i’):
do5(2)
print(rDO”)
if tecla == kb.KeyCode.from char(’o’):
re5(2)
print(rRE+”)
if tecla == kb.KeyCode.from char(’p’):
mi5(2)
print(rMI+”)
if tecla == kb.KeyCode.from char(’2’):
do4s(2)
print(rDO s”)
if tecla == kb.KeyCode.from char(’3’):
re4s(2)
print(rRE s”)
if tecla == kb.KeyCode.from char(’5’):
fa4s(2)
print(rFA s”)
if tecla == kb.KeyCode.from char(’6’):
sol4s(2)
print(rSOL s”)
if tecla == kb.KeyCode.from char(’7’):
la4s(2)
print(rLA s”)
if tecla == kb.KeyCode.from char(’9’):
do5s(2)
print(rDO+ s”)
if tecla == kb.KeyCode.from char(’0’):
re5s(2)
print(rRE+ s”)
if tecla == kb.KeyCode.from char(’x’):
return False

Aunque no es una estructura repetitiva, esta porción de código se ejecuta como

tal mientras pulsa retorne un valor True,

with kb.Listener(pulsa) as escuchador:

escuchador.join()

Cuando se pulsa la tecla ‘x’ la función pulsa retorna False y termina la aplicación

25
b) Cuando se pulsa la tecla ‘x’ la función pulsa retorna False y termina la aplicación.
limite = int(input(Çuantos valores ser mostrarán: ”))
suma = 0
anterior = 0
actual = 1
for i in range(1,limite+1):
suma += actual
print(str(actual),end=)
if i == limite:
print(- ”,end=)
else:
print(- ”,end=)
actual = actual + anterior
anterior = actual - anterior
print(str(suma))

c) Genera un algoritmo que muestre una lista de N valores enteros, los valores pares
se mostrarán en azul y los valores impares en rojo, el algoritmo debe calcular la
suma total, la suma de valores pares, la suma de valores impares, la cantidad
de valores pares y la cantidad de valores impares.

limite = int(input(Çuantos valores ser mostrarán: ”))

sumaTotal = 0
sumaImpares = 0
sumaPares = 0
cantidadPares = 0
cantidadImpares = 0
for i in range(1,limite+1):
sumaTotal += i
if i % 2 == 0:
sumaPares += i
cantidadPares += 1
print(chr(27)+”[3;34m-str(i),end=)
else:
sumaImpares += i
cantidadImpares += 1
print(chr(27)+”[3;31m-str(i),end=)
if i == limite:
print(- ”,end=)
else:
print(- ”,end=)
print(str(sumaTotal))
print(”Suma de numeros pares: - str(sumaPares))
print(”Suma de numeros impares: - str(sumaImpares))
print(Çantidad de valores pares: - str(cantidadPares))
print(Çantidad de valores impares: - str(cantidadImpares))

d ) usando un bucle anidado, generar una matriz cuadrada identidad de NxN

N = int(input(ı̈ngrese la dimension de la matriz: ”))

for i in range(0,N):

26
 for j in range(0,N):
if i == j:
print(”1 ”,end=)
else:
print(”0 ”,end=)
print(”n”)

e) desarrolla un programa que permita únicamente el ingreso de un numero impar

en el rango de [1,9], luego el programa mostrará una matriz con su diagonal
principal en 1 (matriz identidad), ası́ como su diagonal secundaria, la matriz
será de NxN dimensiones.

N = int(input(ı̈ngrese la dimension de la matriz: ”))

while N ¡1 or N ¿9 or N
N = int(input(ı̈ngrese la dimension de la matriz: ”))
limiteVar = N -1
for i in range(0,N):
for j in range(0,N):
if i == j or j == limiteVar:
print(”1 ”,end=)
else:
print(”0 ”,end=)
print(”n”)
limiteVar -= 1

(*) el bucle while, se emplea aquı́ como un bucle de candado, o bucle de bloqueo,
decir:

N = int(input(ı̈ngrese la dimension de la matriz: ”))

while N ¡1 or N ¿9 or N
N = int(input(ı̈ngrese la dimension de la matriz: ”))

Se lee un primer valor N, este valor se compara en el bucle, si cumple con la

condición, ósea que si N está fuera del rango pedido (entre 1 y 9) o si N es par,
el bucle se repetirá y pedirá un valor para N, al ingresar un nuevo valor, el valor
antiguo se descarta y este nuevo valor es comparado en la condición del bucle.

f ) Desarrolla una rutina que calcule el factorial de un numero ingresado

limite = int(input(”Factorial de: ”))

factorial = 1
for i in range(1,limite+1):
factorial *= i
print(.El factorial de: -str(limite)+.es: -str(factorial))

g) Calcula la siguiente serie con un programa, N es ingresado por teclado:

import math
limite = int(input(çantidad de sumandos: ”))
suma = 0
for i in range(1,limite+1):
factorial = 1
for j in range(1,i+1):

27
 factorial *= j
suma += (i + math.sqrt(i+2)) / math.pi * factorial * math.sin(i+1)
print(str(i)+- sqrt(-str(i+2)+”) / PI(-str(factorial)+”)(sen -str(i+1)+”)”,end=
)
if i ¡limite:
print(- ”,end=)
else:
print(- ”,end=)
print(str(suma))

(*)el módulo math permite el uso de muchas funciones y constantes matemáti-

cas, tales como:

math.pi
math.sin(x)

Aquı́ unos ejemplos:

import math
def round(valor):
return(math.floor(valor + 0.5))
print(REDONDEO”)
print(”:.3f”.format(math.ceil(5.5))) #redondeo entero superior
print(”:.3f”.format(math.floor(5.5))) #redondeo entero inferior
print(”:.3f”.format(round(5.5))) #función redondeo con 0.5
print(”TROGONOMETRICAS”)
print(”:.3f”.format(math.sin(2))) #seno
print(”:.3f”.format(math.cos(2))) #coseno
print(”:.3f”.format(math.tan(2))) #tangente
print(”:.3f”.format(math.sinh(2))) #seno hiperbolico
print(”:.3f”.format(math.cosh(2))) #coseno hiperbolico
print(”:.3f”.format(math.tanh(2))) #tangente hiperbolica
print(”:.3f”.format(math.asin(-0.5))) #arcoseno
print(”:.3f”.format(math.acos(-0.5))) #arcocoseno
print(”:.3f”.format(math.atan(-0.5))) #arcotangente
print(”:.3f”.format(math.asinh(-1))) #arcoseno hiperbolico
print(”:.3f”.format(math.acosh(3.2))) #arcocoseno hiperbolico
print(”:.3f”.format(math.atanh(0.5))) #arcotangente hiperbolica
print(.OPERACIONES”)
print(”:.3f”.format(math.factorial(5))) #factorial
print(”:.3f”.format(math.fabs(-8))) #valor absoluto
print(”:.3f”.format(math.fmod(4,3))) #modulo/residuo
print(”:.3f”.format(math.pow(4,2))) #potencia base , exponente
print(”:.3f”.format(math.sqrt(3))) #raiz cuadrada
print(”:.3f”.format(math.exp(4))) #e a la 4
print(”:.3f”.format(math.log(4))) #log 4 base e
print(”:.3f”.format(math.log(4,3))) #log 4 / log 3
print(ÇONSTANTES”)
print(”:.3f”.format(math.pi))
print(”:.3f”.format(math.e))
print(”:.3f”.format(math.tau))

28