1   Why Do We Need Functions?

Suppose you are writing a quiz program. At the end of each round, you need to calculate a percentage, print a grade, and print a congratulations message. You have three rounds — so that logic appears three times in your program.

Without functions, you copy and paste those lines. Then you notice a bug — a typo in the congratulations message. You fix it in one place. You forget to fix the other two. Now your program has three versions of the same logic, and one of them is wrong.

Functions also give you something harder to measure but equally valuable: the ability to give a chunk of logic a name. A well-named function makes code read almost like English:

# Without functions — what does this code do? You have to read every line.
if score / total * 100 >= 60:
    print("Pass")

# With functions — the intent is obvious immediately.
if calculate_percentage(score, total) >= 60:
    print("Pass")

The function version does not just work — it explains itself.

2   Defining and Calling a Function

There are two distinct steps with every function: defining it (writing it once) and calling it (running it whenever you need it).

2.1   The Anatomy of a Function Definition

def greet():
    print("Hello, welcome to the program!")
    print("Let's get started.")

2.2   Calling a Function

Defining a function does not run it. It just registers the name and the code to run later. To actually execute the function, you call it by writing its name followed by parentheses:

def greet():
    print("Hello, welcome to the program!")
    print("Let's get started.")

# Nothing has printed yet — the function is defined but not called.

greet()    # Now it runs.
greet()    # Call it again — runs a second time.
greet()    # And again.

Output:

Hello, welcome to the program!
Let's get started.
Hello, welcome to the program!
Let's get started.
Hello, welcome to the program!
Let's get started.

The same function body runs every time greet() is called. This is the payoff of writing it once.

3   Parameters and Arguments

The greet() function above always does the same thing. That is useful, but limited. What if you want to greet a specific person by name? You need a way to pass information into a function. That is what parameters are for.

3.1   Parameters vs. Arguments — The Exact Distinction

These two words are often used interchangeably in casual conversation, but they mean different things and it is worth being precise:

Think of it this way: the parameter is the label on the toaster slot; the argument is the actual bread you push in.

3.2   A Function With One Parameter

def greet(name):
    print("Hello,", name + "!")
    print("Welcome to the program.")

greet("Alex")     # "Alex" is the argument
greet("Priya")    # "Priya" is the argument
greet("Sam")      # "Sam" is the argument

Output:

Hello, Alex!
Welcome to the program.
Hello, Priya!
Welcome to the program.
Hello, Sam!
Welcome to the program.

Each call passes a different argument. The parameter name takes on that value inside the function body. Same function, three different results.

3.3   Multiple Parameters

A function can take more than one parameter. Separate them with commas — both in the definition and in the call. Order matters: the first argument goes to the first parameter, the second to the second, and so on.

def describe_student(name, score):
    print(name, "scored", score, "points.")
    if score >= 60:
        print(name, "has passed.")
    else:
        print(name, "has not passed.")

describe_student("Alex", 85)
describe_student("Sam", 42)

Output:

Alex scored 85 points.
Alex has passed.
Sam scored 42 points.
Sam has not passed.

3.4   Default Parameter Values

You can give a parameter a default value — a fallback that is used when the caller does not provide that argument. Default parameters are placed at the end of the parameter list.

def greet(name, greeting="Hello"):
    print(greeting + ",", name + "!")

greet("Alex")                  # uses default greeting
greet("Priya", "Good morning") # overrides the default

Output:

Hello, Alex!
Good morning, Priya!

4   The return Statement

So far, all our functions have printed results. Printing is fine for displaying things to a user — but it is not the same as making a value available to the rest of your program. The return statement does that: it sends a value back to whoever called the function, so the result can be stored in a variable, passed to another function, or used in a calculation.

This is one of the most important distinctions in programming, and one of the most commonly confused. Let's deal with it directly.

4.1   A Function Without return

def add(a, b):
    print(a + b)       # displays the result — but does not return it

result = add(3, 4)     # add() runs and prints 7
print(result)          # prints: None

