蓝桥Python组标准库heapq、functool

标准库heapq

使用list表示一个堆
1、将无序List转换成最小堆：
heapq.heapify(a)
2、最小堆a中添加元素x:
heapq.heappush(a,x)
3、弹出并返回最小元素
heapq.heappop(a)
4、弹出并返回最小元素，同时添加元素x
heapq.heapreplace(a,x)
代码操作

import heapq

arr = [9, 3, 13, 7, 1, 19, 5, 14, 12, 10, 2]
heapq.heapify(arr)
print(arr)

print("----------------------")

heapq.heappush(arr, 4)
print(arr)

print("----------------------")

heapq.heappush(arr, 11)
print(arr)

print("----------------------")

err = []
while len(arr):
    err.append(heapq.heappop(arr))
    print(err)
heapq.heapify(err)
print(err)

输出

[1, 2, 5, 7, 3, 19, 13, 14, 12, 10, 9]
----------------------
[1, 2, 4, 7, 3, 5, 13, 14, 12, 10, 9, 19]
----------------------
[1, 2, 4, 7, 3, 5, 13, 14, 12, 10, 9, 19, 11]
----------------------
[1]
[1, 2]
[1, 2, 3]
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 7]
[1, 2, 3, 4, 5, 7, 9]
[1, 2, 3, 4, 5, 7, 9, 10]
[1, 2, 3, 4, 5, 7, 9, 10, 11]
[1, 2, 3, 4, 5, 7, 9, 10, 11, 12]
[1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13]
[1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 14]
[1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 14, 19]
[1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 14, 19]

标准库functool

functools模块，这是一个提供了一系列高阶函数和函数操作的工具模块

1. reduce(): 对序列的元素进行累积操作。
2. partial(): 用于冻结函数的某些参数，创建一个调用时带有预设参数的新函数。
3. lru_cache(): 为函数提供缓存功能，避免重复计算。
4. cmp_to_key():将比较函数转换为sort()或sorted()所需的key函数。
5. total_ordering():为类提供完整的排序方法。 （略）
6. singledispatch(): 用于创建单分派泛函数。 （略）

接下来详细说明前四个：三个函数（ reduce()，partial()，cmp_to_key() ）一个装饰器（ lru_cache() ）：

1.reduce(): 对序列的元素进行累积操作。

代码

from functools import reduce

# 计算序列中所有元素的乘积
result = reduce(lambda x, y: x * y, [1, 2, 3, 4, 5])
print(result)

输出

120

2.partial(): 用于冻结函数的某些参数，创建一个调用时带有预设参数的新函数。

代码1

from functools import partial

def Arr(a, b, c):
    print(a)
    print(b)
    print(c)
    print(a + b + c)

print("-------------")

Arr(1, 3, 5)

print("---------------")

Arr_c = partial(Arr, c=15)
Arr_c(7, 2)

print("-----------------")

Arr_a = partial(Arr, 5)
Arr_a(7, 3)

输出

-------------
1
3
5
9
---------------
7
2
15
24
-----------------
5
7
3
15

代码2

from functools import partial

add_func = partial(lambda x, y: x + y)
print(add_func(10,2))

add_five = partial(lambda x, y: x + y, 5)
print(add_five(10))

输出

12
15

代码3

from functools import partial


def arr(*args, **kwargs):
    for i in args:
        print(i)
    for m, n in kwargs.items():
        print(m, n)


arr(1, 3, 5, a=10, b=20)

print("---------------------")

arr_partial = partial(arr, 10, a=10, b=20)
arr_partial(6,7,8,c=30)

输出

1
3
5
a 10
b 20
---------------------
10
6
7
8
a 10
b 20
c 30

3. lru_cache(): 为函数提供缓存功能，避免重复计算。

计算斐波那契数列

from functools import lru_cache

@lru_cache(maxsize=32)
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

# 计算斐波那契数列的第10项
print(fib(10))

输出

55

4. cmp_to_key():将比较函数转换为sorted()所需的key函数。

下面代码sorted()相关简单使用可以参考之前的这篇文章：
Python排序
下面代码涉及字符串之间的比较可以参考之前的这篇文章：
字典序比较
代码

from functools import cmp_to_key


def compare_strings(a, b):
    # 首先检查两个字符串长度是否不同
    if len(a) != len(b):
        # 如果长度不同，返回长度差值的相反数，实现长度升序排序
        return -(len(b) - len(a))
    else:
        # 如果长度相同，直接比较字符串本身，实现字典序排序
        if a > b:
            return 1
        elif a < b:
            return -1
        else:
            return 0


list_a = ["banana", "apple", "cherry", "date", "sort", "world"]
key_compare_strings = cmp_to_key(compare_strings)
list_a_sorted = sorted(list_a, key=key_compare_strings)
print(list_a_sorted)

输出

['date', 'sort', 'apple', 'world', 'banana', 'cherry']