Introducción a Python

class: center, middle, inverse, title-slide

.title[
# Introducción a Python
]
.subtitle[
## Clase 4: Condicionales y flujo
]
.author[
### Daniel Miles Touya Máster en Análisis de Datos · UdelaR-Uvigo
]
.date[
### 27 abril 2026
]

---

class: inverse, middle

.huge[Clase 4]

## Condicionales y flujo

---

# Guía de lectura de la clase

.smallest[
Hasta ahora:

- sabemos cómo crear objetos  
- sabemos usar estructuras de datos  
]

.div_bloque.small[
Ahora damos un paso clave:

> cómo decide un programa **qué hacer**
]

.smallest[
En esta clase veremos:

- flujo de ejecución  
- decisiones (`if`)  
- condiciones  
- errores lógicos  
]

---

# Flujo secuencial

.div_bloque[
Por defecto, Python ejecuta línea a línea.
]

```python
temperatura = 35

print("Comprobando temperatura...")
print(temperatura)
print("Fin")
```

.smallest[
Todas las líneas se ejecutan siempre.
]

---

# Problema

.div_bloque[
¿Cómo hacemos que el programa decida?
]

.smallest[
Ejemplo:

> avisar solo si hace calor
]

```python
temperatura = 35

print("Comprobando temperatura...")

if temperatura > 30:
    print("⚠ Hace mucho calor")

print("Fin")
```

---

# Qué hace el if

.div_bloque[
El programa evalúa una condición.
]

.smallest[
- si es `True` → ejecuta el bloque  
- si es `False` → lo salta  
]

.smallest[
Esto cambia el flujo del programa.
]

---

# Muy importante: indentación (indentation)

.div_bloque[
La indentación define el bloque.
]

```python
temperatura = 35

if temperatura > 30:
    print("Alerta")
    print("Beber agua")

print("Fin")
```

.smallest[
Las dos líneas `print` están dentro del `if`.

Cuando encuentra una linea sin identation, sabe que terminó el bloque

]

---

# Fuera vs dentro del bloque

.smallest[
Mira la diferencia:
]

```python
if temperatura > 30:
    print("Alerta")

print("Siempre se imprime")
```

.div_bloque.small[
.hi-blue[Idea:]

Lo que está fuera del bloque se ejecuta siempre.
]

---

# Error más peligroso

.div_bloque[
No todos los errores generan error.
]

.smallest[
Ejemplo:
]

```python
nota = 5.0

if nota > 5:
    print("Aprobado")
else:
    print("Suspenso")
```

.smallest[
¿Es correcto?
]

---

# Caso límite

.smallest[
Probamos:
]

```python
nota = 5.0
```

.div_bloque.small[
.hi-red[Problema:]

5.0 no aprueba en este código
]

.smallest[
Solución:
]

```python
if nota >= 5:
    print("Aprobado")
```

---

# Tipo de error

.div_bloque[
Este error no da mensaje.
]

.smallest[
- el programa funciona  
- pero el resultado es incorrecto  
]

.div_bloque.small[
.hi-red[Idea clave:]

> error de lógica (flujo incorrecto)
]

---

# Leer código con condiciones

.smallest[
Cuando leas código (IA incluida), revisa:
]

.smallest[
- operadores (`>`, `>=`, `==`)  
- condiciones  
- casos límite  
]

.div_bloque[
.hi-blue[Idea final:]

> El flujo del programa depende de las condiciones.
]

---
#  if / elif / else

.hi-red[Decisiones]: por dónde debo ir si se cumple la condición...o si no...

---

# Estructura básica

.div_bloque[
Un `if` ejecuta un bloque si la condición es verdadera.
]

```python
x = 10
y = 20

if x < y:
 print("x es menor que y")
```

.smallest[
Si la condición es `False`, no pasa nada.
]

---

# Añadir un else

.div_bloque[
`else` captura el caso contrario.
]

```python
x = 10
y = 20

if x > y:
    print("x es mayor")
else:
    print("x no es mayor")
```

.smallest[
Siempre se ejecuta uno de los dos bloques.
]

---

# Varias condiciones

.div_bloque[
`elif` permite más de dos casos.
]

```python
nota = 8

if nota >= 9:
    print("Sobresaliente")
elif nota >= 7:
    print("Notable")
elif nota >= 5:
    print("Aprobado")
else:
    print("Suspenso")
```

---

# Cómo se ejecuta

.smallest[
Python evalúa en orden:
]

.smallest[
1. evalúa el `if`  
2. si es `False`, pasa al siguiente `elif`  
3. se detiene en el primero que sea `True`  
]

.div_bloque[
> El resto no se evalúa
]

---

# Error típico: orden incorrecto

.smallest[
Mira este código:
]

```python
nota = 8

if nota >= 5:
    print("Aprobado")
elif nota >= 7:
    print("Notable")
```

.div_bloque.small[
.hi-red[Problema:]

Nunca se ejecuta "Notable"
]

.smallest[
¿Por qué?

> la primera condición ya es True: entonces se sale del flujo condicional
]

---

# Regla clave

.div_bloque[
Ordena de más restrictivo a menos restrictivo.
]

