如何使两个函数共享相同的非全局变量（Python）

Question

Is there a way to make function B to be able to access a non global variable that was declared in only in function A, without return statements from function A.

As asked, the question:

Define two functions:

• p : prints the value of a variable

• q : increments the variable

  such that

• Initial value of the variable is 0. You can't define the variable in the global enviroment.
• Variable is not located in the global environment and the only way to change it is by invoking q() .

• The global enviroment should know only p() and q() .

  Tip: 1) In python, a function can return more than 1 value. 2) A function can be assigned to a variable.

# Example:
>>> p()
0
>>> q()
>>> q()
>>> p()
2

Answer 1

Using the tips provided as clues, it could be done something like this:

def make_p_and_q():
    context = {'local_var': 0}

    def p():
        print('{}'.format(context['local_var']))

    def q():
        context['local_var'] += 1

    return p, q

p, q = make_p_and_q()

p()  # --> 0
q()
q()
p()  # --> 2

Answer 2

The question says the global enviroment should know only p and q .

So, taking that literally, it could be done inline using a single function scope:

>>> p, q = (lambda x=[0]: (lambda: print(x[0]), lambda: x.__setitem__(0, x[0] + 1)))()
>>> p()
0
>>> q()
>>> q()
>>> p()
2

Answer 3

The collection of things that functions can access is generally called its scope . One interpretation of your question is whether B can access a "local variable" of A ; that is, one that is defined normally as

def A():
    x = 1

The answer here is "not easily": Python lets you do a lot, but local variables are one of the things that are not meant to be accessed inside a function.

I suspect what your teacher is getting at is that A can modify things outside of its scope, in order to send information out without sending it through the return value. (Whether this is good coding practise is another matter.) For example, functions are themselves Python objects, and you can assign arbitrary properties to Python objects, so you can actually store values on the function object and read them from outside it.

def a():
    a.key = "value"
a()
print a.key

Introspection and hacking with function objects

In fact, you can sort of get at the constant values defined in A by looking at the compiled Python object generated when you define a function. For example, in the example above, "value" is a constant, and constants are stored on the code object:

In [9]: a.func_code.co_consts
Out[9]: (None, 'value')

This is probably not what you meant.

Answer 4

Firstly, it's bad practise to do so. Such variables make debugging difficult and are easy to lose track of, especially in complex code.

Having said that, you can accomplish what you want by declaring a variable as global:

def funcA():
   global foo
   foo = 3

def funcB():
   print foo # output is 3

Answer 5

That's one weird homework assignment; especially the tips make me suspect that you've misunderstood or left out something.

Anyway, here's a simpler solution than the accepted answer: Since calls to q increment the value of the variable, it must be a persistent ("static") variable of some sort. Store it somewhere other than the global namespace, and tell p about it. The obvious place to store it is as an attribute of q :

def q():
    q.x += 1

q.x = 0  # Initialize

def p():
    print(q.x)