Introducción a Python

Primer bucle: 2, 4, 6. Segundo bucle: HOLA — cada carácter en mayúscula, sin espacios por el end="", con salto de línea al final por el print() suelto. Tercer bucle: total = 10 — suma de 1+2+3+4.

range(5) → [0, 1, 2, 3, 4]. range(2, 8) → [2, 3, 4, 5, 6, 7]. range(0, 20, 4) → [0, 4, 8, 12, 16]. range(10, 0, -2) → [10, 8, 6, 4, 2].

precios = [12.5, 8.0, 15.3, 9.7]
for precio in precios:
    print(f"precio: {precio:.2f}€")

La versión sin índice es más corta, más legible y no puede producir un IndexError por error en el rango. El nombre precio (singular) en lugar de precios (plural) es la convención habitual — la variable del bucle es un elemento de la colección.

total = 0
for n in range(1, 100, 2):
    total += n
print(total)   # 2500

range(1, 100, 2) genera los impares del 1 al 99. El stop es 100 — exclusivo — así que el último valor incluido es 99. Más conciso aún: sum(range(1, 100, 2)) — una sola línea sin bucle explícito.

Primer bucle: Color 1: rojo, Color 2: verde, Color 3: azul. Segundo bucle: 1 x, 2 y — solo dos pares porque b tiene dos elementos. El 3 de a no tiene par y se descarta.

zip() se detiene cuando el iterable más corto se agota — no produce un error, simplemente descarta los elementos sobrantes del más largo. Si las listas de nombres y notas tuvieran distinta longitud, algunos alumnos no tendrían nota o algunas notas no tendrían alumno — silenciosamente, sin aviso.

alumnos = ["Ana", "Bob", "Carlos", "Diana"]
for i, alumno in enumerate(alumnos, start=1):
    print(f"Alumno {i}: {alumno}")

La versión con enumerate elimina el i+1 — el ajuste manual del índice desaparece porque start=1 lo gestiona directamente.

productos  = ["manzana", "pera", "naranja", "kiwi"]
precios    = [1.20, 0.90, 0.80, 1.50]
cantidades = [150, 80, 120, 40]

for prod, precio, cantidad in zip(productos, precios, cantidades):
    ingreso = precio * cantidad
    print(f"{prod:10} {ingreso:.2f}€")

# manzana    180.00€
# pera        72.00€
# naranja     96.00€
# kiwi        60.00€

Con break: imprime 0 1 2 — cuando i == 3 el bucle se detiene antes de imprimir el 3. Con continue: imprime 0 1 2 4 5 — cuando i == 3 salta esa iteración pero continúa con 4 y 5.

Con [None, None, None]: no imprime nada — todos los elementos son falsy y el continue salta todos. Con ["Ana"]: imprime una línea: "procesando: Ana".

El else se ejecuta cuando el bucle termina sin break. Con valores = [2, 4, 6, 8] ningún valor es impar — el bucle recorre todos los elementos sin ejecutar el break → el else se ejecuta → imprime "todos son pares".

El problema es que el código no se detiene al encontrar el primer precio alto — sigue recorriendo toda la lista y guarda el último precio que supera el umbral, no el primero. Con break y else:

precios = [12.5, 8.0, 15.3, 9.7, 11.2]
umbral = 14.0

for p in precios:
    if p > umbral:
        print(f"primer precio alto: {p}")
        break
else:
    print("ningún precio supera el umbral")

Tienen __iter__: lista, tupla, string, range, dict y set. No lo tienen: int y float. El error al intentar recorrer un float es el mismo que con int: TypeError: 'float' object is not iterable. El mensaje es exactamente el mismo patrón — el nombre del tipo cambia pero la causa es la misma: el objeto no tiene __iter__().

it = iter("datos")
print(next(it))   # 'd'
print(next(it))   # 'a'
print(next(it))   # 't'
print(next(it))   # 'o'
print(next(it))   # 's'
print(next(it))   # StopIteration

El tipo del iterador es str_iterator. La sexta llamada lanza StopIteration porque el string tiene exactamente 5 caracteres y el iterador los ha entregado todos.

Imprime: 10, 20, 30, 10, 20, 30.

El primer next(it) consume el 10. El for x in it continúa desde donde quedó el iterador — imprime 20 y 30. El segundo for x in nums itera sobre el iterable original — que sigue intacto — creando un nuevo iterador desde el inicio.

