Returning Variables in Functions Python Not Working Right

python function not returning value
python function won't return value
how many return statements are allowed in a python function
python return variable from function
python function not returning list
python if function returns value
how to use return value in another function python
python return not exiting function

I have been trying to return a variable in a function in a variable and use it outside of it:

test = 0

def testing():
    test = 1
    return test

testing()
print(test)

But when I run it, the result is 0. How could I fix this problem?


You are messing up a bit the scopes and/or assignment. Try this:

def testing():
    test = 1
    return test

test = testing()
print(test)

Explanation: The test inside testing is different to the test inside the module. You have to assign it on module-level to get the expected result.

Return doesn't work (python), I suspect you are trying to print(y) outside the function. The variable y is local in scope, that is only defined within fpol(). So you can print it there. Returning Variables in Functions Python Not Working Right (5 answers) Closed last year . It seems like I can't pass a value from a function to another even though I have put a return statement in the 1st function.


Because you declare test in the function, it is not a global variable, thus, you can not access the variable test you created in the function outside of it as they are different scopes

If you want to return test to a variable, you have to do

result = testing()
print(result)

Or, you can also add a global statement:

test = 0

def testing():
    global test
    test = 1
    return test

testing()
print(test)

By the way, when doing a conditional statement, you don't need the brackets around the 1==1 :).

Learning with Python 3, But if the function should return a value, make sure all execution paths do return the value. To find the second problem above, consider what happens if you call this function with an It is preferred over this one, which also works correctly:� You need to go back and work through a tutorial about the basics of variable scope, e.g. the difference between local and global variables, as well as how returning values from a function works. You seem to be under the misapprehenesion that returning from a function makes the local variables you returned leak into the caller's (in this case


Inside the function testing(), you're creating a new variable test, not referring to the one that already exists. If you want to do that, you should use a global statement in the top, as in:

def testing():
    global test
    ...etc...

Python "return (variable)" in a function does not output, Basically “return” isn't working. The return function works when I run them through the terminal. As shown below: [code]>>> def greatest(a): All Python functions return the value None unless there is an explicit return statement with a value other than None. Consider the following common mistake made by beginning Python programmers. As you step through this example, pay very close attention to the return value in the local variables listing.


Your test variable inside the function does not have a global scope. So, if you want to store the return value in a variable and output it after that, you can do something like this:

result = testing()
print(result)

8. Global & Return — Python Tips 0.1 documentation, The function above takes two values as input and then output their addition. to solve this problem by returning a tuple , list or dict with the required values after� Python functions can return multiple variables. These variables can be stored in variables directly. A function is not required to return a variable, it can return zero, one, two or more variables. This is a unique property of Python, other programming languages such as C++ or Java do not support this by default.


TLDR: A return value must be assigned to something at the call site.

test = testing()

Functions in Python have their own scope. It is created on entering (calling) the function, and destroyed when leaving it. Assignment to a name inside a scope makes that name local to this scope - causing it to be destroyed along with the scope.

# start outer scope
test = 0  # create name outer:test

def testing():
    # start inner scope
    test = 1  # create name outer.testing:test
    return test
    # end inner scope
    # destroy name outer.testing:test

testing()  # new temporary inner scope outer.testing
print(test)  # use name outer:test
# end outer scope

Notably, names in an inner scope may "shadow" names from an outer scope. While the name test exists in both testing and the outer scope, it does not refer to the same thing. This has two important implications:

  1. The assignment to the inner test does not affect the outer test.
  2. At the end of testing, the inner test is destroyed and only the outer test remains.

This is why calling testing() does not have the desired effect: it never modifies the outer test passed to print.


The return statement defines the value returned by calling a function. It does not return the name, only the value pointed to.

def testing():
    test = 1  # test refers to the value 1
    return test  # return test => value 1

The value returned by a function is like any other value - be it from a literal, lookup, or other. Most importantly, the value does not persist unless you assign it to a name or use it directly.

testing()  # call test, discard its value
test = testing()  # call test, store its value as `test`
print(testing())  # call test, use its value in `print`

So in order to return something from a function for later use, you must store the result to a name. You can then use that name in a later statement. A minimal example for your case looks like this:

# we already can define testing here
# it is overwritten later on, then

def testing():
    # all names we use inside of testing are gone at the end
    # if we just want a value, we can skip temporary names
    return 1

# store the return value of testing() for later use
test = testing()
print(test)

Addendum: It is possible for a function to modify its containing scope. However, names must then be explicitly declared as being from a foreign scope.

The nonlocal and global keywords allow to modify names from outer scopes. A nonlocal is the name in the closest matching function scope. A global is the name at the module scope, regardless of any functions in-between.

test = 0

def increment():
    global test  # declare test as belonging to a specific scope
    test += 1
    # no need to return something
    # we already modified the outer `test`

print(test)  # 0
increment()
print(test)  # 1

Note that modifying outer names is often the sign of an anti-pattern, moreso for globals than nonlocals. Beyond small scripts, it gets difficult to trace what is accessing and modifying globals. Often, it is more appropriate to use classes or generators to hold state.

A function can always read names from its containing scope, provided it never writes to the same name. Such closures are very easy to create, and the lack of modification makes them easier to trace. Note that modifying a name anywhere in a function makes it local, unless declared global or nonlocal:

test = 0

def increment():
    global test
    test += 1

def show_test():
    # we never modify `test`, so it is fetched from the outside
    print(test)

def show_and_increment1():  # this function is broken!
    print(test)  # `test` is *not* the outer one, since we modify it in the function
    test += 1  # modifying `test` makes it local for the *entire* function

def show_and_increment2():  # this function works!
    global test  # force `test` to be global
    print(test)
    test += 1

show_test()  # 0
increment()
show_test()  # 1
show_and_increment2()  # 1
show_and_increment2()  # 2
show_and_increment2()  # 3
show_test()  # 4
show_and_increment1()  # UnboundLocalError: local variable 'test' referenced before assignment

6.2. Functions that Return Values — How to Think like a Computer , Python has a built-in function for computing the absolute value: The problem with this function is that even though it prints the value of the square, that Since line 6 uses the return value as the right hand side of an assignment statement,� By John Paul Mueller . Functions can display data directly in Python or they can return the data to the caller so that the caller can do something more with it. In some cases, a function displays data directly as well as returns data to the caller, but it’s more common for a function to either display the data directly or to return it to the caller.


Python Tutorial: Functions, We will demonstrate the operating principle of default parameters with a simple example. Default values will not be created when a function is called. A return statement ends the execution of the function call and "returns" the result, i.e. the� Further Reading: Python *args and **kwargs. Python function returning another function. 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.


Python Fundamentals Tutorial: Functions, Functions do not have declared return types. A function without an explicit return statement returns None . In the case of no arguments and no return value, the� Python functions can return multiple values. These values can be stored in variables directly. A function is not restricted to return a variable, it can return zero, one, two or more values. This is the default property of python to return multiple values/variables which is not available in many other programming languages like C++ or Java.


Working With Functions: Return Values, Python also has the ability to return multiple values from a function call, something missing from many other languages. In this case the return values should be a� Aloha !! If u r asking that how to call a variable of 1 function into another function , then possible ways are - 1. Make the variable a function attribute 2. Make the variable global 1st way [code]def a(): a.i="variable" # function attribute d