Conceptos e Instrucciones Básicas

Lenguaje de Programación Python

Intérprete de Python en línea: https://replit.com/languages/python3
¿PARA QUÉ SE UTILIZA EL COMPUTADOR?

Una computadora personal suele estar equipada para cumplir

tareas comunes de la informática moderna, es decir, permite
navegar por Internet, estudiar, escribir textos y realizar otros
trabajos de oficina o educativos, como editar textos y bases de
datos, además de actividades de ocio, como escuchar música,
ver videos, ...

¿PARA QUÉ O POR QUÉ SE CREAN PROGRAMAS?

• Automatizar

¿CÓMO SE CREA UN PROGRAMA PARA CORRER EN EL

COMPUTADOR?

1. Enunciado de un problema

2. Entender el problema

• [Para mí] Elaborar la Tabla de Datos de

Prueba.
• [Para el Lenguaje de Programación]
Elaborar el algoritmo.
 3. [Lo entiendo YO y el Lenguaje de
Programación] Elaborar el CÓDIGO FUENTE.
Necesito un Editor de Texto.

4. TRADUCTOR. Convierte el Código Fuente en

CÓDIGO EJECUTABLE. El traductor es el
lenguaje de programación.

5. PROBAR el código ejecutable. Se utiliza la

Tabla de Datos de Prueba.

6. PONER EN MARCHA.

¿CUÁLES SON LAS INSTRUCCIONES BÁSICAS DE UN

PROGRAMA?

1. Instrucciones de entrada
Nv = int(input (“Digite su edad”))
2. Instrucciones de salida
print (nv1, “mensaje descriptivo”, nv2,
constante, etc)
3. Instrucciones de asignación
 Nv = expresión
4. Instrucciones condicionales NO REPETITIVA
(bifurque)
if / if else / if elif else
5. Instrucciones condicionales REPETITIVA
(bucles o ciclos)
while / for

CONCLUSIÓN: Eso es lo que vamos a encontrar

en cualquier lenguaje de programación. Es lo
mínimo, lo básico.
Estructura Básica de Un Programa (Código Fuente) en Python

Un programa completo (código fuente) está compuesto de

instrucciones, funciones, librerías y datos (simples y estructurados),
archivos y un grupo de palabras reservadas.

• Palabras reservadas: Tienen un significado para el lenguaje de

programación. El programador no las puede utilizar para darle
nombre a variables, a funciones y a librerías.
• Instrucciones: También llamadas sentencias. Son acciones básicas
que se pueden implementar en un lenguaje de programación.
• Función: Es un bloque (conjunto) de instrucciones que realizan una
tarea determinada. La idea es organizar el programa dividiendo en
programitas más pequeños llamados funciones.
• Librería: Es un archivo compuesto por un conjunto de funciones.
Existen librerías predefinidas (forman parte del lenguaje de
programación, vienen con el lenguaje) y definidas por el usuario (las
elabora el usuario programador).
• Archivos: se utilizan para guardar los datos del programa u otros
programas.
# ESTRUCTURA 1

# Comienzo o inicio del programa en Python

Importar las librerías (from math import sqrt)

MAIN BODY
#fin del programa en Python – Aquí termina

MAIN BODY: Es el cuerpo principal (bloque de instrucciones) del programa. Por aquí es
que empieza a ejecutarse un programa de computador.

# ESTRUCTURA 2

Importar las librerías (from math import sqrt)

def nombredelafunción():

MAIN BODY
nombredelafunción()

# ESTRUCTURA 3 (Estructura completa)

...

Caracter: es una representación simbólica. La tabla ASCII tiene 256

caracteres, numerados del 0 (cero) al 255 (doscientos cincuenta y cinco).

Tipos de caracteres:
• Letras: a, b, c, …, z; A, B, C,…, Z
• Dígitos: 0, 1, 2,…, 8, 9
• Especiales: ¿+*#”!{]}[-:/_, etc
Ejemplo: este número tiene 3 caracteres: 453

Variable: Es un elemento que se utiliza para guardar datos. Un programa

maneja varios datos, por lo tanto, utiliza una variable para cada dato. En
un comienzo manejaremos variables simples.

Una variable está compuesta por:

 • Un nombre/identificador. Compuesto por un conjunto de
caracteres. Hay reglas para darle nombre a una variable;
ejemplos: el primer carácter debe ser una letra; debe tener
por lo menos una letra; no se aceptan espacios en blanco;
solo se aceptan letras, dígitos y signo de subrayado; las
minúsculas son diferentes a las mayúsculas; hay
caracteres válidos y no válidos; etc.
• Un dato/valor. Tiene asociado un tipo. Lo que vamos a
procesar en el programa.
¿Cómo asignar datos a una variable?

• Desde el teclado: instrucciones: en Python es input; en C++

es cin >>; en JavaScript es prompt, etc.
• En una instrucción de asignación: x = 3; edad = 31; etc.
• Desde un archivo: el ejemplo se les debe para la próxima.
Ejemplos de uso de variable simple:

• Variables enteras: w = 20; w = 50; x = 5; numero_de_hijos = 3;

• Variables reales: promedio = 3.7; sn = 10000.4
• Variables string: nombre_ ciudad = “Cartagena”;
nombre_estudiante = “Luis Carlos”; nombre_ciudad =
“Moñitos”; x=”5”; x=”x”
• Variables booleanas: condicion=true; condicion=false

Tipos de dato: numérico (entero o real), string (alfanumérico o cadena de

caracteres), booleano, etc.

• Datos tipo string: Son mensajes que deben estar encerrados entre
comillas y utilizan cualquier tipo de caracter. En Python toman el
nombre de str.
• Datos tipo entero: Son valores que se pueden utilizar en fórmulas
matemáticas. En Python toman el nombre de int.
 • Datos tipo real: Son valores que se pueden utilizar en fórmulas
matemáticas. En Python toman el nombre de float.
• Datos tipo booleano: son valores true o false. En Python toman el
nombre de bool.
Operadores: Se utilizan para escribir expresiones.

Tipos de Operadores:

• Operadores matemáticos/aritméticos: suma (+), resta (-),

multiplicación (*) y división (/). Se utilizan escribir las fórmulas
matemáticas. para z = x + y
• Operadores relacionales: <, <=, ==, >, >=, <>. Se utilizan para
escribir las condiciones. x > y; t == 4
• Operadores lógicos: Se utilizan para escribir las condiciones. or,
and, not

Expresiones. Una expresión es una combinación de variables y/o datos,

unidos con operadores.

Tipos de expresiones:

• Expresiones aritméticas. Utilizan operadores aritméticos