La lista ocupa alrededor de 8 millones de bytes (≈8 MB). El range ocupa 48 bytes — independientemente del tamaño del rango.

Si necesitas generar índices para iterar sobre un DataFrame de un millón de filas, range(len(df)) ocupa 48 bytes mientras que list(range(len(df))) ocupa 8 MB. En general, usa range siempre que solo necesites recorrer los valores — no almacenarlos.

Imprime: 1 2 4 8 16 32 fin. La condición es n <= 32 — cuando n vale 32 todavía se imprime porque la condición es verdadera. En la siguiente iteración n pasa a 64 y la condición es falsa — sale del bucle e imprime "fin".

Falta actualizar i dentro del bucle — es un bucle infinito. La condición i <= 10 siempre es True porque i nunca cambia. El programa se quedaría colgado sumando 1 para siempre. La corrección:

total = 0
i = 1
while i <= 10:
    total += i
    i += 1   # ← faltaba esta línea
print(total)   # 55

Recorrer una lista de productos → for: iterable conocido, número de iteraciones fijo.

Esperar hasta que el stock baje de un umbral → while: la condición de parada depende de lo que ocurre durante la ejecución, no se sabe cuántas iteraciones habrá.

Suma de los primeros 100 números → for con range(1, 101): el rango es conocido. También se puede con sum(range(1, 101)) sin ningún bucle explícito.

Procesar hasta encontrar un error → while o for con break: si la lista es conocida, for con break es más claro. Si los registros llegan de forma continua (stream), while.

Iteración 1: acum = 8, idx = 1 — condición: 8 > 20 es False, 1 >= 5 es False → continúa. Iteración 2: acum = 11, idx = 2 → continúa. Iteración 3: acum = 26, idx = 3 — condición: 26 > 20 es True → break.

Imprime: acumulado: 26, iteraciones: 3. Se ejecutaron 3 iteraciones.

Imprime: 1 2 4 5. i = 3: múltiplo de 3 → continue — no imprime. i = 6: múltiplo de 3 → continue — no imprime. i = 7: 7 > 6 → break — sale del bucle. Los valores 3, 6 y 7 no se imprimen.

El else del while se ejecuta cuando el bucle termina de forma natural — sin break. Si la contraseña correcta fuera "clave_incorrecta", ningún intento coincidiría, el bucle recorrería los tres intentos sin ejecutar el break y el else imprimiría "acceso bloqueado — demasiados intentos".

Falta incrementar i dentro del bucle — es un bucle infinito. Siempre suma valores[0] porque i nunca cambia. La corrección:

valores = [5, 10, 15, 20]
total = 0
i = 0
while i < len(valores):
    total += valores[i]
    print(f"acumulado: {total}")
    i += 1   # ← faltaba esta línea
print(f"total: {total}")

Sí hay riesgo: si ningún valor de datos es mayor que 8, el bucle nunca ejecuta el break. Peor aún: cuando i supera el índice válido de la lista, produce un IndexError — no un bucle infinito, pero sí un error no controlado. La versión segura:

datos = [3, 7, 2, 9, 1, 5]
i = 0
while i < len(datos):   # guardia contra IndexError
    valor = datos[i]
    print(f"procesando: {valor}")
    i += 1
    if valor > 8:
        break
else:
    print("ningún valor superó el umbral")

Imprime: café: 2.50€ y zumo: 3.20€. El té tiene precio 1.80 que no supera 2.0 — se salta.

El bloque más interno se ejecuta 3 × 4 = 12 veces. Imprime 12. Para cada valor de i (0, 1, 2), el bucle interior recorre los 4 valores de j (0, 1, 2, 3) — sumando 1 en cada iteración.

notas = {
    "Ana":    [8.5, 7.0, 9.0],
    "Bob":    [6.5, 7.5, 6.0],
    "Carlos": [9.5, 8.0, 9.0],
}

mejor = None
mejor_media = 0

for alumno, lista_notas in notas.items():
    media = sum(lista_notas) / len(lista_notas)
    print(f"{alumno}: {media:.2f}")
    if media > mejor_media:
        mejor_media = media
        mejor = alumno

print(f"\nmejor media: {mejor} ({mejor_media:.2f})")

