Funciones en Python: parámetros, return y módulos

A medida que tus programas crecen, aparece código repetido y difícil de seguir. Las funciones resuelven ambos problemas: agrupan un conjunto de instrucciones bajo un nombre para reutilizarlas cuantas veces quieras. Son la herramienta más importante para escribir código ordenado, y la base de todo lo que harás después en Python.

Definir y llamar una función

def saludar():
    print("¡Hola!")
    print("Bienvenido al sistema")

saludar()
saludar()

• def define la función; después va el nombre (en snake_case), paréntesis y dos puntos.
• El cuerpo va indentado.
• La función no hace nada hasta que la llamas escribiendo su nombre con paréntesis.

Parámetros: datos de entrada

def saludar(nombre):
    print(f"¡Hola, {nombre}!")

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

Un parámetro es la variable de la definición (nombre); el argumento es el valor que pasas al llamarla ("Ana").

Varios parámetros y valores por defecto

def precio_final(precio, impuesto=0.18, descuento=0):
    base = precio * (1 - descuento)
    return base * (1 + impuesto)

print(round(precio_final(100), 2))                  # 118.0
print(round(precio_final(100, descuento=0.1), 2))   # 106.2
print(round(precio_final(100, impuesto=0.16), 2))   # 116.0

Los parámetros con valor por defecto son opcionales y deben ir después de los obligatorios. Al llamar puedes nombrar los argumentos (descuento=0.1): el código se vuelve más legible y no dependes del orden.

return: devolver un resultado

La diferencia entre print y return es fundamental:

• print muestra algo en pantalla, pero el valor se pierde.
• return devuelve el valor a quien llamó la función, para que lo guarde o lo use en otro cálculo.

def area_rectangulo(base, altura):
    return base * altura

a = area_rectangulo(4, 5)
total = area_rectangulo(4, 5) + area_rectangulo(2, 3)
print(a, total)   # 20 26

Una función sin return devuelve None. Y return termina la función en ese momento, lo que permite salidas tempranas:

def dividir(a, b):
    if b == 0:
        return None
    return a / b

Puedes devolver varios valores a la vez (en realidad, una tupla):

def estadisticas(numeros):
    return min(numeros), max(numeros), sum(numeros) / len(numeros)

minimo, maximo, promedio = estadisticas([4, 8, 15, 16, 23, 42])
print(promedio)   # 18.0

Alcance de las variables (scope)

Las variables creadas dentro de una función son locales: solo existen mientras la función se ejecuta.

def calcular():
    resultado = 10 * 2
    return resultado

calcular()
print(resultado)   # NameError: resultado no existe fuera de la función

La forma correcta de sacar un valor de una función es con return, no con variables globales. Las funciones que solo dependen de sus parámetros y devuelven un resultado son más fáciles de entender, probar y reutilizar.

Documentar con docstrings y type hints

def cuota_prestamo(monto: float, tasa_anual: float, meses: int) -> float:
    """Calcula la cuota fija mensual de un préstamo (sistema francés).

    tasa_anual: tasa efectiva anual en decimal, por ejemplo 0.24 para 24%.
    """
    tasa_mensual = (1 + tasa_anual) ** (1 / 12) - 1
    return monto * tasa_mensual / (1 - (1 + tasa_mensual) ** -meses)

print(round(cuota_prestamo(10000, 0.24, 24), 2))   # 517.33

• El texto entre triples comillas es la docstring: explica qué hace la función. VS Code la muestra al pasar el mouse.
• monto: float y -> float son type hints: indican los tipos esperados. Python no los obliga, pero ayudan a tu editor y a quien lea el código.

Funciones de la biblioteca estándar: import

Python trae cientos de módulos listos para usar. Se importan al inicio del archivo:

import math
import random
from datetime import date

print(math.sqrt(144))          # 12.0
print(math.ceil(5.88))         # 6 (redondea hacia arriba)
print(random.choice(["a", "b", "c"]))
print(date.today())            # fecha actual

edad_dias = (date.today() - date(1996, 5, 14)).days

Además existen miles de librerías externas que se instalan con pip desde la terminal (pip install pandas). Son la razón por la que Python se usa en datos, web e inteligencia artificial.

Organizar un programa con funciones

Un programa bien organizado se lee como un índice. Compara este esqueleto con un bloque de 100 líneas seguidas:

def pedir_numero(mensaje):
    return float(input(mensaje))

def calcular_total(subtotal, impuesto=0.18):
    return subtotal * (1 + impuesto)

def mostrar_ticket(subtotal, total):
    print(f"Subtotal: {subtotal:.2f}")
    print(f"Total:    {total:.2f}")

def main():
    subtotal = pedir_numero("Subtotal: ")
    total = calcular_total(subtotal)
    mostrar_ticket(subtotal, total)

if __name__ == "__main__":
    main()

La última línea significa "ejecuta main() solo si este archivo se ejecuta directamente". Así, otro programa podría importar calcular_total sin que se lance todo el programa. Funciones pequeñas con una sola responsabilidad también son más fáciles de probar automáticamente (si te interesa, lee sobre mocks y pruebas).

def es_par(n):
    return n % 2 == 0

def convertir_moneda(monto, tipo_cambio, comision=0.01):
    convertido = monto * tipo_cambio
    return convertido * (1 - comision)

def resumen_notas(notas):
    return {
        "promedio": round(sum(notas) / len(notas), 1),
        "maxima": max(notas),
        "minima": min(notas),
        "aprobados": len([n for n in notas if n >= 60]),
    }

print(es_par(10))                          # True
print(round(convertir_moneda(100, 3.75), 2))  # 371.25
print(resumen_notas([55, 72, 90, 61, 48]))
# {'promedio': 65.2, 'maxima': 90, 'minima': 48, 'aprobados': 3}

Resumen

• def nombre(parámetros): define una función; se ejecuta al llamarla.
• return devuelve un valor; print solo lo muestra.
• Parámetros con valor por defecto y argumentos con nombre hacen el código claro.
• Las variables internas son locales; documenta con docstrings y type hints.
• Organiza tus programas en funciones pequeñas y un main().

En la próxima lección: Archivos, manejo de errores y proyecto final en Python. Verás try/except, archivos de texto, CSV y JSON, y un gestor de gastos completo.