Introducción a Python

Con temperatura = 20: se imprime "Comprobando temperatura..." y "Temperatura comprobada." — las dos líneas fuera del bloque. Las dos líneas dentro del if no se ejecutan porque la condición 20 > 30 es False. Con temperatura = 35 se ejecutan las 4 líneas.

Con nota = 4.9: ambas versiones imprimen "Suspenso" — en este caso el resultado es el mismo. Con nota = 5.0: la versión con > imprime "Suspenso" porque 5.0 > 5 es False. La versión con >= imprime "Aprobado" porque 5.0 >= 5 es True. La correcta para un sistema donde el 5.0 aprueba es >=.

Un SyntaxError detiene el programa inmediatamente y señala exactamente dónde está el problema. Es imposible ignorarlo. Un error de flujo incorrecto deja que el programa termine con normalidad — produce un resultado que parece válido pero no lo es.

En análisis de datos las consecuencias pueden ser graves: clasificar clientes incorrectamente, aplicar un descuento a quien no le corresponde, excluir registros válidos de un análisis o incluir registros que deberían filtrarse. Ninguno de estos errores produce un mensaje — solo los detectas conociendo el resultado esperado o probando casos límite.

Imprime las tres líneas: "iguales", "ambos valen 7" y "fin". La condición a == b es True porque ambas variables valen 7, así que el bloque completo se ejecuta. "fin" se imprime siempre porque está fuera del bloque.

Con temperatura = 36.8: la condición 36.8 > 37.5 es False — solo se ejecuta "Medición completada". Las dos líneas del bloque se saltan.

Con temperatura = 38.2: la condición es True — se ejecutan las tres líneas: "Fiebre detectada", "Consulta con un médico" y "Medición completada".

Es un IndentationError en la línea del primer print — le falta la indentación de 4 espacios. La segunda línea tiene indentación pero la primera no, lo que produce un error de sintaxis. La corrección:

precio = 150
if precio > 100:
    print("precio alto")
    print("aplicar descuento")

Con edad = 17: 17 >= 18 es False — solo imprime "edad registrada: 17". Con edad = 18: 18 >= 18 es True — imprime "acceso permitido" y "edad registrada: 18". Con edad = 65: igual que el caso 18 — imprime ambas líneas.

Con múltiples if: evalúa las tres condiciones. Con elif: evalúa solo la primera — 10 < 20 es True y se detiene. Ambas versiones imprimen "x es menor que y" — el resultado es el mismo pero el camino es distinto.

Con nota = 85 imprime "Notable" — la primera condición verdadera es 85 >= 70. El resto no se evalúa.

Si pones >= 50 primero, con nota = 85 imprimiría "Aprobado" — incorrecto. Porque 85 >= 50 es True y el elif se detiene ahí sin llegar al >= 70.

Con valor = 85 se imprimen dos líneas: "supera la mitad" y "supera el umbral alto" — las dos primeras condiciones son True y como son if independientes, ambas se ejecutan. Con elif solo se imprimiría la primera "supera la mitad" y las demás se saltarían — resultado incorrecto para este caso.

El error está en el orden de condiciones. Con temperatura = 38 la primera condición 38 > 36 es True — imprime "temperatura normal" cuando debería imprimir "fiebre leve". Las condiciones de fiebre nunca se alcanzan porque la primera es demasiado amplia. La corrección: ordenar de más restrictivo a menos restrictivo.

if temperatura > 39:
    print("fiebre alta")
elif temperatura > 37.5:
    print("fiebre leve")
elif temperatura > 36:
    print("temperatura normal")
else:
    print("hipotermia")

Cuando Python llega al elif score >= 70, sabe implícitamente que score < 90 — porque si fuera 90 o más, habría entrado en el if score >= 90 y no habría llegado hasta aquí. Por eso no es necesario escribir score >= 70 and score < 90 — la condición del límite superior está implícita en la estructura del elif.

Sí, los resultados coinciden en todos los casos — ambas versiones son lógicamente equivalentes. Con score = 90: "Sobresaliente". Con score = 69: "Aprobado". Con score = 50: "Aprobado".

saldo = 500
importe = 200

if saldo > 0 and saldo >= importe:
    print("Transferencia aprobada")
elif saldo > 0:
    print("Saldo insuficiente")
else:
    print("Cuenta en negativo")

