Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 4 de 47 · De PHP a Python ✦ WebMCP implementado

Funciones: *args, **kwargs y argumentos con nombre

9 min de lectura 4 retos

Una función en Python se define con def y puede hacer cosas que las de PHP no hacen tan fácil: devolver varios valores a la vez, recibir argumentos por su nombre y aceptar «todos los que lleguen». Aquí ves cada pieza con su equivalente PHP.

¿De dónde vienen los nombres?

def = inglés define (definir)
La palabra que abre una función. Es el function de PHP, más corto.
*args = args = arguments (argumentos)
El nombre que se suele dar a «todos los argumentos sueltos que lleguen». El * los junta en una tupla. En PHP es ...$args.
**kwargs = kw = keyword (palabra clave) + args
Los argumentos que llegan con nombre (prioridad=2), juntados en un diccionario. «Keyword» es el nombre que se les pasa. No hay equivalente directo en PHP.
lambda = la letra griega λ del cálculo lambda, de Alonzo Church
Una función pequeña sin nombre escrita en una línea. Es la fn() => de PHP.
docstring = doc (documentación) + string (cadena)
El texto entre tres comillas justo debajo de la def. Python lo guarda y help() lo enseña. Es el docblock /** */ de PHP, pero vivo.
En 4 ideas
1/4

Una función se define con def nombre(parametros): y el cuerpo va sangrado (en PHP, function nombre($p) { }). return con varios valores devuelve una tupla.

1 · def y return

Una función es una receta con nombre: la defines una vez y la usas cuando quieras. En Python empieza por def, sus parámetros van entre paréntesis y el cuerpo se sangra con 4 espacios, igual que un if.

Pythonmain.py
# En PHP: function formatea_tarea(string $titulo, int $prioridad): string
def formatea_tarea(titulo: str, prioridad: int) -> str:
    return f"[P{prioridad}] {titulo}"


print(formatea_tarea("Comprar pan", 2))


# Una función sin return devuelve None, como una función void de PHP.
def saluda() -> None:
    print("Hola")


resultado = saluda()
print(resultado)

Una función puede devolver varios valores separándolos con comas. Por debajo, Python devuelve una tupla (una lista fija) y tú la desempaquetas al recibirla. En PHP harías un array y [$a, $b] = ....

Pythonmain.py
def cuenta_tareas(estados: list[bool]) -> tuple[int, int]:
    hechas = sum(estados)
    return hechas, len(estados) - hechas


# En PHP: [$hechas, $pendientes] = cuenta_tareas($estados);
hechas, pendientes = cuenta_tareas([True, False, False, True, False])
print(hechas, pendientes)

# Si no lo desempaquetas, es una tupla.
print(cuenta_tareas([True, False]))
PHP 8.5index.php
<?php
declare(strict_types=1);

function cuentaTareas(array $estados): array
{
    $hechas = count(array_filter($estados));
    return [$hechas, count($estados) - $hechas];
}

[$hechas, $pendientes] = cuentaTareas([true, false, false]);
echo "$hechas $pendientes" . PHP_EOL;
Pythonmain.py
def cuenta_tareas(estados: list[bool]) -> tuple[int, int]:
    hechas = sum(estados)
    return hechas, len(estados) - hechas


hechas, pendientes = cuenta_tareas([True, False, False])
print(hechas, pendientes)

Justo debajo de la def puedes escribir un docstring: una explicación entre tres comillas que Python guarda con la función.

Pythonmain.py
def prioridad_texto(prioridad: int) -> str:
    """Devuelve «baja», «media» o «alta» según el número (1, 2 o 3)."""
    return {1: "baja", 2: "media", 3: "alta"}[prioridad]


print(prioridad_texto(3))
print(prioridad_texto.__doc__)

2 · Valores por defecto y argumentos con nombre

Un parámetro con = tiene valor por defecto: si no lo pasas, vale eso. Y al llamar puedes escribir el nombre del parámetro, así no importa el orden y se lee mejor. PHP 8 también lo permite (named arguments).

Pythonmain.py
def crea_tarea(titulo: str, prioridad: int = 1, hecha: bool = False) -> dict:
    return {"titulo": titulo, "prioridad": prioridad, "hecha": hecha}


print(crea_tarea("Comprar pan"))
print(crea_tarea("Llamar al banco", 3))

# En PHP: creaTarea("Repasar", hecha: true)
print(crea_tarea("Repasar", hecha=True))
print(crea_tarea(prioridad=2, titulo="Pagar el alquiler"))
PHP 8.5index.php
<?php
declare(strict_types=1);

function creaTarea(string $titulo, int $prioridad = 1, bool $hecha = false): array
{
    return ["titulo" => $titulo, "prioridad" => $prioridad, "hecha" => $hecha];
}

print_r(creaTarea("Repasar", hecha: true));
Pythonmain.py
def crea_tarea(titulo: str, prioridad: int = 1, hecha: bool = False) -> dict:
    return {"titulo": titulo, "prioridad": prioridad, "hecha": hecha}


print(crea_tarea("Repasar", hecha=True))

¿Por qué? · En PHP no existe

¿Por qué el valor por defecto [] es una trampa? En PHP no lo es

En PHP, el valor por defecto se evalúa en cada llamada, y un array nuevo es una copia nueva. En Python se evalúa una sola vez, cuando se define la función. Si es una lista, todas las llamadas comparten la misma.