• Expresiones relacionales. Utilizan operadores relacionales
• Expresiones lógicas. Utilizan operadores lógicos
Tarea: Buscar en Google o en cualquier otra fuente bibliográfica,
ejemplos de cada concepto vistos en la clase de hoy.

Captura de datos desde el teclado en Python

input (“mensaje”)
• Lo que se captura del teclado es del tipo string
 • string también toma el nombre de alfanumérico o
cadena de caracteres
• Los datos tipos string no se pueden utilizar en las
fórmulas matemáticas/aritméticas
Uso de fórmulas matemáticas

• En una fórmula matemática intervienen datos tipo

numérico (entero y real)

Instrucciones/Sentencias Básicas de todo Lenguaje de

Programación:

1) Instrucción de lectura/captura
2) Instrucción de escritura/impresión
3) Instrucción de asignación
4) Instrucción condicional no repetitiva
5) Instrucción condicional repetitiva
Instrucciones/Sentencias Básicas en Python:

1) Instrucción de lectura (input, casi siempre se

acompaña con una conversión de datos)
2) Instrucción de escritura/impresión (print)
3) Instrucción de asignación (variable = expresión)
4) Instrucción condicional no repetitiva (if [elif] else)
5) Instrucción condicional repetitiva (for y el while)

La instrucción input:

Sintaxis: nomvariable = input(“mensaje”)

• input captura un dato del teclado y lo guarda en la

variable nomvariable
• el dato capturado es de tipo string/cadena
 • si el dato capturado del teclado lo vamos a utilizar en
una expresión aritmética, entonces se debe convertir a
entero o a real
• la función int(variable), convierte variable en un número
entero
• la función float(variable), convierte variable en un
número real.
Ejemplo No. 1: Elabore un programa en Python que nos imprima la
suma de dos valores leídos desde el teclado.

Solución No. 1

x=input("Digite el valor de X:")

y=input("Digite el valor en y:")
s=x+y
print("La suma es: ", s)

Solución No. 2

x=input("Digite el valor de X:")

x1=int(x)
y=input("Digite el valor en y:")
y1=int(y)
s=x1+y1
print("La suma es: ", s)

La instrucción print:

Sintaxis: print(dato1, dato2, dato3,…, datoN)

• print imprime en la pantalla uno o varios datos (dato1,

dato2, dato3,…, datoN); los datos se separan por coma.
• Los datos impresos pueden ser de tipos distintos. Tipos
de datos: int, float, string, bool.
Ejemplo No. 1: imprima en pantalla el mensaje “Hola mundo!”.
 Solución

print ("Hola mundo!")

Ejemplo No. 2: Elabore un programa en Python que nos imprima la

suma de dos valores leídos desde el teclado.

Solución No. 1

x=input("Digite el valor de X:")

x1=int(x)
y=input("Digite el valor en y:")
y1=int(y)
s=y1+x1
print("La suma es: ", s)
print(f'Sum of {x1} plus {y1} is {x1+y1}')

Solución No. 2

x=input("Digite el valor de X:")

x1=float(x)
y=input("Digite el valor en y:")
y1=int(y)
s=y1+x1
print("La suma es: ", s)

Solución No. 3

x=input("Digite el valor de X:")

x1=float(x)
y=input("Digite el valor en y:")
y1=int(y)
s=y1+x1
print("La suma es: ")
print(s)
#Ejemplo int elegante
# Online Python - IDE, Editor, Compiler, Interpreter
def sum(a, b):
return (a + b)
a = int(input('Enter 1st number: '))
b = int(input('Enter 2nd number: '))
print(f'Sum of {a} and {b} is {sum(a, b)}')

Tarea: Elabore un programa en python para convertir temperaturas en grados

Fahrenheit a grados Celsius.
La Instrucciones de Asignación:

Sintaxis: NomVariable = Expresión

• Esta instrucción asigna en NomVariable el resultado de

Expresión.
• NomVariable es el nombre de una variable.
• Expresión es una expresión aritmética o relacional o
lógica o un valor o una variable.
• El resultado o el valor que está al lado derecho del
signo igual define el tipo de NomVariable.
• Las variables que aparecen en Expresión, deben estar
previamente definidas, es decir, deben tener asociado
algún valor. O lo que es lo mismo, toda variable a la
derecha del signo igual (=) debe tener asociado algún
valor.
• Las variables se pueden definir de dos (2) formas, a
saber: 1) en una instrucción de asignación, cuando
aparece a la izquierda del signo igual; 2) capturando un
dato del teclado, es decir, con una instrucción input.

Ejemplos de instrucciones de asignación:

1) S = “Moñitos – Córdoba”
2) R1 = a + b * c
3) R2 = ((a + c – b) * b) / (c + d )
4) X = 5
5) Z = w
6) Y = x <= 20
7) B = false or true
8) x = false
9) y = true
10) B = x or y
11) C = false and true
Ejercicios: Evalué las siguientes expresiones aritméticas, lógicas y
relacionales. Describa paso a paso como se llega al resultado final
en cada ejercicio.

1) (45 <= 7) OR (NOT (5>=7))

2) 2+8-1 mod 1
3) 3*2^5 mod 1
4) 7 mod (5 mod 3)
5) 7 mod 5 mod 3
6) NOT ((5 / 2 * 3 – 1) = 4 div 2 mod 2 OR (10 < = 3 + 3 - 2) AND (3 /
4) ^2 * (2 + 10 mod 3))
7) (3*2^5 mod 1 + 8*(3-5) < (2+8-1 mod 1)
8) A es verdadero; A OR (3+5*8) < 3 AND ((-6/3 div 4)*2 < 2)
9) B = -12; (-B*2 <> 8*3 mod 4) AND (“A”> “B”)

Resuelva el ejercicio de las siguientes maneras: 1) manualmente;

2) elabore un programa en Python que nos muestre las soluciones
de cada una de las expresiones.

Ejemplos:

5 mod 2 = 1 ; residuo (mod, carry: lo que me sobra) = dividendo -

cociente * divisor = 5 – 2*2 = 1

5 / 2 = 2.5
5 div 2 = 2

21 mod 6 = 21 – 6*3 = 3
21 mod 4 = 21 – 4*5 = 1
50 mod 30 = 20
10 mod 2 = 0
3 mod 9 = 3 – 9*0 = 3
5 mod 1000 = 5
-4 mod 1 = 0
2 mod 2 = 0
X mod 1 = 0
 Ejemplo: Si a = 9; b =2; c =5; d = 3

Expresión Aritmética
a+b*c
(a+b)*c
((a + c – b) * b) / (c + d )
(c + d) ^ b

Solución Expresión Aritmética

