python内置库-collections

斕野清辰

已于 2022-10-26 22:04:02 修改

阅读量296

点赞数

分类专栏： python内置库学习文章标签： python

于 2022-10-22 21:56:50 首次发布

本文链接：https://blog.csdn.net/u012891582/article/details/127468141

版权

python内置库学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Counter

功能：是一个字典的子类，用于计数可哈希对象(不可变对象)
格式：Counter(iterable)
描述：

from collections import Counter
c1 = Counter('abbccd')
c2 = Counter(['a', 'b', 'b', 'c', 'c', 'd'])
print(c1)
print(c2)

输出：

Counter({'b': 2, 'c': 2, 'a': 1, 'd': 1})
Counter({'b': 2, 'c': 2, 'a': 1, 'd': 1})

下面是不可哈希对象，会报错

c3 = Counter([['a'], ['b'], ['b'], ['c'], ['c'], ['d']])

namedtuple

from collections import namedtuple

"""
创建一个  命名元组子类 的工厂函数
作用：用以构建只有少数属性但是没有方法的对象
namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)
"""

'''
定义：  typename --> 元组子类的类名
       field_names --> 属性名
       rename -->
       default --> 
'''
# 定义时，field_names可以有三种写法：'a b c'  'a, b, c'  ['a', 'b', 'c']
People = namedtuple('People', ['age', 'name', 'sex'])
p1 = People(18, 'xiaoming', 'nan')

''' 访问 '''
# 将p1当成一个对象来访问
print(p1.name)

# 将p1当成一个元组来访问
print(p1[0], p1[1], p1[2])

''' 默认值   向右对齐'''
animal = namedtuple('animal', ['name', 'age', 'sex'], defaults=[0, '公'])
a1 = animal('monkey')
print(a1[0], a1[1], a1[2])

deque

from collections import deque

"""
deque(iteable, maxlen)
描述：用户创建双向队列
iteable:任意可迭代对象
maxlen： 队列最大长度，
         默认无限长
         有值时达到最大长度后，新项从一端进时老值从另一端出
         
append(x)：添加 x 到右端。
appendleft(x)：添加 x 到左端。
clear()：移除所有元素，使其长度为0.
copy()：创建一份浅拷贝。3.5 新版功能.
count(x)：计算deque中个数等于 x 的元素。3.2 新版功能.
extend(iterable)：扩展deque的右侧，通过添加iterable参数中的元素。
extendleft(iterable)：扩展deque的左侧，通过添加iterable参数中的元素。注意，左添加时，在结果中iterable参数中的顺序将被反过来添加。
index(x[, start[, stop]])：返回第 x 个元素（从 start 开始计算，在 stop 之前）。返回第一个匹配，如果没找到的话，升起 ValueError 。3.5 新版功能.
insert(i, x)：在位置 i 插入 x 。如果插入会导致一个限长deque超出长度 maxlen 的话，就升起一个 IndexError 。3.5 新版功能.
pop()：移去并且返回一个元素，deque最右侧的那一个。如果没有元素的话，就升起 IndexError 索引错误。
popleft()：移去并且返回一个元素，deque最左侧的那一个。如果没有元素的话，就升起 IndexError 索引错误。
remove(value)：移去找到的第一个 value。 如果没有的话就升起 ValueError 。
reverse()：将deque逆序排列。返回 None 。3.2 新版功能.
rotate(n=1)：向右循环移动 n 步。 如果 n 是负数，就向左循环。如果deque不是空的，向右循环移动一步就等价于 d.appendleft(d.pop()) ， 
             向左循环一步就等价于 d.append(d.popleft()) 。
Deque对象同样提供了一个只读属性:
maxlen：Deque的最大尺寸，如果没有限定的话就是 None 。
             
"""

dq = deque()
print(dq)  # deque([])

dq = deque('abc', 10)
print(dq)  # deque(['a', 'b', 'c'], maxlen=10)
print(list(dq))  # ['a', 'b', 'c']

defualtdict

