Python: Funciones

🎮 Analogía: los ataques aprendidos

Un Pokémon aprende un ataque una vez y lo puede usar mil veces. No tiene que reaprender “Impactrueno” en cada batalla: lo sabe, le pone un nombre, y lo invoca cuando quiere.

Una función es eso: un bloque de código que escribís una vez, le ponés un nombre, y lo llamás (lo usás) todas las veces que quieras. ⚡

🛠️ Definir una función con def

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

Desglose:

• def → palabra clave para definir una función.
• saludar → el nombre que le ponés.
• () → los paréntesis (después vemos qué va adentro).
• : → dos puntos, obligatorios.
• El cuerpo va indentado (4 espacios), igual que en los if.

Definir una función no la ejecuta. Para ejecutarla, la llamás por su nombre:

saludar()    # ¡Hola, Entrenador!
saludar()    # ¡Hola, Entrenador!  (la usamos de nuevo, gratis)

📥 Parámetros: darle datos a la función

Un parámetro es un dato que la función recibe para trabajar. Va dentro de los paréntesis.

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

saludar("Ash")      # ¡Hola, Ash!
saludar("Misty")    # ¡Hola, Misty!

Podés tener varios parámetros, separados por comas:

def presentar(nombre, tipo):
    print(f"{nombre} es de tipo {tipo}")

presentar("Pikachu", "Eléctrico")

📤 return: devolver un resultado

return hace que la función devuelva un valor para usarlo después. Es la diferencia entre una función que solo “muestra” y una que “calcula y entrega”.

def calcular_dano(ataque, defensa):
    return ataque - defensa

# Guardamos lo que devuelve en una variable.
resultado = calcular_dano(50, 20)
print(resultado)    # 30

# O lo usamos directamente.
print(calcular_dano(80, 30))   # 50

print vs return — la confusión clásica

def con_print(x):
    print(x * 2)        # MUESTRA en pantalla, pero no devuelve nada

def con_return(x):
    return x * 2        # DEVUELVE el valor para seguir usándolo

a = con_print(5)        # imprime 10, pero a queda en None
b = con_return(5)       # no imprime nada, pero b vale 10
print(b + 1)            # 11  (porque b es un número de verdad)

Regla práctica: si querés usar el resultado después, usá return.

P: Una función tiene `print(x * 2)` en vez de `return x * 2`. Si hacés `resultado = mi_funcion(5)`, ¿qué vale `resultado`?
- 10
- 5
+ `None`
> Sin `return`, la función no devuelve nada útil: Python le asigna `None` a `resultado`. El `print` solo muestra en pantalla, no devuelve el valor.

🎚️ Valores por defecto

Podés darle a un parámetro un valor por defecto, que se usa si no pasás nada:

def atacar(nombre, dano=10):       # dano vale 10 si no se especifica
    print(f"{nombre} hizo {dano} de daño")

atacar("Pikachu")          # Pikachu hizo 10 de daño  (usa el default)
atacar("Charizard", 35)    # Charizard hizo 35 de daño (lo pisamos)

🌐 Scope: dónde vive cada variable

El scope (alcance) es la zona donde una variable existe. Una variable creada adentro de una función solo existe ahí adentro. Es como un Pokémon dentro de su Pokéball: afuera no se lo ve.

def entrenar():
    secreto = "técnica oculta"    # variable LOCAL: solo vive acá adentro
    print(secreto)

entrenar()
# print(secreto)   # ❌ ERROR: 'secreto' no existe afuera de la función

Las variables creadas afuera son globales y se pueden leer adentro:

entrenador = "Ash"        # variable global

def saludar():
    print(f"Hola {entrenador}")   # puede leer la global

saludar()    # Hola Ash

⚡ Funciones lambda: funciones express

Una lambda es una función chiquita de una sola línea, sin nombre. Útil para cosas simples.

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

# La misma como lambda:
doble = lambda x: x * 2

print(doble(5))    # 10

La estructura es: lambda parámetros: expresión. El resultado de la expresión es lo que devuelve.

sumar = lambda a, b: a + b
print(sumar(3, 4))    # 7

P: Tenés `def atacar(nombre, dano=10)`. ¿Qué imprime `atacar("Pikachu")`?
+ Pikachu hizo 10 de daño
- Error: falta el argumento `dano`
- Pikachu hizo None de daño
> `dano=10` es un valor por defecto: si no lo pasás, se usa 10 automáticamente.

📖 Docstrings: documentar tu función

Un docstring es un texto (entre """triple comillas""") justo abajo del def, que explica qué hace la función.

def calcular_dano(ataque, defensa):
    """Calcula el daño restando la defensa al ataque."""
    return ataque - defensa

Sirve para que vos (y otros) entiendan la función sin leer todo el código. Es de buena programadora documentar así.

🔁 Recursión: una función que se llama a sí misma

Recursión es cuando una función se llama a sí misma para resolver un problema más chico. Suena raro, pero es potente.

El ejemplo clásico es el factorial (5! = 5×4×3×2×1):

def factorial(n):
    # Caso base: el punto donde la recursión FRENA.
    if n <= 1:
        return 1
    # Caso recursivo: la función se llama a sí misma con un número más chico.
    return n * factorial(n - 1)

print(factorial(5))    # 120

📝 Resumen

# Definir
def atacar(nombre, dano=10):
    """Muestra un ataque (docstring)."""
    return f"{nombre} hizo {dano} de daño"

# Llamar
mensaje = atacar("Pikachu", 25)

# return devuelve un valor; print solo muestra
# Valores por defecto: dano=10
# Scope: las variables locales no existen afuera
# Lambda: función express
doble = lambda x: x * 2
# Recursión: función que se llama a sí misma (necesita caso base)

➡️ ¿Y ahora qué?

Ahora practicá: andá a los ejercicios de este tema y resolvelos. Se corrigen al instante con tests reales en tu navegador. 💪