a+b*c
(a+b)*c
((a + c – b) * b) / (c + d )
(c + d) ^ b
a+b*c = 9+2*5 = 9+10 = 19
(a+b) * c = (9+2)*5 = 11*5 = 55
((a+c-b)*b)/(c+d) = ((9+5-2)*2)/(5+3) = (12*2)/8 = 24/8 = 3
(c+d)^b = (5+3)^2 = 8^2 = 64

Ejemplo:
S = "Moñitos – Córdoba"
print ("S=",S)
a=9
b=2
c=5
d=3
R1 = a + b * c
print ("R1=", R1)
R2 = ((a + c - b) * b) / (c + d )
print ("R2==>", R2)
X = int(input("Digite X: "))
print ("X=", X)
w=100
Z=w
print ("w=", w, ";", "Z=", Z)
 Los Conceptos Matemáticos, Los Operadores y las Funciones Predefinidas

Potencias de N:
Y = x^2 =x*x=x**2 // Python
Y = x^3 =x*x*x =x**3 // Python
Y = x^N = x**N // Python
Y = pow(x, N) // Python (pow() es una función de la librería math)
Y = pow(base, exponente) // Python (pow() es una función de la librería math)

Y = x*x // C++ (no existe x^2 ni x**2)

Y = x^3 = x*x*x =x**3 // C++ (no existe x^3 ni x**3)
Y = x^N = x**N // C++ (no existe)
Y = pow(x, N) // C++ (pow() es una función de la librería math.h)
Y = pow(base, exponente) // C++ (pow() es una función de la librería math.h)
RaizN(x) = Y = en JavaScript?

Raíces enésimas:
Raizcuadrada(x): Y= x^0.5 = x^(1/2) = x**0.5 // Python
Raizcuadrada(x): Y = pow(x, 0.5) // Python (pow() es una función de la librería math)
Raizcuadrada(x): Y=sqrt(x); // Python (sqrt() es una función de la librería math)
RaizN(x) = x^(1/N) // Python
RaizN(x) = Y = pow(x, (1/N)) // Python (pow() es una función de la librería math)
RaizN(x) = Y = en JavaScript??

Raizcuadrada(x): Y= x^0.5 = x^(1/2) = x**0.5 // C++ (no existe)

Raizcuadrada(x): Y = pow(x, 0.5) // C++ (pow() es una función de la librería math.h)
Raizcuadrada(x): Y=sqrt(x); // C++ (sqrt() es una función de la librería math.h)
RaizN(x) = x^(1/N) // C++ (no existe)
RaizN(x) = Y = pow(x, (1/N)) // C++ (pow() es una función de la librería math.h)
RaizN(x) = Y = en JavaScript?

Y = pow(x,2);
Y = pow(x,0.5);
Y = pow(x,(1/3));

Se vale de todo, en todos los lenguajes del mundo entero

(matemática pura)
e = 2.718281
Y = x^N
ln (Y) = ln (x^N); pero ln (x^N) = N*ln(x)
e(ln (Y)) = e(N*ln (x))

Y = e(N*ln (x)) // Todos los lenguajes de programación la utilizan

En Python:
Y = e^N: Y = exp(N) // librería math
Y = ln(x): Y = ln(N) // librería math

En C++:
Y = e^N: Y = exp(N) // librería math.h
Y = ln(x): Y = ln(N) // librería math.h
Y = exp(N*ln (x)) // librería math.h

En JavaScript: ???

Ejemplo

f=input("INGRESE LA TEMPERATURA EN GRADOS FAHRENHEIT: ")

F1=int(f)
y=int(32)
x=float(0.5555555555555556)
C=(F1-y)*x
print("ESTA ES LA TEMPERATURA EN CELCIUS", C)

Ejemplo

#fahrenheit = int(input('Ingrese una temperatura en grados Fahrenheit: '))

print("Ingrese una temperatura en grados Fahrenheit:")
fahrenheit = float(input())
celsius = (fahrenheit - 32) * 5.0/9.0
 # Hacemos uso de la funcion str.format() para darle formato a nuestra
respuesta
print('{} grados Fahrenheit son {} grados Celsius '.format(fahrenheit,
celsius))

Ejemplo

print("a=9; b=2; c=5; d=3")

print("")
a=int("9")
b=int("2")
c=int("5")
d=int("3")
print("a+ b * c= ",a+b*c)
print("(a + b ) * c= ",(a + b ) * c)
print("((a+c-b)*b)/(c+d)= ",(((a+c-b) * b) / (c + d )))
print("(c+ d)^b=", (c+ d)**b)
Ejemplo

print('Bienvenidos- Fundamentos de Programacion - UTB')

print('A continuacion realizaremos una operacion simple')
a = int(input("digite valor de a:"))
b = int(input("digite valor de b:"))
c = int(input("digite valor de c:"))
d = int(input("digite valor de d:"))
primera = a + b * c
segunda = ( a + b ) * c
temp = a + c - b
tercera = (temp * b) / (c + d )
cuarta = (c + d) ^ b
print("RESPUESTA:")
print("a + b * c= " , primera)
print("( a + b ) * c=" , segunda )
print("((a + c - b) * b) / (c + d )= " , tercera )
print("(c + d) ^ b =", cuarta )

Ejemplo:
a=float(input("Digite el valor de A:"))
b=float(input("Digite el valor de B:"))
c=float(input("Digete el valor de C:"))
d=float(input("Digete el valor de D:"))
Z=a+(b*c)
print("El resultado del primer problema es :",Z)
X=(a+b)*c
print("El resultado del segundo problema es:",X)
J=((a + c-b)*b)/(c+d)
print("El resusltado del trecer problema es:",J)
G=(c+d)**b
print("El resultado del cuarto problema es:",G)

Ejercicios:

Ejemplo 1.

Elabore un algoritmo que nos permita calcular el valor de la hipotenusa

en un triángulo de Pitágoras. Los valores de los catetos se leen desde el
teclado.

h^2 = c1^2 + c2^2

Ejemplo 2.

Elaborar un programa que nos permita resolver la ecuación Y = (a^N). Los

valores de N y a se leen desde el teclado. a^N es a elevado a la N. N es
entero y a es real. Calcular e imprimir el valor de Y.

Ejemplo 3.

Elabore un algoritmo que lea un número y calcule e imprima:

• Valor absoluto del número

• Cuadrado del número
 • Cubo del número y de su valor absoluto

Ejemplo 4.

Elaborar un algoritmo que calcule e imprima el área y el perímetro de un

rectángulo y de un círculo. El valor del radio se lee del teclado.

Área del círculo = π r2 Perímetro del círculo = 2 π r

Ejemplo 5.

Elabore un algoritmo que nos permita leer dos números entero A y B, y

