Argumentos Args e Kwargs em Python

Introdução

Neste laboratório, você aprenderá sobre *args e **kwargs em Python. Estas sintaxes especiais podem parecer intimidantes no início, mas são fáceis de entender e fornecem uma maneira poderosa de tornar suas funções mais flexíveis. Você aprenderá a definir funções que podem aceitar um número variável de argumentos, o que é um recurso comum e útil em muitos programas e bibliotecas Python.

Args e Kwargs

Nesta etapa, você aprenderá a sintaxe básica de *args e **kwargs. Eles são usados em definições de função para permitir a passagem de um número indefinido de argumentos. *args é para argumentos posicionais não nomeados (non-keyword), enquanto **kwargs é para argumentos nomeados (keyword arguments).

Nota: Se você não está familiarizado com o uso do WebIDE (semelhante ao VS Code), aprenda primeiro neste laboratório.

Primeiro, vamos ver como definir uma função que pode aceitar qualquer combinação de argumentos. No explorador de arquivos à esquerda, encontre o arquivo main.py localizado no diretório ~/project e abra-o no editor.

Adicione o seguinte código a main.py:

## Define a function that accepts any number of positional and keyword arguments
def some_function(*args, **kwargs):
    print("This function can accept any arguments.")
    print(f"Received positional arguments: {args}")
    print(f"Received keyword arguments: {kwargs}")
    print("-" * 20)

## Call with any number of positional arguments
some_function('arg1', 'arg2', 'arg3')

## Call with any number of keyword arguments
some_function(key1='arg1', key2='arg2', key3='arg3')

## Call with both positional and keyword arguments
some_function('positional_arg', key1='keyword_arg')

## Or call with no arguments at all
some_function()

É importante notar que args e kwargs são apenas convenções de nomenclatura. O asterisco único (*) e o asterisco duplo (**) são a sintaxe real que realiza o trabalho. No entanto, seguir a convenção é considerado uma boa prática na comunidade Python.

Agora, execute o script abrindo um terminal no WebIDE e executando o seguinte comando:

python3 main.py

Você deverá ver a seguinte saída, demonstrando como a função lida com diferentes chamadas:

This function can accept any arguments.
Received positional arguments: ('arg1', 'arg2', 'arg3')
Received keyword arguments: {}
--------------------
This function can accept any arguments.
Received positional arguments: ()
Received keyword arguments: {'key1': 'arg1', 'key2': 'arg2', 'key3': 'arg3'}
--------------------
This function can accept any arguments.
Received positional arguments: ('positional_arg',)
Received keyword arguments: {'key1': 'keyword_arg'}
--------------------
This function can accept any arguments.
Received positional arguments: ()
Received keyword arguments: {}
--------------------

Isso mostra que *args coleta argumentos posicionais em uma tupla (tuple) e **kwargs coleta argumentos nomeados em um dicionário (dictionary).

args

Nesta etapa, você se concentrará especificamente em *args. Esta sintaxe permite que uma função aceite um número arbitrário de argumentos posicionais. Esses argumentos são coletados em uma tupla (tuple).

Limpe o conteúdo anterior de main.py e adicione o seguinte código. Este exemplo define uma função que aceita *args e imprime os argumentos que recebe, juntamente com seu tipo.

## *args collects positional arguments into a tuple
def some_function(*args):
    print(f'Arguments passed: {args} as {type(args)}')

## Pass multiple arguments - they'll be collected into the args tuple
some_function('arg1', 'arg2', 'arg3')

Neste código, *args na assinatura da função diz ao Python para reunir todos os argumentos posicionais extras passados para some_function e colocá-los em uma tupla chamada args.

Agora, execute o script a partir do terminal:

python3 main.py

A saída confirmará que os argumentos foram passados como uma tupla:

Arguments passed: ('arg1', 'arg2', 'arg3') as <class 'tuple'>

Isso demonstra como *args fornece uma maneira simples de lidar com um número variável de entradas sem ter que definir cada uma como um parâmetro separado.

kwargs

Nesta etapa, você aprenderá a usar **kwargs. Esta sintaxe é usada para coletar um número arbitrário de argumentos de palavra-chave (keyword arguments) em um dicionário (dictionary). Isso é útil quando você deseja lidar com argumentos nomeados que não definiu antecipadamente.

Limpe o conteúdo de main.py e adicione o seguinte código. Este exemplo define uma função que aceita **kwargs e imprime os argumentos de palavra-chave coletados e seu tipo.

## **kwargs collects keyword arguments into a dictionary
def some_function(**kwargs):
    print(f'keywords: {kwargs} as {type(kwargs)}')

## Pass keyword arguments - they'll be collected into the kwargs dict
some_function(key1='arg1', key2='arg2')

Aqui, **kwargs na assinatura da função diz ao Python para coletar todos os argumentos de palavra-chave passados para some_function em um dicionário chamado kwargs. As chaves do dicionário são os nomes dos argumentos e os valores são os valores dos argumentos.

Execute o script a partir do terminal:

python3 main.py

A saída mostrará que os argumentos de palavra-chave foram coletados em um dicionário:

keywords: {'key1': 'arg1', 'key2': 'arg2'} as <class 'dict'>

Este recurso é amplamente utilizado em Python para funções que precisam passar opções ou configurações, permitindo chamadas de função limpas e legíveis.

Resumo

Neste laboratório, você aprendeu a usar *args e **kwargs em Python para criar funções mais flexíveis.

Você aprendeu que:

• *args coleta um número variável de argumentos posicionais em uma tupla (tuple).
• **kwargs coleta um número variável de argumentos de palavra-chave (keyword arguments) em um dicionário (dictionary).
• args e kwargs são nomes convencionais, mas a sintaxe * e ** é o que habilita essa funcionalidade.

Dominar *args e **kwargs é um passo fundamental para escrever código Python mais avançado e reutilizável. Agora você pode criar funções mais adaptáveis a diferentes tipos de entrada.