python常用模块——collections

1.collections在python的基本的数据类型之外给我们提供了额外的五种数据类型，以便我们更加方便的解决一些问题，它们分别是namedtuple、deque、counter、OrderDict、defaulrdict。

 

2.namedtuple：命名元祖，是一个工厂函数。

主要用来产生可以使用名称来访问元素的数据对象。

通常用来增强代码的可读性，在访问一些tuple类型的数据时尤其好用。

>>> P = namedtuple('Point',['x','y','z'])
>>> p = P(1,2,3)
>>> p.x
1
>>> p.y
2
>>> p.z
3

#通过属性来访问数据，有时候会达到意向不到的效果。
>>> one_people = namedtuple('info',('name','sex','age','job'))
>>> kebi =one_people('kebi','男',25,'staff')
>>> kebi.sex
'男'
>>> kebi.age
25
>>> kebi.job
'staff'

 

3.deque：双端队列

支持从两端高效的插入数据、支持随机访问的容器。

双端队列支持的操作：

append()	在尾部添加一个元素
appendleft()	在头部添加一个元素
pop()	从尾部删除一个元素，并返回删除的值
popleft()	从头部删除一个元素，并返回删除的值
extend()	从尾部扩展，被扩展的对象是可迭代对象
extendleft()	从头部扩展，被扩展的对象是可迭代对象
remove()	删除一个值
clear()	清空队列
rotate()	偏移，+向右偏，—向左偏
count()	统计某个值出现的次数
reverse()	反转

 

 

 

 

 

 

 

 

 

 

 

由上面的方法我们就可以看出，双端队列与列表非常类似，但是比列表的功能更加强大。

>>> q = deque(range(5))  #创建了一个双端队列
>>> q
deque([0, 1, 2, 3, 4])
>>> q.append(5)      #从尾部添加
>>> q
deque([0, 1, 2, 3, 4, 5])
>>> q.appendleft(6)   #从头部添加
>>> q
deque([6, 0, 1, 2, 3, 4, 5])
>>> q.pop()   #删除最后面哪一个，并返回删除的那个元素
5
>>> q.popleft()  #删除最前面那个，返回删除的那个元素
6
>>> q
deque([0, 1, 2, 3, 4])
>>> q.rotate(1)    #向右偏移
>>> q
deque([4, 0, 1, 2, 3])
>>> q.rotate(-2)  #向左偏移
>>> q
deque([1, 2, 3, 4, 0])

>>> q.extend((-1,-2))   #扩展一个元祖
>>> q
deque([1, 2, 3, 4, 0, -1, -2])
>>> q.extend(('wo'))   #扩展一个字符串
>>> a
'1-2*-12023'
>>> q
deque([1, 2, 3, 4, 0, -1, -2, 'w', 'o'])
>>> q.extendleft(range(10,13))
>>> q
deque([12, 11, 10, 1, 2, 3, 4, 0, -1, -2, 'w', 'o'])

 

4.OrdereDict：排序的字典，是字典的子类

在前期的数据类型中，学习过dict，其中的键是无序的，OrderedDict是对dict的补充。

为了说明OrderedDict和dict的区别，只用证明OrderedDict是由顺序的就行。

在python2中字典是无序的可以直接测试出，在python3中貌似有部分联系。

#在2中
>>> d = {'c':3,'a':1,'b':2}
>>> for i in d:
...     print i,d[i]
...
a 1     #没有顺序一目了然
c 3
b 2

在3中
>>> d = {'c':3,'a':1,'b':2}
>>> for i in d:
...     print(i,d[i])
...
c 3
a 1
b 2   #貌似有点联系

下面的方法无论在2中还是在3中都可以检测出，dict是无序的，而OrderedDict是有顺序的。

#以不同的顺序把数据写到一张表里面。
>>> d = {'a':1,'b':2,'c':3}
>>> d2 = {'c':3,'a':1,'b':2}
>>> bool(d ==d2)
True
#不管顺序如何，表是一样

