Python-函数式编程模块itertools、functools、operator

女爷i 2022-11-12 04:10 199阅读 0赞

**目录**

上篇文章思考题

itertools

无穷迭代器

count 计数

cycle 循环

repeat 重复

排列组合迭代器

product 笛卡儿积

permutations 排列

combinations 组合

其他迭代器

accumulate 累加

functools

lru\_cache 最近最少使用

reduce 累积缩减

operator

参考

--------------------

# 上篇文章思考题 #

[Python-函数式编程（高阶函数、匿名函数、返回函数、装饰器）][Python-]

> display = print

是将print指向的代码块起了一个别名叫display，而

>     fun = plus_not_now(*tp)
>     fun2 = plus_not_now(*tp)

返回的函数并不是在同一内存，所以id不同

def plus_not_now(*t):
        count = 0
    
        def plus_all():
            nonlocal count
            print(count)
            count += 1
            return sum(t)
    
        return plus_all
    
    
    tp = (range(1, 6))
    fun = plus_not_now(*tp)
    print(fun())
    print(fun())
    print(fun())
    tp = (range(2, 10))
    fun2 = plus_not_now(*tp)
    print(fun2())

**结果**

> 0  
> 15  
> 1  
> 15  
> 2  
> 15  
> 0  
> 44

若fun2与fun指向同一内存的代码块，fun2运行时，代码块中的count应该是3，而不是0

# itertools #

## 无穷迭代器 ##

### count 计数 ###

`count`(*start=0*, *step=1*)

创建一个迭代器，它从 *start* 值开始，返回均匀间隔的值。start, start+step, start+2\*step, ...

for num in count(1, 0.1):
        print(num)
        if num > 2:
            break

结果

> 1  
> 1.1  
> 1.2000000000000002  
> 1.3000000000000003  
> 1.4000000000000004  
> 1.5000000000000004  
> 1.6000000000000005  
> 1.7000000000000006  
> 1.8000000000000007  
> 1.9000000000000008  
> 2.000000000000001

count不仅仅使用在整数上，浮点也可以，精度问题可查看：[Python-数字总结（操作符、方法、内置函数、模块\[四舍五入、分数\]）][Python- 1]

### cycle 循环 ###

`cycle`(*iterable*)

创建一个迭代器，返回 *iterable* 中所有元素并保存一个副本。当取完 *iterable* 中所有元素，返回副本中的所有元素。无限重复。p0, p1, ... plast, p0, p1, ...

nums = 6
    for s in cycle('ABCD'):
        print(s)
        if nums:
            nums -= 1
        else:
            break

结果

> A  
> B  
> C  
> D  
> A  
> B  
> C

### `repeat`重复 ###

`repeat`(*object*\[, *times*\])

创建一个迭代器，不断重复 *object* 。除非设定参数 *times* ，否则将无限重复。

print(list(repeat(3, 5)))

**结果**

> \[3, 3, 3, 3, 3\]

## 排列组合迭代器 ##

### product 笛卡儿积 ###

`product`(*\*iterables*, *repeat=1*)

可迭代对象输入的**笛卡儿积**。

例，"123"的笛卡尔积，即1 2 3有两列，全连线

for item in product('123', repeat=2):
        print(item)

结果

> ('1', '1')  
> ('1', '2')  
> ('1', '3')  
> ('2', '1')  
> ('2', '2')  
> ('2', '3')  
> ('3', '1')  
> ('3', '2')  
> ('3', '3')

类似于列表生成式

> >>> \[(i,j) for i in '123' for j in '123'\]  
> \[('1', '1'), ('1', '2'), ('1', '3'), ('2', '1'), ('2', '2'), ('2', '3'), ('3', '1'), ('3', '2'), ('3', '3')\]

### `permutations 排列` ###

`permutations`(*iterable*, *r=None*)

连续返回由 *iterable* 元素生成长度为 *r* 的**排列**。

如果 *r* 未指定或为 `None` ，*r* 默认设置为 *iterable* 的长度，这种情况下，**生成所有全长排列**。

例，“123”的长度为2的排列

for item in permutations('123', 2):
        print(item)

结果

> ('1', '2')  
> ('1', '3')  
> ('2', '1')  
> ('2', '3')  
> ('3', '1')  
> ('3', '2')

类似列表生成式

> >>> \[(i,j) for i in '123' for j in '123' if j!=i\]  
> \[('1', '2'), ('1', '3'), ('2', '1'), ('2', '3'), ('3', '1'), ('3', '2')\]

### `combinations`组合 ###

`combinations`(*iterable*, *r*)

返回由输入 *iterable* 中元素组成长度为 *r* 的子序列。组合按照字典序返回。所以如果输入 *iterable* 是有序的，生成的组合元组也是有序的。

