python基础Ⅴ（正则表达式、进程、线程、协程、GIL）

ゝ一世哀愁。 2022-12-24 15:52 119阅读 0赞

# 一、写在前面 #

## 关于转义的问题 ##

**正则表达式**中用 **“\\”表示转义**，而**python**中也用 **“\\”表示转义**，当遇到特殊字符需要转义时，你要花费心思到底需要几个“\\”，所以为了避免这个情况，**推荐使用原生字符串类型(raw string)来书写正则表达式**。方法很简单，只需要**在表达式前面加个“r”即可**

## 关于贪婪 ##

**贪婪匹配**：**匹配尽可能多的字符**；  
**非贪婪匹配**：**匹配尽可能少的字符**。  
**python的正则匹配默认是贪婪匹配**  
例如：

import re
    print(re.match(r'^(\w+)(\d*)$', 'abc123').groups())
    print(re.match(r'^(\w+?)(\d*)$', 'abc123').groups())
    # 输出结果
    ('abc123', '')
    ('abc', '123')
    
    表达式1：
    \w+表示匹配字母或数字或下划线或汉字并重复1次或更多次;\d*表示匹配数字并重复0次或更多次。
    分组1中(\w)是贪婪匹配,它会在满足分组2(\d*)的情况下匹配尽可能多的字符(有点拗口)，
    因为分组2(\d*)匹配0个数字也满足，所以分组1就把所有字符全部匹配掉了，分组2只能匹配空了。
    
    表达式2：在表达式后加个?即可进行非贪婪匹配,如上面的(\w+?),
    因为分组1进行非贪婪匹配，也就是满足分组2匹配的情况下，分组1尽可能少的匹配，
    这样的话，上面分组2(\d*)会把所有数字(123)都匹配，所以分组1匹配到(abc)

**不要在正则表达式里面胡乱出现空格**

# 二、正则表达式 #

## match方法 ##

**re.match** 从**字符串的起始位置开始匹配**，如果**起始位置匹配失败**，match()就**返回None**；如果**匹配成功**的话，match()就**返回一个匹配的对象**。类似于**自动加了^符号**

> re.match(pattern, string, flags=0)

*  **pattern** 匹配的正则表达式
 *  **string** 要匹配的字符串。
 *  **flags** 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等
 *  当匹配成功时，使用**group和groups方法**可**提取到被匹配的内容**
 *  当匹配成功时，使用**span方法**可获得**被匹配到的位置**

import re
    
    str1 = 'hello world! Hi, there.'
    res1 = re.match('there', str1)
    print(res1)
    res2 = re.match('hello', str1)
    print(res2.span())
    print(res2.group())
    res3 = re.match('e', str1)
    print(res3)
    # 输出结果
    None
    (0, 5)
    hello
    None

## search 方法 ##

扫描**整个字符串并返回第一个成功的匹配**，**匹配成功**re.search方法**返回一个匹配的对象**，**否则返回None。**

> re.search(pattern, string, flags=0)

*  **pattern** 匹配的正则表达式
 *  **string** 要匹配的字符串。
 *  **flags** 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
 *  当匹配成功时，使用**group和groups方法可提取到被匹配的内容**
 *  当匹配成功时，使用**span方法可获得被匹配到的位置**

import re
    
    str1 = 'hello world! Hi, there.'
    res1 = re.search('there', str1)
    print(res1.span())
    print(res1.group())
    res2 = re.search('hello', str1)
    print(res2.span())
    print(res2.group())
    res3 = re.search('e', str1)
    print(res3.span())
    print(res3.group())
    # 输出结果
    (17, 22)			# （被匹配到的位置，共匹配的长度）
    there
    (0, 5)
    hello
    (1, 2)
    e

## re.match与re.search的区别 ##

**re.match**只匹配**字符串的开始**，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而**re.search**匹配**整个字符**串，直到找到一个匹配。

## findall方法 ##

