Funciones} dek="Empacar bloques de código con nombre. Es lo que separa los scripts sueltos de los programas de verdad." />

Imagina que cada vez que quisieras hacer café tuvieras que explicar paso a paso cómo encender la cafetera, dosificar el café, calentar el agua y servir. Sería agotador. En la vida real, dices "haz café" y ya: alguien ya empaquetó esos pasos bajo ese nombre.

Eso es exactamente una función en programación: un bloque de código con nombre, que puedes ejecutar (llamar) cuantas veces quieras. Definir bien tus funciones es la diferencia entre un programa que crece bien y uno que se vuelve un caos imposible de mantener.

Definir y llamar funciones

Vamos al ejemplo más simple posible:

{`¡Hola! Bienvenida al programa. ¡Hola! Bienvenida al programa.`}

Las cuatro piezas clave:

def: la palabra clave para definir una función. Como if o for.
El nombre (saludar): elígelo descriptivo. Como las variables, en minúsculas con guiones bajos.
Los paréntesis (): ahora vacíos, pero ahí van los parámetros cuando los tenga.
Los dos puntos y la sangría: igual que en if y for. Todo lo sangrado pertenece a la función.

Y luego, fuera de la definición, llamar a la función con su nombre y los paréntesis: saludar(). Eso ejecuta el bloque. Sin los paréntesis, Python no la llama — solo ve el nombre.

Definir una función no la ejecuta. Es como escribir una receta en un papel: tener la receta no es cocinar. Llamarla (poner los paréntesis) es lo que la ejecuta.

¿Por qué usar funciones?

Reutilizar. Escríbelo una vez, úsalo cien.
Organizar. Un programa de 500 líneas sueltas es un infierno. 500 líneas repartidas en 20 funciones bien nombradas se lee como un libro.
Darle nombre a una idea. Ver calcular_precio_con_iva(100) es infinitamente más claro que ver 100 * 1.21 repetido por todo el código.
Probar y arreglar más fácil. Si algo falla, ya sabes en qué función mirar.

Parámetros y argumentos

Una función vacía como saludar() es útil, pero limitada. Lo que la hace poderosa es que puede recibir información cuando la llamas:

{`¡Hola, Ana! ¡Hola, Luis! ¡Hola, Sofía!`}

Dos palabras nuevas que vale la pena diferenciar:

Parámetro: el nombre que aparece al definir la función (nombre, dentro de los paréntesis del def). Es como una variable local que solo existe dentro de la función.
Argumento: el valor real que pasas al llamarla ("Ana", dentro de los paréntesis de la llamada).

En la práctica casi todo el mundo usa "parámetro" y "argumento" como sinónimos. Tú sabe la diferencia, pero no te corrijas demasiado: lo importante es entender qué hacen.

Varios parámetros

{`¡Hola, Ana! Hello, John! Bonjour, Pierre!`}

El orden importa: el primer argumento va al primer parámetro, el segundo al segundo, y así.

Argumentos por nombre (keyword arguments)

Python te deja pasar los argumentos por nombre, no solo por orden. Útil cuando la función tiene muchos parámetros y no quieres acordarte del orden exacto:

{`Ana, 25 años, vive en Madrid Ana, 25 años, vive en Madrid Ana, 25 años, vive en Madrid`}

Valores por defecto

Puedes darle a un parámetro un valor por defecto. Si quien llama a la función no lo proporciona, se usa el valor por defecto:

{`¡Hola, Ana! Hello, John! Hello, Pierre!`} Esto da error: def f(idioma="es", nombre):. La regla es: primero los parámetros obligatorios, después los que tienen valor por defecto. Tiene sentido: si lo hicieras al revés, no podrías saber qué argumento es cuál cuando llamas con menos argumentos.

Devolver valores: `return`

Hasta ahora las funciones solo hacían cosas — imprimían texto. Pero la mayoría de las funciones útiles calculan algo y te lo devuelven para que tú lo uses donde quieras. Para eso está la palabra clave return.

{`49 25`}

Tres cosas que pasan cuando Python ejecuta return:

Evalúa la expresión que va después del return.
Sale de la función inmediatamente, aunque queden líneas debajo.
El valor evaluado reemplaza a la llamada en el código que llamó a la función.

`print` NO es lo mismo que `return`

print y return hacen cosas completamente diferentes:

print muestra algo al usuario, en la pantalla.
return devuelve un valor al código que llamó a la función, para que pueda usarlo.

Mira la diferencia clara:

{`49 a vale: None b vale: 49 b * 2 = 98 TypeError: unsupported operand type(s) for *: 'NoneType' and 'int'`}

Cuando una función no tiene return explícito (o tiene un return sin valor), Python devuelve automáticamente None: un valor especial que significa "nada". Si intentas hacer cuentas con None, todo explota.

Si tu función calcula algo, usa return.
Si tu función solo muestra algo o ejecuta una acción, sin necesidad de devolver nada (como guardar en un archivo, dibujar en pantalla), no necesitas return.

