Python · Lección 18 de 27

Funciones básicas

Las funciones te permiten encapsular lógica reutilizable bajo un nombre descriptivo. En vez de copiar y pegar código, lo definís una vez y lo llamás cuantas veces quieras. Es el salto de "scripts sueltos" a "código profesional".

90–110 min Prerrequisitos: 06 Condicionales, 16-17 Bucles

Concepto teórico

¿Qué es una función?

Una función es un bloque de código con nombre que recibe datos (parámetros), los procesa y opcionalmente devuelve un resultado (return). Definís la función una vez con def y después la llamás cuantas veces quieras pasándole distintos datos.

def nombre_funcion(parametro1, parametro2):
    """Docstring: qué hace la función."""
    # lógica
    resultado = parametro1 + parametro2
    return resultado

# Llamar la función
x = nombre_funcion(10, 20)  # x = 30

Principio DRY — Don't Repeat Yourself: si copiás y pegás el mismo bloque de código más de una vez, necesitás una función. Cada vez que dupliques código, duplicás los bugs potenciales. Con una función, corregís en un solo lugar y la corrección se aplica en todos los puntos donde se llama.

Anatomía de una función

def — keyword que indica "acá defino una función"
Nombre: en snake_case, descriptivo. calcular_iva, no f1
Parámetros: variables que la función recibe entre paréntesis. Puede ser 0, 1 o muchos
Docstring: texto entre """triple comillas""" que documenta qué hace. Accesible con help(funcion)
Cuerpo: el código indentado que se ejecuta cuando llamás la función
return — devuelve un valor al llamador. Sin return, la función devuelve None

Parámetros vs argumentos

Técnicamente: los parámetros son los nombres en la definición (def f(x, y)); los argumentos son los valores que pasás al llamar (f(10, 20)). En la práctica, la gente usa ambos términos indistintamente.

Python soporta dos formas de pasar argumentos:

Posicionales: el orden importa. f(10, 20) → x=10, y=20
Nombrados (keyword): usás el nombre del parámetro. f(y=20, x=10) → mismo resultado. Más legible cuando hay muchos parámetros.

Valores por defecto

Podés darle valores por defecto a los parámetros. Si el llamador no los pasa, se usa el default:

def calcular_iva(precio, tasa=0.21):
    return precio * (1 + tasa)

calcular_iva(1000)           # usa tasa=0.21 → 1210.0
calcular_iva(1000, 0.105)    # usa tasa=0.105 → 1105.0

Regla de oro: los parámetros con default siempre van DESPUÉS de los que no tienen default. def f(a, b=10) ✅. def f(a=10, b) ❌ SyntaxError.

Trampa peligrosa: NUNCA uses un objeto mutable (lista, dict) como valor por defecto. def f(datos=[]) es un bug clásico: la lista se comparte entre todas las llamadas. Usá def f(datos=None): if datos is None: datos = [].

Return: devolver valores

return hace dos cosas: (1) devuelve un valor al llamador, y (2) termina la ejecución de la función inmediatamente. Todo lo que haya después del return NO se ejecuta.

Una función puede devolver múltiples valores como tupla: return a, b, c. El llamador los desempaqueta: x, y, z = funcion().

Si no hay return (o hay return sin valor), la función devuelve None.

Analogía financiera: una función es como una fórmula de Excel con nombre. =CALCULAR_IVA(A1, 0.21) recibe una celda y una tasa, procesa internamente, y devuelve el resultado. No necesitás saber cómo calcula — solo sabés que funciona. Encapsulación.

Type hints: documentar tipos

Python permite anotar los tipos esperados de parámetros y retorno. No fuerzan nada (Python sigue siendo dinámico), pero documentan la intención y habilitan herramientas como Pylance para detectar errores:

def calcular_cuota(capital: float, tasa: float, meses: int) -> float:
    """Calcula cuota simple."""
    return (capital * (1 + tasa)) / meses

En el trabajo real: en equipos profesionales, las funciones son la unidad básica de organización del código. Un pipeline de datos se estructura como una cadena de funciones: leer_csv() → limpiar_datos() → calcular_metricas() → generar_reporte(). Cada función hace UNA cosa bien (principio de responsabilidad única).

Tip de naming: las funciones hacen algo, así que nombralas con verbos: calcular_iva(), filtrar_clientes(), generar_reporte(). Las variables son sustantivos: saldo, cliente, tasa. Verbos para funciones, sustantivos para datos.

