python - 从另一个模块访问全局变量

Question

我想制作一个通用模块，可以将对象转换为 JSON 格式，将其保存到文本文件，然后将它们加载回来。

下面是伪代码的解释

保存时，它会获取一个对象(复制它以不损坏原始对象，由自定义类方法创建)并迭代所有属性。

如果该属性是提供的要跳过的键列表中的值，则会删除该属性

如果属性是可迭代的，它会迭代它以查看它是否有其他可迭代或类对象

如果可迭代对象或属性中的值是类对象，则会在该对象上运行此保存函数

最后它返回一个带有两个键的字典，“id”:“类对象类型的名称”和“data”:“所有属性作为相应数据的键的字典”

这被转换为字符串并保存到文件

加载##时问题来自##

它接受字符串并转换回字典。它采用“id”并尝试使用 globals()[dict["id"]]() 创建该类的实例。

这就是问题的根源。因为我将此模块导入到其他地方的主代码中，所以当调用全局变量时，它获取的是模块的全局变量，而不是主程序，并且据我所知，无法与此导入的模块共享全局变量。我还有其他方法可以做到这一点吗？或者一些不需要我将所有代码重新定位到我的主代码中的修复？我已经在模块本身内对其进行了测试，它可以 100% 工作，但在导入时不行。

tl:博士

制作了一个模块，可以将对象保存为 JSON 并可以将它们转换回来，但需要访问正在运行的程序的全局变量。

这是底部带有功能示例的代码。当不以这种方式导入和使用时它会起作用。

import json

def testiter(object): ## tests if an object is iterable
    if isinstance(object, list) or isinstance(object, tuple):
        return True
    else:
        return False
def testclass(object): ## tests if an object is a class object 
    try:
        object.__dict__
        return True
    except:
        return False
class object_clone(): ## creates a clone of a object
    def __init__(self, object, skip):
        self.__class__.__name__ = object.__class__.__name__
        for attr, value in dict(vars(object)).items():
            if not(attr in skip):
                if testiter(value):
                    setattr(self, attr, self.iterable_search(value, skip))
                elif testclass(value):
                    setattr(self, attr, object_clone(value, skip))
                else:
                    setattr(self, attr, value)
    def iterable_search(self, lst, skip):
        ret = []
        for value in lst:
            if testiter(value):
                ret.append(self.iterable_search(value, skip))
            elif testclass(value):
                ret.append(object_clone(value, skip))
            else:
                ret.append(value)
        return ret
class object_save(): ## saves an object
    def save(self, object, skip, path):
        self.skip=skip ## for skipping data that is unsaveable
        open(path, 'w').write(json.dumps(self.semisave(object_clone(object, skip)))) ## clones the given object, writes it in a dict format, saves as json string, then writes to path
    def semisave(self, object):
        for attr, value in dict(vars(object)).items(): ## iterate over class object attributes
            if attr in self.skip: 
                delattr(object, attr) ##remove unsavable
            elif testiter(value):
                setattr(object, attr, self.iterable_search(value)) ## Searches through iterables
            elif testclass(value): ## runs this function on any class objects found
                setattr(object, attr, self.semisave(value))
        return {
            'class_instance':object.__class__.__name__,
            'data':json.loads(json.dumps(vars(object)))} ## json dict of object
    def iterable_search(self, lst):
        ret=[]
        for value in lst:
            if testiter(value):
                ret.append(self.iterable_search(value)) ## Searches through nested iterables
            elif testclass(value):
                ret.append(self.semisave(value)) ## converts found class objects to dict
            else:
                ret.append(value) ## skips other data
        return ret
class object_load():
    def load(self, path):
        json.loads(open(path, 'r').read()) ## loads saved string and converts to dict
        return self.semiload(json.loads(open(path, 'r').read()))
    def semiload(self, json):
        try:
            [print(key, name) for key, name in globals().items()] ##issue here##
            ret = globals()[json['class_instance']]()
        except:
            return
        for attr, value in json['data'].items():
            if isinstance(value, dict) and 'class_instance' in value:
                setattr(ret, attr, self.semiload(value))
            elif testiter(value):
                setattr(ret, attr, self.iterable_scan(value))
            else:
                setattr(ret, attr, value)
        return ret
    def iterable_scan(self, lst):
        ret=[]
        for value in lst:
            if isinstance(value, dict) and 'class_instance' in value:
                ret.append(self.semiload(value))
            elif testiter(value):
                ret.append(self.iterable_scan(value))
            else:
                ret.append(value)
        return ret

##example
class foo():
    def __init__(self):
        self.a='test'
        self.b=5
        self.c=['test', 5, [bar()]]
    def print_attr(self):
        [print([attr, value]) for attr, value in vars(self).items()]
class bar():
    def __init__(self):
        self.c=5
        self.e=[[6], 2]
object_save().save(foo(), ['b'], 'a')
object_load().load('a').print_attr()

Answer 1

下面的示例代码用简单的术语说明了如何做你想做的事情的原则。尽管我同意 @Tim Roberts 的观点，即做这样的事情通常是不明智的，但我还是提供了它 - 因为我也相信每条“规则”都有异常(exception)，而且我们都是同意的成年人。

事实上，我很早之前就想出了如何做到这一点，正是在我觉得这样做是合理的情况下。

也就是说，我最喜欢的 C/C++ 编程书籍之一的作者在他的一本书的标题中使用了“足够的绳索搬起石头砸自己的脚”。

sample_vars.json:

{
    "a": "foobar",
    "b": 42
}

main.py:

from make_vars import create_vars

create_vars('sample_vars.json')
print(f'{a=}, {b=}')  # -> a='foobar', b=42

make_vars.py:

import json
import sys

def create_vars(json_filename):
    namespace = sys._getframe(1).f_globals  # Caller's globals

    with open(json_filename) as json_file:
        saved_vars = json.load(json_file)

    namespace.update(saved_vars)  # Create/update caller's globals.