Python数据结构（二）

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‘740068006900730020006900730020006100200041005200520041005900‘ array(‘i‘, [1, 2, 3, 4]) b‘01000000020000000300000004000000‘

# 处理数组，类似其他的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)]

#创建堆
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,

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]

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]

#基本的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