它是**search方法的加强版**，findall方法会找到**所有符合条件的结果**并返回一个**列表**，而**search方法**只返回**一个符合条件的结果**

> re.findall(pattern, string, flags=0)

*  **pattern** 匹配的正则表达式
 *  **string** 要匹配的字符串。
 *  **flags** 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
 *  注意**这里没有group、groups方法和span方法**

import re
    
    str1 = 'hello world! Hi, there.'
    res1 = re.findall('there', str1)
    print(res1)
    res2 = re.findall('hello', str1)
    print(res2)
    res3 = re.findall('e', str1)
    print(res3)
    # 输出结果
    ['there']
    ['hello']
    ['e', 'e', 'e']

## sub方法 ##

**re.sub**用于**替换字符串中的匹配项并返回一个新的字符串**，它比字符串的replace方法更灵活

> re.sub(pattern, repl, string, count=0, flags=0)

*  **pattern** : 正则中的模式字符串。
 *  **repl** : 替换的字符串，也可为一个函数。
 *  **string** : 要被查找替换的原始字符串。
 *  **count** : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
 *  **flags** 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

import re
    
    res = re.sub(r'\d+', '100', '数学：78，语文：56')
    print(res)
    # 输出结果
    数学：100，语文：100

## split方法 ##

**split 方法**按照能够**匹配的子串**将**字符串分割后返回列表**

> 这里是引用re.split(pattern, string\[, maxsplit=0, flags=0\])

*  **pattern** 匹配的正则表达式
 *  **string** 要匹配的字符串。
 *  **maxsplit** 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
 *  **flags** 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等

import re
    
    res = re.split(r'[:,]', '数学:78, 语文:56')
    print(res)
    # 输出结果
    ['数学', '78', '语文', '56']

## 特殊字符 ##

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>.</td> 
   <td>用于匹配除换行符（\n）之外的所有字符</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>用于匹配字符串的开始，即行首。</td> 
  </tr> 
  <tr> 
   <td>$</td> 
   <td>用于匹配字符串的末尾（末尾如果有换行符\n，就匹配\n前面的那个字符），即行尾。</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>用于将前面的模式匹配O次或多次 ，贪婪模式</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>用于将前面的模式匹配1次或多次，贪婪模式</td> 
  </tr> 
  <tr> 
   <td>?</td> 
   <td>用于将前面的模式匹配0次或1次，贪婪模式</td> 
  </tr> 
  <tr> 
   <td>*?、+?、??</td> 
   <td>上面的三种特殊字符的非贪婪模式</td> 
  </tr> 
  <tr> 
   <td>{}</td> 
   <td>用于将前面的模式重复匹配</td> 
  </tr> 
  <tr> 
   <td>{}?</td> 
   <td>上面的非贪婪模式</td> 
  </tr> 
  <tr> 
   <td>[]</td> 
   <td>在括号里面选择一个。如果^是第一个字符，则标示的是一个补集。比如[0-9]表示所有的数字，[^0-9]表示除了数字外的字符。</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>或。比如A I B用于匹配A或B。</td> 
  </tr> 
  <tr> 
   <td>()</td> 
   <td>分组，用于匹配括号中的模式，可以在字符串中检素或匹配我们所需要的内容。</td> 
  </tr> 
  <tr> 
   <td>\d</td> 
   <td>匹配任意一个数字，等价于[0-9]</td> 
  </tr> 
  <tr> 
   <td>\D</td> 
   <td>匹配任意一个非数字字符，等价于[^\d]</td> 
  </tr> 
  <tr> 
   <td>\s</td> 
   <td>匹配任意一个空白字符，等价于[\t\n\r\f]。</td> 
  </tr> 
  <tr> 
   <td>\S</td> 
   <td>匹配任意一个非空白字符，等价于[^\s].</td> 
  </tr> 
  <tr> 
   <td>\w</td> 
   <td>匹配任意一个字母数字及下划线，等价于[a-zA-Z0-9_].</td> 
  </tr> 
  <tr> 
   <td>\W</td> 
   <td>匹配任意一个非字母数字及下划线，等价于[^\w]</td> 
  </tr> 
 </tbody> 
