我们从Python开源项目中，提取了以下10个代码示例，用于说明如何使用ast.Node()。
def build_positional_args(self, candidate, callsite): """Attempt to convert the positional and keyword args supplied at the given callsite to the positional args expected by the candidate funcdef. Return a list of ast.Node instances, or raise ValueError if it can't be done. """ if len(callsite.args) > len(candidate.args.args): raise ValueError('too many positional arguments') slots = {} for idx, arg in enumerate(callsite.args): slots[idx] = arg for actual_kwarg in get_keywords(callsite): idx = locate_kwarg(candidate, actual_kwarg.arg) if idx in slots: raise ValueError('positional slot %i already filled' % idx) slots[idx] = actual_kwarg.value actual_pos_args = [] for idx in range(len(candidate.args.args)): if idx not in slots: raise ValueError('argument %i not filled' % idx) actual_pos_args.append(slots[idx]) return actual_pos_args
def make_op_name_dict(self): ''' Make a dict whose keys are operators ('+', '+=', etc), and whose values are lists of values of ast.Node.__class__.__name__. ''' d = { '.': ['Attr',], '(*)': ['Call', 'Tuple',], '[*]': ['List', 'Subscript',], '{*}': ['???',], ### 'and': 'BoolOp', ### 'or': 'BoolOp', } for op in ( '+', '-', '*', '/', '%', '**', '<<', '>>', '|', '^', '&', '//', ): d[op] = ['BinOp',] for op in ( '==', '!=', '<', '<=', '>', '>=', 'is', 'is not', 'in', 'not in', ): d[op] = ['Compare',] return d
def transform_ast(self, node): """Apply the AST transformations from self.ast_transformers Parameters ---------- node : ast.Node The root node to be transformed. Typically called with the ast.Module produced by parsing user input. Returns ------- An ast.Node corresponding to the node it was called with. Note that it may also modify the passed object, so don't rely on references to the original AST. """ for transformer in self.ast_transformers: try: node = transformer.visit(node) except InputRejected: # User-supplied AST transformers can reject an input by raising # an InputRejected. Short-circuit in this case so that we # don't unregister the transform. raise except Exception: warn("AST transformer %r threw an error. It will be unregistered." % transformer) self.ast_transformers.remove(transformer) if self.ast_transformers: ast.fix_missing_locations(node) return node
def _get_node_line_end(self, node): """Get the last line of the given node. This function can recurse if the given node is a complex node (like a FunctionDef node). Args: node (ast.Node): a node of the AST Returns: int: the last line of the statements in the given node """ if isinstance(node, ast.Assign): return node.value.lineno elif isinstance(node, ast.FunctionDef): return self._get_node_line_end(node.body[-1])
def make_patterns_dict(self): '''Assign all patterns to the appropriate ast.Node.''' trace = False or self.trace_patterns for pattern in self.general_patterns: ops = self.find_pattern_ops(pattern) if ops: for op in ops: # Add the pattern to op's list. op_names = self.op_name_dict.get(op) for op_name in op_names: aList = self.patterns_dict.get(op_name, []) aList.append(pattern) self.patterns_dict[op_name] = aList else: # Enter the name in self.names_dict. name = pattern.find_s # Special case for 'number' if name == 'number': aList = self.patterns_dict.get('Num', []) aList.append(pattern) self.patterns_dict['Num'] = aList elif name in self.names_dict: g.trace('duplicate pattern', pattern) else: self.names_dict [name] = pattern.repl_s if 0: g.trace('names_dict...') for z in sorted(self.names_dict): print(' %s: %s' % (z, self.names_dict.get(z))) if 0: g.trace('patterns_dict...') for z in sorted(self.patterns_dict): aList = self.patterns_dict.get(z) print(z) for pattern in sorted(aList): print(' '+repr(pattern)) # Note: retain self.general_patterns for use in argument lists.
def generic_visit(self, node): """ This function is called when all other nodes are encountered when traversing the tree. When inheriting form this standard parser, this function will make the parser ignore all nodes that are not relevant. Args: node (ast.Node): The node which is visited. """ pass # This ignore is necessary to keep the parser at base level, also look comment above in # the visit_Module function body.
