Summary  
This chapter explains how to define Python functions with parameters and pass arguments of various types—such as individual numbers or lists—to perform operations like summation and printing results.  

General domain of usage  
Numerical computations

In Python, **function arguments** are the **inputs** you provide to a function when calling it. They let the function use specific data or values. Arguments can be single values or objects such as lists, tuples, dictionaries, or custom objects.

For instance, the `print()` function takes a string as an argument.

If you want to create a function that calculates and prints the sum of two numbers, you must **pass both numbers to the function** inside parentheses `()`.


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

You have passed **`num_1`** and **`num_2`** as arguments to the function and used them to calculate their **sum**. You can define any number of function arguments.

Now, consider an example where a **list** is used as an argument for a function:


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

This code defines a **function** `calculate_list_sum` that takes a **list** of numbers, **calculates their sum** by adding each number to the `total` variable, and prints the result. The function is called with the list `my_list`, containing the numbers `[1, 2, 3, 4, 5]`, and **outputs the sum**, which is `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

Gain a solid understanding of how functions shape Python programming. Master defining and calling functions, working with arguments, handling return values, and creating flexible, efficient code using recursion and lambda expressions.

Explore what functions are and why they're essential in Python. Learn how to create functions, define arguments, handle return values, and use built-in functions effectively.

Function Arguments in Python

解答