</table>

## 正则表达式引用分组 ##

#### 使用数字 ####

使用**数字加正斜杠**来使用正则表达式的**引用分组**

import re
    
    str1 = '<html><h1>aaaaa</h1></html>'
    res1 = re.match(r'<([\w]+)>(.+?)</([\w]+)>', str1)		# 非贪婪模式
    print(res1)
    print(res1.group())
    print(res1.groups())
    res2 = re.match(r'<([\w]+)>(.+)</([\w]+)>', str1)		# 贪婪模式
    print(res2)
    print(res2.group())
    print(res2.groups())
    res3 = re.match(r'<([\w]+)>(.+?)</(\1)>', str1)			# 非贪婪模式 + 引用分组
    print(res3)
    print(res3.group())
    print(res3.groups())
    # 输出结果
    <re.Match object; span=(0, 20), match='<html><h1>aaaaa</h1>'>
    <html><h1>aaaaa</h1>
    ('html', '<h1>aaaaa', 'h1')
    <re.Match object; span=(0, 27), match='<html><h1>aaaaa</h1></html>'>
    <html><h1>aaaaa</h1></html>
    ('html', '<h1>aaaaa</h1>', 'html')
    <re.Match object; span=(0, 27), match='<html><h1>aaaaa</h1></html>'>
    <html><h1>aaaaa</h1></html>
    ('html', '<h1>aaaaa</h1>', 'html')

#### 使用起名的方式 ####

使用\*\*?P\*\*来使用正则表达式的 **引用分组**。**起名(?P<名字>正则)，引用(?P=名字)。**

import re
    
    str1 = '<html><h1>aaaaa</h1></html>'
    res1 = re.match(r'<(?P<name1>\w+)><(?P<name2>\w+)>(.+?)</(?P=name2)></(?P=name1)>', str1)
    print(res1)
    print(res1.group())
    print(res1.groups())
    res2 = re.match(r'<(?P<name1>\w+)><(?P<name2>\w+)>(.+)</(?P=name2)></(?P=name1)>', str1)
    print(res2)
    print(res2.group())
    print(res2.groups())
    # 输出结果
    <re.Match object; span=(0, 27), match='<html><h1>aaaaa</h1></html>'>
    <html><h1>aaaaa</h1></html>
    ('html', 'h1', 'aaaaa')
    
    <re.Match object; span=(0, 27), match='<html><h1>aaaaa</h1></html>'>
    <html><h1>aaaaa</h1></html>
    ('html', 'h1', 'aaaaa')

# 二、进程 #

下面是python在**Windows**下面对进程的操作

## 进程的创建 ##

from multiprocessing import Process
    from time import sleep
    import os
    
    def task1(s):					# 任务1
        for value in range(5):
            sleep(s)
            print('任务1---子进程pid{}---父进程pid{}'.format(os.getpid(), os.getppid()))
    
    def task2(s):					# 任务2
        for value in range(5):
            sleep(s)
            print('任务2---子进程pid{}---父进程pid{}'.format(os.getpid(), os.getppid()))
    
    
    if __name__ == '__main__':
        p1 = Process(target=task1, name='任务1', args=(1,))	# 定义要执行的内容，子进程的名字，传入参数
        p1.start()			# 开启子进程
        print(p1.name)		# 打印子进程名字
        p2 = Process(target=task2, name='任务2', args=(2,))
        p2.start()
        print(p2.name)

## 进程的结束 ##

