我们从Python开源项目中，提取了以下11个代码示例，用于说明如何使用_ast.Compare()。
def visit_Name(self, name): # Display the repr of the name if it's a local variable or # _should_repr_global_name() thinks it's acceptable. locs = ast_Call(self.builtin("locals"), [], []) inlocs = ast.Compare(ast.Str(name.id), [ast.In()], [locs]) dorepr = self.helper("should_repr_global_name", name) test = ast.BoolOp(ast.Or(), [inlocs, dorepr]) expr = ast.IfExp(test, self.display(name), ast.Str(name.id)) return name, self.explanation_param(expr)
def visit_Compare(self, comp): self.push_format_context() left_res, left_expl = self.visit(comp.left) if isinstance(comp.left, (_ast.Compare, _ast.BoolOp)): left_expl = "({0})".format(left_expl) res_variables = [self.variable() for i in range(len(comp.ops))] load_names = [ast.Name(v, ast.Load()) for v in res_variables] store_names = [ast.Name(v, ast.Store()) for v in res_variables] it = zip(range(len(comp.ops)), comp.ops, comp.comparators) expls = [] syms = [] results = [left_res] for i, op, next_operand in it: next_res, next_expl = self.visit(next_operand) if isinstance(next_operand, (_ast.Compare, _ast.BoolOp)): next_expl = "({0})".format(next_expl) results.append(next_res) sym = binop_map[op.__class__] syms.append(ast.Str(sym)) expl = "%s %s %s" % (left_expl, sym, next_expl) expls.append(ast.Str(expl)) res_expr = ast.Compare(left_res, [op], [next_res]) self.statements.append(ast.Assign([store_names[i]], res_expr)) left_res, left_expl = next_res, next_expl # Use pytest.assertion.util._reprcompare if that's available. expl_call = self.helper("call_reprcompare", ast.Tuple(syms, ast.Load()), ast.Tuple(load_names, ast.Load()), ast.Tuple(expls, ast.Load()), ast.Tuple(results, ast.Load())) if len(comp.ops) > 1: res = ast.BoolOp(ast.And(), load_names) else: res = load_names[0] return res, self.explanation_param(self.pop_format_context(expl_call))
def COMPARE_OP(self, instr): op = instr.arg right = self.ast_stack.pop() expr = self.ast_stack.pop() OP = CMP_OPMAP[op] compare = _ast.Compare(left=expr, ops=[OP()], comparators=[right], lineno=instr.lineno, col_offset=0) self.ast_stack.append(compare)
def visit_Assign(self, node): if len(node.targets) > 1: raise SyntaxError("GPUMAP: multiple assignment not supported") target_types = map(lambda target: type(target), node.targets) if tuple in target_types or list in target_types: raise SyntaxError("GPUMAP: No unpacking allowed") target = node.targets[0] # assignment into object field output = "" value = self.visit(node.value) # assignment into variable if isinstance(target, _ast.Name): # assignment into new variable # not sure about the type just yet.. # see if it's a primitive if target.id not in self.local_vars: # binops and boolops return primitives if isinstance(node.value, _ast.Num) or isinstance(node.value, _ast.Compare) or isinstance(node.value, _ast.BinOp) \ or isinstance(node.value, _ast.BoolOp) or isinstance(node.value, _ast.NameConstant): output += "auto " # check if referenced list contains primitives elif isinstance(node.value, _ast.Subscript): list_name = value[:value.find("[")] try: idx = self.func_repr.args.index(list_name) t = self.func_repr.arg_types[idx] item_type = t[t.find("<") + 1: t.find(">")] if item_type in map(lambda t: t.__name__, primitive_map.keys()): output += "auto " else: output += "auto&& " except: raise RuntimeError("THIS SHOULD NEVER HAPPEN") else: # check if it's an existing variable try: idx = self.func_repr.args.index(value) t = self.func_repr.arg_types[idx] if t in primitive_map: output += "auto " else: output += "auto&& " except ValueError: output += "auto&& " self.local_vars[target.id] = None output += self.visit(target) output += " = " + value return output
def visit_FunctionDef(self, node): """ :type node: _ast.FunctionDef """ children = node.body lambda_assign_children = [child for child in children if type(child) == _ast.Assign and len(child.targets) == 1 and type(child.value) == _ast.Compare and (type(child.value.left) == _ast.Tuple or type(child.value.left) == _ast.Name) and all(map(lambda t: type(t) == _ast.Name, getattr(child.value.left, 'elts', [])))] # Support single line lambdas outside of assigns other_children = [child for child in children if child not in lambda_assign_children] for child in other_children: CompareNodeVisitor().visit(child) for assign_type_child in lambda_assign_children: arguments = _transform_function_arguments(assign_type_child.value.left) function_body = assign_type_child.value.comparators[0] if _is_multiline_lambda(function_body): all_statements = function_body.elts return_statement = all_statements[-1] statements = all_statements[0:len(all_statements) - 1] statements = _transform_multiline_assignment_statements(statements) return_statement = _transform_multiline_return_statement(return_statement) assign_target = assign_type_child.targets[0] if type(assign_target) is _ast.Attribute: function_name = assign_target.attr else: function_name = assign_target.id all_transformed_statements = statements + [return_statement] functiondef_object = ast.FunctionDef(args = arguments, body=all_transformed_statements, lineno=assign_type_child.lineno, name=function_name, col_offset=assign_type_child.col_offset, decorator_list=[]) children.insert(0, functiondef_object) assign_type_child.value = ast.Name(id=functiondef_object.name, col_offset=functiondef_object.col_offset, lineno=functiondef_object.lineno, ctx=ast.Load()) else: lambda_ast_transform = ast.Lambda(args=arguments, body=function_body, lineno=assign_type_child.lineno, col_offset = assign_type_child.col_offset) assign_type_child.value = lambda_ast_transform return node
