Summary  
This chapter explains how to return multiple values from a function in Python either by packing them into a list or tuple or by returning them as comma-separated values, and shows how to unpack or iterate over those returned values.  

General domain of usage  
Data processing

A veces es necesario devolver **múltiples objetos** desde una función. Esto se puede lograr de dos maneras:

## Uso de una lista o tupla

Cree una lista o tupla que contenga todos los objetos requeridos dentro de la función y devuélvala como resultado de la función.


# Define a function
def return_multiple_objects():
    obj1 = 'Hello'
    obj2 = 42
    obj3 = [1, 2, 3]
	# Return all objects packed into list
    return [obj1, obj2, obj3]
  
# Get the list with corresponding objects
result_list = return_multiple_objects()
for obj in result_list:
	print(obj)

Se crearon tres objetos diferentes dentro de la función y se devolvió una lista que los contiene como salida de la función. Luego, se recorrió esta lista para acceder a cada objeto.


## Uso de valores de retorno múltiples
Puede devolver directamente varios valores separados por comas. Cuando se llama a la función, los resultados se capturan en variables separadas.

def return_multiple_objects():
    obj1 = "Hello"
    obj2 = 42
    obj3 = [1, 2, 3]
	# Return objects separated by comma
    return obj1, obj2, obj3

# Get the result of the function into three different values
result1, result2, result3 = return_multiple_objects()
print(result1, result2, result3)

En el código anterior, se devolvieron tres variables por separado. Al utilizar este enfoque, es importante conocer el orden en que se devuelven las variables para utilizarlas correctamente en el código.


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 TestValidateRegistration(unittest.TestCase):
    def test_valid_input(self):
        """Checks that valid input passes validation."""
        import user_code
        try:
            result = user_code.validate_registration("JohnDoe", "john@example.com", "securePass")
            expected_output = (True, [])
            condition = result == expected_output
            failure_message = f"For input `('JohnDoe', 'john@example.com', 'securePass')`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `validate_registration` is not defined."
        _dynamic_test(self, condition, "The function correctly validates valid input.", failure_message)

    def test_short_username(self):
        """Checks that a username shorter than 3 characters returns an error."""
        import user_code
        try:
            result = user_code.validate_registration("jd", "john@example.com", "securePass")
            expected_output = (False, ["Username must be at least 3 characters long."])
            condition = result == expected_output
            failure_message = f"For input `('jd', 'john@example.com', 'securePass')`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `validate_registration` is not defined."
        _dynamic_test(self, condition, "The function correctly detects short usernames.", failure_message)

    def test_invalid_email(self):
        """Checks that an email without '@' returns an error."""
        import user_code
        try:
            result = user_code.validate_registration("JohnDoe", "johnexample.com", "securePass")
            expected_output = (False, ["Invalid email format."])
            condition = result == expected_output
            failure_message = f"For input `('JohnDoe', 'johnexample.com', 'securePass')`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `validate_registration` is not defined."
        _dynamic_test(self, condition, "The function correctly detects invalid email format.", failure_message)

    def test_short_password(self):
        """Checks that a password shorter than 6 characters returns an error."""
        import user_code
        try:
            result = user_code.validate_registration("JohnDoe", "john@example.com", "12345")
            expected_output = (False, ["Password must be at least 6 characters long."])
            condition = result == expected_output
            failure_message = f"For input `('JohnDoe', 'john@example.com', '12345')`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `validate_registration` is not defined."
        _dynamic_test(self, condition, "The function correctly detects short passwords.", failure_message)

    def test_multiple_errors(self):
        """Checks that multiple validation errors are returned correctly."""
        import user_code
        try:
            result = user_code.validate_registration("jd", "johnexample.com", "12345")
            expected_output = (False, [
                "Username must be at least 3 characters long.",
                "Invalid email format.",
                "Password must be at least 6 characters long."
            ])
            condition = result == expected_output
            failure_message = f"For input `('jd', 'johnexample.com', '12345')`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `validate_registration` is not defined."
        _dynamic_test(self, condition, "The function correctly handles multiple validation errors.", failure_message)

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


test_main.py

Adquiera una comprensión sólida de cómo las funciones estructuran la programación en Python. Domine la definición y llamada de funciones, el manejo de argumentos, la gestión de valores de retorno y la creación de código flexible y eficiente mediante 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 las funciones sean más dinámicas y organizadas.

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

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

Valores de Retorno Múltiples

Uso de una lista o tupla

Uso de valores de retorno múltiples

Solución