La versión plana es más fácil de leer de un vistazo — el flujo es lineal sin saltos de indentación. Nótese que saldo > 0 and saldo >= importe podría simplificarse a saldo >= importe si el importe siempre es positivo, porque un saldo suficiente para cubrir el importe implica que es mayor que 0.

El código es correcto — el orden de condiciones es el adecuado: de menor a mayor, usando < como frontera. Con imc = 27.5: 27.5 < 18.5 es False, 27.5 < 25 es False, 27.5 < 30 es True → imprime "Sobrepeso". La lógica es correcta y el orden es el esperado — este es un ejemplo de código generado por IA que está bien escrito.

3 == 3.0 → True: Python compara valores, no tipos — el entero 3 y el float 3.0 son iguales. 3 is 3.0 → False: son objetos distintos en memoria. "Python" == "python" → False: sensible a mayúsculas. "Python".lower() == "python" → True: normalizado. 10 != 10.0 → False: son iguales en valor.

"10" < "9" compara carácter a carácter: '1' tiene código Unicode menor que '9', por eso es True. 10 < 9 compara valores numéricos — es False.

La consecuencia práctica es grave: si un CSV tiene una columna de precios cargada como strings, "100" < "20" es True — el filtrado producirá resultados incorrectos sin ningún mensaje de error. Siempre hay que convertir a número antes de comparar: int(precio_str) < 20.

ventas = umbral dentro del if es un SyntaxError — Python no permite asignación en una condición de esta forma. El error es haber escrito = en lugar de ==. La corrección:

if ventas == umbral:
    print("ventas exactamente en umbral")
else:
    print("ventas distintas del umbral")

Produce un TypeError: no se pueden comparar un string y un entero con >. La corrección es convertir el string a número antes de comparar:

precio = int(precio_str)   # o float() si tiene decimales
if precio > 50:
    print("precio alto")
else:
    print("precio bajo")

a < b and b < c → True: ambas son verdaderas. a > b or c > b → True: la segunda es verdadera. not a == b → True: 5 == 10 es False, negado es True. a < b and b > c or c == 15 → True: se evalúa como (a < b and b > c) or c == 15 → False or True → True. a < b and (b > c or c == 15) → True: True and True.

Con x = 0, Python evalúa x != 0 primero — es False. Como es and, si la primera condición es False el resultado no puede ser True sin importar la segunda. Python se detiene y no evalúa 100 / x — el ZeroDivisionError nunca ocurre. Sin cortocircuito, Python evaluaría las dos condiciones siempre y la división por cero detendría el programa con un error.

Con precio = -5: la primera condición precio > 0 es False — el and cortocircuita y no evalúa el resto. El bloque del if no se ejecuta. El primer elif — precio <= 0 es True — imprime "error: precio no puede ser negativo o cero".

dia = "sábado"
if dia in {"sábado", "domingo"}:
    print("fin de semana")
else:
    print("día laborable")

La ventaja de in escala mucho mejor — si tuvieras diez valores posibles, la versión con or requeriría diez comparaciones explícitas. Con in solo cambias el contenido del set. Además la verificación de pertenencia en un set es O(1) — independientemente de cuántos valores tenga.

bool(0) → False: cero es falsy. bool("False") → True: string no vacío — aunque diga "False", es truthy. bool([]) → False: lista vacía. bool([None]) → True: lista con un elemento — aunque sea None, la lista no está vacía. bool({}) → False: diccionario vacío. bool({0: "cero"}) → True: diccionario con un elemento.

Con valor = 0: la versión truthy no imprime nada — 0 es falsy. La versión is not None sí imprime — 0 no es None.

La diferencia importa cuando 0 es un valor válido en tus datos — por ejemplo, ventas de cero unidades. Si usas la versión truthy, tratarás el cero como "sin datos" cuando en realidad es un dato válido. En ese caso la forma correcta es valor is not None.

datos es una lista vacía — falsy. La primera condición del and es False — cortocircuita y no evalúa el resto. El bloque if no se ejecuta. El primer elif not datos es True — imprime "sin datos".

El elif not config["umbral"] nunca se alcanza en este caso. Si datos = [1, 2, 3], entonces pasaría al siguiente elif porque config["umbral"] es 0 — falsy — e imprimiría "umbral en cero".

if lista:          # en lugar de len(lista) > 0
    ...
if nombre:         # en lugar de nombre != ""
    ...
