Introducción a Python

class: center, middle, inverse, title-slide

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

---

class: inverse, middle

.huge[Clase 6a]

## Qué es una función

---

# Guía de lectura

.smallest[
Hasta ahora:

- escribimos código paso a paso  
- todo era explícito  
]

.div_bloque[
Ahora cambiamos de nivel:

> empezamos a abstraer
]

.smallest[
Objetivo:

- entender qué es una función  
- entender por qué existen  
- aprender a leerlas  
]

---

# Problema

.div_bloque[
Código repetido.
]

```python
print("Hola Ana")
print("Hola Luis")
print("Hola Marta")
```

.smallest[
No es escalable.
]

---

# Idea de función

.div_bloque[
Una función es código con nombre.
]

.smallest[
- se define una vez  
- se usa muchas veces  
]

---

# Ejemplo

```python
def saludar(nombre):
    print("Hola", nombre)

saludar("Ana")
saludar("Luis")
```

.div_bloque.small[
Reutilización.
]

---

# Idea profunda (muy importante)

.div_bloque[
Las funciones cambian cómo pensamos el código.
]

---

# Abstracción de proceso

.smallest[
Usamos funciones sin saber cómo funcionan.
]

```python
round(88.5678, 2)
sorted([5, 2, 8, 1])
len([1, 2, 3])
```

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

> importa qué hacen, no cómo
]

---

# Consecuencia

.smallest[
Puedes usar funciones sin leer su código.
]

.div_bloque[
Esto es clave para leer código de IA.
]

---

# Descomposición de tareas

.div_bloque[
Dividir problemas en partes.
]

```python
def calcular_media(datos):
    return sum(datos) / len(datos)

def calcular_maximo(datos):
    return max(datos)
```

.smallest[
Cada función hace una cosa.
]

---

# Programa principal

.smallest[
En el programa principal, referenciamos las funcines en un código más limpio
]

```python
def analizar(datos):
    return calcular_media(datos), calcular_maximo(datos)
```

.div_bloque.small[
Código más claro.
]

---

# Ventajas

.smallest[
- reutilización  
- verificación  
- legibilidad  
]

---

# Conexión con IA

.div_bloque[
No pedir scripts grandes.
]

.smallest[
Mejor:

- funciones pequeñas  
- verificables  
- combinables  
]

---

# Idea clave

.small[**Una función** = una unidad de lógica]

.small[
Que puedes entender sin ver su interior.
]

---

#Definición, llamada y return

.small[.hi-blue[Cómo funcionan]]

> Definir una función

>>.div_bloque[
Se usa la palabra clave `def`.
]

```python
def saludar(nombre):
    print("Hola", nombre)
```

.smallest[
Esto **NO** ejecuta la función.
]

---

# Llamar a una función

.div_bloque[
La ejecución ocurre al llamarla.
]

```python
saludar("Ana")
saludar("Luis")
```

.smallest[
Ahora sí se ejecuta el código.
]

---

# Parámetros vs argumentos

.smallest[
- parámetro → en la definición  
- argumento → en la llamada  
]

```python
def suma(a, b):   # parámetros
    print(a + b)

suma(2, 3)        # argumentos
```

---

# Qué hace return

.div_bloque[
`return` devuelve un valor.
]

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

resultado = suma(2, 3)

print(resultado)
```

---

# Diferencia clave

.smallest[
Comparar:
]

```python
def f1(x):
    print(x * 2)

def f2(x):
    return x * 2
```

.smallest[
Uso:
]

```python
a = f1(3)
b = f2(3)

print(a)
print(b)
```

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

`print` muestra  
`return` devuelve
]

---

# Qué devuelve una función

.smallest[
Si no hay `return`:
]

```python
def f(x):
    y = x * 2

print(f(3))
```

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

`None`
]

---

# Múltiples returns

.smallest[
Una función puede devolver diferentes valores:
]

```python
def evaluar(nota):
    if nota >= 5:
        return "Aprobado"
    else:
        return "Suspenso"
