# Condicionales y bucles

URL canónica: https://missyera.com/guias/python-desde-cero/control-de-flujo/
Última actualización: 2026-11-14
Autora: Gera Flores (Miss Yera)

> **Respuesta corta**
>
> El if hace algo solo si se cumple una condición, el for repite una vez por cada elemento de una lista y el while repite mientras una condición siga siendo verdad. Con esos tres armas casi cualquier cosa. Y lo que más me costó explicar al principio: en Python la sangría de cuatro espacios no es estética, es sintaxis, así que moverla cambia lo que hace el programa.

Capítulo 5 de 17 del libro [Python desde cero](https://missyera.com/guias/python-desde-cero.md).

## Hola! Aquí empieza a ser un programa

Hasta ahora Python era una calculadora con memoria. Guardaba valores y hacía cuentas 🧮

Con este capítulo empieza a **tomar decisiones** y a **repetir trabajo**, que son las dos cosas por las que valió la pena aprenderlo.

![Árbol para elegir entre if, for y while: decidir una vez es if con elif y else, repetir una vez por elemento es for, y repetir hasta que pase algo es while, que sin una salida segura no para nunca.](https://missyera.com/static/diagramas/webp/py-04-repetir.webp)

*El while es el único de los tres que puede no terminar, y por eso es el único que hay que escribir pensando primero en cómo va a parar.*

## La sangría, que aquí es sintaxis

Antes de nada, esto, porque es lo que más frustra la primera semana.

En otros lenguajes los bloques se marcan con llaves y la sangría es decoración. En Python **la sangría es la que dice qué está dentro y qué está fuera**. No es estética, es gramática.

```
monto = 1500

if monto > 1000:
    print('Venta grande')
    print('Se avisa al supervisor')
print('Esto sale siempre')
```

```text
Venta grande
Se avisa al supervisor
Esto sale siempre
```

Los dos primeros `print` están dentro del `if` porque tienen cuatro espacios. El tercero está fuera porque no los tiene. Cambia la sangría y cambias el programa.

Las reglas que te evitan el 99% de los problemas:

- 📏 Cuatro espacios. Siempre cuatro, nunca dos ni ocho. Lo dice PEP 8 y lo respeta todo el mundo.
- 🚫 Nunca mezcles espacios con tabulaciones. Se ven igual y Python los cuenta distinto, así que produce errores imposibles de ver a ojo.
- ⌨️ Configura tu editor para que la tecla Tab inserte cuatro espacios. En Colab ya viene así.

```
if monto > 1000:
print('sin sangria')
```

```
IndentationError: expected an indented block after 'if' statement on line 1
```

## if, elif, else

```
monto = 780

if monto > 2000:
    categoria = 'Mayorista'
elif monto > 500:
    categoria = 'Mediana'
elif monto > 100:
    categoria = 'Pequeña'
else:
    categoria = 'Mínima'

print(categoria)
```

```text
Mediana
```

Se evalúan en orden y **se sale en la primera que se cumple**. Por eso 780 salió como Mediana y nunca llegó a preguntarse si era mayor que 100.

Ese detalle del orden es donde se cometen los errores de verdad. Mira qué pasa si lo escribes al revés:

```
if monto > 100:
    categoria = 'Pequeña'
elif monto > 500:
    categoria = 'Mediana'
elif monto > 2000:
    categoria = 'Mayorista'

print(categoria)
```

```text
Pequeña
```

Ahí ya nada puede ser Mediana ni Mayorista jamás, porque todo lo que pasa de 500 también pasa de 100 y se sale en la primera 😬

**Con rangos, siempre de más estricto a menos estricto.** Esto lo he visto arruinar segmentaciones enteras de clientes en empresas grandes, y no lo detecta ningún error: el código corre feliz.

### Comparar y combinar

| Operador | Qué pregunta |
|---|---|
| `==` | ¿son iguales? Ojo, dos signos |
| `!=` | ¿son distintos? |
| `>` `<` `>=` `<=` | mayor, menor, y sus versiones con igual |
| `in` | ¿está dentro de esta lista o de este texto? |
| `and` `or` `not` | combinar condiciones |

```
ciudad = 'Lima'
monto = 1500
canal = 'Web'

if ciudad in ['Lima', 'Callao'] and monto > 1000:
    print('Reparto propio')

if canal != 'Tienda' or monto > 5000:
    print('Necesita seguimiento')

print(100 < monto < 2000)
```

```text
Reparto propio
Necesita seguimiento
True
```

Esa última línea es una gracia de Python que otros lenguajes no tienen: puedes encadenar comparaciones como en matemáticas. Se lee lindo 🌸

Y el error número uno de este capítulo:

```
if ciudad = 'Lima':
    print('hola')
```

```
SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?
```

Un igual asigna, dos iguales comparan. Menos mal que Python te lo dice clarito.

## El bucle for

Repite algo una vez por cada elemento de una lista.

```
ventas = [480.37, 154.83, 2480.84]

for v in ventas:
    print(f'S/{v:,.2f}')
```

```text
S/480.37
S/154.83
S/2,480.84
```

El nombre `v` lo eliges tú. Ponle uno que se entienda: si recorres ciudades llámala `ciudad`, no `x`.

Cuando necesites números y no una lista, está `range`:

```
for i in range(5):
    print(i, end=' ')
print()

for i in range(1, 4):
    print(i, end=' ')
```

```text
0 1 2 3 4
1 2 3
```

Igual que las rebanadas: **el final no se incluye**. Python es coherente con eso en todos lados, y una vez que lo interiorizas deja de sorprender.

### enumerate, cuando necesitas la posición

La tentación es llevar un contador a mano. No hace falta:

```
ciudades = ['Lima', 'Arequipa', 'Cusco']

for i, ciudad in enumerate(ciudades, start=1):
    print(f'{i}. {ciudad}')
```

```text
1. Lima
2. Arequipa
3. Cusco
```

### zip, para recorrer dos listas a la vez

```
ciudades = ['Lima', 'Arequipa', 'Cusco']
montos = [12500.5, 980.25, 145600.0]

for ciudad, monto in zip(ciudades, montos):
    print(f'{ciudad:<10} S/{monto:>12,.2f}')
```

```text
Lima       S/   12,500.50
Arequipa   S/      980.25
Cusco      S/  145,600.00
```

Cuidado con una cosa: `zip` se detiene en la lista más corta y no te avisa. Si una tiene 100 elementos y la otra 98, procesas 98 y pierdes dos en silencio 🤫

### Acumular, que es para lo que más se usa

```
ventas = [480.37, 154.83, 2480.84, 524.90]

total = 0
mayores = 0

for v in ventas:
    total = total + v
    if v > 500:
        mayores = mayores + 1

print(f'Total S/{total:,.2f} en {len(ventas)} ventas')
print(f'{mayores} pasaron los S/500')
```

```text
Total S/3,640.94 en 4 ventas
2 pasaron los S/500
```

Fíjate en que `total = 0` va **antes** del bucle. Si lo pones dentro, se reinicia en cada vuelta y terminas con el último valor en vez del total. Es un error clásico y silencioso.

## El bucle while

`for` repite una vez por elemento. `while` repite **mientras** una condición sea verdadera, y no sabe de antemano cuántas veces va a ser.

```
saldo = 10000
meses = 0

while saldo > 0:
    saldo = saldo - 1500
    meses = meses + 1

print(f'Se acaba en {meses} meses, con saldo {saldo}')
```

```text
Se acaba en 7 meses, con saldo -500
```

Y ahora la advertencia que todo el mundo necesita una vez en la vida:

```
# NO ejecutes esto
saldo = 10000
while saldo > 0:
    print('sigo aqui')
```

Nada dentro del bucle cambia `saldo`, así que la condición nunca deja de cumplirse. Eso es un **bucle infinito** y tu cuaderno se queda colgado hasta que lo detengas 🔁

La regla: **dentro de un `while`, algo tiene que mover la condición**. Si no lo ves a simple vista, revísalo antes de ejecutar.

En Colab se corta con el botón de stop de la celda, y si quedó muy trabado, Entorno de ejecución y después Reiniciar. No pasa nada, no rompiste nada.

### break y continue

```
montos = [120.0, 340.5, -50.0, 890.0, 1200.0]

for m in montos:
    if m < 0:
        print('Monto negativo, algo esta mal en el archivo')
        break
    print(f'Procesando S/{m}')
```

```text
Procesando S/120.0
Procesando S/340.5
Monto negativo, algo esta mal en el archivo
```

```
for m in montos:
    if m < 0:
        continue
    print(f'Procesando S/{m}')
```

```text
Procesando S/120.0
Procesando S/340.5
Procesando S/890.0
Procesando S/1200.0
```

`break` sale del bucle entero. `continue` se salta esa vuelta y sigue con la siguiente. Los dos sirven, y elegir cuál depende de si el dato raro es un aviso para parar o algo que simplemente se ignora.

## Preguntas que se responden sin bucle

Hay un patrón que vas a escribir mil veces sin darte cuenta: un bucle con una variable que empieza en `False` y se pone en `True` si pasa algo. Se llama bandera, y casi siempre sobra 🚩

```
montos = [480.37, 154.83, 2480.84, -12.0, 524.90]

hay_negativo = False
for m in montos:
    if m < 0:
        hay_negativo = True
        break
print('con bucle y bandera:', hay_negativo)

print('con any          :', any(m < 0 for m in montos))
print('todos positivos  :', all(m > 0 for m in montos))
print('cuantos negativos:', sum(m < 0 for m in montos))
```

```text
con bucle y bandera: True
con any          : True
todos positivos  : False
cuantos negativos: 1
```

Siete líneas contra una, y la de una se lee en voz alta: *¿hay alguno menor que cero?* 🙂

- ✅ `any(...)` es **¿hay al menos uno?**
- 🔒 `all(...)` es **¿lo cumplen todos?**
- 🔢 `sum(...)` con una condición dentro es **¿cuántos?**, y funciona porque `True` vale 1 y `False` vale 0, que ya lo viste en el capítulo de variables.

Y una cosa que no se nota: `any` también para en cuanto encuentra uno, igual que el `break`. Si el primer monto ya es negativo, no mira los tres mil restantes 🏃‍♀️

## El else del for, que casi nadie conoce

Un `for` puede llevar `else`. Y no significa lo que parece 👀

```
codigos = ['C0045', 'C0325', 'C0260']
buscado = 'C0777'

for c in codigos:
    if c == buscado:
        print('encontrado:', c)
        break
else:
    print(buscado, 'no esta en la lista de', len(codigos), 'codigos')
```

```text
C0777 no esta en la lista de 3 codigos
```

El `else` del bucle corre **cuando el bucle terminó sin romperse**. O sea: cuando no hubo `break`.

Léelo como "si no encontré nada", que es para lo único que se usa. Es la respuesta a la pregunta más común de todas: *busqué y no estaba, ¿ahora qué?*

```
for c in codigos:
    if c == 'C0325':
        print('encontrado:', c)
        break
else:
    print('no aparecio')
```

```text
encontrado: C0325
```

Aquí sí hubo `break`, así que el `else` no corrió.

Sin esto, la alternativa es la bandera de la sección anterior otra vez. Y a mí me costó años enterarme de que existía, así que ahí lo tienes desde el principio en vez de dentro de diez años 💜

## match, para las cadenas largas de elif

Cuando el `elif` se repite cinco veces preguntando siempre por lo mismo, hay una forma más limpia. Existe desde Python 3.10:

```
def etiqueta(canal):
    match canal:
        case 'Web' | 'Marketplace':
            return 'digital'
        case 'Tienda':
            return 'presencial'
        case 'WhatsApp':
            return 'mensajeria'
        case _:
            return 'sin clasificar'

for canal in ['Web', 'Tienda', 'WhatsApp', 'Marketplace', 'Feria']:
    print(f'{canal:<12} -> {etiqueta(canal)}')
```

```text
Web          -> digital
Tienda       -> presencial
WhatsApp     -> mensajeria
Marketplace  -> digital
Feria        -> sin clasificar
```

Tres detalles y ya lo sabes usar 🎯

- ➕ La barra `|` junta varios casos en la misma rama, que es lo que en `if` serían dos comparaciones con `or`.
- 🅰️ El `case _` del final es el "cualquier otra cosa". Ponlo siempre, o los valores que no previste se van sin respuesta.
- 🚫 No hace falta `break` entre casos. Si vienes de otros lenguajes donde sí hacía falta, aquí no.

¿Cuándo uso `match` y cuándo `if`? Si comparas **una misma cosa contra varios valores**, `match`. Si cada rama pregunta algo distinto, `if` y `elif`. Y con dos ramas, `if` siempre: `match` ahí solo hace ruido.

## El bucle que no hay que escribir

Este te lo va a sugerir cualquier buscador y viene de otros lenguajes:

```
ciudades = ['Lima', 'Arequipa', 'Cusco']

for i in range(len(ciudades)):
    print(ciudades[i].upper(), end=' ')
print()

for ciudad in ciudades:
    print(ciudad.upper(), end=' ')
print()

for i, ciudad in enumerate(ciudades, start=1):
    print(f'{i}. {ciudad}', end='  ')
print()
```

```text
LIMA AREQUIPA CUSCO
LIMA AREQUIPA CUSCO
1. Lima  2. Arequipa  3. Cusco
```

Los tres imprimen bien. El primero es el que no quiero que escribas 🙅‍♀️

`range(len(algo))` te da posiciones, y luego tienes que ir a buscar el valor con `algo[i]`. Son dos pasos para lo que Python hace en uno, y cada `[i]` es una oportunidad de equivocarte de índice.

La regla: si dentro del bucle solo usas `ciudades[i]`, recorre la lista directamente. Si de verdad necesitas el número, `enumerate`. El `range(len(...))` no hace falta nunca 🌸

## Un caso completo

Vamos a juntar todo con algo que sí harías en el trabajo: clasificar ventas y sacar un resumen.

```
ventas = [
    {'ciudad': 'Lima', 'monto': 2480.84, 'pagado': True},
    {'ciudad': 'Cusco', 'monto': 154.83, 'pagado': False},
    {'ciudad': 'Lima', 'monto': 780.0, 'pagado': True},
    {'ciudad': 'Piura', 'monto': 95.5, 'pagado': False},
    {'ciudad': 'Lima', 'monto': 3200.0, 'pagado': True},
]

cobrado = 0
por_cobrar = 0
categorias = {}

for v in ventas:
    if v['pagado']:
        cobrado = cobrado + v['monto']
    else:
        por_cobrar = por_cobrar + v['monto']

    if v['monto'] > 2000:
        cat = 'Mayorista'
    elif v['monto'] > 500:
        cat = 'Mediana'
    else:
        cat = 'Pequeña'

    categorias[cat] = categorias.get(cat, 0) + 1

print(f'Cobrado    S/{cobrado:,.2f}')
print(f'Por cobrar S/{por_cobrar:,.2f}')
print(categorias)
```

```text
Cobrado    S/6,460.84
Por cobrar S/250.33
{'Mayorista': 2, 'Pequeña': 2, 'Mediana': 1}
```

Treinta líneas y ya es un reporte que alguien podría pedirte. Con pandas van a ser cuatro, pero ahora entiendes qué está haciendo por dentro 💜

## Ejercicios

**1. Semáforo de stock**

Dado un número de unidades, imprime "Crítico" si es menor a 10, "Bajo" si es menor a 50, y "OK" en el resto de casos.

```
unidades = 34

if unidades < 10:
    print('Crítico')
elif unidades < 50:
    print('Bajo')
else:
    print('OK')
```

```text
Bajo
```

Del más estricto al menos estricto. Si pones el `< 50` primero, nada será nunca Crítico.

**2. Suma solo lo que corresponde**

De una lista de montos, suma solo los positivos y cuenta cuántos negativos descartaste.

```
montos = [120.0, -50.0, 340.5, -12.0, 890.0]

total = 0
descartados = 0
for m in montos:
    if m < 0:
        descartados = descartados + 1
        continue
    total = total + m

print(f'Total S/{total:,.2f}, {descartados} descartados')
```

```text
Total S/1,350.50, 2 descartados
```

Contar lo que descartas es tan importante como sumar lo que sirve. Si un día descartas la mitad del archivo, quieres enterarte.

**3. Tabla numerada**

Imprime una lista de ciudades numerada desde 1, alineando el número a la derecha en dos espacios.

```
ciudades = ['Lima', 'Arequipa', 'Cusco', 'Piura']

for i, c in enumerate(ciudades, start=1):
    print(f'{i:>2}. {c}')
```

```text
 1. Lima
 2. Arequipa
 3. Cusco
 4. Piura
```

**4. Dos listas a la vez**

Con una lista de productos y otra de stock, imprime solo los que tengan menos de 20 unidades.

```
productos = ['Abarrotes', 'Bebidas', 'Limpieza', 'Snacks']
stock = [45, 12, 8, 30]

for p, s in zip(productos, stock):
    if s < 20:
        print(f'{p}: quedan {s}')
```

```text
Bebidas: quedan 12
Limpieza: quedan 8
```

**5. Cuántos meses hasta la meta**

Empiezas con S/5.000 y ahorras S/800 al mes. ¿Cuántos meses hasta llegar a S/20.000? Usa `while`.

```
ahorro = 5000
meses = 0

while ahorro < 20000:
    ahorro = ahorro + 800
    meses = meses + 1

print(f'{meses} meses, terminas con S/{ahorro:,}')
```

```text
19 meses, terminas con S/20,200
```

**6. Parar en el primer problema**

Recorre una lista de códigos de cliente y detente en cuanto encuentres uno vacío, avisando en qué posición estaba.

```
codigos = ['C0045', 'C0325', '', 'C0260']

for i, c in enumerate(codigos):
    if c == '':
        print(f'Código vacío en la posición {i}')
        break
    print(f'OK {c}')
```

```text
OK C0045
OK C0325
Código vacío en la posición 2
```

**7. El acumulador mal puesto**

Escribe a propósito el error de inicializar el total dentro del bucle y explica el resultado.

```
ventas = [100, 200, 300]

for v in ventas:
    total = 0          # mal: se reinicia cada vuelta
    total = total + v

print(total)
```

```text
300
```

Sale 300 y no 600, porque en la última vuelta el total volvió a cero y solo sumó el último valor. No hay error, hay un número equivocado, que es peor.

**8. Filtrar por dos condiciones**

De una lista de ventas, cuenta las que son de Lima **y** pasan de S/1.000.

```
ventas = [
    {'ciudad': 'Lima', 'monto': 2480.84},
    {'ciudad': 'Cusco', 'monto': 1540.0},
    {'ciudad': 'Lima', 'monto': 780.0},
    {'ciudad': 'Lima', 'monto': 3200.0},
]

cuenta = 0
for v in ventas:
    if v['ciudad'] == 'Lima' and v['monto'] > 1000:
        cuenta = cuenta + 1

print(cuenta)
```

```text
2
```

**9. La comparación encadenada**

Clasifica un puntaje de satisfacción del 1 al 5 usando una comparación encadenada para validar que esté en rango.

```
puntaje = 4

if not 1 <= puntaje <= 5:
    print('Puntaje fuera de rango')
elif puntaje >= 4:
    print('Cliente satisfecho')
else:
    print('Cliente en riesgo')
```

```text
Cliente satisfecho
```

Validar el rango antes de clasificar es una costumbre que salva reportes. Un puntaje de 9 en una escala del 1 al 5 significa que alguien cargó mal los datos.

**10. El bucle que se pasa**

Un cliente debe S/3.000 y paga S/700 al mes. Muestra el saldo mes a mes hasta que quede en cero o negativo.

```
saldo = 3000
mes = 0

while saldo > 0:
    mes = mes + 1
    saldo = saldo - 700
    print(f'Mes {mes}: quedan S/{saldo}')
```

```text
Mes 1: quedan S/2300
Mes 2: quedan S/1600
Mes 3: quedan S/900
Mes 4: quedan S/200
Mes 5: quedan S/-500
```

El último mes se pasa. En un caso real ahí pondrías `min(700, saldo)` para cobrar solo lo que falta, que es exactamente el tipo de detalle que diferencia un cálculo correcto de uno que casi lo es.

**11. Cuatro preguntas sin escribir un bucle**

Responde con `any`, `all` y `sum`.

```
ventas = [
    {'codigo': 'C0045', 'ciudad': 'Arequipa', 'monto': 480.37, 'unidades': 10},
    {'codigo': 'C0325', 'ciudad': 'Lima', 'monto': 524.90, 'unidades': 0},
    {'codigo': 'C0260', 'ciudad': 'Cusco', 'monto': 2480.84, 'unidades': 25},
    {'codigo': 'C0111', 'ciudad': 'Piura', 'monto': -12.00, 'unidades': 3},
]

print('hay algun monto negativo :', any(v['monto'] < 0 for v in ventas))
print('todas tienen unidades    :', all(v['unidades'] > 0 for v in ventas))
print('cuantas pasan de mil     :', sum(v['monto'] > 1000 for v in ventas))
print('hay alguna de Trujillo   :', any(v['ciudad'] == 'Trujillo' for v in ventas))
```

```text
hay algun monto negativo : True
todas tienen unidades    : False
cuantas pasan de mil     : 1
hay alguna de Trujillo   : False
```

Esas cuatro líneas son cuatro controles de calidad, y así escritas caben en la primera celda del cuaderno 🧪

La segunda es la que más vale: una venta con cero unidades y monto positivo es un dato imposible, y lo acabas de descubrir en una línea.

**12. Buscar, y decir algo cuando no está**

Usa el `else` del `for` para los dos casos.

```
for buscado in ('C0260', 'C0999'):
    for v in ventas:
        if v['codigo'] == buscado:
            print(f'{buscado}: S/{v["monto"]:.2f} en {v["ciudad"]}')
            break
    else:
        print(f'{buscado}: no esta en las {len(ventas)} ventas')
```

```text
C0260: S/2480.84 en Cusco
C0999: no esta en las 4 ventas
```

Ojo a la sangría, que aquí es todo 📐

El `else` está alineado con el `for` de dentro, no con el `if`. Si lo alineas con el `if`, escribes un `if/else` normal que se ejecuta en cada vuelta y el resultado es otro. Es la única vez que la sangría cambia el significado de forma tan silenciosa.

**13. Clasificar ciudades con `match`**

Agrupa las ciudades en macrorregiones.

```
def macro(ciudad):
    match ciudad:
        case 'Lima' | 'Callao':
            return 'centro'
        case 'Arequipa' | 'Cusco':
            return 'sur'
        case 'Piura' | 'Trujillo' | 'Chiclayo':
            return 'norte'
        case _:
            return 'sin macro'

for v in ventas:
    print(f'{v["ciudad"]:<10} -> {macro(v["ciudad"])}')
```

```text
Arequipa   -> sur
Lima       -> centro
Cusco      -> sur
Piura      -> norte
```

Prueba a quitar el `case _` y pásale una ciudad que no esté, tipo `macro('Iquitos')`. No falla: devuelve `None`, calladito. Y un `None` suelto viajando por tu análisis es de los bugs que más tardan en aparecer 🫥

**14. Borrar mientras recorres, que es el bug silencioso**

Quita los montos negativos de una lista de dos maneras y compara.

```
montos = [120.0, -50.0, 340.5, -12.0, -8.0, 890.0]

copia = list(montos)
for m in copia:
    if m < 0:
        copia.remove(m)
print('borrando sobre la marcha:', copia)

buenos = [m for m in montos if m >= 0]
print('con una lista nueva     :', buenos)
print('cuantos negativos habia :', sum(m < 0 for m in montos))
```

```text
borrando sobre la marcha: [120.0, 340.5, -8.0, 890.0]
con una lista nueva     : [120.0, 340.5, 890.0]
cuantos negativos habia : 3
```

Mira bien la primera línea de salida: **se quedó un negativo dentro** 😖

Había tres y solo borró dos. Y no falló nada: no hay error, no hay aviso, la lista se ve razonable. Este es el bug que te deja el total mal y no te enteras hasta que alguien pregunta.

Lo que pasa es esto. El bucle va por posiciones: 0, 1, 2... Al borrar el `-50.0` de la posición 1, todo lo de atrás se corre un lugar hacia adelante. El bucle pasa a la posición 2, pero ahí ya está el elemento que antes era el 3. El que se corrió al hueco **nunca se mira**.

Por eso los dos `-12.0` y `-8.0` seguidos son la trampa: al borrar el primero, el segundo se cuela.

La regla, y no tiene excepciones: **no modifiques una lista mientras la recorres**. Arma una nueva con una comprensión, que además se lee mejor 🌸

## El if más común de todos y el día que dice mentiras

Ya viste que en Python muchas cosas se comportan como falsas sin ser False. Aquí está lo que pasa cuando eso se cuela en una comprobación que parece de manual 🚨

La trampa

Compruebas si la consulta devolvió algo antes de seguir, que es lo responsable. Y un día el informe sale vacío sin que nadie se entere.

```
ventas = buscar(ciudad, mes)

if ventas:
    generar_informe(ventas)
else:
    avisar('sin conexión a la base')
```

**Qué está mal**

Una lista vacía es **falsa** en Python, igual que el cero, la cadena vacía y None 🫥 Así que "no hubo ventas ese mes", que es un resultado correcto y valioso, entra por la misma puerta que "la base de datos no respondió".

El informe no se genera y el aviso dice algo que no es verdad, así que alguien va a pasarse la tarde revisando una conexión que está perfecta.

Cuando lo que preguntas es **si algo existe**, se pregunta con `is None`. El `if lista:` se usa cuando de verdad quieres tratar igual el vacío y la ausencia, y eso casi nunca es lo que quieres con datos.

Comprueba que lo tienes

Recorres una lista con un for y dentro vas borrando elementos. ¿Qué esperas?

- Que se salte elementos, porque los índices se corren
- Que funcione, porque Python revisa la lista en cada vuelta
- Que reviente con un error
- Que borre de más

## Lo que te llevas

- 📏 La sangría es sintaxis: cuatro espacios, sin mezclar con tabulaciones.
- 🪜 En una cadena de `elif` con rangos, siempre del más estricto al menos estricto.
- 🔢 En `range` y en las rebanadas, el final no se incluye.
- ➕ El acumulador se inicializa **antes** del bucle.
- ♾️ En un `while`, algo dentro tiene que mover la condición.

Y si de todo el capítulo te llevas una sola frase, que sea esta:

Preguntar si algo existe y preguntar si algo está vacío no son la misma pregunta.

Los `if` anidados que acabas de aprender a no escribir son, línea por línea, los SI dentro de SI dentro de SI que hay en medio Excel del país. En la [guía de Excel](https://missyera.com/guias/excel-desde-cero/) están contados desde el otro lado 🧩

En el capítulo 6 vamos a empaquetar todo esto en funciones, que es lo que hace que dejes de copiar y pegar el mismo bloque en cinco sitios.

Que tengas lindo día! 🌸

## Preguntas frecuentes

### ¿Cómo funciona el while en Python?

Repite mientras la condición siga siendo verdadera. El riesgo es que nunca deje de serlo, y ahí el programa se queda dando vueltas para siempre.

### ¿Cuál es la diferencia entre for y while?

El for recorre algo que ya existe y sabe cuándo termina. El while repite hasta que se cumpla una condición, y puede no terminar nunca.

### ¿Qué hacen break y continue?

break corta el bucle entero y sigue con lo de después. continue se salta solo esta vuelta y pasa a la siguiente.

### ¿Por qué Python usa indentación?

Porque el bloque de código se define por los espacios y no por llaves. Mezclar tabuladores y espacios da un error que confunde, y la solución es dejar que el editor ponga cuatro espacios siempre.

## Seguir leyendo

- Anterior: [Listas, tuplas y diccionarios](https://missyera.com/guias/python-desde-cero/listas-y-diccionarios.md)
- Siguiente: [Funciones](https://missyera.com/guias/python-desde-cero/funciones.md)

## Contacto

- Diagnóstico de 30 minutos con Miss Yera: https://calendly.com/soymissyera/reunion-con-yera
- Correo: hola@missyera.com
- Esta página en HTML: https://missyera.com/guias/python-desde-cero/control-de-flujo/
- Índice de todas las páginas en texto: https://missyera.com/llms-index.txt