识别变量是调用方作用域中的字符串列表

Question

I would like to identify all the lists of strings that the user has defined in their interactive shell.

def lists_of_strings():
    d = dict(globals(), **locals())
    d = {k:v for (k, v) in d.items() if not k.startswith("_") and k != 'In'}
    res = {}
    for k, v in d.items():
        if isinstance(v, list):
            if all(map(lambda x: isinstance(x, str), v)):
                res[k] = v
    return res

When I define this function in my current shell, it works:

>>> lists_of_strings()
{}
>>> mylist = ["a", "b"]
>>> lists_of_strings()
{"mylist": ["a", "b"]}

Now if I move this function in a module mymodule and import it:

>>> from mymodule import lists_of_strings
>>> lists_of_strings()
{}
>>> mylist = ["a", "b"]
>>> lists_of_strings()
{}

The function always returns an empty dictionary. Why is that, and more importantly, can I fix it ?

Some context: I am trying to write a helper in my module to identify suitable variables defined by the user in the current jupyter notebook. My goal would be to ask the user if they want to use those variables as an argument of some pre-defined function.

Answer 1

Python's globals built-in returns the dictionary containing the global variables for the current module . That is a quite nice feature, since "global" variables are not process-wide, and module (and therefore file) wide - allows each module to work as a namespace. That simplifies a lot of work to avoid name clashes in big systems (doubly so if one uses third-party components).

But, yes, there is a way to get by to the global variables of another running context. All Python code is run in context of a frame object - it keeps a reference to the actual bytecode, the local variables, and global variables currently in use. The f_globals attribute of a frame object is actually the same dictionary that is returned by the globals built-in.

So, all you have to do is get a reference to the frame object where the call to your function took place - and this can be done by taking the .f_back attribute of the current frame.

That means your function will work across modules (and upon being imported) if you change it to:

import sys

def lists_of_strings():
    caller_frame = sys._getframe().f_back
    d = dict(caller_frame.f_globals, **caller_frame.f_locals)
    d = {k:v for (k, v) in d.items() if not k.startswith("_") and k != 'In'}
    res = {}
    for k, v in d.items():
        if isinstance(v, list):
            if all(map(lambda x: isinstance(x, str), v)):
                res[k] = v
    return res

That said, it is important to note that not all code needs to make use of frames. If you want to simply know the global variables in a known module, you can just make use of that module's __dict__ attribute:

import math
print (math.__dict__)