一、计数器（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