Usando Parâmetros *args e **kwargs no seu Código: um Tutorial de Python 3

Pranay Kapgate2022-02-14 · 11 min read

Usando Parâmetros *args e **kwargs no seu Código: um Tutorial de Python 3

Introdução

Python é uma das linguagens de programação mais populares do mundo. Em Python, os parâmetros fazem parte das definições de função. Eles permitem especificar certos argumentos para uma função. O argumento pode ser aceito e aplicado pela função.

No entanto, não é possível saber no momento da codificação quais casos de uso exatos podem ser implementados com o seu código. Sendo assim, para o bem dos futuros programadores e usuários do seu programa, é aconselhável passar um número variável de argumentos para uma função. Para fazer isso, você deve usar parâmetros especiais. Estes são *args e **kwargs. Neste tutorial, nós iremos aprender tudo sobre os parâmetros *args e **kwargs em Python. Também aprenderemos como ordenar argumentos e como aplicá-los em chamadas de função.

Pré-requisitos

Para poder seguir as etapas do tutorial, existem alguns pré-requisitos que você precisa preparar. Primeiro, você precisa ter o Python 3 instalado em seu servidor com um ambiente de programação configurado e em execução. Você também precisa ter o programa para o seu sistema operacional específico instalado (Ubuntu, CentOS, Debian, etc).

O que é *args e como funciona?

Vamos começar entendendo como o *args funciona. A versão com um único asterisco do parâmetro é usada para enviar listas de argumentos de comprimento variável sem palavras-chave para funções. Tenha em mente que o asterisco é o elemento mais crítico nesse parâmetro.

Para entender melhor, vamos considerar um exemplo. A seguir está uma função típica que você pode encontrar em seu código, usando dois argumentos:

def multiply(x, y):
  print (x * y)

1 2	def multiply(x, y): print (x * y)

Como você pode ver, nossos argumentos na função acima são x e y. Ao chamar a função, você usará números correspondentes a x e y. Digamos que estamos passando os números inteiros 5 e 4 para x e y respectivamente:

def multiply(x, y):
  print (x * y)

multiply(5, 4)

def multiply(x, y):

print (x * y)

multiply(5, 4)

Agora podemos executar o código:

python lets_multiply.py

1	python lets_multiply.py

A saída que receberemos será a seguinte:

Saída:

20

Saída:

A saída mostra que os números inteiros 5 e 4 foram multiplicados. Isso significa que a função multiply(x, y) funcionou.

Agora, digamos que queiramos eventualmente multiplicar três números em vez de apenas dois. Infelizmente, adicionar um número extra à função acima gerará um erro como este:

def multiply(x, y):
  print (x * y)

multiply(5, 4, 3)

def multiply(x, y):

print (x * y)

multiply(5, 4, 3)

Saída:

TypeError: multiply() takes 2 positional arguments but 3 were given

Saída:

TypeError: multiply() takes 2 positional arguments but 3 were given

Portanto, se você tem alguma ideia de que pode precisar adicionar mais argumentos mais tarde, aplique o parâmetro *args para sua conveniência. Você pode usá-lo assim:

def multiply(*args):
  z = 1
  for num in args:
    z *= num
  print(z)

multiply(4, 5)
multiply(10, 9)
multiply(2, 3, 4)
multiply(3, 5, 10, 6)

def multiply(*args):

z = 1

for num in args:

z *= num

print(z)

multiply(4, 5)

multiply(10, 9)

multiply(2, 3, 4)

multiply(3, 5, 10, 6)

Nós simplesmente substituímos os parâmetros de função x e y por *args. A execução deste código fornecerá o produto para cada chamada de função, assim:

Saída:

20
90
24
900

Saída:

900

Assim, o *args é ideal para usar quando você deseja enviar listas de argumentos de comprimento variável para sua função. Devido à sua capacidade, você pode passar quantos argumentos quiser para as chamadas de função. Sendo assim, este parâmetro permite que você construa um código mais flexível que pode aceitar uma boa quantidade de argumentos variáveis e sem palavras-chave na função.

O que é **kwargs e como funciona?

A seguir, temos a versão com duplo asterisco dos parâmetros, que é **kwargs. Ao contrário da forma anterior, este parâmetro permite passar dicionários de argumentos de comprimento variável com palavras-chave para a função. Semelhante ao *args, os asteriscos duplos são o elemento mais crítico do parâmetro.

Como fizemos na seção anterior, você pode adicionar quantos argumentos quiser. A diferença é que você deve atribuir palavras-chave. Para entender melhor, considere o seguinte exemplo. Aqui, começaremos imprimindo os **kwargs argumentos que queremos passar para a função:

