How to Create Reusable Blocks of Code in Python: Absolute Beginners Tutorial

Functions are the primary tool Python gives you for writing code once and using it many times. Once you understand them, you stop copying and pasting logic and start building programs that are clean, predictable, and easy to change.

Every program you write will eventually repeat the same logic in more than one place. When that happens, you have two choices: copy the code wherever you need it, or wrap it in a function and call it by name. The second option is the right one. This tutorial walks through every piece of a Python function from scratch — the syntax, the mechanics, and the thinking behind them — with examples and exercises at every step.

What Is a Function and Why Does It Matter?

A function is a named, self-contained block of code that performs a specific task. You write the block once, give it a name, and then run it by writing that name followed by parentheses anywhere in your program. Every time you call the function, Python executes the block and gives control back to whatever line called it.

The practical benefit is that your code says what it does rather than showing every mechanical step. A line that reads calculate_tax(price) tells you immediately what is happening. Thirty lines of arithmetic that achieve the same result without a function name tell you nothing at a glance.

There are three concrete reasons to use functions. First, they eliminate repetition. When the same logic lives in one function, any fix or change only needs to happen once. Second, they give code a testable unit. You can verify that a single function produces the right output before placing it into a larger program. Third, they make programs readable. Good function names act as documentation, explaining intent without requiring the reader to trace every line.

Before writing one, it helps to see what a program looks like without functions versus with them. The following example calculates a discounted price twice without a function.

# Without a function — logic is repeated
price_one = 100
discount_one = 0.2
final_one = price_one - (price_one * discount_one)
print(final_one)  # 80.0

price_two = 250
discount_two = 0.1
final_two = price_two - (price_two * discount_two)
print(final_two)  # 225.0

The same calculation appears twice. If you later need to change how the discount is applied, you must find and edit both locations. With a function, the logic lives in one place.

# With a function — logic is defined once
def apply_discount(price, discount):
    return price - (price * discount)

print(apply_discount(100, 0.2))   # 80.0
print(apply_discount(250, 0.1))   # 225.0

Defining Your First Function with def

Every Python function starts with the def keyword. The full syntax for the simplest possible function looks like this:

def say_hello():
    print("Hello from my first function!")

# Call the function
say_hello()
# Output: Hello from my first function!

Breaking down each part: def signals the start of a function definition. say_hello is the name — choose something that describes what the function does. The empty parentheses mean this function accepts no input. The colon ends the definition line. The indented line below is the function body — everything indented to the same level belongs to this function.

Notice that defining the function does not run it. The code inside only executes when you call the function by name with parentheses. This is important: Python reads the definition when it first encounters the def block, but waits for you to call it.

Docstrings: built-in documentation

The first statement inside a function body can be a string literal called a docstring. Python stores it as the function's documentation and tools like help() can display it. It is not required, but writing one is a strong habit to develop from the start.

def say_hello():
    """Print a greeting to the terminal."""
    print("Hello from my first function!")

# Access the docstring
print(say_hello.__doc__)
# Output: Print a greeting to the terminal.

Parameters, Arguments, and Return Values

A function that does the same thing every time it runs has limited use. Parameters let you pass data into a function so it can work with different values each time it is called.

Defining and using parameters

A parameter is a variable name listed inside the function's parentheses. When you call the function and pass a value, that value is called an argument. Inside the function, the parameter behaves exactly like a regular variable.

def greet(name):
    """Print a personalised greeting."""
    print("Hello,", name)

greet("Alice")   # Output: Hello, Alice
greet("Bob")     # Output: Hello, Bob

You can define as many parameters as needed, separated by commas. Each becomes its own local variable inside the function.

def describe_pet(name, animal_type):
    """Print a description of a pet."""
    print(f"{name} is a {animal_type}.")

describe_pet("Milo", "cat")   # Output: Milo is a cat.
describe_pet("Rex", "dog")    # Output: Rex is a dog.

Default parameter values

You can assign a default value to a parameter. If the caller does not supply that argument, the default is used. Parameters with defaults must come after parameters without defaults.

def greet(name, greeting="Hello"):
    """Print a greeting with an optional custom greeting word."""
    print(f"{greeting}, {name}!")

greet("Alice")                  # Output: Hello, Alice!
greet("Bob", "Good morning")    # Output: Good morning, Bob!

Returning a value

Many functions compute a result that the rest of your program needs to use. The return statement sends that result back to the caller. Once Python reaches a return statement, the function stops and the value travels back to wherever the function was called from.

def add(a, b):
    """Return the sum of two numbers."""
    return a + b

result = add(3, 7)
print(result)   # Output: 10

# The returned value can be used directly in expressions
print(add(10, 5) * 2)   # Output: 30

Understanding variable scope

Variables created inside a function are local — they only exist within that function's execution. When the function finishes, those variables are discarded. Variables created outside any function are global and readable from anywhere in the program, but modifying them from inside a function requires the global keyword, which should be used sparingly.

def calculate():
    result = 42   # local variable — only lives inside this function
    return result

calculate()

# This would raise a NameError — result does not exist outside
# print(result)   # NameError: name 'result' is not defined

# Global variable example
message = "I am global"

def show_message():
    print(message)   # can read a global variable

show_message()   # Output: I am global

"A function should do one thing, and do it well." — Unix Design Philosophy

Python Learning Summary Points

1. A Python function is defined with the def keyword, a name, parentheses, and a colon. The indented block below is the function body and only runs when the function is called.
2. Parameters are variables listed in the function definition that receive values when the function is called. Providing a default value makes a parameter optional. The return statement sends a result back to the caller — without it, the function returns None.
3. Variables created inside a function are local and disappear when the function finishes. Writing functions that accept inputs through parameters and deliver outputs through return values — rather than reading and writing global variables — keeps programs predictable and easy to test.

Functions are the first major building block that separates code you type once from code that works everywhere. With parameters and return values, a single function can handle an entire category of problems rather than just one specific case. Practice by taking any repeated block in your own scripts and wrapping it in a function — the habit will pay dividends across every program you write from here on.