Skip to content

Easily Understand Python Returning Concept: Explained


The Python return Statement: Usage and Best Practices

Getting Started With Python Functions

Most programming languages allow you to assign a name to a code block that performs a concrete computation. These named code blocks can be reused quickly because you can use their name to call them from different places in your code.

Programmers call these named code blocks subroutines, routines, procedures, or functions depending on the programming language. In Python, functions are defined using the def keyword followed by the name of the function and a pair of parentheses. The code block that forms the function body is then indented below the def line.

Here is a simple example of a Python function:

def greet():
return "Hello, World!"

To call the greet() function and obtain its return value, you simply use the function name followed by a pair of parentheses:

message = greet()
print(message) # Output: Hello, World!

In this example, the greet() function returns the string “Hello, World!” as its return value. The return value is then assigned to the variable message, which is printed to the console.

Understanding the Python return Statement

The return statement is a fundamental part of Python functions. It allows you to specify the value or values that should be sent back to the code that called the function. The return statement is used to terminate the execution of a function and to send a value back to the caller.

Explicit return Statements

When using the return statement, you can explicitly specify the value or values that should be returned. Here’s an example:

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

In this example, the add_numbers() function takes two arguments a and b, and returns their sum. You can call the function and assign the return value to a variable like this:

result = add_numbers(3, 5)
print(result) # Output: 8

Implicit return Statements

In some cases, a return statement may not have any value specified. In this case, the return statement is used to indicate that the function has completed its execution and no value is being returned. Here’s an example:

def greet():
print("Hello, World!")

If you call the greet() function, you will see the message “Hello, World!” printed to the console, but no value will be returned. The return statement simply exits the function.

Returning vs Printing

It’s important to understand the difference between returning a value from a function and printing a value. When a value is returned from a function, it can be used as part of an expression or assigned to a variable. On the other hand, when a value is printed, it is simply displayed on the console and cannot be used in further computations.

Consider the following example:

def multiply(a, b):
print(a * b)
multiply(3, 4) # Output: 12
result = multiply(3, 4)
print(result) # Output: None

In this example, the multiply() function prints the product of the two arguments received. When you call the function, the product is printed to the console, but no value is returned. Thus, when you assign the result of the function call to the variable result, the value of result will be None.

If you want to use the result of a computation in further calculations, you need to return the value instead of printing it.

Returning Multiple Values

Python allows you to return multiple values from a function by separating them with commas. Here’s an example:

def get_name_and_age():
name = "John"
age = 30
return name, age
result = get_name_and_age()
print(result) # Output: ('John', 30)

In this example, the get_name_and_age() function returns two values: the name “John” and the age 30. When you call the function and assign the return value to the variable result, you will get a tuple containing both values.

You can also unpack the values directly into separate variables like this:

name, age = get_name_and_age()
print(name) # Output: 'John'
print(age) # Output: 30

This allows you to use the returned values individually.

Using the Python return Statement: Best Practices

When using the return statement, there are some best practices that can help you write cleaner and more maintainable code.

Returning None Explicitly

If a function does not have any value to return, you can use the return statement with no value specified or with the keyword None. Explicitly returning None can make your code more readable, as it clearly indicates that the function does not produce any meaningful result.

def say_hello():
print("Hello, World!")
return None

Remembering the Return Value

When calling a function that returns a value, it’s important to remember to assign the return value to a variable or use it in some way. Forgetting to do so can lead to bugs, as the return value may contain important data for further calculations.

def compute_twice(number):
return number * 2
compute_twice(5) # Output: 10

In this example, the return value of compute_twice(5) is not assigned to a variable or used in any way. The return value is lost and cannot be used later in the code.

###- Avoiding Complex Expressions

It’s best to keep the return statement simple and easy to read. Avoid complex expressions or calculations within the return statement, as this can make your code more difficult to understand and maintain.

return (a * b) + ((c * d) / (e - f))

In this example, the return statement performs multiple calculations in a single line. It can be hard to decipher the meaning and intention of the code. It’s better to break up the calculations into separate lines for clarity.

result = (a * b)
result += (c * d) / (e - f)
return result

Returning Values vs Modifying Globals

When designing functions, it’s generally best to return values instead of modifying global variables. Modifying global variables can make your code less modular and harder to test and debug. Returning values allows you to encapsulate the functionality of your functions and makes them more reusable.

Using return With Conditionals

You can use the return statement within if statements or other conditionals to control the flow of your code. This can make your functions more flexible and allow for different return values depending on specific conditions.

def is_even(number):
if number % 2 == 0:
return True
return False

In this example, the is_even() function checks if a number is even and returns True if it is, and False otherwise. The return statement is used within an if statement to control the flow of the code.

Returning True or False

In Python, the values True and False have a special significance. They represent boolean values that can be used in conditional statements. When a function needs to determine a condition and return a boolean value, it’s best to directly return True or False instead of returning a string or an integer.

def is_even(number):
if number % 2 == 0:
return True
return False

