Introducción a Python

class: center, middle, inverse, title-slide

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

---

class: inverse, middle

.huge[Clase 5]

## Iterables e iteradores

---

# Guía de lectura

.smallest[
Hasta ahora:

- sabemos trabajar con listas, tuplas y diccionarios  
- sabemos usar condicionales (`if`)  
]

.div_bloque[
Ahora damos un paso clave:

> recorrer datos automáticamente
]

.smallest[
En esta clase aprenderás:

- qué es un iterable  
- qué es un iterador  
- cómo Python recorre objetos  
]

---

# Qué es un iterable

.div_bloque[
Un iterable es un objeto que se puede recorrer elemento a elemento.
]

.smallest[
Ejemplos:

- listas  
- strings  
- tuplas  
- diccionarios  
]

```python
for letra in "Python":
    print(letra)
```

---

# Intuición

.div_bloque[
Un iterable es algo que puedes leer “uno a uno”.
]

.smallest[
Como:

- una lista de números  
- una cadena de texto  
- una colección de datos  
]

---

# Qué es un iterador

.div_bloque[
Un iterador es el objeto que hace el recorrido.
]

.smallest[
Python lo crea automáticamente en un bucle `for`.
]

```python
numeros = [10, 20, 30]

it = iter(numeros)

print(next(it))
print(next(it))
print(next(it))
```

---

# Cómo funciona

.smallest[
El iterador:

- recuerda en qué posición está  
- devuelve el siguiente elemento  
]

.smallest[
Cuando no hay más elementos:
]

```python
next(it)
```

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

`StopIteration`
]

---

# Qué hace realmente for

.div_bloque[
El `for` usa un iterador internamente.
]

.smallest[
Esto:
]

```python
for x in [1, 2, 3]:
    print(x)
```

.smallest[
equivale conceptualmente a:
]

```python
it = iter([1, 2, 3])

while True:
    try:
        x = next(it)
        print(x)
    except StopIteration:
        break
```

--
.div_bloque.small[
.hi-blue[Mirar-observar] el código para crearse dudas que se resolvarán despues
]

---

# Por qué importa

.div_bloque[
Esto explica cómo Python recorre datos.
]

.smallest[
Te ayudará a:

- entender bucles  
- leer código complejo  
- interpretar código de IA  
]

---

# Iterables comunes

.smallest[
En el material verás:
]

```python
[1, 2, 3]          # lista
(1, 2, 3)          # tupla
"hola"             # string
{"a": 1, "b": 2}   # diccionario
```

.smallest[
Todos ellos son iterables.
]

---

# Idea clave

.div_bloque[
Un iterable contiene datos.

Un iterador recorre esos datos.
]

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

> Los bucles funcionan porque los objetos son iterables.
]

---

#  for

> `for` recorrer datos

>Estructura básica

>>.div_bloque[
El bucle `for` recorre un iterable.
]

```python
for x in [1, 2, 3]:
    print(x)
```

.smallest[
En cada iteración:

> `x` toma un valor distinto
]

---

# Qué hace el for

.smallest[
Proceso:

1. toma el primer elemento  
2. ejecuta el bloque  
3. pasa al siguiente  
]

.div_bloque[
> hasta que no quedan objetos en el iterable
]

---

# Ejemplo con lista

```python
numeros = [10, 20, 30]

for n in numeros:
    print(n)
```

.smallest[
n → 10, luego 20, luego 30
]

---

# Ejemplo con string

```python
for letra in "Python":
    print(letra)
```

.smallest[
Un string también es iterable.
]

---

# Nombre de la variable

.div_bloque[
El nombre lo eliges tú.
]

```python
for fruta in ["manzana", "pera", "uva"]:
    print(fruta)
```

.smallest[
Debe ser descriptivo.
]

---

# Error típico

.smallest[
Sobrescribir la variable:
]

```python
numeros = [1, 2, 3]

for numeros in numeros:
    print(numeros)
```

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

pierdes la lista original
]

---

# Usar índices

.smallest[
Forma menos recomendable:
]

```python
numeros = [10, 20, 30]

for i in range(len(numeros)):
    print(numeros[i])
```

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

```python
for n in numeros:
    print(n)
```
]

---

# Usar enumerate

.smallest[
`enumerate`: si necesitas índice y valor:
]

```python
numeros = [10, 20, 30]

for i, n in enumerate(numeros):
    print(i, n)
```

.div_bloque.small[
Muy común en código real.
]

---

# Bucle sobre diccionarios

.smallest[
Por defecto, recorre claves:
]

```python
d = {"a": 1, "b": 2}

for k in d:
    print(k, d[k])
```

---

# Valores y pares

```python
for v in d.values():
    print(v)

for k, v in d.items():
    print(k, v)
```

.smallest[
Esto aparece mucho en data analysis.
]

---

# Bucles anidados

.smallest[
Un bucle dentro de otro:
]

```python
for i in range(3):
    for j in range(2):
        print(i, j)
```

.smallest[
Se ejecuta varias veces.
]

---

# Qué debes entender

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