即使元素的值相同，不同位置的元素也被认为是不同的。如果元素各自不同，那么每个组合中没有重复元素。

注意：r是必填的，如果默认是全长度就是本身，没有意义，所以就设置的必填。

例，"123"的2位组合

for item in combinations('123', 2):
        print(item)

> ('1', '2')  
> ('1', '3')  
> ('2', '3')

类似列表生成式

> >>> \[(i,j) for i in '123' for j in '123' if j!=i and j>i\]  
> \[('1', '2'), ('1', '3'), ('2', '3')\]

## 其他迭代器 ##

### `accumulate 累加` ###

`accumulate`(*iterable*\[, *func*\])

创建一个迭代器，返回累加和或其他二元函数的累加结果（通过可选参数 *func* 指定）。如果提供了 *func* ，它应是2个参数的函数。输入 *iterable* 元素类型应是 *func* 能支持的任意类型。

例，1-10的累加和

print(list(accumulate(range(1, 11))))

结果

> \[1, 3, 6, 10, 15, 21, 28, 36, 45, 55\]

动态规划题目，常用前缀和，可以通过这个实现

<table style="width:500px;"> 前缀和 
 <tbody> 
 <tr> 
 <th>下标</th> 
 <td>0</td> 
 <td>1</td> 
 <td>2</td> 
 <td>3</td> 
 <td>4</td> 
 <td>5</td> 
 <td>6</td> 
 <td>7</td> 
 <td>8</td> 
 <td>9</td> 
 </tr> 
 <tr> 
 <th>数值nums</th> 
 <td>1</td> 
 <td>2</td> 
 <td>3</td> 
 <td>4</td> 
 <td>5</td> 
 <td>6</td> 
 <td>7</td> 
 <td>8</td> 
 <td>9</td> 
 <td>10</td> 
 </tr> 
 <tr> 
 <th>前缀和sums</th> 
 <td>1</td> 
 <td>3</td> 
 <td>6</td> 
 <td>10</td> 
 <td>15</td> 
 <td>21</td> 
 <td>28</td> 
 <td>36</td> 
 <td>45</td> 
 <td>55</td> 
 </tr> 
 </tbody> 
</table>

加头前缀和added

<table style="width:500px;"> 加头前缀和 
 <tbody> 
 <tr> 
 <th>下标</th> 
 <td>0</td> 
 <td>1</td> 
 <td>2</td> 
 <td>3</td> 
 <td>4</td> 
 <td>5</td> 
 <td>6</td> 
 <td>7</td> 
 <td>8</td> 
 <td>9</td> 
 <td>10</td> 
 </tr> 
 <tr> 
 <th>加头前缀和added</th> 
 <td>0</td> 
 <td>1</td> 
 <td>3</td> 
 <td>6</td> 
 <td>10</td> 
 <td>15</td> 
 <td>21</td> 
 <td>28</td> 
 <td>36</td> 
 <td>45</td> 
 <td>55</td> 
 </tr> 
 </tbody> 
</table>

某一段的区间\[i,j\]的和为added\[j+1\] - added\[i\]，0<=i<=j<=len(nums)，例如，nums\[0\]累加到nums\[3\]，added\[3+1\]-added\[0\]=10-0=0，nums\[4\]累加到nums\[5\]，added\[5+1\]-added\[4\]=21-10=11

还有一些不太常用，复制过来没啥意思，看参考吧。

# functools #

## lru\_cache 最近最少使用 ##

`lru_cache`(*maxsize=128*, *typed=False*)

一个**为函数提供缓存功能的装饰器**，缓存 *maxsize* 组传入参数，在下次以相同参数调用时直接返回上一次的结果。用以节约高开销或I/O函数的调用时间。

由于使用了字典存储缓存，所以**该函数的固定参数和关键字参数必须是可哈希的**。

不同模式的参数可能被视为不同从而产生多个缓存项，例如, f(a=1, b=2) 和 f(b=2, a=1) 因其参数顺序不同，可能会被缓存两次。

如果 *maxsize* 设置为 `None` ，LRU功能将被禁用且缓存数量无上限。 ***maxsize* 设置为2的幂时可获得最佳性能**。

如果 *typed* 设置为true，不同类型的函数参数将被分别缓存。例如， `f(3)` 和 `f(3.0)` 将被视为不同而分别缓存。

**递归斐波那锲数列**

times = 0
    
    
    def count_time(func):
        def innner(*args, **kwargs):
            start_time = time.time()
            ret = func(*args, **kwargs)
            end_time = time.time()
            global times
            times = end_time - start_time
            return ret
    
        return innner
    
    
    @count_time
    def fib(n):
        if n == 0:
            return 0
        if n == 1:
            return 1
        return fib(n - 1) + fib(n - 2)
    
    
    if __name__ == '__main__':
        print(fib(30))
        print(times)

