10 examples of 'list comprehension python if else' in Python

231
def is_comprehension(x):
232
    """Returns true if this is a comprehension type."""
233
    return isinstance(x, (ObjectComprehension, SetComprehension, ArrayComprehension))

1042
@utils.check_messages("using-constant-test", "missing-parentheses-for-call-in-test")
1043
def visit_comprehension(self, node):
1044
    if node.ifs:
1045
        for if_test in node.ifs:
1046
            self._check_using_constant_test(node, if_test)

45
def create_comprehension(for_node: ast.For) -> ast.comprehension:
46
    return ast.comprehension(target=for_node.target, iter=for_node.iter, ifs=[])

1276
def visit_ComprehensionNode(self, node):
1277
    if node.expr_scope:
1278
        self.env_stack.append(self.env)
1279
        self.env = node.expr_scope
1280
    # Skip append node here
1281
    self._visit(node.loop)
1282
    if node.expr_scope:
1283
        self.env = self.env_stack.pop()
1284
    return node

929
@backtrackable
930
@memoize
931
def parse_comprehension_iter(self):
932
    """
933
    rule =
934
        | comprehension_for
935
        | comprehension_where
936
    """
937
    result = self.parse_comprehension_for()
938
    if result is None:
939
        result = self.parse_comprehension_where()
940
941
    return result

500
def visit_list_comprehension(self, o: 'mypy.nodes.ListComprehension') -> str:
501
    return self.dump([o.generator], o)

446
def visit_comprehension(self, node, parent):
447
    """visit a Comprehension node by returning a fresh instance of it"""
448
    newnode = nodes.Comprehension(parent)
449
    newnode.postinit(
450
        self.visit(node.target, newnode),
451
        self.visit(node.iter, newnode),
452
        [self.visit(child, newnode) for child in node.ifs],
453
        getattr(node, "is_async", None),
454
    )
455
    return newnode

466
def p_if_stmt(p):
467
    'if_stmt : IF test COLON suite'
468
    p[0] = ast.If([(p[2], p[4])], None)

126
@abstractmethod
127
def visit_list_comprehension(self, o: 'mypy.nodes.ListComprehension') -> T:
128
    pass

1216
@specialize.arg(2)
1217
def comprehension_helper(self, comp_node,
1218
                         handle_source_expr_meth="handle_expr",
1219
                         for_type=syms.comp_for, if_type=syms.comp_if,
1220
                         iter_type=syms.comp_iter,
1221
                         comp_fix_unamed_tuple_location=False):
1222
    handle_source_expression = getattr(self, handle_source_expr_meth)
1223
    fors_count = self.count_comp_fors(comp_node, for_type, if_type)
1224
    comps = []
1225
    for i in range(fors_count):
1226
        for_node = comp_node.get_child(1)
1227
        for_targets = self.handle_exprlist(for_node, ast.Store)
1228
        expr = handle_source_expression(comp_node.get_child(3))
1229
        assert isinstance(expr, ast.expr)
1230
        if for_node.num_children() == 1:
1231
            comp = ast.comprehension(for_targets[0], expr, None)
1232
        else:
1233
            col = comp_node.get_column()
1234
            line = comp_node.get_lineno()
1235
            # Modified in python2.7, see http://bugs.python.org/issue6704
1236
            if comp_fix_unamed_tuple_location:
1237
                expr_node = for_targets[0]
1238
                assert isinstance(expr_node, ast.expr)
1239
                col = expr_node.col_offset
1240
                line = expr_node.lineno
1241
            target = ast.Tuple(for_targets, ast.Store, line, col)
1242
            comp = ast.comprehension(target, expr, None)
1243
        if comp_node.num_children() == 5:
1244
            comp_node = comp_iter = comp_node.get_child(4)
1245
            assert comp_iter.type == iter_type
1246
            ifs_count = self.count_comp_ifs(comp_iter, for_type)
1247
            if ifs_count:
1248
                ifs = []
1249
                for j in range(ifs_count):
1250
                    comp_node = comp_if = comp_iter.get_child(0)
1251
                    ifs.append(self.handle_expr(comp_if.get_child(1)))
1252
                    if comp_if.num_children() == 3:
1253
                        comp_node = comp_iter = comp_if.get_child(2)
1254
                comp.ifs = ifs
1255
            if comp_node.type == iter_type:
1256
                comp_node = comp_node.get_child(0)
1257
        assert isinstance(comp, ast.comprehension)
1258
        comps.append(comp)
1259
    return comps