Python · Lección 17 de 27

For (bucle de iteración)

El bucle for es la estructura de repetición más usada en Python. Recorre cualquier colección — listas, strings, diccionarios, rangos — ejecutando un bloque para cada elemento. Es tu herramienta principal para procesar datos.

90–110 min Prerrequisitos: 08 Listas, 10 Diccionarios, 16 While

Concepto teórico

¿Qué es el bucle for?

El for de Python es diferente al de otros lenguajes. No es un for clásico de C (for(i=0; i). Es un for-each: recorre cada elemento de un iterable (cualquier objeto que se pueda recorrer) y ejecuta el bloque una vez por cada elemento.



      for elemento in iterable:
    # se ejecuta una vez por cada elemento
    hacer_algo(elemento)

      ¿Qué es un iterable? Cualquier cosa que Python pueda recorrer: listas, tuplas, strings,
        diccionarios, sets, ranges, archivos, generadores. Básicamente, si podés poner algo después de in,
        es un iterable.

      Diferencia clave con while: en un while, vos controlás la
        condición de salida (y podés generar loops infinitos). En un for, Python sabe exactamente cuántos
        elementos tiene el iterable y para solo cuando los recorrió todos. No hay riesgo de loop infinito con for
        (excepto con generadores infinitos, algo avanzado).

      range() — generar secuencias numéricas

      Cuando necesitás repetir algo N veces o generar una secuencia de números, usás range():

      
        
          
            Sintaxis
            Genera
            Ejemplo
          
          
            range(n)
            0, 1, 2, ..., n-1
            range(5) → 0,1,2,3,4
          
          
            range(a, b)
            a, a+1, ..., b-1
            range(3, 8) → 3,4,5,6,7
          
          
            range(a, b, paso)
            a, a+paso, ...
            range(0, 20, 5) → 0,5,10,15
          
          
            range(b, a, -1)
            b, b-1, ..., a+1
            range(5, 0, -1) → 5,4,3,2,1
          
        
      

      Error común: range(1, 5) genera 1, 2, 3, 4 — NO incluye el 5.
        El límite superior siempre está excluido, igual que en slicing. Si querés 1 a 5 inclusive, usá
        range(1, 6).
      

      For sobre distintos iterables

      
        Lista: for item in lista: — recorre cada elemento
        String: for char in "hola": — recorre cada carácter (h, o, l, a)
        Diccionario: for k in dict: recorre claves. for k, v in dict.items():
          recorre pares.
        Set: for elem in mi_set: — recorre elementos (orden impredecible)
        Tupla: for elem in tupla: — igual que lista
        Range: for i in range(10): — números del 0 al 9
      

      Patrones esenciales: enumerate, zip, unpacking

      Ya los viste en lecciones anteriores, pero acá los consolidamos como los tres compañeros inseparables del for:
      

      
        enumerate(iterable, start=0) — te da (índice, elemento) en cada iteración. NUNCA uses
          for i in range(len(lista)): cuando podés usar enumerate.
        
        zip(iter1, iter2, ...) — recorre múltiples iterables en paralelo. Para cuando los datos
          están repartidos en listas separadas.
        Unpacking en for: for nombre, score in lista_de_tuplas: — desempaquetá directamente en
          el for.
      

      break, continue y for/else

      break y continue funcionan igual que en while. Pero for tiene un extra exclusivo:
        else.
      

      for/else: el bloque else se ejecuta solo si el for terminó sin break.
        Si hubo break, else NO se ejecuta. Es útil para búsquedas: "si encontré algo, break; si no encontré nada, el
        else se activa".

      for cliente in clientes:
    if cliente["score"] > 800:
        print(f"Premium encontrado: {cliente['nombre']}")
        break
else:
    print("Ningún cliente premium")

      Tip sobre for/else: leelo como "for ... si no hubo break, else ...". Es un
        patrón poco conocido pero muy elegante para búsquedas. En la práctica, la mayoría de la gente usa una variable
        flag (encontrado = False/True) en su lugar, pero for/else es más pythónico.

      En análisis de datos: el for es la base de TODA iteración sobre datos.
        Cada df.apply(), cada df.iterrows(), cada comprehension, cada map() y
        cada filter() son internamente un for. Dominar el for básico te da la base para entender las
        abstracciones de pandas.

      02
      Ejemplos explicados paso a paso

      Ejemplo 1: For sobre distintos iterables

      
        ejemplo_01_iterables.pyPython
        
          
# For sobre LISTA
print("=== Lista ===")
frutas = ["manzana", "banana", "naranja"]
for f in frutas:
    print(f"  🍎 {f}")

# For sobre STRING (cada carácter)
print("\n=== String ===")
cuit = "20-12345678-9"
digitos = 0
for char in cuit:
    if char.isdigit():
        digitos += 1
print(f"  CUIT: {cuit} tiene {digitos} dígitos")

# For sobre DICCIONARIO
print("\n=== Diccionario ===")
cotizaciones = {"USD": 1150, "EUR": 1250, "BRL": 230}
for moneda, precio in cotizaciones.items():
    print(f"  {moneda}: ${precio:,}")

# For sobre RANGE
print("\n=== Range ===")
for i in range(1, 6):
    print(f"  Cuota {i}/5")

# For sobre SET (orden impredecible)
print("\n=== Set ===")
ciudades = {"BsAs", "Córdoba", "Rosario", "Mendoza"}
for c in ciudades:
    print(f"  📍 {c}")
        
        
        Hacé clic en ▶ Ejecutar
      

      Ejemplo 2: range() en profundidad

      
        ejemplo_02_range.pyPython
        
          
# range(n): 0 a n-1
print("range(5):", list(range(5)))

# range(inicio, fin): inicio a fin-1
print("range(3, 8):", list(range(3, 8)))

# range(inicio, fin, paso)
print("range(0, 50, 10):", list(range(0, 50, 10)))
print("range(100, 0, -20):", list(range(100, 0, -20)))

# Caso real: generar IDs de factura
print("\n=== Facturas ===")
for num in range(1, 6):
    print(f"  FAC-2025-{num:05d}")

# Caso real: tabla de interés compuesto
capital = 100000
tasa = 0.05
print(f"\n{'Mes':>4} {'Saldo':>14}")
print(f"{'─'*20}")
saldo = capital
for mes in range(1, 13):
    saldo *= (1 + tasa)
    if mes <= 4 or mes == 12:
        print(f"  {mes:>2}  ${saldo:>11,.0f}")
    elif mes == 5:
        print(f"  ...")

# Pares del 2 al 20
pares = list(range(2, 21, 2))
print(f"\nPares: {pares}")
        
        
        Hacé clic en ▶ Ejecutar
      

      Ejemplo 3: enumerate y zip — los mejores amigos del for

      
        ejemplo_03_enum_zip.pyPython
        
          
clientes = ["García", "López", "Martínez", "Pérez", "Fernández"]
scores = [720, 680, 590, 810, 645]
saldos = [150000, 320000, 45000, 890000, 72000]

# enumerate: índice + valor
print("=== Con enumerate ===")
for i, nombre in enumerate(clientes, start=1):
    print(f"  {i}. {nombre}")

# zip: combinar listas en paralelo
print("\n=== Con zip ===")
for nombre, score in zip(clientes, scores):
    estado = "✅" if score >= 650 else "❌"
    print(f"  {estado} {nombre}: {score}")

# enumerate + zip: el combo completo
print("\n=== enumerate + zip ===")
print(f"{'#':>3} {'Nombre':<12} {'Score':>6} {'Saldo':>12}")
print(f"{'─'*36}")
for i, (nombre, score, saldo) in enumerate(zip(clientes, scores, saldos), 1):
    print(f"  {i} {nombre:<12} {score:>6} ${saldo:>10,}")

print(f"{'─'*36}")
print(f"    {'Total':<12} {'':>6} ${sum(saldos):>10,}")

# Crear dict desde for + zip (patrón muy común)
scoring = {}
for nombre, score in zip(clientes, scores):
    scoring[nombre] = score
print(f"\nDict: {scoring}")
        
        
        Hacé clic en ▶ Ejecutar
      

      Ejemplo 4: break, continue y for/else

      
        ejemplo_04_break_continue.pyPython
        
          
clientes = [
    {"nombre": "García", "score": 720, "activo": True},
    {"nombre": "López", "score": 680, "activo": False},
    {"nombre": "Martínez", "score": 590, "activo": True},
    {"nombre": "Pérez", "score": 810, "activo": True},
]

# continue: saltar clientes inactivos
print("=== Solo activos (continue) ===")
for c in clientes:
    if not c["activo"]:
        continue       # saltear inactivos
    print(f"  {c['nombre']}: score {c['score']}")

# break: encontrar el primer premium (score > 750)
print("\n=== Primer premium (break) ===")
for c in clientes:
    if c["score"] > 750 and c["activo"]:
        print(f"  Premium: {c['nombre']} ({c['score']})")
        break

# for/else: buscar un score específico
print("\n=== Buscar score > 900 (for/else) ===")
for c in clientes:
    if c["score"] > 900:
        print(f"  Encontrado: {c['nombre']}")
        break
else:
    # Se ejecuta SOLO si no hubo break
    print("  Ningún cliente con score > 900")

# Patrón acumulador con continue para filtrar
print("\n=== Total de activos ===")
total = 0
count = 0
for c in clientes:
    if not c["activo"]:
        continue
    total += c["score"]
    count += 1
print(f"  Promedio score activos: {total/count:.0f} ({count} clientes)")
        
        
        Hacé clic en ▶ Ejecutar
      

      Ejemplo 5: For anidados — procesar tablas y matrices

      
        ejemplo_05_anidados.pyPython
        
          
# For anidado sobre lista de dicts con sublistas
sucursales = [
    {
        "nombre": "Centro",
        "clientes": [
            {"nombre": "García", "saldo": 150000},
            {"nombre": "Pérez", "saldo": 890000},
        ]
    },
    {
        "nombre": "Norte",
        "clientes": [
            {"nombre": "López", "saldo": 320000},
            {"nombre": "Sosa", "saldo": 72000},
        ]
    },
]

print("=== Reporte por sucursal ===")
total_general = 0
for sucursal in sucursales:             # for externo: sucursales
    total_suc = 0
    print(f"\n📍 Sucursal {sucursal['nombre']}:")
    for cliente in sucursal["clientes"]:  # for interno: clientes
        print(f"    {cliente['nombre']}: ${cliente['saldo']:,}")
        total_suc += cliente["saldo"]
    print(f"    Subtotal: ${total_suc:,}")
    total_general += total_suc

print(f"\n{'═'*30}")
print(f"TOTAL GENERAL: ${total_general:,}")

# For anidado para crear tabla de multiplicar
print(f"\n=== Tabla del 1 al 5 ===")
for i in range(1, 6):
    fila = ""
    for j in range(1, 6):
        fila += f"{i*j:>4}"
    print(fila)
        
        
        Hacé clic en ▶ Ejecutar
      

      03
      Referencia rápida

      
        
          
            Patrón
            Sintaxis
            Uso
          
          
            For básico
            for x in lista:
            Recorrer cualquier iterable
          
          
            Con range
            for i in range(n):
            Repetir N veces
          
          
            Con enumerate
            for i, x in enumerate(lst):
            Índice + valor
          
          
            Con zip
            for a, b in zip(l1, l2):
            Recorrer en paralelo
          
          
            Sobre dict
            for k, v in d.items():
            Clave + valor
          
          
            Con unpacking
            for a, b in lista_tuplas:
            Desempaquetar en el for
          
          
            For anidado
            for x in ext: for y in int:
            Tablas, matrices, estructuras profundas
          
          
            For/else
            for x in l: ... else:
            Verificar si no hubo break
          
        
      

      
        
          
            Anti-patrón ❌
            Patrón pythónico ✅
          
          
            for i in range(len(lst)): lst[i]
            for elem in lst:
          
          
            i=0; for x in lst: i+=1
            for i, x in enumerate(lst):
          
          
            for i in range(len(a)): a[i], b[i]
            for x, y in zip(a, b):
          
          
            for k in dict: dict[k]
            for k, v in dict.items():
          
        
      

      04
      Ejercicios

      
        Nivel 1 · Básico
        Ejercicio 1: Recorrer lista de nombres
        Dada nombres = ["García","López","Martínez","Pérez"], imprimí cada nombre con un saludo. Debe
          incluir Martínez.
        
          ejercicio_01.pyDebe incluir "Martínez"
          
            
nombres = ["García", "López", "Martínez", "Pérez"]

# Recorré e imprimí:

          
          
          Hacé clic en ▶ Ejecutar
        
        
        
      

      
        Nivel 1 · Básico
        Ejercicio 2: Sumar con for
        Dada ventas = [45000, 72000, 38000, 91000, 55000], sumá todas usando un acumulador con for (sin
          usar sum()). Debe incluir 301000.
        
          ejercicio_02.pyDebe incluir "301000"
          
            
ventas = [45000, 72000, 38000, 91000, 55000]
total = 0

# Sumá con for:

          
          
          Hacé clic en ▶ Ejecutar
        
        
      

      
        Nivel 1 · Básico
        Ejercicio 3: range para generar secuencia
        Imprimí los múltiplos de 5 del 5 al 50 usando range(5, 51, 5). Debe incluir 50.
        
          ejercicio_03.pyDebe incluir "50"
          
            
# Múltiplos de 5 del 5 al 50:

          
          
          Hacé clic en ▶ Ejecutar
        
        
      

      
        Nivel 2 · Intermedio
        Ejercicio 4: enumerate para ranking
        Ordená scores = [720,680,810,590,750] de mayor a menor e imprimilos con posición (1ro, 2do,
          etc.) usando enumerate. Debe incluir 1. 810.
        
          ejercicio_04.pyDebe incluir "1. 810"
          
            
scores = [720, 680, 810, 590, 750]

# Ordená desc e imprimí con enumerate:

          
          
          Hacé clic en ▶ Ejecutar
        
        
        
      

      
        Nivel 2 · Intermedio
        Ejercicio 5: zip para tabla combinada
        Combiná tickers=["GGAL","YPF","PAMP"] y precios=[5200,28000,3100] con zip. Imprimí
          una tabla y el precio total. Debe incluir 36300.
        
          ejercicio_05.pyDebe incluir "36300"
          
            
tickers = ["GGAL", "YPF", "PAMP"]
precios = [5200, 28000, 3100]

# Tabla con zip y total:

          
          
          Hacé clic en ▶ Ejecutar
        
        
        
      

      
        Nivel 2 · Intermedio
        Ejercicio 6: for sobre diccionario
        Dado saldos = {"García": 150000, "López": 320000, "Pérez": 890000}, recorrelo con
          .items() e imprimí cada cliente con formato de moneda. Debe incluir 890,000.
        
        
          ejercicio_06.pyDebe incluir "890,000"
          
            
saldos = {"García": 150000, "López": 320000, "Pérez": 890000}

# Recorré con .items():

          
          
          Hacé clic en ▶ Ejecutar
        
        
        
      

      
        Nivel 3 · Avanzado
        Ejercicio 7: for con continue para limpiar datos
        Dada datos = ["$1,500", "N/A", "$3,200", "", "$800", "error"], recorrela, saltá los inválidos
          con continue, convertí los válidos a float y sumá. Debe incluir 5500.
        
          ejercicio_07.pyDebe incluir "5500"
          
            
datos = ["$1,500", "N/A", "$3,200", "", "$800", "error"]
total = 0

# Procesá con continue para saltar inválidos:

          
          
          Hacé clic en ▶ Ejecutar
        
        
        
      

      
        Nivel 3 · Avanzado
        Ejercicio 8: for/else para búsqueda
        Buscá en una lista de clientes si alguno tiene score > 900. Si lo encontrás, imprimí su nombre con break. Si
          no, imprimí Ninguno encontrado usando for/else. Debe incluir Ninguno encontrado.
        
          ejercicio_08.pyDebe incluir "Ninguno encontrado"
          
            
clientes = [
    {"nombre": "García", "score": 720},
    {"nombre": "López", "score": 680},
    {"nombre": "Pérez", "score": 810},
]

# Buscá score > 900 con for/else:

          
          
          Hacé clic en ▶ Ejecutar
        
        
        
      

      
        Nivel 3 · Avanzado
        Ejercicio 9: For anidado — reporte por sucursal
        Dada una lista de sucursales (cada una con lista de clientes), imprimí un reporte agrupado y el total
          general. Debe incluir TOTAL.
        
          ejercicio_09.pyDebe incluir "TOTAL"
          
            
sucursales = [
    {"nombre": "Centro", "saldos": [150000, 890000]},
    {"nombre": "Norte", "saldos": [320000, 72000, 45000]},
]

# Reporte con for anidado:
total_general = 0

          
          
          Hacé clic en ▶ Ejecutar
        
        
        
      

      
        Nivel 4 · Desafío
        Ejercicio 10: Pipeline completo de procesamiento
        Tenés registros crudos. Para cada uno: (1) split por |, (2) convertir tipos, (3) clasificar score en
          Alto/Medio/Bajo, (4) acumular estadísticas. Imprimí tabla formateada + resumen. Debe incluir
          RESUMEN.
        
        
          ejercicio_10_desafio.pyDebe incluir "RESUMEN"
          
            
registros = [
    "García|720|$150,000",
    "López|680|$320,000",
    "Martínez|590|$45,000",
    "Pérez|810|$890,000",
    "Fernández|645|$72,000",
]

total_saldo = 0
categorias = {"Alto": 0, "Medio": 0, "Bajo": 0}

# Procesá cada registro con for:
for reg in registros:
    pass  # completá

print(f"\n=== RESUMEN ===")

          
          
          Hacé clic en ▶ Ejecutar
        
        
        
      

      05
      Resumen y conexión

      
        for x in iterable: recorre cada elemento de cualquier iterable (lista, dict, string, range,
          set).
        range(start, stop, step) genera secuencias numéricas. El stop está excluido.
        enumerate() da índice + valor. zip() combina iterables en paralelo.
        break sale, continue salta a la siguiente iteración, else se ejecuta
          si no hubo break.
        For anidados procesan estructuras profundas (listas de listas, dicts con sublistas).
        Los anti-patrones (range(len())) se reemplazan con enumerate y zip.
        
      

      En la siguiente lección (18 · Funciones básicas) vas a aprender a crear tus propias funciones
        con def: parámetros, return, docstrings, valores por defecto y el principio DRY que hace tu código
        reutilizable.

      Recursos: Python docs — for · range

      
        ← While
        Funciones básicas →
      


      Hecho con ❤️ por Rodri Gonzalez

Sintaxis	Genera	Ejemplo
`range(n)`	0, 1, 2, ..., n-1	`range(5)` → 0,1,2,3,4
`range(a, b)`	a, a+1, ..., b-1	`range(3, 8)` → 3,4,5,6,7
`range(a, b, paso)`	a, a+paso, ...	`range(0, 20, 5)` → 0,5,10,15
`range(b, a, -1)`	b, b-1, ..., a+1	`range(5, 0, -1)` → 5,4,3,2,1

Anti-patrón ❌	Patrón pythónico ✅
`for i in range(len(lst)): lst[i]`	`for elem in lst:`
`i=0; for x in lst: i+=1`	`for i, x in enumerate(lst):`
`for i in range(len(a)): a[i], b[i]`	`for x, y in zip(a, b):`
`for k in dict: dict[k]`	`for k, v in dict.items():`

Patrón	Sintaxis	Uso
For básico	`for x in lista:`	Recorrer cualquier iterable
Con range	`for i in range(n):`	Repetir N veces
Con enumerate	`for i, x in enumerate(lst):`	Índice + valor
Con zip	`for a, b in zip(l1, l2):`	Recorrer en paralelo
Sobre dict	`for k, v in d.items():`	Clave + valor
Con unpacking	`for a, b in lista_tuplas:`	Desempaquetar en el for
For anidado	`for x in ext: for y in int:`	Tablas, matrices, estructuras profundas
For/else	`for x in l: ... else:`	Verificar si no hubo break