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: 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.

