这种类型的属性值/函数检查，Python中的代码味道？

Question

注：这是crossposted在代码审查，按照建议

前提：我有一个类层次结构（蟒蛇），其中tidy是方法之一。它删除类型为ASTIgnore的节点，并将该节点的子节点重新绑定到其父节点。

目标节点不能自行删除，而不是请参阅其父项（用于重新绑定）。因此，目标（ASTIgnore类型）的删除将在其父母处发生，其中父母检查其子女的类型。

问题：这将如何实现以减少代码异味？

其中哪些方法最不好，还是有其他方法？（见底部）？

# A) 
if child.nodetype == "ASTIgnore": 

# B) 
if child.isIgnored(): 

# C) 
if child.isIgnoreType: 

# D) 
if isinstance(child, ASTIgnore): 

其中，类和tidy看起来像下面。基于最干净的实施，我将删除冗余。

class ASTNode(object): 
    def __init__(self): 
     self.nodetype = self.__class__.__name__ 
     self.isIgnoreType = False 

    def isIgnored(self): 
     return False 

    def tidy(self): 
     # Removes "Ignore" type/attribute nodes while maintaining hierarchy 
     if self.children: 
      for child in self.children: 
       child.tidy() 

      for i, child in reversed(list(enumerate(self.children))): 
       #--------- Is this Bad? ---------- 
       if child.nodetype == "ASTIgnore": 
       #------ -------------------------- 
        if not child.children: 
         # leaf node deletion 
         self.children.pop(i) 
        else: 
         # target node deletion + hierarchy correction 
         grandkids = child.children 
         self.children[i:i+1] = grandkids 


class ASTIgnore(ASTNode): 
    def __init__(self): 
     ASTNode.__init__() 
     self.isIgnoreType = True 

    def isIgnored(self): 
     return True 

鸭打字的事项，推荐给不-ASK政策：

我是新来的Python，并希望成为一个Python的编码器（和一般的更好的编码器）。因此，

我如何鸭型以上？检查属性值（igIgnoreType）/函数（isIgnored）是否被认为是Duck Typing如果属性/函数从未被触及超出对象构造？

我确实有另一个实现，其中tidy过载忽略类型节点。 没有更多的类型检查，但父母仍然必须删除目标孩子，并rebind孙子。在这里，忽略类型返回它们的子节点，对于叶子节点将会是[]。但是，仍然会检查回报是否为None。我相信这肯定是鸭子打字，但是检查None和代码复制，代码错误？

class ASTNode(object): 
    def tidy(self): 
     for i, child in reversed(list(enumerate(self.children))): 
      grandkids = child.tidy() 
      if grandkids is not None: 
       self.children[i:i+1] = grandkids 

     return None 

class ASTIgnore(ASTNode): 
    def tidy(self): 
     for i, child in reversed(list(enumerate(self.children))): 
      grandkids = child.tidy() 
      if grandkids is not None: 
       self.children[i:i+1] = grandkids 

     return self.children 

_edit0

基于Eric's投票，一个isIgnored()功能检查的实施将看起来像

def tidy(self): 
    """ 
    Clean up useless nodes (ASTIgnore), and rebalance the tree 
    Cleanup is done bottom-top 
     in reverse order, so that the deletion/insertion doesn't become a pain 
    """ 
    if self.children: 
     # Only work on parents (non-leaf nodes) 
     for i, child in reversed(list(enumerate(self.children))): 
      # recurse, so as to ensure the grandkids are clean 
      child.tidy() 

      if child.isIgnored(): 
       grandkids = child.children 
       self.children[i: i + 1] = grandkids 

Answer 1

我认为使用从tidy方法的返回值是一个好办法在你的节点之间传递信息。无论如何，你要给每个孩子打电话tidy，所以得到一个返回值，告诉你如何处理这个孩子，这使得整个代码更简单。

你能避免使用super从派生类中调用基类的实现，而只是改变返回值重复自己：

class ASTIgnore(ASTNode): 
    def tidy(self): 
     super().tidy() # called for the side-effects, return value is overridden 
     return self.children 

如果你使用的是Python 2，其中super是一点点不像Python 3那么神奇，你需要使用super(ASTIgnore, self)而不是super()。