Skip to content

Returning a Function in Python: Effortlessly Increase Code Modularity


The Python return Statement: Usage and Best Practices

The Python return statement is a key component of functions and methods in Python. It allows you to send Python objects back to the caller code. These objects are known as the function’s return value, and they can be used for further computation in your programs. In this tutorial, we will explore how to effectively use the return statement in Python functions, as well as best practices to follow.

Getting Started With Python Functions

Before we dive into the return statement, let’s briefly understand the concept of functions in Python. Functions are named code blocks that perform a specific computation. They allow you to reuse code by calling the function from different parts of your program.

Understanding the Python return Statement

The return statement is used to specify the return value of a function. It indicates that the function has finished its execution and is ready to return a value. There are two types of return statements in Python: explicit return statements and implicit return statements.

Explicit return Statements

An explicit return statement explicitly specifies the return value of a function. It consists of the keyword return followed by the value you want to return. Here is an example:

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

In the above example, the add_numbers function returns the sum of the two input parameters a and b.

Implicit return Statements

An implicit return statement does not specify the return value explicitly. Instead, it returns the result of the expression evaluated in the function. Here is an example:

def cube(number):
return number ** 3

In the above example, the cube function returns the cube of the input parameter number by evaluating the expression number ** 3.

Returning vs Printing

It’s important to note the difference between returning a value and printing a value in a function. When you return a value from a function, you can use that value for further computation or store it in a variable. On the other hand, printing a value in a function only displays the value on the console, but you cannot use it for subsequent operations. Consider the following example:

def add_numbers(a, b):
return a + b
def print_sum(a, b):
print(a + b)

In the above example, the add_numbers function returns the sum of the input parameters a and b, while the print_sum function only prints the sum on the console.

Returning Multiple Values

In Python, you can also return multiple values from a function. This can be done by separating the values with commas in the return statement. Here is an example:

def get_name_and_age():
name = "John"
age = 25
return name, age

In the above example, the get_name_and_age function returns both the name and age as separate values. You can then store these values in variables or use them individually.

Using the Python return Statement: Best Practices

When using the return statement in Python, there are several best practices you should follow to write clean and efficient code. Let’s explore some of them:

Returning None Explicitly

In Python, it is common to use None as a placeholder when a function doesn’t have a specific return value. By explicitly returning None, you indicate that the function does not produce any meaningful result. Here is an example:

def greet(name):
if name:
return f"Hello, {name}!"
return None

In the above example, the greet function returns a greeting message if a name is provided, otherwise it returns None.

Remembering the Return Value

When calling a function that has a return value, make sure to capture and assign the returned value to a variable. If you don’t assign the return value, it will be lost. Here is an example:

def calculate_square(number):
return number ** 2
result = calculate_square(5) # Assign the return value to a variable
print(result) # Output: 25

In the above example, the return value of the calculate_square function is assigned to the variable result before printing it.

Avoiding Complex Expressions

It’s generally a good practice to avoid complex expressions in the return statement. Instead, break down the expression into smaller, more manageable parts. This improves the readability and maintainability of your code. Here is an example:

def calculate_total_price(quantity, price):
discount = 0.1
total_price = quantity * price
return total_price - (total_price * discount)

In the above example, the calculate_total_price function calculates the total price after applying a discount. The expression is broken down into separate variables to enhance clarity.

Returning Values vs Modifying Globals

In Python, it’s generally recommended to return values from functions instead of modifying global variables. This promotes encapsulation and modularity in your code. Modifying global variables directly can lead to unexpected side effects and make debugging more difficult. Consider the following example:

total = 0
def add_number(number):
global total
total += number
print(total) # Output: 5

In the above example, the add_number function modifies the global variable total directly. While this works, it can be confusing and error-prone, especially in larger programs.

Using return With Conditionals

You can use the return statement in combination with conditionals to control the flow of your function. This allows you to return specific values based on certain conditions. Here is an example:

def check_even_odd(number):
if number % 2 == 0:
return "Even"
return "Odd"

In the above example, the check_even_odd function returns either “Even” or “Odd” based on the input number.

Returning True or False

It is common to use the return statement to return True or False based on a certain condition. This is often used in functions that perform validation or boolean operations. Here is an example:

def is_positive(number):
return number > 0