nos calcule e imprima los valores de la suma, la resta, el producto, el
cociente y el residuo (resto o módulo).
Instrucción condicional no repetitiva (if [elif] [else])

Ejemplo 1.

Elaborar un algoritmo que calcule e imprima el área y el perímetro de un

círculo. El valor del radio se lee del teclado. Se debe controlar que el valor
del radio sea un número positivo; en caso contrario, se debe imprimir un
mensaje indicando que no se pueden calcular el Área y el Perímetro del
círculo.

Área del círculo = π r2 Perímetro del círculo = 2 π r

Ejemplo 2.

Elabore un algoritmo que nos permita leer dos números A y B, y nos

calcule e imprima el cociente de A entre B y el residuo (resto o módulo).
Sí B es cero se debe imprimir un mensaje que indique que la división no
se puede realizar.

Ejemplo 3.

Elabore un algoritmo que nos permita leer dos números enteros A y B, y

nos calcule e imprima los valores de la suma, la resta, el producto, el
cociente y el residuo (resto o módulo). Sí B es cero se debe imprimir un
mensaje que indique que la división no se puede realizar.

Ejemplo 4.

Elabore un algoritmo que nos permita leer un número, nos imprima el

número y nos diga sí negativo, cero o positivo.

Tareíta No. 1.

El gerente de la empresa de transportes El Tacaño desea saber el valor a

pagar por concepto del arreglo de uno cualquiera de sus vehículos. El
taller Destroyer envía a la empresa la factura por cada vehículo arreglado,
en la cual se encuentra la siguiente información: La placa del vehículo
reparado, el tipo de daño y el costo del mismo. El gerente ha establecido
las siguientes reglas de pago teniendo en cuenta el tipo de daño:

Tipo 1. El gerente paga solamente hasta $100.000

Tipo 2. El gerente paga solamente hasta $300.000
Tipo 3. El gerente paga solamente hasta $500.000

Elabore un algoritmo que muestre la placa del vehículo arreglado, el tipo

del daño y el valor a pagar.

Tareíta No. 2.

Elabore un algoritmo que nos permita leer un número, nos imprima el

número y nos diga a qué mes del año pertenece.

Solución un poquito buena:

1 <= num and num <=12 es lo mismo 1<=num<=12

0 < num and num <= 12 es lo mismo 0<num<=12

0 < num and num <13 es lo mismo 0<num<13

num=int(input("Digite el número a evaluar "))

if 0<num<=12:
if num == 1:
print(num,"--> Enero")
elif num==2:
print(num,"--> Febrero")
elif num==3:
print(num,"--> Marzo")
elif num==4:
print(num,"--> Abril")
elif num==5:
print(num,"--> Mayo")
elif num==6:
print(num,"--> Junio")
 elif num==7:
print(num,"--> Julio")
elif num==8:
print(num,"--> Agosto")
elif num==9:
print(num,"--> Septiempre")
elif num==10:
print(num,"--> Octubre")
elif num==11:
print(num,"--> Noviembre")
elif num==12:
print(num,"--> Diciembre")
else:
print("El número debe estar en rango 1-12")

consulta = input("Digite un numero entre 1 y 12: ")

if consulta == "1":
print(consulta, " es el mes Enero")
elif consulta == "2":
print(consulta, " es el mes Febrero")
elif consulta == "3":
print(consulta, " es el mes Marzo")
elif consulta == "4":
print(consulta, " es el mes Abril")
elif consulta == "5":
print(consulta, " es el mes Mayo")
elif consulta == "6":
print(consulta, " es el mes Marzo")
elif consulta == "7":
print(consulta, " es el mes Junio")
elif consulta == "8":
print(consulta, " es el mes Julio")
elif consulta == "9":
print(consulta, " es el mes Agosto")
elif consulta == "10":
print(consulta, " es el mes Octubre")
elif consulta == "11":
print(consulta, " es el mes Noviembre")
elif consulta == "12":
print(consulta, " es el mes Diciembre")
else:
print("Error:", consulta, "<<-- debe digitar un numero entre 1 y 12")

Tareíta No. 3.

Elabore un algoritmo que nos permita leer el número que corresponde a

un mes del año y nos imprima el mes y los días que tiene ese mes.

Solución No. 1:

mes = int(input("Digite el numero del mes: "))

if mes == 1 or mes == 3 or mes == 5 or mes == 7 or mes == 10 or mes ==
12:
print("31 dias")
elif mes == 4 or mes == 6 or mes == 9 or mes == 11:
print("30 dias")
elif mes == 2:
print("28 dias ")
else:
print("ERROR: mes incorrecto ")
Solución No. 2

#Ingresa un número y verifica a que mes del año #corresponde

n = int(input("Ingrese un numero del 1 al 12: "))
if n==1:
print("<<",n,"==> Enero ==> 31 días >>")
elif n==2:
print("<<",n,"==> Febrero ==> 28 o 29 días >>")
elif n==3:
print("<<",n,"==> de Marzo ==> 31 días >>")
elif n==4:
print("<<",n,"==> Abril ==> 30 días >>")
elif n==5:
print("<<",n,"==> Mayo ==> 31 días >>")
elif n==6:
 print("<<",n,"==> Junio ==> 30 días>>")
elif n==7:
print("<<",n,"==> Julio ==> 31 días >>")
elif n==8:
print("<<",n,"==> Agosto ==> 31 días >>")
elif n==9:
print("<<",n,"==> Septiembre ==> 30 días >>")
elif n==10:
print("<<",n,"==> Octubre ==> 31 días >>")
elif n==11:
print("<<",n,"==> Noviembre ==> 30 días >>")
elif n==12:
print("<<",n,"==> Diciembre ==> 31 días >>")
else:
print("<<",n, "no corresponde a ningún mes >>")

Ejemplo: 21. Elaborar un algoritmo que lea un número y averigue si el

número es par o impar

x = int(input("Digitre un numero entero: "))

d1 = x / 2
d2 = x // 2
print ("d1 = ", d1)
print ("d2 = ", d2)
if d1 == d2:
print (x, " es par")
else:
print (x, " es impar")
if x / 2 == x // 2:
print (x, " es par")
else:
print (x, " es impar")
 Loops / Ciclos / Bucles / Estructuras Repetitivas/Iterativas
<Instrucciones Condicionales Repetitivas>

Ciclo: Es un proceso que se puede repetir varias veces. La estructura

repetitiva o iterativa permite, como su propio nombre indica, repetir una
acción (o grupo de acciones); dicha repetición puede llevarse a cabo un
número prefijado de veces o depender de la evaluación de una expresión
lógica. Por ejemplo: un proceso es el cálculo de las bonificaciones, a cada
vendedor se le calcula de la misma manera, teniendo en cuenta las
mismas restricciones; otro proceso es el cálculo del grado de eficiencia de
un empleado, a cada empleado se le calcula de la misma manera,
teniendo en cuenta las mismas restricciones.