>>> D = OrderedDict()
>>> D2 = OrderedDict()
>>> D['a'] = 1
>>> D['b'] = 2
>>> D['c'] = 3
>>> D2['c'] = 3
>>> D2['a'] = 1
>>> D2['b'] = 2
>>> bool(D==D2)
False
#两张表不同，证明其对顺序有要求

 5.defaultdict：

defaultdict使用工厂函数创建字典，使用的时候可以不用考虑缺失的key。

python原生的dict结构，如果使用d[key]的方式访问，需要先判断key是否存在，如果不存在就会返回一个KeyError异常。

defaultdict就是为了解决这个痛点而生，只要传入一个默认的工厂方法，访问不存在的键值时，就会返回初始设置的默认值。

>>> d
{'a': 1, 'b': 2, 'c': 3}
>>> d['e']
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'e'   #不存在就会报错

>>> d3 = defaultdict(lambda:"N/A")
>>> d3['a'] = 1
>>> d3['b'] = 2
>>> d3['c'] = 3
>>> d3['e']    #访问不存在的键，会返回默认值。
'N/A'

>>> d4 = defaultdict(list)  #工厂函数作为默认值
>>> d4['c'] = 3
>>> d4['a'] = 1
>>> d4['b']
[]

 

6.Counter：计数

Counter类的目的时用来跟踪值出现的次数。它是一个无序的容器类型，以字典键值对形式存储存。

>>> b = Counter("aabbccdd")
>>> b
Counter({'a': 2, 'b': 2, 'c': 2, 'd': 2})   #跟踪计数，形成一个新的容器。
>>> b['a']
2
>>> b['e']  #访问不存在的计数返回0
0

关于Counter的方法非常多

update()	扩展，加上另一个对象
subtract()	从中减去另一个对象
elements()	返回一个迭代器，包含真实存在的元素
most_common()	返回一个字典，元素由元素由单个字符和计数组成
list()	转化成列表
set()	转化成集合
dict()	转化成字典
sum()	求和
clear()	清空

 

 

 

 

 

 

 

 

 

 

#增
>>> b
Counter({'a': 2, 'b': 2, 'c': 2, 'd': 2})
>>> b.update('ddeeffwwww')
>>> b
Counter({'d': 4, 'w': 4, 'a': 2, 'b': 2, 'c': 2, 'e': 2, 'f': 2})


#减
>>> b.subtract('ddeeffwwww')
>>> b
Counter({'a': 2, 'b': 2, 'c': 2, 'd': 2, 'e': 0, 'f': 0, 'w': 0})


#删
>>> del b['e']
>>> b
Counter({'a': 2, 'b': 2, 'c': 2, 'd': 2, 'f': 0, 'w': 0})


#改
>>> b['a'] = 1
>>> b
Counter({'b': 2, 'c': 2, 'd': 2, 'a': 1, 'f': 0, 'w': 0})


#返回一个迭代器，返回真实存在的元素
>>> c = Counter(a=3,b=2,c=1,d=0)
>>> c
Counter({'a': 3, 'b': 2, 'c': 1, 'd': 0})
>>> list(c.elements())
['a', 'a', 'a', 'b', 'b', 'c']


#返回一个列表，元素和个数组成一个列表的元素
>>> g = Counter('aaddccc')
>>> c.most_common()
[('a', 3), ('b', 2), ('c', 1), ('d', 0)]
>>> c.most_common(2)  #可以指定显示的元素的个数
[('a', 3), ('b', 2)]

Counter还支持一些算数操作符

>>> opr1 =Counter(a=4,b=2)
>>> opr2 =Counter(a=2,b=3)
>>> opr1 + opr2
Counter({'a': 6, 'b': 5})   #各元素相加的和
>>> opr1 - opr2      #各元素相减的余，只取正值
Counter({'a': 2})      #取双方都有的交集
>>> opr1 & opr2
Counter({'a': 2, 'b': 2})
>>> opr1 | opr2       #取并集
Counter({'a': 4, 'b': 3})

 

转载于:https://www.cnblogs.com/yangmingxianshen/p/7834764.html