Entrá y llevá tu progreso —ejercicios, medallas y Pokémon— a cualquier dispositivo. 🔄
Si tu cuenta ya tiene progreso guardado, se carga ese al entrar.
Entraste como . Tu progreso se sincroniza solo. 🔄
Devolvé 'Hola <nombre> de <ciudad>'. 'ciudad' tiene valor por defecto "Pueblo Paleta". Ejemplo: saludar_entrenador("Ash") → "Hola Ash de Pueblo Paleta" saludar_entrenador("Brock", "Ciudad Plateada") → "Hola Brock de Ciudad Plateada"
🎯 Meta: aprender a empaquetar código en funciones para reusarlo, organizarlo y no repetirte. Es uno de los conceptos más importantes de toda la programación.
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. ⚡
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.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)
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")
💡 “Parámetro” es el nombre en la definición (nombre). “Argumento” es el valor que pasás al llamar ("Ash"). Mucha gente usa los términos como sinónimos, no te preocupes por eso.
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
⚠️ Cuando Python ejecuta un return, sale de la función inmediatamente. El código que esté después del return no se ejecuta.
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.
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)
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
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
💡 Las lambda se usan mucho para ordenar o filtrar (lo vas a ver más adelante). Por ahora, alcanza con saber qué son.
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.
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 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
⚠️ Toda recursión necesita un caso base (una condición que la frene). Sin él, se llama infinitamente y revienta. Es como las muñecas rusas: en algún momento llegás a la más chiquita.
# 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)
| Concepto | Para qué sirve |
|---|---|
def | Definir una función |
| parámetros | Pasarle datos |
return | Devolver un resultado |
| valor por defecto | Parámetro opcional |
| scope | Dónde vive una variable |
lambda | Función chica de una línea |
| docstring | Documentar qué hace |
| recursión | Función que se llama a sí misma |
Ahora practicá: andá a los ejercicios de este tema y resolvelos. Se corrigen al instante con tests reales en tu navegador. 💪
⚡ “Una buena función es como un buen ataque: la aprendés una vez y te sirve toda la vida.”