Abrir en Google Colab

Sesión 2: Operadores y algoritmos secuenciales¶

Objetivo¶

Usar operadores de asignación, aritméticos, relacionales y lógicos para construir expresiones y resolver problemas mediante algoritmos secuenciales.

Producto de la sesión¶

Elabora un programa secuencial que lea datos, realice cálculos y muestre resultados de forma clara y ordenada.

Resultado esperado¶

Construye un programa secuencial usando operadores y expresiones para resolver un problema con entrada, proceso y salida.

Alcance de la sesión¶

• Uso de operadores de asignación, aritméticos, relacionales y lógicos.
• Construcción de expresiones y resolución de cálculos secuenciales.
• Organización de la solución en entrada, proceso y salida.
• Aplicación en ejercicios guiados y práctica autónoma.

Base conceptual de la sesión¶

• operadores de asignación
• operadores aritméticos
• operadores relacionales
• operadores lógicos
• expresiones
• precedencia de operadores
• conversiones numéricas
• algoritmos secuenciales
• entrada, proceso y salida con cálculos

1. Operadores de asignación

Permiten guardar un valor o el resultado de una expresión en una variable.

El operador principal es =.

subtotal = precio * cantidad

También existen operadores de asignación abreviada:

• += suma y asigna
• -= resta y asigna
• *= multiplica y asigna
• /= divide y asigna

Ejemplo:

total = 5
total += 15

2. Operadores aritméticos

Permiten realizar cálculos con datos numéricos.

Los operadores más usados son:

• + suma
• - resta
• * multiplicación
• / división decimal
• // división entera
• % residuo
• ** potencia

Ejemplo:

total = precio * cantidad
sobrante = caramelos % estudiantes

3. Operadores relacionales

Permiten comparar dos valores. El resultado de una comparación es un dato lógico: True o False.

Los operadores relacionales son:

• == igual que
• != diferente de
• > mayor que
• < menor que
• >= mayor o igual que
• <= menor o igual que

Ejemplo:

aprueba = promedio >= 11

4. Operadores lógicos

Permiten combinar expresiones lógicas.

Los operadores lógicos principales son:

• and: se cumple si ambas expresiones son verdaderas
• or: se cumple si al menos una expresión es verdadera
• not: invierte el valor lógico

Ejemplo:

apto = edad >= 16 and promedio >= 14

5. Expresiones y precedencia

Una expresión combina valores, variables y operadores para obtener un nuevo resultado. Según el operador usado, la expresión puede guardar datos, calcular, comparar o combinar valores lógicos.

Expresión aritmética

promedio = (nota1 + nota2 + nota3) / 3

Expresión relacional

aprueba = promedio >= 11

Expresión lógica

apto = edad >= 16 and promedio >= 14

Expresiones compuestas

Una expresión combinada puede incluir cálculos, comparaciones y operadores lógicos en una sola instrucción.

cumple = ((nota1 + nota2 + nota3) / 3 >= 11) and (asistencia >= 70)

También puede guardar primero resultados intermedios para que el programa sea más claro.

promedio = (nota1 + nota2 + nota3) / 3
cumple = promedio >= 11 and asistencia >= 70

En expresiones lógicas también se pueden usar paréntesis para aclarar el orden y evitar ambigüedad.

cumple = (edad >= 16) and (promedio >= 14)

6. Algoritmos secuenciales

Un algoritmo secuencial ejecuta instrucciones una después de otra, sin decisiones ni repeticiones.

                 +----------------+
                 |     Inicio     |
                 +----------------+
                         |
                         v
                 +----------------+
                 |   Leer datos   |
                 +----------------+
                         |
                         v
                 +----------------+
                 | Procesar datos |
                 +----------------+
                         |
                         v
                 +----------------+
                 | Mostrar salida |
                 +----------------+
                         |
                         v
                 +----------------+
                 |      Fin       |
                 +----------------+

flowchart TD
    inicio([Inicio]) --> entrada[/Leer datos/]
    entrada --> proceso[Realizar cálculos y expresiones]
    proceso --> salida[/Mostrar resultados/]
    salida --> fin([Fin])

En esta sesión los problemas se resolverán leyendo datos, calculando resultados, evaluando expresiones y mostrando una salida ordenada.

Actividad práctica¶

La sesión inicia con mini laboratorios para probar operadores y expresiones. Luego se resuelven ejercicios guiados donde cada programa sigue una estructura secuencial: entrada, proceso y salida.

Arquitectura¶

