python数据结构（一）

collections --容器数据类型，collections模块包含了除内置类型list，dict和tuple以外的其他容器数据类型。

Counter 作为一个容器可以追踪相同的值增加了多少次

#初始化
print(collections.Counter('qweqwe'))
print(collections.Counter(['q','w','e','q','w','e']))
print(collections.Counter(q=2,w=2,e=2,))
print(collections.Counter({'q':2,'w':2,'e':2}))

结果：
Counter({'q': 2, 'e': 2, 'w': 2})
Counter({'q': 2, 'e': 2, 'w': 2})
Counter({'q': 2, 'e': 2, 'w': 2})
Counter({'q': 2, 'e': 2, 'w': 2})

#构造空的Counter，使用update()填充
c = collections.Counter()
print(c)
c.update('qweqwe')
print(c)
c.update(['q','e','w','w'])
c.update({'q':2,'e':2})#计数值会增加，替换数据不会改变计数
c.update('qqew')
print(c)

结果：
Counter()
Counter({'w': 2, 'e': 2, 'q': 2})
Counter({'q': 7, 'e': 6, 'w': 5})

# 访问计数，一旦填充了Counter，可以使用 字典api获取他的值
b = collections.Counter('qwedwewqsa')
for letter in 'qwedz':
    print('%s:%d'%(letter,b[letter]),end=',')

b['x']=0
print(b)
print(list(b.elements()))#elements()返回一个迭代器，将生成Counter中的所有元素，但是不包括计数小于或者等于0的元素

string1 = '这是一段测试文文文字，这用来测试数据数数数结构常常判断数据是否可以正常使用，常用的正常的测试文章结果结构构造'
s = collections.Counter(string1)
for letter,count in s.most_common(3): #most_common()生成一个序列，其中包含n个最常遇到的输入值和相应的计数
    print('%s:%d'%(letter,count),end='|')

结果：
q:2,w:3,e:2,d:1,z:0,Counter({'w': 3, 'q': 2, 'e': 2, 's': 1, 'a': 1, 'd': 1, 'x': 0})
['q', 'q', 's', 'e', 'e', 'w', 'w', 'w', 'a', 'd']
数:5|常:5|文:4|

#算术操作
c1 = collections.Counter('qqqwwweeedx')
c2 = collections.Counter(['q','q','w','w','e','e','d','v'])
print(c1-c2)#每次通过一次操作生成新的Counter时候，计数为0或者负数会被删除
print(c1+c2)
print(c1&c2)
print(c1|c2)

结果：
Counter({'x': 1, 'w': 1, 'e': 1, 'q': 1})
Counter({'e': 5, 'w': 5, 'q': 5, 'd': 2, 'x': 1, 'v': 1})
Counter({'w': 2, 'e': 2, 'q': 2, 'd': 1})
Counter({'e': 3, 'w': 3, 'q': 3, 'x': 1, 'd': 1, 'v': 1})

 defaultdict 初始化容器时候会先让调用者提前指定默认值

def default_factory():
    return 'default value'

d = collections.defaultdict(default_factory,foo='bar')
print(d)
print(d['foo'],d['bar'],d['par'])

结果：
defaultdict(<function default_factory at 0x00000233EF0B7F28>, {'foo': 'bar'})
bar default value default value

deque（双端队列），支持从任意一端增加和删除元素，更为常见的两种结构，栈与队列，就是双端队列的退化形式，其输入和输出限制在一端

d = collections.deque('asdzxc')
print(d,len(d),('left end:',d[0]),('right end',d[-1]))
d.remove('d')
print('remove(d):',d)#deque属于序列容器，支持list的一些操作

结果：
deque(['a', 's', 'd', 'z', 'x', 'c']) 6 ('left end:', 'a') ('right end', 'c')
remove(d): deque(['a', 's', 'z', 'x', 'c'])

# 填充
d1 = collections.deque()
d1.extend('abcdefg')#迭代处理其输入
print('extend:',d1)
d1.append('hijk')
print('append',d1)
d1.extendleft('lmn')
print('extendleft:',d1)
d1.appendleft('opq')
print('appendleft',d1)

结果：
extend: deque(['a', 'b', 'c', 'd', 'e', 'f', 'g'])
append deque(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'hijk'])
extendleft: deque(['n', 'm', 'l', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'hijk'])
appendleft deque(['opq', 'n', 'm', 'l', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'hijk'])

#使用，可以从任意一端取deque的元素
print('from right')
d = collections.deque('abcdefg')
while True:
    try:
        print(d.pop(),end=',')
    except IndexError:
        break
print()
print('from left')
n = collections.deque(range(6))
while True:
    try:
        print(n.popleft(),end=',')
    except IndexError:
        break

结果：
from right
g,f,e,d,c,b,a,
from left
0,1,2,3,4,5,

#使用不同线程同时从两端利用双端队列的内容
import threading
import time
candle  = collections.deque(range(5))
def burn(direction,nextSource):
    while True:
        try:
            next=nextSource()
        except IndexError:
            break
        else:
            print('%8s:%s'%(direction,next))
            time.sleep(1)

    print('%8s done'%direction)
    return

left = threading.Thread(target=burn,args=('left',candle.popleft))
right = threading.Thread(target=burn,args=('right',candle.pop))

left.start()
right.start()

left.join()
right.join()

结果：
    left:0
   right:4
   right:3
    left:1
    left:2
   right done
    left done

#旋转，按照任意一个方向旋转，跳过一些元素
d = collections.deque(range(10))
print(d)
d.rotate(2)#使用正值，会从右端取数据移动到左端
print(d)
d.rotate(-4)#使用负值，会从左端取数据移动到右端
print(d)

结果：
deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
deque([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
deque([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])

 OrderedDict是一个字典的子类，可以记住其内容增加的顺序，是有序的

d = collections.OrderedDict()
d['a'] = 1
d['b'] = 2
d['c'] = 3

for k,v in d.items():
    print(k,v)

d1 = collections.OrderedDict()
d1['a'] = 1
d1['b'] = 2
d1['c'] = 3

d2 = collections.OrderedDict()
d2['b'] = 2
d2['a'] = 1
d2['c'] = 3

print(d1==d2)

结果： 

a 1
b 2
c 3
False