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)

Ya conoces los argumentos **posicionales** y **opcionales**. Pero cuando una función puede recibir muchas entradas o no las conoces de antemano, puedes usar **argumentos posicionales arbitrarios**. Permiten que una función acepte cualquier cantidad de valores.

Cada argumento puede ser cualquier estructura de datos (lista, diccionario, etc.). Los argumentos arbitrarios permiten pasar tantos objetos de este tipo como sea necesario.

Nota

Para definir argumentos posicionales arbitrarios, coloca un asterisco `*` antes del nombre del parámetro. Ejemplo:

# 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))

Aquí, `*values` recopila todos los argumentos posicionales pasados en una tupla. Dentro de la función, se utiliza el nombre de la variable **sin** `*`. El resultado es correcto sin importar cuántos argumentos se proporcionen.

Aunque cualquier nombre funciona, la forma común y legible es `*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 se muestra:

* Sin argumentos → `args` es `()`;
* Un argumento → `(1,)`;
* Varios argumentos → todos los valores aparecen en una tupla, por ejemplo, `(1, 2, 3, 'hello', [4, 5, 6])`.

`*args` se comporta como cualquier otra tupla, proporcionando flexibilidad total al manejar múltiples entradas.


Dado que `*args` es simplemente una tupla, se puede aplicar cualquier lógica a sus valores, incluyendo condicionales. Por ejemplo, después de sumar todos los precios, es posible comprobar el total y aplicar diferentes reglas según el 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

Adquirir una comprensión sólida de cómo las funciones estructuran la programación en Python. Dominar la definición y llamada de funciones, el trabajo con argumentos, la gestión de valores de retorno y la creación de código flexible y eficiente utilizando recursión y expresiones lambda.

Explora qué son las funciones y por qué son esenciales en Python. Aprende a crear funciones, definir argumentos, manejar valores de retorno y utilizar funciones integradas de manera efectiva.

Aprende cómo funcionan los argumentos posicionales y opcionales en Python. Crea funciones adaptables que gestionen diferentes entradas y mejoren la flexibilidad en tu código.

Comprender cómo trabajar con argumentos arbitrarios y de palabras clave para manejar tamaños de entrada variables. Aprender cómo estas técnicas hacen que tus funciones sean más dinámicas y organizadas.

Descubre cómo los valores de retorno representan la salida de una función. Aprende a retornar valores únicos o múltiples, utilizar None y explorar generadores para un control de flujo de datos más avanzado.

Descubre conceptos avanzados de funciones con recursión y funciones lambda. Aprende cómo la recursión resuelve problemas repetitivos y cómo las expresiones lambda crean funciones concisas de una sola línea.

Argumentos Posicionales Arbitrarios

Solución