```python
if nota >= 9:
    print("Sobresaliente")
elif nota >= 7:
    print("Notable")
elif nota >= 5:
    print("Aprobado")
```

---

# Múltiples if (no es lo mismo)

.smallest[
Esto es distinto:
]

```python
valor = 85

if valor > 50:
    print("supera 50")

if valor > 80:
    print("supera 80")
```

.smallest[
Se ejecutan ambas condiciones.
]

.div_bloque.small[
.hi-blue[Idea:]

Aquí NO hay exclusión.
]

---

# Cuándo usar cada uno

.div_bloque[
Dos casos distintos:
]

.smallest[
- `if / elif` → categorías excluyentes  
- múltiples `if` → condiciones independientes  
]

---

# Comparar ambas ideas

.smallest[
Ejemplo:
]

```python
nota = 85

# categorías
if nota >= 90:
    print("A")
elif nota >= 70:
    print("B")

# condiciones independientes
if nota > 50:
    print("pasa umbral")
if nota > 80:
    print("nivel alto")
```

---

# Leer código IA

.div_bloque[
Cuando veas código con condicionales:
]

.smallest[
- revisa el orden  
- revisa los operadores (`>`, `>=`)  
- busca condiciones redundantes  
]

.div_bloque.small[
.hi-red[Idea clave:]

> muchos errores no dan error, solo resultados incorrectos
]

---

# Qué debes entender

.smallest[
En el material, fíjate en:

- cómo funciona `if`, `elif`, `else`  
- por qué el orden importa  
- diferencia entre `elif` y múltiples `if`  
- cómo detectar errores lógicos  
]

.div_bloque[
.hi-blue[Idea final:]

>Leer condicionales = entender el flujo del programa
]

---

# Operadores lógicos: condiciones complejas

.hi-blue[and · or · not]

---

# Combinar condiciones

.div_bloque[
Podemos combinar varias condiciones.
]

```python
edad = 25
ingresos = 2000

if edad > 18 and ingresos > 1500:
    print("Puede acceder")
```

.smallest[
Se deben cumplir ambas condiciones.
]

---

# Operador AND

.div_bloque[
`and` → ambas condiciones deben ser verdaderas.
]

```python
print(True and True)
print(True and False)
```

.smallest[
Resultado:

- `True and True` → True  
- en cualquier otro caso → False  
]

---

# Operador OR

.div_bloque[
`or` → basta con que una condición sea verdadera.
]

```python
print(True or False)
print(False or False)
```

.smallest[
Resultado:

- al menos una True → True  
- ambas False → False  
]

---

# Operador NOT

.div_bloque[
`not` invierte la condición.
]

```python
print(not True)
print(not False)
```

.smallest[
True → False  
False → True  
]

---

# Ejemplo completo

.smallest[
Combinando operadores:
]

```python
edad = 17
acompanado = True

if edad >= 18 or acompanado:
    print("Puede entrar")
```

.div_bloque.small[
.hi-blue[Idea:]

Las condiciones pueden ser combinadas.
]

---

# Error típico

.smallest[
Cuidado con condiciones mal escritas:
]

```python
x = 10

if x > 5 or 20:
    print("OK")
```

.div_bloque.small[
.hi-red[Problema:]

Esto siempre es True
]

.smallest[
¿Por qué?

> `20` se interpreta como True
]

---

# Forma correcta

.smallest[
Hay que escribir ambas condiciones:
]

```python
if x > 5 or x < 20:
 print("OK")
```

---

# Prioridad de operadores

.div_bloque[
`not` → `and` → `or`
]

```python
print(True or False and False)
```

.smallest[
Se evalúa como:

```python
True or (False and False)
```
]

---

# Usa paréntesis

.div_bloque[
Para evitar errores, usa paréntesis.
]

```python
if (x > 5) and (x < 20):
 print("en rango")
```

.smallest[
Hace el código más claro.
]

---

# Ejemplo realista

.smallest[
Lectura de código:
]

```python
edad = 30
pais = "ES"

if edad > 18 and (pais == "ES" or pais == "PT"):
    print("Acceso permitido")
```

.smallest[
Pregunta:

> ¿qué condiciones se están comprobando?
]

---

# Leer código IA

.div_bloque[
Cuando veas condiciones:
]

.smallest[
- identifica cada parte  
- separa condiciones  
- revisa operadores  
]

.div_bloque.small[
.hi-red[Idea clave:]

> los errores aquí son muy frecuentes por que el .hi-blue[agua siempre coge un atajo]: el programa se va a ir por algun lado sin reportar error!!!
]

---

# Qué debes entender

.smallest[
En el material, fíjate en:

- cómo funciona `and`, `or`, `not`  
- cómo se combinan condiciones  
- errores típicos  
- uso de paréntesis  
]

.div_bloque[
.hi-blue[Idea final:]

>Las decisiones complejas dependen de cómo combinamos condiciones.
]

---

# Condicionales anidados: nested if

> Estructuras más complejas

> Qué es un nested if

>> .div_bloque[
Un `if` dentro de otro `if`.
]

```python
edad = 20
ingresos = 1500

if edad > 18:
    if ingresos > 1000:
        print("Acceso permitido")
```