Componentes de un Ciclo:

1. Expresión inicial. Toda condición tiene asociada por lo menos una variable.
Está expresión inicial me permite iniciar las variables asociadas a la
condición. OJO pelao: dependiendo del valor inicial de estas variables,
entonces el ciclo se puede o no ejecutar. Después de la expresión inicial,
siempre se evalúa la condición.
2. Expresión booleana. Evaluar sí es falsa o verdadero una condición. Para
controlar cuántas veces se va a repetir el proceso. La condición tiene asociada
por lo menos una variable que debe ser actualizada. Cada vez que se repite el
ciclo, se evalúa la condición.
3. Expresión de avance. Nos permite actualizar las variables asociadas a la
condición del ciclo. Para que el resultado de la condición (expresión booleana)
en algún momento cambie de valor (cambie de true a false, o viceversa).

¿Cómo se implementa un ciclo/bucle en un Código Fuente?

• Se requieren instrucciones/sentencias:
o En Python: el while y el for
o En C++: el while y el for
• Toda sentencia de ciclo/bucle require que se le especifiquen los tres(3)
componentes

Sentencia/Instrucción WHILE (mientras)

El número de repeticiones lo determina la
condición escrita en la cabecera de la sentencia.
La acción solo se ejecuta si se cumple la
condición, es decir, si esta se evalúa como
verdadera; en caso contrario, se continúa en la
acción situada fuera del bucle tras el fin mientras.

La condición tiene una variable asociada. Esta

variable debe estar inicializada en un valor o tener
algún valor asociado; además dentro del conjunto
de acciones del ciclo, debe haber por lo menos
una donde se actualice dicha variable, de lo
contrario la condición siempre será verdadera y
nunca se saldrá del ciclo (a esto se le llama ciclo
infinito). La Acción es el bloque de instrucciones
del ciclo.

Otro aspecto muy importante de esta estructura de control es que si la expresión lógica
es inicialmente falsa el bucle no se ejecuta ni una sola vez; es decir, la estructura
mientras supone que el bucle iterará 0 ó más veces.

Sintaxis instrucción While:

expresión inicial;
while expresión booleana:
instrucción1;
instrucción2;
…
instrucciónN;
expresión de avance
// Siguiente instrucción después del while, cuando salimos del while

• El proceso está compuesto por las siguientes sentencias/instrucciones:

instrucción1; instrucción2;…, instrucciónN;
• La expresión de avance, forma parte del bloque de instrucciones del while
que se repite varias veces.
• El ciclo (bloque de instrucciones) while se repite mientras la condición
(expresión de booleana) sea verdad (true); en caso contrario (falsa/false),
sale del ciclo/while, salta a la siguiente instrucción después del fin del
while, o sea, después de la última instrucción ejecutada del bloque de
instrucciones del while.
 • De la última instrucción del bloque de instrucciones del while, se salta
hasta el while para evaluar la condición (expresión booleana), por esto es
que se forma el ciclo.
• La siguiente instrucción del while debe tener la misma identación del
while, es decir, debe empezar debajo de la w del while.

Ejemplo No. 1: Elaborar un programa en Python que nos genere e imprima los cinco
(5) primeros números enteros positivos, empezando con el uno (1).

Solución:

i = 1 # expresión inicial
while (i <=5): # expresión booleana
print ("El valor de i es :", i)
i=i+1 # expresión de avance
print ("Saliendo del while…")
print ("El valor de i es :", i)

Ejemplo No. 2: Elaborar un programa en Python que nos genere los cinco (5) primeros
números enteros positivos, empezando con el uno (1); y los imprima con sus
respectivos cuadrados.

#Solución No. 1
i = 0 # expresión inicial
while (i < 5): # expresión booleana
print ("El valor de i es :", i+1, " su cuadrado es: ", (i+1)**2)
i=i+1 # expresión de avance
print ("Saliendo del while…")

#Solución No. 2
i=1
while (i < 6):
print(f"El cuadrado del número {i} es >> {i**2}")
i+=1
print(f"fin")

Ejemplo No. 3.1: Elaborar un programa que lea una pareja de números, intercambie
sus valores y los imprime intercambiados.

x = int (input(“digite el valor de x: ”))

y = int (input(“digite el valor de y: ”))
t=x
x=y
y=t
print (“el valor de x intercambiado es: ”, x)
print (“el valor de y intercambiado es: ”, y)

Ejemplo No. 3.2: Elaborar un programa que lea tres pareja de números, para cada
pareja intercambie los valores y los imprima intercambiados.

p = 1 # expresión inicial
while (p > 2): # expresión booleana
x = int (input(“digite el valor de x: ”))
y = int (input(“digite el valor de y: ”))
t=x
x=y
y=t
print (“el valor de x intercambiado es: ”, x)
print (“el valor de y intercambiado es: ”, y)
p=p+1; # expresión de avance
print ("Saliendo del while…y fin del programa")

p=1
while (p<=3):
# proceso: lineas 4 a 10
print ("Digite los valores de la pareja ", p, ":")
x = int (input("digite el valor de x: "))
y = int (input("digite el valor de y: "))
t=x
x=y
y=t
print ("el valor de x intercambiado es: ", x)
print ("el valor de y intercambiado es: ", y)
# expresion de avance
p=p+1
print("saliendo endo,...")

Ejemplo No. 4: Elaborar un programa que nos genere e imprima los números pares del
0 al 10.

#Solución No. 1
print ("Numeros pares del 0 al 10")
p=0
while (p<=10):
# proceso: lineas 4 a 10
 print (p)
p=p+2
print("saliendo endo,...")

#Solución No. 2
n=1
while n<=10:
if n%2==0:
print(n)
n=n+1

Ejemplo No. 5: Elaborar un programa que nos genere e imprima los números impares
del 0 al 10.

print ("Numeros impares del 0 al 10")

p=1
while (p<=10):
print (p)
p=p+2
print("saliendo endo,...")

Ejercicios

1. Elaborar un algoritmo que lea N parejas de números, por cada pareja debe imprimir el
mayor y el menor. Imprima un mensaje especial si los números son iguales.

Solución No. 1: con [if elif else]

P = int(input("Por favor, ingrese el número de parejas que desee: "))

