Tipos, operadores, estructuras de control, validaciones y menú con loop — todo lo que necesitás para tu primera evaluación
Transición PSeInt → Python, con enfoque en tu primera evaluación
Definir x Como Entero). Python es de tipado dinámico: la variable toma el tipo del valor que se le asigna, y ese tipo puede cambiar durante la ejecución.
int(), float(), str().
| Tipo Python | Equivalente PSeInt | Ejemplo |
|---|---|---|
| int | Entero | x = 42 |
| float | Real | p = 3.14 |
| str | Cadena | n = "Ana" |
| bool | Lógico | ok = True |
tipado_dinamico.pyx = 10 # x es int print(type(x)) # <class 'int'> x = "hola" # ahora x es str ! print(type(x)) # <class 'str'> # ⚠️ esto NO suma, concatena: edad = input("Edad: ") print(edad + 1) # ❌ TypeError! # ✅ correcto: edad = int(input("Edad: ")) print(edad + 1) # ✓ funciona
| Op. | Significado | Ejemplo | Resultado |
|---|---|---|---|
| + | Suma | 7 + 3 | 10 |
| - | Resta | 7 - 3 | 4 |
| * | Multiplicación | 7 * 3 | 21 |
| / | División real | 7 / 2 | 3.5 |
| // | División entera | 7 // 2 | 3 |
| % | Módulo (resto) | 7 % 3 | 1 |
| ** | Potencia | 2 ** 8 | 256 |
// vs /:7 / 2 → 3.5 (float)7 // 2 → 3 (int, trunca)
operadores.pya, b = 10, 3 print(a + b) # 13 print(a / b) # 3.333... print(a // b) # 3 print(a % b) # 1 print(a ** 2) # 100 # par/impar: print(a % 2 == 0) # True → par
🔵 Relacionales
| Python | PSeInt | Significado |
|---|---|---|
| == | = | Igual a |
| != | <> | Distinto de |
| > | > | Mayor que |
| < | < | Menor que |
| >= | >= | Mayor o igual |
| <= | <= | Menor o igual |
🟣 Lógicos
| Python | PSeInt | Significado |
|---|---|---|
| and | Y | Ambas verdaderas |
| or | O | Al menos una verdadera |
| not | NO | Invierte el valor |
logicos.pyedad = 20 tiene_dni = True # and: ambas deben ser True if edad >= 18 and tiene_dni: print("Puede votar") # or: basta una True dia = "sabado" if dia == "sabado" or dia == "domingo": print("Fin de semana") # not: invierte aprobado = False if not aprobado: print("Debe rendir de nuevo") # ⚠️ = asigna, == compara x = 5 # asignación print(x == 5) # True
AND — ambas deben ser True
| A | B | A and B |
|---|---|---|
| True | True | True |
| True | False | False |
| False | True | False |
| False | False | False |
NOT — invierte
| A | not A |
|---|---|
| True | False |
| False | True |
OR — basta una True
| A | B | A or B |
|---|---|---|
| True | True | True |
| True | False | True |
| False | True | True |
| False | False | False |
True y False empiezan con mayúscula.true o false en minúscula → ❌ NameError
¿Cuál es el resultado de ejecutar este código?print(10 % 3 == 1 and not False)
1 == 1 = True. Luego not False = True. Finalmente True and True = True. Python evalúa en orden: primero %, luego ==, luego not, luego and.Detiene el programa y espera que el usuario escriba algo. Siempre devuelve texto, sin importar si el usuario escribe números. El parámetro entre paréntesis es el mensaje que se muestra al usuario.
nombre = input("Tu nombre: ") edad = int(input("Tu edad: ")) nota = float(input("Tu nota: "))
Muestra información en pantalla. Acepta múltiples argumentos separados por coma, e imprime un salto de línea al final por defecto. Se puede cambiar con end= y el separador con sep=.
# concatenación con coma print("Hola", nombre) # f-string (más limpio) print(f"Hola, {nombre}!") print(f"Tenés {edad} años") # format() print("Nota: {:.2f}".format(nota)) # sin salto de línea print("cargando...", end="")
entrada_salida.pynombre = input("Nombre: ") edad = int(input("Edad: ")) nota = float(input("Nota: ")) # Salida simple print("Alumno:", nombre) # F-string con formato print(f"{nombre} tiene {edad} años") # Nota con 2 decimales print(f"Nota: {nota:.2f}") # Separador personalizado print("A", "B", "C", sep="-") # → A-B-C
Convierte a número entero. Descarta decimales, no redondea.
Convierte a número decimal. Acepta enteros o cadenas numéricas.
Convierte cualquier valor a texto. Necesario para concatenar con +.
int("hola") lanza error. Por eso validamos antes de convertir.
int(3.9) → 3 — ¡No redondea! Trunca hacia abajo. Para redondear usá round(3.9) → 4
conversiones.py# str → int edad = int("25") # ✓ 25 x = int("hola") # ❌ ValueError y = int(3.9) # ✓ 3 (trunca) # str → float nota = float("9.5") # ✓ 9.5 p = float("3,14") # ❌ ValueError (coma!) # int/float → str s = str(42) # "42" msg = "Edad: " + str(edad) # "Edad: 25" # mejor con f-string: msg = f"Edad: {edad}" # ✓ más limpio
SiNo Si anidado de PSeInt. Permite encadenar múltiples condiciones de forma limpia, sin el caos del anidamiento.
estructura.pyif condicion1: # bloque 1 elif condicion2: # bloque 2 elif condicion3: # bloque 3 else: # si ninguna aplica
calificacion.pynota = float(input("Nota (0-10): ")) if nota >= 9: print("Sobresaliente") elif nota >= 7: print("Bueno") elif nota >= 6: print("Aprobado") else: print("Reprobado") # Con operador lógico: if nota >= 6 and nota <= 10: print("Rango válido y aprobado") # Equivalente más pythonico: if 6 <= nota <= 10: print("Rango válido y aprobado")
Un alumno escribe el siguiente código. ¿Qué imprime si el usuario ingresa 8.5?
nota = float(input("Nota: ")) if nota >= 9: print("Sobresaliente") elif nota >= 7: print("Bueno") elif nota >= 6: print("Aprobado") else: print("Reprobado")
nota >= 9 (primer elif, False). Sí cumple nota >= 7 (8.5 ≥ 7 = True) → imprime "Bueno" y no evalúa los elif siguientes. El if/elif se detiene en el primer caso verdadero.Mientras … Hacer de PSeInt. Repite mientras la condición sea True. La condición se evalúa antes de entrar al bloque.
estructura.pywhile condicion: # bloque que se repite # debe haber algo que # haga la condición False
while True: crea un bucle infinito intencional. Se sale con break.
while_ejemplo.py# Tabla del 5 i = 1 while i <= 10: print(f"5 x {i} = {5*i}") i += 1 # i = i + 1 # Acumulador suma = 0 n = 1 while n <= 100: suma += n # suma = suma + n n += 1 print(f"Suma 1-100: {suma}") # 5050 # while True + break while True: resp = input("¿Salir? (s/n): ") if resp == "s": break
Para … Hasta de PSeInt. range() genera la secuencia de números.
| Uso de range() | Genera |
|---|---|
| range(5) | 0, 1, 2, 3, 4 |
| range(1, 6) | 1, 2, 3, 4, 5 |
| range(1, 11, 2) | 1, 3, 5, 7, 9 |
| range(10, 0, -1) | 10, 9, 8 … 1 |
range(1, n) llega hasta n-1. Para incluir n: range(1, n+1)
for_range.py# Para i ← 1 Hasta 5 Hacer for i in range(1, 6): print(i) # 1 2 3 4 5 # Suma de N números n = int(input("N: ")) suma = 0 for i in range(1, n + 1): suma += i print(f"Suma: {suma}") # Cuenta regresiva for i in range(10, 0, -1): print(i, end=" ") # 10 9 8 7 6 5 4 3 2 1 # Pares del 2 al 20 for i in range(2, 21, 2): print(i, end=" ")
¿Cuántas veces se imprime "hola" al ejecutar este código?for i in range(2, 10, 3): print("hola")
input() siempre retorna str, antes de convertir con int() debemos verificar que el texto efectivamente representa un número. Para eso usamos el método .isdigit() del string.
Retorna True si todos los caracteres del string son dígitos (0-9). Retorna False si hay letras, espacios, puntos o signos.
"25".isdigit() # True ✓ "hola".isdigit() # False ✗ "3.5".isdigit() # False ✗ (tiene punto) "-5".isdigit() # False ✗ (tiene signo) "007".isdigit() # True ✓
El texto queda guardado como string
Si es False → avisar y repetir
Recién acá, porque ya sabemos que es número
Rango válido, positivo, etc.
validar_numero.py# Pedir edad válida (0-120) while True: texto = input("Edad (0-120): ") if not texto.isdigit(): print("⚠ Ingresá solo números enteros") else: edad = int(texto) if 0 <= edad <= 120: break else: print("⚠ Debe estar entre 0 y 120") print(f"Edad registrada: {edad}") # ─── Validar clave de 4 dígitos ────────── while True: texto = input("Clave (4 dígitos): ") if not texto.isdigit(): print("⚠ Solo números, sin letras ni espacios") elif len(texto) != 4: print("⚠ Debe tener exactamente 4 dígitos") else: clave = int(texto) break print(f"Clave aceptada: {clave}")
cadenas.py# Validar que no esté vacío while True: nombre = input("Nombre: ").strip() if nombre != "": break print("⚠ No puede estar vacío") # Validar opción de menú opciones = ["1", "2", "3"] while True: op = input("Opción (1-3): ") if op in opciones: break print("⚠ Solo 1, 2 o 3")
.isdigit() verifica que todos los caracteres son dígitos, luego se convierte y se valida el rango.
val_entero.py# Nota entera (1-7) while True: texto = input("Nota (1-7): ") if not texto.isdigit(): print("⚠ Solo números enteros") else: nota = int(texto) if 1 <= nota <= 7: break else: print("⚠ Debe estar entre 1 y 7") # Porcentaje entero (0-100) while True: texto = input("Porcentaje (0-100): ") if not texto.isdigit(): print("⚠ Solo números enteros") else: pct = int(texto) if 0 <= pct <= 100: break else: print("⚠ Debe estar entre 0 y 100")
.isdigit() falla con "3.5" porque el punto no es dígito. Truco: quitar un punto y luego verificar.
val_float.py# El truco: replace + isdigit "3.5".replace(".","",1).isdigit() # → "35" → True ✓ "3.5.1".replace(".","",1).isdigit() # → "35.1" → False ✗ "hola".replace(".","",1).isdigit() # → "hola" → False ✗ # Nota decimal (1.0 - 7.0) while True: texto = input("Nota (1.0-7.0): ") if texto.replace(".","",1).isdigit(): nota = float(texto) if 1.0 <= nota <= 7.0: break print("⚠ Fuera de rango") else: print("⚠ Decimal inválido")
try/except permite capturar ese error y manejarlo sin que el programa se caiga.
# Estructura básica try: # código que podría fallar except TipoDeError: # qué hacer si falla
| Excepción | Cuándo ocurre |
|---|---|
| ValueError | int("hola") — conversión inválida |
| ZeroDivisionError | 10 / 0 — división por cero |
| TypeError | "edad" + 1 — tipos incompatibles |
| NameError | usar variable no definida |
try/except es más robusto que .isdigit() para validar números: captura cualquier error de conversión, incluidos decimales y negativos.
try_except.py# ValueError: texto no es número while True: try: edad = int(input("Edad (0-120): ")) if 0 <= edad <= 120: break print("⚠ Debe estar entre 0 y 120") except ValueError: print("⚠ Solo números enteros") # ZeroDivisionError: divisor puede ser 0 try: resultado = 10 / int(input("Divisor: ")) print(resultado) except ZeroDivisionError: print("⚠ No se puede dividir por cero") except ValueError: print("⚠ Ingresá un número") # Validar float con try/except # (más simple que el truco con .replace) while True: try: nota = float(input("Nota (1.0-7.0): ")) if 1.0 <= nota <= 7.0: break print("⚠ Fuera de rango") except ValueError: print("⚠ Ingresá un decimal válido")
try/except el problema del .isdigit() con decimales y negativos desaparece: si la conversión falla por cualquier razón, el except lo captura.
while True externo que muestra el menú, ejecuta la opción elegida, y solo sale cuando el usuario elige "Salir". Toda la lógica del programa vive dentro de este loop.
Loop infinito intencional
print() de todas las opciones
.isdigit() + verificar rango
Ejecutar la funcionalidad
Rompe el while True
menu_principal.pywhile True: # ── Mostrar menú ────────────── print("\n=== MENÚ PRINCIPAL ===") print("1. Saludar") print("2. Calcular promedio") print("3. Verificar mayoría de edad") print("0. Salir") # ── Leer y validar opción ───── texto = input("Opción: ") if not texto.isdigit(): print("⚠ Solo números") continue # vuelve al inicio del while op = int(texto) # ── Ejecutar opción ─────────── if op == 1: nombre = input("Tu nombre: ") print(f"¡Hola, {nombre}!") elif op == 2: a = int(input("Nota 1: ")) b = int(input("Nota 2: ")) print(f"Promedio: {(a+b)/2:.1f}") elif op == 3: texto = input("Edad: ") if texto.isdigit(): edad = int(texto) print("Mayor" if edad >= 18 else "Menor") elif op == 0: print("¡Hasta luego!") break # ← sale del while True else: print("⚠ Opción no válida (0-3)")
integrador.pywhile True: print("\n══ MENÚ ══") print("1. Calcular promedio de notas") print("2. Calcular factorial") print("0. Salir") # Validar opción del menú texto = input("Opción: ") if not texto.isdigit(): print("⚠ Solo números") continue op = int(texto) if op == 1: # Pedir N válido while True: txt = input("¿Cuántas notas? ") if txt.isdigit() and int(txt) > 0: n = int(txt) break print("⚠ Ingresá un entero mayor a 0") suma = 0 for i in range(1, n + 1): while True: # validar cada nota txt = input(f"Nota {i} (1-7): ") if txt.isdigit(): nota = int(txt) if 1 <= nota <= 7: break print("⚠ Debe estar entre 1 y 7") else: print("⚠ Solo números enteros") suma += nota prom = suma / n estado = "✅ Aprobado" if prom >= 4 else "❌ Reprobado" print(f"Promedio: {prom:.1f} → {estado}") elif op == 2: while True: txt = input("Número (≥ 0): ") if txt.isdigit(): num = int(txt) break print("⚠ Solo enteros positivos") fact = 1 for i in range(1, num + 1): fact *= i print(f"{num}! = {fact}") elif op == 0: print("¡Hasta luego! 🐍"); break else: print("⚠ Opción inválida")
¿Cuál de los siguientes fragmentos valida correctamente que el usuario ingresó un número entero positivo antes de convertirlo?
n = int(input("N: ")) if n > 0: break
txt = input("N: ") if txt.isdigit() and int(txt) > 0: n = int(txt); break
n = input("N: ") if n.isdigit(): break
if input("N: ") > 0: break
int(txt) > 0 verifica la regla de negocio (positivo). Solo después convierte con int(). La opción A convierte sin verificar el tipo primero. La C no verifica el rango. La D compara un string con un número, lo que da error.
Mismos conceptos, diferente sintaxis. Indentación reemplaza FinSi/FinMientras.
Sin declarar tipos. Pero input() siempre es str — convertir con int()/float().
+, -, *, /, //, %, **. Comparación: ==, !=, >, <. Lógicos: and, or, not.
F-strings para formato limpio. sep= y end= para controlar salida.
try/except ValueError + while True + break. Robusto ante entradas incorrectas.
while True → mostrar → leer → if/elif → break en salida.
Ya tienen todo lo que necesitan para su primera evaluación. Practiquen validaciones, el menú con loop principal y la conversión de tipos. La programación se aprende haciendo.