> 832040  
> 1.2616260051727295

当然，我们可以**记忆化**递归

@count_time
 def fib_mem(n):
 mem = [0, 1]
 if n < 2:
 return mem[n]
 k = 2
 while k <= n:
 mem.append(mem[-1] + mem[-2])
 k += 1
 print(mem)
 return mem[-1]
 
 
 if __name__ == '__main__':
 print(fib_mem(30))
 print(times)

**结果**

> 832040  
> 0.0

当n为1000时，结果

> 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922  
> 593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875  
> 0.0009968280792236328

**给递归开缓存，会记录部分子问题的结果，不重复计算**

@lru_cache(maxsize=None)
    @count_time
    def fib(n):
        if n == 0:
            return 0
        if n == 1:
            return 1
        return fib(n - 1) + fib(n - 2)

n为100时

> 354224848179261915075  
> 0.000997304916381836

总结：lru\_cache能在一定程度上提高递归的效率，但是仍不如手动记忆化或动态规划算法。如果你做oj等使用递归超时，又不会记忆化或动态规划时可以考虑。

## reduce 累积缩减 ##

map和filter在上一篇文章：[Python-函数式编程（高阶函数、匿名函数、返回函数、装饰器）][Python-]

`reduce`(*function*, *iterable*\[, *initializer*\])

将两个参数的 *function* 从左至右累积地应用到 *sequence* 的条目，以便将该序列缩减为**单一值**。 例如，`reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])` 是计算 `((((1+2)+3)+4)+5)` 的值。 左边的参数 *x* 是累积值而右边的参数 *y* 则是来自 *sequence* 的更新值。 如果存在可选项 *initializer*，它会被放在参与计算的序列的条目之前，并在序列对象为空时作为默认值。 如果没有给出 *initializer* 并且 *sequence* 仅包含一个条目，则将返回第一项。

给的例子很简单，你可能感觉reduce没有什么用，但其实不然

例，将数字列表\[1,2,3,4,5,6\]转为数字123456

print(reduce(lambda x, y: x * 10 + y, [1, 2, 3, 4, 5, 6]))

如果你仍然感觉它不行，可以想想，没有int()函数，如何使用map和reduce将字符串转为数字呢？读者可以思考一下，再看代码

num_dict = dict(zip('0123456789',range(10)))
    print(reduce(lambda x, y: x * 10 + y, map(lambda x: num_dict[x], '123456')))

使用map，将字符串转为数字列表，使用reduce将数字列表乘10累加即可。

# cmp\_to\_key #

`cmp_to_key`(*func*)

将(旧式的)比较函数转换为新式的 [key function][] . 在类似于 [`sorted()`][sorted] ， [`min()`][min] ， [`max()`][max] ， [`heapq.nlargest()`][heapq.nlargest] ， [`heapq.nsmallest()`][heapq.nsmallest] ， [`itertools.groupby()`][itertools.groupby] 等函数的 key 参数中使用。此函数主要用作将 Python 2 程序转换至新版的转换工具，以保持对比较函数的兼容。

比较函数意为一个可调用对象，该对象接受两个参数并比较它们，结果为小于则返回一个负数，相等则返回零，大于则返回一个正数。key function则是一个接受一个参数，并返回另一个用以排序的值的可调用对象。

有时间写个例子，待更新...

# operator #

