Return Statement in Python: Syntax & Examples

Introduction

The return statement allows a function to send a value back to the caller. Instead of simply printing a result on the screen, a function can return the result so it can be stored in a variable, used in calculations, or passed to another function.

For example, a calculator function may add two numbers and return the result. A banking application may calculate an account balance and return the updated value. A web application may retrieve data from a database and return it for further processing.

What is the Return Statement in Python?

The return statement is used inside a function to send a value back to the function caller.

When Python encounters a return statement:

1. The function immediately stops executing.
2. The specified value is sent back to the caller.
3. Control returns to the point where the function was called.

Example:

def add(a, b):
    return a + b
result = add(10, 20)
print(result)

Output:

In this example:

• The function calculates 10 + 20.
• The result is returned.
• The returned value is stored in result.

Why Use the Return Statement?

Without the return statement:

def add(a, b):
    print(a + b)
result = add(10, 20)
print(result)

Output:

The function prints the result but does not return it.

With the return statement:

def add(a, b):
    return a + b
result = add(10, 20)
print(result)

Output:

The returned value can now be stored and reused.

Syntax

The basic syntax is:

def function_name():
    return value

Example:

def greet():
    return "Hello World"
message = greet()
print(message)

Output:

Returning a Single Value

A function can return one value.

Example:

def square(number):
    return number * number
print(square(5))

Output:

The function returns the square of the number.

Returning a String

Example:

def get_name():
    return "John"
print(get_name())

Output:

Functions can return strings just like numbers.

Returning a Boolean Value

Example:

def is_adult(age):
    return age >= 18
print(is_adult(20))

Output:

Boolean values are commonly returned in validation functions.

Returning Multiple Values

Python allows returning multiple values separated by commas.

Example:

def student():
    return "John", 20
name, age = student()
print(name)
print(age)

Output:

Python automatically packs the values into a tuple.

Returning a List

Example:

def colors():
    return ["Red", "Green", "Blue"]
print(colors())

Output:

Returning a Dictionary

Example:

def employee():
    return {
        "name": "John",
        "salary": 50000
    }
print(employee())

Output:

Returning Calculation Results

Example:

def multiply(a, b):
    return a * b
result = multiply(5, 4)
print(result)

Output:

This is one of the most common uses of the return statement.

Using Returned Values in Expressions

Returned values can be used directly in calculations.

Example:

def add(a, b):
    return a + b
total = add(10, 20) * 2
print(total)

Output:

The returned value behaves like any other value.

Returning Values from Conditional Statements

Example:

def check_number(number):
    if number > 0:
        return "Positive"
    return "Negative"
print(check_number(10))

Output:

Returning Values from Loops

Example:

def find_even(numbers):
    for num in numbers:
        if num % 2 == 0:
            return num
print(find_even([1, 3, 5, 8, 9]))

Output:

The function stops as soon as it finds an even number.

Difference between return and print

Many beginners confuse between return and print.

Using print()

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

Displays the result but does not send it back.

Using return

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

Returns the result for later use.

Comparison Table

What Happens After Return?

Once a return statement executes, the function ends immediately.

Example:

def demo():
    print("Start")
    return
    print("End")
demo()

Output:

The second print statement never executes.

Return Without a Value

A return statement can be used without specifying a value.

Example:

def greet():
    return
result = greet()
print(result)

Output:

Python returns None by default.

Functions Without Return Statements

If no return statement exists, Python automatically returns None.

Example:

def welcome():
    print("Welcome")
result = welcome()
print(result)

Output:

Real-Life Examples:

1. Student Grade Calculator

def calculate_average(math, science, english):
    return (math + science + english) / 3
average = calculate_average(80, 90, 70)
print(average)

Output:

Schools commonly use such calculations.

2. E-Commerce Website

def calculate_total(price, quantity):
    return price * quantity
total = calculate_total(500, 3)
print(total)

Output:

Online stores use returned values for billing.

3. Banking System

def deposit(balance, amount):
    return balance + amount
new_balance = deposit(1000, 500)
print(new_balance)

Output:

4. Login Validation

def validate_user(username):
    return username == "admin"
print(validate_user("admin"))

Output:

Authentication systems often return Boolean values.

5. Employee Salary Calculator

def calculate_salary(hours, rate):
    return hours * rate
salary = calculate_salary(40, 20)
print(salary)

Output:

Advantages of the Return Statement

1. Reusability

Returned values can be reused throughout the program.

2. Better Program Design

Functions become independent and modular.

3. Easier Testing

Returned values can be tested automatically.

4. Improved Readability

Functions clearly indicate what data they produce.

5. Supports Complex Operations

Returned values can be passed to other functions.

Common Mistakes

1. Using print Instead of return

Incorrect:

def calculate_salary(hours, rate):
    return hours * rate
salary = calculate_salary(40, 20)
print(salary)

Correct:

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

2. Forgetting to Store Returned Values

Incorrect:

def square(number):
    return number * number
square(5)

The value is returned but not used.

Correct:

result = square(5)

3. Writing Code After Return

Incorrect:

def demo():
    return
    print("Hello")

The print statement never executes.

4. Expecting Output Without Print

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

No output appears because the result is not printed.

5. Forgetting Return in Calculation Functions

Incorrect:

def multiply(a, b):
    a * b

Correct:

def multiply(a, b):
    return a * b

Best Practices

1. Return Values Instead of Printing

Prefer:

return total

Over:

print(total)

2. Use Meaningful Function Names

def calculate_salary():

Instead of:

def cs():

3. Keep Functions Focused

A function should perform one task and return a clear result.

4. Return Consistent Data Types

Avoid returning different types unless necessary.

5. Document Returned Values

Use comments or documentation to explain what a function returns.

Conclusion

The return statement is one of the most important concepts in Python functions. It allows a function to send data back to the caller, making functions reusable, flexible, and powerful. Whether returning numbers, strings, Boolean values, lists, dictionaries, or multiple values, the return statement enables functions to interact effectively with the rest of a program.

Related Python Tutorials