Defining Functions

Intermediate ~20 min read

Functions are the building blocks of reusable code. They let you define a block of code once and use it anywhere in your program by simply calling its name. Functions make your code more organized, readable, and maintainable - they're essential for writing professional Python code!

Defining Functions

In Python, you define a function using the def keyword, followed by the function name, parentheses for parameters, and a colon. The function body is indented below. Good function names use snake_case and start with a verb describing what the function does.

# Defining Functions in Python

# 1. Basic function syntax
print("=== Basic Function ===")
def greet():
    """A simple function that prints a greeting."""
    print("Hello, World!")

# Call the function
greet()
print()

# 2. Function with one parameter
print("=== Single Parameter ===")
def greet_person(name):
    """Greet a specific person."""
    print(f"Hello, {name}!")

greet_person("Alice")
greet_person("Bob")
print()

# 3. Function with multiple parameters
print("=== Multiple Parameters ===")
def introduce(name, age, city):
    """Introduce someone with their details."""
    print(f"{name} is {age} years old and lives in {city}.")

introduce("Charlie", 25, "New York")
introduce("Diana", 30, "London")
print()

# 4. Function names follow same rules as variables
print("=== Naming Conventions ===")
# Good function names (snake_case)
def calculate_total():
    pass

def get_user_input():
    pass

def is_valid_email():  # Returns boolean
    pass

print("Use snake_case for function names")
print("Use descriptive verbs: calculate_, get_, is_, has_")

Output

Click Run to execute your code

Function vs Method: A function is a standalone block of code defined with def. A method is a function that belongs to an object and is called with dot notation like list.append(). Under the hood, methods are just functions that receive the object as their first argument (self).

Calling Functions

To execute a function, you call it by writing its name followed by parentheses. The parentheses are crucial - without them, you're referring to the function object itself, not executing it. You can pass arguments, store return values, and chain function calls.

# Calling Functions in Python

# 1. Basic function call
print("=== Basic Calls ===")
def say_hello():
    print("Hello!")

# Call with parentheses - executes the function
say_hello()

# Without parentheses - reference to function object
print(f"Function object: {say_hello}")
print(f"Type: {type(say_hello)}")
print()

# 2. Calling with arguments
print("=== With Arguments ===")
def add(a, b):
    return a + b

# Positional arguments
result = add(3, 5)
print(f"add(3, 5) = {result}")

# Named/keyword arguments
result = add(a=10, b=20)
print(f"add(a=10, b=20) = {result}")

# Mixed (positional first, then keyword)
result = add(7, b=3)
print(f"add(7, b=3) = {result}")
print()

# 3. Storing function results
print("=== Storing Results ===")
def multiply(x, y):
    return x * y

# Store result in variable
product = multiply(6, 7)
print(f"Product: {product}")

# Use result directly in expressions
total = multiply(3, 4) + multiply(5, 2)
print(f"3*4 + 5*2 = {total}")

# Pass result to another function
def double(n):
    return n * 2

doubled = double(multiply(2, 3))
print(f"double(multiply(2, 3)) = {doubled}")
print()

# 4. Functions calling other functions
print("=== Functions Calling Functions ===")
def square(n):
    return n * n

def sum_of_squares(a, b):
    return square(a) + square(b)

result = sum_of_squares(3, 4)
print(f"3² + 4² = {result}")

Output

Click Run to execute your code

Positional vs Keyword Arguments: When calling a function, positional arguments must come before keyword arguments. func(1, 2, c=3) is valid, but func(a=1, 2, 3) is a syntax error. Keyword arguments make calls more readable and allow you to skip optional parameters.

Docstrings: Documenting Functions

A docstring is a string literal that appears as the first statement in a function. It documents what the function does, its parameters, and return value. Python's built-in help() function and IDEs use docstrings to provide documentation.

# Function Docstrings in Python

# 1. Basic docstring
print("=== Basic Docstring ===")
def greet(name):
    """Greet someone by name."""
    return f"Hello, {name}!"

# Access docstring
print(greet("Alice"))
print(f"Docstring: {greet.__doc__}")
print()

# 2. Multi-line docstring
print("=== Multi-line Docstring ===")
def calculate_area(length, width):
    """
    Calculate the area of a rectangle.

Parameters:
        length: The length of the rectangle
        width: The width of the rectangle

Returns:
        The area (length * width)
    """
    return length * width

print(f"Area: {calculate_area(5, 3)}")
print("Docstring:")
print(calculate_area.__doc__)
print()

# 3. Using help() to view documentation
print("=== Using help() ===")
def is_even(number):
    """
    Check if a number is even.

Args:
        number: An integer to check

Returns:
        True if number is even, False otherwise

Example:
        >>> is_even(4)
        True
        >>> is_even(7)
        False
    """
    return number % 2 == 0

# help(is_even)  # Uncomment to see full help
print(f"is_even(4) = {is_even(4)}")
print(f"is_even(7) = {is_even(7)}")
print()

# 4. Why docstrings matter
print("=== Why Docstrings Matter ===")
print("1. Self-documenting code")
print("2. IDE shows them as tooltips")
print("3. help() function displays them")
print("4. Auto-documentation tools use them")
print("5. Makes your code professional")