In the example above, the function is_even() returns True if the number is even, and False otherwise. This allows you to use the return value directly in an if statement:

if is_even(4):
print("The number is even")
print("The number is odd")

Short-Circuiting Loops

The return statement can be used to terminate a loop early if a certain condition is met. This is known as short-circuiting and can make your code more efficient. Here’s an example:

def is_prime(number):
if number < 2:
return False
for i in range(2, int(number ** 0.5) + 1):
if number % i == 0:
return False
return True

In this example, the is_prime() function checks if a number is prime by iterating from 2 to the square root of the number and checking for any divisors. If a divisor is found, the function immediately returns False, short-circuiting the loop.

Recognizing Dead Code

When using the return statement to exit a function, it’s important to be aware of any code that comes after the return statement. This code is known as dead code and is not executed. Dead code can make your code harder to understand and maintain, as it may give the impression that it is executed when it actually isn’t.

def greet(name):
print("Hello, " + name)
print("Goodbye, " + name)

In this example, the print("Goodbye, " + name) line is never executed because it comes after the return statement. This line of code is considered dead code and should be removed to improve the readability of the function.

Returning Multiple Named-Objects

Sometimes it’s useful to return multiple values from a function and give them meaningful names. This can improve code readability and make it easier to understand the purpose of the returned values. Python allows you to return multiple named objects using dictionaries or namedtuples.

def get_person():
return {"name": "John", "age": 30}
person = get_person()
print(person["name"]) # Output: 'John'
print(person["age"]) # Output: 30

In this example, the get_person() function returns a dictionary with the keys “name” and “age” representing a person’s name and age, respectively. The returned dictionary can be used to access the individual values by their corresponding keys.

Returning Functions: Closures

In Python, functions are first-class objects, which means they can be assigned to variables, passed as arguments to other functions, and returned from functions. This allows you to return functions from other functions, creating what is known as a closure.

def multiply_by(factor):
def inner(number):
return number * factor
return inner
double = multiply_by(2)
print(double(5)) # Output: 10
triple = multiply_by(3)
print(triple(5)) # Output: 15

In this example, the multiply_by() function returns a new function inner(), which can be used to multiply a number by a factor. The returned function inner() “remembers” the value of the factor, creating a closure. You can then assign the returned function to a variable, creating a new function with a specific behavior.

Taking and Returning Functions: Decorators

Another powerful feature of Python is the ability to take functions as arguments and return functions from functions. This allows you to create decorators, which are functions that modify the behavior of other functions. Decorators are a way to add functionality to existing functions without modifying their code.

def uppercase(func):
def wrapper(text):
result = func(text)
return result.upper()
return wrapper
def say_hello(name):
return "Hello, " + name
print(say_hello("John")) # Output: 'HELLO, JOHN'

In this example, the uppercase() function is a decorator that takes a function as an argument and returns a new function that performs the same computation but with the result converted to uppercase. The @uppercase syntax is used to apply the decorator to the say_hello() function. When you call say_hello("John"), the returned value is automatically converted to uppercase.

Returning User-Defined Objects: The Factory Pattern

Sometimes, it can be useful to return instances of user-defined objects from functions. This can be done using the factory pattern, which is a design pattern that allows you to create and return objects in a controlled way.

class Person:
def __init__(self, name, age): = name
self.age = age
def create_person(name, age):
return Person(name, age)
person = create_person("John", 30)
print( # Output: 'John'
print(person.age) # Output: 30

In this example, the create_person() function creates a new instance of the Person class and returns it. The returned object can then be used to access the attributes of the person, such as their name and age.

Using return in try … finally Blocks

Python allows you to use the return statement inside a try ... finally block. The finally block is always executed, regardless of whether an exception occurred or not. If a return statement is encountered inside the try block, the finally block is executed before the function returns.

def divide(a, b):
result = a / b
return result
print("Finally block executed")
print(divide(4, 2)) # Output: 2.0
print(divide(4, 0)) # Output: ZeroDivisionError: division by zero

In this example, the divide() function attempts to divide a by b inside the try block. If the division is successful, the result is returned and the finally block is executed. If an exception occurs, the finally block is still executed before the exception is raised.

Using return in Generator Functions

Generator functions are a special kind of functions in Python that allow you to define an iterator. They use the yield keyword instead of the return statement to define the values that are produced. When the iterator is used, the function is executed until a yield statement is encountered, at which point the value is “yielded” and can be used by the caller.

def count_up_to(n):
i = 1
while i <= n:
yield i
i += 1
for number in count_up_to(5):
# Output: 1
# 2
# 3
# 4
# 5

In this example, the count_up_to() function is a generator function that yields the numbers from 1 to n. When the generator is used in a for loop, each number is produced and printed to the console.


The return statement is a powerful tool in Python that allows you to send values back to the caller code from functions. It’s important to understand how to use the return statement effectively and follow best practices to write clean and readable code. By mastering the return statement, you can write more efficient and elegant functions in Python.