namedtuple
类似于能帮我们创建一个动态的类，使用该类我们可以动态指定属性和值，并且值只能定义一次，以后无法再修改，举例：
from collections import namedtuple
People = namedtuple("People", ["name", "age", "hobby"])
# 创建一个People类，含有name、age和hobby属性，并且属性值只能初始化的时候设置一次
people = People(name="aaa", age=10, hobby="play")
# people = People("aaa", 10, "play")
# 两种传参都可以
print(people)
print(people.name, people.age, people.hobby)
people.name = "xxx"
# 不能修改值
print(people.name, people.age, people.hobby)
# People(name='aaa', age=10, hobby='play')
# aaa 10 play
# AttributeError: can't set attribute
优势
- 节省我们自己开发代码
- 使用
namedtuple创建的类会省掉很多不必要的变量，帮我们节省空间 - 省内存、效率高
实现原理
该类实际上先编写了一个类的字符串模板，源码如下：
_class_template = """\
from builtins import property as _property, tuple as _tuple
from operator import itemgetter as _itemgetter
from collections import OrderedDict
class {typename}(tuple):
'{typename}({arg_list})'
__slots__ = ()
_fields = {field_names!r}
def __new__(_cls, {arg_list}):
'Create new instance of {typename}({arg_list})'
return _tuple.__new__(_cls, ({arg_list}))
@classmethod
def _make(cls, iterable, new=tuple.__new__, len=len):
'Make a new {typename} object from a sequence or iterable'
result = new(cls, iterable)
if len(result) != {num_fields:d}:
raise TypeError('Expected {num_fields:d} arguments, got %d' % len(result))
return result
def _replace(_self, **kwds):
'Return a new {typename} object replacing specified fields with new values'
result = _self._make(map(kwds.pop, {field_names!r}, _self))
if kwds:
raise ValueError('Got unexpected field names: %r' % list(kwds))
return result
def __repr__(self):
'Return a nicely formatted representation string'
return self.__class__.__name__ + '({repr_fmt})' % self
def _asdict(self):
'Return a new OrderedDict which maps field names to their values.'
return OrderedDict(zip(self._fields, self))
def __getnewargs__(self):
'Return self as a plain tuple. Used by copy and pickle.'
return tuple(self)
{field_defs}
"""
以及创建属性的字符串模板：
_field_template = '''\
{name} = _property(_itemgetter({index:d}), doc='Alias for field number {index:d}')
'''
然后通过格式化字符串后，通过exec函数动态创建类，通过该模板发现其还提供了几个方法，下面会介绍
提供方法
_make
类方法，接收一个迭代器创建对象，举例：
from collections import namedtuple
People = namedtuple("People", ["name", "age", "hobby"])
people = People._make(["aaa", 10, "play"])
# 传入一个可迭代对象创建对象
print(people)
# People(name='aaa', age=10, hobby='play')
_replace
修改指定属性值，并返回一个新的对象，举例：
from collections import namedtuple
People = namedtuple("People", ["name", "age", "hobby"])
people = People._make(["aaa", 10, "play"])
new_people = people._replace(name="bbb")
# 修改name，并返回一个新的对象
print(new_people)
# People(name='bbb', age=10, hobby='play')
_asdict
将类转成有序字典返回，举例：
from collections import namedtuple
People = namedtuple("People", ["name", "age", "hobby"])
people = People._make(["aaa", 10, "play"])
print(people._asdict())
# OrderedDict([('name', 'aaa'), ('age', 10), ('hobby', 'play')])
defaultdict
能够在key不存在的时候自动生成一个指定的对象（对象类型在我们实例化的时候传入）：
from collections import defaultdict
dd = defaultdict(list)
# key不存在时，默认设置成一个list对象
print(dd["x"])
dd["x"].append(1)
print(dd["x"])
# []
# [1]
defaultdict初始化指定的类型必须是可调用的对象即可，例如：类、函数等，举例：
from collections import defaultdict
class A: pass
def people():
return {
"name": "aaa",
"age": 20
}
dd = defaultdict(people)
# 传入一个函数
print(dd["x"])
dd = defaultdict(A)
# 传入一个类
print(dd["x"])
# {'name': 'aaa', 'age': 20}
# <__main__.A object at 0x00000225A1A7F3C8>
实现原理
该类实现了__missing__魔法函数，当key不存在时就设置默认值
deque
双端队列，相比于list，提供了很多队头操作的方法，并且deque是线程安全的
Counter
对可迭代对象出现的次数进行统计：
from collections import Counter
a = ["a", "b", "a", "x", "a", "c", "b"]
c = Counter(a)
print(c)
print(c["a"])
# 查看a出现的次数
print(c.most_common(2))
# 取出数量最多的2个
# Counter({'a': 3, 'b': 2, 'x': 1, 'c': 1})
# 3
# [('a', 3), ('b', 2)]
该类继承自dict，因此可以用dict的相关方法
其他方法
most_common(n)
统计次数最多的前n个
elements
返回一个迭代器，里面是所有的内容
subtract
删掉几个元素，举例：
from collections import Counter
a = ["a", "b", "a", "x", "a", "c", "b"]
c = Counter(a)
print(c)
c.subtract(["a", "b"])
# 删掉一个a和一个b
print(c)
# Counter({'a': 3, 'b': 2, 'x': 1, 'c': 1})
# Counter({'a': 2, 'b': 1, 'x': 1, 'c': 1})
OrderDict
有序字典，但在python3.6以后普通的字典都是有序的了，不过该类还提供了一些dict没有的方法
提供方法
popitem
直接把最后一项弹出，举例：
from collections import OrderedDict
od = OrderedDict(a=1, b=2, c=3)
print(od)
print(od.popitem())
print(od)
# OrderedDict([('a', 1), ('b', 2), ('c', 3)])
# ('c', 3)
# OrderedDict([('a', 1), ('b', 2)])
该方法和pop不同，pop需要传入key，但该方法不需要，因为其内部维护了一个链表来记录顺序，然后将popitem时，直接把链表中最后一个弹出
remove_to_end
移动某个key到最后一个，举例：
from collections import OrderedDict
od = OrderedDict(a=1, b=2, c=3)
print(od)
od.move_to_end("a")
print(od)
# OrderedDict([('a', 1), ('b', 2), ('c', 3)])
# OrderedDict([('b', 2), ('c', 3), ('a', 1)])
原理
本质是内部维护了一个链表来记录顺序
chainmap
可以将多个可迭代对象合并到一起：
from collections import ChainMap
d1 = {"a":1, "b":2}
d2 = {"b":1, "c":2}
cm = ChainMap(d1, d2)
print(cm)
for d in cm:
print(d, cm[d])
# ChainMap({'a': 1, 'b': 2}, {'b': 1, 'c': 2})
# c 2
# b 2
# a 1
可以看到如果有重名的，那么第一个会正常返回，而第二个就会被跳过，并且传入的对象只要是可迭代的即可，多个之间可以不是同一类型，举例：
from collections import ChainMap
d1 = [1,2,3]
d2 = {"a":1}
cm = ChainMap(d1, d2)
print(cm)
for d in cm:
print(d)
# ChainMap([1, 2, 3], {'a': 1})
# 1
# 2
# 3
# a
原理
内部实际上就是将所有迭代器使用一个list包起来进行管理，源码如下：
def __init__(self, *maps):
self.maps = list(maps) or [{}] # always at least one map
因此我们也可以通过直接通过这个maps属性来进行操作，举例：
from collections import ChainMap
d1 = [1,2,3]
d2 = [1,4,5]
cm = ChainMap(d1, d2)
print(cm)
cm.maps[1][0] = 0
print(cm)
# ChainMap([1, 2, 3], [1, 4, 5])
# ChainMap([1, 2, 3], [0, 4, 5])