Defining & Calling Functions — I can define and call...

SECTION 1

Historical Context & Motivation

Before functions existed, programmers wrote long, sequential scripts where the same instructions appeared dozens of times throughout the code. If you needed to change one calculation, you had to find and edit every copy — a tedious and error-prone process. As programs grew larger during the mid-twentieth century, this approach became unmanageable, and computer scientists began searching for ways to organize and reuse code more effectively.

1950s

Subroutines Emerge

Early languages like FORTRAN introduced subroutines — named blocks of code that could be executed from different places in a program, reducing repetition.

1968

Structured Programming

Edsger Dijkstra advocated breaking programs into small, well-defined procedures. This structured programming movement made functions a core building block of software design.

1972

C Language Standardizes Functions

Dennis Ritchie's C language made every piece of executable code live inside a function, cementing the idea that programs are collections of small, reusable units.

1991

Python Is Created

Guido van Rossum released Python with a clean, readable def keyword for defining functions, making it one of the easiest languages in which to learn modular programming.

The central question this lesson addresses is straightforward: how do we take a chunk of code, give it a name, and run it whenever we need it? Python's def keyword provides the answer, and understanding it is the first major step toward writing programs that are organized, readable, and easy to maintain.

SECTION 2

Core Principles & Definitions

A function is a named, reusable block of code that performs a specific task. You define a function once using the def keyword, and then you call it as many times as you need. Think of defining a function as writing a recipe card, and calling a function as actually cooking the recipe.

Function Definition

The act of creating a function using def function_name(): followed by an indented body. This does not run the code — it only stores it for later use.

Function Call

Writing the function's name followed by parentheses, like function_name(), tells Python to execute the stored code right now. Without a call, the function never runs.

Parameters & Arguments

Parameters are placeholder variables listed in the definition. Arguments are the actual values you pass in when calling the function.

Return Value

A function can send a result back to the caller using return. If no return statement is used, the function returns None by default.

DRY Principle

Don't Repeat Yourself — whenever you notice the same code appearing in multiple places, wrap it in a function. This makes your program shorter, cleaner, and easier to debug.

✦ KEY TAKEAWAY

Think of a function like a contact saved in your phone. You save a phone number (define the function) once, then whenever you want to call that person, you just tap the contact name (call the function) instead of dialing all ten digits from memory every time. The number stays saved no matter how many times you use it — just like a function stays defined no matter how many times you call it.

SECTION 3

Visual Explanation — Anatomy of a Function

This diagram shows the two main parts: the function definition (top, with the def keyword, function name, parameter, and return statement) and the function call (middle, where an argument is passed in). The bottom flow shows the order of execution when a function is called.

Notice how the definition and the call are separate actions. When Python encounters a def block, it reads and stores the function but does not execute the body. Only when it reaches the function call — greet("Alice") — does it jump into the function, run each line inside the body, and then return to the point where it was called. This separation is what makes functions reusable: define once, call many times.

SECTION 4

How Functions Work Under the Hood

While Python functions don't involve mathematical formulas in the traditional sense, they follow a precise, step-by-step mechanism every time they are called. Understanding this mechanism will help you predict exactly what your code will do.

The Function Execution Lifecycle

Step 1 — Definition: Python reads the def statement and stores the function object in memory under the given name. The body is NOT executed yet.
Step 2 — Call: When Python sees function_name(arguments), it pauses the current line of code and jumps into the function body.
Step 3 — Parameter Binding: Each argument is assigned to the corresponding parameter. For example, if you call greet("Alice"), then name gets the value "Alice".
Step 4 — Body Execution: Python runs every line in the indented body from top to bottom.
Step 5 — Return: When Python hits a return statement (or reaches the end of the body), it sends a value back to the caller and resumes execution at the line that made the call.

Syntax Template

FUNCTION DEFINITION SYNTAX

def function_name(param1, param2, ...): # body — indented code return value

def = keyword that starts the definition · function_name = a descriptive name you choose · param1, param2 = parameters (inputs) the function expects · return = sends a value back to the caller

FUNCTION CALL SYNTAX

variable = function_name(arg1, arg2, ...)

function_name() = triggers execution of the stored function · arg1, arg2 = actual values passed to the parameters · The returned value is stored in variable

⚠️ Common Mistake

Forgetting to call a function is one of the most frequent beginner errors. Writing def greet(name): only defines the function — you must also write greet("Alice") somewhere later in your code to actually run it. Similarly, forgetting the parentheses — writing greet instead of greet() — refers to the function object rather than executing it.

SECTION 5

Why Functions Improve Organization & Reuse

Functions are not just a convenience — they fundamentally change the way you think about building programs. There are several concrete reasons why professional developers rely on functions constantly, and understanding these reasons will make you a stronger programmer right from the start.

The left side shows repeated code blocks for three users — if you need to change the welcome message, you must edit it in three different places. The right side uses a single function that is called three times. Changes only need to happen in one place, making the code organized, reusable, easy to debug, and readable.

Five key benefits of using functions

Benefit	What It Means	Real-World Analogy
Reuse	Write code once, call it many times without copying and pasting.	A recipe you follow every Thanksgiving instead of re-inventing the dish each year.
Organization	Group related code into named units so your program reads like an outline.	Organizing your closet into labeled bins instead of throwing everything in a pile.
Easier Debugging	If something breaks, you only need to fix it in the one function — not in every copy.	Fixing a typo in one shared Google Doc instead of emailing corrections to 20 copies.
Readability	A well-named function like `calculate_grade()` tells readers what the code does without reading every line.	Chapter titles in a book let you find information quickly.
Abstraction	The caller doesn't need to know how the function works — only what it does.	You don't need to understand engine mechanics to drive a car — you just turn the key.

