Python：如何获取在另一个模块中定义的所有局部变量

Question

Is there a way to get a reference to the local variables defined in a different module?

for example, I have two files: framework.py and user_code.py:

framework.py:

from kivy.app import App

class BASE_A:
    pass

class MyApp(App):
    def on_start(self):
        '''Here I'd like to get a reference to sub-classes of BASE_A and
        instantiated objects of these sub-classes, defined in the file
        "user_code.py" such as a1, a2, as well as the class A itself,
        without explicitly passing them to MyApp's instance.
        '''

user_code.py:

from framework import MyApp

class A(BASE_A):
    pass

app = MyApp()
a1 = A()
a2 = A()

app.run()

What I'd like to do is to somehow get a reference to the objects a1 and a2 , as well as the class A , that were all defined in user_code.py . I'd like to use them in the method on_start , which is invoked in app.run() .

Is it possible, for example, to get a reference to the scope in which the MyApp object was defined (user_code.py)?

Some background for anyone who's interested:

I know it's a bit of an odd question, but the reason is:

I'm writing a python framework for creating custom-made GUI control programs for self-made instruments, based on Arduino. It's called Instrumentino (sitting in GitHub ) and I'm currently developing version 2.

For people to use the framework, they need to define a system description file ( user_code.py in the example) where they declare what parts they're using in their system (python objects), as well as what type of actions the system should perform (python classes).

What I'm trying to achieve is to automatically identify these objects and classes in MyApp's on_start without asking the user to explicitly pass these objects and classes, in order to make the user code cleaner. Meaning to avoid code such as:

app.add_object(a1)
app.add_object(a2)
app.add_class(A)

Answer 1

New-style classes in Python have a method named __subclasses__ which returns a list of all direct subclasses that have been defined so far. You can use that to get a hold of the A class in your example, just call BASE_A.__subclasses__() (if you're using Python 2, you'll also need to change BASE_A to inherit from object ). See this question and its answers for more details (especially the functions to recursively get all subclasses).

As for getting access to the instances, for that you probably should add some code to the base class, perhaps saving the instances created by __new__ into some kind of data structure (eg a weakset ). See this question and its answers for more on that part. Actually, now that I think about it, if you put your instances into a centralized data structure somewhere (eg not in an attribute of each subclass), you might not need the function to search for the classes, since you can just inspect the type of the instances and find the subclasses that are being used.

Answer 2

Your question is a bit illogical.

Since Python interprets the code sequentially: b is not defined before a initialization .

If you can set b before a then:

b = None # global variable

class A():
    global b
    def __init__(self):
        '''Here I'd like to get a reference to b (of type B) without passing it as an argument'''

class B_BASE():
    pass

class B(B_BASE):
    def __init__(self):
        pass

if __name__ == '__main__':
    b = B()
    a = A()

I wouldn't recommend doing this because I find that this isn't clean. Since you have a dependency on b in a you should pass it as a parameter to the A class