def print_kwargs(**kwargs):
  print(kwargs)

1 2	def print_kwargs(**kwargs): print(kwargs)

Agora, vamos chamar a função. Como você pode ver, adicionamos argumentos de palavra-chave:

def print_kwargs(**kwargs):
 print(kwargs)

print_kwargs(kwargs_1="Shark", kwargs_2=4.5, kwargs_3=True)

def print_kwargs(**kwargs):

print(kwargs)

print_kwargs(kwargs_1="Shark", kwargs_2=4.5, kwargs_3=True)

Executar o programa neste ponto mostrará esta saída:

python print_kwargs.py

1	python print_kwargs.py

Saída:

{'kwargs_3': True, 'kwargs_2': 4.5, 'kwargs_1': 'Shark'}

Saída:

{'kwargs_3': True, 'kwargs_2': 4.5, 'kwargs_1': 'Shark'}

No entanto, existe a possibilidade de que o tipo de dados do seu dicionário não seja ordenado. Isso depende muito da versão do Python 3 que você usa. Por exemplo, qualquer versão posterior ao Python 3.6 fornece os pares chave-valor em ordem. Qualquer versão anterior a essa mostrará a saída em ordem aleatória. O dicionário que você criar será chamado kwargs. Note que você pode usá-lo e manipulá-lo como qualquer outro dicionário no sistema. Vamos ver como você pode colocar o **kwargs parâmetro em maior uso e aplicação.

No exemplo a seguir, tentaremos criar uma nova função que saudará um dicionário com nomes. Nosso dicionário de exemplo terá dois nomes:

def print_values(**kwargs):
  for key, value in kwargs.items():
    print("O valor de {} é {}".format(key, value))

print_values(my_name="Sammy", your_name="Casey")

def print_values(**kwargs):

for key, value in kwargs.items():

print("O valor de {} é {}".format(key, value))

print_values(my_name="Sammy", your_name="Casey")

Executar o programa fornecerá esta saída:

python print_values.py

1	python print_values.py

Saída:

O valor de your_name é Casey
O valor de my_name é Sammy

Saída:

O valor de your_name é Casey

O valor de my_name é Sammy

Semelhante ao exemplo anterior, os dicionários podem parecer não ordenados. Como tal, a ordem dos nomes Casey e Sammy pode ser invertida em alguns casos.

A seguir, passaremos argumentos adicionais para a função. Isso provará que você pode fazer o **kwargs aceitar qualquer número de argumentos que você desejar:

def print_values(**kwargs):
  for key, value in kwargs.items():
    print("O valor de {} é {}".format(key, value))

print_values(
name_1="Alex",
name_2="Gray",
name_3="Harper",
name_4="Phoenix",
name_5="Remy",
name_6="Val")

def print_values(**kwargs):

for key, value in kwargs.items():

print("O valor de {} é {}".format(key, value))

print_values(

name_1="Alex",

name_2="Gray",

name_3="Harper",

name_4="Phoenix",

name_5="Remy",

name_6="Val")

Executar o programa mostrará esta saída:

Saída:

O valor de name_2 é Gray
O valor de name_6 é Val
O valor de name_4 é Phoenix
O valor de name_5 é Remy
O valor de name_3 é Harper
O valor de name_1 é Alex

Saída:

O valor de name_2 é Gray

O valor de name_6 é Val

O valor de name_4 é Phoenix

O valor de name_5 é Remy

O valor de name_3 é Harper

O valor de name_1 é Alex

Esta saída também pode não ser ordenada. Independentemente disso, estes exemplos mostram que o **kwargs dá ao seu programa a flexibilidade de usar vários argumentos de palavra-chave.

Como ordenar argumentos

É importante ter em mente a ordem definida ao ordenar um argumento em uma função ou chamada de função. Ela é a seguinte:

Argumentos posicionais formais
*args
Argumentos de palavra-chave
**kwargs

Digamos que você esteja usando *args e **kwargs com parâmetros posicionais explícitos. Isso significa que sua função será parecida com esta:

def example(arg_1, arg_2, *args, **kwargs):
...

1 2	def example(arg_1, arg_2, args, *kwargs): ...

Por outro lado, usar esses parâmetros com nomes (parâmetros nomeados) dará à sua função a seguinte estrutura geral:

def example2(arg_1, arg_2, *args, kw_1="shark", kw_2="blobfish", **kwargs):
...