In the above example, the is_positive function returns True if the input number is positive, and False otherwise.

Short-Circuiting Loops

When using loops, you can use the return statement to exit the loop early if a certain condition is met. This is known as short-circuiting the loop. Here is an example:

def find_index(items, target):
for i, item in enumerate(items):
if item == target:
return i
return -1

In the above example, the find_index function searches for a target item in a list. If the target is found, the function immediately returns the index. Otherwise, it returns -1.

Recognizing Dead Code

When using the return statement, it’s important to recognize dead code. Dead code is any code that is never executed because it comes after a return statement. This code is effectively unreachable and can be safely removed. Here is an example:

def is_negative(number):
if number < 0:
return True
return False
print("This code is unreachable") # Dead code

In the above example, the print statement is dead code because it comes after the return statement.

Returning Multiple Named-Objects

Python allows you to return multiple named objects from a function by using a dictionary or a custom class. This can be useful when you want to return multiple related values together. Here is an example using a dictionary:

def get_person_details():
name = "John"
age = 25
return {"name": name, "age": age}

In the above example, the get_person_details function returns a dictionary containing the person’s name and age.

Returning Functions: Closures

In Python, you can also return functions from other functions. This is known as returning closures. A closure is a function object that remembers values in the enclosing scope even if they are not present in memory. Returning functions allows for dynamic behavior and code reusability. Here is an example:

def multiply_by(num):
def multiply(number):
return num * number
return multiply
multiply_by_5 = multiply_by(5)
result = multiply_by_5(10) # Output: 50

In the above example, the multiply_by function returns another function multiply. The returned function can then be used to multiply numbers by a specific factor.

Taking and Returning Functions: Decorators

Another advanced use case of returning functions in Python is in the concept of decorators. Decorators allow you to modify the behavior of an existing function dynamically by wrapping it with additional functionality. This is achieved by returning a function that wraps the original function. Here is a simple example:

def uppercase_decorator(func):
def wrapper(text):
return func(text.upper())
return wrapper
def say_hello(name):
return f"Hello, {name}!"
result = say_hello("John") # Output: "Hello, JOHN!"

In the above example, the uppercase_decorator function returns another function wrapper. The returned function wraps the say_hello function by converting the input to uppercase before executing the original function.

Returning User-Defined Objects: The Factory Pattern

The return statement can also be used to create and return user-defined objects. This is commonly known as the factory pattern in object-oriented programming. The factory pattern allows you to create objects of a specific class based on input parameters or conditions. Here is an example:

class Rectangle:
def __init__(self, length, width):
self.length = length
self.width = width
def create_rectangle(length, width):
if length == width:
return Square(length)
return Rectangle(length, width)
rectangle = create_rectangle(5, 5) # Create a square object

In the above example, the create_rectangle function returns an instance of the Rectangle class. However, if the length and width are equal, it returns an instance of the Square class instead.

Using return in try … finally Blocks

You can also use the return statement in a try ... finally block. The finally block is always executed, regardless of whether an exception is raised or not. Here is an example:

def divide(a, b):
return a / b
print("Division Complete")
result = divide(10, 2)
print(result) # Output: 5.0

In the above example, the return statement is executed before the finally block, which prints “Division Complete” on the console.

Using return in Generator Functions

Finally, the return statement can also be used in generator functions. A generator function is a special type of function that returns an iterator. In generator functions, you can use the return statement to stop the iteration early. Here is an example:

def count_up_to(n):
for i in range(n):
yield i
return None
numbers = count_up_to(5)
for num in numbers:
print(num) # Output: 0, 1, 2, 3, 4

In the above example, the count_up_to generator function returns all the numbers from 0 to n using the yield statement. The return statement in this case is optional since the function would naturally end after generating all the numbers.


In this tutorial, you have learned how to use the Python return statement effectively in your functions. You now understand how to return single or multiple values, as well as important best practices to follow. By following these guidelines, you can write more readable, maintainable, and concise functions in Python. It’s important to remember to capture and assign the return value of a function, avoid complex expressions, and utilize the return statement in different scenarios such as conditionals, loops, and closures. Additionally, you have explored advanced concepts such as returning functions, decorators, and factory patterns. With this knowledge, you are well-equipped to write Python functions that are both informative and efficient.