from multiprocessing import Process
    from time import sleep
    
    def task1(n):
        while True:
            sleep(n)
            print('task11111')
    
    def task2(n):
        while True:
            sleep(n)
            print('task22222')
    
    if __name__ == '__main__':
        p1 = Process(target=task1, name='你', args=(0.8,))
        p1.start()				# 开启进程
        print(p1.name)			# 进程名
        p2 = Process(target=task2, name='我', args=(0.5,))
        p2.start()
        print(p2.name)
        n = 1
        while True:
            n += 1
            sleep(0.2)
            if n == 100:
                p1.terminate()			# 结束进程
                p2.terminate()
                break					# break退出循环
        print('进程结束')

*  多进程相当于**程序多开**
 *  要注意**全局变量**在**多个进程中不能共享**，在**子进程**中**修改全局变量，对其他进程没有影响**

## 自定义进程 ##

**自定义进程**可使**子进程更加的灵活**

from multiprocessing import Process
    
    class MyProcess(Process):
        def __init__(self, name):
            super(MyProcess, self).__init__()		# 调用父类的init方法
            self.name = name
    
        def run(self):
            num = 1
            while num < 1000:
                print('进程名{}---num为{}'.format(self.name, num))
                num += 1
    
    
    if __name__ == '__main__':
        p1 = MyProcess('lihua')
        p1.start()				# 当使用start方法时，会自动的调用进程里的run方法
        p2 = MyProcess('liming')
        p2.start()

子类中的\*\*\_\_init\_\_方法会覆盖掉父类的\_\_init\_\_方法\*\*，而可以通过**在子类的\_\_init\_\_方法中使用 super().\_\_init\_\_() , 以避免覆盖父类的 \_\_init\_\_构造方法**

## 进程池 ##

当**需要创建的子进程数量不多**时，可以直接利用**multiprocessing**中的**Process**动态成生多个进程就可以。但如果是**上百甚至上千个目标**，手动的去创建进程的工作量巨大，此时就可以**用到multiprocessing模块提供的Pool方法**。因为进程的创建很浪费资源，所以**初始化Pool时**，可以**指定一个最大进程数**，之后**Pool里面的进程号就固定了（任务与进程号轮询）**，这样就可以减少资源的浪费。且**进程池分为非阻塞式和阻塞式**

#### 非阻塞式 ####

**创建指定个数的新进程来执行请求**，并将**创建好的进程一次性提交到Pool**内，如果池中的进程数已经**达到指定的最大值**，那么该请求就会**等待**，直到池中**有进程结束**，才会**创建新的进程**，提交到**池内并执行**。**进程号与请求轮询**

from multiprocessing import Pool
    import time
    from random import random
    
    def task(task_name):					# 任务
        print('任务名', task_name)
        start = time.time()
        time.sleep(random())
        end = time.time()
        return '任务名：{}，执行时间：{}'.format(task_name, end - start)
    
    finish_tasklist = []					# 完成的任务列表
    def callbcak_task(param):				# 每次任务完成后就调用
        finish_tasklist.append(param)
    
    if __name__ == '__main__':
        pool = Pool(5)				# 开启进程池，且里面的进程个数为5
    
        tasks = ('喝水', '吃饭', '做饭', '上厕所', '骑车', '上学', '出游', '写作业')
        for value in tasks:
        	# 将任务提交到Pool内并传递参数与回调函数
            pool.apply_async(task, args=(value,), callback=callbcak_task)
    
        pool.close()		# 表示进程提交结束
        pool.join()			
        # 因为Pool的生命周期依赖于主进程，而主进程执行的时间相对于子进程来说要短得多
        # 就导致了当主进程完成了后，主进程与Pool就结束了，而Pool里面的进程还没有执行完成
        # 而要避免上述的内容发生，就要使用join方法来确保当Pool里面的进程完成后再继续主进程，也就是说先搁置主进程而执行子进程
        # join()就相当于插队，先执行完他再之心其他的内容
        print(finish_tasklist)
        print('OVER')

#### 阻塞式 ####

