Functions

Without a function — the same formula copied three times:

price1 = 100 * 1.19    # 119.0
price2 = 250 * 1.19    # 297.5
price3 = 49.90 * 1.19  # 59.381

With a function — the formula exists only once:

def gross(net):
    return net * 1.19

price1 = gross(100)    # 119.0
price2 = gross(250)    # 297.5
price3 = gross(49.90)  # 59.381

If the tax rate changes from 19% to 16%, you update one single line instead of searching through the entire program.

message = "I am global"

def show_message():
    message = "I am local"
    print(message)      # "I am local"

show_message()
print(message)          # "I am global"

Inside the function, a separate variable message exists that shadows the global one. The global variable remains unchanged — this is exactly the intended behavior. Scope keeps functions independent from each other.

def calculate():
    x = 42

calculate()
print(x)    # NameError: name 'x' is not defined

The variable x exists only inside the function calculate(). After the call, it is gone — like a hotel room after checkout.

Parameters can have default values. If no argument is passed during the call, the default is used:

def greet(name="World"):
    return f"Hello, {name}!"

print(greet())         # "Hello, World!"
print(greet("Ada"))    # "Hello, Ada!"

With keyword arguments you can address parameters by name: greet(name="Ada"). With multiple parameters, this makes the code more readable because the order no longer matters.

Caution: never use an empty list as a default value (def f(items=[])). Python creates the default only once — the list accumulates entries across multiple calls. Use items=None instead and create the list inside the function body.

The true power of functions shows when one function's return value becomes the input for the next — a pipeline of small, specialized building blocks:

def load(file):
    return open(file).read()

def clean(text):
    return text.strip().lower()

def count(text):
    return len(text.split())

# Pipeline: load -> clean -> count
content = load("data.txt")
cleaned = clean(content)
word_count = count(cleaned)
print(f"{word_count} words")

In later articles, you will see this pattern in data processing and machine learning workflows.