.smallest[
Primero se evalúa la condición externa.

Luego la interna.
]

---

# Cómo se ejecuta

.smallest[
El flujo es secuencial:
]

.smallest[
1. se evalúa el primer `if`  
2. si es True → entra en el bloque  
3. se evalúa el segundo `if`  
]

.div_bloque[
> ambas condiciones deben cumplirse
]

---

# Problema de legibilidad

.div_bloque[
Los nested if pueden ser difíciles de leer.
]

```python
if edad > 18:
    if ingresos > 1000:
        print("Acceso")
```

.smallest[
Esto es equivalente a:
]

```python
if edad > 18 and ingresos > 1000:
    print("Acceso")
```

---

# Regla práctica

.div_bloque[
Evita nested if cuando puedas usar operadores lógicos.
]

.smallest[
Código más limpio = más fácil de leer
]

---

# Cuándo usar nested if

.smallest[
A veces sí son necesarios.
]

```python
if usuario == "admin":
    if activo:
        print("Acceso total")
    else:
        print("Usuario inactivo")
```

.div_bloque.small[
Aquí hay una jerarquía lógica.
]

---

# Alternativa con elif

.smallest[
A veces es mejor reorganizar el código.
]

```python
if usuario != "admin":
    print("Acceso limitado")
elif not activo:
    print("Usuario inactivo")
else:
    print("Acceso total")
```

---

# Error típico

.smallest[
Indentación incorrecta:
]

```python
if edad > 18:
print("Acceso")
```

.div_bloque.small[
.hi-red[Resultado:]

`IndentationError`
]

---

# Error lógico

.smallest[
Código difícil de entender:
]

```python
if edad > 18:
    if ingresos > 1000:
        if pais == "ES":
            print("OK")
```

.div_bloque.small[
.hi-red[Problema:]

Demasiados niveles
]

---

# Mejor alternativa

.smallest[
Más claro:
]

```python
if edad > 18 and ingresos > 1000 and pais == "ES":
    print("OK")
```

.div_bloque.small[
.hi-blue[Idea:]

Menos niveles → más claridad
]

---

# Leer código IA

.div_bloque[
Cuando veas nested if:
]

.smallest[
- intenta simplificar mentalmente  
- busca condiciones combinables  
- revisa indentación  
]

.div_bloque.small[
.hi-red[Idea clave:]

&gt; código correcto no siempre es código claro
]

---

# Qué debes entender

.smallest[
En el material, fíjate en:

- cómo funcionan los nested if  
- cuándo evitarlos  
- cómo simplificar condiciones  
- problemas de indentación  
]

.div_bloque[
.hi-blue[Idea final:]

>El buen código no solo funciona, también se entiende.
]

---

# Tareas

> Qué tenéis que hacer

>>.div_bloque[
En esta parte vais a trabajar con condicionales.
]

.smallest[
Para cada ejemplo del material:

1. copia el código en JupyterLab  
2. ejecútalo (`Shift + Enter`)  
3. observa qué se imprime  
4. intenta explicarlo  
]

---

# Cómo trabajar

.div_bloque[
No copies sin pensar.
]

.smallest[
Para cada `if`, pregúntate:

- ¿qué condición se está evaluando?  
- ¿qué pasa si es True?  
- ¿qué pasa si es False?  
]

---

# Prueba cambios

.smallest[
No te limites a ejecutar.
]

.smallest[
Cambia valores y observa qué pasa:
]

```python
nota = 6

if nota >= 5:
    print("Aprobado")
else:
    print("Suspenso")
```

.smallest[
Prueba:

- `nota = 4`  
- `nota = 5`  
- `nota = 10`  
]

---

# Detectar errores

.div_bloque[
Muchos errores no dan error.
]

.smallest[
Ejemplo:
]

```python
nota = 5

if nota > 5:
    print("Aprobado")
```

.smallest[
Pregunta:

&gt; ¿es correcto?
]

---

# Casos límite

.div_bloque[
Siempre prueba valores límite.
]

.smallest[
Ejemplos:

- `nota = 5`  
- `edad = 18`  
- `precio = 0`  
]

.smallest[
> aquí es donde fallan muchos programas
]

---

# Leer código

.smallest[
Cuando leas código (IA incluida):
]

.smallest[
- revisa operadores (`>`, `>=`, `==`)  
- revisa el orden de condiciones  
- revisa indentación  
]

---

# Si algo no entiendes

.div_bloque[
No sigas adelante.
]

.smallest[
Prueba:

- usar `print()`  
- cambiar valores  
- simplificar la condición  
- aprende a elaborar un `prompt` y preguntarlo a la IA
]

---

# Trabajo individual

.div_bloque[
Cada uno a su ritmo.
]

.smallest[
- algunos ejemplos serán fáciles  
- otros requieren más tiempo  
]

.smallest[
> lo importante es entender, no terminar todo
]

---

# Qué deberías conseguir

.smallest[
Al final de la sesión deberías poder:

- leer condicionales en Python  
- entender el flujo del programa  
- detectar errores lógicos  
- interpretar código generado por IA  
]