精华内容
下载资源
问答
  • 列表推导式与字典推导式,滚雪球学 Python

    千次阅读 多人点赞 2021-03-03 21:50:58
    列表推导式、字典推导式、集合推导式、生成器初识

    橡皮擦,一个逗趣的互联网高级网虫,新的系列,让我们一起 Be More Pythonic

    四、列表推导式与字典推导式

    在 Python 中推导式是一种非常 Pythonic 的知识,本篇博客将为你详细解答列表推导式与字典推导式相关的技术知识。

    4.1 列表推导式

    列表推导式可以利用列表,元组,字典,集合等数据类型,快速的生成一个特定需要的列表。
    语法格式如下:

    [表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]]
    

    if 条件表达式 非必选,学完列表推导式之后,你可以发现它就是 for 循环的一个变种语句,例如咱们现有一个需求是将一个列表中的所有元素都变成原值的 2 倍。

    for 循环写法

    my_list = [1,2,3]
    new_list = []
    for i in my_list:
        new_list.append(i*2)
    
    print(new_list)
    

    列表推导式写法

    nn_list = [i*2 for i in my_list]
    print(nn_list)
    

    是不是对比看就是将 for 循环语句做了变形之后,增加了一个 [],不过需要注意的是,列表推导式最终会将得到的各个结果组成一个新的列表。
    再看一下列表推导式语法构成 nn_list = [i*2 for i in my_list]for 关键字后面就是一个普通的循环,前面的表达式 i*2 其中的 i 就是 for 循环中的变量,也就是说表达式可以用后面 for 循环迭代产生的变量,理解这个内容列表推导式就已经掌握 9 成内容了,剩下的是熟练度的问题。

    在将 if 语句包含进代码中,运行之后,你也能掌握基本技巧,if 语句是一个判断,其中 i 也是前面循环产生的迭代变量。

    nn_list = [i*2 for i in my_list if i>1]
    print(nn_list)
    

    这些都是一般技能,列表推导式能支持两层 for 循环,例如下述代码:

    nn_list = [(x,y) for x in range(3) for y in range(3) ]
    print(nn_list)
    

    当然如果你想**加密(谁都看不懂你的代码)**你的代码,你可以无限套娃下去,列表推导式并没有限制循环层数,多层循环就是一层一层的嵌套,你可以展开一个三层的列表推导式,就都明白了

    nn_list = [(x,y,z,m) for x in range(3) for y in range(3) for z in range(3) for m in range(3)]
    print(nn_list)
    

    当然在多层列表推导式里面,依旧支持 if 语句,并且 if 后面可以用前面所有迭代产生的变量,不过不建议超过 2 成,超过之后会大幅度降低你代码的可阅读性。

    当然如果你希望你代码更加难读,下面的写法都是正确的。

    nn_list = [(x, y, z, m) for x in range(3) if x > 1 for y in range(3) if y > 1 for z in range(3) for m in range(3)]
    print(nn_list)
    nn_list = [(x, y, z, m) for x in range(3) for y in range(3) for z in range(3) for m in range(3) if x > 1 and y > 1]
    print(nn_list)
    nn_list = [(x, y, z, m) for x in range(3) for y in range(3) for z in range(3) for m in range(3) if x > 1 if y > 1]
    print(nn_list)
    

    现在你已经对列表推导式有比较直观的概念了,列表推导式对应的英文是 list comprehension,有的地方写作列表解析式,基于它最后的结果,它是一种创建列表的语法,并且是很简洁的语法。

    有了两种不同的写法,那咱们必须要对比一下效率,经测试小数据范围影响不大,当循环次数到千万级时候,出现了一些差异。

    import time
    def demo1():
        new_list = []
        for i in range(10000000):
            new_list.append(i*2)
    
    def demo2():
        new_list = [i*2 for i in range(10000000)]
    s_time = time.perf_counter()
    demo2()
    e_time = time.perf_counter()
    print("代码运行时间:", e_time-s_time)
    

    运行结果:

    # for 循环
    代码运行时间: 1.3431036140000001
    # 列表推导式
    代码运行时间: 0.9749278849999999
    

    在 Python3 中列表推导式具备局部作用域,表达式内部的变量和赋值只在局部起作用,表达式的上下文里的同名变量还可以被正常引用,局部变量并不会影响到它们。所以其不会有变量泄漏的问题。例如下述代码:

    x = 6
    my_var = [x*2 for x in range(3)]
    
    print(my_var)
    print(x)
    

    列表推导式还支持嵌套
    参考代码如下,只有想不到,没有做不到的。

    my_var = [y*4 for y in [x*2 for x in range(3)]]
    print(my_var)
    

    4.2 字典推导式

    有了列表推导式的概念,字典推导式学起来就非常简单了,语法格式如下:

    {:for 迭代变量 in 可迭代对象 [if 条件表达式]}
    

    直接看案例即可

    my_dict = {key: value for key in range(3) for value in range(2)}
    print(my_dict)
    

    得到的结果如下:

    {0: 1, 1: 1, 2: 1}
    

    此时需要注意的是字典中不能出现同名的 key,第二次出现就把第一个值覆盖掉了,所以得到的 value 都是 1。

    最常见的哪里还是下述的代码,遍历一个具有键值关系的可迭代对象。

    my_tuple_list = [('name', '橡皮擦'), ('age', 18),('class', 'no1'), ('like', 'python')]
    my_dict = {key: value for key, value in my_tuple_list}
    print(my_dict)
    

    4.3 元组推导式与集合推导式

    其实你应该能猜到,在 Python 中是具备这两种推导式的,而且语法相信你已经掌握了。不过语法虽然差不多,但是元组推导式运行结果却不同,具体如下。

    my_tuple = (i for i in range(10))
    print(my_tuple)
    

    运行之后产生的结果:

    <generator object <genexpr> at 0x0000000001DE45E8>
    

    使用元组推导式生成的结果并不是一个元组,而是一个生成器对象,需要特别注意下,这种写法在有的地方会把它叫做生成器语法,不叫做元组推导式。

    集合推导式也有一个需要注意的地方,先看代码:

    my_set = {value for value in 'HelloWorld'}
    print(my_set)
    

    因为集合是无序且不重复的,所以会自动去掉重复的元素,并且每次运行显示的顺序不一样,使用的时候很容易晕掉。

    4.4 这篇博客的总结

    这篇博客,我们学习了列表和字典推导式,掌握并熟练的应用二者之后,你 Python 技能又向前进了一步。

    相关阅读

    1. Python 爬虫 100 例教程,超棒的爬虫教程,立即订阅吧
    2. Python 爬虫小课,精彩 9 讲

    今天是持续写作的第 98 / 100 天。
    如果你想跟博主建立亲密关系,可以关注同名公众号 梦想橡皮擦,近距离接触一个逗趣的互联网高级网虫。
    博主 ID:梦想橡皮擦,希望大家点赞评论收藏

    展开全文
  • 列表推导式、元组推导式、字典推导式、集合推导式列表推导式元组推导式字典推导式集合推导式 推导式(又称解析器),是 Python 独有的一种特性。 使用推导式可以快速生成列表、元组、字典以及集合类型的数据,因此...

    列表推导式、元组推导式、字典推导式、集合推导式

    推导式(又称解析器),是 Python 独有的一种特性。

    使用推导式可以快速生成列表、元组、字典以及集合类型的数据,因此推导式又可细分为列表推导式、元组推导式、字典推导式以及集合推导式。

    列表推导式

    列表推导式可以利用 range 区间、元组、列表、字典和集合等数据类型,快速生成一个满足指定需求的列表。

    列表推导式的语法格式如下:

    [表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]
    

    此格式中,[if 条件表达式] 不是必须的,可以使用,也可以省略。

    通过列表推导式的语法格式,明显会感觉到它和 for 循环存在某些关联。

    其实,除去 [if 条件表达式] 部分,其余各部分的含义以及执行顺序和 for 循环是完全一样的(表达式其实就是 for 循环中的循环体),即它的执行顺序如下所示:

    for 迭代变量 in 可迭代对象
        表达式
    

    可以这样认为,它只是对 for 循环语句的格式做了一下简单的变形,并用 [] 括起来而已,只不过最大的不同之处在于,列表推导式最终会将循环过程中,计算表达式得到的一系列值组成一个列表

    a_range = range(10)
    # 对a_range执行for表达式
    a_list = [x * x for x in a_range]
    # a_list集合包含10个元素
    print(a_list)
    
    输出结果:
    [0 , 1 , 4 , 9 , 16 , 25 , 36 , 49 , 64, 81]
    

    上面代码的第 3 行会对 a_range 执行迭代,由于 a_range 相当于包含 10 个元素,因此程序生成的 a_list 同样包含 10 个元素,且每个元素都是 a_range 中每个元素的平方(由表达式 x * x 控制)。

    不仅如此,我们还可以在列表推导式中添加 if 条件语句,这样列表推导式将只迭代那些符合条件的元素。例如:

    b_list = [x * x for x in a_range if x % 2 == 0]
    # a_list集合包含5个元素
    print(b_list)
    
    输出结果:
    [0 ,4 , 16, 36, 64]
    

    这里给列表推导式增加了 if 条件语句,这会导致推导式只处理 range 区间的偶数,因此程序生成的 b_list 只包含 5 个元素。

    另外,以上所看到的列表推导式都只有一个循环,实际上它可使用多个循环,就像嵌套循环一样。例如如下代码:

    d_list = [(x, y) for x in range(5) for y in range(4)]
    # d_list列表包含20个元素
    print(d_list)
    

    上面代码中,x 是遍历 range(5) 的迭代变量(计数器),因此该 x 可迭代 5 次;y 是遍历 range(4) 的计数器,因此该 y 可迭代 4 次。因此,该(x,y)表达式一共会迭代 20 次。上面的 for 表达式相当于如下嵌套循环:

    dd_list = []
    for x in range(5):
        for y in range(4):
            dd_list.append((x, y))
    
    输出结果:
    [(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (4, 3)]
    

    当然,也支持类似于三层嵌套的 for 表达式,例如如下代码:

    e_list = [[x, y, z] for x in range(5) for y in range(4) for z in range(6)]
    # e_list列表包含120个元素
    print(e_list)
    

    对于包含多个循环的 for 表达式,同样可指定 if 条件。

    假如我们有一个需求:

    • 程序要将两个列表中的数值按“能否整除”的关系配对在一起。

    • 比如 src_a 列表中包含 30,src_b 列表中包含 5,其中 30 可以整除 5,那么就将 30 和 5 配对在一起。对于上面的需求使用 for 表达式来实现非常简单,例如如下代码:

    src_a = [30, 12, 66, 34, 39, 78, 36, 57, 121]
    src_b = [3, 5, 7, 11]
    # 只要x能整除y,就将它们配对在一起
    result = [(x, y) for x in src_a for y in src_b if x % y == 0]
    print(result)
    
    输出结果:
    [(30, 3), (30, 5), (12, 3), (66, 3), (66, 11), (39, 3), (78, 3), (36, 3), (57, 3), (121, 11)]
    

    元组推导式

    元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型,快速生成一个满足指定需求的元组。

    元组推导式的语法格式如下:

    (表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] )
    

    其中,用 [] 括起来的部分,可以使用,也可以省略。

    通过和列表推导式做对比,你会发现,除了元组推导式是用 () 圆括号将各部分括起来,而列表推导式用的是 [],其它完全相同。不仅如此,元组推导式和列表推导式的用法也完全相同。

    例如,我们可以使用下面的代码生成一个包含数字 1~9 的元组:

    a = (x for x in range(1,10))
    print(a)
    
    输出结果:
    <generator object <genexpr> at 0x000001C6E5F97748>
    

    从上面的执行结果可以看出,使用元组推导式生成的结果并不是一个元组,而是一个生成器对象,这一点和列表推导式是不同的。

    如果我们想要使用元组推导式获得新元组或新元组中的元素,有以下三种方式:

    1. 使用 tuple() 函数,可以直接将生成器对象转换成元组,例如:
    a = (x for x in range(1,10))
    print(tuple(a))
    
    运行结果为:
    (1, 2, 3, 4, 5, 6, 7, 8, 9)
    
    1. 直接使用 for 循环遍历生成器对象,可以获得各个元素,例如:
    a = (x for x in range(1,10))
    for i in a:
        print(i,end=' ')
    print(tuple(a))
    
    输出结果:
    1 2 3 4 5 6 7 8 9 ()
    
    1. 使用 __next__() 方法遍历生成器对象,也可以获得各个元素,例如:
    a = (x for x in range(3))
    print(a.__next__())
    print(a.__next__())
    print(a.__next__())
    a = tuple(a)
    print("转换后的元组:",a)
    
    输出结果:
    0
    1
    2
    转换后的元组: ()
    

    注意,无论是使用 for 循环遍历生成器对象,还是使用 __next__() 方法遍历生成器对象,遍历后原生成器对象将不复存在,这就是遍历后转换原生成器对象却得到空元组的原因

    字典推导式

    Python 中,使用字典推导式可以借助列表、元组、字典、集合以及 range 区间,快速生成符合需求的字典。

    字典推导式的语法格式如下:

    {表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}
    

    可以看到,和其它推导式的语法格式相比,唯一不同在于,字典推导式用的是大括号{}

    listdemo = ['Jack','Tom']
    #将列表中各字符串值为键,各字符串的长度为值,组成键值对
    newdict = {key:len(key) for key in listdemo}
    print(newdict)
    
    输出结果:
    {'Jack': 4, 'Tom': 3}
    

    交换现有字典中各键值对的键和值。

    olddict={'Jack': 4, 'Tom': 3}
    newdict = {v: k for k, v in olddict.items()}
    print(newdict)
    
    输出结果:
    {4: 'Jack', 3: 'Tom'}
    

    使用 if 表达式筛选符合条件的键值对。

    olddict={'Jack': 4, 'Tom': 3}
    newdict = {v: k for k, v in olddict.items() if v>3}
    print(newdict)
    
    输出结果:
    {4: 'Jack'}
    

    集合推导式

    集合推导式的语法格式和字典推导式完全相同,如下所示:

    { 表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] }
    

    集合推导式和字典推导式的格式完全相同,那么给定一个类似的推导式,如何判断是哪种推导式呢?

    最简单直接的方式,就是根据表达式进行判断,如果表达式以键值对(key:value)的形式,则证明此推导式是字典推导式;反之,则是集合推导式。

    setnew = {i**2 for i in range(3)}
    print(setnew)
    
    输出结果:
    {0, 1, 4}
    

    既然生成的是集合,那么其保存的元素必须是唯一的。

    tupledemo = (1,1,2,3,4,5,6,6)
    setnew = {x**2 for x in tupledemo if x%2==0}
    print(setnew)
    
    输出结果:
    {16, 4, 36}
    
    dictdemo = {'1':1,'2':2,'3':3}
    setnew = {x for x in dictdemo.keys()}
    print(setnew)
    
    输出结果:
    {'2', '1', '3'}
    
    展开全文
  • 推导式创建序列列表推导式字典推导式推导式代码普通代码集合推导式生成器推导式(生成元组)嵌套推导式1 列表套列表2 一个列表套两个 for 循环2.1 有点像 `product` 函数 的感觉2.2 在列表推导式中 序列解包3 批量...

    54.推导式创建序列

    推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合, 从而避免冗长的代码。推导式是典型的Python 风格,会使用它代表你已经超过Python初 学者的水平。

    列表推导式

    列表推导式生成列表对象,语法如下:

    [表达式 for item in 可迭代对象 ] 
                或者:
    [表达式 for item in 可迭代对象 if 条件判断]
    
    >>> [x for x in range(1,5)]
    [1, 2, 3, 4] 
    
    >>> [x*2 for x in range(1,5)]
    [2, 4, 6, 8] 
    
    >>> [x*2 for x in range(1,20) if x%5==0 ] 
    [10, 20, 30] 
    
    >>> [a for a in "abcdefg"]
    ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    
    >>> cells = [(row,col) for row in range(1,10) for col in range(1,10)] #可以使用两 个循环
    >>> for cell in cells:
        print(cell)
    

    字典推导式

    字典的推导式生成字典对象,格式如下:

    {key_expression : value_expression for 表达式 in 可迭代对象}
    

    类似于列表推导式,字典推导也可以增加 if条件判断、多个 for 循环。

    统计文本中字符出现的次数:

    推导式代码

    my_text = "i love you, i love python, i love onepis"
    char_count = {c: my_text.count(c) for c in my_text}
    print(char_count)
    

    普通代码

    # 使用普通的循环实现上面字典推导式实现的字符出现次数的统计
    
    char_count = {}
    my_text = "i love you, i love python, i love onepis"
    for c in my_text:
        my_text.count(c)
        char_count[c] = my_text.count(c)
    print(char_count)
    
    
    # 输出:
    {'i': 4, ' ': 8, 'l': 3, 'o': 6, 'v': 3, 'e': 4, 'y': 2, 'u': 1, ',': 2, 'p': 2, 't': 1, 'h': 1, 'n': 2, 's': 1}
    
    

    集合推导式

    集合推导式生成集合,和列表推导式的语法格式类似:

    {表达式 for item in 可迭代对象 } 
        或者:
    {表达式 for item in 可迭代对象 if 条件判断}
    
    # 集合推导式
    # 本质上集合还是字典,只是里面全是key   没有value,特点是不可重复
    
    b = {x for x in range(1, 100) if x % 9 == 0}
    print(b)
    

    生成器推导式(生成元组)

    很多同学可能会问:“都有推导式,元组有没有?”,能不能用小括号呢?

    >>> (x for x in range(1,100) if x%9==0) 
    <generator object <genexpr> at 0x0000000002BD3048>
    
    gnt = (x for x in range(4))
    
    # print(tuple(gnt))
    
    
    for x in gnt:  # gnt是生成器对象,生成器是可迭代的对象,只能使用一次
        print(x, end=",")  # 这里是用for循环去迭代遍历 生成器.输出 打印
    print(tuple(gnt))    # 第二次输出打印所以 没有数据线了,只有()
    

    我们发现提示的是“一个生成器对象”。显然,元组是没有推导式的。

     一个生成器只能运行一次。第一次迭代可以得到数据,第二次迭代发现数据已经没有了。

    嵌套推导式

    1 列表套列表

    # 推导式
    some_tuple = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
    
    list1 = [[x for x in tup] for tup in some_tuple]
    print(list1)
    # 输出
    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    print('***********************')
    
    
    # 普通循环
    list2 = []
    for tup in some_tuple:
        list2 .append(list(tup))
        # 不过从循环次数来说 普通的 循环
        # 特别是涉及到操作 元素的  比如 append  我感觉 还是普通的好。
        # 因为循环次数减少了。
        # 当然也和你的 需求相关。
        # 具体问题具体分析
    print(list2)
    
    

    2 一个列表套两个 for 循环

    2.1 有点像 product 函数 的感觉

    [(x, y) for x in range(5) for y in range(5)]
    # 输出
    [(0, 0),
     (0, 1),
     (0, 2),
     (0, 3),
     (0, 4),
     (1, 0),
     (1, 1),
     (1, 2),
     (1, 3),
     (1, 4),
     (2, 0),
     (2, 1),
     (2, 2),
     (2, 3),
     (2, 4),
     (3, 0),
     (3, 1),
     (3, 2),
     (3, 3),
     (3, 4),
     (4, 0),
     (4, 1),
     (4, 2),
     (4, 3),
     (4, 4)]
    

    2.2 在列表推导式中 序列解包

    
    a = ['I lobe u\n', '123\n', 'dad\n']
    b = enumerate(a)  
    # 枚举,用元组包含起来,做一个索引   enumerate方法
    # 前面讲过的 返回一个元组 。
    # 忘记的朋友 可以去看我的博客 38_序列解包 
      
    print("a -> ",a)
    print("list b -> ",list(b))
    # 在后面 添加序号  #+数字 的形式
    c = [temp.rstrip()+' #' + str(index) for index, temp in enumerate(a)]
    # rstrip去掉右边空白符号
    # index,temp  看做一  块内容. 其实 就是 解包 解出来两个元素
    # 用两个变量 来接收
    print("c-> ",c)
    
    # 输出
    a ->  ['I lobe u\n', '123\n', 'dad\n']
    list b ->  [(0, 'I lobe u\n'), (1, '123\n'), (2, 'dad\n')]
    c->  ['I lobe u #0', '123 #1', 'dad #2']
    

    3 批量创建文件

    # 批量创建文件
    import os
    path = r'C:\Users\bai\Desktop\test\2'
    os.chdir(path)  # 改变当前文件夹
    a = range(10)
    b = []
    [b.append(str(z)) for z in a]  # 把列表a里面的 int数字 转换为 字符串装到列表b
    files = ['test (' + y + ').txt' for y in b]
    for x in files:
        with open(x, 'w')as f: # w 是 write 写的意思。 写模式。 后面会详细讲解 io 输入输出的
            f.write('')
    

    5 加判断的推导式

    # 列出工作目录下的所有的.py文件,并且输出文件名
    
    # 普通代码
    path = os.getcwd()  # 返回工作目录以及文件 get current directory 的 简写
    # 获取 当前 工作目录的意思
    
    file_list = os.listdir(path)  # 列出子目录、子文件
    for filename in file_list:
        if filename.endswith('py'): 
        # 文件以 什么结尾  里面 写py 就是 以 py 结尾的意思
        # endswith 返回的 是一个bool 值
        # 用于判断 是否 以 py 结尾
            print(filename)
    
    
    print('***********************')
    
    # 用推导式实现
    file_list2 = [filename for filename in os.listdir(
        path) if filename.endswith('py')]
    
    for f in file_list2:
        print(f, end='\t')
    
    '''
    一些简单的 计算机常识
    print(os.curdir)  # 返回一个点  . 代表当前 文件夹,两个点  .. 是上级目录
    print(os.pardir)  # 返回上级目录
    print(os.name)  # 返回操作系统名称
    '''
    
    展开全文
  • 列表推导式 和 字典推导式在python中常用,但是有时候经常混淆,语法上也略有区别,随手写下,给自己个记录 列表推导式 a = [0,1,2,3,4,5,6,7,8,9] b = [i+100 if i > 5 else 0 for i in a ] print('b : ',b...

    列表推导式 和 字典推导式在python中常用,但是有时候经常混淆,语法上也略有区别,随手写下,给自己做个记录

    列表推导式

    a = [0,1,2,3,4,5,6,7,8,9]
    b = [i+100 if i > 5 else 0 for i in a ]
    print('b : ',b)

    输出:

    注意:条件语句 在for之前

    这个顺序能否颠倒呢?

    a = [0,1,2,3,4,5,6,7,8,9]
    b = [i+100  for i in a if i > 5 else 0]
    print('b : ',b)

    报错:

     

    字典推导式

    a = [0,1,2,3,4,5,6,7,8,9]
    c = {i:i+100  for i in a if i > 5 }
    print("c : ",c)

    输出:

    注意:条件语句在for之后

    这个顺序能否颠倒呢?

    a = [0,1,2,3,4,5,6,7,8,9]
    c = {i:i+100 if i > 5 for i in a  }
    print("c : ",c)

    报错:

    能不能在后面加上else呢?

    a = [0,1,2,3,4,5,6,7,8,9]
    c = {i:i+100  for i in a  if i > 5 else i:i}
    print("c : ",c)

    依然报错:

     

    仅此记录。如果发现错误或者不足,欢迎留言告知,谢谢!

    展开全文
  • Python笔记002-列表推导式 以下是我学习《流畅的Python》后的个人笔记,现在拿出来和大家共享,希望帮到各位Python学习者。 首次发表于: 微信公众号:科技老丁哥,ID: TechDing,敬请关注。 本篇主要知识点: ...
  • 详解Python列表推导式

    2021-07-13 16:52:54
    列表推导式可以使用非常简洁的方式对列表或其他可迭代对象的元素进行遍历和过滤,快速生成满足特定需求的列表,代码具有非常强的可读性,是Python程序开发时应用最多的技术之一。Python的内...
  • 列表推导式 # 列表推导式就是使用一个简单的方法创建一个列表 # 列表里元素的类型是根据for前面的数据类型而定的 a = [m for m in range(31)] print(a)# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16...
  • python之列表推导式

    千次阅读 2014-11-17 10:00:23
    Python语言以简易明了著称,但初次学习Python,却被很多语法搞的昏头涨脑。List comprehension绝对是其中之一。... 问题一:列表推导式中的变量,是全局变量?还是局部变量?还是闭包变量?  注:一个简单的列
  • Python进阶-列表推导式详解总结

    千次阅读 2019-09-15 21:57:55
    列表推导式并不是什么特别的技术,它只是一种创建列表的简洁方法,目的是为了让大家写程序时更方便更快捷,写出更简洁的代码 初识列表 现在请创建一个list,元素为1到9的整数,先用普通方法 lst = [] for i in ...
  • 列表推导式 就是一个简单的公式,我们用这个列表推导式,把你好几行的for循环的过程给一行解决掉,但是这个过程你必须放在列表的框中[ ] 一般用法: #循环模式#[经过加工的i for i in 可迭代对象] #筛选模式#...
  • python列表推导式中使用if-else

    万次阅读 多人点赞 2018-02-10 17:12:26
    列表推导式总共有两种形式: ①[x for x in data if condition] 此处if主要起条件判断作用,data数据中只有满足if条件的才会被留下,最后统一生成为一个数据列表 ②[exp1 if condition else exp2 for x in data]...
  • 我突然灵光一现,采用列表推导式中的变量作为元素下标来实现元素间的运算,试算了一下,通过,拿来与大家分享。 问题的提出 a = [1, 2, 3] b = [4, 5, 6] >>>print(a+b) [1, 2, 3, 4, 5, 6] 怎么...
  • 精彩内容不迷路 选自towardsdatascience,作者:Benedikt Droste 机器之心编译 ...什么列表推导式 如果我们有一个列表,并希望抽取列表中的元素,那么最标准的方法是使用 Python 循环,...
  • Python小技巧之列表推导式到匿名函数 最近又看了一遍python的基础知识,所谓温故而知新,哈哈哈,所以在这里写下自己的一些见解,我觉得在实战过程中还是非常有用的一些小技巧,也分享给大家,如果写的不好,请大家...
  • 什么时候在Python中使用列表推导式

    千次阅读 多人点赞 2020-05-18 17:30:40
    这篇文章将带你了解Python列表的全部功能以及如何优雅的使用它们。还将了解使用它们所带来的权衡,以便确定何时其他方法更佳
  • 列表推导式和生成器

    2018-11-21 21:39:00
    列表推导式 列表推导是构建列表(list)的快捷方式,而生成器表达式则可以创建其他任何类型的序列,如果你的代码里并不 经常使用它们,你有可能错过很多可读性很好的而且更高效的代码的机会 示例1: 把一个字符串...
  • 一、用列表推导式取代map和filter python 提供一种精炼的写法,可以根据一份列表来制作另外一份列表。这种表达式称为list comprehension(列表推导式)。 eg: >>> a = [1,2,3,4,5,6] >>> squares = [x**2 for x in a] ...
  • 而之前讨论的时候,正好在生成关系矩阵的时候用了列表推导式。所以我就脑洞大开,试着写了一个等价类划分的列表推导式:size = 20rela = lambda a,b: (a - b) % 3 == 0[not [eq.append(i) for eq in eqcls if rela(i...
  • 列表推导式并不是什么特别的技术,它只是一种创建列表的简洁方法,目的是为了让大家写程序时更方便更快捷,写出更简洁的代码1、初识列表1.1 现在请创建一个list,元素为1到9的整数先用普通方法lst = []for i in ...
  • map()函数以及列表推导式 目录map()函数以及列表推导式前言例题&题解知识回顾map() 函数列表推导式 前言 如果只是对例题感兴趣的小伙伴,看看例题就好啦,后面的知识回顾算是个人知识巩固吧!会有很多拓展。 ...
  • 列表解析式(List comprehension)或者称为列表推导式,是 Python 中非常强大和优雅的方法。它可以基于现有的列表一些操作,从而快速创建新列表。在我们第一次见到列表推导式时,可能会感觉这种方法非常炫酷,因此...
  • 以下内容转载自必会的List Comprehension (列表推导式),原作者为CodingFish。 强大的List Comprehension (列表推导式或者列表解析式)是Python中必须知道的概念。然而对于初学者来说是最具挑战性的。掌握这个...
  • 如果你还在使用 For 循环迭代列表,那么你需要了解了解列表推导式,看看它的基本概念都是什么。 **选自towardsdatascience,**作者:Benedikt Droste,机器之心编译,参与:思。 列表解析式(List comprehension)...
  • 列表推导式 列表推导式是python3中的一个语法糖可用于快速迭代一个可迭代对象并将结果存储在列表中 #基本语法 #iterable是可迭代对象,即可以是list,set之类的序列也可以是实现了__iter__的类 #var用于保存每次...
  • 上一节我们结束了有关python的方法相关内容 这一节我们先来学习python的列表推导式之前跟大家说过range方法的使用,在这里我就不过多的解释了,如忘记了,请翻阅之前的介绍列表推导式,是Python内置的一种极其...
  • Python列表推导式和生成器表达式

    千次阅读 2014-10-23 10:58:24
    和列表一样,列表推导式也采用
  • 2,用列表推导式做下列小题 (1)过滤掉长度小于3的字符串列表,并将剩下的转换成大写字母 (2)求(x,y)其中x是0-5之间的偶数,y是0-5之间的奇数组成的元祖列表 (3)求M中3,6,9组成的列表M = [[1,2,3],[4,5,6],[7,8,9]] ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,029
精华内容 7,611
关键字:

列表推导式能做什么