i=1
while (i <= P):
print("Por favor, digite los valores de la pareja", i)
print()
x = float(input("Digite el valor de x: "))
y = float(input("Digite el valor de y: "))
if x > y:
print("El número mayor de la pareja", i, "es:", x)
print("El número menor de la pareja", i, "es:", y)
elif x == y:
print("Los dos números ingresados, son iguales")
else:
print("El número mayor de la pareja", i, "es:", y)
print("El número menor de la pareja", i, "es:", x)
i = i+1
print()
print("Expresión después del While")
 Solución No. 2 con [if else]

P = int(input("Por favor, ingrese el número de parejas que desee: "))

i=1
while (i <= P):
print("Por favor, digite los valores de la pareja", i)
print()
x = float(input("Digite el valor de x: "))
y = float(input("Digite el valor de y: "))
if x > y:
print("El número mayor de la pareja", i, "es:", x)
print("El número menor de la pareja", i, "es:", y)
else:
if x == y:
print("Los dos números ingresados, son iguales")
else:
print("El número mayor de la pareja", i, "es:", y)
print("El número menor de la pareja", i, "es:", x)
i = i+1
print()
print("Expresión después del While: Fin del programa")

2. Elaborar un algoritmo que lea N ternas de números (x, y, z), por cada terna debe imprimir el
mayor y el menor. Imprima un mensaje especial si por lo menos hay dos números iguales.

Para cada terna (x, y, z) se puede cumplir alguno/uno de los siguientes casos:

1) Si entre x, y, z hay por lo menos dos (2) iguales, entonces tenemos: (x==y)
or (x==z) or (y==z)
Sí no es verdad la condición anterior, entonces puede ocurrir uno de los
siguientes casos:

2) x > y and y > z

3) x > z and z > y
4) y > x and x > z
5) y > z and z > x
6) z > x and x > y
7) z > y and y > x

Tabla de Datos de Prueba

Expresión Lógica x y z
(x==y) or (x==z) or (y==z) 3 45 3
x > y and y > z
 x > z and z > y 10 4 5
y > x and x > z
y > z and z > x
z > x and x > y
z > y and y > x 1 50 80

N = int(input("Digite el valor de N"))

for t in range(N):
x = int(input("Digite el valor de x: "))
y = int(input("Digite el valor de y: "))
z = int(input("Digite el valor de z: "))
if (x==y) or (x==z) or (y==z):
print ("Por lo menos 2 son iguales")
elif x > y and y > z:
print ("El mayor es x: ", x)
print ("El manor es z: ", z)
elif x > z and z > y:
print ("El mayor es x: ", x)
print ("El manor es z: ", z)
elif y > x and x > z:
print ("El mayor es y: ", y)
print ("El manor es z: ", z)
elif y > z and z > x:
print ("El mayor es y: ", y)
print ("El manor es x: ", x)
elif z > x and x > y:
print ("El mayor es z: ", z)
print ("El manor es y: ", y)
else: # (z > y and y > x)
print ("El mayor es z: ", z)
print ("El manor es x: ", x)
print ("Fin del programa...")

Solución de Kevin:

[3:02 p. m.] kevin alfonso (Invitado)

# declaro las variables y le pido el numero de parejas al usuario parejas =input("digite cuantas
ternas de numeros quieres ingresar: ")
contador =0; #valido con un while si el dato ingresado es un numero entero si no es le manda
un alerta al usuario
while parejas.isnumeric()==False:

print("debe digitar un numero")

print("===========================================")
parejas =input("digite cuantas ternas de numeros quieres ingresar: ") #cuando termine el
while convierto el string numero a entero
parejas = int(parejas)
while contador<parejas:
#le pido los dos numeros al usuario mediante un while el cual se repetira dependiendo del
numero de parejas numero1 = input("digite el primer numero: ")
print("===========================================")
numero2 = input("digite el segundo numero: ")
print("===========================================")
numero3 = input("digite el tercer numero: ")

# valido si los datos ingresados son de tipo entero si no lo son el da un alerta al usuario y
no terminara hasta que sea un entero
while numero1.isnumeric() == False or numero2.isnumeric() == False:
print("DATOS INCORRECTOS, DEBEN SER NUMERO ENTEROS")
print("===========================================")
numero1 = input("digite el primer numero: ")
print("===========================================")
numero2 = input("digite el segundo numero: ")
print("===========================================")
numero3 = input("digite el tercer numero: ")

numero1=int(numero1)
numero2=int(numero2)
numero3=int(numero3)

#primero mayor y segundo menor

#primero mayor y tercer menor
#segundo mayor y tercer menor
#segundo mayor y primero menor
#tercer mayor y primero menor
#tercer mayor y segundo menor
#dos numeros iguales
if numero1 > numero2 and numero1 >numero3 and numero3 >numero2:
print("===========================================")
print("el mayor es: ",numero1,"y el menor es: ",numero2)
print("===========================================")
elif numero1 > numero2 and numero1 >numero3 and numero2 >numero3:
print("===========================================")
print("el mayor es: ",numero1,"y el menor es: ",numero3)
print("===========================================")
elif numero2 > numero1 and numero2 >numero3 and numero1 >numero3:
print("===========================================")
 print("el mayor es: ",numero2,"y el menor es: ",numero3)
print("===========================================") elif numero2
> numero1 and numero2 >numero3 and numero3 >numero1:
print("===========================================")
print("el mayor es: ",numero2,"y el menor es: ",numero1)
print("===========================================")

elif numero3 > numero1 and numero3 >numero2 and numero1 >numero2:
print("===========================================")
print("el mayor es: ",numero3,"y el menor es: ",numero2)
print("===========================================")

elif numero3 > numero2 and numero3 >numero1 and numero2 >numero1:
print("===========================================")
print("el mayor es: ",numero3,"y el menor es: ",numero1)
print("===========================================")
elif numero1 == numero2 or numero2 == numero3 or numero1== numero3:
print("hay dos numeros iguales")

3. Estadísticas de la población apta para votar en un país.

Elabore un programa de computador que lea los siguientes datos para un número
desconocido de personas:

• Edad de la persona
• Sexo (1 si es masculino, 2 si es femenino)
• Estado civil (1 si es soltero, 2 si es casado)

Se desea saber:

• El número de hombres que pueden votar.

• El número de mujeres que pueden votar.
• El número total de personas solteras que pueden votar.
• El número total de personas casadas que pueden votar.
• El número total de personas que pueden votar.
• El número total de personas que no pueden votar.

Nota: Solo pueden votar los que tengan 18 años cumplidos ó más.
Conta_puede_votar = 0
Conta_no_puede_votar = 0
Total_personas = 0
while True:
Total_personas += 1
edad = int(input("Digite su edad (años): "))
sexo = int(input("Digite sexo (1: hombre; 2: mujer): "))
esci = int(input("Digite estado civil (1: soltero; 2: casado): "))
if edad >= 18:
Conta_puede_votar += 1
else:
Conta_no_puede_votar += 1
sw = input("Desea continuar (s: si; n: no ==> ")
if sw == "n":
break
print ("Total personas que pueden votar: ", Conta_puede_votar)
print ("Total personas que no pueden votar: ", Conta_no_puede_votar)
print("Fin del programa...")

