Digital Art Animation OpenToonz Course for Children in Chiba

1. Introduction: Beyond Static Functions

In previous topics, a function was defined as a reusable code segment created to perform a designated task under a clear, descriptive name.

However, useful real-world functions should rarely perform fixed, static operations (such as only calculating 2 + 3). Instead, a versatile function should be capable of operating on any arbitrary values provided to it.

To make functions dynamic and communicative with the rest of your program, Python implements two fundamental mechanisms:

1. Inputs (Parameters & Arguments): Variables and values sent into a function so it has data to process.
2. Outputs (Return Values): The computed result sent back from the function to the calling code.

2. Function Inputs: Parameters vs. Arguments

When you define a function, you place placeholder variables inside the parentheses. These are called parameters. When you later call the function, the actual values you pass into those placeholders are the arguments.

• Function Definition Phase: Defining a function registers the template in memory but does not execute it. At definition time, no screen output or computation is generated.
• Function Calling Phase: You call the function by its name, supplying the values needed to populate its parameters.

3. Function Outputs: The return Keyword

After completing its calculations, a function can send the final outcome back to the caller. This result is known as the return value.

• Capturing the Return Value: When a function finishes evaluating a return statement, the function call itself evaluates to the returned value. You can capture this result by assigning it to a variable using the assignment operator (=).
• Reusability of Results: Unlike a direct print() statement inside a function—which simply displays text on the screen—a return value hands the actual data back to your program so it can be stored, passed to other functions, or printed.

4. Practical Code Walkthroughs

Example 1: The add() Function (Multiple Parameters)

In this example, an addition function accepts two numerical values, calculates their sum, and returns the result:

# 1. Defining the function with two parameters: 'a' and 'b'
def add(a, b):
    return a + b

# 2. Calling the function with arguments (3, 5) and storing the return value
result = add(3, 5)

# 3. Printing the stored result
print(result)

Execution Walkthrough

1. Definition: Defining def add(a, b): produces no output because definition only sets the blueprint.
2. Calling: When add(3, 5) is executed, the values 3 and 5 are bound to parameters a and b.
3. Calculation & Return: The expression a + b evaluates to 8, which is returned by the function.
4. Assignment: The equality operator (=) stores the returned value 8 inside the variable result.

Output:

8

Example 2: The square() Function (Single Parameter)

A function can also accept a single input to compute and return a transformation, such as squaring a number:

# 1. Defining the square function
def square(number):
    return number * number

# 2. Calling the function with 5 as the argument
result = square(5)

# 3. Printing the squared result
print(result)

Execution Walkthrough

1. When the cell defining def square(number): is run, no immediate output appears.
2. When the function is called with square(5), 5 is passed into the number parameter.
3. The function calculates 5 * 5 and returns the resulting value.
4. The return value is stored in result and printed:

Output:

25