Como usar os parâmetros *args no Python

Resumo: neste tutorial, você aprenderá sobre os parâmetros *args do Python e como usá-los para definir funções variádicas.

Desempacotamento de tupla

O seguinte descompacta uma tupla em duas variáveis:

x, y = 10, 20

Python atribui 10 a x e 20 a y. É semelhante a passar dois argumentos para uma função:

def add(x, y):
    return x + y


add(10, 20)

Neste exemplo, Python passou 10 para x e 20 para y.

Da mesma forma, o seguinte atribui 10 a x, 20 a y e a lista [30, 40] a z:

x, y, *z = 10, 20, 30, 40

print(x)
print(y)
print(z)

Python usa o mesmo conceito para os argumentos da função. Por exemplo:


def add(x, y, *args):
    total = x + y
    for arg in args:
        total += arg

    return total


result = add(10, 20, 30, 40)
print(result)

A função add aceita três parâmetros x, y e *args. O *args é um argumento especial precedido por uma estrela (*).

Ao passar os argumentos posicionais 10, 20, 30 e 40 para a função, o Python atribui 10 a x, 20 a y e uma tupla (30, 40) a args.

É como desempacotar tupla, exceto que args é uma tupla, não uma lista.

Introdução ao parâmetro Python *args

Quando uma função possui um parâmetro precedido por um asterisco (*), ela pode aceitar um número variável de argumentos. E você pode passar zero, um ou mais argumentos para o parâmetro *args.

Em Python, os parâmetros como *args são chamados de parâmetros variádicos. As funções que possuem parâmetros variádicos são chamadas de funções variádicas.

Observe que você não precisa nomear args um parâmetro variádico. Por exemplo, você pode usar qualquer nome significativo como *numbers, *strings, *lists, etc.

No entanto, por convenção, o Python usa *args para um parâmetro variável.

Vejamos o seguinte exemplo:

def add(*args):
    print(args)


add()

Saída:

()

A função add mostra uma tupla vazia.

O seguinte mostra o tipo do argumento args e seu conteúdo:

def add(*args):
    print(type(args))
    print(args)

add()

Saída

<class 'tuple'>
()

Como não passamos nenhum argumento para a função add(), a saída mostra uma tupla vazia.

O seguinte passa três argumentos para a função add():

def add(*args):
    print(args)


add(1,2,3)

Saída:

(1, 2, 3)

Agora, o args tem três números 1, 2 e 3. Para acessar cada elemento do argumento args, você usa a notação de colchetes [] com um índice:

def add(*args):
    print(args[0])
    print(args[1])
    print(args[2])


add(1, 2, 3)

Além disso, você pode usar um loop for para iterar sobre os elementos da tupla.

A seguir mostramos como somar todos os números da tupla args na função add():

def add(*args):
    total = 0
    for arg in args:
        total += arg
    return total


total = add(1, 2, 3)
print(total)

Saída:

O argumento Python *args esgota os argumentos posicionais

Se você usar o argumento *args, não poderá adicionar mais argumentos posicionais. No entanto, você pode usar argumentos de palavra-chave.

O exemplo a seguir resulta em erro porque usa um argumento posicional após o argumento *args:

def add(x, y, *args, z):
    return x + y + sum(args) + z


add(10, 20, 30, 40, 50)

Erro:

TypeError: add() missing 1 required keyword-only argument: 'z'

Para corrigi-lo, você precisa usar um argumento de palavra-chave após o argumento *args da seguinte forma:

def add(x, y, *args, z):
    return x + y + sum(args) + z


add(10, 20, 30, 40, z=50)

Neste exemplo, o Python atribui 10 a x, 20 a y, (30,40) a args e 50 a z.

Argumentos de descompactação

A função point a seguir aceita dois argumentos e retorna uma representação de string de um ponto com coordenada x e coordenada y:

def point(x, y):
    return f'({x},{y})'

Se você passar uma tupla para a função point, receberá um erro:

a = (0, 0)
origin = point(a)

Erro:

TypeError: point() missing 1 required positional argument: 'y'

Para corrigir isso, você precisa prefixar a tupla a com o operador * assim:

def point(x, y):
    return f'({x},{y})'


a = (0, 0)
origin = point(*a)
print(origin)

Saída:

(0,0)

Quando você precede o argumento a com o operador *, o Python descompacta a tupla e atribui seus elementos aos parâmetros x e y.

Resumo

Use argumentos Python *args para uma função que aceita um número variável de argumentos.
O argumento *args esgota os argumentos posicionais, portanto, você só pode usar argumentos de palavra-chave depois dele.