resultado - ¿Cuál es la cantidad máxima de argumentos en una función de Python?

pasar una lista como parametro en python

Question

Es de conocimiento común que las funciones de Python pueden tener un máximo de 256 argumentos. Lo que me interesa saber es si este límite se aplica a *args y **kwargs cuando se desenrollan de la siguiente manera:

items = [1,2,3,4,5,6]

def do_something(*items):
    pass

Lo pregunto porque, hipotéticamente, puede haber casos en los que se desenrolle una lista de más de 256 elementos como un conjunto de *args o **kwargs .

Answer 1

El límite se debe a la forma en que el bytecode compilado llama a una función con argumentos de posición y / o argumentos de palabra clave.

La CALL_FUNCTION op_arg de bytes de preocupación es CALL_FUNCTION que transporta un op_arg 4 bytes de longitud, pero en los dos bytes menos significativos se utilizan. De ellos, el byte más significativo representa la cantidad de argumentos de palabra clave en la pila y el byte menos significativo el número de argumentos de posición en la pila. Por lo tanto, puede tener como máximo 0xFF == 255 argumentos clave o 0xFF == 255 argumentos posicionales.

Este límite no se aplica a *args y **kwargs porque las llamadas con esa gramática utilizan las operaciones bytecode CALL_FUNCTION_VAR , CALL_FUNCTION_KW y CALL_FUNCTION_VAR_KW dependiendo de la firma. Para estos **kwargs , la pila consta de un iterable para los *args y un dict para los **kwargs . Estos artículos se pasan directamente al receptor que los desenrolla según sea necesario.

Answer 2

En versiones anteriores a Python 3.7, CPython tiene un límite de 255 argumentos pasados ​​explícitamente en una llamada:

>>> def f(*args, **kwargs): pass
...
>>> exec("f({})".format('', ''.join(map(str, range(256)))))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
SyntaxError: more than 255 arguments

Esta limitación está en su lugar porque hasta Python 3.5, el CALL_FUNCTION operación CALL_FUNCTION sobrecargó el argumento del código de operación para codificar tanto el número de argumentos posicionales como el de palabra clave en la pila, cada uno codificado en un solo byte.

Esta limitación se elimina en la próxima versión de Python 3.7, consulte el número 27213 y el número 12844 ; # 27213 reformuló la familia de CALL_FUNCTION* para rendimiento y simplicidad (parte de 3.6), liberando el argumento de código de operación para codificar solo un conteo de argumento único, y # 12844 eliminó la verificación en tiempo de compilación que impidió compilar código con más argumentos .

En 3.7, con el código de operación EXTENDED_ARG() , ahora no hay ningún límite en cuanto a la cantidad de argumentos que puede pasar usando argumentos explícitos, guarde cuántos se pueden ajustar en la pila (tan limitados ahora por su memoria):

>>> import sys
>>> sys.version_info
sys.version_info(major=3, minor=7, micro=0, releaselevel=''alpha'', serial=2)
>>> def f(*args, **kwargs): pass
...
>>> exec("f({})".format('', ''.join(map(str, range(256)))))
>>> exec("f({})".format('', ''.join(map(str, range(2 ** 16)))))

Tenga en cuenta que las listas, tuplas y diccionarios están limitados a los elementos sys.maxsize , por lo que si la función llamada usa *args y / o **kwargs catch-all de **kwargs , estos son limitados.

Para la sintaxis de llamada de *args y **kwargs (argumentos de expansión), no existen límites que no sean los mismos límites de tamaño sys.maxint en los tipos estándar de Python.

Answer 3

Esto parece ser una restricción en la compilación de la fuente, por lo que probablemente exista solo para que los argumentos se pasen directamente, no en * args o ** kwargs.

El código relevante se puede encontrar en ast.c :

if (nargs + nkeywords + ngens > 255) {
  ast_error(n, "more than 255 arguments");
  return NULL;
}

Pero tenga en cuenta que esto está en ast_for_call, por lo que solo se aplica al lado de la llamada. es decir, f(a,b,c,d,e...) , en lugar de la definición, aunque contará tanto posicional (a,b,c,d) como keyword (a=1, b=2, c=3) parámetros de estilo. Los parámetros reales *args y **kwargs parecen que solo deberían contar como un argumento para estos fines en el lado de la llamada.

Answer 4

Intenté una lista de 4000 artículos, y funcionó. Así que supongo que funcionará también para valores más grandes.

Answer 5

WFM

>>> fstr = ''def f(%s): pass'' % ('', ''.join([''arg%d'' % i for i in range(5000)]))
>>> exec(fstr)
>>> f
<function f at 0x829bae4>

Actualización: como notó Brian, el límite está en el lado de la llamada:

>>> exec ''f('' + '',''.join(str(i) for i in range(5000)) + '')''

Traceback (most recent call last):
  File "<pyshell#63>", line 1, in <module>
    exec ''f('' + '',''.join(str(i) for i in range(5000)) + '')''
  File "<string>", line 1
SyntaxError: more than 255 arguments (<string>, line 1)

por otro lado esto funciona:

>>> f(*range(5000))
>>> 

Conclusión: no, no se aplica a argumentos desenrollados.

Answer 6

para ** kwargs, si recuerdo bien, este es un diccionario. Por lo tanto, no tiene límites.

por * args, no estoy tan seguro, pero creo que es una tupla o una lista, por lo que tampoco tiene límites.

Me refiero sin límites, excepto quizás el límite de memoria.