TEXTBOOK

Simple Example:

def compute_mean(value1, value2):
    result = (value1 + value2) / 2
    return result

mean = compute_mean(2,4)
print(mean)

Explanation:

• def compute_mean(value1, value2): defines a function named compute_mean with two parameters
• result = (value1 + value2) / 2 is an instruction step which computes the average and stores it in a variable named result
• return result is the final instruction steps which specifies the output value
• compute_mean(2,4) executes the function with specific valuesvalues
• The returned value is stored in variable mean

❌ Approach 1: Repetitive Code

# Living room area
length1 = 5
width1 = 4
area1 = length1 * width1

# Bedroom area
length2 = 3.5
width2 = 3
area2 = length2 * width2

# Kitchen area
length3 = 4
width3 = 3.5
area3 = length3 * width3

print(area1, area2, area3)

Identified Problems:

• The calculation length * width appears three times
• Six variables track three calculations
• Each repetition introduces potential transcription errors
• Modifying the formula requires updating multiple locations
• Code readability deteriorates as repetitions increase

✅ Approach 2: Function-Based Code

def calculate_area(length, width):
    area = length * width
    return area

# Calculate areas using the function
area1 = calculate_area(5, 4)
area2 = calculate_area(3.5, 3)
area3 = calculate_area(4, 3.5)

print(area1, area2, area3)

Advantages:

• ✅ The formula exists in a single location
• ✅ Code length is reduced
• ✅ Transcription errors are eliminated
• ✅ Formula modifications require updating only one location
• ✅ Code intent is immediately clear
• ✅ The function can be reused throughout the program

EXAMPLE 1: Zero parameters, one return value

def get_pi():
    return 3.14159

pi_value = get_pi()
print("π ≈", pi_value)

Note: Even without parameters, parentheses () are mandatory.

EXAMPLE 2: One parameter, one return value

def square(x):
    result = x ** 2
    return result

number = 7
squared = square(number)
print(f"{number}² = {squared}")

Case 3: Multiple parameters, one return value

def calculate_rectangle_area(length, width):
    area = length * width
    return area

room1_area = calculate_rectangle_area(5, 3)
room2_area = calculate_rectangle_area(10, 4)

print("Room 1 area:", room1_area, "square units")
print("Room 2 area:", room2_area, "square units")

Execution:

• calculate_rectangle_area(5, 3) is invoked
• Parameter length receives value 5
• Parameter width receives value 3
• Calculation: 5 * 3 = 15
• Value 15 is returned and stored in room1_area

Case 4: Multiple parameters, multiple return values

def divide_with_remainder(dividend, divisor):
    quotient = dividend // divisor
    remainder = dividend % divisor
    return quotient, remainder

q, r = divide_with_remainder(17, 5)
print(f"17 ÷ 5 = {q} remainder {r}")

Technical note: Multiple return values are implemented as tuples. The statement return quotient, remainder creates tuple (quotient, remainder), which is unpacked upon assignment.

❌ BAD – Using print inside functions:

def calculate_area(length, width):
    area = length * width
    print(area)  # ❌ NEVER do this!
    
result = calculate_area(5, 3)  # Prints "15" but...
print(result)  # Prints "None" - the function gave nothing back!
double = result * 2  # ERROR - can't do math with None!

✅ GOOD – Using return:

def calculate_area(length, width):
    area = length * width
    return area  # ✅ Give the value back
    
result = calculate_area(5, 3)  # Nothing prints yet - value stored
print(result)  # Now we choose when to display: 15
double = result * 2  # Works perfectly: 30

Example: Definition vs. Invocation

# DEFINITION - creates the function
def calculate_double(x):
    return x * 2

# At this point, nothing has been calculated yet

# INVOCATION - executes the function
result = calculate_double(5)
print("Result:", result)

Mathematical Function Composition

def square(x):
    """Calculate x²."""
    return x ** 2

def sum_of_squares(a, b):
    """Calculate a² + b²."""
    return square(a) + square(b)

import math 
def distance_from_origin(x, y):
    """Calculate distance from origin: √(x² + y²)."""
    sum_sq = sum_of_squares(x, y)
    distance = math.sqrt(sum_sq)
    return distance

point_x = 3
point_y = 4
dist = distance_from_origin(point_x, point_y)
print(f"Distance from origin to ({point_x}, {point_y}): {dist}")

Benefits of this approach:

• Each function has a single, clear responsibility
• Functions can be tested independently
• Code reusability is maximized
• Complex calculations are decomposed into comprehensible steps

Integrating Custom and Library Functions

import math

def calculate_distance(x1, y1, x2, y2):
    """Calculate Euclidean distance between two points."""
    dx = x2 - x1
    dy = y2 - y1
    distance = math.sqrt(dx**2 + dy**2)
    return distance

def calculate_circle_area(radius):
    """Calculate circle area using math.pi."""
    return math.pi * radius ** 2

# Test the functions
dist = calculate_distance(0, 0, 3, 4)
print("Distance:", dist)

area = calculate_circle_area(5)
print("Circle area:", round(area, 2))

Observation: Custom functions can utilize library functions to implement complex operations efficiently.

Trace Example 1: Basic Function

Code:

def multiply_and_add(x, y):
    product = x * y
    result = product + 10
    return result

a = 3
b = 4
final = multiply_and_add(a, b)
print(final)

Trace Table:

Key observations:

• Blue rows (steps 4-7): Execution inside function; a and b are out of scope
• White rows: Execution in main program; x, y, product, result are out of scope
• Return value (22) bridges the two scopes