CAPÍTULO III

Estructuras de Control

1. Estructuras condicionales
a) Estructura if
b) Estructura if…else
c) Estructuras anidadas
d) Estructura elif
e) switch…case en python, diccionarios en Python
f) ejemplos
2. Estructuras repetitivas
a) Bucle for
b) Bucle while
c) Bucles anidados
d) ejemplos
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ó anteriormente,
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 numero de DNI:”
Leer dni
Fin_si
Imprimir “persona: ” + nombre
Imprimir “edad: ” + edad
Si dni <> NULL 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:"))
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 instrucció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

tabulaciones); 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)

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 escenarios 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 comportamiento
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: ”
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("2")
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

Se llama operación de multiplicación lógica a and y suma lógica a or, por consiguiente,
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("cero")
else:
if num == 1:
print("uno")
else:
if num == 2:
print ("dos")
else:
if num == 3:
print("tres")
else:
if num == 4:
print("cuatro")
else:
if num == 5:
 print("cinco")
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")

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("2")
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, observa el
siguiente código:

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")

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á, diccionarioNumeros =
{…,…,…} 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("ingrese 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 al
concepto manejado en las matemáticas, pues una función evalúa u opera un valor y
devuelve un resultado.

numero = float(input("ingrese 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 (entero),
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={
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
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("Ingrese el número de mes: "))

anio = int(input("Ingrese 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)
print("Fecha: " + str(mes)+ " de " + nombreMes + " de " + str(anio) + " ,cantidad 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)

1. 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,
multiplicación, división y modulo(residuo).

numero1 = float(input("ingrese el primer valor: "))

numero2 = float(input("ingrese el segundo valor: "))
operacion = input("ingrese la operacion:\n"
"[+]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) + " % " + str(numero2) + " = " + str(numero1 % numero2))
else:
print("operacion no valida")

2. 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("ingrese el primer valor: "))

numero2 = float(input("ingrese 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")

3. 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("ingrese un caracter:")

if len(caracter)>1:
print("se considerará solo el primer caracter de la cadena")
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(" y su codigo ASCII es: ",end="")
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.

4. Desarrolla un programa que permita el ingreso de tres valores enteros, el programa

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:
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)

5. 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:
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)

6. 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'
}
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("Ingresa tu nombre: ")

apellido = input ("ingresa 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.

7. 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:
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("Calififique 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("Calififique 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("Calififique 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("Calififique 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("Calififique empatia:\n[A] 10 pts\n[B] 8 pts\n[C] 6 pts\n[D] 4 pts\n[E] 2 pts")
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)

8. 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
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
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úmeros

(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 seri 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 ingreso), 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 estructura
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:

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
estructuras 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+" ]\t",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)

1. 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:
 OCTAVAS
NOTAS
0 1 2 3 4 5 6 7 8
DO 16.35 32.7 65.41 130.81 261.63 523.25 1046.5 2093 4186.01
DO# 17.32 34.65 69.3 138.59 277.18 554.36 1108.73 2217.46 4434.92
RE 18.35 36.71 73.42 146.83 293.67 587.33 1174.66 2349.32 4698.64
RE# 19.45 38.89 77.78 155.56 311.13 622.25 1244.51 2489.02 4978.03
MI 20.6 41.2 82.41 164.81 329.63 659.25 1318.51 2637.02 5274.04
FA 21.83 43.65 87.31 174.61 349.23 698.46 1396.91 2793.83 5587.65
FA# 23.12 46.25 92.5 185 369.99 738.99 1479.98 2959.96 5919.91
SOL 24.5 49 98 196 392 783.99 1567.98 3135.96 6271.93
SOL# 25.96 51.91 103.83 207.65 415.3 830.61 1661.22 3322.44 6644.88
LA 27.5 55 110 220 440 880 1760 3520 7040
LA# 29.14 58.27 116.54 233.08 466.16 932.33 1864.66 3729.31 7458.62
SI 38.87 63.74 123.47 246.94 493.88 987.77 1975.53 3951.07 7902.13

Emplear la escala 4, Python tiene un módulo llamado winsound con muchas rutinas,
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:
C:\Users\pc\AppData\Local\Programs\Python\Python39\Scripts>
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

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)
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

2. Calcular la suma y mostrar la lista de N valores de la serie de Fibonacci.

limite = int(input("Cuantos 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))

3. 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("Cuantos 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("Cantidad de valores pares: " + str(cantidadPares))
print("Cantidad de valores impares: " + str(cantidadImpares))
4. usando un bucle anidado, generar una matriz cuadrada identidad de NxN

N = int(input("ingrese la dimension de la matriz: "))

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

5. 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("ingrese la dimension de la matriz: "))

while N < 1 or N > 9 or N % 2 == 0:
N = int(input("ingrese 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("ingrese la dimension de la matriz: "))
while N < 1 or N > 9 or N % 2 == 0:
N = int(input("ingrese 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.

6. 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))

7. Calcula la siguiente serie con un programa, N es ingresado por teclado:

1 + √3 2 + √4 3 + √5 𝑁 + √𝑁 + 2
𝐸= 𝑠𝑒𝑛(2) + 𝑠𝑒𝑛(3) + 𝑠𝑒𝑛(4) + ⋯ 𝑠𝑒𝑛(𝑁 + 1)
𝜋(1!) 𝜋(2!) 𝜋(3!) 𝜋(𝑁!)

import math
limite = int(input("cantidad de sumandos: "))
suma = 0
for i in range(1,limite+1):
factorial = 1
for j in range(1,i+1):
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áticas,

tales como:

math.pi
math.sin(x)

para mayor información se puede consultar:

https://docs.python.org/3/library/math.html
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("CONSTANTES")
print("{:.3f}".format(math.pi))
print("{:.3f}".format(math.e))
print("{:.3f}".format(math.tau))