if valor is None:  # en lugar de valor == None
    ...
if activo:         # en lugar de activo == True
    ...

Si la lista está vacía, acceder a lista[0] produce un IndexError que detiene el programa. La forma más concisa de escribir la guardia es:

if lista:
    print(lista[0])

Aprovecha que una lista vacía es falsy — es más conciso que if len(lista) > 0 y produce exactamente el mismo resultado.

pedido = "pera": "pera" in inventario es True. inventario["pera"] > 0 es False — el stock es 0. El primer bloque no se ejecuta. El elif — "pera" in inventario es True — imprime "pera agotado".

La Forma A es más explícita — primero verifica, luego accede. Útil cuando quieres distinguir entre "la clave no existe" y "la clave existe pero vale None".

La Forma B es más compacta — usa get() que devuelve None si la clave no existe, y luego verifica ese None. Pero si el valor legítimo del campo puede ser None, no distingue entre "clave ausente" y "clave presente con valor None". En ese caso la Forma A es más segura.

Dos problemas: primero, registros[0] falla si la lista está vacía. Segundo, r["nota"] lanza KeyError en el registro de Bob que no tiene la clave "nota". La versión corregida:

if not registros:
    print("sin registros")
else:
    # solo comparar registros que tienen nota
    con_nota = [r for r in registros if "nota" in r]
    if con_nota:
        mejor = max(con_nota, key=lambda r: r["nota"])
        print(f"mejor alumno: {mejor['nombre']}")

El if de Python evalúa una condición sobre un único valor y decide si ejecutar un bloque o no. El filtrado booleano de pandas evalúa una condición sobre toda una columna a la vez.

df["ventas"] > 100 devuelve una Serie booleana — una columna de True y False para cada fila. df[df["ventas"] > 100] usa esa Serie como máscara y devuelve un DataFrame con solo las filas donde el valor es True.

Primer filtro — precio menor que 1.0 and ventas mayor que 50: pera (0.90, 80) y naranja (0.80, 120).

Segundo filtro — categoría fruta or ventas igual a 0: manzana, pera, fresa (frutas) y kiwi (ventas = 0).

Tercer filtro — not activo: solo kiwi, que tiene activo = False.

and en Python opera sobre valores escalares — devuelve uno de los dos operandos. En pandas, la condición es una Serie de muchos valores — Python no sabe cómo aplicar and a una Serie entera y lanza un ValueError: "The truth value of a Series is ambiguous". Con & pandas aplica la operación elemento a elemento sobre toda la Serie — que es exactamente lo que queremos.

El código es correcto en lógica pero puede fallar si df_validos está vacío — mean() sobre un DataFrame vacío devuelve NaN, no un error, pero el :.2f del f-string puede producir resultados confusos. La versión con guardia:

df_validos = df[(df["activo"]) & (df["ventas"] > 0)]
if df_validos.empty:
    print("sin productos válidos para calcular media")
else:
    media = df_validos["precio"].mean()
    print(f"precio medio: {media:.2f}€")

case _ es el caso por defecto — captura cualquier valor que no coincidió con ningún case anterior. No es obligatorio. Si el valor no coincide con ningún case y no hay case _, Python simplemente no ejecuta ningún bloque y continúa — sin error, sin aviso. Es recomendable incluirlo siempre para manejar valores inesperados.

Con codigo = 403: coincide con case 401 | 403 → imprime "acceso denegado". Con codigo = 301: coincide con case 301 | 302 → imprime "redirección".

rol = "editor"

match rol:
    case "admin":
        print("acceso total")
    case "editor" | "moderador":
        print("acceso parcial")
    case "lector":
        print("solo lectura")
    case _:
        print("rol no reconocido")

La versión match/case es más limpia — elimina la repetición de rol == en cada línea y el or se convierte en el más conciso |.

match/case compara contra valores fijos concretos — no puede expresar rangos como imc < 18.5 o 18.5 <= imc < 25. Para rangos numéricos la estructura correcta es if/elif/else con operadores de comparación, ordenando las condiciones de más restrictivo a menos restrictivo como vimos en la Parte II.

# A
acceso = "permitido" if edad >= 18 else "denegado"

# B — aún más conciso
alerta = temperatura > 37.5
# La comparación ya devuelve True/False directamente
# No hace falta el ternario en este caso

