类的前向声明？

Question

我有一些类看起来像这样：

class Base: 
    subs = [Sub3,Sub1] 
    # Note that this is NOT a list of all subclasses! 
    # Order is also important 

class Sub1(Base): pass 
class Sub2(Base): pass 
class Sub3(Base): pass 
... 

现在，这是因为Sub1的和Sub3中时Base.subs是没有定义失败。但显然我不能在Base之前放置子类。有没有办法在Python中转发声明类？我想与isinstance一起工作，因此subs中的类型实际上必须与后面声明的子类相同，它们具有相同的名称和其他属性是不够的。

一种解决方法是：Base.subs = [Sub3,Sub1]之后的子类已被定义，但我不喜欢必须以这种方式拆分我的类。

编辑：约为了

Answer 1

这里的本质@Ignacio巴斯克斯 - 艾布拉姆斯和它保留在列表中的子类的顺序@ aaronasterling的回答混合动力版。最初所期望的子类名称（即字符串）被手动放置在subs列表中所需的顺序，那么作为每个子类被定义，类装饰导致相应的字符串以与实际子类所取代：

class Base(object): # New-style class (i.e. explicitly derived from object). 

    @classmethod 
    def register_subclass(cls, subclass): 
     """ Class decorator for registering subclasses. """ 

     # Replace any occurrences of the class name in the class' subs list. 
     # with the class itself. 
     # Assumes the classes in the list are all subclasses of this one. 
     # Works because class decorators are called *after* the decorated class' 
     # initial creation. 
     while subclass.__name__ in cls.subs: 
      cls.subs[cls.subs.index(subclass.__name__)] = subclass 

     return cls # Return modified class. 

    subs = ['Sub3', 'Sub1'] # Ordered list of subclass names. 


@Base.register_subclass 
class Sub1(Base): pass 

@Base.register_subclass 
class Sub2(Base): pass 

@Base.register_subclass 
class Sub3(Base): pass 

print('Base.subs: {}'.format(Base.subs)) 
# Base.subs: [<class '__main__.Sub3'>, <class '__main__.Sub1'>] 

更新

完全一样的东西也可以用做一个元类，它不过它有它消除了如在头顶显示（你接受）我原来的答案，需要明确地装点每个子类的优势，这一切都是自动发生的。请注意，即使元类'__init__()被称为创建每个子类，它只会更新subs列表，如果子类的名称出现在其中 - 所以subs列表的内容的初始基类定义仍然控制什么获取取而代之（维持秩序）。

class BaseMeta(type): 

    def __init__(cls, name, bases, classdict): 
     if classdict.get('__metaclass__') is not BaseMeta: # Metaclass instance? 
      # Replace any occurrences of a subclass' name in the class being 
      # created the class' sub list with the subclass itself. 
      # Names of classes which aren't direct subclasses will be ignored. 
      while name in cls.subs: 
       cls.subs[cls.subs.index(name)] = cls 

     # Chain to __init__() of the class instance being created after changes. 
     # Note class instance being defined must be new-style class. 
     super(BaseMeta, cls).__init__(name, bases, classdict) 


# Python 2 metaclass syntax. 
class Base(object): # New-style class (derived from built-in object class). 
    __metaclass__ = BaseMeta 
    subs = ['Sub3', 'Sub1'] # Ordered list of subclass names. 

# Python 3 metaclass syntax. 
#class Base(metaclass=BaseMeta): 
# subs = ['Sub3', 'Sub1'] # Ordered list of subclass names. 


# Note: No need to manually register the (direct) subclasses. 
class Sub1(Base): pass 
class Sub2(Base): pass 
class Sub3(Base): pass 

print('Base.subs: {}'.format(Base.subs)) 

它重要的是要注意，有两个答案，即之间至少有一个微妙的不同之处在于，首先会与的工作，通过@Base.register_subclass()注册任何类的名字，不管是不是其实际的子类Base（虽然这也许可以改变/修复。）

我指出这一点的一对夫妇的原因：一是因为在你的意见，你说subs在列表中的“一堆班，一些这可能是其子类“，更重要的是，因为这是而不是我的更新中的代码的情况下，它只适用于Base子类，因为它们实际上通过元类自动“注册” - 但会在列表中单独留下任何其他内容。这可以被视为一个错误或功能。​​

Answer 2

