Aprende Python desde cero

Una función es un bloque de código con nombre que puedes reutilizar. Es la herramienta número uno para no repetirte y para organizar programas grandes.

Definir y llamar

def saludar():
    print("¡Hola!")

saludar()    # ¡Hola!
saludar()    # ¡Hola! → cuantas veces quieras

def define la función
Los paréntesis son obligatorios (aquí van los parámetros)
El cuerpo va indentado
La función solo se ejecuta cuando la llamas con ()

Parámetros y return

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

resultado = sumar(3, 5)
print(resultado)    # 8

return entrega un valor a quien llamó. Sin return explícito, toda función devuelve None:

def saludar():
    print("hola")

x = saludar()
print(x)    # None ← print no es return

Diferencia clave: print muestra en pantalla; return entrega el valor para que el programa lo use.

Parámetros con valor por defecto

def saludar(nombre="mundo"):
    return f"Hola, {nombre}"

print(saludar())          # Hola, mundo
print(saludar("Ana"))     # Hola, Ana

Argumentos por nombre (keyword arguments)

def crear_perfil(nombre, edad, ciudad):
    return f"{nombre}, {edad}, {ciudad}"

# por posición:
crear_perfil("Ana", 25, "Bogotá")

# por nombre — el orden da igual:
crear_perfil(edad=25, ciudad="Bogotá", nombre="Ana")

*args y **kwargs

A veces no sabes cuántos argumentos recibirás:

def sumar_todos(*numeros):
    # numeros llega como una TUPLA
    return sum(numeros)

print(sumar_todos(1, 2))        # 3
print(sumar_todos(1, 2, 3, 4))  # 10

def mostrar_perfil(**datos):
    # datos llega como un DICT
    for clave, valor in datos.items():
        print(f"{clave}: {valor}")

mostrar_perfil(nombre="Ana", edad=25)

*args agrupa argumentos posicionales extra en una tupla
**kwargs agrupa argumentos nombrados extra en un dict

Scope: dónde vive una variable

variable_global = "soy global"

def mi_funcion():
    variable_local = "solo existo dentro"
    print(variable_global)     # sí puede leer globals

mi_funcion()
print(variable_local)          # NameError: no existe fuera

Regla de oro: evita modificar globales desde una función. Recibe lo que necesites por parámetros y devuelve resultados con return — funciones así son fáciles de probar y entender.

Lambda: funciones anónimas de una línea

duplicar = lambda x: x * 2
print(duplicar(5))    # 10

sumar = lambda a, b: a + b
print(sumar(2, 3))    # 5

Las lambda brillan como argumento de funciones como sorted:

palabras = ["banana", "kiwi", "manzana"]
por_longitud = sorted(palabras, key=lambda p: len(p))
print(por_longitud)   # ['kiwi', 'banana', 'manzana']

Para lógica de más de una línea, usa def — la lambda es para expresiones simples.

Resumen

def nombre(parametros): define; nombre(argumentos) llama
return entrega el valor; sin él, la función devuelve None
Valores por defecto y argumentos nombrados hacen APIs flexibles
*args tupla, **kwargs dict
Variables locales mueren con la función; no toques globales
lambda para expresiones de una línea (especialmente como key)

Funciones