精华内容
下载资源
问答
  • Python中列表推导式总结

    Python中列表推导式总结:


    定义:

    >所谓的列表推导式就是:轻量级循环创建列表.
    

    以下案例加以说明:

    Num01–>基本方式

    listName=[x  for x  in  range(10)]
    print(listName)
    结果如下:
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    Num02–>在循环过程中使用if条件判断的方式

    listName=[x  for x  in  range(10)  if x%2==0]
    print(listName)
    结果如下:
    [0, 2, 4, 6, 8]

    Num03–>使用两个for循环的方式

    listName=[(x,y) for x in range(10) for y in range(10)]
    print(listName)
    结果如下:
    [(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9)]

    Num04–>使用三个for循环的方式,可以生成一个矩阵

    listName=[(x,y,z) for x in range(3)for y in range(3)for z in range(3)]
    print(listName)
    结果如下:
    [(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 1, 0), (0, 1, 1), (0, 1, 2), (0, 2, 0), (0, 2, 1), (0, 2, 2), (1, 0, 0), (1, 0, 1), (1, 0, 2), (1, 1, 0), (1, 1, 1), (1, 1, 2), (1, 2, 0), (1, 2, 1), (1, 2, 2), (2, 0, 0), (2, 0, 1), (2, 0, 2), (2, 1, 0), (2, 1, 1), (2, 1, 2), (2, 2, 0), (2, 2, 1), (2, 2, 2)]
    展开全文
  • Python列表解析式总结

    2020-06-08 09:41:41
    Python编程语言中的列表解析(list comprehension)就是这类语法糖(syntactic sugar)的绝佳代表。 Python中的列表解析是个伟大的发明,但是要掌握好这个语法则有些难,因为它们并是用来解决全新的问题:...

    前言

    目录

    前言

    什么是列表解析式?

    从循环到解析式

    列表解析式:可视化解读

    无条件子句的列表解析式

    嵌套循环

    其他解析式

    还要注意可读性

    列表解析式 List comprehension

    带嵌套循环的列表解析式

    字典解析式

    总结

    补充:if ... else用法


    有时候,一个编程设计模式使用得十分普遍,甚至会逐步形成自己独特的语法。Python编程语言中的列表解析式(list comprehension)就是这类语法糖(syntactic sugar)的绝佳代表。

    Python中的列表解析式是个伟大的发明,但是要掌握好这个语法则有些难,因为它们并是用来解决全新的问题:只是为解决已有问题提供了新的语法。

    什么是列表解析式?

    列表解析式是将一个列表(实际上适用于任何可迭代对象(iterable))转换成另一个列表的工具。在转换过程中,可以指定元素必须符合一定的条件,才能添加至新的列表中,这样每个元素都可以按需要进行转换。

    如果你熟悉函数式编程(functional programming),你可以把列表解析式看作为结合了filter函数与map函数功能的语法糖:

    >>> doubled_odds = map(lambda n: n * 2, filter(lambda n: n % 2 == 1, numbers))
    >>> doubled_odds = [n * 2 for n in numbers if n % 2 == 1]
    
    

    如果你不熟悉函数式编程,也不用担心:我稍后会通过for循环为大家讲解。

    从循环到解析式

    每个列表解析式都可以重写为for循环,但不是每个for循环都能重写为列表解析式。

    掌握列表解析式使用时机的关键,在于不断练习识别那些看上去像列表解析式的问题(practice identifying problems that smell like list comprehensions)。

    如果你能将自己的代码改写成类似下面这个for循环的形式,那么你也就可以将其改写为列表解析式:

    :::python
    new_things = []
    for ITEM in old_things:
        if condition_based_on(ITEM):
            new_things.append("something with " + ITEM)
    
    

    你可以将上面的for循环改写成这样的列表解析式:

    :::python
    new_things = ["something with " + ITEM for ITEM in old_things if condition_based_on(ITEM)]
    
    

    列表解析式:可视化解读

    可视化解读听上去是个不错的注意,但是我们怎么才能做到这点呢?

    嘿嘿,只需要从for循环中复制粘贴,稍微调整一下就变成了列表解析式啦。

    for loop to list comprehension

    下面是我们复制粘贴的顺序:

    • 将变量赋值操作复制到新建的空列表中(第三行)
    • append()方法中的表达式参数复制到新列表中(第六行)
    • 复制for循环语句,不包括最后的:(第四行)
    • 复制if条件控制语句,同样不包括最后的:(第五行)

    这样,我们将从下面这段代码:

    :::python
    numbers = [1, 2, 3, 4, 5]
    
    doubled_odds = []
    for n in numbers:
        if n % 2 == 1:
            doubled_odds.append(n * 2)
    
    

    转换成了这两行代码:

    :::python
    numbers = [1, 2, 3, 4, 5]
    
    doubled_odds = [n * 2 for n in numbers if n % 2 == 1]
    
    

    无条件子句的列表解析式

    如果是那些没有条件子句(即if SOMETHING部分)的代码呢,又该怎样复制粘贴?这些形式的代码甚至比有条件子句的代码更好实现。

    一个没有if语句的for循环:

    :::python
    doubled_numbers = []
    for n in numbers:
        doubled_numbers.append(n * 2)
    
    

    上面这段代码页可以改写为一个列表解析式:

    :::python
    doubled_numbers = [n * 2 for n in numbers]
    
    

    我们可以从上面那个简单的for循环中,按照这样的顺序复制粘贴:

     

    • 将变量赋值操作复制到新建的空列表中(第三行)
    • append()方法中的表达式参数复制到新列表中(第五行)
    • 复制for循环语句,不包括最后的:(第四行)

    嵌套循环

    那么嵌套循环(nested loop)又该怎样改写为列表解析式呢?

    下面是一个拉平(flatten)矩阵(以列表为元素的列表)的for循环:

    :::python
    flattened = []
    for row in matrix:
        for n in row:
            flattened.append(n)
    
    

    下面这个列表解析式实现了相同的功能:

    :::python
    flattened = [n for row in matrix for n in row]
    
    

    列表解析式中的嵌套循环读起来就有点绕口了。

    注意:我本能地会想把这个列表解析式写成这样:

    :::python
    flattened = [n for n in row for row in matrix]
    
    

    但是这行代码是错误的。这里我不小心颠倒了两个for循环的顺序。正确的代码是之前那个。

    如果要在列表解析式中处理嵌套循环,请记住for循环子句的顺序与我们原来for循环的顺序是一致的

    同样地原则也适用集合解析式(set comprehension)和字典解析式(dictionary comprehension)。

    其他解析式

    下面的代码提取单词序列中每个单词的首字母,创建了一个集合(set):

    :::python
    first_letters = set()
    for w in words:
        first_letters.add(w[0])
    
    

    同样的代码可以改写为集合解析式:

    :::python
    first_letters = {w[0] for w in words}
    
    

    下面的代码将原有字典的键和值互换,从而创建了一个新的字典:

    :::python
    flipped = {}
    for key, value in original.items():
        flipped[value] = key
    
    

    同样的代码可以改写为字典解析式:

    :::python
    flipped = {value: key for key, value in original.items()}
    
    

    还要注意可读性

    你有没有发现上面的列表解析式读起来很困难?我经常发现,如果较长的列表解析式写成一行代码,那么阅读起来就非常困难。

    不过,还好Python支持在括号和花括号之间断行。

    列表解析式 List comprehension

    断行前:

    :::python
    doubled_odds = [n * 2 for n in numbers if n % 2 == 1]
    
    

    断行后:

    :::python
    doubled_odds = [
        n * 2
        for n in numbers
        if n % 2 == 1
    ]
    
    

    带嵌套循环的列表解析式

    断行前:

    :::python
    flattened = [n for row in matrix for n in row]
    
    

    断行后:

    :::python
    flattened = [
        n
        for row in matrix
        for n in row
    ]
    
    

    字典解析式

    断行前:

    :::python
    flipped = {value: key for key, value in original.items()}
    
    

    断行后:

    :::python
    flipped = {
        value: key
        for key, value in original.items()
    }
    
    

    请注意,我们并不是随意进行断行:我们是在每一行复制过来的代码之后断行的。

    总结

    纠结于写不出列表解析式吗?不要担心。先写一个for循环,能后按照本文说的顺序复制粘贴,就可以写出解析式了。

    任何类似下面代码形式的for循环:

    :::python
    new_things = []
    for ITEM in old_things:
        if condition_based_on(ITEM):
            new_things.append("something with " + ITEM)
    
    

    都可以被改写为下面这种列表解析式:

    :::python
    new_things = ["something with " + ITEM for ITEM in old_things if condition_based_on(ITEM)]
    
    

    (有删减)

    原文链接:https://treyhunner.com/2015/12/python-list-comprehensions-now-in-color/

    补充:if ... else用法

    使用列表生成式的时候,有些童鞋经常搞不清楚if...else的用法。

    例如,以下代码正常输出偶数:

    >>> [x for x in range(1, 11) if x % 2 == 0]
    [2, 4, 6, 8, 10]
    

    但是,我们不能在最后的if加上else

    >>> [x for x in range(1, 11) if x % 2 == 0 else 0]
      File "<stdin>", line 1
        [x for x in range(1, 11) if x % 2 == 0 else 0]
                                                  ^
    SyntaxError: invalid syntax
    

    这是因为跟在for后面的if是一个筛选条件,不能带else,否则如何筛选?

    另一些童鞋发现把if写在for前面必须加else,否则报错:

    >>> [x if x % 2 == 0 for x in range(1, 11)]
      File "<stdin>", line 1
        [x if x % 2 == 0 for x in range(1, 11)]
                           ^
    SyntaxError: invalid syntax
    

    这是因为for前面的部分是一个表达式,它必须根据x计算出一个结果。因此,考察表达式:x if x % 2 == 0,它无法根据x计算出结果,因为缺少else,必须加上else

    >>> [x if x % 2 == 0 else -x for x in range(1, 11)]
    [-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]
    

    上述for前面的表达式x if x % 2 == 0 else -x才能根据x计算出确定的结果。

    可见,在一个列表生成式中,for前面的if ... else是表达式,而for后面的if是过滤条件,不能带else

     

    展开全文
  • 列表推导式总结

    千次阅读 2018-03-27 19:15:18
    列表推导 可以说是Python中一大亮点,可惜 ··· 我并不会用 从基础开始:~ GO [i for i in lis] ==> 这是最基础的了吧··· 等同于下面展开 l = [] for i in lis: l.append(i) 看看这种...

    list1 = [11, [22, 3], [4, ], [55, 66], 8, [9, [7, [12, [34, [26]]]]]]

    如这个list 如何将这些中括号去掉

    去括号,要知道一句话字符串操作要比类型操作容易。

    所以我的第一反应是

    li = str(list1).replace('[', '').replace(']', '').split(',')
    print([int(i.strip()) for i in li])

    皮这一下就是很快乐,反正达到要求了 不是么~

    正经的使用递归函数处理

    def func(li, l2=[]):
        for i in li:
            if isinstance(i, list):
                func(i)
            else:
                l2.append(i)
        return l2
    
    
    print(func(list1))

    中规中矩的一个递归函数 先判断是否是列表,是列表就循环,不是就添加

    老师给的装逼利器

    def func2(lis):
        return [li for item in lis for li in func2(item)] if isinstance(lis, list)else [lis]
    
    
    print(func2(list1))

    看不懂 但是我会拆开哇~

    def func2(lis):
        if isinstance(lis, list):
            result = []
            for item in lis:
                for li in func2(item):
                    result.append(li)
            return result
        else:
            return [lis]

    拆开以后是不是瞬间领悟了

    顺便拓展下 对于列表推导式:

    列表推导式 可以说是Python中一大亮点,可惜 ··· 我并不会用

    从基础开始:~ GO

    [i for i in lis] ==> 这是最基础的了吧··· 等同于下面展开
    l = []
    for i in lis:
        l.append(i)

    看看这种用法

    for i in lis:
        print(i)
    平常打印之类的 经常看眼数据对吧 换个方式看吧 ==> [print(i) for i in lis]

    反正都是一些常用的偷懒的方法

    [print(i) for i in lis if i>5] ==> 加一些简单的判断
    for i in lis:
        if i > 5:
            print(i)

    猜猜看下面的打印结果

    [i if i>8 else i-1 for i in range(10) if i>5]
    惊不惊喜 不止后面可以加判断条件 前面也可以继续处理
    l = []
    for i in range(10):
        if i > 5:
            if i > 8:
                l.append(i)
            else:
                l.append(i-1)

    一层循环没意思,加一层

    [print(li) for item in lis for li in item] ==> 循环嵌套
    for item in lis:
        for li in item:
            print(li)

    当然 多层循环也可以加条件

    [print(f'{y}*{x}={x*y}', end='\t\t') if x != 9 else print(f'{y}*{x}={x*y}') for y in range(1, 10) for x in range(y, 10)]
    emm 有点问题  但是 大概 可能 也算一个乘法表··· 逃~
    
    for y in range(1, 10):
        for x in range(y, 10):
            if x!= 9:
                print(f'{y}*{x}={x*y}', end='\t\t')
            else:
                print(f'{y}*{x}={x*y}')

    当然 还可以加很多很多东西, 比如网上的那些黑魔法(一行画个图。。之类的) 就是利用列表推导式 + join

    不过 推导式虽然好用,但不要写的太过于复杂,不利于阅读和维护。

    展开全文
  • 列表推导并不是什么特别的技术,它只是一种创建列表的简洁方法,目的是为了让大家写程序时更方便更快捷,写出更简洁的代码初识列表现在请创建一个list,元素为1到9的整数,先用普通方法做lst = []for i in range...

    列表推导式并不是什么特别的技术,它只是一种创建列表的简洁方法,目的是为了让大家写程序时更方便更快捷,写出更简洁的代码

    初识列表

    现在请创建一个list,元素为1到9的整数,先用普通方法做lst = []

    for i in range(10):

    lst.append(i)

    用了3行代码完成了这个功能,现在用列表推导式来做lst = [i for i in range(10)]

    仅仅是一行代码哦,一行代码就能解决的问题,就没必要用三行代码去做

    创建一个列表,元素为10以内的偶数,方法1lst = [i for i in range(2,10,2)]

    方法2lst = [i for i in range(2,10) if i%2 == 0]

    小做总结

    讲到这里,我必须稍微的做一个总结了,for语句前面的表达式,经过计算,最终留在新建的list列表中,for循环是一个不断取值的过程,而满足if语句的元素才有资格参与for语句前面的表达式计算。

    我这样讲,可能你还是不能够理解,换一个新的例子,创建一个列表,元素为10以内偶数的平方lst = [i*i for i in range(2,10) if i%2 == 0]

    程序解读:for 语句前面的表达式是i*i

    i 的值从2变化到9,但不是每一个i的值都会参加i*i的计算,i的值必须满足if条件语句才行

    配合函数

    for语句前面的表达式在某些情况下,仍然不能够满足实际需要,比如下面的要求,创建一个list,元素为10以内的偶数的平方,如果元素的个位数是6,则该元素的值转为字符串。

    根据要求,新创建的列表内容应当为[4, '16', '36', 64],你现在知道for语句前面的内容是表达式,更进一步,他们是lambda表达式,关于这个概念,我后续会介绍,想要用lambda表达式来完成这个功能,是比较困难的,这种情况下,可以配合函数来做,代码如下def func(i):

    res = i * i

    if res % 10 == 6:

    return str(res)

    return res

    lst = [func(i) for i in range(2,10) if i % 2 == 0]

    print lst

    列表推导式更快

    列表推导式不仅仅是让程序更简洁,其速度也比普通方法快,下面是一段测试比较代码#coding=utf-8

    import time

    #装饰器函数

    def timefunc(func):

    def newfunc(*args,**kwargs):

    t1 = time.time()

    lst = func(*args,**kwargs)

    t2 = time.time()

    diff = t2 - t1

    print u'{func}用时{diff}'.format(diff=diff,

    func=func.func_name)

    return lst

    return newfunc

    @timefunc

    def func1(count):

    lst = []

    for i in range(count):

    lst.append(i)

    return lst

    @timefunc

    def func2(count):

    lst = [i for i in range(count)]

    return lst

    count = 1000000

    func1(count)

    func2(count)

    这段代码里用到了装饰器,后续我也会讲,程序运行的结果如下:

    func1用时0.144474029541

    func2用时0.0513877868652

    可以明显的看到,使用列表推导式,创建相同内容的列表,要比普通方法快接近3倍的速度

    列表推导式总结优点简洁

    高效

    缺点

    如果使用不当,会造成阅读困难。

    写出别人难以理解的代码是非常容易的,如果再用心些,写出一份几天后自己都看不懂的代码也不是什么难事,真正难的是写出别人看得懂的代码,列表推导式虽然简洁,但一味的简洁,在推导式里写上一堆的代码,就造成理解困难,比如下面的题目:a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    将这个嵌套列表转成一维列表,转换后,列表内容为[1, 2, 3, 4, 5, 6, 7, 8, 9]

    如果用列表推导式,则可以这样写a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    b = [j for i in a for j in i]

    print(b)

    上面的代码我已经不想去解释了,如果是用普通方法,则可以这样写a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    b = []

    for i in a:

    for j in i:

    b.append(j)

    print b

    这两份代码,你更喜欢用哪一个呢?

    展开全文
  • 列表推导并不是什么特别的技术,它只是一种创建列表的简洁方法,目的是为了让大家写程序时更方便更快捷,写出更简洁的代码初识列表现在请创建一个list,元素为1到9的整数,先用普通方法做lst = [] for i in range...
  • 列表推导并不是什么特别的技术,它只是一种创建列表的简洁方法,目的是为了让大家写程序时更方便更快捷,写出更简洁的代码初识列表现在请创建一个list,元素为1到9的整数,先用普通方法做lst = []for i in range...
  • Python进阶-列表推导详解总结

    千次阅读 2019-09-15 21:57:55
    列表推导并不是什么特别的技术,它只是一种创建列表的简洁方法,目的是为了让大家写程序时更方便更快捷,写出更简洁的代码 初识列表 现在请创建一个list,元素为1到9的整数,先用普通方法做 lst = [] for i in ...
  • Python里面有个很棒的语法糖(syntactic sugar),它就是 list comprehension ,有人把它翻译成“列表推导”,也有人翻译成“列表解析”。名字听上去很难理解,但是看它的语法就很清晰了。虽然名字叫做 list ...
  • 1.三元表达式 表示方式: 结果+if判断+else条件 ...列表推导 表示方式: [表达式(包含x)+for x in iterable+条件](后面这个条件可写可不写) 注:这里,[]中括号必须写,然后就是把中括号换成普通的括号()的话...
  • 视频地址: python之列表生成和生成器对比大总结 更多精彩内容,敬请扫码关注(HelloWorld小码农):  
  • python列表总结

    2020-09-10 11:15:14
    二、列表2.1 列表的语法2.2 列表的创建2.2.1 基本语法创建2.2.2 list()创建2.2.3 range()创建整数列表2.2.4 推导生成列表2.3列表元素的增加和删除2.3.1 添加元素 append()2.3.2 运算符操作2.3.3 extend()方法2.3.4...
  • Python列表操作总结

    2017-03-01 10:56:00
    列表a_list=[1,2,3,4]特点有序可变连续的内存空间,最好从尾部进行元素的增加与删除列表的创建a_list=[1,2,3,4]a_list=list((3,5,7,9,11))a_list=[5 for I in range(10)]列表推导[I for I in a_list if i>...
  • 1.列表推导 ''' 格式: [表达式 for 变量 in 旧列表] 或者 [表达式 for 变量 in 旧列表 if 条件] ''' ''' 举例: 将列表中元素长度大于3,并且将其首字母大写后输出 names = ['aaaa', 'dd', 'werr', 'xiaoxie', '...
  • 各种推导式总结

    2018-08-20 18:51:00
    推导是从一个或者多个迭代器快速简洁地创建数据结构的一种方法...之前已经说过创建列表的多种方法,使用[ ] 、list() 、str.split() 等方法,除此之外,列表推导也是生成具有一定规律的列表的方法。 如创建一个...
  • 主要介绍了Python列表解析操作,结合实例形式总结分析了Python列表解析常见的列表推导、循环语句、条件列表、嵌套列表等相关操作技巧,需要的朋友可以参考下
  • 1、列表生成 列表生成即List Comprehensions,是Python内置的非常简单却强大的可以用来创建list的生成。 可以用来生成一系列的数据。 举个例子,要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list...
  • 最近在工作中为了减少代码的行数而开始使用列表推导, 结果非常好, 七八行的代码只需要用一行代码就能够写完, 虽然逻辑对于不怎么使用列表推导的人来说会比较困难, 但是习惯之后也相当容易。 因此强烈推荐...
  • Python-生成式总结

    2019-12-09 20:03:11
    文章目录生成式列表生成字典生成 生成 列表生成 # 需求1:接收变量 k a b s = '51 5000 10000' a = s.split() print(a) li = [] for item in s.split(): li.append(int(item)) #常规结构 li = [int(item) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,078
精华内容 431
关键字:

列表式总结