Writing Functions in Python

March 6, 2026 · 6 min read · Updated March 7, 2026 · beginner

functions def parameters return beginner

Functions are one of the most powerful concepts in programming. They let you wrap a piece of code into a reusable block that you can call whenever you need it. Instead of writing the same logic over and over, you define it once in a function and call that function by name whenever you need it.

In this tutorial, you will learn how to write functions in Python using the def keyword, how to pass data into functions using parameters, how to get results back using return values, and best practices that will make your functions clean and maintainable.

What Is a Function?

A function is a reusable block of code that performs a specific task. Think of it like a recipe: you write the recipe once (define the function), and then you can follow that recipe as many times as you want (call the function).

Functions help you:

Avoid repetition: Write code once, use it many times
Organize code: Break complex programs into smaller, manageable pieces
Make code testable: You can test each function independently
Improve readability: Well-named functions make code self-documenting

Defining Your First Function

In Python, you define a function using the def keyword followed by the function name and parentheses:

def greet():
    print("Hello, World!")

This creates a function called greet that prints a message when called. To run the function, you call it by name with parentheses:

greet()

Try it out in your Python interpreter:

>>> def greet():
...     print("Hello, World!")
... 
>>> greet()
Hello, World!

Functions with Parameters

Parameters let you pass data into a function so it can work with different values. Inside the function, parameters work like variables that hold the values you pass in.

Single Parameter

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

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

Multiple Parameters

You can define functions with multiple parameters:

def greet_full(first_name, last_name):
    print(f"Hello, {first_name} {last_name}!")

greet_full("John", "Doe")  # Output: Hello, John Doe!

Default Parameters

Python lets you specify default values for parameters. If the caller does not provide a value, the default is used:

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

greet("Alice")           # Output: Hello, Alice!
greet("Bob", "Hi")       # Output: Hi, Bob!
greet("Carol", "Howdy")  # Output: Howdy, Carol!

Important: Default parameters must come after non-default parameters in your function definition:

# Incorrect
def greet(greeting="Hello", name):
    pass  # This will cause an error!

# Correct order
def greet(name, greeting="Hello"):
    pass  # This works

Return Values

Functions can send back results using the return statement. The returned value becomes the result of the function call:

def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # Output: 8

You can return any type of value — numbers, strings, lists, dictionaries, or even other functions:

def get_user_info():
    return {
        "name": "Alice",
        "email": "alice@example.com",
        "age": 30
    }

user = get_user_info()
print(user["name"])  # Output: Alice

Returning Multiple Values

Python functions can return multiple values as a tuple:

def divide_and_remainder(a, b):
    quotient = a // b
    remainder = a % b
    return quotient, remainder

q, r = divide_and_remainder(10, 3)
print(q, r)  # Output: 3 1

Early Returns

You can return early from a function using multiple return statements:

def find_first_even(numbers):
    for i, num in enumerate(numbers):
        if num % 2 == 0:
            return i
    return -1  # No even number found

print(find_first_even([1, 3, 5, 6, 7]))  # Output: 3
print(find_first_even([1, 3, 5, 7]))      # Output: -1

Understanding Variable Scope

Variables defined inside a function are local to that function — they do not exist outside of it:

def test_scope():
    local_var = "I am local"
    print(local_var)

test_scope()           # Output: I am local
print(local_var)       # Error! NameError

Variables defined outside functions are global and can be read inside functions (but you should avoid modifying them):

counter = 0

def increment():
    print(counter)  # Reading global variable — OK

increment()

To modify a global variable inside a function, use the global keyword (use sparingly):

counter = 0

def increment():
    global counter
    counter += 1

increment()
increment()
print(counter)  # Output: 2

Keyword Arguments

Python lets you pass arguments by name using keyword arguments. This makes function calls more readable and allows you to specify arguments in any order:

def create_user(username, email, is_admin=False):
    return {
        "username": username,
        "email": email,
        "is_admin": is_admin
    }

# Using keyword arguments
user1 = create_user(username="alice", email="alice@example.com")
user2 = create_user(email="bob@example.com", username="bob")
user3 = create_user("charlie", "charlie@example.com", is_admin=True)

Args and kwargs

Sometimes you do not know how many arguments a function will receive. Python provides special parameters for this:

*args collects extra positional arguments into a tuple
**kwargs collects extra keyword arguments into a dictionary

def print_all(*args, **kwargs):
    print("Positional arguments:", args)
    print("Keyword arguments:", kwargs)

print_all(1, 2, 3, name="Alice", age=30)
# Output:
# Positional arguments: (1, 2, 3)
# Keyword arguments: {"name": "Alice", "age": 30}

This is useful for creating flexible functions and when working with decorators.

Docstrings: Documenting Your Functions

A docstring is a string literal that appears right after the function definition. It documents what the function does:

def calculate_area(length, width):
    """
    Calculate the area of a rectangle.
    
    Args:
        length: The length of the rectangle
        width: The width of the rectangle
    
    Returns:
        The area (length * width)
    """
    return length * width

Docstrings are accessible at runtime using the help() function or __doc__ attribute:

help(calculate_area)
print(calculate_area.__doc__)

Best Practices for Writing Functions

Use descriptive names: Function names should clearly describe what they do — calculate_area() is better than calc().
Keep functions small: Each function should do one thing well. If a function is doing too much, consider breaking it into smaller functions.
Use comments wisely: Explain why the code does something, not what it does. The code itself should be self-explanatory.
Follow the DRY principle: Do not Repeat Yourself. If you find yourself copying and pasting code, create a function instead.

Use default parameters wisely: They make functions more flexible but can cause unexpected behavior with mutable defaults:

# Bad — do not do this!
def add_item(item, items=[]):
    items.append(item)
    return items

# Good — use None instead
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

Putting It All Together

Here is an example that combines everything we have learned:

def calculate_stats(numbers, show_details=False):
    """
    Calculate basic statistics for a list of numbers.
    
    Args:
        numbers: A list of numeric values
        show_details: If True, return detailed statistics
    
    Returns:
        A dictionary with the calculated statistics
    """
    if not numbers:
        return {"error": "No numbers provided"}
    
    total = sum(numbers)
    average = total / len(numbers)
    minimum = min(numbers)
    maximum = max(numbers)
    
    if show_details:
        return {
            "sum": total,
            "average": average,
            "min": minimum,
            "max": maximum,
            "count": len(numbers)
        }
    else:
        return {"average": average}

# Basic usage
scores = [85, 90, 78, 92, 88]
print(calculate_stats(scores))
# Output: {"average": 86.6}

# Detailed statistics
print(calculate_stats(scores, show_details=True))
# Output: {"sum": 433, "average": 86.6, "min": 78, "max": 92, "count": 5}

Next Steps

Now that you understand functions, you are ready to move on to the next tutorial in the Python Fundamentals series: Lists, Tuples, and Dictionaries. You will learn how to organize data using Python is built-in collection types, which you will often use inside functions.

Functions are everywhere in Python — the built-in functions like len(), print(), and range() are just functions others have written for you. As you continue learning, you will not only use functions but also learn about advanced topics like decorators, lambda functions, and generators.