精华内容
下载资源
问答
  • 本文实例讲述了Python列表推导式、字典推导式与集合推导式用法。分享给大家供大家参考,具体如下: 推导式comprehensions(又称解析式),是Python的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据...
  • 主要介绍了python列表推导式操作解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 本文实例讲述了Python列表推导式与生成器用法。分享给大家供大家参考,具体如下: 1. 先看两个列表推导式 def t1(): func1 = [lambda x: x*i for i in range(10)] result1 = [f1(2) for f1 in func1] print ...
  • 列表推导式语法与应用案例 列表推导式(又称列表解析式)提供了一种简明扼要的方法来创建列表。它的结构是在一个中括号里包含一个表达式,然后是一个for语句,然后是 0 个或多个 for 或者 if 语句。那个表达式可以是...
  • 主要介绍了python之列表推导式的用法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Python小技巧之列表推导式到匿名函数 最近又看了一遍python的基础知识,所谓温故而知新,哈哈哈,所以在这里写下自己的一些见解,我觉得在实战过程中还是非常有用的一些小技巧,也分享给大家,如果写的不好,请大家...
  • 主要介绍了Python推导式,结合简单实例形式分析了Python列表推导式、字典推导式与集合推导式基本使用方法,需要的朋友可以参考下
  • Python 列表推导式并不是给初学者用的,因为它非常反直觉,甚至对于有其他编程语言背景的人也是如此。 我们接触到 List 的使用时,学习的内容都是零散的。所以我们缺少一个关于如何在各种各样的场景下使用 List 的...
  • 需要的题量多的话建议购买付费专栏(包含上百道题目答案,并持续更新中)
  • 需要的题量多的话建议购买付费专栏(包含上百道题目答案,并持续更新中)
  • Python列表推导

    2021-01-20 02:55:32
    列表推导式书写形式:list = [表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件] , 记得加[ ] 多重嵌套:example = [[1,2,3],[4,5,6],[7,8,9],[10]]  list = [表达式 for 变量1 in ...
  • python3列表推导

    2020-12-23 01:20:20
    列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素,用其获得的结果作为生成新列表的元素,或者根据确定的判定条件创建子序列。 每个列表推导式都在 for 之后跟一个表达式...
  • 列表推导(List comprehension)的作用是为了更方便地生成列表(list)。 比如,一个list变量的元素均为数字,如果需要将每个元素的值乘以2并生成另外一个list,下面是一种做法:复制代码 代码如下:#-*-encoding:utf...
  • 本文实例讲述了Python学习笔记之列表推导式。分享给大家供大家参考,具体如下: 列表推导列表推导式可以快速简练地创建列表 之前的复杂写法: capitalized_cities = [] for city in cities: capitalized_cities...
  • 本文实例讲述了Python列表推导式与生成器表达式用法。分享给大家供大家参考,具体如下: 和列表一样,列表推导式也采用方括号[]表示,并且用到了一个简写版的for循环,第一部分是一个生成结果列表元素的表达式,第二...
  • 主要介绍了Python列表推导式实现代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 本文实例讲述了Python中map和列表推导效率比较。分享给大家供大家参考。具体分析如下: 直接来测试代码吧: #!/usr/bin/env python # -*- coding: utf-8 -*- # list comprehension and map import time def test(f,...
  • 在本篇文章里小编给大家整理的是关于Python从列表推导到zip()函数的5种技巧的相关知识点和代码,需要的朋友们参考学习下。
  • 乍一看到列表推导式你可能会感到疑惑。它们是一种创建和使用列表的简洁方式。理解列表推导式是有用的,因为你可能在其他人的代码里看到列表推导式。下面来了解下列表推导式吧。 数字列表的推导式 回顾之前学过的知识...
  • 列表推导式、元组推导式、字典推导式、集合推导式列表推导式元组推导式字典推导式集合推导式 推导式(又称解析器),是 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'}
    
    展开全文
  • 列表推导式提供了一个更简单的创建列表的方法。常见的用法是把某种操作应用于序列或可迭代对象的每个元素上,然后使用其结果来创建列表,或者通过满足某些特定条件元素来创建子序列。例如,假设我们想创建一个平方...

    列表推导式提供了一个更简单的创建列表的方法。常见的用法是把某种操作应用于序列或可迭代对象的每个元素上,然后使用其结果来创建列表,或者通过满足某些特定条件元素来创建子序列。

    例如,假设我们想创建一个平方列表,像这样

    >>> squares = []

    >>> for x in range(10):

    ... squares.append(x**2)

    ...

    >>> squares

    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

    注意这里创建(或被重写)的名为 x 的变量在for循环后仍然存在。我们可以计算平方列表的值而不会产生任何副作用

    squares = list(map(lambda x: x**2, range(10)))

    或者,等价于

    squares = [x**2 for x in range(10)]

    上面这种写法更加简洁易读。

    Python列表推导式的结构是由一对方括号所包含的以下内容:一个表达式,后面跟一个 for 子句,然后是零个或多个 for或 if 子句。 其结果将是一个新列表,由对表达式依据后面的 for 和 if 子句的内容进行求值计算而得出。 举例来说,以下列表推导式会将两个列表中不相等的元素组合起来:

    >>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]

    [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

    而它等价于

    >>> combs = []

    >>> for x in [1,2,3]:

    ... for y in [3,1,4]:

    ... if x != y:

    ... combs.append((x, y))

    ...

    >>> combs

    [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

    注意在上面两个代码片段中, for 和 if 的顺序是相同的。

    如果表达式是一个Python元组(例如上面的 (x, y)),那么就必须加上括号

    >>>

    >>> vec = [-4, -2, 0, 2, 4]

    >>> # create a new list with the values doubled

    >>> [x*2 for x in vec]

    [-8, -4, 0, 4, 8]

    >>> # filter the list to exclude negative numbers

    >>> [x for x in vec if x >= 0]

    [0, 2, 4]

    >>> # apply a function to all the elements

    >>> [abs(x) for x in vec]

    [4, 2, 0, 2, 4]

    >>> # call a method on each element

    >>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']

    >>> [weapon.strip() for weapon in freshfruit]

    ['banana', 'loganberry', 'passion fruit']

    >>> # create a list of 2-tuples like (number, square)

    >>> [(x, x**2) for x in range(6)]

    [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]

    >>> # the tuple must be parenthesized, otherwise an error is raised

    >>> [x, x**2 for x in range(6)]

    File "", line 1, in

    [x, x**2 for x in range(6)]

    ^

    SyntaxError: invalid syntax

    >>> # flatten a list using a listcomp with two 'for'

    >>> vec = [[1,2,3], [4,5,6], [7,8,9]]

    >>> [num for elem in vec for num in elem]

    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    列表推导式可以使用复杂的表达式和嵌套函数

    >>> from math import pi

    >>> [str(round(pi, i)) for i in range(1, 6)]

    ['3.1', '3.14', '3.142', '3.1416', '3.14159']

    展开全文
  • 详解Python列表推导

    2021-07-13 16:52:54
    列表推导式可以使用非常简洁的方式对列表或其他可迭代对象的元素进行遍历和过滤,快速生成满足特定需求的列表,代码具有非常强的可读性,是Python程序开发时应用最多的技术之一。Python的内...

    列表推导式可以使用非常简洁的方式对列表或其他可迭代对象的元素进行遍历和过滤,快速生成满足特定需求的列表,代码具有非常强的可读性,是Python程序开发时应用最多的技术之一。Python的内部实现对列表推导式做了大量优化,可以保证很快的运行速度,也是推荐使用的一种技术。列表推导式的语法形式为:

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

    列表推导式在逻辑上等价于一个循环语句,只是形式上更加简洁。例如,

    >>> aList = [x*x for x in range(10)]

    相当于

    >>> aList = []

    >>> for x in range(10):

    aList.append(x*x)

    大家应该知道一个故事,说是阿凡提(也有的说是阿基米德,这不是重点)与国王比赛下棋,国王说要是自己输了的话阿凡提想要什么他都可以拿得出来。阿凡提说那就要点米吧,棋盘一共64个小格子,在第一个格子里放1粒米,第二个格子里放2粒米,第三个格子里放4粒米,第四个格子里放8粒米,以此类推,后面每个格子里的米都是前一个格子里的2倍,一直把64个格子都放满。那么到底需要多少粒米呢,其实使用列表推导式再结合内置函数sum()就很容易知道答案。

    >>> sum([2**i for i in range(64)])

    18446744073709551615

    按一斤大米约26000粒计算,为放满棋盘,需要大概350亿吨大米。结果可想而知,最后国王没有办法拿出那么多米。

    接下来再通过几个示例来进一步展示列表推导式的强大功能。

    (1)实现嵌套列表的平铺

    >>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    >>> [num for elem in vec for num in elem]

    [1, 2, 3, 4, 5, 6, 7, 8, 9] 

    在这个列表推导式中有2个循环,其中第一个循环可以看做是外循环,执行的慢;而第二个循环可以看做是内循环,执行的快。上面代码的执行过程等价于下面的写法:

    >>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    >>> result = []

    >>> for elem in vec:

    for num in elem:

    result.append(num)

    >>> result

    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    当然,这里演示的只是一层嵌套列表的平铺,如果有多级嵌套或者不同子列表嵌套深度不同的话,就不能使用上面的思路了。这时,可以使用函数递归实现。

    (2)过滤不符合条件的元素

    在列表推导式中可以使用if子句对列表中的元素进行筛选,只在结果列表中保留符合条件的元素。例如下面的代码可以列出当前文件夹下所有Python源文件:

    >>> import os

    >>> [filename for filename in os.listdir('.') if filename.endswith('.py')]

    下面的代码用于从列表中选择符合条件的元素组成新的列表:

    >>> aList = [-1, -4, 6, 7.5, -2.3, 9, -11]

    >>> [i for i in aList if i>0]   #所有大于0的数字

    [6, 7.5, 9]

    再例如,已知有一个包含一些同学成绩的字典,现在需要计算所有成绩的最高分、最低分、平均分,并查找所有最高分同学,代码可以这样编写:

    >>> scores = {"Zhang San": 45,

                            "Li Si": 78,

                            "Wang Wu": 40,

                            "Zhou Liu": 96,

                            "Zhao Qi": 65,

                            "Sun Ba": 90,

                            "Zheng Jiu": 78,

                            "Wu Shi": 99,

                            "Dong Shiyi": 60}

    >>> highest = max(scores.values())  #最高分

    >>> lowest = min(scores.values()) #最低分

    >>> average = sum(scores.values())/len(scores)  #平均分

    >>> highest, lowest, average

    (99, 40, 72.33333333333333)

    >>> highestPerson = [name for name, score in scores.items() if score == highest]

    >>> highestPerson

    ['Wu Shi']

    (3)同时遍历多个列表或可迭代对象

    >>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]

    [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

    对于包含多个循环的列表推导式,一定要清楚多个循环的执行顺序或“嵌套关系”。例如,上面的代码等价于

    >>> result = []

    >>> for x in [1, 2, 3]:

    for y in [3, 1, 4]:

    if x != y:

    result.append((x,y))

    >>> result

    [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

    (4)使用列表推导式实现矩阵转置

    >>> matrix = [ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

    >>> [[row[i] for row in matrix] for i in range(4)]

    [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

    对于嵌套了列表推导式的列表推导式,一定要清楚其执行顺序。例如,上面列表推导式的执行过程等价于下面的代码

    >>> matrix = [ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

    >>> result = []

    >>> for i in range(len(matrix[0])):

    result.append([row[i] for row in matrix])

    >>> result

    [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

    如果把内层的列表推导式也展开的话,完整的执行过程可以通过下面的代码来模拟:

    >>> matrix = [ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

    >>> result = []

    >>> for i in range(len(matrix[0])):

    temp = []

    for row in matrix:

    temp.append(row[i])

    result.append(temp)

    >>> result

    [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

    (5)列表推导式中可以使用函数或复杂表达式

    >>> def f(v):

        if v%2 == 0:

            v = v**2

        else:

            v = v+1

        return v

    >>> print([f(v) for v in [2, 3, 4, -1] if v>0])

    [4, 4, 16]

    (6)列表推导式支持文件对象迭代 

    >>> with open('C:\\RHDSetup.log', 'r') as fp:

    print([line for line in fp])

    (7)使用列表推导式生成100以内的所有素数

    >>> from math import sqrt

    >>> [ p for p in range(2, 100) if 0 not in [ p% d for d in range(2, int(sqrt(p))+1)] ]

    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

    展开全文
  • Python 列表推导

    2021-01-29 05:00:31
    一、列表推导式????简介:列表推导式(list comprehension)是利用其它列表创建新列表的一种方式,工作原理类似for循环,即可对得到的元素进行转换或者筛选。1.1、列表推导式的基本格式:变量名=[表达式 for 变量 in ...

    一、列表推导式😘

    简介:列表推导式(list comprehension)是利用其它列表创建新列表的一种方式,工作原理类似for循环,即可对得到的元素进行转换或者筛选。

    1.1、列表推导式的基本格式:

    变量名=[表达式 for 变量 in 列表]

    变量名= [表达式 for 变量 in 列表 if 条件]

    1.2、执行流程:

    遍历出列表中的内容给变量,表达式根据变量值进行逻辑运算。

    或者遍历列表中的内容给变量,然后进行判断,符合的值在给表达式。

    1.3、例子:

    list = [x*x for x in range(10)]

    #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

    #等价于

    list = []

    for x in range(10):

    list.append(x*x)

    list1=[[1,2,3],[4,5,6],[7,8,9]]

    list2=[num for elem in list1 for num in elem]

    #[1, 2, 3, 4, 5, 6, 7, 8, 9]

    #等价于

    list1=[[1,2,3],[4,5,6],[7,8,9]]

    list2=[]

    for elem in list1:

    for num in elem:

    list2.append(num)

    print(num)

    #4 列表表达式 if—else

    #有两种形式

    # 1:[x for x in data if condition]

    #此处的if主要起判断的作用,data数据只有满足if条件的才会留下,最后统一生成一个数据列表

    # 2:[exp1 if condition else exp2 for x in data]

    #此处的if -slse 主要起赋值的作用,如果x满足条件只想exp1不满足执行else

    list = [x for x in range (1,101) if x%3==0]

    print(list)

    p = [x if x %3==0 else -x for x in range(101)]

    print(p)

    二、字典推导式🎈

    简介:字典推导式是列表推导式的延续,语法差不多,只不过产生的是字典而已。

    2.1、字典推导式格式:

    d = {key: value for (key, value) in iterable}

    2.2、例子:

    dic={'k1':20,'k2':10}

    new_dic={value:key for key,value in dic.items()}

    print(new_lst) # {20: 'k1', 10: 'k2'}

    三、集合推导式🎏

    简介:集合推导式跟列表推导式非常相似,唯一区别在于用{}代替[]

    3.1、例子:

    lst=[-2,3,-3,5]

    set1={i**2 for i in lst}

    print(set1) # {9, 4, 25}

    tupledemo = (1,1,2,3,4,5,6,6)

    setnew = {x**2 for x in tupledemo if x%2==0}

    print(setnew)

    展开全文
  • 栏目介绍Python列表推导式的使用。相关免费学习推荐:Python 列表推导式并不是给初学者用的,因为它非常反直觉,甚至对于有其他编程语言背景的人也是如此。我们接触到 List 的使用时,学习的内容都是零散的。所以...
  • Python列表推导式玩法

    2021-04-27 03:11:51
    一些基础的之前已经是反复温习和使用了,今天我们来学习它的进阶版--》列表推导式。列表推导式:优点:是将所有的值一次性加载到内存中,相比于for循环生成的列表执行速度快,并且语法精简,一行代码就完成for循环...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 71,727
精华内容 28,690
关键字:

列表推导

友情链接: magiccolor.rar