我们从Python开源项目中，提取了以下26个代码示例，用于说明如何使用ast.comprehension()。
def test_base_classes(self): self.assertTrue(issubclass(ast.For, ast.stmt)) self.assertTrue(issubclass(ast.Name, ast.expr)) self.assertTrue(issubclass(ast.stmt, ast.AST)) self.assertTrue(issubclass(ast.expr, ast.AST)) self.assertTrue(issubclass(ast.comprehension, ast.AST)) self.assertTrue(issubclass(ast.Gt, ast.AST))
def _check_comprehension(self, fac): self.expr(fac([]), "comprehension with no generators") g = ast.comprehension(ast.Name("x", ast.Load()), ast.Name("x", ast.Load()), []) self.expr(fac([g]), "must have Store context") g = ast.comprehension(ast.Name("x", ast.Store()), ast.Name("x", ast.Store()), []) self.expr(fac([g]), "must have Load context") x = ast.Name("x", ast.Store()) y = ast.Name("y", ast.Load()) g = ast.comprehension(x, y, [None]) self.expr(fac([g]), "None disallowed") g = ast.comprehension(x, y, [ast.Name("x", ast.Store())]) self.expr(fac([g]), "must have Load context")
def _simple_comp(self, fac): g = ast.comprehension(ast.Name("x", ast.Store()), ast.Name("x", ast.Load()), []) self.expr(fac(ast.Name("x", ast.Store()), [g]), "must have Load context") def wrap(gens): return fac(ast.Name("x", ast.Store()), gens) self._check_comprehension(wrap)
def test_dictcomp(self): g = ast.comprehension(ast.Name("y", ast.Store()), ast.Name("p", ast.Load()), []) c = ast.DictComp(ast.Name("x", ast.Store()), ast.Name("y", ast.Load()), [g]) self.expr(c, "must have Load context") c = ast.DictComp(ast.Name("x", ast.Load()), ast.Name("y", ast.Store()), [g]) self.expr(c, "must have Load context") def factory(comps): k = ast.Name("x", ast.Load()) v = ast.Name("y", ast.Load()) return ast.DictComp(k, v, comps) self._check_comprehension(factory)
def visit_Call(self, node): if node.func.id not in GRP_FUNCS: return node else: self.generic_visit(node) return ast.Call( func=node.func, args=[ ast.ListComp( elt=node.args[0], generators=[ ast.comprehension( target=ast.Name(id="datarow", ctx=ast.Store(), lineno=0, col_offset=0), iter=ast.Name(id="data", ctx=ast.Load(), lineno=0, col_offset=0), ifs=[], lineno=0, col_offset=0 ) ], lineno=0, col_offset=0, ) ], keywords=[], ctx=ast.Load(), lineno=0, col_offset=0, )
def addBinding(self, node, value): """ Called when a binding is altered. - `node` is the statement responsible for the change - `value` is the new value, a Binding instance """ # assert value.source in (node, node.parent): for scope in self.scopeStack[::-1]: if value.name in scope: break existing = scope.get(value.name) if existing and not self.differentForks(node, existing.source): parent_stmt = self.getParent(value.source) if isinstance(existing, Importation) and isinstance(parent_stmt, ast.For): self.report(messages.ImportShadowedByLoopVar, node, value.name, existing.source) elif scope is self.scope: if (isinstance(parent_stmt, ast.comprehension) and not isinstance(self.getParent(existing.source), (ast.For, ast.comprehension))): self.report(messages.RedefinedInListComp, node, value.name, existing.source) elif not existing.used and value.redefines(existing): self.report(messages.RedefinedWhileUnused, node, value.name, existing.source) elif isinstance(existing, Importation) and value.redefines(existing): existing.redefined.append(node) if value.name in self.scope: # then assume the rebound name is used as a global or within a loop value.used = self.scope[value.name].used self.scope[value.name] = value
def handleNodeStore(self, node): name = getNodeName(node) if not name: return # if the name hasn't already been defined in the current scope if isinstance(self.scope, FunctionScope) and name not in self.scope: # for each function or module scope above us for scope in self.scopeStack[:-1]: if not isinstance(scope, (FunctionScope, ModuleScope)): continue # if the name was defined in that scope, and the name has # been accessed already in the current scope, and hasn't # been declared global used = name in scope and scope[name].used if used and used[0] is self.scope and name not in self.scope.globals: # then it's probably a mistake self.report(messages.UndefinedLocal, scope[name].used[1], name, scope[name].source) break parent_stmt = self.getParent(node) if isinstance(parent_stmt, (ast.For, ast.comprehension)) or ( parent_stmt != node.parent and not self.isLiteralTupleUnpacking(parent_stmt)): binding = Binding(name, node) elif name == '__all__' and isinstance(self.scope, ModuleScope): binding = ExportBinding(name, node.parent, self.scope) else: binding = Assignment(name, node) self.addBinding(node, binding)
def _peval_comprehension_generators(state, generators, ctx): if len(generators) == 0: return state, [] generator = generators[0] next_generators = generators[1:] state, iter_result = _peval_expression(state, generator.iter, ctx) masked_bindings = _get_masked_bindings(generator.target, ctx.bindings) masked_ctx = ctx.set('bindings', masked_bindings) state, ifs_result = _peval_comprehension_ifs(state, generator.ifs, masked_ctx) if is_known_value(ifs_result): success, bool_value = try_call(bool, args=(ifs_result.value,)) if success and bool_value: ifs_result = [] state, new_generator_kwds = map_reify( state, dict(target=generator.target, iter=iter_result, ifs=ifs_result)) new_generator = ast.comprehension(**new_generator_kwds) state, new_generators = _peval_comprehension_generators(state, next_generators, ctx) return state, [new_generator] + new_generators
def _visit_For(self, node): if not isinstance(node.target, ast.Name): return # for i in (1, 2, 3): ... if not isinstance(node.iter, ast.Constant): return iter_value = node.iter.value if not isinstance(iter_value, tuple): return if not(1 <= len(iter_value) <= self.config.unroll_loops): return # don't optimize if 'break' or 'continue' is found in the loop body found = None def find_callback(node): nonlocal found found = node return False # FIXME: restrict this the current scope # (don't enter class/function def/list comprehension/...) visitor = FindNodes(CANNOT_UNROLL, find_callback) visitor.visit(node) if found is not None: self.log(node, "cannot unroll loop: %s is used at line %s", compact_dump(found), found.lineno) return name = node.target.id body = node.body # replace 'for i in (1, 2, 3): body' with... new_node = [] for value in node.iter.value: value_ast = self.new_constant(node.iter, value) if value_ast is None: return # 'i = 1' name_ast = ast.Name(id=name, ctx=ast.Store()) copy_lineno(node, name_ast) assign = ast.Assign(targets=[name_ast], value=value_ast) copy_lineno(node, assign) new_node.append(assign) # duplicate 'body' new_node.extend(body) if node.orelse: new_node.extend(node.orelse) self.log(node, "unroll loop (%s iterations)", len(node.iter.value)) return new_node