from collections import defaultdict
"""
字典的子类，为字典的访问提供默认值
描述：使用dict时，如果应用的key不存在，则返回设置的默认值。
defaultdict(default_factory=None, **kwargs)

default_factory   用于设置字典值的默认值，default_factory是一个可调用的对象
"""

dic1 = defaultdict(lambda: 'no exist')
print(dic1['dic1'])  # no exist
print(dic1.get('test'))  # None

dic2 = defaultdict(int)
print(dic2['dic2'])  # 0
print(dic2.get('test2'))  # None


''' 应用举例 '''
# 列表：
l = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
d = defaultdict(list)
for k, v in l:
    d[k].append(v)
print(d)  # {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]}

# 计数
s = 'abbccc'
d = defaultdict(int)
for w in s:
    d[w] = d[w]+1
print(d)  # {'a': 1, 'b': 2, 'c': 3}

OrderedDict

from collections import OrderedDict
import copy

"""
字典的子类，保留了元素被添加的顺序
功能： 1、记住插入顺序(初始化时候的顺序是否记住了)  
       2、根据key，value排序

"""

''' 定义 '''
d = OrderedDict(name="xiaoming", age=18)
d['sex'] = 'nan'
d['job'] = 'student'
d['sport'] = 'football'
print(d)
print(d['name'])

''' 排序 '''
fruits = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2, 'cherry': 10}
sorted_fruits_by_key = OrderedDict(sorted(fruits.items(), key=lambda x: x[0]))
print(sorted_fruits_by_key)
sorted_fruits_by_value = OrderedDict(sorted(fruits.items(), key=lambda x: x[1]))
print(sorted_fruits_by_value)

print(isinstance(sorted_fruits_by_value, dict))  # True

''' 其他方法 '''
print("##################### 弹出 ######################")
d1 = d.copy()
print(f'd1:{d1}')
print(d1.popitem(-1))  # 弹出尾
print(d1.popitem())  # 弹出尾
print(d1.popitem(last=True))  # 弹出尾
print(d1.popitem(last=False))  # 弹出头
print(d1.popitem(0))  # 弹出头

print("##################### 移动元素 ######################")
d2 = d.copy()
print(f'd2:{d2}')
d2.move_to_end('name')  # 移动到尾
d2.move_to_end('name', last=True)  # 移动到尾
d2.move_to_end('name', last=False)  # 移动到头
print(d2)

# 访问的key不存在则添加key
d3 = d.copy()
val = d3.setdefault('k5')
print(val)
print(d3)

# 传统的字典不能指定索引pop项目
x = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
print(x.pop('apple'))
print(x.popitem())

ChainMap

from collections import ChainMap

"""
字典的容器
如果键相同，前面的会覆盖后面的
"""

d1 = {'red': 1, 'yellow': 2}
d2 = {'green': 3, 'white': 4, 'red':10}
combine = ChainMap(d1, d2)
print(combine)  # {'red': 1, 'yellow': 2}, {'green': 3, 'white': 4}
for k, v in combine.items():
    print(f'{k}: {v}')

print('\n')

combine_rev = ChainMap(d2, d1)
print(combine_rev)  # {'green': 3, 'white': 4}, {'red': 1, 'yellow': 2}
for k, v in combine_rev.items():
    print(f'{k}: {v}')


''' 更新 '''
print(f'\n#####更新')
combine.maps[0]['red'] = 100
print(combine)

abc

UserDict

from collections import UserDict
import sys
"""
这个UserDict只是一个内置dict的封装类,其中包含的字典内容通过data访问.

想要创建自己的具有某些修改函数或某些新函数的字典时，此类非常有用。它可以被视为为字典添加新行为的一种方式。此类将字典实例作为参数，并模拟保存在常规字典中的字典。该类的data属性可访问该词典。
"""
d = {'a': 1, 'b': 2, 'c': 3}
ud = UserDict(d)  # {'a': 1, 'b': 2, 'c': 3}
print(ud.data)

print(sys.getsizeof(d))  # 232
print(sys.getsizeof(ud)) # 48
print(sys.getsizeof(ud.data)) # 232