• [编程基础] Python内置模块collections使用笔记


    collections是Python标准库中的一个内置模块,它提供了一些额外的数据结构类型,用于增强Python基础类型如列表(list)、元组(tuple)和字典(dict)等。以下是对collections模块中主要数据结构类的概述:

    • namedtuple:命名元组,创建一个带有名称的tuple,并且可以通过名称访问元素。
    • deque:双端队列,可以在两端高效地执行插入和删除操作。
    • Counter:计数器,用于计算可迭代对象中元素的出现次数。
    • defaultdict:默认字典,类似于普通字典,但是在访问不存在的键时会返回一个默认值。
    • OrderedDict:有序字典,可以设置字典键值的顺序。
    • ChainMap:将多个字典或映射组合在一起的类。
    • UserList:列表的包装器类,用于创建自定义列表。
    • UserString:字符串的包装器类,用于创建自定义字符串。
    • UserDict:字典的包装器类,用于创建自定义字典。

    本文主要介绍这些数据类的基础使用方法,以更好地利用Python的collections模块来处理不同类型的数据。关于collections模块更详细的使用介绍可以参考Python官方文档:python-collections

    1 namedtuple

    namedtuple类似于元组(tuple),但是可以通过为每个元素指定名称,从而实现使用元素字段名来引用其元素,而不仅仅依赖于位置索引。

    以下代码展示了namedtuple的使用

    from collections import namedtuple
    # 定义一个名为Person的namedtuple类型,包含name和age两个字段
    Person = namedtuple('Person', ['name', 'age'])
    # Person = namedtuple('Person','age name') # 另一种创建方式
    # 创建一个Person对象
    person1 = Person('Alice', 17)
    # 访问字段值
    print(person1.name) # Alice
    print(person1.age) # 17
    # 也可以通过索引访问字段值
    print(person1[0]) # Alice
    print(person1[1]) # 17
    # namedtuple字段值是不可变的,不能直接修改字段值
    # person1.name = 'Bob' # 这行会抛出异常
    # 通过_replace方法创建一个新的命名元组,并替换特定字段的值
    person2 = person1._replace(name='Bob')
    print(person2) # Person(name='Bob', age=17)
    # 打印字段名
    print(person2._fields) # ('name', 'age')
    Alice
    17
    Alice
    17
    Person(name='Bob', age=17)
    ('name', 'age')

    从以上代码可以看到namedtuple和Python字典类型有一些相似之处,但它们在实现和使用方式上存在很大的差异,需要根据具体的需求和情况选择合适的数据类型。如果需要保持字段的顺序、提高访问速度和内存效率,可以选择namedtuple。而如果需要动态地添加、删除和修改键值对,并且需要使用字典提供的更多内置方法和功能,那么字典类型可能更适合。相比字典类型,namedtuple优劣如下:

    namedtuple优势:

    • 访问速度快:namedtuple内部使用整数索引访问字段,因此比字典更高效。
    • 内存效率高:namedtuple采用紧凑的内存布局,相比字典更节省内存。
    • 字段顺序固定:namedtuple定义时可以指定字段的顺序,并且不可变。这对于涉及字段顺序的操作非常有用。

    namedtuple劣势:

    • 不可变性:namedtuple的字段是不可变的,一旦创建就不能修改。而字典可以动态地添加、删除和修改键值对。
    • 灵活性较差:字典提供了更多的内置方法和功能,例如迭代、查找、更新等。namedtuple相对简化,没有这些额外的功能。

    以下代码展示了namedtuple和普通字典占用空间大小的效果对比:

    import random
    import sys
    from collections import namedtuple
    # 创建字典
    person_dict = {'age': 32, 'name': 'John Doe'}
    print('person_dict占用的空间大小:', sys.getsizeof(person_dict))
    # 将字典转换为namedtuple
    Person = namedtuple('Person', ['age', 'name'])
    person_tuple = Person(**person_dict)
    print('person_tuple占用的空间大小:', sys.getsizeof(person_tuple))
    person_dict占用的空间大小: 248
    person_tuple占用的空间大小: 72

    2 deque

    deque(双端队列)是一种具有队列和栈性质的数据结构,它允许从两端快速地添加和删除元素。deque类似列表list,但deque在插入和删除元素时具有更好的性能,尤其是在操作频繁的情况下。以下代码展示了deque的使用。

    from collections import deque
    # 创建一个空的双端队列
    my_deque = deque()
    # 创建一个包含元素的双端队列
    my_deque = deque([1, 2, 3])
    # 创建一个指定最大长度的双端队列,多余的元素会被丢弃
    my_deque = deque([1, 2, 3], maxlen=5)
    # 在队列的右侧添加一个元素
    my_deque.append(1)
    # 在队列的左侧添加一个元素
    my_deque.appendleft(2)
    # 移除并返回队列中的最右侧元素
    right_element = my_deque.pop()
    # 移除并返回队列中的最左侧元素
    left_element = my_deque.popleft()
    # 输出当前队列中的所有元素
    print(my_deque) # deque([1, 2, 3], maxlen=5)
    # 输出队列中的第一个元素
    print(my_deque[0]) # 1
    # deque不支持切片操作,需要转换为list
    # print(my_deque[:-1])
    print(list(my_deque)[:-1]) # [1, 2]
    deque([1, 2, 3], maxlen=5)
    1
    [1, 2]

    deque也支持基于字符串或列表来添加元素,如下所示:

    from collections import deque
    # 创建一个空的deque对象
    my_deque = deque()
    # 使用extend/extendleft添加元素
    my_deque.extend([1, 2, 3])
    print(my_deque) # deque([1, 2, 3])
    # 使用extend/extendleft添加字符串
    my_deque.extendleft("Hello")
    print(my_deque) # deque(['o', 'l', 'l', 'e', 'H', 1, 2, 3])
    deque([1, 2, 3])
    deque(['o', 'l', 'l', 'e', 'H', 1, 2, 3])

    deque一些常用函数操作如下所示:

    from collections import deque
    # 创建一个空的deque对象
    my_deque = deque()
    # 在左侧扩展字符串"Hello",将其拆分为字符并逐个添加到deque的左侧
    my_deque.extendleft("Hello")
    # 打印deque的长度
    print(len(my_deque)) # 5
    # 统计字符"l"在deque中出现的次数
    print(my_deque.count("l")) # 2
    # 在deque的左侧插入字符串"123"
    my_deque.insert(0, "123")
    print(my_deque) # deque(['123', 'o', 'l', 'l', 'e', 'H'])
    # 将deque中的元素从右端取两个元素,并把它们移动到左端
    # 如果为负数,则从左侧取元素
    my_deque.rotate(2)
    print(my_deque) # deque(['e', 'H', '123', 'o', 'l', 'l'])
    # 反转队列
    my_deque.reverse()
    print(my_deque) # deque(['l', 'l', 'o', '123', 'H', 'e'])
    # 清空deque中的所有元素
    my_deque.clear()
    print(my_deque)
    5
    2
    deque(['123', 'o', 'l', 'l', 'e', 'H'])
    deque(['e', 'H', '123', 'o', 'l', 'l'])
    deque(['l', 'l', 'o', '123', 'H', 'e'])
    deque([])

    3 Counter

    Counter用于计算可迭代对象中元素的出现次数,这些可迭代对象可以是列表、字符串、元组等。

    以下代码展示了Counter的使用。

    from collections import Counter
    # 创建一个Counter对象来统计列表中各元素的数量
    print(Counter(['a','c','d','d','b','c','a'])) # Counter({'a': 2, 'c': 2, 'd': 2, 'b': 1})
    # 创建一个Counter对象来统计字符串中各字符的数量
    print(Counter('aabbacdd')) # Counter({'a': 3, 'b': 2, 'd': 2, 'c': 1})
    # 创建一个Counter对象来统计字符串中各字符的数量
    string_count = Counter('aabbacdd')
    # Counter对象转换为字典,遍历输出键值对
    for num, count in dict(string_count).items():
    print(num, count)
    # 遍历Counter对象中的项,输出键值对
    for item in string_count.items():
    print(item)
    Counter({'a': 2, 'c': 2, 'd': 2, 'b': 1})
    Counter({'a': 3, 'b': 2, 'd': 2, 'c': 1})
    a 3
    b 2
    c 1
    d 2
    ('a', 3)
    ('b', 2)
    ('c', 1)
    ('d', 2)

    若分别计算字符串中词的出现次数和字符的出现次数,代码如下:

    from collections import Counter
    line = '你好 世界 你好 !'
    # 将字符串按空格拆分成单词列表
    list_of_words = line.split()
    # 计算每个单词出现的次数
    word_count = Counter(list_of_words)
    # 打印每个单词及其出现的次数
    print(word_count) # Counter({'你好': 2, '世界': 1, '!': 1})
    line = '你好 世界 你好 !'
    # 计算每个字符出现的次数
    string_count = Counter(line)
    # 打印每个字符及其出现的次数
    print(string_count) # Counter({' ': 3, '你': 2, '好': 2, '世': 1, '界': 1, '!': 1})
    Counter({'你好': 2, '世界': 1, '!': 1})
    Counter({' ': 3, '你': 2, '好': 2, '世': 1, '界': 1, '!': 1})

    Counter相关功能函数d的使用如下所示:

    from collections import Counter
    # 创建一个Counter对象,用于统计元素出现的次数
    word_count = Counter(['a', 'c', 'd', 'd', 'b', 'c', 'a'])
    # 统计出现次数最多的两个元素并打印结果
    print(word_count.most_common(2)) # [('a', 2), ('c', 2)]
    # 若不指定个数,则列出全部元素及其出现次数
    print(word_count.most_common()) # [('a', 2), ('c', 2), ('d', 2), ('b', 1)]
    # 打印Counter对象中的元素迭代器
    print(word_count.elements()) #
    # 将元素迭代器转换为列表并打印
    print(list(word_count.elements())) # ['a', 'a', 'c', 'c', 'd', 'd', 'b']
    # 将元素迭代器排序后打印
    print(sorted(word_count.elements())) # ['a', 'a', 'b', 'c', 'c', 'd', 'd']
    # 对Counter对象进行排序后打印(按元素字典序排序)
    print(sorted(word_count)) # ['a', 'b', 'c', 'd']
    # 打印Counter对象的键(即元素)
    print(word_count.keys()) # dict_keys(['a', 'c', 'd', 'b'])
    # 打印Counter对象的值(即元素出现的次数)
    print(word_count.values()) # dict_values([2, 2, 2, 1])
    [('a', 2), ('c', 2)]
    [('a', 2), ('c', 2), ('d', 2), ('b', 1)]
    .chain object at 0x7efe4809fcd0>
    ['a', 'a', 'c', 'c', 'd', 'd', 'b']
    ['a', 'a', 'b', 'c', 'c', 'd', 'd']
    ['a', 'b', 'c', 'd']
    dict_keys(['a', 'c', 'd', 'b'])
    dict_values([2, 2, 2, 1])

    对Counter中单个元素的操作,代码如下:

    from collections import Counter
    # 创建一个 Counter 对象,统计列表中各元素的出现次数
    word_count = Counter(['a', 'c', 'd', 'd', 'b', 'c', 'a'])
    # 输出字母"c"的出现次数
    print(word_count["c"]) # 2
    # 更新 Counter 对象,添加新的元素并重新统计出现次数
    word_count.update(['b', 'e'])
    print(word_count) # Counter({'a': 2, 'c': 2, 'd': 2, 'b': 2, 'e': 1})
    # 删除 Counter 对象中的元素"e"
    del word_count["e"]
    print(word_count) # Counter({'a': 2, 'c': 2, 'd': 2, 'b': 2})
    # 将字母"f"的出现次数增加3
    word_count['f'] += 3
    print(word_count) # Counter({'f': 3, 'a': 2, 'c': 2, 'd': 2, 'b': 2})
    # 计算两个Counter对象的交集
    print(Counter('abc') & Counter('bde')) # Counter({'b': 1})
    # 计算两个 Counter 对象的并集
    print(Counter('abc') | Counter('bde')) # Counter({'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 1})
    2
    Counter({'a': 2, 'c': 2, 'd': 2, 'b': 2, 'e': 1})
    Counter({'a': 2, 'c': 2, 'd': 2, 'b': 2})
    Counter({'f': 3, 'a': 2, 'c': 2, 'd': 2, 'b': 2})
    Counter({'b': 1})
    Counter({'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 1})

    4 defaultdict、OrderedDict

    4.1 defaultdict

    defaultdict是Python标准库collections模块中的一个类,它是dict类的一个子类。defaultdict的作用是创建一个字典,当访问字典中不存在的键时,不会抛出KeyError异常,而是返回一个默认值。defaultdict用法如下:

    from collections import defaultdict
    # 创建一个默认值为0的defaultdict对象d
    d = defaultdict(int)
    # 打印d中键'a'对应的值,由于键'a'不存在,所以返回默认值0
    print(d['a']) # 0
    # 将键'b'赋值为2
    d['b'] = 2
    print(d) # defaultdict(, {'a': 0, 'b': 2})
    # 将键'c'对应的值加1
    d['c'] += 1
    print(d) # defaultdict(, {'a': 0, 'b': 2, 'c': 1})
    0
    defaultdict( 'int'>, {'a': 0, 'b': 2})
    defaultdict( 'int'>, {'a': 0, 'b': 2, 'c': 1})

    4.2 OrderedDict

    OrderedDict的使用方法与普通字典dict类似,唯一的区别是它可以设置元素的顺序。

    from collections import OrderedDict
    # 创建一个空的有序字典,按照元素添加的顺序进行遍历和访问
    order_dict = OrderedDict()
    # 添加键值对
    order_dict['apple'] = 3
    order_dict['banana'] = 2
    order_dict['orange'] = 5
    print(order_dict) # OrderedDict([('apple', 3), ('banana', 2), ('orange', 5)])
    # 创建一个字典fruits
    fruits = {'banana': 2, 'apple': 3, 'orange': 5}
    # 按照键对字典进行排序并将其转换为有序字典
    order_dict = OrderedDict(sorted(fruits.items(), key=lambda x: x[0]))
    print(order_dict) # OrderedDict([('apple', 3), ('banana', 2), ('orange', 5)])
    # 按照值对字典进行排序并将其转换为有序字典
    order_dict = OrderedDict(sorted(fruits.items(), key=lambda x: x[1]))
    print(order_dict) # OrderedDict([('banana', 2), ('apple', 3), ('orange', 5)])
    # 按照键的长度对字典进行排序并将其转换为有序字典
    order_dict = OrderedDict(sorted(fruits.items(), key=lambda x: len(x[0])))
    print(order_dict) # OrderedDict([('apple', 3), ('banana', 2), ('orange', 5)])
    OrderedDict([('apple', 3), ('banana', 2), ('orange', 5)])
    OrderedDict([('apple', 3), ('banana', 2), ('orange', 5)])
    OrderedDict([('banana', 2), ('apple', 3), ('orange', 5)])
    OrderedDict([('apple', 3), ('banana', 2), ('orange', 5)])

    5 ChainMap

    ChainMap用于方便地合并多个字典或映射对象,使它们作为一个整体进行操作。具体使用方法如下:

    from collections import ChainMap
    employee1 = {'John': '001', 'Mary': '002', 'David': '003'}
    employee2 = {'Lisa': '004', 'Michael': '005', 'Sarah': '006'}
    employee3 = {'Peter': '007', 'Emily': '008', 'Ryan': '009'}
    # 创建ChainMap对象
    combined_employees = ChainMap(employee1, employee2, employee3)
    # 打印出ChainMap中所有的字典,按照添加顺序
    print(combined_employees.maps)
    # 打印出ChainMap中所有键的列表,按照添加顺序
    print(list(combined_employees.keys()))
    # 打印出ChainMap中所有值的列表,按照添加顺序
    print(list(combined_employees.values()))
    [{'John': '001', 'Mary': '002', 'David': '003'}, {'Lisa': '004', 'Michael': '005', 'Sarah': '006'}, {'Peter': '007', 'Emily': '008', 'Ryan': '009'}]
    ['Peter', 'Emily', 'Ryan', 'Lisa', 'Michael', 'Sarah', 'John', 'Mary', 'David']
    ['007', '008', '009', '004', '005', '006', '001', '002', '003']

    如果要合并的对象中出现键值重合,使用ChainMap时将按照添加顺序,以最先添加的字典为准。在这种情况下,相同的键值经过合并后,会取第一个字典中的值作为重复键的值。具体示例如下:

    from collections import ChainMap
    # John项重复
    employee1 = {'John': '001', 'Mary': '002'}
    employee2 = {'Lisa': '004', 'John': '005'}
    # 创建ChainMap对象
    combined_employees = ChainMap(employee1, employee2)
    print(combined_employees.maps)
    print(list(combined_employees.keys()))
    print(list(combined_employees.values()))
    [{'John': '001', 'Mary': '002'}, {'Lisa': '004', 'John': '005'}]
    ['Lisa', 'John', 'Mary']
    ['004', '001', '002']

    在创建ChainMap对象后,也可以为其添加新的字典类型子项。

    from collections import ChainMap
    employee1 = {'John': '001', 'Mary': '002', 'David': '003'}
    employee2 = {'Mary': '004', 'Michael': '005', 'Sarah': '006'}
    employee3 = {'Peter': '007', 'Emily': '008', 'Ryan': '009'}
    combined_employees = ChainMap(employee1, employee2, employee3)
    # 创建字典employee4,包含员工编号信息
    employee4 = {'Jack': '010', 'Halr': '011'}
    # 使用new_child方法将employee4添加到combined_employees中
    combined_employees = combined_employees.new_child(employee4)
    print(combined_employees)
    ChainMap({'Jack': '010', 'Halr': '011'}, {'John': '001', 'Mary': '002', 'David': '003'}, {'Mary': '004', 'Michael': '005', 'Sarah': '006'}, {'Peter': '007', 'Emily': '008', 'Ryan': '009'})

    6 UserList、UserString、UserDict

    6.1 UserList

    UserList是list的包装类,用于创建一个自定义的列表类。如下所示,UserList可以像普通list一样操作:

    from collections import UserList
    # 创建一个普通的Python列表
    my_list = [13, 4, 1, 5, 7]
    # 使用UserList类构造函数创建一个自定义列表对象,传入普通列表作为参数
    # my_list可以通过UserList.data方法访问。
    user_list = UserList(my_list)
    # 打印自定义列表对象
    print(user_list) # [13, 4, 1, 5, 7]
    # 打印自定义列表对象的Python列表数据
    print(user_list.data) # [13, 4, 1, 5, 7]
    print(user_list[:-1]) # [13, 4, 1, 5]
    [13, 4, 1, 5, 7]
    [13, 4, 1, 5, 7]
    [13, 4, 1, 5]

    UserList的好处在于可以创建一个继承自UserList的子类,以便自定义列表的各个方法。下面是重写了append方法的简单示例:

    from collections import UserList
    class MyList(UserList):
    def __init__(self, initialdata=None):
    super().__init__(initialdata)
    def append(self, item):
    # 在添加元素时打印一条消息
    print("Appending", item)
    super().append(item)
    # 创建一个MyList对象并添加元素
    my_list = MyList([1, 2, 3])
    my_list.append(4)
    print(my_list) # [1, 2, 3, 4]
    Appending 4
    [1, 2, 3, 4]

    6.2 UserString

    UserString用于创建自定义字符串类。通过继承UserString类,可以创建自定义的可变字符串对象,并且可以使用各种字符串操作方法。如下所示:

    from collections import UserString
    # 自定义user_string类,继承自UserString类
    class user_string(UserString):
    # 定义append方法,用于向字符串后追加内容
    def append(self, new):
    self.data = self.data + new
    # 定义remove方法,用于删除字符串中的指定内容
    def remove(self, s):
    self.data = self.data.replace(s, "")
    text = 'dog cat lion elephant'
    animals = user_string(text)
    animals.append("monkey")
    for word in ['cat', 'elephant']:
    animals.remove(word)
    print(animals) # dog lion monkey
    dog lion monkey

    6.3 UserDict

    UserDic是一个字典类型的包装类,用于创建自定义字典类。通过继承UserDict类,可以创建自定义的字典对象。如下所示:

    from collections import UserDict
    class MyDict(UserDict):
    def __init__(self, initialdata=None):
    super().__init__(initialdata)
    def __setitem__(self, key, value):
    # 在设置键值对时,将所有键转为大写
    super().__setitem__(key.upper(), value)
    # 创建自定义字典对象
    my_dict = MyDict()
    # 添加键值对
    my_dict['name'] = 'Alice'
    my_dict['age'] = 25
    # 输出字典内容
    print(my_dict) # {'NAME': 'Alice', 'AGE': 25}
    {'NAME': 'Alice', 'AGE': 25}

    7 参考

  • 相关阅读:
    【博客443】OVS架构组成
    SAP权限相关的表及如何使用FM获取用户权限
    软路由的负载均衡设置:优化网络性能和带宽利用率
    Docker安装操作常用服务器软件
    Vite - 静态资源处理 - json文件导入
    java《ArrayList篇》--ArrayList全套知识点总结及其配套习题逐语句分析(附带全套源代码)
    msyql锁分类
    界面组件DevExpress Reporting v23.1亮点 - 全新升级报表查看器
    【模式识别】计算机科学博士课程作业解析
    FreeRTOS介绍 和 将FreeRTOS移植到STM32F103C8T6
  • 原文地址:https://www.cnblogs.com/luohenyueji/p/17680320.html