Entrada -> Proceso -> Salida

• Entrada: datos del problema.
• Proceso: aplicación de operadores, expresiones y cálculos secuenciales.
• Salida: resultados obtenidos.

Mini laboratorio¶

Prueba operadores aritméticos con valores pequeños antes de resolver problemas completos.

In [ ]:

precio_texto = input('Precio: ')
cantidad_texto = input('Cantidad: ')

precio = float(precio_texto)
cantidad = int(cantidad_texto)

total = precio * cantidad

print('Total:', round(total, 2))

precio_texto = input('Precio: ') cantidad_texto = input('Cantidad: ') precio = float(precio_texto) cantidad = int(cantidad_texto) total = precio * cantidad print('Total:', round(total, 2))

In [ ]:

a = 12
b = 5

print('Suma:', a + b)
print('Resta:', a - b)
print('Multiplicación:', a * b)
print('División decimal:', a / b)
print('División entera:', a // b)
print('Residuo:', a % b)
print('Potencia:', a ** 2)
print('Raíz cuadrada:', a ** (1 / 2))
print('Raíz cúbica:', a ** (1 / 3))

a = 12 b = 5 print('Suma:', a + b) print('Resta:', a - b) print('Multiplicación:', a * b) print('División decimal:', a / b) print('División entera:', a // b) print('Residuo:', a % b) print('Potencia:', a ** 2) print('Raíz cuadrada:', a ** (1 / 2)) print('Raíz cúbica:', a ** (1 / 3))

In [ ]:

edad = 17
promedio = 15.5
asistencia = 82

cumple_edad = edad >= 16
cumple_promedio = promedio >= 14
cumple_asistencia = asistencia >= 80
apto = cumple_edad and cumple_promedio and cumple_asistencia

print('Cumple edad:', cumple_edad)
print('Cumple promedio:', cumple_promedio)
print('Cumple asistencia:', cumple_asistencia)
print('Apto:', apto)

edad = 17 promedio = 15.5 asistencia = 82 cumple_edad = edad >= 16 cumple_promedio = promedio >= 14 cumple_asistencia = asistencia >= 80 apto = cumple_edad and cumple_promedio and cumple_asistencia print('Cumple edad:', cumple_edad) print('Cumple promedio:', cumple_promedio) print('Cumple asistencia:', cumple_asistencia) print('Apto:', apto)

Ejercicio 1: Promedio de notas¶

Construir un programa que lea tres notas, calcule el promedio y lo muestre con dos decimales.

Resolución guiada

1. Comprender: se necesita obtener un solo promedio a partir de tres notas.
2. Entradas: nota1, nota2 y nota3, como números decimales.
3. Proceso:

• sumar las tres notas
• dividir la suma entre 3
• redondear el resultado al mostrarlo

4. Salida: promedio final.
5. Pruebas: usa notas como 14, 16 y 13 para verificar el cálculo.
6. Código:

In [ ]:

nota1 = float(input('Nota 1: '))
nota2 = float(input('Nota 2: '))
nota3 = float(input('Nota 3: '))

promedio = (nota1 + nota2 + nota3) / 3

print('Promedio:', round(promedio, 2))

nota1 = float(input('Nota 1: ')) nota2 = float(input('Nota 2: ')) nota3 = float(input('Nota 3: ')) promedio = (nota1 + nota2 + nota3) / 3 print('Promedio:', round(promedio, 2))

Ejercicio 2: Área y perímetro de un rectángulo¶

Construir un programa que lea la base y la altura de un rectángulo. Luego debe calcular el área y el perímetro.

Resolución guiada

1. Comprender: se deben obtener dos resultados a partir de la base y la altura.
2. Entradas: base y altura, como números decimales.
3. Proceso:

• calcular area = base * altura
• calcular perimetro = 2 * (base + altura)

4. Salidas: área y perímetro.
5. Pruebas: usa base = 8 y altura = 5.
6. Código:

In [ ]:

base = float(input('Base: '))
altura = float(input('Altura: '))

area = base * altura
perimetro = 2 * (base + altura)

print('Área:', round(area, 2))
print('Perímetro:', round(perimetro, 2))

base = float(input('Base: ')) altura = float(input('Altura: ')) area = base * altura perimetro = 2 * (base + altura) print('Área:', round(area, 2)) print('Perímetro:', round(perimetro, 2))

Ejercicio 3: Boleta de venta¶

Construir un programa que lea el precio unitario y la cantidad comprada. Luego debe calcular el subtotal, el IGV y el total a pagar.

Resolución guiada

1. Comprender: una boleta requiere calcular importes en orden.
2. Entradas: precio_unitario como decimal y cantidad como entero.
3. Proceso:

• calcular el subtotal multiplicando precio por cantidad
• calcular el IGV como el 18% del subtotal
• calcular el total sumando subtotal e IGV

4. Salidas: subtotal, IGV y total.
5. Pruebas: usa precio = 25.50 y cantidad = 3.
6. Código:

In [ ]:

precio_unitario = float(input('Precio unitario: '))
cantidad = int(input('Cantidad: '))

subtotal = precio_unitario * cantidad
igv = subtotal * 0.18
total = subtotal + igv

print('Subtotal:', round(subtotal, 2))
print('IGV:', round(igv, 2))
print('Total:', round(total, 2))

precio_unitario = float(input('Precio unitario: ')) cantidad = int(input('Cantidad: ')) subtotal = precio_unitario * cantidad igv = subtotal * 0.18 total = subtotal + igv print('Subtotal:', round(subtotal, 2)) print('IGV:', round(igv, 2)) print('Total:', round(total, 2))

Ejercicio 4: Reparto de entradas¶

Construir un programa que lea la cantidad total de entradas y la cantidad de estudiantes. Luego debe mostrar cuántas entradas recibe cada estudiante y cuántas sobran.

Resolución guiada

1. Comprender: se debe repartir una cantidad entera en partes iguales.
2. Entradas: entradas y estudiantes, como números enteros.
3. Proceso:

• usar // para calcular cuántas entradas recibe cada estudiante
• usar % para calcular cuántas entradas sobran

4. Salidas: entradas por estudiante y entradas sobrantes.
5. Pruebas: usa 25 entradas y 6 estudiantes.
6. Código:

In [ ]:

entradas = int(input('Entradas: '))
estudiantes = int(input('Estudiantes: '))

por_estudiante = entradas // estudiantes
sobrantes = entradas % estudiantes

print('Cada estudiante recibe:', por_estudiante)
print('Sobran:', sobrantes)

entradas = int(input('Entradas: ')) estudiantes = int(input('Estudiantes: ')) por_estudiante = entradas // estudiantes sobrantes = entradas % estudiantes print('Cada estudiante recibe:', por_estudiante) print('Sobran:', sobrantes)

Ejercicio 5: Costo de viaje¶

Construir un programa que lea la distancia de un viaje en kilómetros, el rendimiento del vehículo en kilómetros por galón y el precio del galón. Luego debe calcular cuántos galones se necesitan y el costo total del viaje.

Resolución guiada

1. Comprender: se debe calcular consumo y costo usando una secuencia de fórmulas.
2. Entradas: distancia, rendimiento y precio_galon, como números decimales.
3. Proceso:

• calcular los galones necesarios dividiendo distancia entre rendimiento
• calcular el costo multiplicando galones por precio del galón

4. Salidas: galones necesarios y costo total.
5. Pruebas: usa distancia = 180, rendimiento = 45 y precio_galon = 17.5.
6. Código:

In [ ]:

distancia = float(input('Distancia en km: '))
rendimiento = float(input('Km por galón: '))
precio_galon = float(input('Precio por galón: '))

galones = distancia / rendimiento
costo = galones * precio_galon

print('Galones necesarios:', round(galones, 2))
print('Costo total:', round(costo, 2))

distancia = float(input('Distancia en km: ')) rendimiento = float(input('Km por galón: ')) precio_galon = float(input('Precio por galón: ')) galones = distancia / rendimiento costo = galones * precio_galon print('Galones necesarios:', round(galones, 2)) print('Costo total:', round(costo, 2))

Ejercicio 6: Habilitación académica¶

En una competencia de programación, los enunciados suelen pedir una salida exacta. En este reto, debes calcular el promedio de un estudiante, su porcentaje de asistencia y mostrar si cumple los requisitos académicos.

Problema

Leer el nombre de un estudiante, tres notas, la cantidad de clases asistidas y la cantidad total de clases. Luego calcular el promedio, el porcentaje de asistencia y verificar si el estudiante queda habilitado.

Reglas

• Cumple nota si su promedio es mayor o igual que 11.
• Cumple asistencia si su asistencia es mayor o igual que 70.
• Está habilitado si cumple ambas condiciones.

Salida esperada

Mostrar los datos en este formato:

ESTUDIANTE: Ana
PROMEDIO: 13.67
ASISTENCIA: 80.0
CUMPLE_NOTA: True
CUMPLE_ASISTENCIA: True
HABILITADO: True

Resolución guiada

1. Comprender: no se debe usar if; solo se deben evaluar expresiones aritméticas, relacionales y lógicas.
2. Entradas: estudiante, nota1, nota2, nota3, asistidas y total_clases.
3. Proceso:

• calcular el promedio de las tres notas
• calcular el porcentaje de asistencia
• comparar promedio y asistencia con los mínimos requeridos
• combinar las condiciones con and

4. Salidas: nombre, promedio, asistencia y resultados lógicos con etiquetas exactas.
5. Pruebas: usa un caso donde todo se cumpla y otro donde falle un requisito.
6. Código:

In [ ]:

estudiante = input('Estudiante: ')
nota1 = float(input('Nota 1: '))
nota2 = float(input('Nota 2: '))
nota3 = float(input('Nota 3: '))
asistidas = int(input('Clases asistidas: '))
total_clases = int(input('Total de clases: '))

promedio = (nota1 + nota2 + nota3) / 3
asistencia = asistidas * 100 / total_clases

cumple_nota = promedio >= 11
cumple_asistencia = asistencia >= 70
habilitado = cumple_nota and cumple_asistencia

print('ESTUDIANTE:', estudiante)
print('PROMEDIO:', round(promedio, 2))
print('ASISTENCIA:', round(asistencia, 2))
print('CUMPLE_NOTA:', cumple_nota)
print('CUMPLE_ASISTENCIA:', cumple_asistencia)
print('HABILITADO:', habilitado)

estudiante = input('Estudiante: ') nota1 = float(input('Nota 1: ')) nota2 = float(input('Nota 2: ')) nota3 = float(input('Nota 3: ')) asistidas = int(input('Clases asistidas: ')) total_clases = int(input('Total de clases: ')) promedio = (nota1 + nota2 + nota3) / 3 asistencia = asistidas * 100 / total_clases cumple_nota = promedio >= 11 cumple_asistencia = asistencia >= 70 habilitado = cumple_nota and cumple_asistencia print('ESTUDIANTE:', estudiante) print('PROMEDIO:', round(promedio, 2)) print('ASISTENCIA:', round(asistencia, 2)) print('CUMPLE_NOTA:', cumple_nota) print('CUMPLE_ASISTENCIA:', cumple_asistencia) print('HABILITADO:', habilitado)

Aprendizaje autónomo¶

Desarrolle el producto de la sesión resolviendo una o más de las siguientes actividades mediante un programa secuencial con entrada, proceso y salida claramente identificables.

1 Calcula el sueldo de un trabajador a partir de horas trabajadas, pago por hora y bonificación porcentual.

In [ ]:

# Actividad 1

# Actividad 1

2 Calcula el cambio que debe recibir un cliente después de una compra y muestra si el pago realizado cubre el total.

In [ ]:

# Actividad 2

# Actividad 2

3 Convierte una cantidad de minutos a horas y minutos usando // y %.

In [ ]:

# Actividad 3

# Actividad 3

4 Calcula el área de un triángulo y de un círculo usando variables y una constante PI.

In [ ]:

# Actividad 4

# Actividad 4

5 Diseña una boleta simple con subtotal, descuento, total final y una expresión lógica que indique si el descuento fue aplicado.

In [ ]:

# Actividad 5

# Actividad 5

6 Crea un verificador de requisitos sin usar if: edad mínima, promedio mínimo y asistencia mínima.

In [ ]:

# Actividad 6

# Actividad 6

7 Dado el monto de un sueldo en soles, calcula cuántos billetes o monedas se deben entregar para completar el pago. Denominaciones disponibles: 200, 100, 50, 20, 10, 5, 2, 1, 0.50, 0.20 y 0.10. Regla: la solución debe usar la menor cantidad posible de billetes y monedas. Convierte el monto a céntimos y usa // y %, sin condicionales.

In [ ]:

# Actividad 7: pago de sueldo en efectivo

# Actividad 7: pago de sueldo en efectivo

Evaluación del producto de la sesión¶

Lista de cotejo para revisar el producto elaborado por el estudiante:

• Identifica las entradas, el proceso de cálculo y la salida del problema planteado.
• Usa operadores y expresiones adecuadas para resolver el problema en forma secuencial.
• Presenta resultados claros, ordenados y correctos según lo solicitado.
• Verifica el programa con datos de prueba antes de entregarlo.
• Entrega la evidencia del trabajo realizado.