一、计数器（counter）

    计数器（counter）以字典的形式返回序列中各个字符出现的次数，值为key，次数为value

1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/env python
#-*- coding:utf-8 -*-
 
#导入collections模块
import collections
 
counter_test = collections.Counter("asfafjhadgkhjkgfjhgfjhaghdg")
print(counter_test)
 
#返回值
C:\Python27\python27.exe D:/cto3/day6/coun_1.py
Counter({'g': 5, 'h': 5, 'a': 4, 'f': 4, 'j': 4, 'd': 2, 'k': 2, 's': 1})


  1、计数器的方法（字典方法略）

     counter是dict的子类，所有它拥有字典的所有方法，还有一些自己的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#取前3位的返回值
ret1 = counter_test.most_common(3)
print(ret1)
##########
result:[('g', 5), ('h', 5), ('a', 4)]
 
#循环取计数器中的值
for k,v in counter_test.items():
    print(k,v)
##########
result:
('a', 4)
('d', 2)
('g', 5)
('f', 4)
('h', 5)
('k', 2)
('j', 4)
('s', 1)
 
#update方法，subtract方法，更新与移除
obj = collections.Counter([11,22,33,22,])
print(obj)
obj.update([11,22,44])
print(obj)
obj.subtract([11,22,44])
print(obj)
##########
result:
Counter({22: 2, 33: 1, 11: 1})
Counter({22: 3, 11: 2, 33: 1, 44: 1})
Counter({22: 2, 33: 1, 11: 1, 44: 0})

 二、有序字典（orderedDict）

   有序字典（orderedDict）是字典的子类，在字典的基础上记录了元素添加的顺序

1
2
3
4
5
6
7
8
9
10
11
12
#导入collections模块
import collections
 
dic = collections.OrderedDict()
dic['k1'] = 'v1'
dic['k2'] = 'v2'
dic['k3'] = 'v3'
print(dic)
 
##########
result:
OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])

 1、有序字典的方法（字典的方法略）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#python3中新加入的方法，移动字典中的顺序
dic.move_to_end('k1')
print(dic)
##########
result:
OrderedDict([('k2', 'v2'), ('k3', 'v3'), ('k1', 'v1')])
 
#按照顺序，后进先出弹出元素（有返回值）
dic.popitem()
print(dic)
##########
result:
OrderedDict([('k1', 'v1'), ('k2', 'v2')])
 
#指定弹出的元素（有返回值）
dic.pop('k2')
print(dic)
##########
result:
OrderedDict([('k1', 'v1'), ('k3', 'v3')])
 
#更新，update方法
dic.update({'k1':'new1','k4':'v4'})
print(dic)
##########
result:
OrderedDict([('k1', 'new1'), ('k2', 'v2'), ('k3', 'v3'), ('k4', 'v4')])

三、默认字典（defaultdict）

    默认字典与字典的区别是可设置其元素的类型

1
2
3
4
5
6
7
8
9
#导入collections模块
import collections
 
my_dict = collections.defaultdict(list)
my_dict['k1'].append('v1')
print(my_dict)
##########
result:
defaultdict(<class 'list'>, {'k1': ['v1']})

 示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# 练习：元素分类
# 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，
# 将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
# 即： {'k1': 大于66 , 'k2': 小于66}
 
1、不用默认指点的写法要判断字典中是否已有{'k1':[]}
all_list = [11,22,33,44,55,66,77,88,99,90,]
dic = {}
for i in all_list:
    if i > 66:
        if "k1" in dic.keys():
            dic['k1'].append(i)
        else:
            dic['k1'] = [i,]
    else:
        if "k2" in dic.keys():
            dic['k2'].append(i)
        else:
            dic['k2'] = [i,]
 
print(dic)
 
2、默认字典
all_list = [11,22,33,44,55,66,77,88,99,90,]
dic = collections.defaultdict(list)
for i in all_list:
    if i > 66:
        dic['k1'].append(i)
    else:
        dic['k2'].append(i)
print(dic)
 
##########
result:
defaultdict(<class 'list'>, {'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]})


四、可命名元祖（namedtuple）

  namedtuple与元组的区别是namedtuple创建了一个包含tuple和自己特定方法的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#导入collections模块
import collections
 
# 创建了一个可命名元组的类
MytupleClass = collections.namedtuple('MytupleClass',['x','y','z'])
 
# 创建对象,obj对象的x=11，y=22，z=33
obj = MytupleClass(11,22,33)
print(obj.x)
print(obj.y)
print(obj.z)
 
##########
result:
11
22
33


五、队列

1、双向队列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#导入collections模块
import collections
d = collections.deque('ghi')
 
常用方法：
#右加入
>>> d.append('j')
#左加入
>>> d.appendleft('f')
>>> d
deque(['f', 'g', 'h', 'i', 'j'])
 
#右移除(有返回值)
>>> d.pop()
'j'
#左移除（有返回值）
>>> d.popleft()
'f'
>>> d
deque(['g', 'h', 'i'])
 
#队列可转换为列表
>>> list(d)
['g', 'h', 'i']
 
#右扩展
>>> d.extend('jkl')
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
#左扩展(倒序加入队列)
>>> d.extendleft('abc')
>>> d
deque(['c', 'b', 'a', 'g', 'h', 'i', 'j', 'k', 'l'])
 
#右轮换
>>> d.rotate(1)
>>> d
deque(['l', 'g', 'h', 'i', 'j', 'k'])
#左轮换
>>> d.rotate(-1)
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
 
#统计队列中元素出现的次数
>>> d.extend('ghijk')
>>> d
deque(['g', 'h', 'i', 'g', 'h', 'i', 'j', 'k'])
>>> d.count('g')
2
 
#清除
>>> d.clear()

 2、单向队列（先进先出）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import queue
#创建单向队列
q = queue.Queue()
 
#插入第一条数据
q.put('123')
#插入第二条数据
q.put('456')
#查看队列中有几条数据
print(q.qsize())
#顺序取出第一条数据
print(q.get())
##########
result:
2
123