Learn What def is in Python: Absolute Beginners Tutorial

Before you can build anything meaningful in Python, you need to know how to package code so it can be reused. That starts with def — the keyword Python uses to define functions. This tutorial explains exactly what def does, why it exists, and how to write your first function from scratch.

Every time you write a program, you will end up running the same group of instructions more than once. Copying those instructions every time you need them is not just tedious — it creates bugs, because a change in one copy does not update the others. Functions solve this problem. The def keyword is how you tell Python you are about to create one.

What def Actually Means

def is short for define. When Python encounters a def statement, it does not run the code inside immediately. Instead, it reads the instructions, packages them up as a function object, and stores that object in memory under the name you gave it. Nothing executes until you call the function.

This distinction matters. Reading a recipe is not the same as cooking dinner. def writes the recipe. Calling the function cooks it.

Here is the simplest function you can write:

def say_hello():
    print("Hello, world!")

This def statement creates a function named say_hello. The function has no parameters — the parentheses are empty — and its body contains a single print call. After Python reads these two lines, say_hello exists as a function object in memory. It has not printed anything yet.

To actually run it:

say_hello()     # Output: Hello, world!

The parentheses after the name are what trigger execution. Without them, you would be referencing the function object itself, not calling it.

"A function definition is a compound statement that binds a function object to a name." — Python Language Reference

The Anatomy of a Python Function

Every function defined with def has the same structural components. Understanding each one helps you write functions correctly and read other people's code without confusion.

The components break down like this:

Parameters, Arguments, and Return Values

A function that always does the same thing is useful but limited. Parameters make functions flexible by letting callers pass data in. Return values let functions send data back out.

Parameters vs. Arguments

These two words are often used interchangeably, but they mean different things. A parameter is the variable name listed in the def line. An argument is the actual value passed when the function is called.

def add(x, y):          # x and y are parameters
    return x + y

result = add(3, 4)      # 3 and 4 are arguments
print(result)           # Output: 7

When Python executes the add(3, 4) call, it assigns 3 to x and 4 to y inside the function's local scope. Those assignments only exist while the function runs.

The return Statement

A function does not have to return a value. If you write no return statement — or just return with nothing after it — Python returns None automatically. When a function does return a value, the caller receives it and can store it, print it, or use it as input to another function.

# Function with a return value
def square(n):
    return n * n

# Function with no return value
def announce(message):
    print(f"Announcement: {message}")

value = square(5)       # value is 25
announce("Done!")       # Prints the message, returns None

# Step 1 and 2: def line + body
def greet():
    print("Hello!")

# Step 3: adding a parameter
def greet(name):
    print(f"Hello, {name}!")

# Step 4: returning a value
def greet(name):
    return f"Hello, {name}!"

# Step 5: calling the function
message = greet("Alex")
print(message)          # Output: Hello, Alex!

Python Learning Summary Points