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'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)]
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 对象的非永久引用