Output

Click Run to execute your code

Comments vs Docstrings: Regular comments (#) are for implementation notes and are not accessible at runtime. Docstrings ("""...""") are stored in the function's __doc__ attribute and can be accessed programmatically. Always use docstrings for function documentation, not comments.

Practical Function Examples

Let's look at some real-world function examples - utility functions for temperature conversion, string processing, validation, and working with lists. These patterns will appear constantly in your Python programs.

# Practical Function Examples

# 1. Temperature converter
print("=== Temperature Converter ===")
def celsius_to_fahrenheit(celsius):
    """Convert Celsius to Fahrenheit."""
    return (celsius * 9/5) + 32

def fahrenheit_to_celsius(fahrenheit):
    """Convert Fahrenheit to Celsius."""
    return (fahrenheit - 32) * 5/9

print(f"0°C = {celsius_to_fahrenheit(0)}°F")
print(f"100°C = {celsius_to_fahrenheit(100)}°F")
print(f"98.6°F = {fahrenheit_to_celsius(98.6):.1f}°C")
print()

# 2. String utilities
print("=== String Utilities ===")
def clean_string(text):
    """Remove extra whitespace and convert to lowercase."""
    return " ".join(text.split()).lower()

def count_words(text):
    """Count the number of words in a string."""
    return len(text.split())

messy = "   Hello    World   "
print(f"Original: '{messy}'")
print(f"Cleaned: '{clean_string(messy)}'")
print(f"Word count: {count_words(messy)}")
print()

# 3. Validation functions
print("=== Validation Functions ===")
def is_valid_age(age):
    """Check if age is a valid positive number."""
    return isinstance(age, int) and 0 <= age <= 150

def is_valid_email(email):
    """Basic email validation (contains @ and .)"""
    return "@" in email and "." in email

print(f"is_valid_age(25): {is_valid_age(25)}")
print(f"is_valid_age(-5): {is_valid_age(-5)}")
print(f"is_valid_email('test@example.com'): {is_valid_email('test@example.com')}")
print(f"is_valid_email('invalid'): {is_valid_email('invalid')}")
print()

# 4. List processing
print("=== List Processing ===")
def get_evens(numbers):
    """Return only even numbers from a list."""
    return [n for n in numbers if n % 2 == 0]

def get_sum_and_avg(numbers):
    """Return both sum and average of a list."""
    total = sum(numbers)
    avg = total / len(numbers) if numbers else 0
    return total, avg  # Return multiple values as tuple

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(f"Numbers: {nums}")
print(f"Evens: {get_evens(nums)}")
total, avg = get_sum_and_avg(nums)
print(f"Sum: {total}, Average: {avg}")

Output

Click Run to execute your code

Common Mistakes

1. Forgetting parentheses when calling

# Wrong - this is the function object, not a call
result = my_function  # No execution!
print(result)  # Prints: 

# Correct - use parentheses to call
result = my_function()
print(result)  # Prints the actual return value

2. Missing colon after function definition

# Wrong - missing colon
def greet(name)  # SyntaxError!
    print(f"Hello, {name}")

# Correct - include the colon
def greet(name):
    print(f"Hello, {name}")

3. Incorrect indentation in function body

# Wrong - inconsistent indentation
def calculate(a, b):
    result = a + b
  extra = result * 2  # IndentationError!
    return extra

# Correct - consistent indentation
def calculate(a, b):
    result = a + b
    extra = result * 2
    return extra

4. Calling function before definition

# Wrong - function called before it's defined
result = add(3, 5)  # NameError: name 'add' is not defined

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

# Correct - define first, then call
def add(a, b):
    return a + b

result = add(3, 5)

5. Using wrong number of arguments

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

# Wrong - too few arguments
greet("Alice")  # TypeError: missing 1 required positional argument

# Wrong - too many arguments
greet("Alice", "Smith", "Ms.")  # TypeError: takes 2 positional arguments but 3 were given

# Correct - exact number of arguments
greet("Alice", "Smith")

Exercise: Calculator Functions

Task: Create basic calculator functions.

Requirements:

Define add(a, b) - returns sum
Define subtract(a, b) - returns difference
Define multiply(a, b) - returns product
Each function should have a docstring
Test each function with sample values

Output

Click Run to execute your code

Show Solution

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

def subtract(a, b):
    """Return a minus b."""
    return a - b

def multiply(a, b):
    """Return the product of a and b."""
    return a * b

# Test the functions
print(f"5 + 3 = {add(5, 3)}")
print(f"10 - 4 = {subtract(10, 4)}")
print(f"6 * 7 = {multiply(6, 7)}")

Summary

Define: def function_name(parameters):
Call: function_name(arguments)
Naming: Use snake_case with descriptive verbs
Docstrings: First line in function body: """Description."""
Parameters: Variables in definition; arguments are values passed when calling
Execution order: Define before calling; Python reads top-to-bottom
Parentheses: Always use () to call; without them you get the function object

What's Next?

Now that you can define and call functions, let's dive deeper into Function Arguments - you'll learn about default values, keyword arguments, and how to create flexible functions that accept any number of arguments with *args and **kwargs!

Previous Nested Structures

Next Function Arguments