El caso B es interesante: cuando el resultado del ternario es True o False, casi siempre puedes simplificarlo a la comparación directa — alerta = temperatura > 37.5 es equivalente y más conciso.

Con x = 0: "cero". Con x = 5: "positivo". Con x = -3: "negativo".

El código funciona pero no es legible — hay que seguir el encadenamiento mentalmente para entenderlo. La versión más clara:

if x == 0:
    resultado = "cero"
elif x > 0:
    resultado = "positivo"
else:
    resultado = "negativo"

El ternario de Python opera sobre un único valor escalar — devuelve uno de los dos valores según la condición. np.where() opera sobre una Serie o columna entera — aplica la misma lógica a cada elemento de la columna y devuelve una Serie con los resultados.

Usa el ternario de Python cuando trabajas con un valor simple. Usa np.where() cuando quieres crear una columna nueva en un DataFrame basada en una condición sobre otra columna.

El ternario anidado funciona pero está en el límite de la legibilidad — tres casos con ternarios encadenados requieren esfuerzo para seguirlos. Con gasto = 450: 450 >= 500 es False → evalúa el segundo: 450 >= 200 es True → resultado: "medio".

Para este caso con tres segmentos la versión más legible es if/elif/else:

if gasto >= 500:
    segmento = "premium"
elif gasto >= 200:
    segmento = "medio"
else:
    segmento = "básico"

La condición de stock debe ir primera — es la más restrictiva y excluye completamente la lógica de ventas. Si la condición de ventas fuera primera, naranja (ventas=60, stock=0) recibiría "bajo rendimiento" en lugar de "agotado". El orden correcto es: primero la excepción (stock = 0), luego las reglas generales.

Debería usar >= para el umbral de 150 — el kiwi con exactamente 150 ventas debería recibir "alto rendimiento". Con > recibiría "rendimiento medio" — error silencioso en el caso límite. El resultado esperado: manzana → alto, pera → medio, naranja → agotado, kiwi → alto, fresa → agotado.

La IA probablemente usará una lista de diccionarios — es la estructura más natural para representar registros con campos nombrados. También puede usar una lista de tuplas o directamente un DataFrame de pandas. Las tres opciones son válidas — la más legible para este caso es la lista de diccionarios o el DataFrame.

not nombre y nombre == "" no son completamente equivalentes: not nombre también detecta None como nombre vacío, mientras que nombre == "" solo detecta el string vacío. En datos reales donde el nombre puede ser None, not nombre es más robusto.

La condición "nota fuera del rango 0-10" se expresa como nota < 0 or nota > 10. La forma con comparación encadenada sería la negación: not (0 <= nota <= 10). La IA probablemente usará or — es la más directa.

Para mostrar solo el primer error, debe usar if/elif/else — que se detiene en el primer True. Con múltiples if independientes, un registro con nombre vacío y nota incorrecta mostraría los dos errores. El resultado esperado: Ana → aprobado, registro vacío → error nombre, Bob → error nota, Carlos → inactivo, Diana → suspenso.

Ambas opciones son válidas. match/case con agrupación de extensiones es más limpio para este caso porque compara un valor fijo contra múltiples opciones concretas. if/elif con in — if ext in {"csv", "tsv"} — también es correcto y quizás más familiar para la IA. Las dos soluciones son aceptables.

Usará nombre.split(".")[-1] para extraer la extensión — el último elemento al separar por punto. O el método os.path.splitext(nombre)[1] que es más robusto para nombres con varios puntos. Para normalizar a minúsculas: .lower() antes de comparar.

Aplicando .lower() a la extensión antes de comparar, "CSV" se convierte en "csv" y "JPG" en "jpg" — ambos clasificados correctamente. "parquet" no está en ninguna categoría → "desconocido".

Para tres categorías la IA probablemente usará np.where() anidado:

df["rendimiento"] = np.where(
    df["ventas"] >= 150, "alto",
    np.where(df["ventas"] >= 80, "medio", "bajo")
)

O puede usar pd.cut() que es más elegante para rangos. Ambas son correctas.

Para "precio_ajustado" con dos casos usará np.where() simple. El filtro combinado debe usar & con paréntesis:

df_filtrado = df[
    (df["activo"]) &
    (df["categoria"] == "fruta") &
    (df["ventas"] > 0)
]

Con los datos de ejemplo pasan el filtro: manzana, pera y fresa. Naranja es cítrico, kiwi está inactivo y tiene ventas cero.