10个Python Itertools方法助你事半功倍

2024-04-18 0 770
目录
  • 简介
  • 1.itertools.product():避免嵌套循环的巧妙方式
  • 2.itertools.compress():过滤数据的便捷方式
  • 3.itertools.groupby():对可迭代对象进行分组
  • 4.itertools.combinations():获取可迭代对象中给定长度的所有组合
  • 5.itertools.permutations(): 获取可迭代对象中给定长度的所有排列
  • 6.itertools.accumulate():从可迭代对象生成累积项
  • 7.itertools.repeat(),itertools.cycle(),itertools.count():创建无限迭代器
    • 7.1itertools.repeat():重复生成相同的项目
    • 7.2itertools.cycle():通过循环获取无限迭代器
    • 7.3itertools.count():生成一个无限的数字序列
  • 8.itertools.pairwise():轻松获取成对的元组
    • 9.itertools.takewhile():以不同的方式过滤元素
      • 10.itertools.dropwhile():itertools.takewhile的反向操作

        用更短的代码实现相同的功能,使用10个PythonItertools方法让代码更简洁。

        简介

        Python的编程优势在于它的简洁性。这不仅是因为Python语法优雅,还因为它有许多精心设计的内置模块,可以帮助开发者高效地实现常用功能。

        itertools模块就是一个很好的例子,它为开发者提供了许多强大的工具,可以用更短的代码来操作Python的可迭代对象,帮助开发者事半功倍地完成任务。

        1.itertools.product():避免嵌套循环的巧妙方式

        当程序变得越来越复杂时,可能需要编写嵌套循环。与此同时,Python代码将变得丑陋和难以阅读:

        list_a = [1, 2020, 70]
        list_b = [2, 4, 7, 2000]
        list_c = [3, 70, 7]

        for a in list_a:
        for b in list_b:
        for c in list_c:
        if a + b + c == 2077:
        print(a, b, c)
        # 70 2000 7

        如何改进上述代码,使其具有Python风格?

        可以使用itertools.product()函数:

        from itertools import product

        list_a = [1, 2020, 70]
        list_b = [2, 4, 7, 2000]
        list_c = [3, 70, 7]

        for a, b, c in product(list_a, list_b, list_c):
        if a + b + c == 2077:
        print(a, b, c)
        # 70 2000 7

        如上所示,它返回输入可迭代对象的笛卡尔积,帮助将3个嵌套的for循环合并为一个。

        2.itertools.compress():过滤数据的便捷方式

        可以通过一个或多个循环来过滤列表中的项目。

        但有时候,可能不需要编写任何循环,而是使用函数itertools.compress()。

        itertools.compress()函数返回一个迭代器,该迭代器根据对应的布尔掩码值对可迭代对象进行过滤。

        例如,以下代码使用itertools.compress()函数选择真正的数据:

        import itertools
        leaders = [\’Yang\’, \’Elon\’, \’Tim\’, \’Tom\’, \’Mark\’]
        selector = [1, 1, 0, 0, 0]
        print(list(itertools.compress(leaders, selector)))
        # [\’Yang\’, \’Elon\’]

        第二个参数selector作为一个掩码,也可以定义为以下形式:

        selector = [True, True, False, False, False]

        3.itertools.groupby():对可迭代对象进行分组

        itertools.groupby()函数是将可迭代对象中相邻的重复元素进行分组的一种便捷方式。

        例如,可以对一个长字符串进行如下分组:

        from itertools import groupby

        for key, group in groupby(\’YAaANNGGG\’):
        print(key, list(group))
        # Y [\’Y\’]
        # A [\’A\’]
        # a [\’a\’]
        # A [\’A\’]
        # N [\’N\’, \’N\’]
        # G [\’G\’, \’G\’, \’G\’]

        此外,还可以利用它的第二个参数来告诉groupby()函数如何判断两个元素是否相同:

        from itertools import groupby

        for key, group in groupby(\’YAaANNGGG\’, lambda x: x.upper()):
        print(key, list(group))
        # Y [\’Y\’]
        # A [\’A\’, \’a\’, \’A\’]
        # N [\’N\’, \’N\’]
        # G [\’G\’, \’G\’, \’G\’]

        4.itertools.combinations():获取可迭代对象中给定长度的所有组合

        对于初学者来说,编写一个正确的函数来获取列表的所有可能组合可能需要一些时间。

        实际上,如果使用itertools.combinations()函数,可以很容易地实现:

        import itertools

        author = [\’Y\’, \’a\’, \’n\’, \’g\’]

        result = itertools.combinations(author, 2)

        for x in result:
        print(x)
        # (\’Y\’, \’a\’)
        # (\’Y\’, \’n\’)
        # (\’Y\’, \’g\’)
        # (\’a\’, \’n\’)
        # (\’a\’, \’g\’)
        # (\’n\’, \’g\’)

        如上述程序所示,itertools.combinations()函数有两个参数,一个是原始可迭代对象,另一个是函数生成的子序列的长度。

        5.itertools.permutations(): 获取可迭代对象中给定长度的所有排列

        既然有一个函数可以获取所有组合,当然还有另一个名为itertools.permutations的函数可以获取所有可能的排列:

        import itertools

        author = [\’Y\’, \’a\’, \’n\’, \’g\’]

        result = itertools.permutations(author, 2)

        for x in result:
        print(x)

        # (\’Y\’, \’a\’)
        # (\’Y\’, \’n\’)
        # (\’Y\’, \’g\’)
        # (\’a\’, \’Y\’)
        # (\’a\’, \’n\’)
        # (\’a\’, \’g\’)
        # (\’n\’, \’Y\’)
        # (\’n\’, \’a\’)
        # (\’n\’, \’g\’)
        # (\’g\’, \’Y\’)
        # (\’g\’, \’a\’)
        # (\’g\’, \’n\’)

        如上所示,itertools.permutations()函数的使用方式与itertools.combinations()函数类似。唯一的区别在于它们的结果。

        6.itertools.accumulate():从可迭代对象生成累积项

        基于可迭代对象获取一系列累积值是一种常见的需求。借助itertools.accumulate()函数的帮助,不需要编写任何循环就能实现。

        import itertools
        import operator

        nums = [1, 2, 3, 4, 5]
        print(list(itertools.accumulate(nums, operator.mul)))
        # [1, 2, 6, 24, 120]

        如果不想使用operator.mul,上述程序与以下程序相同:

        import itertools

        nums = [1, 2, 3, 4, 5]
        print(list(itertools.accumulate(nums, lambda a, b: a * b)))
        # [1, 2, 6, 24, 120]

        7.itertools.repeat(),itertools.cycle(),itertools.count():创建无限迭代器

        在某些情况下,开发者需要获得一个无限迭代器。有3个函数可以帮助实现:

        7.1itertools.repeat():重复生成相同的项目

        例如,可以按以下方式获取三个相同的“Yang”:

        import itertools
        print(list(itertools.repeat(\’Yang\’, 3)))
        # [\’Yang\’, \’Yang\’, \’Yang\’]

        7.2itertools.cycle():通过循环获取无限迭代器

        itertools.cycle函数在中断循环之前不会停止:

        import itertools

        count = 0

        for c in itertools.cycle(\’Yang\’):
        if count >= 12:
        break
        else:
        print(c, end=\’,\’)
        count += 1
        # Y,a,n,g,Y,a,n,g,Y,a,n,g,

        7.3itertools.count():生成一个无限的数字序列

        如果需要的只是数字,可以使用itertools.count函数:

        import itertools

        for i in itertools.count(0, 2):
        if i == 20:
        break
        else:
        print(i, end=\” \”)
        # 0 2 4 6 8 10 12 14 16 18

        如上所示,它的第一个参数是起始数字,第二个参数是步长。

        8.itertools.pairwise():轻松获取成对的元组

        自Python 3.10以来,itertools模块新增了一个名为pairwise的新函数。它是一个简洁的工具,可以从可迭代对象生成连续重叠的成对元素。

        import itertools

        letters = [\’a\’, \’b\’, \’c\’, \’d\’, \’e\’]

        result = itertools.pairwise(letters)

        print(list(result))
        # [(\’a\’, \’b\’), (\’b\’, \’c\’), (\’c\’, \’d\’), (\’d\’, \’e\’)]

        9.itertools.takewhile():以不同的方式过滤元素

        itertools.takewhile()返回一个迭代器,只要给定的谓词函数评估为True,该迭代器就会生成可迭代对象中的元素。

        import itertools

        nums = [1, 61, 7, 9, 2077]

        print(list(itertools.takewhile(lambda x: x < 100, nums)))
        # [1, 61, 7, 9]

        此函数与内置的filter()函数不同。

        filter函数将遍历整个列表:

        nums = [1, 61, 7, 9, 2077]

        print(list(filter(lambda x: x < 10, nums)))
        # [1, 7, 9]

        然而,itertools.takewhile函数会在评估函数为False时停止:

        import itertools

        nums = [1, 61, 7, 9, 2077]

        print(list(itertools.takewhile(lambda x: x < 10, nums)))
        # [1]

        10.itertools.dropwhile():itertools.takewhile的反向操作

        这个函数是上一个函数的逆操作。

        itertools.takewhile()函数在True时返回可迭代对象中的元素,而itertools.dropwhile()函数会在True时删除可迭代对象的元素,并返回剩余的元素。

        import itertools

        nums = [1, 61, 7, 9, 2077]

        print(list(itertools.dropwhile(lambda x: x < 100, nums)))
        # [2077]

        到此这篇关于Python中itertools高效迭代工具的文章就介绍到这了,更多相关Python itertools内容请搜索悠久资源网以前的文章或继续浏览下面的相关文章希望大家以后多多支持悠久资源网!

        您可能感兴趣的文章:

        • Python itertools模块详解
        • Python中itertools模块用法详解
        • python中的itertools的使用详解
        • Python标准库之itertools库的使用方法
        • Python使用itertools模块实现排列组合功能示例
        • 在Python中使用itertools模块中的组合函数的教程
        • 介绍Python中内置的itertools模块

        收藏 (0) 打赏

        感谢您的支持,我会继续努力的!

        打开微信/支付宝扫一扫,即可进行扫码打赏哦,分享从这里开始,精彩与您同在
        点赞 (0)

        悠久资源 Python 10个Python Itertools方法助你事半功倍 https://www.u-9.cn/jiaoben/python/186999.html

        常见问题

        相关文章

        发表评论
        暂无评论
        官方客服团队

        为您解决烦忧 - 24小时在线 专业服务