- cómo funciona `for`  
- qué es un iterable  
- cómo elegir nombres  
- cómo leer bucles anidados  
]

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

> `for` recorre automáticamente los elementos de un iterable.
]

---
# while

.div_bloque[.hi-blue[Bucle while]: repetición condicional]

> Estructura básica

>> .div_bloque[
El `while` repite mientras una condición sea verdadera.
]

```python
x = 0

while x < 5:
 print(x)
 x += 1
```

.smallest[
Se repite hasta que la condición es False.
]

---

# Diferencia con for

.div_bloque[
`for` → recorre un iterable  
`while` → depende de una condición  
]

.smallest[
No sabemos de antemano cuántas veces se ejecuta.
]

---

# Cómo funciona

.smallest[
En cada iteración:

1. evalúa la condición  
2. si es True → ejecuta  
3. vuelve a evaluar  
]

.div_bloque[
> no para hasta que sea False
]

---

# Error más peligroso

.div_bloque[
Bucle infinito
]

```python
x = 0

while x < 5:
 print(x)
```

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

x nunca cambia
]

---

# Solución

.smallest[
Siempre debe haber actualización:
]

```python
x = 0

while x < 5:
 print(x)
 x += 1
```

---

# Ejemplo con input

.smallest[
Se repite hasta cumplir condición:
]

```python
numero = -1

while numero != 0:
    numero = int(input("Introduce un número: "))
    print(numero)
```

.smallest[
Termina cuando el usuario introduce 0.
]

---

# Uso de condiciones complejas

```python
x = 0

while x < 10 and x != 5:
 print(x)
 x += 1
```

.smallest[
Se combinan condiciones.
]

---

# Variables de control

.smallest[
A veces usamos flags:
]

```python
activo = True

while activo:
    print("ejecutando")
    activo = False
```

---

# Equivalencia con for

.smallest[
Esto:
]

```python
for i in range(5):
    print(i)
```

.smallest[
equivale a:
]

```python
i = 0

while i < 5:
 print(i)
 i += 1
```

---

# Cuándo usar while

.div_bloque[
Cuando no sabes cuántas veces se repite.
]

.smallest[
Ejemplos:

- esperar una condición  
- input del usuario  
- procesos iterativos  
]

---

# Leer código

.div_bloque[
Cuando veas un `while`:
]

.smallest[
- identifica la condición  
- busca dónde cambia  
- comprueba que termina  
]

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

> si no cambia nada → bucle (loop) infinito
]

---

# Qué debes entender

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

- cómo funciona `while`  
- diferencia con `for`  
- errores típicos  
- cómo leer el flujo  
]

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

> `while` repite mientras la condición sea verdadera.
]

---

# Bucles sobre estructuras

> Listas

.div_bloque[
Recorrer listas es el uso más común.
]

```python
numeros = [10, 20, 30]

for n in numeros:
    print(n)
```

.smallest[
Cada elemento se procesa uno a uno.
]

---

# Transformar datos

.smallest[
Ejemplo: multiplicar valores
]

```python
numeros = [1, 2, 3]

for n in numeros:
    print(n * 2)
```

.div_bloque.small[
Esto aparece constantemente en análisis de datos.
]

---

# Acumulación

.smallest[
Sumar elementos:
]

```python
numeros = [1, 2, 3, 4]

total = 0

for n in numeros:
    total += n

print(total)
```

---

# Filtrar datos

.smallest[
Seleccionar valores:
]

```python
numeros = [1, 2, 3, 4, 5]

for n in numeros:
    if n % 2 == 0:
        print(n)
```

.div_bloque.small[
Esto es la base de muchos análisis.
]

---

# Strings

.smallest[
También podemos recorrer texto:
]

```python
texto = "Python"

for letra in texto:
    print(letra)
```

---

# Diccionarios (claves)

.smallest[
Por defecto:
]

```python
d = {"a": 1, "b": 2}

for k in d:
    print(k)
```

---

# Diccionarios (valores)

```python
for v in d.values():
    print(v)
```

---

# Diccionarios (pares)

```python
for k, v in d.items():
    print(k, v)
```

.div_bloque.small[
Este patrón es muy importante.
]

---

# Lista de diccionarios

.smallest[
Muy común en datos:
]

```python
datos = [
    {"nombre": "Ana", "nota": 8},
    {"nombre": "Luis", "nota": 7}
]

for alumno in datos:
    print(alumno["nombre"], alumno["nota"])
```

.smallest[
Esto aparece mucho en código de IA.
]

---

# Sets

.smallest[
Recorrer elementos únicos:
]

```python
s = {1, 2, 3}

for x in s:
    print(x)
```

.smallest[
El orden no está garantizado.
]

---

# Bucles anidados

.smallest[
Trabajar con estructuras complejas:
]

```python
matriz = [
    [1, 2],
    [3, 4]
]

for fila in matriz:
    for valor in fila:
        print(valor)
```

---

# Error típico

.smallest[
Modificar estructura mientras iteras:
]

```python
lista = [1, 2, 3]

for x in lista:
    lista.append(x)
```

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

bucle infinito o comportamiento inesperado
]

---

# Idea clave

