python-- toolz.itertoolz

Posted 2020-11-14 Marvin_Tang

2019.9.25:

　　 toolz 是十分便利的工具

 

学习内容：itertoolz

---

  

一、Itertoolz：

1、accumulate（binop, seq, initial）:

　　反复将二进制函数应用于序列，累积结果，返回迭代器

　　如果有initial，新序列第一个值就是initial，不然就是seq的第一个值

>>> from operator import add, mul
>>> list(accumulate(add, [1, 2, 3, 4, 5]))
[1, 3, 6, 10, 15]
>>> list(accumulate(mul, [1, 2, 3, 4, 5]))
[1, 2, 6, 24, 120]

插一句：operator有以下方法提供：

__all__ = [\'abs\', \'add\', \'and_\', \'attrgetter\', \'concat\', \'contains\', \'countOf\',
           \'delitem\', \'eq\', \'floordiv\', \'ge\', \'getitem\', \'gt\', \'iadd\', \'iand\',
           \'iconcat\', \'ifloordiv\', \'ilshift\', \'imatmul\', \'imod\', \'imul\',
           \'index\', \'indexOf\', \'inv\', \'invert\', \'ior\', \'ipow\', \'irshift\',
           \'is_\', \'is_not\', \'isub\', \'itemgetter\', \'itruediv\', \'ixor\', \'le\',
           \'length_hint\', \'lshift\', \'lt\', \'matmul\', \'methodcaller\', \'mod\',
           \'mul\', \'ne\', \'neg\', \'not_\', \'or_\', \'pos\', \'pow\', \'rshift\',
           \'setitem\', \'sub\', \'truediv\', \'truth\', \'xor\']

 

2、groupby(key, seq):

　　序列：

>>> names = [\'Alice\', \'Bob\', \'Charlie\', \'Dan\', \'Edith\', \'Frank\']
>>> groupby(len, names)  # doctest: +SKIP
{3: [\'Bob\', \'Dan\'], 5: [\'Alice\', \'Edith\', \'Frank\'], 7: [\'Charlie\']}

　　序列嵌套字典：通过key对 List[dict] 分组，注意结果⚠️

>>> groupby(\'gender\', [{\'name\': \'Alice\', \'gender\': \'F\'},
...                    {\'name\': \'Bob\', \'gender\': \'M\'},
...                    {\'name\': \'Charlie\', \'gender\': \'M\'}]) # doctest:+SKIP
{\'F\': [{\'gender\': \'F\', \'name\': \'Alice\'}],
 \'M\': [{\'gender\': \'M\', \'name\': \'Bob\'},
       {\'gender\': \'M\', \'name\': \'Charlie\'}]}

 

3、merge_sorted(*seqs, key=None)：

　　合并序列，并排序。返回惰性迭代器。

 

4、interleave(seqs):

　　交替合并序列，返回惰性迭代器（不解包不执行）

 

5、unique（seq，key=None）：

　　类似集合的特性，保持元素唯一性，同时很灵活的可以通过key做唯一性的约定

 

6、isiterable(x) :

　　返回布尔值，x是否可迭代的。

 

7、isdistinct（seq）：

　　返回布尔值，seq中元素是否不重复。

 

8、take（n， seq）：

　　返回序列的前n个元素。

 

9、drop（n， seq）：

　　返回序列的除前n个元素的其他元素，返回迭代器。

 

10、take_nth（n， seq）：

　　隔n-1个元素取出一个，并加入到迭代器.

from toolz import take_nth

seq = [1,2,3,4,5,6,7,8,9,0]
take_nth(seq, 3)
list(take_nth(3, seq))

>>>[1, 4, 7, 0]

 

11、first（seq）或 second（seq）或 nth（n， seq）或last（seq）：

　　返回seq的第一或二或n或最后一个元素。

 

12、get（ind， seq， default=\'__ no__default__\'）：

　　返回迭代器。

　　序列：等同 seq[x] for x in ind

　　字典：获取指定key的value 

 

13、concat(seqs): 

　　列表嵌套列表：拆开子列表，不做去重和排序，返回迭代器。可被set（）强转达到去重的目的

>>> list(concat([[], [1], [2, 3]]))
[1, 2, 3]

 

14、cons（el，seq）：

　　将el插到seq序列的开头。

 

15、interpose（el，seq）： 

　　seq每个元素中间都插一个el。

>>> list(interpose("a", [1, 2, 3]))
[1, \'a\', 2, \'a\', 3]

 

16、frequencies（seq）：

　　

 

17、reduceby（key，binop，seq，init =\'__ no__default__\'）：

　　后续补充

 

18、iterate（func， x）：

　　反复将函数func应用于原始输入。

　　例如：产生x，然后是func（x），然后是func（func（x）），然后是func（func（func（x））），依此类推。

　　通过next（）产生下一个结果

 

19、sliding_window（n，seq）：

　　产生重叠为n位的子序列：

>>> list(sliding_window(2, [1, 2, 3, 4]))
[(1, 2), (2, 3), (3, 4)]

 

20、partition（n，seq，pad =\'__ no__pad__\'）：

　　按照n，将序列拆分成元组，不重叠。如果的长度seq不能被整除n，则最后的元组将被丢弃（如果pad未指定），或通过填充填充至长度n。pad是填充值。

 

21、partition_all（n， seq）：

　　和partition区别是，突出的元素不会被丢弃或填充，只是独立成一个元组

 

22、diff（*seq， **kwargs， default=\'__ no__default__\'， key=None）：

　　将序列之间不同的元素，最多两个，组成一个元组。如果有奇数个元素不同，最后那个元素可能丢弃（除非default存在填充）。key将一个函数应用于每个项目。

 

23、topk（k，seq，key=None）：

　　找出序列的k个最大元素。key设定挑选规则

 

 

24、peek（seq）：

　　返回两个值，一个是seq的第一个元素，另一个是该原始seq。

 

25、recipes.countby(key, seq): 

　　针对key制定的规则对seq进行计数：

 

26、recipes.partitionby(func, seq)：

　　根据func对seq进行分区。每次func的输出更改时 ，都会启动一个新列表，并将后续项目收集到该列表中。