```

---

# Return detiene la función

.div_bloque[
Cuando aparece `return`, la función termina.
]

```python
def f():
    return 1
    print("Esto no se ejecuta")
```

---

# Devolver varios valores

.smallest[
Podemos devolver varios resultados:
]

```python
def operaciones(a, b):
    return a + b, a * b

suma, producto = operaciones(2, 3)

print(suma, producto)
```

---

# Uso típico

.smallest[
Funciones como transformación:
]

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

resultado = cuadrado(4)
```

.smallest[
Muy común en análisis de datos.
]

---

# Error típico

.smallest[
Olvidar `return`:
]

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

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

no devuelve nada
]

---

# Leer código IA

.div_bloque[
Cuando veas una función:
]

.smallest[
- busca `return`  
- identifica qué devuelve  
- mira cómo se usa después  
]

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

el valor devuelto es lo importante
]

---

# Qué debes entender

.smallest[
En el material que te adjunto en html, fíjate en:

- cómo definir funciones  
- diferencia entre `print` y `return`  
- qué devuelve una función  
- cómo se usan los resultados  
]

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

> Una función devuelve un valor (un value, un objeto, no tiene porque se un valor numerico)que puedes reutilizar.
]

---

# Tipos de argumentos

.small[**Argumentos**: cómo pasan los datos]

> Argumentos en funciones

>> Motivación

>>.div_bloque[
Las funciones pueden recibir datos de distintas formas.
]

.smallest[
Esto hace el código más flexible.
]

---

# Argumentos posicionales

.div_bloque[
Se asignan por orden.
]

```python
def resta(a, b):
    return a - b

print(resta(10, 3))
```

.smallest[
a = 10, b = 3
]

---

# Error típico

.smallest[
Cambiar el orden cambia el resultado:
]

```python
print(resta(3, 10))
```

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

El orden importa
]

---

# Argumentos con nombre

.div_bloque[
Podemos especificar el nombre.
]

```python
print(resta(a=10, b=3))
print(resta(b=3, a=10))
```

.smallest[
El orden ya no importa.
]

---

# Ventaja

.div_bloque[
Más claridad.
]

.smallest[
Muy útil en funciones largas.
]

---

# Argumentos por defecto

.div_bloque[
Podemos definir valores por defecto.
]

```python
def saludar(nombre="Usuario"):
    print("Hola", nombre)

saludar()
saludar("Ana")
```

.smallest[
Si no se pasa argumento → usa el valor por defecto.
]

---

# Regla importante

.div_bloque[
Los argumentos por defecto van al final.
]

```python
def f(a, b=2):
    return a + b
```

.smallest[
Esto es correcto.
]

---

# Error típico

```python
def f(a=2, b):
    return a + b
```

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

Error de sintaxis
]

---

# Mezclar tipos

.smallest[
Podemos combinar:
]

```python
def f(a, b=2):
    return a + b

print(f(3))
print(f(3, 5))
```

---

# Argumentos nombrados + posicionales

.smallest[
Regla:
]

```python
f(3, b=5)
```

.smallest[
Primero posicionales, luego nombrados.
]

---

# Error típico

```python
f(a=3, 5)
```

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

orden incorrecto
]

---

# Ejemplo real

.smallest[
Funciones en librerías:
]

```python
round(3.1416, ndigits=2)
```

.smallest[
Esto es muy común.
]

---

# Leer código IA

.div_bloque[
Cuando veas una función:
]

.smallest[
- identifica argumentos  
- mira si hay valores por defecto  
- distingue posicional vs nombrado  
]

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

esto cambia el comportamiento
]

---

# Qué debes entender

.smallest[
En el html, fijate en:

- argumentos posicionales  
- argumentos nombrados  
- valores por defecto  
- reglas de orden  
]

.div_bloque[
.hi-blue[Cuestión:]

> Cómo pasas los argumentos cambia el resultado de la función.
]

