Introducción a Python

.title[
# Introducción a Python
]
.subtitle[
## Clase 6c: Funciones de Primera Clase
]
.author[
### Daniel Miles Touya Máster en Análisis de Datos · UdelaR-Uvigo
]
.date[
### 24 abril 2026
]

---

## Funciones como objetos

---

# Guía de lectura

- sabemos definir funciones  
- sabemos usarlas  
]

&gt; las funciones son datos
]

---

# Idea clave

- números  
- listas  
- strings  
]

---

# Ejemplo

```python
def square(x):
    return x * x

print(type(square))
```

---

# Propiedades de objeto

```python
print(square.__name__)
print(id(square))
print(dir(square))
```

---

# Nombre vs objeto

---

```python
def square(x):
    return x * x

f = square

print(f(5))
print(f is square)
```

---

# Diferencia clave

```python
f = square     # función
g = square(5)  # resultado
```

.div_bloque.small[
.hi-red[MUY importante:]

paréntesis → ejecuta  
sin paréntesis → objeto
]

---

# Borrar el nombre

```python
def square(x):
    return x * x

f = square

del square

print(f(5))
```

---

# Idea profunda

---

# Mini ejercicio 1

```python
def doble(x):
    return x * 2

g = doble

print(g)
print(g(5))
print(type(g))
```

---

# Mini ejercicio 2

```python
a = doble
b = doble(3)

print(type(a))
print(type(b))
```

---

# Por qué importa

---

# Idea final

---

# Parte II · Funciones como argumentos

## Funciones como input

---

# Idea clave

---

# Motivación

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

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

---

# Problema

```python
# cuadrados
# cubos
# raíces
```

---

# Solución

---

# Ejemplo

```python
def cuadrado(x):
    return x**2

def my_map(func, lista):
    res = []
    for x in lista:
        res.append(func(x))
    return res
```

---

# Uso

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

print(my_map(cuadrado, numeros))
```

---

# Idea clave

---

# Ejemplo con built-in

```python
print(my_map(len, ["hola", "python"]))
```

---

# Ejemplo más general

```python
def derivada(f, x, h=1e-5):
    return (f(x+h) - f(x)) / h
```

---

# Uso

```python
def cuadrado(x):
    return x**2

print(derivada(cuadrado, 3))
```

---

# Idea profunda

- el algoritmo  
- la función concreta  
]

---

# Mini ejercicio 1

```python
def aplicar(func, x):
    return func(x)

print(aplicar(abs, -5))
print(aplicar(str, 10))
```

---

# Mini ejercicio 2

```python
def f(x):
    return x + 1

def g(x):
    return x * 2

funciones = [f, g]

for fun in funciones:
    print(fun(3))
```

---

# Mini ejercicio 3

```python
def suma(a, b):
    return a + b

print(my_map(suma, [1, 2, 3]))
```

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

firma incorrecta
]

---

# Patrón real

---

# Leer código IA

```python
df.apply(func)
```

---

# Qué debes entender

&gt; Pasar funciones permite escribir código general.
]

---

# Parte III · Fábricas y closures

## Closures

---

# Motivación

---

# Ejemplo básico

```python
def crear_sumador(n):
    def suma(x):
        return x + n
    return suma
```

---

# Uso

```python
sumar_5 = crear_sumador(5)

print(sumar_5(10))
```

---

# Qué está pasando

---

# Closure

---

# Ejemplo paso a paso

.smallest[
1. se llama crear_sumador(5)  
2. se crea suma(x)  
3. suma “recuerda” n = 5  
4. se devuelve suma  
]

---

# Otro ejemplo

```python
def multiplicador(k):
    def f(x):
        return x * k
    return f
```

---

# Uso

```python
por_3 = multiplicador(3)

print(por_3(4))
```

---

# Idea clave

---

# Mini ejercicio 1

```python
f1 = crear_sumador(2)
f2 = crear_sumador(10)

print(f1(5))
print(f2(5))
```

---

# Mini ejercicio 2

```python
def f(n):
    def g(x):
        return x * n
    return g

h = f(3)

print(h(2))
```

---

# Mini ejercicio 3

```python
f1 = crear_sumador(5)
f2 = crear_sumador(5)

print(f1 == f2)
```

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

mismo comportamiento ≠ mismo objeto
]

---

# Error típico

---

# Cuándo se usa

---

# Conexión con IA

- funciones que dependen de parámetros  
- pipelines dinámicos  
]

---

# Leer código

```python
def outer(...):
    def inner(...):
        ...
    return inner
```

---

# Qué debes entender

.smallest[
- funciones que devuelven funciones  
- qué es un closure  
- cómo se “recuerda” el entorno  
]

&gt; Un closure es una función con memoria.
]

---

# Parte IV · Paradigma funcional

## Functional programming

---

# Idea general

- pasos secuenciales  
]

- transformaciones de datos  
]

---

# Comparación

```python
res = []
for x in [1, 2, 3]:
    res.append(x * 2)
```

```python
res = [x * 2 for x in [1, 2, 3]]
```

---

# Funciones puras

---

# Ejemplo

```python
def cuadrado(x):
    return x**2
```

---

# Función no pura

```python
total = 0

def suma(x):
    global total
    total += x
```

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

depende del estado externo
]

---

# Ventajas

---

# Composición de funciones

```python
def doble(x):
    return x * 2

def suma1(x):
    return x + 1

print(doble(suma1(3)))
```

---

# Map

```python
list(map(lambda x: x * 2, [1, 2, 3]))
```

---

# Lambda

```python
lambda x: x * 2
```

```python
sorted([3, 1, 2], key=lambda x: x)
```

---

# Patrón general

```python
res = list(map(lambda x: x * 2, datos))
```

---

# Mini ejercicio 1

```python
list(map(lambda x: x + 1, [1, 2, 3]))
```

---

# Mini ejercicio 2

```python
def f(x):
    return x + 1

def g(x):
    return x * 2

print(g(f(3)))
```

---

# Mini ejercicio 3

```python
x = 10

def f(y):
    return x + y
```

---

# Conexión con IA

---

# Qué debes entender

&gt; Programar es transformar datos usando funciones.
]