In Python 3.0 a function returns none because a function does not store it’s output unless we use a return statement?

Question

In Python, does a function just execute it's code block & not store it unless we use a return statement?

When we print variables & expressions I understand we are printing values.

So I am thinking that a function performs it's code block & then does not save that result unless we return it? Is this what's happening in the computer?

 Example 1  
def add(a,b):
 nums = a + b

print(add(2,4)+2)
Error

But when we use the return value statement it works

 Example 2
def add(a,b):
 nums = a + b
 return nums

print(add(2,4) + 2)
Output: 8

The error was caused in the first example because the function just executed it's code block & did not save the result therefore resulting in an error due to not being able to add None to an integer(2)? & It worked in example 2 because we saved the functions result with the return statement giving us an integer; Therefore allowing the print statement to print the result of the functions integer + the integer we added it to in the expression?

Answer 1

In python, functions are blocks of code that execute some logic of some sort (sometimes based on arguments passed into them and sometimes not). They are very broad and can do many different kinds of things depending on how they are constructed. I'm not exactly sure what you mean by "store the results" but hopefully some of the following explanation will help.
All variables created in a function are stored with the "local" scope, meaning that they are only existent when the function is running and are deleted the moment the function terminates. For example, in the following code, you cannot access the variable x after the function terminates:

def example():
    x = 'Hello World'
    print(x) #This prints: Hello World
example()
print(x) #This will give you a Reference error 

If that is what you mean by "stores the results" then you are right: those results will not be stored. You can, however, declare a variable inside of a function to be a global variable, meaning that it can be accessed outside of the function too:

def example():
    global x = 'Hello World'
    print(x) #This prints: Hello World
example()
print(x) #This prints: Hello World

When you use the return statement in a function you are just telling the compiler that if a variable is set equal to a function call of said function, whatever follows the return statement is what that variable should be set equal to. However, simply returning a value does not "store" it. See the following code:

def example():
    x = 'Hello World'
    return x
example()
print(x) #This will still cause a reference error
x = example()
print(x) #This prints: Hello World

One final thing to note about the code above: as long as two variables are in different scopes, they can have the same name and not cause an error. The x inside the function is in a local scope and the x outside of the function is in the global scope which is why that does not cause an error.

Answer 2

Welcome to Stack Overflow. When I was learning programming, it helped me to think of calls to functions using an analogy to variables in math. In most languages, you can think of "substituting" the return value in for the function call, the same way you can substitute a literal number into a variable.

In math, you can do this:

m = 4
b = 2

y = m * x + b  # Plug 4 and 2 in for "m" and "b"
y = 4 * x + 2

It's the same with value-returning functions:

def foo():
    return 'bar'

>>> x = foo() # Plug the return value 'bar' in for "foo()"
>>> x
'bar'

In Python, when a function has no explicit return , the default return value is None . So:

def foo():
    print('bar')
    # No return, so Python implicitly returns None

>>> x = foo() # Plug the return value None in for "foo()"
'bar'
>>> x
None

Answer 3

the function define local variable even same name as global variable so when it executed if you don't return something or store the result in global variable the result not appears outside function example

x = 10
def test():
   x= 15
test()
print(x) # result 10

but if use global keyword you can access to global variable like this

x = 10
def test():
   global x
   x= 15
test() 
print(x) #result 15

or if you return the value

x = 10
def test():
  x= 15
  return x
x = test()
print(x) #result 15