<table style="width:600px;"> 运算符映射到函数 
 <thead> 
 <tr> 
 <th> 运算 </th> 
 <th> 语法 </th> 
 <th> 函数 </th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td> 加法 </td> 
 <td> <code>a + b</code> </td> 
 <td> <code>add(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 字符串拼接 </td> 
 <td> <code>seq1 + seq2</code> </td> 
 <td> <code>concat(seq1, seq2)</code> </td> 
 </tr> 
 <tr> 
 <td> 包含测试 </td> 
 <td> <code>obj in seq</code> </td> 
 <td> <code>contains(seq, obj)</code> </td> 
 </tr> 
 <tr> 
 <td> 除法 </td> 
 <td> <code>a / b</code> </td> 
 <td> <code>truediv(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 除法 </td> 
 <td> <code>a // b</code> </td> 
 <td> <code>floordiv(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 按位与 </td> 
 <td> <code>a &amp; b</code> </td> 
 <td> <code>and_(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 按位异或 </td> 
 <td> <code>a ^ b</code> </td> 
 <td> <code>xor(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 按位取反 </td> 
 <td> <code>~ a</code> </td> 
 <td> <code>invert(a)</code> </td> 
 </tr> 
 <tr> 
 <td> 按位或 </td> 
 <td> <code>a | b</code> </td> 
 <td> <code>or_(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 取幂 </td> 
 <td> <code>a ** b</code> </td> 
 <td> <code>pow(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 一致 </td> 
 <td> <code>a is b</code> </td> 
 <td> <code>is_(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 一致 </td> 
 <td> <code>a is not b</code> </td> 
 <td> <code>is_not(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 索引赋值 </td> 
 <td> <code>obj[k] = v</code> </td> 
 <td> <code>setitem(obj, k, v)</code> </td> 
 </tr> 
 <tr> 
 <td> 索引删除 </td> 
 <td> <code>del obj[k]</code> </td> 
 <td> <code>delitem(obj, k)</code> </td> 
 </tr> 
 <tr> 
 <td> 索引取值 </td> 
 <td> <code>obj[k]</code> </td> 
 <td> <code>getitem(obj, k)</code> </td> 
 </tr> 
 <tr> 
 <td> 左移 </td> 
 <td> <code>a &lt;&lt; b</code> </td> 
 <td> <code>lshift(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 取模 </td> 
 <td> <code>a % b</code> </td> 
 <td> <code>mod(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 乘法 </td> 
 <td> <code>a * b</code> </td> 
 <td> <code>mul(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 矩阵乘法 </td> 
 <td> <code>a @ b</code> </td> 
 <td> <code>matmul(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 否定（算术） </td> 
 <td> <code>- a</code> </td> 
 <td> <code>neg(a)</code> </td> 
 </tr> 
 <tr> 
 <td> 否定（逻辑） </td> 
 <td> <code>not a</code> </td> 
 <td> <code>not_(a)</code> </td> 
 </tr> 
 <tr> 
 <td> 正数 </td> 
 <td> <code>+ a</code> </td> 
 <td> <code>pos(a)</code> </td> 
 </tr> 
 <tr> 
 <td> 右移 </td> 
 <td> <code>a &gt;&gt; b</code> </td> 
 <td> <code>rshift(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 切片赋值 </td> 
 <td> <code>seq[i:j] = values</code> </td> 
 <td> <code>setitem(seq, slice(i, j), values)</code> </td> 
 </tr> 
 <tr> 
 <td> 切片删除 </td> 
 <td> <code>del seq[i:j]</code> </td> 
 <td> <code>delitem(seq, slice(i, j))</code> </td> 
 </tr> 
 <tr> 
 <td> 切片取值 </td> 
 <td> <code>seq[i:j]</code> </td> 
 <td> <code>getitem(seq, slice(i, j))</code> </td> 
 </tr> 
 <tr> 
 <td> 字符串格式化 </td> 
 <td> <code>s % obj</code> </td> 
 <td> <code>mod(s, obj)</code> </td> 
 </tr> 
 <tr> 
 <td> 减法 </td> 
 <td> <code>a - b</code> </td> 
 <td> <code>sub(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 真值测试 </td> 
 <td> <code>obj</code> </td> 
 <td> <code>truth(obj)</code> </td> 
 </tr> 
 <tr> 
 <td> 比较 </td> 
 <td> <code>a &lt; b</code> </td> 
 <td> <code>lt(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 比较 </td> 
 <td> <code>a &lt;= b</code> </td> 
 <td> <code>le(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 相等 </td> 
 <td> <code>a == b</code> </td> 
 <td> <code>eq(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 不等 </td> 
 <td> <code>a != b</code> </td> 
 <td> <code>ne(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 比较 </td> 
 <td> <code>a &gt;= b</code> </td> 
 <td> <code>ge(a, b)</code> </td> 
 </tr> 
 <tr> 
 <td> 比较 </td> 
 <td> <code>a &gt; b</code> </td> 
 <td> <code>gt(a, b)</code> </td> 
 </tr> 
 </tbody> 
</table>

这个不实践了，很简单...

# 参考 #

[python官方文档-函数式编程模块][python_-]

[Python-]: https://blog.csdn.net/lady_killer9/article/details/108943582
[Python- 1]: https://blog.csdn.net/lady_killer9/article/details/109017050
[key function]: https://docs.python.org/zh-cn/3.7/glossary.html#term-key-function
[sorted]: https://docs.python.org/zh-cn/3.7/library/functions.html#sorted
[min]: https://docs.python.org/zh-cn/3.7/library/functions.html#min
[max]: https://docs.python.org/zh-cn/3.7/library/functions.html#max
[heapq.nlargest]: https://docs.python.org/zh-cn/3.7/library/heapq.html#heapq.nlargest
[heapq.nsmallest]: https://docs.python.org/zh-cn/3.7/library/heapq.html#heapq.nsmallest
[itertools.groupby]: https://docs.python.org/zh-cn/3.7/library/itertools.html#itertools.groupby
[python_-]: https://docs.python.org/zh-cn/3.7/library/functional.html