Function Definition Syntax

To define a function in Python, we use the def keyword followed by the function name and parentheses:

1
def functionName(parameter1, parameter2, ...):
2
    # We have created a new scope
3
    # We put statements here
4
    pass

The function definition consists of:

1. The def keyword
2. The function name (following the same naming rules as variables)
3. Parentheses () that may contain parameters
4. A colon : to indicate the start of the function body
5. The function body (indented code block) - this creates a new scope

Note

By convention, function names use lowercase letters with underscores separating words (snake_case), e.g., calculate_total, get_user_input.

Calling Functions

To execute a function, we call it by writing its name followed by parentheses:

1
def say_hello():
2
    print("Hello!")
3

4
say_hello()  # Function call
5
say_hello()  # Can be called multiple times

Functions with Parameters

Functions can accept parameters (inputs) to make them more flexible. We can also give functions some values. These values are called arguments of a function.

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

4
greet("Alice")   # Hello, Alice!
5
greet("Bob")     # Hello, Bob!

A parameter is the variable listed inside the parentheses in the function definition. An argument is the value that is sent to the function when it is called.

We can give a function your name, and it can greet you!

Functions with Return Values

All functions in Python return a value. This is done using the return keyword. If not specified, a function will return None.

1
def add(a, b):
2
    return a + b
3

4
result = add(3, 5)
5
print(result)  # 8

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

4
result = greet("Alice")
5
print(result)  # None

Multiple Return Values

Python functions can return multiple values using tuples:

1
def get_name_and_age():
2
    return "Alice", 25
3

4
name, age = get_name_and_age()
5
print(name)  # Alice
6
print(age)   # 25

This is actually returning a tuple, which is then unpacked into multiple variables.

The pass Statement

The pass statement does nothing. It can be used when a statement is required syntactically but the program does no action:

1
def future_function():
2
    pass  # Placeholder - function does nothing for now
3

4
def calculate():
5
    # TODO: Implement calculation logic
6
    pass

Function Body

The function body contains the code that executes when the function is called. It must be indented:

1
def calculate_area(length, width):
2
    area = length * width
3
    return area
4

5
result = calculate_area(5, 3)
6
print(result)  # 15

Example: Complete Function

1
def calculate_discount(price, discount_percent):
2
    discount_amount = price * (discount_percent / 100)
3
    final_price = price - discount_amount
4
    return final_price
5

6
original_price = 100
7
discount = 20
8
final = calculate_discount(original_price, discount)
9
print(f"Original: ${original_price}, Final: ${final}")

Exercises

1
def greet_user(name):
2
  print(f"Hello, {name}!")
3

4
greet_user("Alice")

1
def multiply(a, b):
2
    return a * b
3

4
a = int(input())
5
b = int(input())
6
result = multiply(a, b)
7
print(result)

1
def display_message():
2
  print("Hello World")
3

4
result = display_message()
5
print(result)

1
Hello World
2
None

1
def get_name_age():
2
    name = input()
3
    age = int(input())
4
    return name, age
5

6
name, age = get_name_age()
7
print(f"Name: {name}, Age: {age}")

1
def calculate_area(length, width):
2
  pass  # TODO: Implement area calculation