collections模块部分类的常用方法

Counter类

from collections import Counter

# Counter是一个容器，用于对可哈希（散列）对象进行计数，对元素出现次数进行统计
# 列表和字典和集合不可哈希，或者说不可散列
# 字符串、元组可哈希
# 虽然列表本身不可哈希，但是Counter类在内部并不是直接对列表进行哈希操作
list = [1, 2, 3, 2, 1, 3, 1]
counter_obj = Counter(list)
print(counter_obj)  # output:Counter({1: 3, 2: 2, 3: 2})
# Counter对象可以看作是一个字典子类，可以使用索引访问
print(counter_obj[1])  # output:3

# most_common()返回一个按照元素计数从高到低排序的元组列表
print(counter_obj.most_common())  # output:[(1, 3), (2, 2), (3, 2)]
# 返回出现次数最多的前2个元素及其计数的元组列表
print(counter_obj.most_common(2))  # output:[(1, 3), (2, 2)]

# update()方法
# 用于更新Counter对象的计数。
# 可以传入一个可迭代对象，将其中元素的计数添加到当前Counter对象中
counter1 = Counter([1, 2, 3])
counter2 = Counter([3, 4, 5])
counter1.update(counter2)
print(counter1)  # output:Counter({3: 2, 1: 1, 2: 1, 4: 1, 5: 1})

# elements()方法返回一个迭代器，该迭代器会根据元素的计数重复返回元素。
# 简单地说，它会按照元素出现的次数，将元素逐个返回
# 元素返回的顺序是不确定的，因为Counter是基于字典的，字典本身是无序的。
elements_iter = counter_obj.elements()
print(counter_obj)  # output:Counter({1: 3, 2: 2, 3: 2})
for element in elements_iter:
    print(element)
# output:
# 1
# 1
# 1
# 2
# 2
# 3
# 3

# clear()方法用于清空Counter对象中的所有元素计数
print("Before clear:", counter_obj)
# output:Before clear: Counter({1: 3, 2: 2, 3: 2})
counter_obj.clear()
print("After clear:", counter_obj)
# output:After clear: Counter()

deque类

增

from collections import deque

# 可以通过maxlen参数限制deque的最大长度
d = deque(maxlen = 3)

# insert()方法用于在双端队列的指定位置插入一个元素。
# 创建一个双端队列
my_deque = deque([1, 2, 3])
# 在索引为1的位置插入元素4
my_deque.insert(1, 4)
print(my_deque)  # output：deque([1, 4, 2, 3])

# append()在deque的右端（尾部）添加一个元素
d = deque([1, 2, 3])
d.append(4)
print(d)  # output：deque([1, 2, 3, 4])

# appendleft()在deque的左端（头部）添加一个元素
d = deque([1, 2, 3])
d.appendleft(0)
print(d)  # output：deque([0, 1, 2, 3])

# extend()在deque的右端（尾部）扩展一个可迭代对象（如列表、元组等）
d = deque([1, 2, 3])
new_elements = [4, 5, 6]
d.extend(new_elements)
print(d)  # output：deque([1, 2, 3, 4, 5, 6])

# extendleft()在deque的左端（头部）扩展一个可迭代对象
# 不过需要注意的是，当扩展一个可迭代对象时，其中的元素会以逆序的方式添加到deque的头部
d = deque([1, 2, 3])
new_elements = [4, 5, 6]
d.extendleft(new_elements)
print(d)  # output：deque([6, 5, 4, 1, 2, 3])

删

from collections import deque

# pop()删除并返回deque的右端（尾部）的元素，不能索引删除
d = deque([1, 2, 3])
last_element = d.pop()
print(last_element)  # output：3
print(d)  # output：deque([1, 2])

# popleft()删除并返回deque的左端（头部）的元素，不能索引删除
d = deque([1, 2, 3])
first_element = d.popleft()
print(first_element)  # output：1
print(d)  # output：deque([2, 3])

# remove方法用于从双端队列deque中移除第一个匹配的元素
# 如果没有找到要移除的元素，会抛出ValueError异常
my_deque = deque([1, 2, 3, 2])
my_deque.remove(2)
print(my_deque)  # output：deque([1, 3, 2])

改