Bucles infinitos

Si la condición del bucle se cumple siempre, el bucle no terminará nunca de ejecutarse

y tendremos lo que se denomina un bucle infinito.

Los bucles infinitos deben evitarse pues significan perder el control del programa.
Cada lenguaje de programación utiliza una combinación de teclas para interrumpir la
ejecución de un bucle infinito: por ejemplo, en Python para interrumpir un bucle
infinito, hay que pulsar la combinación de teclas Ctrl+C.

Nadie está exento de cometer un error, es fácil programar involuntariamente un bucle

infinito, por lo que es inevitable hacerlo de vez en cuando, sobre todo cuando se está
aprendiendo a programar.

A continuación se muestran dos (2) ejemplos de bucles infinitos:

Ejemplo No. 1. El programador ha olvidado modificar la variable de control dentro del

bucle y el programa imprimirá números 1 indefinidamente:

i=1
while i <= 10: Imprime infinitamente (nunca sale del ciclo)
 print(i, "", end="") 1 1 1 1 1 1 1 1 ...

Ejemplo No. 2. El programador ha escrito una condición que se cumplirá siempre y el

programa imprimirá números consecutivos indefinidamente:

i=1
while i > 0:
print(i, "", end="") Imprime infinitamente (nunca sale del ciclo)
i += 1 1 2 3 4 5 6 7 8 9 10 11 ...

Uso de Variables CONTADORES, ACUMULADORES e INTERRUPTORES

En muchos programas se necesitan variables que cuenten cuántas veces ha ocurrido

algo (contadores) o que acumulen valores (acumuladores).

En caso de necesitar las variables contadores y acumuladores, estas están presenten

en programas que utilicen sentencias iterativas; mientras que las variables
interruptores (o switches), no necesariamente se utilizan con sentencias iterativas.
Las variables interruptores (o switches), también se pueden utilizar para controlar
ciclos en donde es desconocido el número de veces que se repite un proceso. Un caso
muy común de uso de estos ciclos se presenta cuando el programa interactúa
directamente con el usuario, para que este decida sí se continua repitiendo o no con
algún proceso. Las sentencias iterativas adecuadas son el mientras que (while) o el
repita hasta (repeat until). Por obvias razones, la sentencia for no sirve para controlar
ciclos con variables interruptores.
Las situaciones pueden ser muy diversas para necesitar usar estas variables, a
continuación se muestran varios ejemplos para mostrar sus usos.
Variable Contador
Se entiende por contador una variable que lleva la cuenta del número de veces que se
ha cumplido una condición. El ejemplo siguiente es un ejemplo de programa con
contador.

Ejemplo: Elaborar un algoritmo que nos averigüe e imprimir cuántos números

múltiplos de 7 hay en los 1000 primeros números enteros positivos.

cuenta = 0
i=1
while i <= 100:
if i % 7 == 0:
cuenta = cuenta + 1
 print (i, " es multiplo de 7")
i=i+1
print("Desde 1 hasta 100 hay", cuenta, "múltiplos de 7")

Detalles importantes:

• En cada iteración, el programa comprueba si i es múltiplo de 7.

• El contador se modifica sólo si la variable de control i es múltiplo de 7.
• El contador va aumentando de uno en uno.
• Antes del bucle se debe dar un valor inicial al contador (en este caso, 0)

Variable Acumulador

Se entiende por acumulador una variable que acumula el resultado de una operación.
El ejemplo siguiente es un ejemplo de programa con contador.

Ejemplo: Elaborar un algoritmo que nos imprima la suma de los primeros 4 números
enteros positivos (1, 2, 3 y el 4).

suma = 0
i=1
while i <= 4:
suma = suma + i
i=i+1
print("Suma de los enteros entre 1 y 4: ", suma)
Detalles importantes:

• El acumulador se modifica en cada iteración del bucle. (en este caso, el valor
de i se añade al acumulador suma).
• Antes del bucle se debe dar un valor inicial al acumulador (en este caso, 0)

Variable Interruptor o switch

También se les denomina conmutadores, indicador, centinelas y bandera (flag). Se

llama interruptor a una variable que únicamente toma dos valores (no necesariamente
booleano), los cuales se identifican con “abierto / cerrado”, “verdadero / falso”, “on /
off”, “start / stop”, “válido / no válido”, 10/20, “10/20”, etc.

El interruptor se usa para el control de flujo de los programas y para la toma de

decisiones. Por su naturaleza bipolar se asemejan a las variables booleanas,
ocurriendo muchas veces que el interruptor es una variable booleana. Sin embargo, ni
todos los interruptores son variables booleanas ni todas las variables booleanas son
interruptores. Vea los siguientes ejemplos de uso de variables.
Un interruptor normalmente se puede sustituir por una evaluación de una variable. Sin
embargo, son muy usados porque evitan tener que evaluar expresiones complejas y
porque aportan claridad para la escritura y lectura de programas.

Taller: Procesamiento de Notas. Cálculo de la definitiva de cada uno de los N

estudiante de un curso de Fundamentos de Programación

Cada estudiante tiene:

• Código
• Nombre
• Nota1
• Nota2

Definitiva = (Nota1+Nota2)/2

Nos piden:
1. Imprimir Código y la definitiva de cada estudiante
2. Calcular e Imprimir el promedio del grupo
3. Calcular e Imprimir el número de estudiantes (Cuántos?) con definitiva
superior o igual al promedio del grupo.
4. Calcular e Imprimir cuáles estudiantes tienen definitiva superior o igual al
promedio del grupo. Imprima el código y el nombre de cada uno de estos.
5. Imprimir los datos de cada estudiante, ordenados
(ascendentemente/descendente) por la definitiva.
6. Imprimir los datos de cada estudiante, ordenados
(ascendentemente/descendente) por la nombre.

TABLA DE DATOS DE PRUEBA

Código Nombre Nota1 Nota2 Definitiva

