Funciones: empaqueta lógica y reutilízala

Imagina que eres un chef y cada vez que alguien pide una tortilla, tienes que explicar desde cero cómo se hace — a ti mismo. "Rompe 3 huevos, bate, pon aceite en sartén, calienta..." Y cuando piden otra tortilla, lo repites todo OTRA VEZ. Absurdo, ¿no? Lo lógico sería tener un libro de recetas donde la tortilla ya está escrita, y simplemente dices: "haz la receta de la tortilla". Eso es una función: un bloque de código con nombre que puedes "llamar" (ejecutar) cuando quieras, sin repetir la lógica.

### La metáfora: la receta con nombre

Una función es exactamente como una receta de cocina guardada en un libro. Tiene un NOMBRE (para poder referirte a ella), puede recibir INGREDIENTES (que en programación se llaman parámetros) y PRODUCE UN RESULTADO (el plato terminado, que en programación se llama valor de retorno). La receta de "limonada" necesita los ingredientes: limones, agua y azúcar. Y produce: un vaso de limonada. La próxima vez que quieras limonada, no reinventas la receta — la llamas por su nombre.

Las funciones resuelven DOS problemas enormes: 1) REPETICIÓN — si necesitas hacer lo mismo en 5 lugares de tu código, escribes la función una vez y la llamas 5 veces. Si luego hay que cambiar algo, lo cambias en UN solo lugar. 2) COMPLEJIDAD — divides un problema grande en trozos pequeños y manejables. En vez de un programa de 500 líneas imposible de entender, tienes 20 funciones de 25 líneas cada una, cada una con un nombre que explica qué hace.

### Crear y usar funciones en Python

En Python, defines una función con la palabra def, seguida del nombre, paréntesis con los parámetros y dos puntos. El código de la función va indentado debajo. Para devolver un resultado usas return. Para USAR (llamar) la función, escribes su nombre con los valores que quieres pasarle entre paréntesis.

1# DEFINIR una función (escribir la receta)
2def saludar(nombre):
3    """Muestra un saludo personalizado."""
4    print(f"¡Hola, {nombre}! Bienvenido al programa.")
5
6# LLAMAR a la función (usar la receta)
7saludar("Ana")      # ¡Hola, Ana! Bienvenido al programa.
8saludar("Carlos")   # ¡Hola, Carlos! Bienvenido al programa.
9saludar("María")    # ¡Hola, María! Bienvenido al programa.
10
11# Función con RETURN (devuelve un valor)
12def calcular_iva(precio, porcentaje_iva=21):
13    """Calcula el precio con IVA incluido."""
14    iva = precio * (porcentaje_iva / 100)
15    total = precio + iva
16    return total
17
18# Usar el valor devuelto
19precio_final = calcular_iva(100)
20print(f"100€ + IVA = {precio_final}€")  # 121.0€
21
22# Con otro porcentaje de IVA
23precio_reducido = calcular_iva(100, 10)
24print(f"100€ + IVA reducido = {precio_reducido}€")  # 110.0€

### Parámetros vs argumentos: la diferencia sutil

Cuando DEFINES la función, los nombres entre paréntesis son PARÁMETROS (los huecos vacíos de la receta: "necesito X gramos de harina"). Cuando LLAMAS a la función, los valores que le pasas son ARGUMENTOS (los ingredientes concretos que usas: "voy a usar 200 gramos de harina"). En la práctica la gente los usa como sinónimos — no te preocupes demasiado por la diferencia.

### Funciones que no devuelven nada vs funciones que sí

Hay dos tipos de funciones: las que HACEN algo (imprimir, guardar un archivo) y las que CALCULAN algo (y devuelven el resultado con return). Las primeras son como un robot que mueve cajas — hace un trabajo pero no te da nada. Las segundas son como una calculadora — le das números y te devuelve un resultado que puedes guardar en una variable.

1# Función que HACE algo (no return)
2def mostrar_ticket(producto, precio, cantidad):
3    """Imprime un ticket de compra formateado."""
4    total = precio * cantidad
5    print("=" * 30)
6    print(f"Producto: {producto}")
7    print(f"Precio unidad: {precio:.2f}€")
8    print(f"Cantidad: {cantidad}")
9    print(f"TOTAL: {total:.2f}€")
10    print("=" * 30)
11
12mostrar_ticket("Café", 1.50, 3)
13
14# Función que CALCULA algo (con return)
15def calcular_media(numeros):
16    """Calcula la media de una lista de números."""
17    suma = 0
18    for n in numeros:
19        suma = suma + n
20    media = suma / len(numeros)
21    return media
22
23notas = [7.5, 8.0, 6.5, 9.0, 7.0]
24mi_media = calcular_media(notas)
25print(f"Tu media es: {mi_media}")  # 7.6
26
27# Puedes usar el resultado en decisiones
28if mi_media >= 7:
29    print("¡Notable!")

### Scope: las variables dentro de una función son privadas

Las variables que creas DENTRO de una función solo existen DENTRO de esa función. Es como si cada función fuera una habitación cerrada — lo que pasa dentro se queda dentro. Esto se llama "scope" (alcance) y es bueno porque evita que funciones se interfieran accidentalmente entre sí.

1def duplicar(numero):
2    resultado = numero * 2  # 'resultado' solo existe aquí dentro
3    return resultado
4
5valor = duplicar(5)
6print(valor)  # 10
7
8# Esto daría ERROR:
9# print(resultado)  # NameError: 'resultado' no existe fuera de la función

### Combinar funciones: construir con piezas de LEGO

La verdadera potencia de las funciones aparece cuando las combinas. Cada función es una pieza de LEGO — individual es simple, pero combinándolas construyes cosas complejas. Una función puede llamar a otra función, que a su vez llama a otra. Así se construyen programas profesionales.

1# Funciones que se llaman entre sí
2def calcular_descuento(precio, porcentaje):
3    """Aplica un descuento a un precio."""
4    return precio - (precio * porcentaje / 100)
5
6def calcular_iva(precio, iva=21):
7    """Añade IVA a un precio."""
8    return precio * (1 + iva / 100)
9
10def precio_final(precio_base, descuento, iva=21):
11    """Calcula el precio final con descuento e IVA."""
12    con_descuento = calcular_descuento(precio_base, descuento)
13    con_iva = calcular_iva(con_descuento, iva)
14    return con_iva
15
16# Usar la función compuesta
17resultado = precio_final(200, 15)  # 200€, 15% descuento, 21% IVA
18print(f"Precio final: {resultado:.2f}€")  # 205.70€
19
20# Otro ejemplo: validar un email (simplificado)
21def tiene_arroba(email):
22    return "@" in email
23
24def tiene_punto(email):
25    return "." in email
26
27def es_email_valido(email):
28    return tiene_arroba(email) and tiene_punto(email)
29
30print(es_email_valido("ana@gmail.com"))  # True
31print(es_email_valido("ana_sin_arroba"))  # False

### Resumen

• ▹def nombre(parámetros): define una función.
• ▹return devuelve un valor al código que llamó a la función.
• ▹Una función sin return implícitamente devuelve None.
• ▹Los parámetros son los datos que la función necesita para trabajar.
• ▹Las variables dentro de la función son locales (no existen fuera).
• ▹Una función debe hacer UNA cosa y hacerla bien.
• ▹Puedes combinar funciones llamando unas desde otras.