3. 有点难~ Python函数式编程中 itertools 模块

绝地灬酷狼 2022-09-10 13:14 248阅读 0赞

本篇博客将为你介绍 `itertools` 模块中处理可迭代集合的相关函数。

## 容器与可迭代对象 ##

在正式开始前先补充一些基本概念在 Python 中存在**容器** 与 **可迭代对象**

*  容器：用来存储多个元素的数据结构，例如 列表，元组，字典，集合等内容；
 *  可迭代对象：实现了 `__iter__` 方法的对象就叫做可迭代对象。

从可迭代对象中还衍生出 **迭代器** 与 **生成器**：

*  迭代器：既实现了 `__iter__`，也实现了 `__next__` 方法的对象叫做迭代器；
 *  生成器：具有 `yield` 关键字的函数都是生成器。

这样就比较清楚了，可迭代对象的范围要大于容器。而且**可迭代对象只能使用一次**，使用完毕再获取值就会提示 `StopIteration` 异常。

除此之外，**可迭代对象**还有一些限制：

*  不能对可迭代对象使用 `len` 函数；
 *  可以使用 `next` 方法处理可迭代对象，**容器**也可以通过 `iter` 函数转换成迭代器；
 *  for 语句会自动调用容器的 `iter` 函数，所以容器也能被循环迭代。

## count() 函数 ##

`count` 函数一般与 `range` 函数对比学习，例如 `range` 函数需要定义生成范围的下限，上限与步长可选，而 `count` 函数不同，指定下限与步长，上限值不用声明。

函数原型声明如下

count(start=0, step=1) --> count object

测试代码如下，其中必须添加跳出循环的判定条件，否则代码会一直运行下去。

from itertools import count
    
    a = count(5, 10)
    for i in a:
        print(i)
        if i > 100:
            break

除此之外，`count` 函数还接收非整数参数，所以下述代码中定义的也是正确的。

from itertools import count
    
    a = count(0.5, 0.1)
    for i in a:
        print(i)
        if i > 100:
            break

## cycle 函数 ##

用 `cycle` 函数可以循环一组值，测试代码如下所示：

from itertools import cycle
    
    x = cycle('梦想橡皮擦abcdf')
    for i in range(5):
        print(next(x), end=" ")
    print("\n")
    print("*" * 100)
    for i in range(5):
        print(next(x), end=" ")

代码输出如下内容：

梦 想 橡 皮 擦
    
    ****************************************************************************************************
    a b c d f

可以看到 `cycle` 函数与 `for` 循环非常类似。

## repeat 函数 ##

`repeat` 函数用于**重复返回某个值**，官方给出的函数描述如下所示：

