• 第二章:25+ Python 数据操作教程(第十六节PYTHON 列表理解:通过示例学习)持续更新中


    本教程介绍列表理解在 Python 中的工作原理。它包含许多示例,可以帮助您熟悉这个概念,并且您应该能够在本课程结束时在您的实际项目中实现它。 

    目录

    什么是列表理解?

    列表推导式 vs. For 循环 vs. Lambda + map()

    列表理解:IF-ELSE

    使用列表理解过滤字典

    在 Pandas DataFrame 上使用列表理解

    如何对多列进行操作?

    将字符变量转换为整数

    嵌套列表理解

    列表中字典的列表理解

    如何从列表创建元组

    使用列表理解将句子拆分为单词

    什么是列表理解?

    列表推导式 vs. For 循环 vs. Lambda + map()

    列表理解:IF-ELSE

    使用列表理解过滤字典

    在 Pandas DataFrame 上使用列表理解

    如何对多列进行操作?

    将字符变量转换为整数

    嵌套列表理解

    列表中字典的列表理解

    如何从列表创建元组

    使用列表理解将句子拆分为单词


    什么是列表理解?

    Python 是一种面向对象的编程语言。其中几乎所有东西都被一致地视为一个对象。Python 还具有函数式编程的特点,这与解决问题的数学方法非常相似,在函数中分配输入,并且使用相同的输入值获得相同的输出。给定一个函数,f(x) 将始终返回具有相同 x 值的相同结果。该函数没有“副作用”,这意味着操作对超出预期用途的变量/对象没有影响。“副作用”是指代码中的泄漏,它可以修改可变数据结构或变量。 f(x) = x2

    函数式编程也有利于并行计算,因为没有共享数据或对同一变量的访问。

    列表理解是函数式编程的一部分,它提供了一种无需编写 for 循环即可创建列表的简洁方法。
    在上图中,for clause迭代列表的每个项目。if clause过滤器列出并仅返回满足过滤条件的项目。if 子句是可选的,因此如果没有条件语句,可以忽略它。

    [i**3 for i in [1,2,3,4] if i>2]意思是迭代地从列表[1,2,3,4]中取出一项,然后检查它是否大于2。如果是,则取它的立方。否则,如果该值小于或等于 2,则忽略该值。稍后,它会创建值 3 和 4 的立方体列表。 Output : [27, 64]

    列表推导式 vs. For 循环 vs. Lambda + map()

    所有这三个都有不同的编程风格来迭代列表的每个元素,但它们具有相同的目的或返回相同的输出。它们之间存在一些差异,如下所示。
    1. 列表推导式比 For 循环和 Lambda 函数更具可读性。
    列表理解
    [i**2 表示 i 在范围 (2,10) 内]
    [i**2 for i in range(2,10)]
    For循环
    平方根 = []
    对于范围 (2,10) 内的 i:
        sqr.append(i**2)
    平方根
    1. sqr = []
    2. for i in range(2,10):
    3. sqr.append(i**2)
    4. sqr
    拉姆达 + 地图
    列表(地图(lambda i: i**2, 范围(2, 10)))
    list(map(lambda i: i**2, range(2, 10)))
    输出
    [4, 9, 16, 25, 36, 49, 64, 81]
    1. Output
    2. [4, 9, 16, 25, 36, 49, 64, 81]
    列表理解正在执行循环操作,然后仅用一行代码将项目组合到列表中。它比 for 循环和 lambda 更容易理解、更清晰。

    range(2,10)返回 2 到 9(不包括 10)。

    **2指的是平方(数字的 2 次方)。sqr = []创建空列表。append( )函数在 for 循环中存储序列每次重复的输出(即平方值)。

    map( )将 lambda 函数应用于可迭代(列表)的每个项目。将其包装起来list( )以生成列表作为输出

    2.列表理解比For循环和Lambda函数稍快。
    这里我们测量这 3 个方法的代码执行时间。仅当某个值是偶数(可被 2 整除)时,我们才会一一计算从 1 到 1000 万的值的平方。
    If 语句if x%2 == 0检查一个数是否为偶数。例如,5 % 2返回 1,即余数。如果余数为0,则表示是偶数。
    列表理解
    l1= [x**2 for x in range(1, 10**7) if x % 2 == 0]
    
    # 处理时间:3.96 秒
    1. l1= [x**2 for x in range(1, 10**7) if x % 2 == 0]
    2. # Processing Time : 3.96 seconds
    For循环
    平方根 = []
    对于范围 (1, 10**7) 内的 x:
        如果 x%2 == 0:
            sqr.append(x**2)
    
    # 处理时间:5.46 秒
    1. sqr = []
    2. for x in range(1, 10**7):
    3. if x%2 == 0:
    4. sqr.append(x**2)
    5. # Processing Time : 5.46 seconds
    Lambda + Map()
    l0 = 列表(映射(lambda x: x**2, 过滤器(lambda x: x%2 == 0, 范围(1, 10**7))))
    
    # 处理时间:5.32 秒
    1. l0 = list(map(lambda x: x**2, filter(lambda x: x%2 == 0, range(1, 10**7))))
    2. # Processing Time : 5.32 seconds
    filter(lambda x: x%2 == 0, range(1, 10**7))返回 1 到(10 的 7 次方)之间的偶数,因为 filter() 函数用于从列表中提取项目子集。粗略地说,您可以将 filter() 视为WHERESQL 子句。

    列表理解:IF-ELSE

    在这里,我们告诉 python 如果字符串长度大于 4,则将列表中每个项目的文本转换为大写字母。否则,将文本转换为小写字母。upper( )将字符串转换为大写。同样,您可以使用lower( )函数将字符串转换为小写。
    列表理解
    mylist = ['戴夫', '迈克尔', '深渊']
    [x.upper() if len(x)>4 else x.lower() for x in mylist]
    1. mylist = ['Dave', 'Micheal', 'Deeps']
    2. [x.upper() if len(x)>4 else x.lower() for x in mylist]
    For循环
    k = []
    对于我的列表中的 x:
        如果 len(x) > 4:
            k.append(x.upper())
        别的:
            k.append(x.lower())
    k
    1. k = []
    2. for x in mylist:
    3. if len(x) > 4:
    4. k.append(x.upper())
    5. else:
    6. k.append(x.lower())
    7. k

    使用列表理解过滤字典

    假设您有一个字典并且您想要选择特定的键和特定的值。简而言之,您希望将条件语句应用于IF子集或过滤字典。
    d = {'a': [1,2,1], 'b': [3,4,1], 'c': [5,6,2]}
    d = {'a': [1,2,1], 'b': [3,4,1], 'c': [5,6,2]}
    按值过滤字典
    这里我们选择 b 大于 2 的值。
    [x for x in d['b'] if x >2]
    
    输出
    [(3, 4)]
    1. [x for x in d['b'] if x >2]
    2. Output
    3. [(3, 4)]
    按多个条件过滤字典
    这里我们应用条件 - 仅选择 a 等于 1 并且 b 大于 1 的值。
    [(x,y) for x, y in zip(d['a'],d['b']) if x == 1 and y > 1]
    
    输出
    [(1, 3)]
    1. [(x,y) for x, y in zip(d['a'],d['b']) if x == 1 and y > 1]
    2. Output
    3. [(1, 3)]
    在上面的程序中,x 指的是 d['a'],y 指的是 d['b']。
    过滤所有值都大于1的字典
    all( )检查列表中所有值的条件。它返回 True/False。

    k指的是字典的键,v指的是字典的值。

    [(k,v) for k,v in d.items() if all(x > 1 for x in v) ]
    
    输出
    [('c', [5, 6, 2])]
    1. [(k,v) for k,v in d.items() if all(x > 1 for x in v) ]
    2. Output
    3. [('c', [5, 6, 2])]
    只有键c包含全部大于 1 的值。类似地,我们有一个any( )函数,如果任何值满足条件,则返回 True。
    [(k,v) for k,v in d.items() if any(x > 2 for x in v) ]
    
    输出
    [('b', [3, 4, 1]), ('c', [5, 6, 2])]
    1. [(k,v) for k,v in d.items() if any(x > 2 for x in v) ]
    2. Output
    3. [('b', [3, 4, 1]), ('c', [5, 6, 2])]

    在 Pandas DataFrame 上使用列表理解

    在现实世界中,我们通常将数据存储在 CSV 或关系数据库中。我们通常将其转换为pandas数据框,然后进行数据清理和操作。因此,学习如何在数据帧上使用列表理解非常重要。假设您有一个包含员工姓名以及当前和以前工资的数据框。让我们创建一个 pandas 数据框来进行说明。
    将 pandas 导入为 pd
    df = pd.DataFrame({'name': ['Sandy', 'Sam', 'Wright', 'Atul'],
            '预薪': [71, 65, 64, 90],                   
            '下一个工资': [75, 80, 61, 89]})
    df
    1. import pandas as pd
    2. df = pd.DataFrame({'name': ['Sandy', 'Sam', 'Wright', 'Atul'],
    3. 'prevsalary': [71, 65, 64, 90],
    4. 'nextsalary': [75, 80, 61, 89]})
    5. df
         姓名 前工资 下工资
    0 桑迪 71 75
    1 萨姆 65 80
    2 赖特 64 61
    3 阿图尔 90 89
    1. name prevsalary nextsalary
    2. 0 Sandy 71 75
    3. 1 Sam 65 80
    4. 2 Wright 64 61
    5. 3 Atul 90 89
    我们需要创建一个名为“Flag”的列,其值为“High Bracket”或“Low Bracket”。如果列的值prevsalary大于 70,则应将其标记为“高括号”。否则将其指定为“低括号”。
    df['Flag'] = ["高括号" if x > 70 else "低括号" for x in df['prevsalary']]
    df['Flag'] = ["High Bracket" if x > 70 else "Low Bracket" for x in df['prevsalary']]
    上面的代码行在 df 数据框中生成了一个新列。
         名称 prevsalary nextsalary 标志
    0 桑迪 71 75 高支架
    1 Sam 65 80 低支架
    2 莱特 64 61 低支架
    3 Atul 90 89 高支架
    1. name prevsalary nextsalary Flag
    2. 0 Sandy 71 75 High Bracket
    3. 1 Sam 65 80 Low Bracket
    4. 2 Wright 64 61 Low Bracket
    5. 3 Atul 90 89 High Bracket

    如何对多列进行操作?

    假设您要比较两个变量(列)prevsalarynextsalary。如果 prevsalary > nextsalary,则将其分类为“增加”。否则填充“减少”值。
    df['Flag2'] = [“增加”如果 x > y 否则“减少” for (x,y) in zip(df['nextsalary'],df['prevsalary'])]
    df['Flag2'] = ["Increase" if x > y  else "Decrease" for (x,y) in zip(df['nextsalary'],df['prevsalary'])]
         名称 prevsalary nextsalary Flag Flag2
    0 桑迪 71 75 高括号增加
    1 Sam 65 80 低支架增加
    2 赖特 64 61 低括号减少
    3 Atul 90 89 高括号减少
    1. name prevsalary nextsalary Flag Flag2
    2. 0 Sandy 71 75 High Bracket Increase
    3. 1 Sam 65 80 Low Bracket Increase
    4. 2 Wright 64 61 Low Bracket Decrease
    5. 3 Atul 90 89 High Bracket Decrease

    这里我们在列表理解中比较两个变量 x 和 y
    x = df['nextsalary'], y = df['prevsalary']

    将字符变量转换为整数

    假设您有一个包含数值的列,但该列被定义为字符变量(对象列类型)。您需要将其转换为整数。当您从某些在线门户读取数据或表的某些列以 char 或 varchar 格式存储在关系数据库中时,这是一个常见问题。例如,让我们创建一个数据框。
    将 pandas 导入为 pd
    df = pd.DataFrame({"col1" : ['1', '2', '3']})
    1. import pandas as pd
    2. df = pd.DataFrame({"col1" : ['1', '2', '3']})
    df['col2'] = [int(x) for x in df['col1']]
    df['col2'] = [int(x) for x in df['col1']]
    请参阅下面的输出。col2具有整数列类型。
    列1 对象
    列2 int64
    1. col1 object
    2. col2 int64
    这可以在没有列表理解的情况下解决,因为 pandas 具有相同的内置函数df['col2'] = df['col1'].astype(int)

    嵌套列表理解

    相当于多个for循环。嵌套列表理解的标准语法如下所示

    假设您有一个列表列表,并且您只想选择奇数。任何不能被 2 整除的数都是奇数。
    列表理解
    mat = [[1,2],[3,4],[5,6]]
    [x 表示垫中的行,表示行中的 x,如果 x%2==1]
    1. mat = [[1,2], [3,4], [5,6]]
    2. [x for row in mat for x in row if x%2==1]

    多重For循环

    b = []
    对于垫子中的行:
        对于行中的 x:
            如果 x%2 == 1:
                b.追加(x)
    
    b
    1. b = []
    2. for row in mat:
    3. for x in row:
    4. if x%2 == 1:
    5. b.append(x)
    6. b
    如果你观察上面的语法并比较它们,你会发现它们非常相似。
    输出
    [1, 3, 5]
    1. Output
    2. [1, 3, 5]

    列表中字典的列表理解

    假设您有一个包含多个字典的列表,并且您想要对值应用过滤并选择特定键。
    mylist = [{'a': 1, 'b': 2}, {'a': 3, 'b': 4}, {'a': 5, 'b': 6}]
    mylist = [{'a': 1, 'b': 2}, {'a': 3, 'b': 4}, {'a': 5, 'b': 6}]
    在下面的代码中,我们仅选择键a以及该键大于 1 的所有值。
    [i['a'] for i in mylist if 'a' in i if i['a'] > 1]
    
    输出
    [3, 5]
    1. [i['a'] for i in mylist if 'a' in i if i['a'] > 1]
    2. Output
    3. [3, 5]

    如何从列表创建元组

    想法是通过应用具有列表理解的多个循环来准备所有可能的组合。
    l1 = ['a','b']
    l2 = ['c','d']
    [(x,y) 对于 l1 中的 x 对于 l2 中的 y]
    1. l1 = ['a','b']
    2. l2 = ['c','d']
    3. [(x,y) for x in l1 for y in l2]
    输出
    [('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd')]
    1. Output
    2. [('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd')]

    使用列表理解将句子拆分为单词

    在文本挖掘中,将句子分解为单词是初始数据清理步骤之一。拆分之前,请确保所有单词都转换为小写或大写,以避免相同内容出现多个单词。
    text = [“生活是美好的”,“无需过度思考”,“冥想有助于克服抑郁症”]
    
    [文本中的单词对句子中的单词对句子中的单词.lower().split(' ')]
    
    ['生活',
     '是',
     '美丽的',
     '不',
     '需要',
     '到',
     '想多了',
     '冥想',
     '帮助',
     '在',
     ‘克服’,
     '沮丧']
    1. ['life',
    2. 'is',
    3. 'beautiful',
    4. 'no',
    5. 'need',
    6. 'to',
    7. 'overthink',
    8. 'meditation',
    9. 'help',
    10. 'in',
    11. 'overcoming',
    12. 'depression']
    怎么运行的?
    1. for sentence in text表示循环遍历列表中的每个句子text
    2. text[0].lower().split(' ')转换为小写,然后将句子分成单词并返回['life', 'is', 'beautiful']
    练习练习
    以下是可以帮助您获得实践经验的练习。解决并将您的解决方案粘贴到下面的评论框中。

    1.is, in, to, notext列表中删除这些单词。所需的输出应如下 -

    '生活',
     '美丽的',
     '需要',
     '想多了',
     '冥想',
     '帮助',
     ‘克服’,
     '沮丧'
    1. 'life',
    2. 'beautiful',
    3. 'need',
    4. 'overthink',
    5. 'meditation',
    6. 'help',
    7. 'overcoming',
    8. 'depression'

    2. 在列表中查找匹配的号码。

    x = [51, 24, 32, 41]
    y = [42, 32, 41, 50]
    1. x = [51, 24, 32, 41]
    2. y = [42, 32, 41, 50]
    输出应为 [32, 41]

    3.如果列表元素在30到45之间,则为1,否则为0

    x = [51, 24, 32, 41]
    

    输出:[0,0,1,1]

    1. x = [51, 24, 32, 41]
    2. Output : [0, 0, 1, 1]
  • 相关阅读:
    程序员常用linux命令
    一文带你深入理解【Java基础】· Java集合(下)
    ovs vxlan实现代码分析
    Docker 使用原理流程
    财务体验/看透人生穷富的关键
    【Pm4py第六讲】关于合规性检查
    ReentrantLock与ReentrantReadWirteLock 原理
    数字化时代,数据分析到底有什么意义
    保姆级JAVA 性能指标、压测入门
    蛇岛狂蟒出没
  • 原文地址:https://blog.csdn.net/wly476923083/article/details/132703171