**创建一个新进程来执行请求**，并将**创建好的进程提交到Pool内**，只有当池中有进程结束，才会创建新的进程，然后提交到池内并执行。将进程的执行，他没有体现进程池的优势，所以说阻塞式的意义不大。**进程号与请求轮询**

from multiprocessing import Pool
    import time
    from random import random
    
    def task(task_name):
        print('任务名', task_name)
        start = time.time()
        time.sleep(random())
        end = time.time()
        print('任务名：{}，执行时间：{}'.format(task_name, end - start))
    
    
    if __name__ == '__main__':
        pool = Pool(5)
    
        tasks = ('喝水', '吃饭', '做饭', '上厕所', '骑车', '上学', '出游', '写作业')
        for value in tasks:
            pool.apply(task, args=(value,))			# 阻塞型
    
        pool.close()
        pool.join()
        print('OVER')

## 进程之间的通信（queue） ##

示例一：

from multiprocessing import Queue
    
    my_queue = Queue(3)			# 利用queue实现进程之间的通信
    message = ['a', 'b', 'c', 'd', 'e']
    for value in message:
        if not my_queue.full():	# 判断queue是否为满
            my_queue.put(value, timeout=2)	# 放进值到queue里
        else:
            print('满了')
    
    print(my_queue.qsize())			# 打印queue的当前存放了多少个值
    while not my_queue.empty():		# 判断queue是否为空
        print(my_queue.get(timeout=2))	# 从queue里取值

示例二：

from multiprocessing import Queue, Process
    from time import sleep
    
    def task1(queue):			# 任务1
        message = ['a', 'b', 'c', 'd', 'e']
        for value in message:
            queue.put(value, timeout=2)		# 放值
            sleep(0.5)
    
    def task2(queue):			# 任务2
        while True:			
            try:
                print(queue.get(timeout=5))	# 取值
            except:
                break
    
    
    if __name__ == '__main__':
        q = Queue(3)
        p1 = Process(target=task1, args=(q,))		# 创建进程
        p1.start()			# 开始进程
        p2 = Process(target=task2, args=(q,))
        p2.start()

# 三、线程 #

