python 蓝桥杯之常用的库_蓝桥杯python库

heapq

heapq 是 Python 中的一个内置模块，提供了对堆数据结构的支持。堆是一种特殊的树形数据结构，具有以下特点：

1. 在堆中，父节点的值总是小于或者大于它的子节点的值，这取决于是最小堆还是最大堆。
2. 堆是一个完全二叉树，通常使用数组来实现。

heapq 模块提供了一系列函数，可以在普通的列表上模拟堆的行为。下面是一些 heapq 库的常用函数及其用法：

1. heapify(iterable)：将一个可迭代对象转换为堆数据结构。

   import heapq
   
   heap = [3, 1, 4, 1, 5, 9, 2, 6, 5]
   heapq.heapify(heap)
   print(heap)
   # 输出：[1, 1, 2, 5, 3, 9, 4, 6, 5]
   1
   2
   3
   4
   5
   6

2. heappush(heap, item)：向堆中添加一个新元素。

   import heapq
   
   heap = [3, 1, 4]
   heapq.heappush(heap, 2)
   print(heap)
   # 输出：[1, 2, 4, 3]
   1
   2
   3
   4
   5
   6

3. heappop(heap)：从堆中弹出并返回最小元素。

   import heapq
   
   heap = [1, 2, 4, 3]
   smallest = heapq.heappop(heap)
   print(smallest)  # 输出：1
   print(heap)      # 输出：[2, 3, 4]
   1
   2
   3
   4
   5
   6

4. heapreplace(heap, item)：弹出并返回最小元素，并将新元素推入堆中。

   import heapq
   
   heap = [1, 2, 4, 3]
   smallest = heapq.heapreplace(heap, 5)
   print(smallest)  # 输出：1
   print(heap)      # 输出：[2, 3, 4, 5]
   1
   2
   3
   4
   5
   6

5. nlargest(n, iterable)：返回可迭代对象中的前 n 个最大元素。

   import heapq
   
   numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]
   largest = heapq.nlargest(3, numbers)
   print(largest)  # 输出：[9, 6, 5]
   1
   2
   3
   4
   5

6. nsmallest(n, iterable)：返回可迭代对象中的前 n 个最小元素。

   import heapq
   
   numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]
   smallest = heapq.nsmallest(3, numbers)
   print(smallest)  # 输出：[1, 1, 2]
   1
   2
   3
   4
   5

这些函数为使用堆数据结构提供了便利，使得对列表的操作更加高效。

Counter

Counter 是 Python 标准库中 collections 模块提供的一个类，用于对可迭代对象中的元素进行计数。它提供了一种快速、高效的方式来统计列表、字符串或其他可迭代对象中各元素的出现次数，并以字典的形式返回统计结果。

以下是 Counter 类的一些主要特性和用法：

导入模块

from collections import Counter
1

创建一个 Counter 对象

# 通过列表创建 Counter 对象
word_counts = Counter(['apple', 'banana', 'apple', 'orange', 'banana', 'apple'])

# 通过字符串创建 Counter 对象
char_counts = Counter('abracadabra')
1
2
3
4
5

获取元素的出现次数

print(word_counts)
# 输出：Counter({'apple': 3, 'banana': 2, 'orange': 1})

print(char_counts)
# 输出：Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})
1
2
3
4
5

访问特定元素的计数

print(word_counts['apple'])
# 输出：3

print(char_counts['a'])
# 输出：5
1
2
3
4
5

更新计数

update 接收的参数必须是可迭代的

# 通过加法更新计数
word_counts.update(['apple', 'orange'])
print(word_counts)
# 输出：Counter({'apple': 4, 'banana': 2, 'orange': 2})

# 通过减法更新计数
word_counts.subtract(['apple', 'banana'])
print(word_counts)
# 输出：Counter({'apple': 3, 'orange': 2, 'banana': 1})
1
2
3
4
5
6
7
8
9

那么对于整数的计数

from collections import Counter


num = Counter()
for i in range(10):
    num.update([i])

print(num)
1
2
3
4
5
6
7
8