Carlos tiene la nota media más alta: 8.83. Ana tiene 8.17 y Bob 6.67.

El código es correcto — recorre todos los elementos y actualiza el máximo cuando encuentra uno mayor. El resultado es 9. La forma más concisa:

# Con max() y una lista aplanada
maximo = max(max(fila) for fila in matriz)
print(f"máximo: {maximo}")

# O aplanando primero
todos = [v for fila in matriz for v in fila]
print(f"máximo: {max(todos)}")

Un for directamente sobre un DataFrame itera sobre los nombres de columna — devuelve strings. iterrows() itera sobre las filas — devuelve tuplas (índice, Serie) donde el índice es un entero o el índice del DataFrame y la Serie contiene los valores de esa fila con los nombres de columna como índice.

for idx, fila in df.iterrows():
    if fila["categoria"] == "fruta":
        print(f"{fila['producto']}: {fila['ventas']} uds — {fila['precio']:.2f}€")

Imprime manzana y pera — los dos productos de categoría fruta. Naranja es cítrico y kiwi es exótico — se saltan.

Precio con IVA → vectorizado: df["precio"] * 1.21 — operación simple sobre toda la columna.

Lógica compleja con muchas condiciones anidadas → iterrows(): cuando la vectorización requeriría muchos np.where() anidados difíciles de leer.

Filtrar filas con ventas > 100 → vectorizado: df[df["ventas"] > 100] — filtrado booleano directo.

Imprimir resumen para depurar → iterrows(): cuando necesitas ver cada fila con formato personalizado durante el desarrollo.

El código es correcto pero ineficiente. La forma vectorizada es mucho más concisa y rápida:

# Vectorizado — una línea
total = (df["ventas"] * df["precio"]).sum()
print(f"total: {total:.2f}€")

# A
resultado = [x ** 3 for x in range(1, 6)]

# B
mayus = [n.capitalize() for n in nombres]

# C
ingresos = [v * 1.20 for v in ventas]

[x * 2 for x in range(5)] → [0, 2, 4, 6, 8]. [c.upper() for c in "hola"] → ['H', 'O', 'L', 'A']. [len(p) for p in ["uno", "dos", "tres"]] → [3, 3, 4]. [(x, x**2) for x in range(1, 4)] → [(1, 1), (2, 4), (3, 9)].

No deberías usar una comprehension para imprimir porque las comprehensions son para construir listas, no para efectos secundarios. [print(x) for x in [1,2,3]] imprime los valores — eso es correcto — pero devuelve [None, None, None] porque print() devuelve None. La lista resultante no tiene ninguna utilidad y confunde al lector. Para efectos secundarios usa siempre un for normal.

El código es correcto pero difícil de leer — combina un filtro if y un ternario if/else en una sola línea densa. La versión más legible en varias líneas:

resultado = [
    x**2 if x % 2 == 0 else x**3
    for x in datos
    if x > 3
]
print(resultado)
# filtra x > 3: [7, 9, 4, 6, 8]
# pares → cuadrado, impares → cubo
# [343, 729, 16, 36, 64]

a filtra — solo los pares: longitud 3, [2, 4, 6]. b transforma — pares quedan igual, impares se convierten en 0: longitud 6, [0, 2, 0, 4, 0, 6].

disponibles = [p["nombre"] for p in productos
               if p["stock"] > 0]
print(disponibles)   # ['manzana', 'kiwi']

La comprehension es más concisa y comunica claramente la intención: "nombres de los productos con stock positivo".

Para cada par (x, y) con x, y ∈ {1, 2, 3} donde x ≠ y: (1,2)=2, (1,3)=3, (2,1)=2, (2,3)=6, (3,1)=3, (3,2)=6. Resultado: [2, 3, 2, 6, 3, 6]. Se excluyen los casos donde x == y: (1,1), (2,2), (3,3).

El código es correcto — produce ['normal', 'fiebre', 'normal', 'fiebre alta', 'normal']. Pero no es legible — el ternario anidado en una sola línea larga requiere esfuerzo para seguirlo. La versión más legible:

resultado = [
    "fiebre alta" if t > 39
    else "fiebre"   if t > 37.5
    else "normal"
    for t in temps
]
print(resultado)