The function printed 7 to the screen — but when we tried to store the result in a variable, we got None. That is because a function with no return statement automatically returns None (Python's way of saying "nothing"). The value 7 was displayed and then lost.

4.2   The Same Function With return

def add(a, b):
    return a + b       # sends the result back to the caller

result = add(3, 4)     # the returned value (7) is stored in result
print(result)          # prints: 7

# Now we can use the result:
doubled = add(3, 4) * 2
print(doubled)         # prints: 14

The function no longer displays anything — it just does the calculation and hands the result back. The caller decides what to do with it.

4.3   return Ends the Function

The moment Python hits a return statement, the function stops — immediately. Any lines after return are never reached:

def check_pass(score):
    if score >= 60:
        return "Pass"       # function ends here if score >= 60
    return "Fail"           # only reached if score < 60

print(check_pass(85))       # Pass
print(check_pass(40))       # Fail

This is a clean, readable pattern: check the first condition and return early if it matches; otherwise fall through to the next return. You will see this in almost every professional codebase.

4.4   Using return Values in Practice

The real power of return is that it lets functions feed into each other:

def calculate_percentage(score, total):
    return round(score / total * 100, 1)

def get_grade(percentage):
    if percentage >= 90:
        return "A"
    elif percentage >= 80:
        return "B"
    elif percentage >= 70:
        return "C"
    elif percentage >= 60:
        return "D"
    else:
        return "F"

# Using both functions together:
score = 37
total = 50

pct = calculate_percentage(score, total)   # returns 74.0
grade = get_grade(pct)                     # returns "C"

print(f"Score: {score}/{total} ({pct}%) — Grade: {grade}")

Each function does one job. The output of one becomes the input of another. This is how real programs are built — not one enormous block of code, but small, composable functions that do one thing well.

5   Variable Scope

Scope is the set of rules that governs where a variable can be seen and used. This is one of the most important concepts in functions — and one of the most frequent sources of bugs and confusion for beginners. Read this section carefully.

5.1   Local Scope

A variable created inside a function is called a local variable. It exists only while the function is running, and it can only be used inside that function. Once the function returns, the local variable disappears.

def calculate_bonus(salary):
    bonus = salary * 0.1       # bonus is a LOCAL variable
    return bonus

calculate_bonus(50000)
print(bonus)                   # NameError: name 'bonus' is not defined

bonus was created inside calculate_bonus(). Outside the function, it does not exist. Python raises a NameError because from the outside world, bonus was never created.

5.2   Global Scope

A variable created outside all functions is called a global variable. It can be read from anywhere in the file — including inside functions.

TAX_RATE = 0.2              # global variable — readable everywhere

def calculate_tax(price):
    tax = price * TAX_RATE  # reading TAX_RATE from global scope — this is fine
    return tax

print(calculate_tax(100))   # 20.0
print(calculate_tax(250))   # 50.0

Reading a global variable from inside a function is perfectly normal and useful — especially for constants like TAX_RATE or MAX_SCORE that should not change. The convention is to name constants in ALL_CAPS to signal that they are global and fixed.

5.3   The Crucial Rule: Functions Cannot Modify Globals (by default)

Reading a global variable is fine. But trying to change a global variable from inside a function does not work the way you might expect. Python treats any variable you assign inside a function as a new local variable — even if a global with the same name already exists:

score = 0                    # global variable

def add_points(points):
    score = score + points   # Python creates a LOCAL score — does not touch the global!
    print("Inside function, score:", score)

add_points(10)
print("Outside function, score:", score)    # still 0 — unchanged!

score = 0

def add_points(current_score, points):
    return current_score + points     # return the new value

score = add_points(score, 10)         # update the global by reassigning it
print(score)                          # 10 — correct!

5.4   Local Variables in Different Functions Are Separate

Two different functions can both use a variable named result or total — they are completely independent. Each function has its own private scope:

def calculate_area(width, height):
    result = width * height     # this "result" belongs to calculate_area
    return result

def calculate_perimeter(width, height):
    result = 2 * (width + height)  # this "result" is a DIFFERENT variable
    return result

area = calculate_area(4, 6)           # 24
perimeter = calculate_perimeter(4, 6) # 20
print(area, perimeter)

Both functions use a variable called result. They do not interfere with each other at all — each function's result lives in its own private scope.

5.5   A Visual Summary of Scope

6   Putting It All Together

Here is a complete program that uses everything from this article: well-named functions, parameters, return values, and clean scope. Read it carefully — notice how each function does exactly one job, takes its input through parameters, and sends its result back through return.

PASSING_SCORE = 60           # global constant — readable everywhere

def calculate_percentage(score, total):
    """Returns score as a percentage of total, rounded to 1 decimal place."""
    return round(score / total * 100, 1)

def get_grade(percentage):
    """Returns a letter grade for a given percentage."""
    if percentage >= 90:
        return "A"
    elif percentage >= 80:
        return "B"
    elif percentage >= 70:
        return "C"
    elif percentage >= 60:
        return "D"
    else:
        return "F"

def is_passing(percentage):
    """Returns True if the percentage meets the passing threshold."""
    return percentage >= PASSING_SCORE

def print_report(name, score, total):
    """Prints a formatted report card line for one student."""
    pct   = calculate_percentage(score, total)
    grade = get_grade(pct)
    status = "PASS" if is_passing(pct) else "FAIL"
    print(f"  {name:<12} {score}/{total}  ({pct}%)  Grade: {grade}  [{status}]")

# ── Main program ──────────────────────────────────────────────────
students = [
    ("Alice",  43, 50),
    ("Bob",    28, 50),
    ("Carol",  47, 50),
    ("Dan",    31, 50),
]

print("=== End of Term Report ===")
for name, score, total in students:
    print_report(name, score, total)

What to notice:

• Each function has a clear, single purpose — the name describes exactly what it does.
• Every function gets its inputs through parameters and sends results back through return. None of them modify global variables.
• PASSING_SCORE is a global constant — named in ALL_CAPS, read inside is_passing(), never modified.
• print_report() calls three other functions and uses their return values — this is functions feeding into each other.
• The main program loop is clean and short because all the logic lives in the functions.

7   Common Mistakes to Watch For

8   Final Check: The Big Picture

9   Quick-Reference Summary