Como utilizar argumentos de comprimento variável (*args, **kwargs) em Python

Os seguintes argumentos de função são provavelmente os mais comuns quando se olha para o código Python e se diz: “O que é isto?

• *args
• **kwargs

Qualquer número de argumentos (argumentos de comprimento variável) pode ser especificado anexando um asterisco ao argumento na definição da função, como se segue

• *
• **

Os nomes *args,**kwargs são frequentemente utilizados como convenção. No entanto, outros nomes são aceitáveis desde que * e ** estejam no início. O seguinte código de amostra utiliza os nomes *args,**kwargs.

Os seguintes detalhes são descritos abaixo.

• *args:Aceita múltiplos argumentos como um tuple
• **kwargs:Aceita múltiplos argumentos de palavras-chave como dicionário

*args: Aceita múltiplos argumentos como um tuple

O número arbitrário de argumentos pode ser especificado através da definição de argumentos com *, como em *args.

def my_sum(*args):
    return sum(args)

print(my_sum(1, 2, 3, 4))
# 10

print(my_sum(1, 2, 3, 4, 5, 6, 7, 8))
# 36

Vários argumentos são recebidos como um tuple na função. No exemplo, a função soma() é passada como um tuple para calcular a soma.

def my_sum2(*args):
    print('args: ', args)
    print('type: ', type(args))
    print('sum : ', sum(args))

my_sum2(1, 2, 3, 4)
# args:  (1, 2, 3, 4)
# type:  <class 'tuple'>
# sum :  10

Também pode ser combinado com um argumento de posição.

O valor especificado depois (à direita de) o argumento posicional é passado para args como um tuple. Se houver apenas um argumento posicional, é um tuple vazio.

def func_args(arg1, arg2, *args):
    print('arg1: ', arg1)
    print('arg2: ', arg2)
    print('args: ', args)

func_args(0, 1, 2, 3, 4)
# arg1:  0
# arg2:  1
# args:  (2, 3, 4)

func_args(0, 1)
# arg1:  0
# arg2:  1
# args:  ()

Os argumentos marcados com * podem ser definidos em primeiro lugar. Neste caso, contudo, os argumentos definidos mais tarde do que *args devem ser especificados em forma de palavras-chave. A propósito, o formato da palavra-chave é o formato “nome do argumento = valor”.

O último valor não é automaticamente passado para o argumento posicional. Portanto, se não for especificado como um argumento de palavra-chave, resultará um erro de TypeError.

def func_args2(arg1, *args, arg2):
    print('arg1: ', arg1)
    print('arg2: ', arg2)
    print('args: ', args)

# func_args2(0, 1, 2, 3, 4)
# TypeError: func_args2() missing 1 required keyword-only argument: 'arg2'

func_args2(0, 1, 2, 3, arg2=4)
# arg1:  0
# arg2:  4
# args:  (1, 2, 3)

Se apenas * argumentos forem especificados, os argumentos subsequentes devem ser sempre especificados como argumentos de palavras-chave.(keyword-only argument)

def func_args_kw_only(arg1, *, arg2):
    print('arg1: ', arg1)
    print('arg2: ', arg2)

# func_args_kw_only(100, 200)
# TypeError: func_args_kw_only() takes 1 positional argument but 2 were given

func_args_kw_only(100, arg2=200)
# arg1:  100
# arg2:  200

**kwargs: Aceita múltiplos argumentos de palavras-chave como dicionário

O número arbitrário de argumentos com palavras-chave pode ser especificado definindo argumentos com ,** como em **kwargs.

Na função, o nome do argumento é recebido como um dicionário cuja chave é a chave e cujo valor é o valor.

def func_kwargs(**kwargs):
    print('kwargs: ', kwargs)
    print('type: ', type(kwargs))

func_kwargs(key1=1, key2=2, key3=3)
# kwargs:  {'key1': 1, 'key2': 2, 'key3': 3}
# type:  <class 'dict'>

Também pode ser usado em conjunto com um argumento de posição.

def func_kwargs_positional(arg1, arg2, **kwargs):
    print('arg1: ', arg1)
    print('arg2: ', arg2)
    print('kwargs: ', kwargs)

func_kwargs_positional(0, 1, key1=1)
# arg1:  0
# arg2:  1
# kwargs:  {'key1': 1}

Ao especificar o objecto do dicionário com ** como argumento ao chamar a função, é possível expandi-lo e passá-lo como o respectivo argumento.

d = {'key1': 1, 'key2': 2, 'arg1': 100, 'arg2': 200}

func_kwargs_positional(**d)
# arg1:  100
# arg2:  200
# kwargs:  {'key1': 1, 'key2': 2}

Os argumentos marcados com ** só podem ser definidos no final do argumento. A definição de outro argumento após o argumento marcado com ** resultará num erro de SyntaxError.

# def func_kwargs_error(**kwargs, arg):
#     print(kwargs)

# SyntaxError: invalid syntax