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

KOBE

目录

• 简介
  
• 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.1 itertools.repeat()：重复生成相同的项目
    
  • 7.2 itertools.cycle()：通过循环获取无限迭代器
    
  • 7.3 itertools.count()：生成一个无限的数字序列
    
  
  
• 8. itertools.pairwise()：轻松获取成对的元组
  
• 9. itertools.takewhile()：以不同的方式过滤元素
  
• 10. itertools.dropwhile()：itertools.takewhile的反向操作
  

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

简介

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

1. itertools

复制代码

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

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

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

1. list_a = [1, 2020, 70]
   
2. list_b = [2, 4, 7, 2000]
   
3. list_c = [3, 70, 7]
   
4. 
   
5. for a in list_a:
   
6.     for b in list_b:
   
7.         for c in list_c:
   
8.             if a + b + c == 2077:
   
9.                 print(a, b, c)
   
10. # 70 2000 7

复制代码

如何改进上述代码，使其具有Python风格？
可以使用

1. itertools.product()

复制代码

函数：

1. from itertools import product
   
2. 
   
3. list_a = [1, 2020, 70]
   
4. list_b = [2, 4, 7, 2000]
   
5. list_c = [3, 70, 7]
   
6. 
   
7. for a, b, c in product(list_a, list_b, list_c):
   
8.     if a + b + c == 2077:
   
9.         print(a, b, c)
   
10. # 70 2000 7

复制代码

如上所示，它返回输入可迭代对象的笛卡尔积，帮助将3个嵌套的

1. for

复制代码

循环合并为一个。

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

可以通过一个或多个循环来过滤列表中的项目。
但有时候，可能不需要编写任何循环，而是使用函数

1. itertools.compress()

复制代码

。

1. itertools.compress()

复制代码

函数返回一个迭代器，该迭代器根据对应的布尔掩码值对可迭代对象进行过滤。
例如，以下代码使用

1. itertools.compress()

复制代码

函数选择真正的数据：

1. import itertools
   
2. leaders = ['Yang', 'Elon', 'Tim', 'Tom', 'Mark']
   
3. selector = [1, 1, 0, 0, 0]
   
4. print(list(itertools.compress(leaders, selector)))
   
5. # ['Yang', 'Elon']

复制代码

第二个参数

1. selector

复制代码

作为一个掩码，也可以定义为以下形式：

1. selector = [True, True, False, False, False]

复制代码

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

1. itertools.groupby()

复制代码

函数是将可迭代对象中相邻的重复元素进行分组的一种便捷方式。
例如，可以对一个长字符串进行如下分组：

1. from itertools import groupby
   
2. 
   
3. for key, group in groupby('YAaANNGGG'):
   
4.     print(key, list(group))
   
5. # Y ['Y']
   
6. # A ['A']
   
7. # a ['a']
   
8. # A ['A']
   
9. # N ['N', 'N']
   
10. # G ['G', 'G', 'G']

复制代码

此外，还可以利用它的第二个参数来告诉

1. groupby()

复制代码

函数如何判断两个元素是否相同：

1. from itertools import groupby
   
2. 
   
3. for key, group in groupby('YAaANNGGG', lambda x: x.upper()):
   
4.     print(key, list(group))
   
5. # Y ['Y']
   
6. # A ['A', 'a', 'A']
   
7. # N ['N', 'N']
   
8. # G ['G', 'G', 'G']

复制代码

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

对于初学者来说，编写一个正确的函数来获取列表的所有可能组合可能需要一些时间。
实际上，如果使用

1. itertools.combinations()

复制代码

函数，可以很容易地实现：

1. import itertools
   
2. 
   
3. author = ['Y', 'a', 'n', 'g']
   
4. 
   
5. result = itertools.combinations(author, 2)
   
6. 
   
7. for x in result:
   
8.     print(x)
   
9. # ('Y', 'a')
   
10. # ('Y', 'n')
    
11. # ('Y', 'g')
    
12. # ('a', 'n')
    
13. # ('a', 'g')
    
14. # ('n', 'g')

复制代码

如上述程序所示，

1. itertools.combinations()

复制代码

函数有两个参数，一个是原始可迭代对象，另一个是函数生成的子序列的长度。

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

既然有一个函数可以获取所有组合，当然还有另一个名为

1. itertools.permutations

复制代码

的函数可以获取所有可能的排列：

1. import itertools
   
2. 
   
3. author = ['Y', 'a', 'n', 'g']
   
4. 
   
5. result = itertools.permutations(author, 2)
   
