Funciones en Python

Aprendé a definir y usar funciones para organizar tu código, evitar repetición y hacerlo más fácil de mantener.

¿Qué es una función?

Una función es un bloque de código reutilizable que realiza una tarea específica. En vez de repetir el mismo código en varios lugares, lo escribís una vez dentro de una función y la llamás cuando la necesitás. 

# Definir la función
def saludar():
    print("¡Hola, mundo!")

# Llamar la función
saludar()   # ¡Hola, mundo!
saludar()   # ¡Hola, mundo! (se puede llamar muchas veces)
def — definir una función

La palabra clave def define una función. El nombre va en snake_case, seguido de paréntesis y dos puntos. El cuerpo va indentado.

Probá el Ejemplo 1: Funciones básicas

Parámetros y argumentos

Los parámetros son variables que recibe la función. Los argumentos son los valores que le pasás al llamarla. 

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

saludar("Ana")     # ¡Hola, Ana!
saludar("Carlos")  # ¡Hola, Carlos!

# Múltiples parámetros
def sumar(a, b):
    print(f"{a} + {b} = {a + b}")

sumar(3, 5)   # 3 + 5 = 8
sumar(10, 20) # 10 + 20 = 30

Parámetros con valor por defecto

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

saludar("Ana")              # Hola, Ana!
saludar("Carlos", "Buenas") # Buenas, Carlos!
saludar(saludo="Hey", nombre="Diego")  # argumentos con nombre
Argumentos con nombre (keyword arguments)

Al llamar una función podés especificar el nombre del parámetro: saludar(saludo="Hey", nombre="Diego"). Así no importa el orden.

Probá el Ejemplo 2: Parámetros

return — devolver un valor

Una función puede devolver un resultado con return. Ese resultado se puede guardar en una variable o usar directamente. 

def sumar(a, b):
    return a + b

resultado = sumar(3, 5)
print(resultado)           # 8
print(sumar(10, 20))       # 30
print(sumar(3, 5) * 2)     # 16 — usamos el resultado directo

Devolver múltiples valores

def min_max(numeros):
    return min(numeros), max(numeros)

minimo, maximo = min_max([4, 1, 8, 2, 9, 3])
print(f"Mínimo: {minimo}, Máximo: {maximo}")  # Mínimo: 1, Máximo: 9
return vs print()

print() muestra en pantalla pero no devuelve nada útil. return devuelve el valor para que puedas usarlo en otra parte del código. Una función sin return devuelve None implícitamente.

Probá el Ejemplo 3: return

Scope — alcance de las variables

Las variables definidas dentro de una función son locales — solo existen ahí. Las variables definidas fuera son globales. 

mensaje = "Soy global"   # variable global

def mostrar():
    local = "Soy local"  # variable local
    print(mensaje)       # puede leer la global
    print(local)

mostrar()
print(mensaje)   # OK
# print(local)   # Error — local no existe acá afuera
Evitá modificar variables globales desde funciones

Aunque se puede con la palabra clave global, hacerlo dificulta entender el código. Lo mejor es pasar los datos como parámetros y recibirlos con return.

*args y **kwargs

Cuando no sabés cuántos argumentos va a recibir la función, usás estas formas especiales.

*args — cantidad variable de argumentos posicionales

def sumar_todo(*numeros):
    total = 0
    for n in numeros:
        total += n
    return total

print(sumar_todo(1, 2, 3))        # 6
print(sumar_todo(10, 20, 30, 40)) # 100

**kwargs — argumentos con nombre variables

def mostrar_datos(**datos):
    for clave, valor in datos.items():
        print(f"{clave}: {valor}")

mostrar_datos(nombre="Ana", edad=28, ciudad="Córdoba")

Funciones lambda

Las lambdas son funciones anónimas de una sola expresión. Son útiles para operaciones simples, especialmente como argumentos de otras funciones. 

# Función normal
def cuadrado(x):
    return x ** 2

# Equivalente lambda
cuadrado = lambda x: x ** 2

print(cuadrado(5))  # 25

# Uso típico: ordenar con criterio personalizado
productos = [
    {"nombre": "Laptop", "precio": 1200},
    {"nombre": "Mouse",  "precio": 25},
    {"nombre": "Teclado","precio": 75},
]

# Ordenar por precio
productos.sort(key=lambda p: p["precio"])
for p in productos:
    print(f"{p['nombre']}: ${p['precio']}")

Ejemplo Completo

Calculadora con funciones bien separadas:

def calcular_descuento(precio, porcentaje):
    """Aplica un descuento y retorna el precio final."""
    descuento = precio * (porcentaje / 100)
    return precio - descuento

def calcular_total(items):
    """Suma los precios de una lista de items."""
    return sum(item["precio"] * item["cantidad"] for item in items)

def mostrar_factura(cliente, items, descuento=0):
    """Muestra una factura formateada."""
    print(f"\n{'='*40}")
    print(f"  FACTURA — {cliente}")
    print(f"{'='*40}")
    for item in items:
        subtotal = item["precio"] * item["cantidad"]
        print(f"  {item['nombre']:<15} ${item['precio']:>7} x{item['cantidad']} = ${subtotal:>8}")
    print(f"{'-'*40}")
    total_sin_desc = calcular_total(items)
    total_final    = calcular_descuento(total_sin_desc, descuento) if descuento else total_sin_desc
    if descuento:
        print(f"  Subtotal:              ${total_sin_desc:>10.2f}")
        print(f"  Descuento {descuento}%:          -${total_sin_desc * descuento/100:>9.2f}")
    print(f"  TOTAL:                 ${total_final:>10.2f}")
    print(f"{'='*40}")

# Uso
compra = [
    {"nombre": "Laptop",  "precio": 1200, "cantidad": 1},
    {"nombre": "Mouse",   "precio": 25,   "cantidad": 2},
    {"nombre": "Teclado", "precio": 75,   "cantidad": 1},
]
mostrar_factura("Ana García", compra, descuento=10)
Probá el Ejemplo 4: Calculadora con funciones

Buenas Prácticas

  • Una función, una responsabilidad — cada función debería hacer una sola cosa bien
  • Nombres descriptivos — calcular_descuento() es claro, f() no lo es
  • Docstrings — usá """descripción""" al principio de funciones complejas
  • Preferí return sobre print — las funciones que devuelven valores son más reutilizables
  • Parámetros por defecto — hacen las funciones más flexibles sin complicar su uso
  • Evitá variables globales — pasá los datos como parámetros