Pythonmain.py
def con_etiqueta(titulo, etiquetas=[]):
    etiquetas.append("nueva")
    return titulo, etiquetas

Cada vez que llames a esa función sin pasar etiquetas, la lista crece. La solución es usar None como valor por defecto y crear la lista dentro. El porqué (listas mutables frente a inmutables) lo verás en la lección [Mutable frente a inmutable y la trampa del [] por defecto](/bootcamp/python/mutable-e-inmutable), en el módulo 04.

3 · *args y **kwargs

A veces no sabes cuántos argumentos van a llegar. *args junta los sueltos en una tupla; **kwargs junta los que llegan con nombre en un diccionario. Los nombres args y kwargs son costumbre: lo que manda son los asteriscos.

Pythonmain.py
# En PHP: function sumaPrioridades(int ...$prioridades): int
def suma_prioridades(*prioridades: int) -> int:
    print(prioridades)
    return sum(prioridades)


print(suma_prioridades(1, 3, 2))
print(suma_prioridades())


def describe(titulo: str, **extras) -> str:
    print(extras)
    return titulo + " " + ", ".join(f"{k}={v}" for k, v in extras.items())


print(describe("Comprar pan", prioridad=2, lugar="tienda"))

El asterisco también sirve al llamar: *lista reparte una lista en argumentos sueltos y **dic reparte un diccionario en argumentos con nombre. En PHP es el spread ...$lista.

Pythonmain.py
def crea_tarea(titulo, prioridad=1, hecha=False):
    return f"{titulo} P{prioridad} hecha={hecha}"


datos = ["Comprar pan", 2]
extras = {"hecha": True}

# En PHP: creaTarea(...$datos, ...$extras)
print(crea_tarea(*datos, **extras))
Quiero…En PHPEn Python
Recoger argumentos sueltosfunction f(...$a)def f(*a)
Recoger argumentos con nombre(no existe igual)def f(**kw)
Repartir una lista al llamarf(...$lista)f(*lista)
Repartir un diccionario al llamarf(...$asociativo)f(**dic)

4 · Solo por nombre y solo por posición

Python deja decidir cómo se pasa cada argumento. Todo lo que va después de un * solo se puede pasar por nombre (útil con banderas como hecha=True, para que nadie escriba un True suelto sin saber qué es). Todo lo que va antes de una / solo se puede pasar por posición.

Pythonmain.py
# Después del * solo se admite por nombre.
def crea_tarea(titulo, *, prioridad=1, hecha=False):
    return f"{titulo} P{prioridad} hecha={hecha}"


print(crea_tarea("Comprar pan", prioridad=2))
# crea_tarea("Comprar pan", 2)  daría TypeError.


# Antes de la / solo se admite por posición.
def doble(numero, /):
    return numero * 2


print(doble(21))
# doble(numero=21)  daría TypeError.

5 · Las funciones son valores

En Python una función es un valor como cualquier otro: la guardas en una variable, la metes en una lista o se la pasas a otra función. Sin comillas y sin tipo callable. Escribes el nombre sin paréntesis y es la función; con paréntesis, la ejecutas.

Pythonmain.py
def formatea_tarea(titulo: str) -> str:
    return f"- {titulo}"


# En PHP: $f = formatea_tarea(...);  (first-class callable)
f = formatea_tarea
print(f("Comprar pan"))
print(f)


def aplica(funcion, titulos):
    return [funcion(t) for t in titulos]


# En PHP: array_map(strtoupper(...), $titulos)
print(aplica(str.upper, ["pan", "leche"]))
print(aplica(formatea_tarea, ["pan", "leche"]))

# lambda: una función pequeña sin nombre. En PHP: fn($t) => strlen($t)
largo = lambda t: len(t)
print(largo("Comprar pan"))
PHP 8.5index.php
<?php
declare(strict_types=1);

function formateaTarea(string $titulo): string
{
    return "- $titulo";
}

$f = formateaTarea(...);
echo $f("Comprar pan") . PHP_EOL;
print_r(array_map(strtoupper(...), ["pan", "leche"]));
Pythonmain.py
def formatea_tarea(titulo: str) -> str:
    return f"- {titulo}"


f = formatea_tarea
print(f("Comprar pan"))
print(list(map(str.upper, ["pan", "leche"])))

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Formatea una tarea

Escribe formatea(titulo, prioridad) que imprima [P2] Comprar pan para formatea("Comprar pan", 2), y llámala con esos valores. Es el printf("[P%d] %s", ...) de PHP.

Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.

Pythonmain.py · editable

Resumen

Lo que te llevas de esta lección

  1. def nombre(params): y cuerpo sangrado (en PHP, function nombre($p) { }). Sin return, devuelve None.
  2. return a, b devuelve una tupla; se desempaqueta con x, y = f() (en PHP, [$x, $y] = f()).
  3. Valores por defecto y argumentos por nombre (hecha=True), como los named arguments de PHP 8. Nunca [] por defecto: usa None.
  4. *args = tupla de sueltos, **kwargs = diccionario de nombrados (en PHP, ...$args). *, obliga a nombrar y / lo prohíbe.
  5. Una función es un valor: f sin paréntesis es la función, f() la ejecuta (en PHP, strlen(...)).

Para recordarlo: «Una estrella suelta, dos estrellas nombra»

*args junta lo suelto (tupla) y **kwargs junta lo que tiene nombre (diccionario). Y recuerda: sin paréntesis es la función; con paréntesis, la ejecutas.