Summary  
This chapter covers how to define functions with parameters and pass arguments—ranging from individual values to collection objects like lists—so the function can operate on those inputs and printing the outcomes.

General domain of usage  
numeric calculations

En Python, los **argumentos de función** son las **entradas** que proporcionas a una función al llamarla. Permiten que la función utilice datos o valores específicos. Los argumentos pueden ser valores individuales u objetos como listas, tuplas, diccionarios u objetos personalizados.

Por ejemplo, la función `print()` recibe una cadena como argumento.

Si deseas crear una función que calcule e imprima la suma de dos números, debes **pasar ambos números a la función** dentro de paréntesis `()`.


# Specify two arguments of the function
def sum_of_two_numbers(num_1, num_2):
	# Use arguments to calculate sum
	result = num_1 + num_2
    # Print the result
	print(f'Sum of two numbers is {result}')
 
# Call the function 
sum_of_two_numbers(2, 10)

Has pasado **`num_1`** y **`num_2`** como argumentos a la función y los has utilizado para calcular su **suma**. Puedes definir cualquier cantidad de argumentos de función.

Ahora, considera un ejemplo donde una **lista** se utiliza como argumento para una función:


# Define the function `calculate_list_sum`
def calculate_list_sum(list):
    # Initialize the total sum to 0
    total = 0
    # Iterate through each number in the list
    for num in list:
        # Add the current number to the total sum
        total += num
    # Print the total sum
    print(total)

# Create a list of numbers
my_list = [1, 2, 3, 4, 5]
# Call the function 
calculate_list_sum(my_list)

Este código define una **función** `calculate_list_sum` que recibe una **lista** de números, **calcula su suma** agregando cada número a la variable `total` y muestra el resultado. La función se llama con la lista `my_list`, que contiene los números `[1, 2, 3, 4, 5]`, y **muestra la suma**, que es `15`.

import unittest
import user_code
import re
import io
from contextlib import redirect_stdout

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 TestUserCode(unittest.TestCase):
   
    def test_calculate_triangle_perimeter_output(self):
        """Checks that `calculate_triangle_perimeter` outputs the correct text"""
        import user_code
    
        expected_output = "The perimeter is 10"
    
        try:
            f = io.StringIO()
            with redirect_stdout(f):
                user_code.calculate_triangle_perimeter(2, 3, 5)
            output = f.getvalue().strip()
    
            condition = output == expected_output
            failure_message = f"Wrong output for input {2, 3, 5}, expected `{expected_output}` but got `{output}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_triangle_perimeter` is not defined."
    
        _dynamic_test(self, condition, "The function functions correctly for input {2, 3, 5}.", failure_message)

    def test_calculate_triangle_perimeter_different_values(self):
        """Checks that `calculate_triangle_perimeter` outputs the correct text"""
        import user_code
    
        expected_output = "The perimeter is 20"
    
        try:
            f = io.StringIO()
            with redirect_stdout(f):
                user_code.calculate_triangle_perimeter(4, 7, 9)
            output = f.getvalue().strip()
    
            condition = output == expected_output
            failure_message = f"Wrong output for input {4, 7, 9}, expected `{expected_output}` but got `{output}`."
        except AttributeError:
            condition = False
            failure_message = "The function `calculate_triangle_perimeter` is not defined."
    
        _dynamic_test(self, condition, "The function functions correctly for input {4, 7, 9}.", 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

Solución