collections:内建模块,提供额外的集合类
介绍
collections里面包含了很多除了内置类型之外的数据类型,我们使用它们有时可以很方便的完成一系列操作
ChainMap:搜索多个字典
from collections import ChainMap
'''
ChainMap类一个字典序列,并按照其出现的顺序搜索以查找与键关联的值。
ChainMap提供了一个很好的上下文容器,因为可以把它看做成一个栈,栈增长时发生变更,栈收缩时这些变更将被丢弃
'''
d1 = {"a": 12, "b": 22, "c": 33}
d2 = {"b": 1, "c": 2, "d": 3}
# 将多个字典传进去
d = ChainMap(d1, d2)
for k, v in d.items():
print(k, v)
'''
b 22
c 33
d 3
a 12
'''
# 可以看到打印的结果是无序的,而且如果多个字典中有相同的key,那么只保留第一次出现的key
# 并且ChainMap有一个maps属性,存储了要搜索的映射列表。这个列表是可变的。所以可以直接增加新映射,或者改变元素的顺序以控制查找和更新行为。
print(d.maps) # [{'a': 12, 'b': 22, 'c': 33}, {'b': 1, 'c': 2, 'd': 3}]
# 这是我们存储的信息,如果在d.maps里面修改了,那么会怎么样呢?
print(d1) # {'a': 12, 'b': 22, 'c': 33}
d.maps[0]["a"] = "yoyoyo"
# 可以看到d.maps里面存储的只是一个引用,因此改变之后会影响原来的结果
print(d1) # {'a': 'yoyoyo', 'b': 22, 'c': 33}
# 那我如果改变了原来的值,会不会影响d.maps呢?显然是可以的,毕竟同一个内存地址嘛
d2["d"] = "我屮艸芔茻"
print(d.maps) # [{'a': 'yoyoyo', 'b': 22, 'c': 33}, {'b': 1, 'c': 2, 'd': '我屮艸芔茻'}]
Counter:统计可散列的对象
from collections import Counter
'''
Counter是一个容器,可以计算出序列中每一个元素出现的次数
'''
# 初始化
print(Counter("aabbbc")) # Counter({'b': 3, 'a': 2, 'c': 1})
print(Counter(['a', 'a', 'b', 'b', 'b', 'c'])) # Counter({'b': 3, 'a': 2, 'c': 1})
print(Counter(a=2, b=3, c=1)) # Counter({'b': 3, 'a': 2, 'c': 1})
c = Counter("aaabbc")
# 表示a出现了三次,b出现了两次,c出现了一次
print(c) # Counter({'a': 3, 'b': 2, 'c': 1})
# 可以进行填充
c.update("bcd")
# 可以看到b和c的值都增加了1,并且出现了d
print(c) # Counter({'a': 3, 'b': 3, 'c': 2, 'd': 1})
# 访问计数,Counter对象可以像字典一样访问
print(c["a"]) # 3
# 如果访问一个不存在的key,不会引发KeyError,而是会返回0,表示对象中没有这个key
print(c["mmp"]) # 0
# 还可以使用elements进行迭代,会得到Counter对象中的所有元素
print(list(c.elements())) # ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd']
# 还可以计算出现最多的元素
# 统计string中前三个出现次数最多的元素
string = "sasaxzsdsadfscxzcasdscxzdfscxsasadszczxczxcsds"
c = Counter(string)
print(c) # Counter({'s': 13, 'c': 7, 'a': 6, 'x': 6, 'z': 6, 'd': 6, 'f': 2})
print(c.most_common(3)) # [('s', 13), ('c', 7), ('a', 6)]
# Counter还可以进行算数操作
c1 = Counter("aabbccc")
c2 = Counter("bbbccdd")
print(c1) # Counter({'a': 2, 'b': 2, 'c': 3})
print(c2) # Counter({'b': 3, 'c': 2, 'd': 2})
# 如果c1的元素出现在了c2中,就把该元素减去,记住:减的是次数
print(c1 - c2) # Counter({'a': 2, 'c': 1})
'''
a在c1中出现了2次,c2中没有出现,所有是a: 2。b在c1中出现两次,在c2中出现3次,所以一减就没有了。
而c在c1中出现了三次,在c2中出现两次,所以相减还剩下一次。至于c1没有的元素就不用管了
'''
# 相加就很好理解了
print(c1 + c2) # Counter({'b': 5, 'c': 5, 'a': 2, 'd': 2})
# 相交的话,查找公共的元素,并且取次数出现较小的那个
print(c1 & c2) # Counter({'b': 2, 'c': 2})
# 并集的话,取较大的,记住不是相加,所以b和c出现的次数不会增加,只是取较大的那个、
print(c1 | c2) # Counter({'b': 3, 'c': 3, 'a': 2, 'd': 2})
defaultdict:缺少的键返回一个默认值
from collections import defaultdict
'''
标准字典中有setdefault和get,可以用来获取key对应的value。
如果key存在,两者会获取key对应的value
但如果key不存在,setdefault就会先将key和指定的默认值设置进去,然后返回一个默认值。
而get则只会返回默认值,。不会设置值
example:
d = {"a": 1}
print(d.get("a", 0)) # 1
print(d.setdefault("a", 0)) # 1
print(d) # {"a": 1}
print(d.get("b", 0)) # 0
print(d) # {"a": 1}
print(d.setdefault("b", 0)) # 0
print(d) # {"a": 1, "b": 0}
所以这里相当于执行了两步操作。先将("b", 0)设置到字典里,然后再获取
defaultdict在初始化的时候就会让调用者提前指定默认值
'''
# 统计每一个元素出现的次数
s = "aabbccdddddee"
d1 = {}
for c in s:
# 不存在就默认设置为0
d1.setdefault(c, 0)
d1[c] += 1
print(d1) # {'a': 2, 'b': 2, 'c': 2, 'd': 5, 'e': 2}
如果使用defaultdict的话呢?
from collections import defaultdict
# 如果使用defaultdict的话呢?
d2 = defaultdict(int)
print(d2["a"]) # 0
d2 = defaultdict(str)
print("%r" % d2["a"]) # ''
d2 = defaultdict(tuple)
print(d2["a"]) # ()
d2 = defaultdict(list)
print(d2["a"]) # []
# 如果获取不到key,那么会自动输出传入类型所对应的零值.能获取到key,输入key对应的value值
from collections import defaultdict
s = "aabbccdddddee"
d2 = defaultdict(int)
for c in s:
'''
一开始没有值,设置为0,然后每来一个值就加上1
'''
d2[c] += 1
print(d2) # defaultdict(<class 'int'>, {'a': 2, 'b': 2, 'c': 2, 'd': 5, 'e': 2})
此外还可以自定义返回值,只需要添加一个不需要参数的函数即可,并指定一个返回值
from collections import defaultdict
# 此时的默认值就是default
d3 = defaultdict(lambda: "default")
print(d3["aa"]) # default
# 此外还可以添加参数,因为单独指定了aa,所以打印的时候以指定的为准
# 如果没有指定,那么才会得到默认值
d4 = defaultdict(lambda: "default", aa="bar")
print(d4["aa"]) # bar
print(d4["bb"]) # default
那么肯定会有人好奇,这是如何实现的呢?其实里面主要使用了一个叫做__missing__
的魔法方法
class MyDict(dict):
def __getitem__(self, item):
value = super().__getitem__(item)
# 会执行父类的__getitem__方法,如果获取不到
# 会检测我们是否定义__missing__方法,如果有,执行。没有,报错
# 所以这里的value就是__missing__方法的返回值
return value
def __missing__(self, key):
self[key] = "搞事情ヘ(´ー`ヘ)搞事情"
return self[key]
d = MyDict([("a", 3), ("b", 4)])
print(d) # {'a': 3, 'b': 4}
print(d["mmm"]) # 搞事情ヘ(´ー`ヘ)搞事情
deque:双端队列
双端队列支持从任意一端增加和删除元素。更为常用的两种数据结构(即栈和队列)就是双端队列的退化形式,它们的输入和输出被限制在某一端
from collections import deque
d = deque("abcdefg")
print(d) # deque(['a', 'b', 'c', 'd', 'e', 'f', 'g'])
print(len(d)) # 7
print(d[0]) # a
print(d[-1]) # g
# 由于deque是一种序列容器,因此同样支持list的操作。如:通过索引获取元素,查看长度,删除元素,反转元素等等
# list支持的deque基本上都支持
d.reverse()
print(d) # deque(['g', 'f', 'e', 'd', 'c', 'b', 'a'])
d.remove("c")
print(d) # deque(['g', 'f', 'e', 'd', 'b', 'a'])
除了增删改查,并且还支持其他操作
from collections import deque
d = deque("abcdefg")
# 填充元素
# 首先可以像list一样添加元素,但是deque可以从两端添加
d.append("yoyoyo") # 默认和list一样,在尾部添加
d.appendleft("哟哟哟") # 也可以添加在头部
print(d) # deque(['哟哟哟', 'g', 'f', 'e', 'd', 'b', 'a', 'yoyoyo'])
# 还可以使用insert, 如果范围越界,自动添加在两端
d.insert(100, "x")
print(d) # deque(['哟哟哟', 'g', 'f', 'e', 'd', 'b', 'a', 'yoyoyo', 'x'])
# extend,extendleft
d1 = [1, 2, 3]
d2 = deque([4, 5, 6])
d.extend(d1)
print(d) # deque(['哟哟哟', 'g', 'f', 'e', 'd', 'b', 'a', 'yoyoyo', 'x', 1, 2, 3])
d.extendleft(d2)
print(d) # deque([6, 5, 4, '哟哟哟', 'g', 'f', 'e', 'd', 'b', 'a', 'yoyoyo', 'x', 1, 2, 3])
# 可以看到extend也支持从左端添加,而且不仅仅可以添加deque,任意序列类型都是可以的。
d.extendleft("我屮艸芔茻")
print(d) # deque(['茻', '芔', '艸', '屮', '我', 6, 5, 4, '哟哟哟', 'g', 'f', 'e', 'd', 'b', 'a', 'yoyoyo', 'x', 1, 2, 3])
# 注意添加的顺序,我们是从左边开始添加的,先添加"我",然后"屮"跑到开头就把"我"挤到右边了,所以是结果是倒过来的
# 那么如果消费deque里面的元素呢?
print(d.pop()) # 3
print(d.pop()) # 2
print(d.pop()) # 1
print(d.pop()) # x
print(d.popleft()) # 茻
# pop是从右端删除一个元素,popleft是从左端开始删除一个元素。但是如果我想pop掉指定的索引的元素,只能用pop函数,传入索引值即可
# 注意:deque和queue一样,是线程安全的,是受GIL这把超级大锁保护的,可以不同的线程中进行消费。
# 如果想清空里面的元素的话,可以像list、dict一样,使用clear函数
d.clear()
print(d) # deque([])
# 旋转
# deque还有一个很用的地方就是可以按任意一个方向进行旋转,从而跳过某些元素。
# d.rotate(n)-->n大于0,从右边开始取n个元素放到左边,n小于0,从左边取n个元素放到右边
d = deque(range(10))
print(d) # deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
d.rotate(2)
# 从右边取2个元素放到左边,所以8和9被放到了左边
print(d) # deque([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
d.rotate(-3)
# 从左边取3个元素放到右边,所以8、9、0被放到了右边
print(d) # deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
# 限制队列的大小
# 我们在初始化一个双端队列的时候,还可以限制它的大小
d = deque("abcdefg", maxlen=5)
# 我们初始化7个元素,但是指定最大长度只有5,所以前面两个("a"和"b")就被挤出去了
print(d) # deque(['c', 'd', 'e', 'f', 'g'], maxlen=5)
d.appendleft("yoyoyo")
# 当我往前面添加元素的时候,后面的就被挤出去了,因为队列最多只能容纳5个元素
print(d) # deque(['yoyoyo', 'c', 'd', 'e', 'f'], maxlen=5)
namedtuple:带名字字段的元组子类
from collections import namedtuple
# 传入名字,和字段
person = namedtuple("person", ["name", "age", "gender"])
person1 = person(name="mashiro", age=16, gender="f")
print(person1) # person(name='mashiro', age=16, gender='f')
print(person1.name, person1.age, person1.gender) # mashiro 16 f
print(person1[0]) # mashiro
'''
可以看到不仅可以像普通的tuple一样使用索引访问,还可以使用像类一样通过.字段名访问
'''
person2 = person("satori", 16, "f")
print(person2) # person(name='satori', age=16, gender='f')
'''
注意:这个和普通的元组一样,是不可以修改的
'''
try:
person2.name = "xxx"
except AttributeError as e:
print(e) # can't set attribute
# 非法字段名,不能使用Python的关键字
try:
girl = namedtuple("女孩们", ["for", "in"])
except ValueError as e:
print(e) # Type names and field names cannot be a keyword: 'for'
# 如果字段名重复了怎么办
try:
girl = namedtuple("女孩们", ["name", "age", "age"])
except ValueError as e:
print(e) # Encountered duplicate field name: 'age'
# 如果非要加上重名字段呢,可以设置一个参数
girl = namedtuple("女孩们", ["name", "age", "age"], rename=True)
print(girl) # <class '__main__.女孩们'>
girl1 = girl("koishi", 15, 15)
# 可以看到重复的字段名会按照索引的值,在前面加上一个下划线。比如第二个age重复,它的索引是多少呢?是2,所以默认帮我们把字段名修改为_2
print(girl1) # 女孩们(name='koishi', age=15, _2=15)
# 此外我们所有的字段名都保存在_fields属性中
print(girl1._fields) # ('name', 'age', '_2')
OrderDict:记住字典键值对的顺序
OrderDict是一个字典子类,可以记住字典中增加键的顺序。在Python2中,字典是无序的,但在Python3中,字典默认是有序的,所以这个个人觉得不是很常用,至少在python3中感觉不是很常用
from collections import OrderedDict
d = OrderedDict()
d["a"] = "A"
d["b"] = "B"
d["c"] = "C"
for k, v in d.items():
print(k, v)
'''
a A
b B
c C
'''
# 此外也可以在初始化的时候,添加元素
print(OrderedDict({"a": 1})) # OrderedDict([('a', 1)])
# 相等性,对于常规字典来说,只要里面元素一样便是相等的,不考虑顺序。但是对于OrderDict来说,除了元素,顺序也要一样,否则就不相等
d1 = {"a": 1, "b": 2}
d2 = {"b": 2, "a": 1}
print(d1 == d2) # True
d1 = OrderedDict({"a": 1, "b": 2})
d2 = OrderedDict({"b": 2, "a": 1})
print(d1 == d2) # False
# 重排
# 在OrderDict中可以使用move_to_end()将键移至序列的起始位置或末尾位置来改变键的顺序
d3 = OrderedDict({"a": 1, "b": 2, "c": 3, "d": 4})
d3.move_to_end("c") # 表示将key="c"的这个键值对移动到末尾
print(d3) # OrderedDict([('a', 1), ('b', 2), ('d', 4), ('c', 3)])
d3.move_to_end("c", last=False) # 表示将key="c"的这个键值对移动到行首
print(d3) # OrderedDict([('c', 3), ('a', 1), ('b', 2), ('d', 4)])
collections:内建模块,提供额外的集合类的更多相关文章
- python常用内建模块 collections,bs64,struct,hashlib,itertools,contextlib,xml
# 2 collections 是Python内建的一个集合模块,提供了许多有用的集合类. # 2.1 namedtuple #tuple可以表示不变集合,例如,一个点的二维坐标就可以表示成: p ...
- Python内建模块--collections
python内建模块--collections collections是Python内建的一个集合模块,提供了许多有用的集合类. namedtuple 我们知道tuple可以表示不变集合,例如,一个点 ...
- Python常用的内建模块
PS:Python之所以自称“batteries included”,就是因为内置了许多非常有用的模块,无需额外安装和配置,即可直接使用.下面就来看看一些常用的内建模块. 参考原文 廖雪峰常用的内建模 ...
- Python常用内建模块
Python常用内建模块 datetime 处理日期和时间的标准库. 注意到datetime是模块,datetime模块还包含一个datetime类,通过from datetime import da ...
- python的常用内建模块与常用第三方模块
本文的文字及图片来源于网络,仅供学习.交流使用,不具有任何商业用途,如有问题请及时联系我们以作处理 一.常用内置模块1.datetimePython 提供了一个 time 和 calendar 模块可 ...
- Python常用内建模块和第三方库
目录 内建模块 1 datetime模块(处理日期和时间的标准库) datetime与timestamp转换 str与datetime转换 datetime时间加减,使用timedelta这个类 转 ...
- Python3 内建模块 hashlib、itertools、HTMLParser、urllib
Python的hashlib提供了常见的摘要算法,如MD5,SHA1等等. 什么是摘要算法呢?摘要算法又称哈希算法.散列算法.它通过一个函数,把任意长度的数据转换为一个长度固定的数据串(通常用16进制 ...
- 四十六 常用内建模块 itertools
Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数. 首先,我们看看itertools提供的几个“无限”迭代器: >>> import itertools ...
- Python的程序结构[5] -> 模块/Module[0] -> 内建模块 builtins
builtins 内建模块 / builtins Module 在Python的模块中,有一种特殊模块,无需导入便可以使用,其中包含了许多内建函数与类. builtins 模块内容 / builtin ...
- Python3 内建模块 datetime/collections/base64/struct
datetime 我们先看如何获取当前日期和时间: >>> from datetime import datetime >>> now = datetime.now ...
随机推荐
- partprobe 和 partx 的用法
partprobe: 用于重读分区表,当出现删除文件后,出现仍然占用空间.可以partprobe在不重启的情况下重读分区. 将磁盘分区表变化信息通知内核,请求操作系统重新加载分区表. -d 不更新内核 ...
- Python3的编译安装
Linux环境自带了Python 2.x版本,但是如果要更新到3.x的版本,可以在Python的官方网站下载Python的源代码并通过源代码构建安装的方式进行安装,具体的步骤如下所示. 1. 安装依赖 ...
- jenkins密码忘记解决
1.停止jenkins sh /usr/local/tomcat/bin/shutdown.sh 2.找到config.xml [root@test3 hello]# find / -name con ...
- Es性能优化
1. Es中10亿级别的数据量,如何提高查询效率 (1) 性能优化关键:file system cache a. 不要期待随手挑一个参数,就可以万能的应对所有性能慢的场景 b. es依赖于底层的fil ...
- 20190526 - CentOS 7 中 安装 MySQL 8 并授权 root 远程访问
1. CentOS 7 中 安装 MySQL 8 CentOS 7 中内置 MariaDB 建议升级一下用,性能好很多.但如果一定要用 MySQL 8,就得自己装. 坦白的说,Oracle 升级 My ...
- 【并行计算-CUDA开发】CUDA线程、线程块、线程束、流多处理器、流处理器、网格概念的深入理解
GPU的硬件结构,也不是具体的硬件结构,就是与CUDA相关的几个概念:thread,block,grid,warp,sp,sm. sp: 最基本的处理单元,streaming processor 最 ...
- NPM安装过程中的一些问题与解决
1. 安装 vue-cli3后提示 : Package require os(darwin) not compatible with your platform(win32). 上面是因为安装 npm ...
- 第三次Java实验报告
Java实验报告 班级 计科二班 学号20188437 姓名 何磊 完成时间 2019/9/22 评分等级 实验三 String类的应用 实验目的 掌握类String类的使用: 学会使用JDK帮助文档 ...
- H2内嵌数据库的使用
H2内嵌数据库的使用 H2是一个开源的嵌入式数据库引擎,采用java语言编写,不受平台的限制. 同时H2提供了一个十分方便的web控制台用于操作和管理数据库内容. H2还提供兼容模式,可以兼容一些主流 ...
- PAT B1048 数字加密 (20)
AC代码 #include <cstdio> #include <cstring> #include <algorithm> #include <iostre ...