*  **线程**有时被称为**轻量进程**(Lightweight Process，LWP)，**是程序执行流的最小单元**。一个标准的线程有线程ID；当前指令指针(PC)，寄存器集合和堆栈组成。另外，线程是进程中的一个实体，**是被系统独立调度和分派的基本单位**，**线程自己不拥有系统资源**，只拥有一点儿在运行中必不可少的资源，但**它可与同属一个进程的其它线程共享进程所拥有的全部资源**。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。**线程也有就绪、阻塞和运行三种基本状态**。**就绪状态**是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机;**运行状态**是指线程占有处理机正在运行;**阻塞状态**是指线程在等待一个事件(如某个信号量)，逻辑上不可执行。**每一个进程都至少有一个线程,若进程只有一个线程，那就是进程本身。**
 *  **线程**是**系统独立调度和分派CPU的基本单位指令运行时的程序的调度单位。**
 *  **多线程**（multithreading)是指从**软件或者硬件上实现多个线程并发执行的技术**。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理(Chip-level multithreading）或同时多线程(Simultaneous multithreading）处理器。**具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能**

## 多线程 ##

from threading import Thread
    from time import sleep
    
    def task1(num):			# 任务一
        message = ['a', 'b', 'c', 'd', 'e']
        for value in message:
            sleep(num)
            print('下载', value)
    
    def task2(num):			# 任务二
        message = ['1', '2', '3', '4', '5']
        for value in message:
            sleep(num)
            print('输出', value)
    
    if __name__ == '__main__':
        t1 = Thread(target=task1, name='任务1', args=(1,))	# 创建线程
        t2 = Thread(target=task2, name='任务2', args=(1,))
        t1.start()			# 开启线程
        t2.start()
        print(t1.name)		# 获得线程名
        print(t2.name)

*  **线程与进程的使用方法基本类似**，**线程**可以**共享全局变量**，而**进程**里面**只能通过Queue来实现共享变量**
 *  当**共享变量的值不够大**时，python会**自动给线程**加上**全局解释器锁（GIL）就形成了进程同步**；而当**共享变量足够大**时，python的**全局解释器**会**自动释放**就**无法进程同步**，而导致**数据不安全**，不过可用**通过手动加锁**
 *  但是一**加上全局解释器锁python的运行速度就会变慢**，也就失去了创建线程的目的，不过同时**数据是安全的**
 *  所以**进程**一般用于**计算密集型的操作**，而**线程**用于**耗时操作（爬虫、文件读写）**

## 手动加锁与解锁 ##

*  使用**Thread模块**的**Lock和Rlock模块**可以实现**简单的线程同步**，这两个**对象**都有**acquire方法**和**release方法**，对于那些需要**每次只允许一个线程操作的数据**，可以将**其操作放到acquire和release方法之间**。线程的优势在于可以同时运行多个任务(至少感觉起来是这样）。但是**当线程需要共享数据时**，可能存在**数据不同步**的问题。**为了避免这种情况，引入了锁的概念。**
 *  **可创建多个锁**，但对**同一全局变量应使用同一把锁**

import threading
    from time import sleep
    
    list_example = [0] * 10			# 可变的全局变量
    lock = threading.Lock()			# 创建一个锁
    
    def task1():
        lock.acquire()				# 请求锁，这里有阻塞效果，若海没有请求到锁则一直阻塞
        for value in range(len(list_example)):
            sleep(0.5)
            list_example[value] = 1	# 给全局变量赋值
        lock.release()				# 释放锁
    
    
    def task2():
        lock.acquire()				# 请求锁，这里有阻塞效果，若海没有请求到锁则一直阻塞
        for value in range(len(list_example)):
            sleep(0.5)
            print(list_example[value])
        lock.release()				# 释放锁
    
    
    if __name__ == '__main__':
        t1 = threading.Thread(target=task1, name='任务1')	# 创建线程
        t2 = threading.Thread(target=task2, name='任务2')
        t1.start()			# 开启线程
        t2.start()
        print(t1.name)
        print(t2.name)
        # 这里是先执行任务1，等任务1执行完后再执行任务2.
        # 虽然两个函数里面都有sleep方法，但是由于GIL的存在，当一个线程里访问全局变量时，另一个线程不会抢占资源

## 死锁的避免与自定义线程 ##

**GIL**有可能会**导致死锁**的发生，而**可使用timeout来避免死锁**的发生

from threading import Thread, Lock
    from time import sleep
    
    lock_a = Lock()			# 锁1
    lock_b = Lock()			# 锁2
    class MyThread1(Thread):		# 自定义线程1
        def run(self):			# start方法会自动调用run方法
            if lock_a.acquire():	# 返回值为Bool类型，若请求到锁则为True
                print(self.name + '获得了A锁')
                sleep(0.1)		# 
                if lock_b.acquire(timeout=5):	# 设置tumeout防止死锁
                    print(self.name + '获得了B锁')
                    sleep(0.1)
                	lock_b.release()		# 锁的释放
            	lock_a.release()
    
    class MyThread2(Thread):		# 自定义线程2
        def run(self):
            if lock_b.acquire():
                print(self.name + '获得了B锁')
                sleep(0.1)
                if lock_a.acquire(timeout=5):
                    print(self.name + '获得了A锁')
                    sleep(0.1)
                	lock_a.release()
            	lock_b.release()
    
    if __name__ == '__main__':
        p1 = MyThread1(name='任务1')		# 创建线程
        p2 = MyThread2(name='任务2')
        p1.start()				# 开启线程
        p2.start()

## 进程的生成者与消费者 ##

**进程的生成者与消费者问题**也就是**两个进程之间的通信**。Python的**queue模块**中提供了 **FIFO(先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，优先级队列PriorityQueue。** 这些队列都**实现了锁原理**(可以理解为原子操作，即要么不做，要么就做完)

import threading
    import queue
    import random
    import time
    
    def producer(queue):			# 生产者
        i = 0
        while i < 10:
            num = random.randint(1, 100)
            queue.put(num)			# 放入数据
            print('生产者生产了{}'.format(num))
            i += 1
        queue.put(None)
    
    
    def consumer(queue):			# 消费者
        while True:
            item = queue.get()		# 取出数据
            if item is None:
                break
            print('消费者消费了{}'.format(item))
    
    if __name__ == '__main__':
        queue = queue.Queue(3)		# 创建队列
        t1 = threading.Thread(target=producer, name='生产者', args=(queue,))	# 创建线程
        t2 = threading.Thread(target=consumer, name='消费者', args=(queue,))
        t1.start()		# 开启线程
        t2.start()
        print(t1.name)	# 打印线程名
        print(t2.name)

# 四、协程 #

**协程**是一种**用户态的轻量级线程**，且协程**可使用生成器来实现**。有**耗时操作（爬虫、网络请求、文件读写等）时才考虑使用协程**

## 生成器 ##

import threading
    import time
    
    def task1():			# 任务1
        for i in range(3):
            print('A{}'.format(i))
            yield
            time.sleep(0.2)
    
    
    def task2():			# 任务2
        for i in range(3):
            print('B{}'.format(i))
            yield
            time.sleep(0.2)
    
    if __name__ == '__main__':
        g1 = task1()		# 生成器
        g2 = task2()
    
        while True:
            try:
                g1.__next__()		# 使用生成器
                g2.__next__()
            except:
                break			# 当有错误时退出循环

## greenlet ##

**greenlet**实现了**协程**，它可以**使你在任意函数之间随意切换**

> pip install greenlet

from greenlet import greenlet
    
    def test1():
        print("111")
        g2.switch()		# 切换函数
        print("333")
        g1.switch()		# 切换函数
    
    def test2():
        print("222")
        g1.switch()		# 切换函数
    
    g1 = greenlet(test1)
    g2 = greenlet(test2)
    g1.switch()			# 切换函数

## gevent ##

*  **gevent**是一个第三方库，**gevent实现了协程**，而在**gevent**中用到的主要模式是**greenlet**。其原理是**当一个greentlet遇到IO**(指的是input output输入输出，比如网络、文件操作等)操作时，就**自动切换到其他的greenlet等到IO完成**，再**适当的时候切换回来继续执行**

> pip install gevent

*  由于**IO操作非常耗时**，经常使程序处于等待状态，有了**gevent我们自动切换协程，就保证总有greenlet在运行，而不是等待IO**
 *  **gevent**与**猴子补丁**一起出现

from gevent import monkey
    import time
    
    gevent.monkey.patch_all()		# 猴子补丁，把所有的耗时操作在底层自动进行了替换，如下面的time()
    
    def task1():			# 任务1
        for i in range(3):
            print('A' + str(i))
            time.sleep(0.1)			# 这里的time()不是真正的time()而是经过替换的time()
    
    
    def task2():			# 任务2
        for i in range(3):
            print('B' + str(i))
            time.sleep(0.1)
    
    
    if __name__ == '__main__':
        g1 = gevent.spawn(task1)		# 使用gevent
        g2 = gevent.spawn(task2)
    
        g1.join()		# 注意这里与Pool有点类似，他的生命周期依赖于主进程，如果没有join()的话gevent将被迫结束
        g1.join()		# gevent内部有joinall()可以代替join()

**生成器** > **greenlet** > **gevent**

还不了解的可以[点击这里][Link 1]

# 五、杂 #

## 全局解释器锁 ##

具体查看这里[传送门][Link 2]

本文只用于个人学习与记录

[Link 1]: https://www.cnblogs.com/GumpYan/p/12973871.html
[Link 2]: https://blog.csdn.net/weixin_39639965/article/details/111020958