Exemple Simple d'utilisation de l'ast.NodeVisitor?

Quelqu'un aurait-il un exemple simple à l'aide de l'ast.NodeVisitor à pied de l'arbre de syntaxe abstraite dans la version 2.6 de Python? La différence entre visite et generic_visit est pas clair pour moi, et je ne trouve aucun exemple à l'aide de google codesearch ou de la plaine google.

InformationsquelleAutor lacker | 2009-10-04

74

ast.visit -- sauf si vous la remplacez, dans une sous-classe, évidemment, lorsqu'il est appelé à visiter un ast.Node de classe foo, les appels self.visit_foo si cette méthode existe, sinon self.generic_visit. Ce dernier, encore dans sa mise en œuvre dans la classe ast lui-même, juste des appels self.visit sur chaque nœud enfant (et n'effectue aucune autre action).

À envisager, par exemple:
```
>>> class v(ast.NodeVisitor):
...   def generic_visit(self, node):
...     print type(node).__name__
...     ast.NodeVisitor.generic_visit(self, node)
... 
```
Ici, nous sommes primordial generic_visit pour imprimer le nom de la classe, mais aussi appelant jusqu'à la classe de base (de sorte que tous les enfants seront également visité). Ainsi, par exemple...:
```
>>> x = v()
>>> t = ast.parse('d[x] += v[y, x]')
>>> x.visit(t)
```
émet:
```
Module
AugAssign
Subscript
Name
Load
Index
Name
Load
Store
Add
Subscript
Name
Load
Index
Tuple
Name
Load
Name
Load
Load
Load
```
Mais supposons que nous n'en avons pas pour Charger nœuds (et les enfants de celle-ci -- si ils avaient tout;-). Alors qu'une simple façon de traiter avec que pourrait être, par exemple:
```
>>> class w(v):
...   def visit_Load(self, node): pass
... 
```
Maintenant, quand nous visite une Charge nœud, visit dépêches, de ne PAS generic_visit plus, mais à notre nouveau visit_Load... ce qui ne veut rien faire du tout. Donc:
```
>>> y = w()
>>> y.visit(t)
Module
AugAssign
Subscript
Name
Index
Name
Store
Add
Subscript
Name
Index
Tuple
Name
Name
```
ou, supposons que nous voulions aussi voir les noms réels pour le Nom de nœuds; alors...:
```
>>> class z(v):
...   def visit_Name(self, node): print 'Name:', node.id
... 
>>> z().visit(t)
Module
AugAssign
Subscript
Name: d
Index
Name: x
Store
Add
Subscript
Name: v
Index
Tuple
Name: y
Name: x
Load
Load
```
Mais, NodeVisitor est une classe, car cela lui permet de stocker des informations pendant une visite. Supposons que tout ce que nous voulons, c'est l'ensemble des noms dans un "module". Ensuite, nous n'avons pas besoin de remplacer generic_visit plus, mais plutôt...:
```
>>> class allnames(ast.NodeVisitor):
...   def visit_Module(self, node):
...     self.names = set()
...     self.generic_visit(node)
...     print sorted(self.names)
...   def visit_Name(self, node):
...     self.names.add(node.id)
... 
>>> allnames().visit(t)
['d', 'v', 'x', 'y']
```
Ce genre de chose est un des plus typiques de cas d'utilisation que celles qui nécessitent des remplacements de generic_visit -- normalement, vous n'êtes intéressé que par quelques types de nœuds, comme nous sommes ici dans le Module et le Nom, donc il nous suffit de remplacer visit_Module et visit_Name et laissez ast visit faire l'envoi en notre nom.
- Merci!!!! - c'est exactement ce que je cherchais.
- vous êtes les bienvenus!
- Génial, j'aimerais comprendre un peu plus la différence entre le compilateur.ast sna ast maintenant...
- Comment puis-je visiter et vous inscrire class à l'aide de NodeVisitor?
InformationsquelleAutor Alex Martelli

En regardant le code dans ast.py il n'est pas difficile de copier coller et de rouler vos propres walker. E. g.

import ast
def str_node(node):
    if isinstance(node, ast.AST):
        fields = [(name, str_node(val)) for name, val in ast.iter_fields(node) if name not in ('left', 'right')]
        rv = '%s(%s' % (node.__class__.__name__, ', '.join('%s=%s' % field for field in fields))
        return rv + ')'
    else:
        return repr(node)
def ast_visit(node, level=0):
    print('  ' * level + str_node(node))
    for field, value in ast.iter_fields(node):
        if isinstance(value, list):
            for item in value:
                if isinstance(item, ast.AST):
                    ast_visit(item, level=level+1)
        elif isinstance(value, ast.AST):
            ast_visit(value, level=level+1)


ast_visit(ast.parse('a + b'))

Imprime

Module(body=[<_ast.Expr object at 0x02808510>])
  Expr(value=BinOp(op=Add()))
    BinOp(op=Add())
      Name(id='a', ctx=Load())
        Load()
      Add()
      Name(id='b', ctx=Load())
        Load()

InformationsquelleAutor ubershmekel

5

generic_visit est appelée lorsqu'une coutume visiteur (c'est à dire visit_Name) ne peut pas être trouvé. Voici un morceau de code que j'ai écrit récemment avec l'ast.NodeVisitor: https://bitbucket.org/pypy/pypy/src/6df19fd2b6df6058daf162100cf7ee4521de5259/py/_code/_assertionnew.py?at=default&fileviewer=file-view-default Il interprète les nœuds de l'AST pour acquérir des informations de débogage sur certains d'entre eux et retombe dans avec generic_visit spécial de la mise en œuvre n'est pas fournie.

InformationsquelleAutor Benjamin Peterson

Vous devez vous connecter pour publier un commentaire.