Python return statement

Every function in Python returns something. If the function doesn’t have any return statement, then it returns None.

def print_something(s):
    print('Printing::', s)
output = print_something('Hi')
print(f'A function without return statement returns {output}')

Output:

We can perform some operation in a function and return the result to the caller using the return statement.

def add(x, y):
    result = x + y
    return result
output = add(5, 4)
print(f'Output of add(5, 4) function is {output}')

Output:

We can have expressions also in the return statement. In that case, the expression is evaluated and the result is returned.

def add(x, y):
    return x + y
output = add(5, 4)
print(f'Output of add(5, 4) function is {output}')

Output:

Let’s look at an example where we will return the boolean value of the argument of a function. We will use bool() function to get the boolean value of the object.

def bool_value(x):
    return bool(x)
print(f'Boolean value returned by bool_value(False) is {bool_value(False)}')
print(f'Boolean value returned by bool_value(True) is {bool_value(True)}')
print(f'Boolean value returned by bool_value("Python") is {bool_value("Python")}')

Output:

Let’s look at an example where our function will return the string representation of the argument. We can use the str() function to get the string representation of an object.

def str_value(s):
    return str(s)
print(f'String value returned by str_value(False) is {str_value(False)}')
print(f'String value returned by str_value(True) is {str_value(True)}')
print(f'String value returned by str_value(10) is {str_value(10)}')

Output:

Sometimes we want to convert a number of variables into a tuple. Let’s see how to write a function to return a tuple from a variable number of arguments.

def create_tuple(*args):
    my_list = []
    for arg in args:
        my_list.append(arg * 10)
    return tuple(my_list)
t = create_tuple(1, 2, 3)
print(f'Tuple returned by create_tuple(1,2,3) is {t}')

Output:

Further Reading: Python *args and **kwargs

We can return a function also from the return statement. This is similar to Currying, which is the technique of translating the evaluation of a function that takes multiple arguments into evaluating a sequence of functions, each with a single argument.

def get_cuboid_volume(h):
    def volume(l, b):
        return l * b * h
    return volume
volume_height_10 = get_cuboid_volume(10)
cuboid_volume = volume_height_10(5, 4)
print(f'Cuboid(5, 4, 10) volume is {cuboid_volume}')
cuboid_volume = volume_height_10(2, 4)
print(f'Cuboid(2, 4, 10) volume is {cuboid_volume}')

Output:

We can also return a function that is defined outside of the function with return statement.

def outer(x):
    return x * 10
def my_func():
    return outer
output_function = my_func()
print(type(output_function))
output = output_function(5)
print(f'Output is {output}')

Output:

If you want to return multiple values from a function, you can return tuple, list, or dictionary object as per your requirement. However, if you have to return a huge number of values then using sequence is too much resource hogging operation. We can use yield, in this case, to return multiple values one by one.

def multiply_by_five(*args):
    for arg in args:
        yield arg * 5
a = multiply_by_five(4, 5, 6, 8)
print(a)
# showing the values
for i in a:
    print(i)

Output:

The python return statement is used to return the output from a function. We learned that we can also return a function from another function. Also, expressions are evaluated and then the result is returned from the function.

You can checkout complete python script and more Python examples from our GitHub Repository.