.div_bloque[
Los bucles permiten trabajar con datos reales.
]

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

> Data analysis = recorrer y transformar datos
]

---
# Walrus operator `:=`

.div_bloque.small[

>  Asignar valores dentro de una expresión

>> `:=` “calcula y guarda el resultado en una variable”

>> Se llama assignment expression (PEP 572), pero todo el mundo lo llama walrus operator.

]

.div_bloque.small[
Supongamos que queremos calcular el cuadrado de varios números y mostrar solo los que sean mayores que 5.

```python
for x in range(5):
    y = x**2
    if y > 5:
        print(y)
```
]

.div_bloque.small[

Con el operador walrus podemos asignar `y` dentro del propio `if`:

```python
for x in range(5):
    if (y := x**2) > 5:
        print(y)
```
]

---
# Walrus

.div_bloque.small[
> ¿Qué está pasando aquí?

```python
if (y := x**2) > 5:
```

Python hace tres cosas:

1. Calcula `x**2`
2. Guarda el resultado en `y`
3. Comprueba si `y > 5`

Es decir, esta línea:

```python
if (y := x**2) > 5:
```

equivale a:

```python
y = x**2
if y > 5:
```
]
---
# Comprehensions

.hi-blue[List Comprehensions]: Código más compacto

> Motivación

>> .div_bloque[
Queremos transformar listas de forma compacta.
]

.smallest[
Forma clásica:
]

```python
numeros = [1, 2, 3]
resultado = []

for n in numeros:
    resultado.append(n * 2)

print(resultado)
```

---

# List comprehension

.div_bloque[
Forma más compacta:
]

```python
numeros = [1, 2, 3]

resultado = [n * 2 for n in numeros]

print(resultado)
```

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

misma lógica, menos código
]

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

Recordar que la IA les dará el codigo: ustedes deben saber cómo interpretarlo o cómo pedirle el coódigo deseado a la IA mediante un prompt con coneptos (e.g., list comprehensions) adecuados
]

---

# Estructura

.smallest[
Forma general:
]

```python
[expresion for elemento in iterable]
```

.smallest[
Se lee como:

> “para cada elemento, calcula esto”
]

---

# Con condición

.smallest[
Podemos filtrar:
]

```python
numeros = [1, 2, 3, 4, 5]

pares = [n for n in numeros if n % 2 == 0]

print(pares)
```

.smallest[
Resultado: [2, 4]
]

---

# Transformar + filtrar

```python
numeros = [1, 2, 3, 4, 5]

resultado = [n * 2 for n in numeros if n > 2]

print(resultado)
```

---
# Walrus

El operador walrus también se puede usar dentro de una list comprehension.

Por ejemplo:

```python
[x for x in range(10) if (y := x**2) > 20]
```

Para cada `x`:

1. Calcula `x**2`
2. Guarda el resultado en `y`
3. Conserva `x` solo si `y > 20`

---

# Strings

.smallest[
También funciona con texto:
]

```python
texto = "python"

mayus = [letra.upper() for letra in texto]

print(mayus)
```

--
.div_bloque.small[

Imaginemos que queremos quedarnos con las palabras cuya longitud sea mayor que 5.

```python
palabras = ["sol", "python", "universidad", "casa", "programar"]
```

Sin walrus:

```python
largas = []

for palabra in palabras:
    longitud = len(palabra)
    if longitud > 5:
        largas.append(palabra)
```
> Con list comprehension y walrus

```python
largas = [
    palabra
    for palabra in palabras
    if (longitud := len(palabra)) > 5
]
```

]

---

# Diccionarios (concepto)

.smallest[
Ejemplo básico:
]

```python
numeros = [1, 2, 3]

d = {n: n**2 for n in numeros}

print(d)
```

.smallest[
Esto aparece mucho en código real.
]

---

# Set comprehension

.smallest[
También con sets:
]

```python
numeros = [1, 2, 2, 3]

s = {n for n in numeros}

print(s)
```

---

# Comparación

.div_bloque[
Dos formas equivalentes:
]

.smallest[
Bucle:
]

```python
res = []
for n in numeros:
    res.append(n * 2)
```

.smallest[
Comprehension:
]

```python
res = [n * 2 for n in numeros]
```

---

# Cuándo usarla

.div_bloque[
Usa comprehensions cuando:
]

.smallest[
- la lógica es simple  
- quieres código compacto  
]

.smallest[
Evita cuando:

- hay muchas condiciones  
- el código se vuelve difícil de leer  
]

---

# Error típico

.smallest[
Demasiado complejo:
]

```python
[x * 2 if x > 2 else x for x in numeros if x != 3]
```

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

difícil de leer
]

---

# Leer código IA

.div_bloque[
Las comprehensions aparecen constantemente.
]

.smallest[
Cuando las veas:

- identifica el iterable  
- identifica la expresión  
- identifica la condición  
]

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

tradúcelo mentalmente a un bucle
]

---

# Qué debes entender

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

- cómo funciona la estructura  
- cómo filtrar  
- cómo transformar  
- cuándo usarla  
]

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

> Una comprehension es un bucle escrito en una sola línea.
]