6. 
   
7. for x in result:
   
8.     print(x)
   
9. 
   
10. # ('Y', 'a')
    
11. # ('Y', 'n')
    
12. # ('Y', 'g')
    
13. # ('a', 'Y')
    
14. # ('a', 'n')
    
15. # ('a', 'g')
    
16. # ('n', 'Y')
    
17. # ('n', 'a')
    
18. # ('n', 'g')
    
19. # ('g', 'Y')
    
20. # ('g', 'a')
    
21. # ('g', 'n')

复制代码

如上所示，

1. itertools.permutations()

复制代码

函数的使用方式与

1. itertools.combinations()

复制代码

函数类似。唯一的区别在于它们的结果。

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

基于可迭代对象获取一系列累积值是一种常见的需求。借助

1. itertools.accumulate()

复制代码

函数的帮助，不需要编写任何循环就能实现。

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

复制代码

如果不想使用

1. operator.mul

复制代码

，上述程序与以下程序相同：

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

复制代码

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

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

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

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

1. import itertools
   
2. print(list(itertools.repeat('Yang', 3)))
   
3. # ['Yang', 'Yang', 'Yang']

复制代码

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

1. itertools.cycle

复制代码

函数在中断循环之前不会停止：

1. import itertools
   
2. 
   
3. count = 0
   
4. 
   
5. for c in itertools.cycle('Yang'):
   
6.     if count >= 12:
   
7.         break
   
8.     else:
   
9.         print(c, end=',')
   
10.         count += 1
    
11. # Y,a,n,g,Y,a,n,g,Y,a,n,g,

复制代码

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

如果需要的只是数字，可以使用

1. itertools.count

复制代码

函数：

1. import itertools
   
2. 
   
3. for i in itertools.count(0, 2):
   
4.     if i == 20:
   
5.         break
   
6.     else:
   
7.         print(i, end=" ")
   
8. # 0 2 4 6 8 10 12 14 16 18

复制代码

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

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

自Python 3.10以来，

1. itertools

复制代码

模块新增了一个名为

1. pairwise

复制代码

的新函数。它是一个简洁的工具，可以从可迭代对象生成连续重叠的成对元素。

1. import itertools
   
2. 
   
3. letters = ['a', 'b', 'c', 'd', 'e']
   
4. 
   
5. result = itertools.pairwise(letters)
   
6. 
   
7. print(list(result))
   
8. # [('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', 'e')]

复制代码

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

1. itertools.takewhile()

复制代码

返回一个迭代器，只要给定的谓词函数评估为

1. True

复制代码

，该迭代器就会生成可迭代对象中的元素。

1. import itertools
   
2. 
   
3. nums = [1, 61, 7, 9, 2077]
   
4. 
   
5. print(list(itertools.takewhile(lambda x: x < 100, nums)))
   
6. # [1, 61, 7, 9]

复制代码

此函数与内置的

1. filter()

复制代码

函数不同。

1. filter

复制代码

函数将遍历整个列表：

1. nums = [1, 61, 7, 9, 2077]
   
2. 
   
3. print(list(filter(lambda x: x < 10, nums)))
   
4. # [1, 7, 9]

复制代码

然而，

1. itertools.takewhile

复制代码

函数会在评估函数为

1. False

复制代码

时停止：

1. import itertools
   
2. 
   
3. nums = [1, 61, 7, 9, 2077]
   
4. 
   
5. print(list(itertools.takewhile(lambda x: x < 10, nums)))
   
6. # [1]

复制代码

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

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

1. itertools.takewhile()

复制代码

函数在

1. True

复制代码

时返回可迭代对象中的元素，而

1. itertools.dropwhile()

复制代码

函数会在

1. True

复制代码

时删除可迭代对象的元素，并返回剩余的元素。

1. import itertools
   
2. 
   
3. nums = [1, 61, 7, 9, 2077]
   
4. 
   
5. print(list(itertools.dropwhile(lambda x: x < 100, nums)))
   
6. # [2077]

复制代码

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

可爱的游戏世界

这个话题真是有趣，我也对它感兴趣。

邓桑旦

嘎嘎嘎嘎嘎嘎嘎

wanghanqun

牛逼

龘龘龘爨

谢谢你分享这个信息

春風秋雨

顶一个，观点非常中肯！

strikefreedome

太棒了！感谢分享这个信息！

水・夫

感谢分享，受益匪浅！

无形杀金士顿

嘎嘎嘎嘎嘎嘎嘎

快乐的阳光888

我不太确定，可能需要再确认一下。