Salida temprana con `return`

Cuando Python ejecuta un return, sale de la función inmediatamente. Esto te permite escribir funciones más claras evitando anidamientos profundos:

{`85.0 100 0`}

Devolver varios valores

Python tiene un truco bonito: una función puede devolver varios valores a la vez, separándolos con comas:

17 / 5 → cociente 3, resto 2

Verás esto mucho en Python. Internamente se llama "tupla" (lo veremos en el módulo de listas y tuplas), pero por ahora piénsalo como "varios valores que viajan juntos".

Alcance: variables que viven dentro de la función

Las variables que creas dentro de una función solo existen dentro de esa función. En cuanto la función termina, esas variables desaparecen. A esto se le llama alcance local:

Esto es bueno — significa que dos funciones pueden usar variables con el mismo nombre sin pisarse:

Los parámetros son también variables locales. Cambiar el valor de un parámetro dentro de la función no afecta a la variable que pasaste cuando la llamaste:

Una variable definida fuera de toda función es global: las funciones pueden leerla. Pero modificarla desde dentro requiere usar la palabra clave global, y eso casi siempre es señal de mal diseño. La regla práctica: pásalo como parámetro, no leas variables globales.

Funciones integradas (built-ins) de Python

Python ya viene con docenas de funciones listas para usar — algunas las has visto, otras son nuevas. Aquí las más importantes para tu día a día:

Función	Hace	Ejemplo

{`6 15 9 4 3.14 60`} Antes de escribir una función nueva, busca si ya existe. Python (y sus librerías) tienen funciones para casi todo: contar, ordenar, parsear, formatear, calcular, generar. Una búsqueda de tres segundos en internet — "python how to round a number" — te puede ahorrar treinta minutos de reinventar la rueda.

Un ejemplo completo: refactorizar un programa

Vamos a ver cómo se transforma un programa cuando le metes funciones. Mira esta versión sin funciones, una receta lineal:

Y ahora la misma idea organizada en funciones:

Lo que ganamos:

No repetimos lógica. La regla del 15% está en un solo sitio. Si cambia a 20%, lo arreglamos una vez.
El "programa principal" se lee como un esquema. Si vuelves a este código en seis meses, ves la estructura de un vistazo.
Es más fácil probarlo. Puedes llamar a aplicar_descuento(100, True) directamente para comprobar que devuelve 85.0, sin tener que reescribir todo el programa.

Una buena función hace una sola cosa, la hace bien, y su nombre lo dice todo.

Ejercicios

Cinco ejercicios. Hasta ahora habías escrito código suelto; a partir de aquí empezarás a pensar en términos de funciones.

Calentamos motores: definir y llamar.

Tu primera función con return útil.

Parámetros por defecto + return.

= 30 → "Obesidad" # # Después: pide al usuario peso y altura, calcula, # y muestra el IMC con DOS DECIMALES y su categoría. `, hint: 'Para el IMC usa la potencia: altura ** 2. Para los dos decimales: round(imc, 2) o usa f-string con formato {imc:.2f}. La segunda función es un if/elif/else como los del Módulo 4.', solution: { code: `def calcular_imc(peso_kg, altura_m): return peso_kg / (altura_m ** 2) def categoria_imc(imc): if imc < 18.5: return "Bajo peso" elif imc < 25: return "Normal" elif imc < 30: return "Sobrepeso" else: return "Obesidad" peso = float(input("Peso (kg): ")) altura = float(input("Altura (m): ")) imc = calcular_imc(peso, altura) print(f"Tu IMC es {imc:.2f} ({categoria_imc(imc)})")`, explanation: 'Fíjate cómo cada función hace UNA sola cosa. Calcular el IMC y clasificarlo son responsabilidades distintas. El código del programa principal se lee como una receta clara. Y el truco {imc:.2f} fuerza dos decimales — lo usaremos a fondo más adelante.', }, }} >

Dos funciones que cooperan. Esto es programar de verdad.

El módulo se cierra con tu primera mini-API: cuatro funciones que cubren una tarea.

Resumen del módulo

// lo importante en una página

def nombre(parámetros): define una función. La sangría marca su cuerpo.
Para ejecutarla, llámala con paréntesis: nombre().
Parámetro (al definir) ≠ argumento (al llamar). Llevan el mismo orden.
Argumentos por nombre (keyword): f(x=1). Útil cuando hay muchos parámetros.
Valores por defecto: def f(x, y=10):. Los defaults van al final.
return devuelve un valor y sale de la función. Sin return, devuelve None.
print no es return: uno muestra al usuario, el otro devuelve al código.
Las variables creadas dentro de una función son locales — desaparecen al salir.
Python ya tiene funciones built-in útiles: len, type, abs, min, max, round, sum…

En el próximo módulo aprenderás a manejar colecciones de datos: listas y tuplas. Las funciones combinadas con listas son lo que de verdad desencadena el poder de Python.