Python高级知识点学习(六)

  1. 云栖社区>
  2. 博客>
  3. 正文

Python高级知识点学习(六)

yi杯咖啡 2018-10-25 18:07:00 浏览383
img_44f49925bfa26e0ecddd852e95158e3a.png
围棋少年

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。