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ó.
En una línea
Sección titulada «En una línea»No se pasa el valor ni la referencia: se pasa el objeto, y el parámetro es otra etiqueta sobre él.
El modelo, sin metáforas
Sección titulada «El modelo, sin metáforas»def f(x): print(id(x))
a = [1, 2, 3]print(id(a))f(a) # el mismo númeroLas 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.
Lo que cuesta la flexibilidad
Sección titulada «Lo que cuesta la flexibilidad»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:
| 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.
El default que se acumula
Sección titulada «El default que se acumula»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 historialNone 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.
* y /: obligar al llamador
Sección titulada «* y /: obligar al llamador»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.
Inmutables: el alias inofensivo
Sección titulada «Inmutables: el alias inofensivo»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.
La trampa
Sección titulada «La trampa»Cuándo NO copiar al entrar
Sección titulada «Cuándo NO copiar al entrar»- 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,tuplede inmutables yfrozensetno necesitan protección.
Ejercicio
Sección titulada «Ejercicio»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 itemsSolució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).
Referencias
Sección titulada «Referencias»- 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.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 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.