Summary  
This chapter explains how to define functions that accept an arbitrary number of positional arguments using `*args`, automatically collecting them into a tuple for flexible processing.  

General domain of usage  
Mathematical computations (e.g., summing variable sets of values)

Você já conhece argumentos **posicionais** e **opcionais**. Mas quando uma função pode receber muitas entradas ou você não sabe quantas serão antecipadamente, é possível usar **argumentos posicionais arbitrários**. Eles permitem que uma função aceite qualquer quantidade de valores.

Cada argumento pode ser qualquer estrutura de dados (lista, dicionário, etc.). Argumentos arbitrários permitem passar quantos desses objetos forem necessários.

Nota

Para definir argumentos posicionais arbitrários, coloque um asterisco `*` antes do nome do parâmetro. Exemplo:

# Define function with arbitrary positional arguments named values
def calculate_sum(*values):
	return sum(values)

# Test the function using different number of arguments
print(calculate_sum(1, 2, 3))
print(calculate_sum(1, 2, 3, 4))
print(calculate_sum(1, 2, 3, 4, 5))

Aqui, `*values` coleta todos os argumentos posicionais passados em uma tupla. Dentro da função, utiliza-se o nome da variável **sem** o `*`. O resultado está correto independentemente de quantos argumentos forem fornecidos.

Embora qualquer nome funcione, a forma mais comum e legível é `*args`.

def example_function(*args):
    print(type(args))
    print(args)
    for arg in args:
        print(arg)

print("Call without arguments:")
example_function()

print("\nCall with one argument:")
example_function(1)

print("\nCall with multiple arguments:")
example_function(1, 2, 3, 'hello', [4, 5, 6])

Como mostrado:

* Sem argumentos → `args` é `()`;
* Um argumento → `(1,)`;
* Vários argumentos → todos os valores aparecem em uma tupla, por exemplo, `(1, 2, 3, 'hello', [4, 5, 6])`.

`*args` se comporta como qualquer outra tupla, oferecendo total flexibilidade ao lidar com múltiplas entradas.


Como `*args` é apenas uma tupla, é possível aplicar qualquer lógica aos seus valores – incluindo condicionais. Por exemplo, após somar todos os preços, é possível verificar o total e aplicar regras diferentes dependendo do resultado.

import unittest

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestCalculateTotal(unittest.TestCase):
    def test_no_items_in_cart(self):
        """Checks that an empty cart returns the correct message"""
        import user_code
        try:
            result = user_code.calculate_total()
            expected_output = "Your cart is empty."
            condition = result == expected_output
            failure_message = f"For input `()`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_total` is not defined."
        _dynamic_test(self, condition, "The function correctly handles an empty cart.", failure_message)
    
    def test_no_discount(self):
        """Checks that no discount is applied for a total below $100"""
        import user_code
        try:
            result = user_code.calculate_total(20, 20, 50)
            expected_output = "Final total: $90.00"
            condition = result == expected_output
            failure_message = f"For input `(20, 20, 50)`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_total` is not defined."
        _dynamic_test(self, condition, "The function correctly calculates the total without a discount (total below $100).", failure_message)
    
    def test_ten_percent_discount(self):
        """Checks that a 10% discount is applied for a total between 100 and 200"""
        import user_code
        try:
            result = user_code.calculate_total(100, 20, 30)
            expected_output = "Final total: $135.00"
            condition = result == expected_output
            failure_message = f"For input `(100, 20, 30)`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_total` is not defined."
        _dynamic_test(self, condition, "The function correctly applies a 10% discount.", failure_message)
    
    def test_twenty_percent_discount(self):
        """Checks that a 20% discount is applied for a total greater than 200"""
        import user_code
        try:
            result = user_code.calculate_total(150, 100)
            expected_output = "Final total: $200.00"
            condition = result == expected_output
            failure_message = f"For input `(150, 100)`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_total` is not defined."
        _dynamic_test(self, condition, "The function correctly applies a 20% discount.", failure_message)

if __name__ == '__main__':
    unittest.main()

test_main.py

Adquira uma compreensão sólida de como as funções moldam a programação em Python. Domine a definição e chamada de funções, o trabalho com argumentos, o tratamento de valores de retorno e a criação de código flexível e eficiente utilizando recursão e expressões lambda.

Explore o que são funções e por que elas são essenciais em Python. Aprenda a criar funções, definir argumentos, manipular valores de retorno e usar funções embutidas de forma eficaz.

Aprenda como os argumentos posicionais e opcionais funcionam em Python. Desenvolva funções adaptáveis que lidam com diferentes entradas e aumentam a flexibilidade do seu código.

Compreensão de como trabalhar com argumentos arbitrários e argumentos nomeados para lidar com tamanhos de entrada variáveis. Aprendizado de como essas técnicas tornam suas funções mais dinâmicas e organizadas.

Descubra como os valores de retorno representam a saída de uma função. Aprenda a retornar valores únicos ou múltiplos, utilizar None e explorar geradores para um controle de fluxo de dados mais avançado.

Desbloqueie conceitos avançados de funções com recursão e funções lambda. Aprenda como a recursão resolve problemas repetitivos e como as expressões lambda criam funções concisas em uma única linha.

Argumentos Posicionais Arbitrários

Solução