python collections

最新推荐文章于 2024-10-13 19:04:04 发布

bgape002

最新推荐文章于 2024-10-13 19:04:04 发布

阅读量380

点赞数 4

分类专栏： python3 文章标签： python 开发语言

本文链接：https://blog.csdn.net/bgape002/article/details/136283013

版权

python3 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

title: collections package

collections模块

collections包含了一些特殊的容器，针对Python内置的容器，例如list、dict、set和tuple，提供了另一种选择；
namedtuple，可以创建包含名称的tuple；
deque，类似于list的容器，可以快速的在队列头部和尾部添加、删除元素；
Counter，dict的子类，计算可hash的对象；
OrderedDict，dict的子类，可以记住元素的添加顺序；

这里主要介绍namedtuple

`namedtuple`

tuple

tuple元组

不可变；可迭代。python的变量实质是引用

拆包

tup1 = ('bgape002', 'bgape003')
tup2 = ('bgape002', 'bgape003', '002', '003')
tup3 = (*tup1, '002', '003')

n1, n2 = tup1
me, *other = tup2  # 取出第一个元素，其余的放在一个列表里
m1, *m2 = tup1

print(n1, n2)
print(me, other)
print(m1, m2)

"""output
bgape002 bgape003
bgape002 ['bgape003', '002', '003']
bgape002 ['bgape003']

('bgape002', 'bgape003', '002', '003')

"""

不可变不是绝对的；一般不建议元组里放入可变对象（如列表）

tup = ('bgape', ['bgape002', 'bgape003'])
tup[1].append('001')
print(tup)

"""output
('bgape', ['bgape002', 'bgape003', '001'])

"""

tuple优点
- 性能优化，元组会作为常量在编译时确定，优化程序性能
- 线程安全
- 元组可作为dict字典的key
- 拆包特性

namedtuple

可以类似class通过.来访问数据；代码简洁，实现简单
继承了tuple的优点

"""namedtuple基础应用

"""
from collections import namedtuple

# 定义一个namedtuple类型User，并包含name，sex和age属性。
User = namedtuple('User', ['name', 'sex', 'age'])


#########     创建一个User对象    #############
user = User(name='Runoob', sex='male', age=12)

# 获取所有字段名
print(user._fields)

# 也可以通过一个list来创建一个User对象，这里注意需要使用"_make"方法
user = User._make(['Runoob', 'male', 12])

print(user)
# User(name='user1', sex='male', age=12)

# 获取用户的属性
print(user.name)
print(user.sex)
print(user.age)

# 修改对象属性，注意要使用"_replace"方法
user = user._replace(age=22)
print(user)
# User(name='user1', sex='male', age=21)

# 将User对象转换成字典，注意要使用"_asdict"
print(user._asdict())
# OrderedDict([('name', 'Runoob'), ('sex', 'male'), ('age', 22)])

"""namedtuple的一些便捷使用技巧

"""

from collections import namedtuple


# User = namedtuple('User', ['name', 'sex', 'age'])
User = namedtuple('User', ['name', 'sex', 'age', 'heigh'])
oTup = ('Runoob', 'male', 12)
oDict = {'name': 'Runoob', 'sex': 'male', 'age': 12}
# user = User(name='Runoob', sex='male', age=12)   直接赋值
user = User(*oTup, 178)    # 通过元组赋值
userD = User(**oDict, heigh=178)    # 通过字典赋值

print(user)
print(userD)

# 拆包特性
name, sex, *other = user
print(name, sex, *other)


"""output
User(name='Runoob', sex='male', age=12, heigh=178)
User(name='Runoob', sex='male', age=12, heigh=178)
Runoob male 12 178

"""

`defaultdict`

咋觉着基础的dict更灵活好用呢…

`deque`

双端队列，适用于数据需要对头部做频繁操作的情景。

`Counter`


from collections import *


class Collections_op(object):
    # counter可以支持方便、快速的计数
    def counterop(self):
        cnt1 = Counter()
        cnt2 = Counter("serchingFortheoceans")
        cnt3 = Counter({"dogs": 4, "cats": 8})
        cnt4 = Counter(a=2,b=4,c=0,d=-2,e = 1,g=2,f=4,h=2)
        cnt5 = Counter(a=5, b=1, c=2, d=1, e=1, g=4, h=2, j=4)
        wordList = ["a", "b", "c", "c", "a", "a"]
        for word in wordList:
            cnt1[word] += 1
        print(cnt1, type(cnt1))
        print(cnt2, type(cnt2))
        print("-" * 20)
        print(cnt3, type(cnt3))

        # Counter对象类似于字典，如果某个项缺失，会返回0，而不是报出KeyError
        print('s:',cnt2['s'],type(cnt2['s']),'dogs:',cnt3['dogs'],'dog:',cnt3['dog'])
        # 元素赋值与删除元素
        cnt3['dog'] = 0
        del cnt3['dogs']
        print('cnt3:', cnt3)
        print('-'*40)
        print('cnt4:', cnt4)

        # element()，返回一个迭代器，每个元素重复的次数为它的数目，
        # 顺序是任意的顺序，
        # 如果一个元素的数目少于1，那么elements()就会忽略它；
        print('cnt4.elements:',list(cnt4.elements()))

        # most_common(n)，返回一个列表，包含counter中n个最大数目的元素，
        # 如果忽略n或者n=None，most_common()将会返回counter中的所有元素，
        # 元素有着相同数目的将会以任意顺序排列；
        print('cnt4.most_common:', cnt4.most_common(3))

        # subtract()，从一个可迭代对象中或者另一个映射（或counter）中，元素相减，
        # 返回一个counter对象，按数值从大到小排序的，
        # 输入和输出都有可能为0或者为负；
        print('-' * 40)
        print('cnt5:', cnt5)
        print('cnt4:', cnt4)
        cnt5.subtract(cnt4)
        print('cnt5-cnt4:', cnt5)

        # update()，从一个可迭代对象中或者另一个映射（或counter）中所有元素相加，
        # 是数目相加而非替换它们，
        # 可迭代对象是一个元素序列，而非(key,value)对构成的序列；
        print('cnt5+cnt4:', cnt5+cnt4)


if __name__ == "__main__":
    op = Collections_op()
    op.counterop()