Python数据结构（二）

array固定类型的数据序列，与list类似，只不过成员必须是相同的基本类型

array.typecodes #包含所有可用类型代码的字符串bBuhHiIlLqQfd

输入代码	C型	Python类型	最小字节数	笔记
'b'	签名字符	INT	1
'B'	无符号字符	INT	1
'u'	Py_UNICODE	Unicode字符	2	（1）
'h'	签署简称	INT	2
'H'	无符号短	INT	2
'i'	签名int	INT	2
'I'	无符号整数	INT	2
'l'	长签字	INT	4
'L'	无符号长整数	INT	4
'q'	签了很久	INT	8	（2）
'Q'	无符号long long	INT	8	（2）
'f'	浮动	浮动	4
'd'	双	浮动	8

import array
import binascii
s = 'this is a ARRAY'
w = [1,2,3,4]
a = array.array('u',s)#实例化时候需要传递一个参数
b = array.array('i',w)
print(a,binascii.hexlify(a),b,binascii.hexlify(b))

结果：
array('u', 'this is a ARRAY') b'' array('i', [1, 2, 3, 4]) b''

# 处理数组，类似其他的Python序列，可以采取同样方式扩展和处理array
a = array.array('i',range(3))
print(a)
a.extend(range(3))
print(a,a[3:5],list(enumerate(a)))

结果:
array('i', [0, 1, 2])
array('i', [0, 1, 2, 0, 1, 2]) array('i', [0, 1]) [(0, 0), (1, 1), (2, 2), (3, 0), (4, 1), (5, 2)]

heapq堆排序算法，堆（heap）是一种树形数据结构，其中子节点与父节点是一种有序关系。

#创建堆
import heapq
heap1 = []
for i in [19,9,4,10,11]:#元素逐个插入，形成堆结构
    heapq.heappush(heap1,i)
print(heap1)
heap2 = [19,9,4,10,11] #目标已存在，直接转化堆结构
heapq.heapify(heap2)
print(heap2)

for i in [0,13]:
    heapq.heapreplace(heap2,i) #维持固定大小的堆，每次插入一个元素同时删除一个最小的元素
print(heap2)

#heappop()删除最小值元素
for i in range(len(heap1)):
    print(heapq.heappop(heap1),end=',')
print()

结果:
[4, 10, 9, 19, 11]
[4, 9, 19, 10, 11]
[9, 10, 19, 13, 11]
4,9,10,11,19,

bisect数组二等分算法，该模块支持按排序顺序维护列表，而无需在每次插入后对列表进行排序。对于昂贵的比较操作的长项目列表，这可能是比较常见的方法的改进。该模块被称为bisect是因为它使用基本的二分算法来完成其工作，

import bisect
import random
random.seek(1)
l = []
for i in range(1,10):
    r = random.randint(1,100)
    position =bisect.bisect(l,r)
    bisect.insort(l,r)
    print('%3d%3d'%(r,position),l)

结果： 

　　18 0 [18]
　　73 1 [18, 73]
　　98 2 [18, 73, 98]
　　 9 0 [9, 18, 73, 98]
　　33 2 [9, 18, 33, 73, 98]
　　16 1 [9, 16, 18, 33, 73, 98]
　　64 4 [9, 16, 18, 33, 64, 73, 98]
　　98 7 [9, 16, 18, 33, 64, 73, 98, 98]
　　58 4 [9, 16, 18, 33, 58, 64, 73, 98, 98]

处理重复：

bisect.bisect_left（a，x，lo = 0，hi = len（a））

bisect.bisect_right（a，x，lo = 0，hi = len（a））

bisect.insort_left（a，x，lo = 0，hi = len（a））

bisect.insort_right（a，x，lo = 0，hi = len（a））

import bisect
import random
random.seed(1)
l = []
for i in range(1,10):
    r = random.randint(1,100)
    position =bisect.bisect_left(l,r)
    bisect.insort(l,r)
    print('%3d%3d'%(r,position),l)
结果：
 18  0 [18]
 73  1 [18, 73]
 98  2 [18, 73, 98]
  9  0 [9, 18, 73, 98]
 33  2 [9, 18, 33, 73, 98]
 16  1 [9, 16, 18, 33, 73, 98]
 64  4 [9, 16, 18, 33, 64, 73, 98]
 98  6 [9, 16, 18, 33, 64, 73, 98, 98]#相同值放在了左边
 58  4 [9, 16, 18, 33, 58, 64, 73, 98, 98]

Queue 模块提供一个适用与多线程编程先进先出FIFO数据结构，可以用来在生产者和消费者线程之间安全的传递消息或者数据，为调用者处理锁定，使多个线程可以安全的处理同一个Queue实例

#基本的FIFO
import queue
q = queue.Queue()
for i in range(5):
    q.put(i) #元素添加
while not q.empty():
    print(q.get())#元素删除

结果
0
1
2
3
4

#LIFO队列，LifoQueue使用了后进先出（LIFO）顺序，通常与栈结构关联
import queue
q=queue.LifoQueue()
for i in range(5):
    q.put(i) #元素添加
while not q.empty():
    print(q.get())#元素删除
结果：
4
3
2
1
0

#优先队列，PriorityQueue使用队列内容的有序顺序来决定获取哪个元素

import queue
import threading

class Job():
    def __init__(self,priority,description):
        self.priority = priority
        self.description = description
        print('new job',description)

    def __lt__(self, other):
        return self.priority < other.priority

q = queue.PriorityQueue()

q.put(Job(3,'mid-level job'))
q.put(Job(10,'low-level job'))
q.put(Job(1,'important-level job'))

def process_job(q):
    while True:
        next_job = q.get()
        print('Processing job:',next_job.description)
        q.task_done() #用task_done()以指示该项目已被检索并且所有工作都已完成，计数就会减少

workers = [threading.Thread(target=process_job,args=(q,)),
           threading.Thread(target=process_job,args=(q,)),
           ]

for w in workers:
    print(w.getName())
    w.setDaemon(True)
    w.start()

q.join()#阻塞，直到队列中的所有项目都被获取并处理

结果：
new job mid-level job
new job low-level job
new job important-level job
Thread-1
Processing job: important-level job
Thread-2
Processing job: mid-level job
Processing job: low-level job

struct 二进制数据结构，将字节解释为二进制数据，在字符串和二进制数据之间进行转换

weakref 对象的非永久引用