Ejemplos explicados paso a paso

Ejemplo 1: Definir y llamar funciones básicas

ejemplo_01_basico.pyPython

# Función sin parámetros ni return
def saludar():
    print("¡Hola desde una función!")

saludar()  # llamar

# Función con parámetros
def saludar_a(nombre):
    print(f"¡Hola, {nombre}!")

saludar_a("García")
saludar_a("López")

# Función con return
def calcular_iva(precio, tasa=0.21):
    return precio * (1 + tasa)

resultado = calcular_iva(10000)
print(f"\nPrecio con IVA: ${resultado:,.0f}")

# Con tasa distinta (argumento nombrado)
resultado_2 = calcular_iva(10000, tasa=0.105)
print(f"Con IVA reducido: ${resultado_2:,.0f}")

# Sin return → devuelve None
def solo_imprime(msg):
    print(msg)

x = solo_imprime("Hola")
print(f"Retorno: {x}")  # None

Hacé clic en ▶ Ejecutar

Ejemplo 2: Return múltiple y docstrings

ejemplo_02_return_docs.pyPython

def analizar_cartera(saldos):
    """
    Analiza una lista de saldos y devuelve estadísticas.
    
    Args:
        saldos (list): Lista de saldos numéricos.
    
    Returns:
        tuple: (total, promedio, minimo, maximo, cantidad)
    """
    total = sum(saldos)
    cantidad = len(saldos)
    promedio = total / cantidad
    return total, promedio, min(saldos), max(saldos), cantidad

# Llamar y desempaquetar
datos = [150000, 320000, 45000, 890000, 72000]
total, prom, mini, maxi, n = analizar_cartera(datos)

print(f"Cartera de {n} clientes:")
print(f"  Total:    ${total:>12,}")
print(f"  Promedio: ${prom:>12,.0f}")
print(f"  Mínimo:   ${mini:>12,}")
print(f"  Máximo:   ${maxi:>12,}")

# Acceder al docstring
print(f"\nDocumentación:")
print(analizar_cartera.__doc__)

Hacé clic en ▶ Ejecutar

Ejemplo 3: DRY — de código repetido a funciones

ejemplo_03_dry.pyPython

# ❌ SIN DRY — código repetido 3 veces
print("=== Sin DRY (repetido) ===")
sueldo_1 = 450000
neto_1 = sueldo_1 - sueldo_1*0.11 - sueldo_1*0.03 - sueldo_1*0.17
print(f"García: ${neto_1:,.0f}")

sueldo_2 = 800000
neto_2 = sueldo_2 - sueldo_2*0.11 - sueldo_2*0.03 - sueldo_2*0.17
print(f"López: ${neto_2:,.0f}")

sueldo_3 = 350000
neto_3 = sueldo_3 - sueldo_3*0.11 - sueldo_3*0.03 - sueldo_3*0.17
print(f"Pérez: ${neto_3:,.0f}")

# ✅ CON DRY — función reutilizable
print("\n=== Con DRY (función) ===")
def calcular_sueldo_neto(bruto, jub=0.11, os=0.03, gan=0.17):
    """Calcula sueldo neto descontando jubilación, obra social y ganancias."""
    deducciones = bruto * (jub + os + gan)
    return bruto - deducciones

# Una línea por empleado — cambiar la fórmula requiere editar UN solo lugar
empleados = [("García", 450000), ("López", 800000), ("Pérez", 350000)]
for nombre, bruto in empleados:
    neto = calcular_sueldo_neto(bruto)
    print(f"{nombre}: ${neto:,.0f}")

