Sin suposiciones. Sin saltos. Desde cero hasta operadores lógicos, tipos de datos, None y listas.
if? La pregunta que toma decisionesImagina que eres el guardia de un edificio. Antes de dejar pasar a alguien haces UNA pregunta: ¿tiene pase? Si sí → entra. Si no → se queda afuera. if hace exactamente eso.
Sintaxis → if <condición>: y debajo, con sangría, lo que debe pasar si esa condición es verdadera.
# Guardamos la edad en una variable edad = 20 if edad >= 18: print("Puedes entrar 🎉")
else, Python simplemente se salta ese bloque y sigue adelante. No explota. No dice nada. Sigue.
edad = 15 if edad >= 18: print("Puedes entrar 🎉") else: print("Lo siento, eres menor de edad 🚫")
if. Si olvidas la sangría, Python da error.
Python permite escribir un if en una sola línea. Técnicamente funciona. Pero vas a ver por qué confunde y por qué los bloques son mejores.
nota = 75 if nota >= 60: print("Aprobado") else: print("Reprobado")
nota = 75 print("Aprobado") if nota >= 60 else print("Reprobado")
Ambos dan el mismo resultado: Aprobado. Entonces… ¿cuál es la diferencia?
if nota >= 60) y luego saltar de izquierda a derecha. Con más condiciones o lógica compleja esto se vuelve un laberinto.resultado = "Par" if numero % 2 == 0 else "Impar". Solo si la condición y ambas opciones son cortas y obvias.
elif: cuando hay más de dos opcioneselif = else if = "si lo anterior fue falso, entonces prueba esto otro". Puedes tener tantos elif como necesites.
1️⃣ Evalúa la condición del if → ¿es True? Ejecuta ese bloque y salta todo lo demás.
2️⃣ Si fue False, baja al primer elif → ¿es True? Ejecuta y salta el resto.
3️⃣ Sigue bajando por cada elif hasta que uno sea True, o llegue al else.
4️⃣ El else se ejecuta solo si ningún if/elif fue verdadero.
nota = 85 if nota >= 90: print("🏆 Excelente") elif nota >= 80: print("👍 Muy Bien") elif nota >= 70: print("✅ Bien") elif nota >= 60: print("⚠️ Aprobado") else: print("❌ Reprobado")
elif verdadero (85 >= 80). Los bloques de abajo ni siquiera se revisan. Python siempre ejecuta el primero que sea verdadero y se va.
color = "AMARILLO" if color == "VERDE": print("🟢 Puedes avanzar") elif color == "AMARILLO": print("🟡 Prepárate para frenar") elif color == "ROJO": print("🔴 Alto, no avances") else: print("❓ Color desconocido")
Una prueba lógica es cualquier expresión que Python puede evaluar como True (verdadero) o False (falso). Esto es lo que va dentro del if.
El if siempre necesita una prueba lógica. En el momento en que Python llega al if, evalúa esa expresión y obtiene un resultado: True o False. Solo hay dos posibilidades.
| Expresión | ¿Qué evalúa Python? | Resultado |
|---|---|---|
edad >= 18 | ¿Es edad mayor o igual a 18? | True o False |
nombre == "Ana" | ¿Es el nombre exactamente "Ana"? | True o False |
saldo > 0 | ¿Hay dinero en la cuenta? | True o False |
lista_vacia == [] | ¿Está la lista vacía? | True o False |
0, 0.0, "" (cadena vacía), [] (lista vacía), None. Todo lo demás es True.
tiene_dinero = True if tiene_dinero: # equivale a: if tiene_dinero == True: print("Puedes comprar 🛒") else: print("Sin fondos 💸") # ¿Y con un número? saldo = 0 if saldo: # 0 es Falsy → entra al else print("Tienes saldo") else: print("Cuenta en cero")
int, float, bool, str — y por qué importanPython maneja diferentes tipos de datos. Saber qué tipo tienes importa al comparar, sumar y al usar if.
| Tipo | ¿Qué guarda? | Ejemplos | ¿Verdadero si…? |
|---|---|---|---|
int |
Números enteros | 5, -3, 100 |
Cualquier número distinto de 0 |
float |
Números decimales | 3.14, -0.5, 1.0 |
Cualquier número distinto de 0.0 |
bool |
Verdadero/Falso | True, False |
Solo True |
str |
Texto | "Hola", "A" |
Cualquier texto que no sea vacío "" |
NoneType |
"Sin valor" | None |
Nunca — siempre False |
"18" == 18 es False. Un texto con el número 18 NO es lo mismo que el número entero 18. Si quieres comparar: int("18") == 18 → True.
precio = 99.9 # float cantidad = 3 # int en_oferta = True # bool nombre = "Laptop" # str if en_oferta: descuento = precio * 0.10 print(f"{nombre} tiene 10% de descuento: ${precio - descuento:.2f}") else: print(f"{nombre} a precio normal: ${precio:.2f}")
float si ya existe int?
Porque los enteros no tienen decimales. 10 / 3 en Python devuelve 3.3333... (float). Los floats pueden representar medidas, precios, temperaturas — cualquier cosa que no sea "exactamente entera".
= vs == — el error que todo principiante cometeSon completamente distintos. Confundirlos es el bug #1 de los estudiantes nuevos en Python.
# Guarda un valor en una variable nombre = "Carlos" edad = 25 activo = True # Lee: "nombre TOMA EL VALOR Carlos"
# Pregunta si dos cosas son iguales nombre == "Carlos" # ¿Es Carlos? edad == 30 # ¿Tiene 30? activo == True # ¿Está activo? # Lee: "¿nombre ES IGUAL A Carlos?"
if nombre = "Carlos": # SyntaxError — Python no te deja hacer estoif nombre == "Carlos": # ✅ Correcto — esto sí compara
usuario = "admin" # = ASIGNA "admin" a usuario clave = "1234" if usuario == "admin": # == COMPARA: ¿es "admin"? print("🔓 Usuario válido") else: print("🔒 Usuario no reconocido")
Un igual (=) → ordenas. Como decir "desde hoy tu nombre ES Juan".
Dos iguales (==) → preguntas. Como decir "¿tu nombre ES Juan?"
Todos devuelven True o False. Son la materia prima de las pruebas lógicas.
| Operador | Significado | Ejemplo | Resultado |
|---|---|---|---|
== | Igual a | 5 == 5 | True |
!= | Distinto de | 5 != 3 | True |
> | Mayor que | 10 > 8 | True |
< | Menor que | 3 < 1 | False |
>= | Mayor o igual | 7 >= 7 | True |
<= | Menor o igual | 9 <= 5 | False |
temperatura = 78 # grados Celsius if temperatura < 40: print("🟢 Normal") elif temperatura < 70: print("🟡 Caliente") elif temperatura < 90: print("🟠 Muy caliente — revisa el servidor") else: print("🔴 CRÍTICO — apagando")
0 <= edad < 18 es válido en Python (no en todos los lenguajes). Lee: "¿está la edad entre 0 y 17?"
edad = 14 if 0 <= edad < 12: print("Niño") elif 12 <= edad < 18: print("Adolescente") else: print("Adulto")
and, or, notSirven para combinar varias pruebas lógicas en una sola. Son el "pegamento" entre condiciones.
and — LAS DOS deben ser verdaderasSi tienes dos condiciones con and, Python pide que ambas sean verdaderas para que el resultado sea True. Con que UNA sea falsa, ya es False.
| Condición A | Condición B | A and B |
|---|---|---|
| True | True | True |
| True | False | False |
| False | True | False |
| False | False | False |
nota = 75 asistencia = 90 # porcentaje if nota >= 60 and asistencia >= 80: print("✅ Aprobado (nota Y asistencia suficientes)") else: print("❌ No aprobado (falta nota o asistencia)")
or — BASTA CON UNA verdaderaCon or, si al menos una condición es verdadera, el resultado es True. Solo es False si las DOS son falsas.
| Condición A | Condición B | A or B |
|---|---|---|
| True | True | True |
| True | False | True |
| False | True | True |
| False | False | False |
es_admin = False es_mod = True if es_admin or es_mod: print("🛡️ Tiene acceso al panel") else: print("🚫 Acceso denegado")
not — INVIERTE el resultadonot es simple: convierte True en False y viceversa. Es la negación.
| Condición | not Condición |
|---|---|
| True | False |
| False | True |
bloqueado = False if not bloqueado: # not False → True print("✅ El usuario puede entrar") else: print("❌ Usuario bloqueado")
Estas dos leyes matemáticas (del lógico Augustus De Morgan, siglo XIX) te dicen cómo transformar condiciones con not:
1ª Ley: not (A and B) es igual a (not A) or (not B)
2ª Ley: not (A or B) es igual a (not A) and (not B)
En palabras simples:
• "No es (A y B)" = "No es A" o "No es B"
• "No es (A o B)" = "No es A" y "No es B"
llueve = True hay_viento = False # Estas dos condiciones son EQUIVALENTES: # (1ª Ley de De Morgan) version1 = not (llueve and hay_viento) version2 = (not llueve) or (not hay_viento) print(version1) # True print(version2) # True (misma lógica) print(version1 == version2) # True — son idénticas
and?return — ¿para qué devolver algo?return solo aparece dentro de funciones (def). Le dice a la función: "ya terminé, aquí está el resultado".
return es ese "te devuelvo el resultado".
def clasificar_nota(nota): if nota >= 90: return "Excelente 🏆" elif nota >= 70: return "Bien 👍" elif nota >= 60: return "Aprobado ✅" else: return "Reprobado ❌" # Usar la función: resultado = clasificar_nota(85) print(resultado) print(clasificar_nota(45))
return:
"Bien 👍")def doble(n): return n * 2 x = doble(5) # x = 10 y = doble(3) # y = 6 print(x + y) # 16
def doble(n): print(n * 2) # imprime pero no devuelve x = doble(5) # x = None y = doble(3) # y = None print(x + y) # ERROR: no puedes sumar None
None — la "caja vacía" de PythonNone significa literalmente "no hay nada aquí". No es 0, no es False, no es "". Es ausencia de valor.
1. Una función sin return devuelve None automáticamente.
2. Puedes asignar None explícitamente para decir "aún no sé el valor".
3. Muchas funciones de Python devuelven None cuando no encuentran algo.
# None como "valor vacío" intencional ganador = None # nadie ha ganado todavía if ganador is None: # comparar con None → usa "is", no "==" print("🏁 El torneo aún no tiene ganador") else: print(f"🏆 Ganador: {ganador}") # Función sin return → devuelve None def saludar(nombre): print(f"Hola, {nombre}!") # sin return resultado = saludar("María") print(f"La función devolvió: {resultado}") print(type(resultado))
| ¿Qué devuelve? | Tipo | ¿Es None? |
|---|---|---|
None | NoneType | Sí |
0 | int | No |
False | bool | No |
"" | str | No |
[] | list | No |
is, no con ==
Técnicamente variable == None funciona, pero la convención Python (PEP 8) dice que uses variable is None. Es más explícito y correcto.
for objeto in listaUna lista es una colección ordenada de elementos. El for te permite visitar cada uno, uno a la vez, y hacer algo con él.
Usas corchetes [] y separas los elementos con comas. Cada elemento puede ser cualquier tipo: número, texto, bool…
# Crear una lista de frutas frutas = ["manzana", "banana", "mango", "kiwi"] # Mostrar cada elemento con for for fruta in frutas: print(fruta)
for toma la lista, y en cada "vuelta" (iteración) pone el elemento actual dentro de la variable que pusiste antes del in. Puedes llamar a esa variable como quieras: fruta, elemento, item, x…
notas = [85, 42, 91, 60, 55, 78] for nota in notas: if nota >= 60: print(f"Nota {nota}: ✅ Aprobado") else: print(f"Nota {nota}: ❌ Reprobado")
alumnos = [ {"nombre": "Ana", "nota": 92}, {"nombre": "Luis", "nota": 55}, {"nombre": "Sofía", "nota": 74}, {"nombre": "Carlos", "nota": 60}, ] for alumno in alumnos: nombre = alumno["nombre"] nota = alumno["nota"] if nota >= 90: estado = "🏆 Excelente" elif nota >= 60: estado = "✅ Aprobado" else: estado = "❌ Reprobado" print(f"{nombre} ({nota}) → {estado}")
notas = [70, 40, 85, 55, 92] aprobados = [] # lista vacía donde guardaremos for nota in notas: if nota >= 60: aprobados.append(nota) # agrega solo los que pasan print("Aprobados:", aprobados) print(f"Total: {len(aprobados)} de {len(notas)}")
for que recorre → if que filtra → .append() que acumula. Este patrón lo verás en miles de programas reales.
Une todo lo que aprendiste: lista, for, if/elif/else, and, return, None.
# ────────────────────────────────────────────── # BIBLIOTECA DIGITAL — Sistema de Acceso # ────────────────────────────────────────────── def nivel_acceso(nombre, edad, membresia): """ Devuelve el nivel de acceso del usuario. Si no cumple nada → devuelve None. """ if membresia and edad >= 18: return "🌟 COMPLETO — puede descargar y leer online" elif membresia and edad < 18: return "📖 JUVENIL — puede leer online, no descargar" elif not membresia and edad >= 18: return "👁️ VISITANTE — solo puede leer resúmenes" else: return None # menor sin membresía: sin acceso # Lista de usuarios del sistema usuarios = [ {"nombre": "María", "edad": 25, "membresia": True }, {"nombre": "Pedro", "edad": 16, "membresia": True }, {"nombre": "Lucía", "edad": 32, "membresia": False}, {"nombre": "Tomás", "edad": 12, "membresia": False}, ] print("═══════════════════════════════") print(" 📚 SISTEMA BIBLIOTECA DIGITAL") print("═══════════════════════════════") for usuario in usuarios: acceso = nivel_acceso( usuario["nombre"], usuario["edad"], usuario["membresia"] ) if acceso is None: print(f"❌ {usuario['nombre']}: Sin acceso") else: print(f"✅ {usuario['nombre']}: {acceso}")
def + return para crear una función que devuelve resultadosNone cuando no hay acceso aplicableif / elif / else con múltiples condicionesand y not para combinar condicionesfor usuario in usuarios para recorrer cada registrois None para detectar ausencia de valor| Concepto | En una línea |
|---|---|
if | Ejecuta código solo si la condición es verdadera |
elif | Se prueba cuando el if anterior fue falso |
else | Se ejecuta si ninguna condición fue verdadera |
= | Asigna un valor a una variable |
== | Pregunta si dos valores son iguales |
and | Las DOS deben ser verdaderas |
or | BASTA con que una sea verdadera |
not | Invierte: verdadero ↔ falso |
return | La función entrega su resultado y termina |
None | Ausencia de valor — no es 0 ni False |
for x in lista | Recorre cada elemento de la lista |