Python中的迭代协议
迭代协议有两个概念：
- 可迭代类型（Iterable）
- 迭代器（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释放：
- 会根据执行的字节码行数以及时间片释放gil。
- 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的里边字节码：
- LOAD_FAST：首先把 a LOAD 到内存中
- LOAD_CONST ：再把1 LOAD 到内存中
- INPLACE_ADD：执行加的操作
- 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。
