## return, return None, and no return at all?

### Question

Consider three functions:

``````def my_func1():
print "Hello World"
return None

def my_func2():
print "Hello World"
return

def my_func3():
print "Hello World"
``````

They all appear to return None. Are there any differences between how the returned value of these functions behave? Are there any reasons to prefer one versus the other?

2019/08/23
1
399
8/23/2019 3:36:33 PM

On the actual behavior, there is no difference. They all return `None` and that's it. However, there is a time and place for all of these. The following instructions are basically how the different methods should be used (or at least how I was taught they should be used), but they are not absolute rules so you can mix them up if you feel necessary to.

## Using `return None`

This tells that the function is indeed meant to return a value for later use, and in this case it returns `None`. This value `None` can then be used elsewhere. `return None` is never used if there are no other possible return values from the function.

In the following example, we return `person`'s `mother` if the `person` given is a human. If it's not a human, we return `None` since the `person` doesn't have a `mother` (let's suppose it's not an animal or something).

``````def get_mother(person):
if is_human(person):
return person.mother
else:
return None
``````

## Using `return`

This is used for the same reason as `break` in loops. The return value doesn't matter and you only want to exit the whole function. It's extremely useful in some places, even though you don't need it that often.

We've got 15 `prisoners` and we know one of them has a knife. We loop through each `prisoner` one by one to check if they have a knife. If we hit the person with a knife, we can just exit the function because we know there's only one knife and no reason the check rest of the `prisoners`. If we don't find the `prisoner` with a knife, we raise an alert. This could be done in many different ways and using `return` is probably not even the best way, but it's just an example to show how to use `return` for exiting a function.

``````def find_prisoner_with_knife(prisoners):
for prisoner in prisoners:
if "knife" in prisoner.items:
prisoner.move_to_inquisition()
return # no need to check rest of the prisoners nor raise an alert
``````

Note: You should never do `var = find_prisoner_with_knife()`, since the return value is not meant to be caught.

## Using no `return` at all

This will also return `None`, but that value is not meant to be used or caught. It simply means that the function ended successfully. It's basically the same as `return` in `void` functions in languages such as C++ or Java.

In the following example, we set person's mother's name and then the function exits after completing successfully.

``````def set_mother(person, mother):
if is_human(person):
person.mother = mother
``````

Note: You should never do `var = set_mother(my_person, my_mother)`, since the return value is not meant to be caught.

2019/11/18
524
11/18/2019 11:26:25 AM

Yes, they are all the same.

We can review the interpreted machine code to confirm that that they're all doing the exact same thing.

``````import dis

def f1():
print "Hello World"
return None

def f2():
print "Hello World"
return

def f3():
print "Hello World"

dis.dis(f1)
4   0 LOAD_CONST    1 ('Hello World')
3 PRINT_ITEM
4 PRINT_NEWLINE

8 RETURN_VALUE

dis.dis(f2)
9   0 LOAD_CONST    1 ('Hello World')
3 PRINT_ITEM
4 PRINT_NEWLINE

8 RETURN_VALUE

dis.dis(f3)
14  0 LOAD_CONST    1 ('Hello World')
3 PRINT_ITEM
4 PRINT_NEWLINE
8 RETURN_VALUE
``````
2013/03/08

They each return the same singleton `None` -- There is no functional difference.

I think that it is reasonably idiomatic to leave off the `return` statement unless you need it to break out of the function early (in which case a bare `return` is more common), or return something other than `None`. It also makes sense and seems to be idiomatic to write `return None` when it is in a function that has another path that returns something other than `None`. Writing `return None` out explicitly is a visual cue to the reader that there's another branch which returns something more interesting (and that calling code will probably need to handle both types of return values).

Often in Python, functions which return `None` are used like `void` functions in C -- Their purpose is generally to operate on the input arguments in place (unless you're using global data (shudders)). Returning `None` usually makes it more explicit that the arguments were mutated. This makes it a little more clear why it makes sense to leave off the `return` statement from a "language conventions" standpoint.

That said, if you're working in a code base that already has pre-set conventions around these things, I'd definitely follow suit to help the code base stay uniform...

2016/06/09

As other have answered, the result is exactly the same, `None` is returned in all cases.

The difference is stylistic, but please note that PEP8 requires the use to be consistent:

Be consistent in return statements. Either all return statements in a function should return an expression, or none of them should. If any return statement returns an expression, any return statements where no value is returned should explicitly state this as return None, and an explicit return statement should be present at the end of the function (if reachable).

Yes:

``````def foo(x):
if x >= 0:
return math.sqrt(x)
else:
return None

def bar(x):
if x < 0:
return None
return math.sqrt(x)
``````

No:

``````def foo(x):
if x >= 0:
return math.sqrt(x)

def bar(x):
if x < 0:
return
return math.sqrt(x)
``````

https://www.python.org/dev/peps/pep-0008/#programming-recommendations

Basically, if you ever return non-`None` value in a function, it means the return value has meaning and is meant to be caught by callers. So when you return `None`, it must also be explicit, to convey `None` in this case has meaning, it is one of the possible return values.

If you don't need return at all, you function basically works as a procedure instead of a function, so just don't include the `return` statement.

If you are writing a procedure-like function and there is an opportunity to return earlier (i.e. you are already done at that point and don't need to execute the remaining of the function) you may use empty an `return`s to signal for the reader it is just an early finish of execution and the `None` value returned implicitly doesn't have any meaning and is not meant to be caught (the procedure-like function always returns `None` anyway).

2019/12/04

In terms of functionality these are all the same, the difference between them is in code readability and style (which is important to consider)

2018/10/31