Defining and Calling Functions

Introduction

In the previous chapter, you learned why functions are important and how they reduce code duplication. Now it is time to write your own functions. In Python, a function is created using the def keyword followed by a name, parentheses, and a colon. The body of the function is indented below the header.

Defining a function does not execute it immediately. The code inside the function only runs when the function is called by writing its name followed by parentheses. This separation of definition and execution is a fundamental concept in Python programming.

This chapter walks you through every detail—from naming rules and indentation to docstrings and execution flow—so you can define and call functions with confidence.

Syntax of a Function

Every user-defined function in Python follows this general syntax:

def function_name(parameters):
    """Docstring describing the function."""
    # function body
    # one or more statements

Breakdown of the syntax:

• def — The keyword that tells Python you are defining a function.
• function_name — A meaningful name you choose (follows variable naming rules).
• (parameters) — Optional list of variables that receive input values.
• : — A colon that marks the end of the function header.
• Docstring — An optional string that documents what the function does.
• Indented body — The statements that form the function's logic.

Example 1 — Simplest Function

Let us define and call the most basic function possible:

def greet():
    print("Hello, welcome to Python!")

greet()
greet()

Output:
Hello, welcome to Python!
Hello, welcome to Python!

Step-by-step explanation:

1. Line 1: def greet(): defines a function named greet. Nothing is executed yet.
2. Line 2: The indented print() statement becomes the body of the function.
3. Line 4: greet() calls the function. Now Python executes the body.
4. Line 5: The second call repeats the execution.

Example 2 — Function with Parameters

def greet_person(name):
    print("Hello, " + name + "!")

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

Output:
Hello, Alice!
Hello, Bob!

Here, name is a parameter. When you call greet_person("Alice"), the string "Alice" is an argument that gets assigned to the parameter name inside the function.

Example 3 — Multiple Parameters

def add(a, b):
    result = a + b
    print("Sum =", result)

add(10, 20)
add(5, 7)

Output:
Sum = 30
Sum = 12

You can define as many parameters as you need, separated by commas.

Real-Life Analogy

Think of a microwave. The manufacturer writes the instruction manual (function definition) once. Every user reads the manual and presses the start button (function call) whenever they need to heat food. The manual does not cook food by itself—it only works when someone follows (calls) the instructions.

Similarly, defining a function only creates the instructions. Calling the function makes Python actually execute those instructions.

Function Naming Rules

Docstrings — Documenting Your Function

A docstring is a string literal placed as the first statement inside a function. It describes what the function does. You can access it using function_name.__doc__.

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

print(multiply.__doc__)
print(multiply(3, 4))

Output:
Return the product of two numbers.
12

Docstrings are considered best practice. They help other developers (and your future self) understand the function without reading its code.

Defining vs Calling a Function

Execution Flow of a Function

Consider the following code:

print("Step 1")

def my_func():
    print("Inside function")

print("Step 2")
my_func()
print("Step 3")

Output:
Step 1
Step 2
Inside function
Step 3

Explanation:

1. Python executes top-level statements in order.
2. When it reaches def my_func():, it defines the function but does not run the body.
3. print("Step 2") executes next.
4. my_func() calls the function, so the body runs: print("Inside function").
5. After the function finishes, execution continues to print("Step 3").

Functions with No Parameters and No Return

A function does not need parameters or a return value. It can simply perform an action:

def display_menu():
    print("===== MENU =====")
    print("1. Add")
    print("2. Subtract")
    print("3. Multiply")
    print("4. Divide")
    print("=================")

display_menu()

Output:
===== MENU =====
1. Add
2. Subtract
3. Multiply
4. Divide
=================

This is useful for organizing output into logical blocks and avoiding repetition.

Common Mistakes

def greet()    # SyntaxError: expected ':'
    print("Hello")

def greet():
print("Hello")    # IndentationError

greet()         # NameError: name 'greet' is not defined

def greet():
    print("Hello")

Practice Questions

def print_square(n):
    print(n * n)

print_square(5)
# Output: 25

def display():
    print("A")

def main():
    display()
    display()

main()
display()

Answer: A, A, A

def is_even(num):
    if num % 2 == 0:
        print(num, "is even")
    else:
        print(num, "is odd")

is_even(4)   # 4 is even
is_even(7)   # 7 is odd

def display_info(name, age):
    print("Name:", name)
    print("Age:", age)

display_info("Alice", 21)