Est-il possible de visiter des nœuds en AST Python avec ast.NodeVisitor deux fois ou changer l'ordre de traversée?

Question

NodeVisitor traverse la profondeur AST en premier et ne visite chaque nœud qu'une seule fois, lors de la saisie. Il est donc problématique de faire quelque chose de sérieux avec cela. Est-il possible de changer son comportement par défaut?

Answer 1

Non. Vous devriez écrire votre propre visiteur. La visite récursive de tous les nœuds est assez simple, donc si le module ast ne le fait pas pour vous (et il n'y a rien dans le module pour faire ce que vous voulez, dans ce cas), ce n'est pas si mal de le faire vous même .

Answer 2

Peut-être que quelqu'un sera intéressé par certains esquissée par exemple, comment faire ce qui a été proposé par DSblizzard, donc entendre est mon exemple:

import ast 

class RecursiveVisitor(ast.NodeVisitor): 
    """ example recursive visitor """ 

    def recursive(func): 
     """ decorator to make visitor work recursive """ 
     def wrapper(self,node): 
      func(self,node) 
      for child in ast.iter_child_nodes(node): 
       self.visit(child) 
     return wrapper 

    @recursive 
    def visit_Assign(self,node): 
     """ visit a Assign node and visits it recursively""" 
     print(type(node).__name__) 

    @recursive 
    def visit_BinOp(self, node): 
     """ visit a BinOp node and visits it recursively""" 
     print(type(node).__name__) 

    @recursive 
    def visit_Call(self,node): 
     """ visit a Call node and visits it recursively""" 
     print(type(node).__name__) 

    @recursive 
    def visit_Lambda(self,node): 
     """ visit a Function node """ 
     print(type(node).__name__) 

    @recursive 
    def visit_FunctionDef(self,node): 
     """ visit a Function node and visits it recursively""" 
     print(type(node).__name__) 

    @recursive 
    def visit_Module(self,node): 
     """ visit a Module node and the visits recursively""" 
     pass 

    def generic_visit(self,node): 
     pass 

class SimpleVisitor(ast.NodeVisitor): 
    """ simple visitor for comparison """ 

    def recursive(func): 
     """ decorator to make visitor work recursive """ 
     def wrapper(self,node): 
      func(self,node) 
      for child in ast.iter_child_nodes(node): 
       self.visit(child) 
     return wrapper 

    def visit_Assign(self,node): 
     """ visit a Assign node """ 
     print(type(node).__name__) 

    def visit_BinOp(self, node): 
     """ visit a BinOp node """ 
     print(type(node).__name__) 

    def visit_Call(self,node): 
     """ visit a Call node """ 
     print(type(node).__name__) 

    def visit_Lambda(self,node): 
     """ visit a Function node """ 
     print(type(node).__name__) 

    def visit_FunctionDef(self,node): 
     """ visit a Function node """ 
     print(type(node).__name__) 

    @recursive 
    def visit_Module(self,node): 
     """ visit a Module node and the visits recursively, otherwise you 
     wouldn't see anything here""" 
     pass 

    def generic_visit(self,node): 
     pass 

# usage example 
a = """ 
b= lambda x: x*5 +5 
def hhh(u): 
    b=19 
    return u*b 
m=hhh(9*4+5) 
""" 

recursive_visitor = RecursiveVisitor() 
simple_visitor = SimpleVisitor() 
tree = ast.parse(a) 
print('\nvisit recursive\n') 
recursive_visitor.visit(tree) 
print('\nvisit simple\n') 
simple_visitor.visit(tree) 

quelqu'un Hope peut trouver utile.