AiTechWorlds

Chapter 4: Functions Write Once, Use Forever

Parameters, Arguments, and Return Values

University learning companion

Start with a real-world problem

Introduction to Programming · Parameters, Arguments, and Return Values

Case study: taking the concept into a real project

A small product team needs to apply “Parameters, Arguments, and Return Values” to a feature that real people depend on. Define the problem, state the assumptions, work through one concrete example, and decide how the team would test the result and recognise failure.

Visual map: where this topic fits

Use this course-level map to place “Parameters, Arguments, and Return Values” in the larger system. It complements—not replaces—a topic-specific worked diagram.

Parameters, Arguments, and Return Values

Think about a vending machine. You walk up, press B7 (that's your argument what you're asking for), the machine does its internal work, and then it gives you a bag of chips (that's the return value what you get back). The slot labeled B7 is the parameter the slot defined to receive your input.

Every time you call a function, this same exchange happens: you give something in, the function processes it, and something comes back out.

Parameters vs Arguments The Exact Difference

These two words confuse almost every programmer at first. Here's the clean distinction:

Parameter = the variable name in the function definition
Argument = the actual value you pass when calling the function

python

# "celsius" is the PARAMETER — it's in the definition
def celsius_to_fahrenheit(celsius):
    return (celsius * 9/5) + 32

# 100 is the ARGUMENT — it's in the function call
result = celsius_to_fahrenheit(100)

The parameter celsius is a placeholder. When you call the function with 100, the value 100 fills the placeholder. Think of the parameter as an empty box with a label the argument is what you put in the box.

Multiple Parameters

Functions can accept multiple pieces of information:

python

def greet(first_name, last_name, title):
    print(f"Good morning, {title} {last_name}!")
    print(f"Welcome, {first_name}.")

greet("Alice", "Johnson", "Dr.")

Output:

code

Good morning, Dr. Johnson!
Welcome, Alice.

The order matters. Python matches arguments to parameters by position:

first_name gets "Alice"
last_name gets "Johnson"
title gets "Dr."

The `return` Statement

So far we've seen functions that print things. But printing isn't the same as returning. The difference is huge:

python

# This function PRINTS — the result disappears after display
def add_printing(a, b):
    print(a + b)

# This function RETURNS — the result can be stored and used later
def add_returning(a, b):
    return a + b

Why does this matter?

python

# Can I use the result of add_printing?
result1 = add_printing(5, 3)   # Prints 8, but result1 is None
print(result1 * 2)              # Error or prints "None2"

# Can I use the result of add_returning?
result2 = add_returning(5, 3)  # result2 = 8
print(result2 * 2)              # Prints 16

When a function returns a value, that value travels back to wherever the function was called. You can store it, use it in calculations, pass it to another function, or display it.

A function without a return statement implicitly returns None Python's way of saying "nothing."

Default Parameter Values

Sometimes you want a function to work even when the caller doesn't provide every argument. Default values handle this:

python

def send_email(to, subject, body, urgent=False, signature="Best regards"):
    print(f"To: {to}")
    print(f"Subject: {'URGENT: ' if urgent else ''}{subject}")
    print(f"Body: {body}")
    print(f"{signature}")
    print()

# Using defaults
send_email("alice@example.com", "Meeting tomorrow", "See you at 10am")

# Overriding one default
send_email("boss@company.com", "Server down", "Production is offline", urgent=True)

Output:

code

To: alice@example.com
Subject: Meeting tomorrow
Body: See you at 10am
Best regards

To: boss@company.com
Subject: URGENT: Server down
Body: Production is offline
Best regards

Rule: Default parameters must come after non default parameters in the function definition.

Keyword Arguments

Instead of relying on position, you can name your arguments:

python

def order_coffee(size, milk, sugar=0, temperature="hot"):
    print(f"Order: {size} {temperature} coffee, {milk} milk, {sugar} sugars")

# Positional — order matters
order_coffee("large", "oat")

# Keyword — order doesn't matter
order_coffee(sugar=2, size="medium", milk="whole", temperature="iced")

Output:

code

Order: large hot coffee, oat milk, 0 sugars
Order: medium iced coffee, whole milk, 2 sugars

Keyword arguments make code much more readable, especially when a function has many parameters.

Returning Multiple Values

Python has a unique ability: functions can return multiple values at once (as a tuple):

python

def get_min_max_avg(numbers):
    minimum = min(numbers)
    maximum = max(numbers)
    average = sum(numbers) / len(numbers)
    return minimum, maximum, average   # Returns a tuple of 3 values

scores = [78, 92, 65, 88, 95, 71]
low, high, avg = get_min_max_avg(scores)  # Unpack directly

print(f"Lowest: {low}")
print(f"Highest: {high}")
print(f"Average: {avg:.1f}")

Output:

code

Lowest: 65
Highest: 95
Average: 81.5

This is called tuple unpacking Python automatically matches each variable on the left to each return value on the right.

Real Project: Payroll Calculator

Let's build something realistic. A company has workers earning an hourly rate. Standard hours are 40/week. Overtime is paid at 1.5× the regular rate.

python

def calculate_pay(name, hours_worked, hourly_rate, overtime_threshold=40):
    """
    Calculate total pay including overtime.
    Returns: (regular_pay, overtime_pay, total_pay, overtime_hours)
    """
    if hours_worked <= overtime_threshold:
        regular_pay = hours_worked * hourly_rate
        overtime_pay = 0
        overtime_hours = 0
    else:
        regular_pay = overtime_threshold * hourly_rate
        overtime_hours = hours_worked - overtime_threshold
        overtime_pay = overtime_hours * hourly_rate * 1.5

    total_pay = regular_pay + overtime_pay
    return regular_pay, overtime_pay, total_pay, overtime_hours


def print_payslip(name, hours_worked, hourly_rate):
    regular, overtime, total, ot_hours = calculate_pay(name, hours_worked, hourly_rate)

    print(f"\n{'='*40}")
    print(f"  PAYSLIP: {name}")
    print(f"{'='*40}")
    print(f"  Hours worked:     {hours_worked} hrs")
    print(f"  Hourly rate:      ${hourly_rate:.2f}/hr")
    print(f"  Regular pay:      ${regular:.2f}")
    if ot_hours > 0:
        print(f"  Overtime ({ot_hours} hrs): ${overtime:.2f}")
    print(f"  {'─'*32}")
    print(f"  TOTAL PAY:        ${total:.2f}")
    print(f"{'='*40}")


# Process multiple employees
employees = [
    ("Alice Chen", 40, 25.00),
    ("Bob Martinez", 47, 22.50),
    ("Carol Davis", 35, 30.00),
]

for name, hours, rate in employees:
    print_payslip(name, hours, rate)

Output:

code

========================================
  PAYSLIP: Alice Chen
========================================
  Hours worked:     40 hrs
  Hourly rate:      $25.00/hr
  Regular pay:      $1000.00
  ────────────────────────────────
  TOTAL PAY:        $1000.00
========================================

========================================
  PAYSLIP: Bob Martinez
========================================
  Hours worked:     47 hrs
  Hourly rate:      $22.50/hr
  Regular pay:      $900.00
  Overtime (7 hrs): $236.25
  ────────────────────────────────
  TOTAL PAY:        $1136.25
========================================

========================================
  PAYSLIP: Carol Davis
========================================
  Hours worked:     35 hrs
  Hourly rate:      $30.00/hr
  Regular pay:      $1050.00
  ────────────────────────────────
  TOTAL PAY:        $1050.00
========================================

Notice how calculate_pay is a pure function it takes data in, returns data out, never prints anything. print_payslip handles the display. This separation makes code easier to test and modify.

Key Takeaways

Concept	What It Means
Parameter	Variable in the function definition
Argument	Actual value passed when calling
Default value	Used when argument not provided
Keyword argument	Named argument in function call
return	Sends value back to the caller
Multiple returns	Return tuple, unpack at call site

The return value is what makes functions truly powerful. Instead of just printing and forgetting, functions can produce results that build on each other the output of one becomes the input of another, creating complex behavior from simple pieces.

University learning companion

Apply, test and verify

Introduction to Programming · Parameters, Arguments, and Return Values

Guided lab and self-check

Complete the steps without looking at the answer first; record evidence rather than only a final result.

Implement or demonstrate “Parameters, Arguments, and Return Values” in the smallest useful example, then write down the expected result before running it.
Test a normal input, an empty or boundary input, and an invalid input. Compare expected and actual behaviour.
Explain the main assumption, one likely failure mode, and how you would verify the concept in a real project.

Reflection: Which assumption matters most in “Parameters, Arguments, and Return Values”, what edge case could break it, and what evidence would convince you the solution is correct?

Authoritative sources and further reading

These are primary or established learning references for this subject. Check the relevant chapter or specification for the exact topic and version.

💬 DiscussionPowered by GitHub Discussions

📱

Get this course's notes on Telegram!

Free cheat sheets, summaries & practice exercises

Get Notes Free →

Parameters, Arguments, and Return Values

Start with a real-world problem

Case study: taking the concept into a real project

Visual map: where this topic fits

Parameters, Arguments, and Return Values

Parameters vs Arguments The Exact Difference

Multiple Parameters

The return Statement

Default Parameter Values

Keyword Arguments

Returning Multiple Values

Real Project: Payroll Calculator

Key Takeaways

Apply, test and verify

Guided lab and self-check

Authoritative sources and further reading

💬 DiscussionPowered by GitHub Discussions

Parameters, Arguments, and Return Values

Start with a real-world problem

Case study: taking the concept into a real project

Visual map: where this topic fits

Parameters, Arguments, and Return Values

Parameters vs Arguments The Exact Difference

Multiple Parameters

The return Statement

Default Parameter Values

Keyword Arguments

Returning Multiple Values

Real Project: Payroll Calculator

Key Takeaways

Apply, test and verify

Guided lab and self-check

Authoritative sources and further reading

💬 DiscussionPowered by GitHub Discussions

The `return` Statement

The `return` Statement