Desempacotamento e Empacotamento de Parâmetros em Funções em Python

Uma das áreas comuns onde o empacotamento e o desempacotamento são aplicados é nos parâmetros de funções. É comum observar em definições de funções a presença de parâmetros como *args e **kwargs.

Os termos args e kwargs são convenções de programação em Python, mas é possível usar qualquer nome no lugar deles. O *args representa parâmetros passados por posição, enquanto o **kwargs representa parâmetros passados por nome, ou seja, argumentos nomeados.

O operador * pode ser usado com qualquer objeto iterável (por exemplo, tuplas, listas e strings), enquanto o operador ** é usado apenas com dicionários.

*args

O operador * permite que uma função receba múltiplos valores que são empacotados em uma tupla:

def fun(*args):
    # acessa o primeiro elemento da tupla
    print(args[0])

    # imprime toda a tupla
    print(args)

fun("Python", "C++", "Java", "C#")

Neste exemplo, a função fun aceita uma tupla de valores. Podemos passar um número variável de argumentos para a função. No exemplo acima, quatro strings são passadas, formando uma tupla. A saída do programa é:

Python
('Python', 'C++', 'Java', 'C#')

Com essa funcionalidade, podemos passar para a função uma quantidade variável de argumentos:

def sum(*args):
    result = 0
    for arg in args:
        result += arg
    return result

print(sum(1, 2, 3))         # 6
print(sum(1, 2, 3, 4))      # 10
print(sum(1, 2, 3, 4, 5))   # 15

**kwargs

O operador ** empacota os argumentos passados por nome em um dicionário, onde os nomes dos parâmetros se tornam as chaves. Por exemplo, vamos definir uma função que apenas imprime todos os parâmetros recebidos:

def fun(**kwargs):
    print(kwargs)   # imprime o dicionário

fun(name="Tom", age="38", company="Google")
fun(language="Python", version="3.11")

A saída do programa será:

{'name': 'Tom', 'age': '38', 'company': 'Google'}
{'language': 'Python', 'version': '3.11'}

Dentro da função, podemos acessar os valores dos argumentos pelo nome das chaves:

def fun(**kwargs):
    for key in kwargs:
        print(f"{key} = {kwargs[key]}")

fun(name="Tom", age="38", company="Google")

A saída do programa será:

name = Tom
age = 38
company = Google

Desempacotamento de Argumentos

Até agora, mostramos como os operadores * e ** são usados para empacotar argumentos em tuplas e dicionários. No entanto, esses mesmos operadores podem ser usados para desempacotar valores.

Operador * e Desempacotamento

Vamos começar com uma situação em que o desempacotamento é útil. Suponha que estamos passando uma tupla para uma função:

def sum(*args):
    result = 0
    for arg in args:
        result += arg
    return result

numbers = (1, 2, 3, 4, 5)
print(sum(numbers))

Nesse caso, a tupla numbers é passada como um único elemento para *args, resultando em um erro:

TypeError: unsupported operand type(s) for +=: 'int' and 'tuple'

Para que os elementos da tupla sejam passados individualmente, é necessário fazer o desempacotamento:

def sum(*args):
    result = 0
    for arg in args:
        result += arg
    return result

numbers = (1, 2, 3, 4, 5)
# aplicando desempacotamento - *numbers
print(sum(*numbers))     # 15

Aqui, *numbers desempacota a tupla, passando seus elementos como argumentos individuais para a função.

Outro exemplo de desempacotamento é quando uma função recebe múltiplos parâmetros, mas queremos passar um único objeto iterável:

def print_person(name, age, company):
    print(f"Name: {name}, Age: {age}, Company: {company}")

person = ("Tom", 38, "Google")
# desempacotando a tupla person
print_person(*person)   # Name: Tom, Age: 38, Company: Google

Nesse caso, *person divide a tupla em valores individuais que são passados para os parâmetros name, age e company.

Operador ** e Desempacotamento

O operador ** é usado para desempacotar dicionários:

def print_person(name, age, company):
    print(f"Name: {name}, Age: {age}, Company: {company}")

tom = {"name": "Tom", "age": 38, "company": "Google"}
# desempacotando o dicionário tom
print_person(**tom) # Name: Tom, Age: 38, Company: Google

Aqui, **tom desempacota o dicionário em valores individuais, passando-os para os parâmetros name, age e company com base nas chaves do dicionário.

Combinação de Parâmetros

Os parâmetros *args e **kwargs podem ser usados em conjunto com outros parâmetros em funções. Por exemplo:

def sum(num1, num2, *nums):
    result = num1 + num2
    for n in nums:
        result += n
    return result

print(sum(1, 2, 3))       # 6
print(sum(1, 2, 3, 4))    # 10

Documentação oficial

• Desempacotando listas de argumentos