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

Question

我想制作一个通用模块，可以将对象转换为 JSON 格式，将其保存到文本文件中，然后重新加载它们。
下面是伪代码的解释
保存时，它需要一个对象(复制它以不损坏由自定义类方法创建的原始对象)并遍历所有属性。
如果属性是提供的要跳过的键列表中的值，则删除该属性
如果属性是可迭代的，它会对其进行迭代以查看它是否具有其他可迭代对象或类对象
如果来自可迭代对象或属性的值是类对象，它会在该对象上运行此保存函数
最后它返回一个带有两个键的字典，“id”:“类对象类型的名称”和“data”:“所有属性作为对应数据键的字典”
这被转换为字符串并保存到文件中
加载时##问题出在哪里##
它接受字符串并转换回字典。它接受“id”并尝试使用 globals()[dict["id"]]() 创建该类的实例
这就是问题的来源。因为我将此模块导入到其他地方的主代码中，所以当调用 globals 时，它获取的是模块的全局变量，而不是主程序，据我所知，没有办法与这个导入的模块共享全局变量。我还有另一种方法吗？或者一些不需要我将所有代码重新定位到我的主代码中的修复？我已经在模块本身中对其进行了测试，它可以 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.