resultado = {p: v for p, v in zip(productos, ventas)}
print(resultado)
# {'manzana': 150, 'pera': 80, 'naranja': 200, 'kiwi': 95}

Aún más conciso sin comprehension: dict(zip(productos, ventas)) — cuando el caso es tan simple, la comprehension no añade claridad.

aprobados = {
    nombre: round(nota, 1)
    for nombre, nota in notas.items()
    if nota >= 5
}
print(aprobados)
# {'Ana': 8.6, 'Carlos': 7.9, 'Eva': 6.2}

Produce la frecuencia de cada letra única en "mississippi": {'m': 1, 'i': 4, 's': 4, 'p': 2} — aunque el orden puede variar porque viene de un set.

Se usa set(texto) en lugar de texto para iterar solo sobre las letras únicas — si iteraras sobre texto directamente calcularías texto.count(c) 11 veces en lugar de 4, repitiendo el cálculo para cada aparición de cada letra.

No es correcto siempre. Con original = {"a": 1, "b": 2, "c": 1} los valores 1 aparecen dos veces — en "a" y en "c". Al invertir, la clave 1 solo puede tener un valor: el último que se procesa gana. Imprime {1: "c", 2: "b"} — la clave "a" se pierde silenciosamente.

El Bloque A construye un diccionario con los productos como claves y sus ingresos como valores: {'manzana': 180.0, 'pera': 72.0, 'naranja': 96.0, 'kiwi': 300.0, 'fresa': 190.0}.

Sin mejor is None, la primera iteración intentaría evaluar ingresos[mejor] con mejor = None — KeyError. El mejor is None actúa como guardia — la primera iteración siempre asigna el primer producto sin necesidad de comparar.

destacados contiene los productos con ingreso mayor de 150: ['manzana', 'kiwi', 'fresa'] — manzana 180, kiwi 300, fresa 190. Pera (72) y naranja (96) no pasan el filtro.

Fresa con 190€ → "alto" porque 190 > 150. Pera con 72€ → "bajo" porque no supera 150 ni 80.

El Bloque E ordena los productos por ingreso descendente e imprime el ranking con posición, nombre, etiqueta e ingreso:

  1. kiwi       [alto]  300.00€
  2. fresa      [alto]  190.00€
  3. manzana    [alto]  180.00€
  4. naranja    [medio]  96.00€
  5. pera       [bajo]   72.00€

Terminan en validos: Ana López (8.5), Diana Ruiz (4.5) y Eva Martín (7.8) — 3 registros. Terminan en errores: registro 2 (nombre vacío), registro 3 (nota 11 fuera de rango), registro 4 (Carlos inactivo) — 3 errores.

i se incrementa al inicio del bucle — antes de los continue. El registro con nombre vacío es el segundo de la lista pero cuando se añade el error, i ya vale 2. Por eso el mensaje es "registro 2: nombre vacío".

Se ordenan por nota descendente — Eva (7.8) primera, Ana (8.5) primera en realidad:

  1. Ana López      8.5 ✓
  2. Eva Martín     7.8 ✓
  3. Diana Ruiz     4.5 ✗

sum(n for _, n in validos) suma las notas de los alumnos válidos: 8.5 + 4.5 + 7.8 = 20.8. La media es 20.8 / 3 = 6.93. (n for _, n in validos) es un generador — un iterador perezoso que produce valores uno a uno sin crear una lista en memoria. Es el concepto que conecta con yield de la Clase 6.

El texto tiene 8 palabras pero solo 7 únicas — "python" aparece dos veces. freq tiene 7 claves. Solo "python" tiene valor 2.

top3 contiene las tres palabras más frecuentes: ["python", ...] — "python" primero con 2, el resto con 1 en orden arbitrario. Se usa _ para ignorar la cuenta — solo nos interesa el nombre de la palabra.

El Bloque D extrae todas las consonantes únicas del texto en orden alfabético. El primer for recorre las palabras, el segundo recorre las letras de cada palabra, el if filtra las vocales. El set() elimina duplicados y sorted() ordena alfabéticamente.

El else del while se ejecuta cuando el bucle termina sin break. En este caso la lista ordenada empieza con "python" (cuenta 2) — se imprime. El siguiente tiene cuenta 1 → break. El else no se ejecuta. Imprime solo: E: 'python' aparece 2 veces.