---

# Argumentos flexibles:· *args y **kwargs

> Motivación

>>.div_bloque[
¿Y si no sabemos cuántos argumentos habrá qué hacemos?
]

.smallest[
Queremos funciones más flexibles.
]

---

# *args

.div_bloque[
`*args` recoge argumentos posicionales.
]

--
.small[
>Suma sobre un número indefinido de valores
]

```python
# Iterar sobre args
def suma(*args):
    total = 0
    for x in args:
        total += x
    return total
```
--

> Cómo se empaca arg

````python
arg = (1,2,3)
suma(*arg)
````

>> Una tupla

---
# Otos ejemplos

> suma flexible

```python
def total_ventas(*ventas):
    return sum(ventas)

print(total_ventas(100, 200, 300))
```
--

> logging flexible

```python
def log(*mensajes):
    for m in mensajes:
        print("LOG:", m)

log("inicio", "cargando datos", "fin")
```

> máximo personalizado

```python
def maximo(*args):
    return max(args)

print(maximo(3, 7, 2, 9))
```

---
# Otos ejemplos

.smallest[
> concatenar texto

```python
def unir_textos(*args):
    return " ".join(args)

print(unir_textos("hola", "mundo"))
```
]
--
.smallest[
> forwarding (MUY IMPORTANTE)

```python
def wrapper(*args):
    return sum(args)

def f(*args):
    return wrapper(*args)

print(f(1, 2, 3))
```
]
--
.smallest[
> Funciones dinámicas

```python
def aplicar_funcion(func, *args):
    return func(*args)

print(aplicar_funcion(sum, [1,2,3]))
```
]
--
.smallest[
> pipeline

```python
def pipeline(*funcs):
    def aplicar(x):
        for f in funcs:
            x = f(x)
        return x
    return aplicar
```
]

---

# Idea clave

.div_bloque[
*args aparece cuando:

- no sabes cuántos inputs habrá  
- quieres flexibilidad  
- reenvías argumentos  
]

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

> *args permite escribir funciones reutilizables y generales.
]

---

# Cuándo usarlo

.div_bloque[
Cuando el número de argumentos es variable.
]

---

# **kwargs

.div_bloque[
`**kwargs` recoge argumentos con nombre.
]

```python
def mostrar(**kwargs):
    print(kwargs)

mostrar(a=1, b=2)
```

.smallest[
Resultado:

```python
{'a': 1, 'b': 2}
```
]

---

# Cómo funciona

.smallest[
`**kwargs` es un diccionario.
]

```python
def mostrar(**kwargs):
    for k, v in kwargs.items():
        print(k, v)
```

---

# Ejemplo conjunto

.smallest[
Podemos combinarlos:
]

```python
def f(*args, **kwargs):
    print(args)
    print(kwargs)

f(1, 2, a=3, b=4)
```

---

# Orden correcto

.div_bloque[
Regla:
]

.smallest[
1. argumentos normales  
2. `*args`  
3. `**kwargs`  
]

```python
def f(a, *args, **kwargs):
    pass
```

---

# Error típico

.smallest[
Orden incorrecto:
]

```python
def f(**kwargs, *args):
    pass
```

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

error de sintaxis
]

---

# Uso real

.smallest[
Muy común en librerías:
]

```python
def modelo(x, **kwargs):
    pass
```

.smallest[
Permite añadir opciones sin cambiar la función.
]

---

# Lectura de código IA

.div_bloque[
Cuando veas `*args` o `**kwargs`:
]

.smallest[
- `*args` → muchos valores  
- `**kwargs` → opciones con nombre  
]

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

flexibilidad total
]

---

# Qué debes entender

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

- qué hace `*args`  
- qué hace `**kwargs`  
- cómo se usan juntos  
- en qué casos aparecen  
]

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

&gt; `*args` y `**kwargs` permiten funciones más generales y reutilizables.
]