Python Functions: Stop Copying and Pasting

Python Functions: Stop Copying and Pasting

A function is a named block of code you can run whenever you need it. You write the steps once, give them a name, and call that name instead of repeating the steps. If you have copied the same five lines into three places, you need a function.

Why this matters

Copy-paste code has one big problem: when the rule changes, you have to find and fix every copy. You will miss one. I can almost guarantee it. With a function, you fix it once. Functions also make code readable, because a good name like calculate_total() tells you what a block does without reading it.

Defining and calling a function

def greet():
    print("Hello, welcome to the course.")

greet()
greet()

def defines the function. Nothing runs until you call it with greet(). The parentheses are required. greet without them just refers to the function and does nothing.

Parameters: giving a function input

def greet(name):
    print(f"Hello, {name}!")

greet("Ana")
greet("Ben")

name is a parameter: a placeholder that gets a real value each time the function is called.

return: getting a result back

This is the part beginners get wrong most. print() shows something on screen. return hands a value back to the code that called the function, so you can store it and use it.

def add_tax(amount, rate):
    return amount * (1 + rate)

price = add_tax(1000, 0.12)
print(price)                  # 1120.0
print(add_tax(500, 0.12) + 50)  # 610.0

Compare it with a function that only prints:

def add_tax_print(amount, rate):
    print(amount * (1 + rate))

result = add_tax_print(1000, 0.12)   # prints 1120.0
print(result)                        # None

The second one shows the number but gives nothing back, so result is None. If you need the value later, the function must return it. A good rule: functions that calculate should return. Let the caller decide whether to print.

Default values

def add_tax(amount, rate=0.12):
    return round(amount * (1 + rate), 2)

print(add_tax(1000))         # uses 0.12 -> 1120.0
print(add_tax(1000, 0.05))   # overrides it -> 1050.0

The 12% here is only an example rate for the exercise. In real code, put rates and limits like this in one clearly named place, because rules change and you want one place to change them.

A real-world example: replacing copy-paste

Before, with the same discount logic pasted twice:

order_a = 1500
if order_a >= 1000:
    order_a = order_a * 0.9
order_b = 800
if order_b >= 1000:
    order_b = order_b * 0.9
print(order_a, order_b)

After:

def apply_discount(subtotal, minimum=1000, percent=10):
    """Return the subtotal after the discount, if it qualifies."""
    if subtotal >= minimum:
        return subtotal * (100 - percent) / 100
    return subtotal

print(apply_discount(1500))   # 1350.0
print(apply_discount(800))    # 800

Same result. But now the discount rule lives in one place, has a name, and the text in triple quotes (a docstring) says what it does. When the minimum changes to 1,200, you change one number.

Variables inside functions stay inside

def make_total():
    total = 500
    return total

make_total()
try:
    print(total)
except NameError as error:
    print("Error:", error)

A variable created inside a function only exists inside it. That is a feature. It means functions do not accidentally overwrite each other's variables. If you need the value outside, return it.

Common mistakes

• Printing instead of returning. Then the caller gets None.
• Calling before defining. Python reads top to bottom. The def must run before the call.
• Forgetting the parentheses. greet is not greet().
• Functions that do everything. If you cannot name it without the word "and", it probably should be two functions.

What happens if you skip this step

Your scripts grow by copy and paste. They work. Then a rule changes, you update four of the five copies, and the fifth one keeps applying the old rule for months. Nobody notices until somebody does the math by hand. Functions do not make you a better programmer by themselves. They just make that particular mistake much harder to make.

Quick check: what does a function return if it has no return statement?