Saltearse al contenido

Argumentos

«Python pasa los argumentos por referencia» y «por valor» son dos frases falsas, y la segunda es peor. Python pasa objetos compartidos: el parámetro es otro nombre para el mismo objeto, exactamente como b = a. Lo que ocurra después depende de si el objeto es mutable, no de cómo se pasó.

No se pasa el valor ni la referencia: se pasa el objeto, y el parámetro es otra etiqueta sobre él.

def f(x):
print(id(x))
a = [1, 2, 3]
print(id(a))
f(a) # el mismo número

Las dos llamadas imprimen el mismo id. No hay copia al entrar, y no hay copia al salir. Eso significa que una función puede hacer dos cosas muy distintas con su parámetro:

Lo que hace la función Efecto en el llamador
x = algo Ninguno: sólo mueve su etiqueta local
x.append(...), x[0] = ... Modifica el objeto del llamador
x = copy.deepcopy(x) y luego mutar Ninguno, pero paga la copia

Es habitual leer que esto es «pasar por referencia». No lo es: en C++ una referencia permite reasignar el objeto del llamador (x = algo cambia su variable). Aquí no. Es paso por objeto compartido, y el nombre importa porque predice el comportamiento.

Cada forma de declarar una función tiene un precio. No para elegir la más rápida, sino para saber cuándo el envoltorio gratuito deja de serlo:

Un millón de llamadas a la misma función
Forma Coste por llamada Frente a la directa
f(1, 2, 3) 63 ns 1.0×
f(a=1, b=2, c=3) 93 ns 1.47×
def f(*args, **kwargs) que delega 191 ns 3.0×

python mediciones/01-06-09-argumentos-numeros-texto-hash.py

El envoltorio genérico —el que usa un decorador, un functools.wraps, un framework de inyección— triplica el coste. Sigue siendo 191 nanosegundos: irrelevante una vez, decisivo en un bucle de un millón. La regla es la de siempre: mide antes de optimizar, pero sabe cuál es la forma barata cuando el perfil lo pida.

Un solo objeto por defecto, compartido entre llamadas
[] el valor por defecto, creado al definir 1ª llamada 2ª llamada 3ª llamada

El `[]` de la firma se evalúa una vez, al definir la función. Todas las llamadas que no pasen el argumento usan ese mismo objeto.

def registrar(evento, historial=[]):
historial.append(evento)
return historial
registrar("a") # ['a']
registrar("b") # ['a', 'b']

Es el mismo mecanismo de los capítulos 03 y 05, aplicado a la firma. La solución es el centinela inmutable:

def registrar(evento, historial=None):
historial = [] if historial is None else historial
historial.append(evento)
return historial

None es inmutable y único, así que no puede acumular nada. Es la razón por la que la biblioteca estándar lo usa en todas partes.

Dos símbolos en la firma cambian el contrato de la llamada, y casi nadie los usa:

def dividir(a, b, /, *, exacto=False):
...
  • Lo que está antes de / sólo puede pasarse por posición: dividir(10, 2).
  • Lo que está después de * sólo puede pasarse por nombre: dividir(10, 2, exacto=True).

Sirven para congelar la API: si el nombre de un parámetro posicional no es parte del contrato, renombrarlo no rompe a nadie. Y los argumentos por nombre son autodocumentados en la llamada. len(), str() y casi todas las funciones de C usan / por esta razón.

Cuando el argumento es inmutable, compartir el objeto no puede romper nada:

Tipo del argumento ¿La función puede cambiar el objeto del llamador?
int, float, str, tuple de inmutables No: cualquier operación crea otro objeto
list, dict, set, instancia mutable Sí, si llama a un método que muta
Mutable, pero copiado al entrar No, a cambio de O(n) por llamada

Esto explica por qué str es el tipo de paso más cómodo: puedes pasarlo a veinte funciones sin miedo, y ninguna puede estropearlo. Y por qué una API que recibe listas necesita o documentar que las muta, o copiarlas, o aceptar un iterable y materializar dentro.

  • Cuando la función documenta que muta. lista.sort() muta y está bien: el nombre lo dice.
  • Cuando el objeto es grande y de sólo lectura, copiar en cada llamada convierte una operación O(1) en O(n). Documenta el contrato en el docstring y confía en él.
  • Cuando el tipo es inmutable, copiar es no hacer nada: str, int, tuple de inmutables y frozenset no necesitan protección.

Explica por qué estas dos funciones se comportan distinto, y cuál usarías para una API pública:

def agregar_v1(items, x):
items += [x]
return items
def agregar_v2(items, x):
items = items + [x]
return items
Solución

agregar_v1 muta la lista del llamador, porque += sobre una lista llama a __iadd__ y modifica el objeto en su sitio. agregar_v2 crea una lista nueva y sólo mueve su etiqueta local: el llamador queda intacto.

Para una API pública, v2 es más segura porque no sorprende, pero es O(n) por llamada. La versión idiomática devuelve una lista nueva sin copiar dos veces:

def agregar(items, x):
return [*items, x]

Y si la intención es mutar por rendimiento, el nombre debe decirlo: agregar_en_sitio(items, x).

Comprobación con datos de ejemplo:

def agregar_v1(items, x):
items += [x]
return items
def agregar_v2(items, x):
items = items + [x]
return items
original = [1, 2]
r1 = agregar_v1(original, 3)
print("v1:", original, r1, r1 is original)
original = [1, 2]
r2 = agregar_v2(original, 3)
print("v2:", original, r2, r2 is original)
original = [1, 2]
r3 = agregar(original, 3)
print("agregar:", original, r3, r3 is original)
assert original == [1, 2], "agregar no debe mutar la lista del llamador"
  • Ramalho, L. Fluent Python, 2ª ed. Capítulos 6 y 7: objetos compartidos y funciones de primera clase.
  • Lott, S. F. Modern Python Cookbook, 3ª ed. Capítulo 3: parámetros, *, / y **kwargs.
  • Mediciones: mediciones/01-06-09-argumentos-numeros-texto-hash.py.
  • 03 · Nombres, no variables: el mismo mecanismo, dentro de una función.
  • 05 · Copias: cómo aislar el parámetro cuando hace falta.
  • 09 · Hashabilidad: por qué una clave mutable rompe un diccionario.