我们可以给数字加上一个列表的外壳
返回一个类似字典的形式

获取计数值最高的元素

# 获取出现次数最高的两个元素及其次数
top_two = word_counts.most_common(2)
print(top_two)
# 输出：[('apple', 3), ('orange', 2)]
1
2
3
4

其他常用方法

• elements(): 返回一个迭代器，包含所有计数大于 0 的元素。
• keys(): 返回 Counter 对象中所有的元素。
• values(): 返回 Counter 对象中所有元素的计数值。

Counter 类提供了一种简单而强大的方法来进行元素计数，尤其适用于需要统计频率、词频等问题。它的使用方法简单明了，能够快速地对数据进行统计分析。

统计一个数字中每一个数字的数目

方法一：直接将字符整体传入Counter,当我们通过字符进行访问的时候，就可以得到具体的数目

from collections import Counter

num = input()
count = Counter(num)

sum = 0
for i in range(1,10,2):
  sum = count[str(i)] + sum

print(sum)

1
2
3
4
5
6
7
8
9
10
11
12

注意：键不一定是字符

defaultdict

defaultdict(set) 是一种使用 defaultdict 创建的特殊类型的字典，它的默认值是一个空的 set 集合。defaultdict(set) 的工作原理与普通的 defaultdict 类似，但是它的默认值类型是一个空的 set，这使得在使用时特别方便，尤其是在需要存储一组唯一值时。

下面是关于 defaultdict(set) 的详细介绍以及使用示例：

导入模块

from collections import defaultdict
1

创建一个 defaultdict(set)

d = defaultdict(set)
1

向字典中添加元素

d['group1'].add('value1')
d['group1'].add('value2')
d['group2'].add('value3')
1
2
3

在我们创建defaultdict 对象的时候，在具体的使用的时候，应该配合使用add , append 等方法

访问字典中的元素

print(d['group1'])  # 输出：{'value1', 'value2'}
print(d['group2'])  # 输出：{'value3'}
1
2

访问不存在的键

当你访问一个不存在的键时，defaultdict(set) 会自动创建这个键，并将其对应的值初始化为一个空的 set。

print(d['group3'])  # 输出：set()
1

注意事项

• 在使用 defaultdict(set) 时，你不需要手动初始化每个键的值为一个空的 set，因为它会自动创建并初始化这些值。
• 当你向某个键对应的值中添加元素时，如果这个键不存在，defaultdict(set) 会自动创建该键并将其对应的值初始化为一个空的 set。
• 使用 defaultdict(set) 可以方便地管理一组唯一值，因为 set 可以确保其中的元素唯一性，并且你可以直接使用 add() 方法添加元素，而不必担心键不存在的问题。

datetime

from datetime import datetime, timedelta 这行代码是 Python 中的导入语句，用于从 datetime 模块中导入特定的类或函数。

• datetime 类：datetime 类是 Python 中处理日期和时间的基本类之一。它允许创建表示特定日期和时间的对象，以及执行各种与日期和时间相关的操作，如格式化、比较、计算等。

• timedelta 类：timedelta 类用于表示时间间隔，即两个日期或时间之间的差异。它可以表示以天、小时、分钟、秒等单位的时间差。timedelta 类通常与 datetime 类一起使用，用于在日期和时间上执行加法或减法运算。

通过 from datetime import datetime, timedelta 这行代码，我们可以直接使用 datetime 和 timedelta 类，而不需要在代码中使用 datetime.datetime 或 datetime.timedelta 的完全限定名称。

例如，可以这样使用：

from datetime import datetime, timedelta

# 创建一个表示当前日期和时间的 datetime 对象
now = datetime.now()

# 创建一个表示一天时间间隔的 timedelta 对象
one_day = timedelta(days=1)

# 将当前日期加上一天
next_day = now + one_day

# 打印结果
print(next_day)
1
2
3
4
5
6
7
8
9
10
11
12
13

这种导入方式能够简化代码，提高代码的可读性和易用性，使得在代码中使用 datetime 和 timedelta 更加方便。

strftime(‘%Y%m%d’) 格式化时间为年月日