# How to Use Return in Python programming?

Posted by Marta on December 18, 2020 Viewed 1220 times In this article, I will explain the use of return in Python and how to use return in python, including examples to help you get a better and more in-depth understanding of this concept.

The return keyword is essential in python and most programming languages, such as java, ruby, c++, etc.

The return concept is related to functions. A function is a set of instructions that perform a specific task labelled with a name. This way, you can call your function over and over, without repeating code. Your function will return the result of a calculation using the return python word.

For instance, let’s say that you write a function to check if a credit card number is valid. To do so, you could use the Luhn Formula. Here are the operations you need to perform sequentially to determine if a card number is valid:

1. Drop the last digit from the number. The last digit is what we want to check against
2. Reverse the numbers
3. Multiply the digits in odd positions (1, 3, 5, etc.) by 2 and subtract 9 to all any result higher than 9
4. Add all the numbers together.
5. The check digit (the last number of the card) is the amount that you would need to add to get a multiple of 10 (Modulo 10)

The code below illustrates how to implement these steps in python:

```def verify_credit_card(card_number):
# Drop the last digit from the number
last_digit = int(card_number[-1])
result_step1 = card_number[:-1]

# Reverse the numbers
result_step2 = result_step1[::-1]

# Multiply the digits in odd positions (1, 3, 5, etc.) by 2
# And subtract 9 to all any result higher than 9
result_step3 = ''
for digit in result_step2:
doubled_digit = int(digit)*2
if(doubled_digit > 9):
doubled_digit = doubled_digit-9
result_step3 = result_step3 + str(doubled_digit)

# Add all the numbers together
result_step4 =0
for digit in result_step3:
result_step4 = result_step4 + int(digit)

# Check if the result of module 10 is equal to the last digit,
# if so, the card number is a valid number
final_result = result_step4 % 10
return final_result == last_digit```

This function uses the return term at line 29 to return a variable containing a boolean value, which indicates if the card number is valid or not. This way, you can assign the calculation result into a variable. Check out the following code:

```is_card1_valid = verify_credit_card('4539797671535063') # Invalid number
is_card2_valid = verify_credit_card('4929817131531581') # Valid number
print(is_card1_valid)
print(is_card2_valid)```

Output:

```False
True```

## What does return do in python?

The return keyword allows you to pass the function result to the piece of caller code. Any variable within the function will disappear or be wiped out from the memory once the function finished its execution. The only part remaining is the value the function passed back using the return statement. See the code example below:

```def function():
variable1 = 2
variable2 = variable1*3
return 4

result = function()
print(result)```

Output:

`4`

The function above will return the value 4, and the variable1 and variable2 values will disappear as soon as the function is finished executing and can’t be accessed. In other words, variable1 and variable2 are only accessible in the function scope, which goes from line 1 to line 4. The only variable that is accessible outside the function scope is the variable passed back using return.

Additionally, the return statement indicates to the program to finish the execution and return the value that goes right after the return. See the code example below:

```def function2(parameter1):
if parameter1>5:
return 1
return 2

variable1 = function2(6)
variable2 = function2(3)
print(variable1)
print(variable2)```

Output:

```1
2```

This function will return two different values and exit at two other places. The first time the function gets called since the parameter is greater than five; the program will exit the function at line 3, returning 3. The program won’t execute line 4. However, next time the function gets called using parameter1=3, the program will exit at line 4, returning 2. As soon as the program finds a return statement, it will leave the function and pass the specified value.

## Return multiple values in python

So far, I have covered the use of return in programming and how to return a single value; however, there are more possibilities. The python return allows you to return multiple values as well. You only need to separate each value by a comma. All values will be returned in a tuple, which you can access by index. See below an example of a function that return multiple values:

```def function3():
var1 = 'value1'
var2 = 'value2'
var3 = 'value3'
return var1, var2, var3

tuple_var = function3()
print(tuple_var)
print(type(tuple_var))```

Output:

```('value1', 'value2', 'value3')
<class 'tuple'>```

The function above will return three values wrapped in a tuple. Another option is using unpacking. This way, you can assign each value to a different variable. See the example below:

```def function3():
var1 = 'value1'
var2 = 'value2'
var3 = 'value3'
return var1, var2, var3

v1, v2, v3 = function3()
print(v1)
print(v2)
print(v3)```

Output:

```value1
value2
value3```

### Return two values in Python

What if you like to return just two values? No problem, the return statement in python allows you to passed back any number of values you prefer. If you would like to give two values, you only need to add the return term and the two values to return separated by a comma. See the example below:

```def function_two_values():
var1 = 'value1'
var2 = 'value2'
return var1, var2

value1, value2 = function_two_values()
print(value1)
print(value2)```

Output:

```'value1'
'value2'```

### Return list in python

You can use the return statement to return any value, including a collection such as a list. To pass a list from a function you need to add the return term followed by the python list. See a simple example below:

```def function4():
list = [1,2,3,4]
return list

result = function4()
print(result)
print(type(result))```

Output:

```[1, 2, 3, 4]
<class 'list'>```

The function above returns a list of numbers. At line 5, I have assigned the result of executing the function, the list, to the variable output `result`. Therefore the variable output contains the list. And last I have printed the outcome to make sure the code works as I expect.

## Return vs. Print

What is the difference between return and print? When should you use return or print? These two statements can be confusing the first time you encounter them. The Print statement displays something on the screen to see the value of a variable is what you expect. Return won’t print anything on the screen. You can use the return to pass back a value from a function. Here is an example that illustrates this difference:

```def display_sum(num1,num2):
total_sum = num1 + num2
print(total_sum)

result = display_sum(2,2)
print(result)```

Output:

```4
None```

The above function is not using return, only printing. Therefore the total is printed on the screen; however, the value is not passed back to the caller code. That’s why the result variable is None. Let’s see an example using return to see the difference:

```def display_sum2(num1,num2):
total_sum = num1 + num2
print(total_sum)

result = display_sum2(2,2)
print(result)```

The function above is nearly the same as the previous one; it also prints the total. However, I have added a return statement. Doing so means the value saved in `total_sum` is passed back to the caller function at line 6, and assigned to the `result` variable.

## Conclusion

To summarise, this article covers the use of return in programming with examples and how to return multiple values using the return statement. Plus, the difference between using return and print. I hope you enjoy the tutorial, and thank you so much for reading and supporting this blog! 🙂

## Recommended Articles

How to Count Occurrences in String in Python

How to Get the day of the week in Python

Python int function – Ultimate Guide

How to Fix Valueerror: too many values to unpack  