T100 Jhonny El Bravo 3,0 4,0 3,5
T005 Mickey 2,0 3,0 2,5
T010 Mafalda 4,0 4,8 4,4
T019 Benitín 3,0 3,0 3,0
Promedio del Grupo = 3,35
cod = []
nom = []
nota1 = []
nota2 = []
defi = []
sumadefi = 0.0
for i in range(4):
codigo = input("Digite su código:")
cod.append(codigo)
nombre = input("Digite su nombre:")
nom.append(nombre)
n1 = float(input("Digite su nota 1:"))
nota1.append(n1)
n2 = float(input("Digite su nota 1:"))
nota2.append(n2)
definitiva=(nota1[i]+nota2[i])/2
sumadefi = sumadefi + definitiva
defi.append(definitiva)
promedio = sumadefi/4
for x in range(4):
print(cod[x], nom[x], defi[x])
print ("Promedio del Grupo ==> ", promedio)
contap = 0
for x in range(4):
if defi[x] >= promedio:
contap = contap + 1
print ("Numero de estudiantes con defi >= promedio del grupo ==> ", contap)
for x in range(4):
if defi[x] >= promedio:
print(cod[x], nom[x], defi[x])
Sentencia/Instrucción FOR (desde-hasta)

Esta estructura permite repetir la ejecución de una acción o de un grupo de acciones

un número determinado de veces. Usa una variable contadora que va desde un valor
inicial hasta un valor final, realizando una iteración cada vez y modificando el contador
según lo indicado en paso; la sintaxis es la siguiente:

El funcionamiento de la estructura es el siguiente:

• En primer lugar, se asigna a la variable índice el

valor de inicio. A esto se le llama expresión inicial.
• El bucle se ejecuta mientras índice no alcance el
valor final. A esto se le llama expresión booleana
(condición).
• En cada iteración el valor de índice es
incrementado según el paso indicado (expresión
de avance) y se ejecuta la acción o grupo de
acciones (bloque de instrucciones o proceso)
encerrados en el bucle.
• En caso de que no se indique ningún paso el que
se empleará será +1.

Sintaxis instrucción for:

for nomvariable in range (Parámetro1, Parámetro2, Parámetro3):

instrucción1;
instrucción2;
…
instrucciónN;
// Siguiente instrucción después del for, cuando salimos del for

• El proceso está compuesto por las siguientes sentencias/instrucciones:

instrucción1; instrucción2;…, instrucciónN;
• nomvariable: es el nombre de la variable asociada a la condición del for.
• Parámetro1: representa el valor inicial de nomvariable. Aquí se encuentra
implícita la expresión inicial.
• El bucle se ejecuta mientras nomvariable no alcance el valor final representado
en Parametro2, una vez nomvariable sea igual o superior a Parámetro2, sale del
 ciclo/for, salta a la siguiente instrucción después del for, o sea, después de la
última instrucción ejecutada del bloque de instrucciones del for. Aquí se
encuentra implícita la condición (expresión de booleana).
• Parámetro3: Toma el nombre de paso, es el valor de avance representado en
expresión de avance.
• El bloque de instrucciones del for, no debe tener la misma identación del for.
• La siguiente instrucción del for debe tener la misma identación del for, es
decir, debe empezar debajo de la f del for.
• De los tres (3) parámetros Parámetro1, Parámetro2 y Parámetro3, que están
entre paréntesis después del range, uno o dos de ellos pueden ser opcionales.
Siempre se especifica Parametro2. En caso que no se especifique Parámetro3, el
valor de avance por defecto será +1; en caso que no se especifiquen Parametro1
y Parametro3, nomvariable inicia en cero y el valor de avance por defecto será
+1.
• En el caso que Parámetro1 > Parámetro2 y Parámetro3 < 0: tenemos conteo
regresivo con paso Parámetro3; y la expresión de booleana cambia, el ciclo se
repite sí nomvariable es superior a Parámetro2.
Ejemplos:

#Forma 1
print ("Forma 1")
for i in range(1, 10, 1):
print ("i=", i)
#Forma 2
print ("Forma 2")
for i in range(1,10,2):
print ("i=", i)
#Forma 3
print ("Forma 3")
for i in range(10):
print ("i=", i)
#Forma 4
print ("Forma 4")
for i in range(3, 5):
print ("i=", i)

Ejercicios

Ejemplo: Elaborar un algoritmo que nos averigüe e imprimir cuántos números

múltiplos de 7 hay en los 100 primeros números enteros positivos. Reemplace el while
por un for.
cuenta = 0
i=1
while i <= 100:
if i % 7 == 0:
cuenta = cuenta + 1
print (i, " es multiplo de 7")
i=i+1
print("Desde 1 hasta 100 hay", cuenta, "múltiplos de 7")

Ejemplo: Elaborar un algoritmo que lea N parejas de números, por cada pareja debe imprimir
el mayor y el menor. Imprima un mensaje especial si los números son iguales. Reemplace el
while por un for.

Solución [for]

P = int(input("Por favor, ingrese el número de parejas que desee: "))

i=1
while (i <= P):
print("Por favor, digite los valores de la pareja", i)
print()
x = float(input("Digite el valor de x: "))
y = float(input("Digite el valor de y: "))
if x > y:
print("El número mayor de la pareja", i, "es:", x)
print("El número menor de la pareja", i, "es:", y)
elif x == y:
print("Los dos números ingresados, son iguales")
else:
print("El número mayor de la pareja", i, "es:", y)
print("El número menor de la pareja", i, "es:", x)
i = i+1
print()
print("Expresión después del While")
Break & Continue

En Python break y continue son dos sentencias que alteran el flujo de un ciclo,
haciendo que se detenga o que continue dependiendo de la condición que se
plantee.

De momento sabemos que se puede iterar un número finito de veces a través de la

función range(), sin embargo, supongamos que nos gustaría detenernos cuando se
llegue a un número específico en la secuencia de números.

Las sentencias Break y Continue sólo se pueden utilizar dentro de un ciclo (while o
for).

La sentencia Break

Escribe y ejecuta el siguiente programa…

for x in range (0, 30):

print (“x=”, x)
if x==10:
break
print (“Siguiente instrucción del for)

Observa que solamente se imprimen los números del 0 al 10, por el condicional que
se cumple cuando x = 10. Al mismo tiempo dentro del condicional puedes ubicar
cualquier condición de cualquier tipo para que el ciclo se detenga usando break.

La sentencia Continue

Escribe y ejecuta el siguiente programa…

for x in range (0, 30):

if x==10:
continue
print (“x=”, x)
print (“Siguiente instrucción del for)

Observa que la sentencia continue hace que el ciclo continue aun así haya terminado
con un proceso en específico y salta enseguida a la siguiente iteración. En este
programa podrás observar que cuando x toma el valor de 10 no lo imprime porque
pasa directamente a la siguiente iteración y pasa a imprimir el resto de número,
ejecútalo veras como en la secuencia de números impresos solo hace falta del
número 10.
EJEMPLO:

Y = (a**N)/N!
Numerador = a**N
Denominador = N! =1x2x3x4x5x…x(N-1)xN

Y = Numerador / Denominador