class repeat(object):
        """
        repeat(object [,times]) -> create an iterator which returns the object
        for the specified number of times.  If not specified, returns the object
        endlessly.

进行一下简单的测试，看一下效果：

from itertools import repeat
    
    x = repeat('橡皮擦')
    for i in range(5):
        print(next(x), end=" ")
    print("\n")
    print("*" * 100)
    for i in range(5):
        print(next(x), end=" ")

怎么看这个函数，都好像没有太大用处。

## enumerate 函数，添加序号 ##

这个函数在前面的文章中，已经进行过简单介绍，并且该函数在 `__builtins__` 包中，所以不再过多说明，基本格式如下所示：

enumerate(sequence, [start=0])

其中 `start` 参数是下标起始位置。

## accumulate 函数 ##

该函数基于给定的函数返回一个可迭代对象，默认是累加效果，即第二个参数为 `operator.add`，测试代码如下：

from itertools import accumulate
    data = [1, 2, 3, 4, 5]
    # 计算累积和
    print(list(accumulate(data)))  # [1, 3, 6, 10, 15]

针对上述代码，修改为累积。

from itertools import accumulate
    import operator
    
    data = [1, 2, 3, 4, 5]
    # 计算累积
    
    print(list(accumulate(data, operator.mul)))

除此之外，第二个参数还可以为 `max`，`min` 等函数，例如下述代码：

from itertools import accumulate
    
    data = [1, 4, 3, 2, 5]
    
    print(list(accumulate(data, max)))

代码输出如下内容，其实是将 `data` 里面的任意两个值进行了比较，然后留下最大的值。

[1, 4, 4, 4, 5]

## chain 与 groupby 函数 ##

`chain` 函数用于将多个迭代器组合为单个迭代器，而 `groupby` 可以将一个迭代器且分为多个子迭代器。

首先展示一下 `groupby` 函数的应用：

from itertools import groupby
    
    a = list(groupby('橡橡皮皮擦擦'))
    
    print(a)

输出内容如下所示：

[('橡', <itertools._grouper object at 0x0000000001DD9438>),
    ('皮', <itertools._grouper object at 0x0000000001DD9278>),
    ('擦', <itertools._grouper object at 0x00000000021FF710>)]

为了使用 `groupby` 函数，建议先对原列表进行排序，因为它是有点像切片一样，发现不同的就分出一个迭代器。

`chain` 函数的用法如下，将多个迭代对象进行拼接：

from itertools import groupby, chain
    
    a = list(chain('ABC', 'AAA', range(1,3)))
    print(a)

## zip\_longest 与 zip ##

`zip` 函数在之前的博客中已经进行过说明，`zip_longest` 与 `zip` 的区别就是，`zip` 返回的结果以最短的序列为准，而 `zip_longest` 以最长的为准。

测试代码如下，自行比对结果即可。

from itertools import zip_longest
    
    a = list(zip('ABC', range(5), [10, 20, 30, 40]))
    print(a)
    
    a = list(zip_longest('ABC', range(5), [10, 20, 30, 40]))
    print(a)

`zip_logest` 如果碰到长度不一致的序列，缺少部分会填充 `None`。

## tee 函数 ##

`tee` 函数可以克隆可迭代对象，产出多个生成器，每个生成器都可以产出输入的各个元素。

from itertools import tee
    
    a = list(tee('橡皮擦'))
    print(a)

## compress 函数 ##

该函数通过\*\*谓词（是否，True/False）\*\*来确定对某个元素的取舍问题，最简单的代码如下所示：

from itertools import compress
    
    a = list(compress('橡皮擦', (0, 1, 1)))
    print(a)

## islice、dropwhile、takewhile、filterfalse、filter ##

这几个函数都是从输入的可迭代对象中获取一个子集，而且不修改元素本身。

本部分只罗列各个函数的原型声明，具体用法直接参考使用即可。

islice(iterable, stop) --> islice object
    islice(iterable, start, stop[, step]) --> islice object
    
    dropwhile(predicate, iterable) --> dropwhile object
    
    takewhile(predicate, iterable) --> takewhile object
    
    filterfalse(function or None, sequence) --> filterfalse object

其中只有 `filterfalse` 中的参数是函数在前，序列在后。

测试代码如下，尤其注意第一个参数是 `callable` 即函数。

from itertools import islice, dropwhile, takewhile, filterfalse
    
    a = list(filterfalse(lambda x: x in ["皮", "擦"], '橡皮擦'))
    print(a)

## 写在后面 ##

以上内容就是本文的全部内容，在使用无限迭代器函数 `count`，`cycle`，`repeat` 的时候，一定要注意即使停止。

> 今天是持续写作的第 218 / 365 天。  
> 可以关注，点赞、评论、收藏。

**更多精彩**

*  [滚雪球学 Python（完结）][Python]
 *  [滚雪球学 Python 第二轮（完结）][Python 1]
 *  [滚雪球学 Python 第三轮][Python 2]
 *  [滚雪球学 Python 番外篇（完结）][Python 3]

[Python]: https://blog.csdn.net/hihell/category_10573584.html
[Python 1]: https://blog.csdn.net/hihell/category_10763952.html
[Python 2]: https://blog.csdn.net/hihell/category_10901284.html
[Python 3]: https://blog.csdn.net/hihell/category_10656235.html