A small question about python's variable scope

Question

I am a beginner of python and have a question, very confusing for me. If I define a function first but within the function I have to use a variable which is defined in another function below, can I do it like this? Or how can I import the return things of another function into a function? for example:

def hello(x,y):
    good=hi(iy,ix)
    "then do somethings,and use the parameter'good'."
    return something

def hi(iy,ix):
    "code"
    return good

Answer 1

your example program works, because the two instances of 'good' are different variables (you just happen to have both variables with the same name). The following code is exactly the same:

def hello(x,y):
    good=hi(iy,ix)
    "then do somethings,and use the parameter'good'."
    return something

def hi(iy,ix):
    "code"
    return great

Answer 2

The scope of functions hello and hi are entirely different. They do not have any variables in common.

Note that the result of calling hi(x,y) is some object. You save that object with the name good in the function hello.

The variable named good in hello is a different variable, unrelated to the variable named good in the function hi.

They're spelled the same, but the exist in different namespaces. To prove this, change the spelling the good variable in one of the two functions, you'll see that things still work.

---

Edit. Follow-up: "so what should i do if i want use the result of hi function in hello function?"

Nothing unusual. Look at hello closely.

def hello(x,y):
    fordf150 = hi(y,x)
    "then do somethings,and use the variable 'fordf150'."
    return something

def hi( ix, iy ):
    "compute some value, good."
    return good

Some script evaluates hello( 2, 3).

1. Python creates a new namespace for the evaluation of hello.

2. In hello, x is bound to the object 2. Binding is done position order.

3. In hello, y is bound to the object 3.

4. In hello, Python evaluates the first statement, fordf150 = hi( y, x ), y is 3, x is 2.

   a. Python creates a new namespace for the evaluation of hi.

   b. In hi, ix is bound to the object 3. Binding is done position order.

   c. In hi, iy is bound to the object 2.

   d. In hi, something happens and good is bound to some object, say 3.1415926.

   e. In hi, a return is executed; identifying an object as the value for hi. In this case, the object is named by good and is the object 3.1415926.

   f. The hi namespace is discarded. good, ix and iy vanish. The object (3.1415926), however, remains as the value of evaluating hi.

5. In hello, Python finishes the first statement, fordf150 = hi( y, x ), y is 3, x is 2. The value of hi is 3.1415926.

   a. fordf150 is bound to the object created by evaluating hi, 3.1415926.

6. In hello, Python moves on to other statements.

7. At some point something is bound to an object, say, 2.718281828459045.

8. In hello, a return is executed; identifying an object as the value for hello. In this case, the object is named by something and is the object 2.718281828459045 .

9. The namespace is discarded. fordf150 and something vanish, as do x and y. The object (2.718281828459045 ), however, remains as the value of evaluating hello.

Whatever program or script called hello gets the answer.

Answer 3

The "hello" function doesn't mind you calling the "hi" function which is hasn't been defined yet, provided you don't try to actually use the "hello" function until after the both functions have been defined.

Answer 4

If you want to define a variable to the global namespace from inside a function, and thereby make it accessible by other functions in this space, you can use the global keyword. Here's some examples

varA = 5   #A normal declaration of an integer in the main "global" namespace

def funcA():
    print varA #This works, because the variable was defined in the global namespace
               #and functions have read access to this.
def changeA():
    varA = 2  #This however, defines a variable in the function's own namespace
              #Because of this, it's not accessible by other functions.
              #It has also replaced the global variable, though only inside this function
def newVar():
    global varB #By using the global keyword, you assign this variable to the global namespace
    varB = 5

def funcB():
    print varB #Making it accessible to other functions

Conclusion: variables defined in a function stays in the function's namespace. It still has access to the global namespace for reading only, unless the variable has been called with the global keyword.

The term global isn't entirely global as it may seem at first. It's practically only a link to the lowest namespace in the file you're working in. Global keywords cannot be accessed in another module.

As a mild warning, this may be considered to be less "good practice" by some.

Answer 5

More details on the python scoping rules are here :

Short Description of Python Scoping Rules