pop()+inset()/append()
popleft()+inset()/appendleft()

查

from collections import deque

# 使用索引访问deque中的元素
d = deque([1, 2, 3])
print(d[0])  # output：1
print(d[1])  # output：2

# index方法用于返回指定元素在双端队列中的位置（索引）
d = deque([10, 20, 30, 20])
print(d.index(20))  # output:1

其它

from collections import deque

# clear()清空双端队列中的所有元素
my_deque = deque([1, 2, 3])
print(len(my_deque))  # output:3
my_deque.clear()
print(len(my_deque))  # output:0

# rotate()将deque中的元素旋转
# 正数参数表示向右旋转，负数参数表示向左旋转
d = deque([1, 2, 3, 4, 5])
d.rotate(1)
print(d)  # output：deque([5, 1, 2, 3, 4])
d.rotate(-2)
print(d)  # output：deque([2, 3, 4, 5, 1])

# copy()创建deque对象的浅拷贝
# 浅拷贝意味着它会创建一个新的deque对象
# 新对象中的元素是原始deque对象中元素的引用
d1 = deque([1, 2, 3])
d2 = d1.copy()
print(d1)  # output:deque([1, 2, 3])
print(d2)  # output:deque([1, 2, 3])

# count()计算指定元素在双端队列中出现的次数
my_deque = deque([1, 2, 3, 2, 1])
print(my_deque.count(1))  # output:2
print(my_deque.count(4))  # output:0

# reverse方法用于反转双端队列中的元素顺序
my_deque = deque([1, 2, 3])
my_deque.reverse()
print(my_deque)  # output:deque([3, 2, 1])

defaultdict类

from collections import defaultdict

# 它的主要作用是在访问时字典中不存在的键时，能够返回一个默认值
# 访问前字典是没有默认值的
# 而不是像普通字典那样抛出KeyError异常。

# 默认值是一个整数（默认为 0）
my_dict = defaultdict(int)
print(my_dict)  # output:defaultdict(<class 'int'>, {})
my_dict['key1'] += 1
print(my_dict['key1'])  # output:1
print(my_dict['key2'])  # output:0

# 默认值是列表（默认为空列表）
my_list_dict = defaultdict(list)
my_list_dict['key1'].append(1)
print(my_list_dict['key1'])  # output:[1]
print(my_list_dict['key2'])  # output:[]


# 自定义默认值函数
def custom_default():
    return ["default value"]


my_custom_dict = defaultdict(custom_default)
print(my_custom_dict['key1'])  # output:['default value']

# 统计一个列表中元素出现的次数，使用defaultdict比使用普通字典更简洁
# 使用defaultdict
my_list = [1, 2, 3, 1, 2]
count_dict = defaultdict(int)
for i in my_list:
    count_dict[i] += 1
print(count_dict)  # output:defaultdict(<class 'int'>, {1: 2, 2: 2, 3: 1})
# 使用普通字典
my_list = [1, 2, 3, 1, 2]
count_dict = {}
for i in my_list:
    if i in count_dict:
        count_dict[i] += 1
    else:
        count_dict[i] = 1
print(count_dict)  # output:{1: 2, 2: 2, 3: 1}

OrderedDict类

from collections import OrderedDict

# OrderedDict是 Python 中的一个字典子类
# 与普通字典不同的是，OrderedDict会记住元素插入的顺序
# 在普通字典中，迭代字典的键或值时，顺序是不确定的（通常是按照哈希值排序）
# 而OrderedDict会按照元素插入的顺序进行迭代
# 实际上普通字典在python高版本中也具有一定的顺序性
ordered_dict = OrderedDict()
ordered_dict['first'] = 1
ordered_dict['second'] = 2
ordered_dict['third'] = 3
for key, value in ordered_dict.items():
    print(key, value)
# first 1
# second 2
# third 3

# 普通字典相等只需要存在的键值对相同，不需要键值对的顺序相同
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 2, 'a': 1}
print(dict1 == dict2)
# 有序字典相等不仅需要存在的键值对相同，还需要键值对的顺序相同
ordered_dict1 = OrderedDict([('a', 1), ('b', 2)])
ordered_dict2 = OrderedDict([('b', 2), ('a', 1)])
print(ordered_dict1 == ordered_dict2)