在python中获取类的类路径或名称空间，即使它是嵌套的

Question

我目前正在用 Python 编写一个可以序列化用户定义类的序列化模块。为此，我需要获取对象的完整名称空间并将其写入文件。然后我可以使用该字符串重新创建对象。

例如假设我们在一个名为A.py的文件中有以下类结构

class B:
    class C:
        pass

现在假设my_klass_string 是字符串"A::B::C"

klasses = my_klass_string.split("::")
if globals().has_key(klasses[0]):   
    klass = globals()[klasses[0]]
else:
    raise TypeError, "No class defined: %s} " % klasses[0]
if len(klasses) > 1:
    for klass_string in klasses:
        if klass.__dict__.has_key(klass_string):
            klass = klass.__dict__[klass_string]
        else:
            raise TypeError, "No class defined: %s} " % klass_string            
klass_obj = klass.__new__(klass)

我可以创建类 C 的实例，即使它位于模块 A 中的类 B 下。 以上代码相当于调用eval(klass_obj = A.B.C.__new__(A.B.C))

注意： 我在这里使用__new__()，因为我正在重构一个序列化对象并且我不想初始化该对象，因为我不知道该类的__init__ 方法采用哪些参数。我想在不调用 init 的情况下创建对象，然后再为其分配属性。

我可以通过任何方式从字符串创建 A.B.C 类的对象。我该如何走另一条路？即使类是嵌套的，如何从该类的实例获取描述类的完整路径的字符串？

Answer 1

你不能得到“给定一个实例的类的完整路径” 类”，因为在 Python 中没有这样的东西。对于 例如，以您的示例为基础：

>>> class B(object):
...     class C(object):
...             pass
... 
>>> D = B.C
>>> x = D()
>>> isinstance(x, B.C)
True

x 的“类路径”应该是什么？ D 还是 B.C？两者都是 同样有效，因此 Python 没有给你任何告诉你的方法 来自另一个。

确实，即使是 Python 的 pickle 模块也无法对对象 x 进行酸洗：

>>> import pickle
>>> t = open('/tmp/x.pickle', 'w+b')
>>> pickle.dump(x, t)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.6/pickle.py", line 1362, in dump
    Pickler(file, protocol).dump(obj)
  ...
  File "/usr/lib/python2.6/pickle.py", line 748, in save_global
   (obj, module, name))
  pickle.PicklingError: Can't pickle <class '__main__.C'>: it's not found as __main__.C

所以，总的来说，除了添加属性，我没有其他选择 到你所有的类（比如_class_path），你的序列化代码会查找它 将类名记录成序列化格式：

class A(object):
  _class_path = 'mymodule.A'
  class B(object):
    _class_path = 'mymodule.A.B'
    ...

您甚至可以使用 some metaclass magic 自动执行此操作（但也可以阅读 the same SO post 中的其他 cmets，了解如果您执行上述 D=B.C 可能适用的警告）。

也就是说，如果您可以将序列化代码限制为 (1) 个实例 新式类，以及 (2) 这些类在 模块的顶层，然后你可以复制 pickle 所做的 （函数save_global 在 Python 的 pickle.py 中的第 730--768 行 2.6)。

想法是每个新样式类都定义属性__name__ 和__module__，它们是扩展为类名的字符串（如 在源代码中找到）和模块名称（如在 sys.modules);通过保存这些，您可以稍后导入模块并 获取类的实例：

__import__(module_name)
class_obj = getattr(sys.modules[module_name], class_name)

Answer 2

你不能，以任何合理的非疯狂方式。我猜你可以找到类名和模块，然后为每个类名验证它是否存在于模块中，如果不存在，则以分层方式遍历模块中确实存在的所有类，直到找到它。

但是由于没有理由拥有这样的类层次结构，所以这不是问题。 :-)

另外，我知道你现在不想在你的工作中听到这个，但是：

跨平台序列化是一个有趣的主题，但是像这样使用对象不太可能很有用，因为目标系统必须安装完全相同的对象层次结构。因此，您必须拥有两个用两种完全等效的不同语言编写的系统。这几乎是不可能的，而且可能不值得麻烦。

例如，您将无法使用 Python 标准库中的任何对象，因为 Ruby 中不存在这些对象。最终结果是您必须创建自己的对象层次结构，最终只使用字符串和数字等基本类型。在这种情况下，您的对象刚刚成为基本原语的包含，然后您也可以使用 JSON 或 XML 序列化所有内容。

Answer 3

我目前正在用 Python 编写一个序列化模块，可以序列化用户定义的类。

不要。标准库已经包含一个。实际上，根据您的计算方式，它至少包括两个（pickle 和 shelve）。

Answer 4

有两种方法可以做到这一点。

解决方案 1

第一个通过垃圾收集器。

B -> __dict__ -> C

这是代码：

>>> class B(object):
    class C(object):
        pass

>>> gc.get_referrers(B.C) # last element in the list
[<attribute '__dict__' of 'C' objects>, <attribute '__weakref__' of 'C' objects>, (<class '__main__.C'>, <type 'object'>), {'__dict__': <attribute '__dict__' of 'B' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'B' objects>, 'C': <class '__main__.C'>, '__doc__': None}] 

>>> gc.get_referrers(gc.get_referrers(B.C)[-1]) # first element in this list
[<class '__main__.B'>, [<attribute '__dict__' of 'C' objects>, <attribute '__weakref__' of 'C' objects>, (<class '__main__.C'>, <type 'object'>), {'__dict__': <attribute '__dict__' of 'B' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'B' objects>, 'C': <class '__main__.C'>, '__doc__': None}]]

>>> gc.get_referrers(gc.get_referrers(B.C)[-1])[0]
<class '__main__.B'>

算法：

1. 搜索具有与 C 相同的__module__ 的类字典
2. 上课，使用'C'属性
3. 如果这个类是嵌套的。 1.递归地做

解决方案 2

使用源文件。使用检查来获取类的行并向上扫描以查找嵌套它的新类。

注意：我不知道在 python 2 中没有干净的方法，但 python 3 提供了一个。