Question

<>代码>_qualname__因地制宜而使我受益;然而,由于:

。在我使用的情况下,我需要提及母物体。

有时返回<代码>超标/代码> 不属于参考类别。例如:

class Parent():

    def __init__(self):
        pass


class Child(Parent):
    pass


print(Child.__init__.__qualname__)  # Prints: "Parent.__init__"

我正在开发的一揽子计划需要坚固,最突出的例子有:_qualname_。 http://www.python.org/dev/peps/pep-3155/“rel=“nofollow noreferer”>。只要我能说的话。

在>parsing ́s with ast, qualname<_/code> be relemented in Zhu__3 with visit? 如何执行<代码>_qualname__? 在执行核心功能时,我认为我能够加以调整,以适应我的使用情况。

<>Prior Research:

PEP 3155: https://www.python.org/dev/peps/pep-3155/
Python 2 qualname implementation: https://github.com/wbolster/qualname/blob/master/qualname.py
Parsing __qualname__ to get references: Get defining class of unbound method object in Python 3
Python 2 __qualname__ stackoverflow: Reproduce effects of Python 3.3 __qualname__ in earlier Pythons

我无法在沙捞越源法中找到执行标语。

Answer 1

你不会得到你想要的东西。请注意:your_thing(Parent.__init__),就Parent 和your_thing(Child.__init__),就Child,但Parent.__init>和Child.__init_均为同一对象。


你用两种不同的方式来查阅,但灰色没有这方面的记录。 无论你执行什么,都只能得到功能标的,而没有你要求的信息。

即使你做一些可怕的ack检查,看看<代码>your_thing(Child.__init__)的源码在其中说“Child”,在功能存放于变数或经过几层功能电话时,就赢得了工作。仅仅因为你在撰写法典时已经掌握了你想要的信息,就一小部分案件而言,这毫无道理。

Answer 2

如果您能够接受使用<代码>Base node的子类的非常规(或累))级分类,则每个属性

class A(BaseNode):
    class a(BaseNode):
        pass
    a = a()


class B(BaseNode):
    class a1(A):
        pass
    a1 = a1()

    class a2(A):
        pass
    a2 = a2()


class C(B):
    class c(BaseNode):
        pass
    c = c()

那么,每个归属者都知道他在级别上的道路名称。 (可通过使用<条码>_init_subclass__(或代号)来简化分类。)

c = C()
assert c._pathname      ==  C 
assert c.c._pathname    ==  C.c 
assert c.a1._pathname   ==  C.a1 
assert c.a1.a._pathname ==  C.a1.a 
assert c.a2._pathname   ==  C.a2 
assert c.a2.a._pathname ==  C.a2.a

每个属性案例都是根据您可在<条码><>/条码>产出上看到的要求设立的。

*** <__main__.C object at 0x7fca81558190>  creates  c  from <class  __main__.C.c >
*** <__main__.C object at 0x7fca81558190>  creates  a1  from <class  __main__.B.a1 >
*** <__main__.B.a1 object at 0x7fca8155b760>  creates  a  from <class  __main__.A.a >
*** <__main__.C object at 0x7fca81558190>  creates  a2  from <class  __main__.B.a2 >
*** <__main__.B.a2 object at 0x7fca8155b490>  creates  a  from <class  __main__.A.a >

。

    class BaseNode:
    def __init__(self, parent=None):
        self._parent = parent

    @property
    def _path(self):
        path = []
        obj = self
        while obj:
            path.append(obj)
            obj = obj._parent
        return path[::-1]

    @property
    def _pathname(self):
        return  . .join(node.__class__.__name__ for node in self._path)

    def __get__(self, obj, cls=None):
        if obj is None:
            return self
        name = self.__class__.__name__
        try:
            inst = obj.__dict__[name]
        except KeyError:
            print(f *** {obj}  creates {name!r} from {self.__class__} )
            inst = self.__class__(obj)
            obj.__dict__[name] = inst
        return inst

The descriptor method __get__() dynamically creates the attributes (= BaseNode instances) on demand.

BTW:欢迎对这种做法的任何评论或改进:

友情链接