Python高级知识点学习（六）

Python中的迭代协议

迭代协议有两个概念：

1. 可迭代类型（Iterable）
2. 迭代器（Iterator）

迭代器：迭代器是访问集合内元素的一种方式， 一般用来遍历数据。

迭代器和以下标的访问方式不一样， 迭代器是不能返回的, 迭代器提供了一种惰性方式数据的方式。

可迭代对象（Iterable） 和 迭代器（Iterator） 是不同的。

可迭代对象：

• 实现__iter__这个魔法函数

迭代器：

• 实现__next__这个魔法函数
• 实现__iter__这个魔法函数

from collections.abc import Iterable, Iterator a = [1, 2] print(isinstance(a, Iterable)) print(isinstance(a, Iterator)) 打印结果： True False 

上边代码，因为a是一个list，而list是一个可迭代对象并不是迭代器，因为list对象中没有__next__方法。

生成器

生成器函数：函数里只要有yield关键字，它就是生成器对象。
生成器对象在python编译字节码的时候就产生了。
生成器对象也是实现了迭代器协议的，所以可以使用for循环遍历到它的值。

def gen_func(): yield 1 gen = gen_func() for value in gen: print(value) 打印结果： 1 

Python 中的GIL

GIL：global interpreter lock （cpython）
GIL：全局解释器锁。

python中一个线程对应于c语言中的一个线程。

GIL使得同一个时刻只有一个线程在一个cpu上执行字节码, 也就意味着无法将多个线程映射到多个cpu上执行。

GIL锁分配给某一线程后，并不是说这个线程执行完了之后它才会释放把它交给另外一个线程，它不是整个过程完全占有，它实际上是会在适当的时刻释放的，是结合了字节码执行的行数比如他执行了1000行字节码之后，它会释放，然后另外一个线程就可以得到运行。

GIL释放：

1. 会根据执行的字节码行数以及时间片释放gil。
2. gil在遇到io的操作时候主动释放。

total = 0 def add(): global total for i in range(1000000): total += 1 def desc(): global total for i in range(1000000): total -= 1 thread1 = threading.Thread(target=add) thread2 = threading.Thread(target=desc) thread1.start() thread2.start() thread1.join() thread2.join() print(total) 

上边代码两个线程分别执行两个函数，两个函数对同一变量做加减操作，本来应该先加到1000000再减1000000最终打印出0，但事实上是不会打印0的。

多线程编程

IO密集型时，适合多线程。
CPU密集型时，适合多进程。

多线程编程是我们几乎所有编程语言中都会遇到的问题。

操作系统能够切换和调度的最小单元是线程。

在最开始的时候，操作系统能够调度的最小单元是进程，但是由于进程对系统资源消耗非常大，所以后期就演变出了线程。

第一种方式：通过Thread类实例化

def get_detail_html(url): print("get detail html started") time.sleep(2) print("get detail html end") def get_detail_url(url): print("get detail url started") time.sleep(4) print("get detail url end") if __name__ == "__main__": thread1 = threading.Thread(target=get_detail_html, args=("",)) thread2 = threading.Thread(target=get_detail_url, args=("",)) # 设置为守护线程，随着主线程退出，子线程也退出 #thread1.setDaemon(True) #thread2.setDaemon(True) start_time = time.time() thread1.start() thread2.start() # 等待线程1，2执行完成 再执行完主线程； thread1.join() thread2.join() print(time.time() - start_time) 

上边代码中，两个线程分别执行两个函数，主线程下有两个子线程。

thread1.setDaemon(True)这个操作是把thread1设置为守护线程，随着主线程退出，thread1也退出。
thread1.join()这个操作是把主线程等待thread1执行完再执行完主线程。

第二种方式：通过重载Thread来实现多线程

def get_detail_html(url): print("get detail html started") time.sleep(2) print("get detail html end") def get_detail_url(url): print("get detail url started") time.sleep(4) print("get detail url end") class GetDetailHtml(threading.Thread): def __init__(self, name): super().__init__(name=name) def run(self): print("get detail html started") time.sleep(2) print("get detail html end") class GetDetailUrl(threading.Thread): def __init__(self, name): super().__init__(name=name) def run(self): print("get detail url started") time.sleep(4) print("get detail url end") if __name__ == "__main__": thread1 = GetDetailHtml("get_detail_html") thread2 = GetDetailUrl("get_detail_url") start_time = time.time() thread1.start() thread2.start() thread1.join() thread2.join() print("last time: {}".format(time.time()-start_time)) 

上边代码继承threading.Thread必须重载run方法。

线程同步Lock、RLock

为什么要线程同步？
现有两个函数，分别是对全局变脸a进行加减操作，两个函数使用两个线程来运行，一个线程负责把a加一，另一个负责把a减一，上代码：

a = 0 def add(a): a += 1 def desc(a): a-=1 

首先使用内置方法dis()看一下两个函数字节码是什么样子的：

import dis def add(a): a += 1 def desc(a): a-=1 print(dis.dis(add)) print(dis.dis(desc)) 打印结果： 63 0 LOAD_FAST 0 (a) 2 LOAD_CONST 1 (1) 4 INPLACE_ADD 6 STORE_FAST 0 (a) 8 LOAD_CONST 0 (None) 10 RETURN_VALUE None 66 0 LOAD_FAST 0 (a) 2 LOAD_CONST 1 (1) 4 INPLACE_SUBTRACT 6 STORE_FAST 0 (a) 8 LOAD_CONST 0 (None) 10 RETURN_VALUE None 

上边代码打印结果：

看下add的里边字节码：

1. LOAD_FAST：首先把 a LOAD 到内存中
2. LOAD_CONST ：再把1 LOAD 到内存中
3. INPLACE_ADD：执行加的操作
4. STORE_FAST：将加完的值赋值给 a

desc里边也是一样的，分四步，不同的是desc里执行的是减法。

如果同时执行add字节码和desc字节码时，之前笔记中提过，执行以上四个步骤时随时都可能释放gil锁，因为字节码的数量已经满了，以上四步任何一步骤都可能释放gil锁切换到另外一个线程，所以有可能造成一个结果，就是a要么等于1，要么等于-1，但是我们期望的是a 等于0，这时候就需要线程同步来解决问题。

我们希望在执行add函数的代码段时，另一个线程中的desc代码段是停止的，这就是线程同步机制。

python给我们提供了一个机制，叫做锁：
from threading import Lock
在运行一个代码段时，加一把锁，等运行完了，再释放锁。

from threading import Lock total = 0 # 声明一把锁 lock = RLock() def add(): global lock global total for i in range(1000000): # 获得锁 lock.acquire() total += 1 # 释放锁 lock.release() def desc(): global total global lock for i in range(1000000): lock.acquire() total -= 1 lock.release() import threading thread1 = threading.Thread(target=add) thread2 = threading.Thread(target=desc) thread1.start() thread2.start() thread1.join() thread2.join() print(total) 打印结果： 0 

上边代码不管累加多少次最终结果都是0。
如果没有释放锁，会导致死锁。

使用锁会影响性能。

RLock：
在同一个线程里面，可以连续调用多次acquire， 一定要注意acquire的次数要和release的次数相等。

在同一个线程中，可以使用RLock。