SECTION 6

Worked Example — Building a Tip Calculator Function

Let's walk through creating a function that calculates the tip on a restaurant bill. We will define the function, call it with different values, and trace exactly what Python does at each step.

Tip Calculator Function

Step 1 — Identify the taskWe want to compute a tip based on a bill amount and a tip percentage. The inputs (parameters) will be bill and tip_percent. The output (return value) will be the dollar amount of the tip.

Step 2 — Write the function definitionWe use def followed by a descriptive name, parameters in parentheses, and a colon. The body is indented.

def calculate_tip(bill, tip_percent):
    tip = bill * (tip_percent / 100)
    return tip

Step 3 — Call the function with argumentsWe call calculate_tip with a $50.00 bill and a 20% tip rate.

my_tip = calculate_tip(50.00, 20)

Step 4 — Trace the executionPython binds bill = 50.00 and tip_percent = 20. Inside the body: tip = 50.00 × (20 / 100) = 50.00 × 0.2 = 10.0. Python returns 10.0, which is stored in my_tip.

my_tip = 10.0

Step 5 — Reuse with different argumentsThe same function works for any bill and any tip rate. We can call it again immediately:

another_tip = calculate_tip(85.50, 15) # returns 12.825

💡 Try It Yourself

Open a Python interpreter or an online editor like replit.com. Type in the calculate_tip function, call it with your own values, and use print() to see the result. Experimenting with real code is the fastest way to internalize these concepts.

SECTION 7

Comparing Functions to Inline Code

You might wonder: when should I use a function versus just writing the code directly? The short answer is that any piece of logic you use more than once, or any block that performs a distinct task, is a good candidate for a function. However, there are trade-offs to consider.

When to use inline code vs. a function

Criteria	Inline Code	Using a Function
Code length	Can be shorter for a one-time task	Slightly more lines for the definition, but fewer total lines when reused
Readability	Details are visible right where they are used	Main code reads like a high-level outline; details are tucked away
Maintenance	Every copy must be updated individually	One fix in the function fixes every call
Testing	Hard to test a chunk embedded in a larger script	Easy to test in isolation by calling with known inputs
Best used when…	The logic runs exactly once and is very short (1–2 lines)	The logic is reused, complex, or benefits from a descriptive name

✦ KEY TAKEAWAY

Think of functions like apps on your phone. You could manually type a web address, search for a store, and calculate directions every time you need to go somewhere — or you could just tap the Maps app. Functions package complex steps behind a simple name so you can use them with a single "tap" (call) whenever you need them.

SECTION 8

Connection to Advanced Concepts

The functions you have learned to write in this lesson are the foundation for nearly every advanced programming topic you will encounter. Once you are comfortable with def and return, you are ready to explore more powerful techniques.

How today's lesson connects to future topics

This Lesson	What Comes Next
Functions with simple parameters	Default parameters & keyword arguments — let callers skip arguments that have sensible defaults
Functions that return a single value	Returning multiple values — using tuples to send back more than one result
Functions defined in one file	Modules & imports — storing functions in separate files and importing them into other programs
Standalone functions	Methods in classes (OOP) — functions that belong to objects, enabling object-oriented design
A function calling other code	Recursion — a function calling itself to solve problems that have repeating sub-problems

Every one of these advanced topics builds directly on the def / call pattern you practiced today. Mastering the basics now will make each of these future concepts feel like a natural extension rather than a whole new idea.

SECTION 9

Practice Problems

PROBLEM 1 — CONCEPTUAL

Explain, in your own words, the difference between defining a function and calling a function. Why does Python not run the function body the moment it reads the def statement?

PROBLEM 2 — BASIC CALCULATION

Write a function called double that takes one parameter n and returns n * 2. Then show how you would call it with the argument 7 and print the result.

PROBLEM 3 — INTERMEDIATE

Write a function called rectangle_area that accepts two parameters, length and width, and returns the area. Then call the function twice — once for a 5 × 3 rectangle and once for a 12 × 8 rectangle — and print both results.

PROBLEM 4 — APPLIED

You are building a simple grade-book program. Write a function called average that takes three test scores as parameters and returns the average. Then use the function to compute the averages for two students: Student A (90, 85, 92) and Student B (78, 88, 70). Print a message for each student showing their average.

PROBLEM 5 — CRITICAL THINKING

A classmate argues: "Functions just add extra lines of code. I can write everything faster without them." Write a short paragraph (3–5 sentences) refuting this argument. Include at least two specific benefits of functions discussed in this lesson and give a concrete scenario where avoiding functions would cause problems.

SUMMARY

Lesson Summary

A function is a named, reusable block of code created with the def keyword. Defining a function stores the code without executing it; calling the function (by writing its name followed by parentheses) triggers execution. Parameters are placeholders in the definition, while arguments are the actual values passed in during a call. The return statement sends a result back to the caller.

Functions improve your programs in several key ways: reuse (write once, call many times), organization (group related code under descriptive names), easier debugging (fix one function, fix every call), and readability (well-named functions make your code self-documenting). Embracing the DRY principle — Don't Repeat Yourself — by wrapping repeated logic in functions is one of the most important habits you can build as a programmer.