# Bonus: si cambian las tasas, se cambia en UN solo lugar
print(f"\nCon nueva tasa ganancias 20%:")
for nombre, bruto in empleados:
    neto = calcular_sueldo_neto(bruto, gan=0.20)
    print(f"  {nombre}: ${neto:,.0f}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Funciones con type hints y validación

ejemplo_04_typehints.pyPython

def evaluar_credito(score: int, ingreso: float, deuda: bool = False) -> dict:
    """
    Evalúa si un cliente califica para un crédito.
    
    Args:
        score: Score crediticio (300-900).
        ingreso: Ingreso mensual en pesos.
        deuda: Si tiene deuda vencida.
    
    Returns:
        dict con 'aprobado' (bool), 'categoria' (str), 'motivo' (str).
    """
    if deuda:
        return {"aprobado": False, "categoria": "Rechazado", "motivo": "Deuda vencida"}
    if score < 500:
        return {"aprobado": False, "categoria": "Rechazado", "motivo": f"Score bajo ({score})"}
    if ingreso < 80000:
        return {"aprobado": False, "categoria": "Rechazado", "motivo": f"Ingreso bajo (${ingreso:,.0f})"}
    
    # Pasó todas las validaciones
    if score >= 750:
        categoria = "Premium"
    elif score >= 650:
        categoria = "Estándar"
    else:
        categoria = "Básico"
    
    return {"aprobado": True, "categoria": categoria, "motivo": "Cumple requisitos"}

# Probar con distintos clientes
clientes = [
    ("García", 720, 350000, False),
    ("López", 480, 200000, False),
    ("Martínez", 810, 500000, True),
    ("Pérez", 680, 60000, False),
]

print(f"{'Nombre':<12} {'Resultado':<12} {'Categoría':<12} {'Motivo'}")
print(f"{'─'*60}")
for nombre, score, ingreso, deuda in clientes:
    r = evaluar_credito(score, ingreso, deuda)
    emoji = "✅" if r["aprobado"] else "❌"
    print(f"{emoji} {nombre:<10} {str(r['aprobado']):<12} {r['categoria']:<12} {r['motivo']}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Funciones como pipeline

ejemplo_05_pipeline.pyPython

# Pipeline de procesamiento: cada paso es una función
def limpiar_monto(texto: str) -> float:
    """Convierte '$1,500.00' a 1500.0"""
    return float(texto.replace("$", "").replace(",", ""))

def clasificar_monto(monto: float) -> str:
    """Clasifica un monto en categorías."""
    if monto > 100000: return "Grande"
    if monto > 10000: return "Mediano"
    return "Chico"

def formatear_reporte(nombre: str, monto: float, categoria: str) -> str:
    """Formatea una línea de reporte."""
    return f"  {nombre:<12} ${monto:>10,.0f}  [{categoria}]"

# Datos crudos
registros = [
    ("García", "$150,000"),
    ("López", "$8,500"),
    ("Pérez", "$320,000"),
    ("Sosa", "$2,100"),
]

# Pipeline: limpiar → clasificar → formatear
print("=== REPORTE ===")
total = 0
for nombre, monto_str in registros:
    monto = limpiar_monto(monto_str)           # paso 1
    categoria = clasificar_monto(monto)          # paso 2
    linea = formatear_reporte(nombre, monto, categoria)  # paso 3
    print(linea)
    total += monto

print(f"{'─'*38}")
print(f"  {'TOTAL':<12} ${total:>10,.0f}")

# Cada función hace UNA cosa. Podés testear, reutilizar y
# modificar cada paso de forma independiente.

Hacé clic en ▶ Ejecutar

Referencia rápida

Concepto	Sintaxis	Ejemplo
Definir	`def nombre(params):`	`def sumar(a, b):`
Llamar	`nombre(args)`	`sumar(3, 5)`
Return	`return valor`	`return a + b`
Return múltiple	`return a, b`	Devuelve tupla
Default	`def f(x, y=10):`	y es opcional, vale 10
Keyword arg	`f(y=20, x=5)`	Nombrás el parámetro
Docstring	`"""Descripción."""`	Primera línea del cuerpo
Type hint	`def f(x: int) -> str:`	Documentar tipos
Sin return	—	Devuelve `None`

Buena práctica	Ejemplo
Nombres con verbos	`calcular_iva`, `filtrar_clientes`
Una responsabilidad	Cada función hace UNA cosa
DRY: no repetir código	Si copiás un bloque, creá una función
Docstring siempre	Args, Returns, descripción
No mutar argumentos	No modificar listas/dicts que te pasan
Return temprano	`if error: return None` al inicio

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Función con IVA

Creá con_iva(precio) que devuelva el precio + 21%. Probá con $10,000. Debe incluir 12100.

ejercicio_01.pyDebe incluir "12100"

# Definí con_iva():

# Probá:
print(con_iva(10000))

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Función con parámetro default

Creá saludar(nombre, saludo="Hola") que imprima "{saludo}, {nombre}!". Probá con y sin saludo. Debe incluir Hola, García.

ejercicio_02.pyDebe incluir "Hola, García"

# Definí saludar():

# Probá:
saludar("García")
saludar("López", "Buenos días")

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Return múltiple

Creá min_max(numeros) que devuelva el mínimo y máximo como tupla. Probá con [45, 72, 38, 91, 55]. Debe incluir 38.

ejercicio_03.pyDebe incluir "38"

# Definí min_max():

datos = [45, 72, 38, 91, 55]
mi, ma = min_max(datos)
print(f"Min: {mi}, Max: {ma}")

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Sueldo neto con función

Creá sueldo_neto(bruto, jub=0.11, os=0.03, gan=0.17). Calculá el neto de $750,000. Debe incluir 517500.

ejercicio_04.pyDebe incluir "517500"

# Definí sueldo_neto():

print(sueldo_neto(750000))

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Función con docstring completo

Creá interes_simple(capital, tasa, meses) con docstring que incluya Args y Returns. Calculá para $200,000 al 5% por 6 meses. Debe incluir 60000.

ejercicio_05.pyDebe incluir "60000"

# Definí con docstring completo:

print(interes_simple(200000, 0.05, 6))

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Función clasificadora

Creá clasificar_score(score) que devuelva "Excelente" (>=800), "Bueno" (>=700), "Regular" (>=600) o "Malo". Probá con 720. Debe incluir Bueno.

ejercicio_06.pyDebe incluir "Bueno"

# Definí clasificar_score():

print(clasificar_score(720))

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Función que procesa lista

Creá limpiar_montos(lista_str) que reciba ["$1,500","N/A","$3,200"] y devuelva una lista de floats (saltando inválidos). Debe incluir 4700.

ejercicio_07.pyDebe incluir "4700"

# Definí limpiar_montos():

datos = ["$1,500", "N/A", "$3,200", "", "$-100"]
limpios = limpiar_montos(datos)
print(f"Limpios: {limpios}")
print(f"Total: {sum(limpios)}")

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Función que devuelve diccionario

Creá analizar(saldos) que devuelva un dict con total, promedio, min, max, cantidad. Debe incluir promedio.

ejercicio_08.pyDebe incluir "promedio"

# Definí analizar():

datos = [150000, 320000, 45000, 890000]
resultado = analizar(datos)
for k, v in resultado.items():
    print(f"  {k}: {v:,.0f}" if isinstance(v, float) else f"  {k}: {v}")

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Funciones como pipeline

Creá 3 funciones: limpiar(texto) que stripee y titlece, validar(nombre) que verifique que tiene al menos 2 caracteres, y formatear(nombre, i) que devuelva "N. Nombre". Aplicá las 3 a una lista sucia. Debe incluir García.

ejercicio_09.pyDebe incluir "García"

# Definí las 3 funciones:

nombres_sucios = ["  GARCÍA  ", "", "  lópez  ", " a ", "  PÉREZ  "]

# Aplicá el pipeline:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Motor de evaluación crediticia como funciones

Creá un mini motor de crédito con funciones: validar_edad(e), validar_ingreso(i), validar_score(s), calcular_ratio(cuota, ingreso), y evaluar_cliente(nombre, edad, ingreso, score, cuota) que las use todas. Probá con 3 clientes. Debe incluir EVALUACIÓN.

ejercicio_10_desafio.pyDebe incluir "EVALUACIÓN"

# Definí las funciones de validación:

# Definí evaluar_cliente() que las use:

# Probá:
clientes = [
    ("García", 35, 350000, 720, 85000),
    ("López", 17, 200000, 680, 50000),
    ("Pérez", 45, 500000, 810, 200000),
]
print("=== EVALUACIÓN CREDITICIA ===")

Hacé clic en ▶ Ejecutar

Resumen y conexión

def nombre(params): define una función. return devuelve un valor.
Los parámetros con default van al final: def f(a, b=10):.
Return múltiple (return a, b) devuelve una tupla que podés desempaquetar.
Sin return, la función devuelve None.
Docstrings ("""...""") documentan funciones. Type hints (x: int) documentan tipos.
Principio DRY: si copiás código, creá una función. Nombra funciones con verbos.
Las funciones como pipeline (limpiar → validar → procesar) son el patrón profesional.

En la siguiente lección (19 · Funciones avanzadas) vas a aprender *args/**kwargs, lambda, funciones como objetos, closures, decoradores y generators — las herramientas que separan código junior de código senior.

Recursos: Python docs — Functions · PEP 257 — Docstrings

Hecho con ❤️ por Rodri Gonzalez