编辑补充信息：由于订单的增加要求的我完全重新设计我的答案。我也使用了一个类装饰器，这个在这里首先由@Ignacio Vazquez-Abrams使用。

EDIT2：代码现在测试，其中一些愚蠢小幅修正

class Base(object): 
    subs = [] 

    @classmethod 
    def addsub(cls, before=None): 
     def inner(subclass): 
      if before and before in cls.subs: 
       cls.subs.insert(cls.subs.index(before), subclass) 
      else: 
       cls.subs.append(subclass) 
      return subclass 
     return inner 

@Base.addsub() 
class Sub1(Base): 
    pass 

class Sub2(Base): 
    pass 

@Base.addsub(before=Sub1) 
class Sub3(Base): 
    pass 

Answer 3

写一个装饰，它添加到注册表中Base。

class Base(object): 
    subs = [] 

    @classmethod 
    def addsub(cls, scls): 
    cls.subs.append(scls) 

... 

@Base.addsub 
class Sub1(Base): 
    pass 

class Sub2(Base): 
    pass 

@Base.addsub 
class Sub3(Base): 
    pass 

Answer 4

class Foo: 
    pass 

class Bar: 
    pass 

Foo.m = Bar() 
Bar.m = Foo() 

Answer 5

我也只是定义了子类为字符串，并有必然的装饰与他们的名字的类更换琴弦。我还会在元类上定义装饰器，因为我认为这更符合目标：我们修改类行为，就像通过修改类修改对象行为一样，通过修改元类来修改类行为。

class BaseMeta(type): 

    def register(cls, subcls): 
     try: 
      i = cls.subs.index(subcls.__name__) 
     except ValueError: 
      pass 
     else: 
      cls.subs[i] = subcls 
     finally: 
      return cls 


class Base(object): 
    __metaclass__ = BaseMeta 
    subs = ['Sub3', 'Sub1'] 

@Base.register 
class Sub1(Base): pass 

@Base.register 
class Sub2(Base): pass 

@Base.register 
class Sub3(Base): pass 

print Base.subs 

此输出：

[<class '__main__.Sub3'>, <class '__main__.Sub1'>] 

Answer 6

我很确定这应该适合你。之后只需指定依赖的类属性。 这也不复杂。

class Base:pass 

class Sub1(Base): pass 
class Sub2(Base): pass 
class Sub3(Base): pass 

Base.subs = [Sub3,Sub1] 
print(Sub1.subs) 
#[<class __main__.Sub3 at 0x0282B2D0>, <class __main__.Sub1 at 0x01C79810>] 

Answer 7

没有办法直接宣布在Python向前引用，但有几个解决方法，其中的一些是合理的：

1）添加它们被定义后，手动的子类。

- Pros: easy to do; Base.subs is updated in one place 
    - Cons: easy to forget (plus you don't want to do it this way) 

实施例：

class Base(object): 
    pass 

class Sub1(Base): 
    pass 

class Sub2(Base): 
    pass 

class Sub3(Base): 
    pass 

Base.subs = [sub3, sub1] 

2）创建Base.subs与str值，并使用class decorator来代替实际的亚类（这可以是在基类方法或函数 - I显示功能版本，但我可能会使用方法版本）。

- Pros: easy to do 
- Cons: somewhat easy to forget; 

实施例：

def register_with_Base(cls): 
    name = cls.__name__ 
    index = Base.subs.index(name) 
    Base.subs[index] = cls 
    return cls 

class Base(object): 
    subs = ['Sub3', 'Sub1'] 

@register_with_Base 
class Sub1(Base): 
    pass 

class Sub2(Base): 
    pass 

@register_with_Base 
class Sub3(Base): 
    pass 

）创建Base.subs与str值，并且有一个使用Base.subs做替代的方法。

- Pros: no extra work in decorators, no forgetting to update `subs` later 
- Cons: small amount of extra work when accessing `subs` 

例子：

class Base(object): 
    subs = ['Sub3', 'Sub1'] 
    def select_sub(self, criteria): 
     for sub in self.subs: 
      sub = globals()[sub] 
      if #sub matches criteria#: 
       break 
     else: 
      # use a default, raise an exception, whatever 
     # use sub, which is the class defined below 

class Sub1(Base): 
    pass 

class Sub2(Base): 
    pass 

class Sub3(Base): 
    pass 

我会用选项我自己，因为它使功能性和数据在同一个地方。你唯一需要做的就是保持subs为最新版本（当然写下适当的子类）。