1 2	def example2(arg_1, arg_2, args, kw_1="shark", kw_2="blobfish", *kwargs): ...

Não cumprir com a ordem definida resultará em um erro de sintaxe ao executar seu código. Portanto, é melhor evitar cometer esse erro logo de início.

Como usar *args e **kwargs em chamadas de função

Por fim, mostraremos como usar ambos os parâmetros para passar argumentos para funções. Começaremos com um exemplo mostrando *args:

def some_args(arg_1, arg_2, arg_3):
  print("arg_1:", arg_1)
  print("arg_2:", arg_2)
  print("arg_3:", arg_3)

args = ("Sammy", "Casey", "Alex")

some_args(*args)

def some_args(arg_1, arg_2, arg_3):

print("arg_1:", arg_1)

print("arg_2:", arg_2)

print("arg_3:", arg_3)

args = ("Sammy", "Casey", "Alex")

some_args(*args)

Há três parâmetros nesta função: arg_1, arg_2, e arg_3. Você deve criar uma variável e defini-la como um iterável. Neste caso, será uma tupla. Depois, você pode passar a variável para a função usando a sintaxe de asterisco.

Observe a saída ao executar o programa usando o python some_args.py comando:

Saída:

arg_1: Sammy
arg_2: Casey
arg_3: Alex

Saída:

arg_1: Sammy

arg_2: Casey

arg_3: Alex

Também é possível alterar o programa para um tipo de dados de lista iterável tipo de dados com um nome de variável diferente. O código a seguir combina *args com um parâmetro nomeado:

def some_args(arg_1, arg_2, arg_3):
  print("arg_1:", arg_1)
  print("arg_2:", arg_2)
  print("arg_3:", arg_3)

my_list = [2, 3]

some_args(1, *my_list)

def some_args(arg_1, arg_2, arg_3):

print("arg_1:", arg_1)

print("arg_2:", arg_2)

print("arg_3:", arg_3)

my_list = [2, 3]

some_args(1, *my_list)

A saída será a seguinte ao executar o programa:

Saída:

arg_1: 1
arg_2: 2
arg_3: 3

Saída:

arg_1: 1

arg_2: 2

arg_3: 3

Por outro lado, você pode aplicar argumentos nomeados com **kwargs. Certifique-se de criar uma variável que seja igual a um dicionário. Ela deve ter 2 pares de chave-valor. Veja como passaremos a variável para uma função com 3 argumentos:

def some_kwargs(kwarg_1, kwarg_2, kwarg_3):
  print("kwarg_1:", kwarg_1)
  print("kwarg_2:", kwarg_2)
  print("kwarg_3:", kwarg_3)

kwargs = {"kwarg_1": "Val", "kwarg_2": "Harper", "kwarg_3": "Remy"}

some_kwargs(**kwargs)

def some_kwargs(kwarg_1, kwarg_2, kwarg_3):

print("kwarg_1:", kwarg_1)

print("kwarg_2:", kwarg_2)

print("kwarg_3:", kwarg_3)

kwargs = {"kwarg_1": "Val", "kwarg_2": "Harper", "kwarg_3": "Remy"}

some_kwargs(**kwargs)

Use o python some_kwargs.py comando mais uma vez para executar o programa:

Saída:

kwarg_1: Val
kwarg_2: Harper
kwarg_3: Remy

Saída:

kwarg_1: Val

kwarg_2: Harper

kwarg_3: Remy

Conclusão

Ao final deste tutorial, você deve estar bem familiarizado com o que são *args e **kwargs e como eles funcionam. Agora você pode aplicar esses parâmetros ao seu próprio código para tornar seu programa flexível para futuros usuários. Eles são ideais para situações em que você não sabe quantos argumentos podem ser usados. Apenas certifique-se de ter cuidado com os elementos críticos das funções e parâmetros.

Por fim, aqui estão mais recursos do nosso blog que ajudarão você a trabalhar com sucesso com o Python:

Boa computação!

Pranay Kapgate

Autor · CloudSigma

Preslav Dobrev é um designer criativo na CloudSigma, focado na construção de uma identidade empresarial consistente por meio de canais de marketing tradicionais e inovadores. Ele é hábil em combinar a visão artística com o marketing estratégico para criar narrativas de marca impactantes.

Usando Parâmetros *args e **kwargs no seu Código: um Tutorial de Python 3

Introdução

Pré-requisitos

O que é *args e como funciona?

O que é **kwargs e como funciona?

Como ordenar argumentos

Como usar *args e **kwargs em chamadas de função

Conclusão

Pranay Kapgate

Comentários