NotionNext BLOG

Python转义的五种表示法

Fri, 21 Feb 2025 00:00:00 GMT

😀

这里写文章的前言：一个简单的开头,简述这篇文章讨论的问题、目标、人物、背景是什么？并简述你给出的答案。

可以说说你的故事：阻碍、努力、结果成果，意外与转折。

📝 主旨内容

ASCII 表中一共有 128 个字符。这里面有我们非常熟悉的字母、数字、标点符号，这些都可以从我们的键盘中输出。除此之外，还有一些非常特殊的字符，这些字符，我通常很难用键盘上的找到，比如制表符、响铃这种。

为了能将那些特殊字符都能写入到字符串变量中，就规定了一个用于转义的字符 \ ，有了这个字符，你在字符串中看的字符，print 出来后就不一定你原来看到的了。

举个例子

是不是有点神奇？变成阶梯状的输出了。

那个\013又是什么意思呢？

\是转义符号，上面已经说过

013是ASCII编码的八进制表示，注意前面是0且不可省略，而不是字母o

把八进制的13转成10进制后是 11

对照查看ASCII码表，11对应的是一个垂直定位符号，这就能解释，为什么是阶梯状的输出字符串。

2. 转义的 5 种表示法

ASCII 有 128 个字符，如果用八进制表示，至少得有三位数，才能将其全部表示。这就是为什么说上面的首位 0 不能省略的原因，即使现在用不上，我也得把它空出来。

而如果使用十六进制，只要两位数就其 ASCII 的字符全部表示出来。同时为了避免和八进制的混淆起来，所以在 \ 后面要加上英文字母 x 表示十六进制，后面再接两位十六进制的数值。

\ 开头并接三位0-7的数值，表示8进制

\x 开头并接两位0-f的数值，表示16进制

因此，当我定义一个字符串的值为 hello + 回车 + world 时，就有了多种方法：

通常我们很难记得住一个字符的ASCII编号，即使真记住了，也要去转换成八进制或者16进制，实在是太难了。

因此对于一些常用并且比较特殊字符，我们习惯用另一种类似别名的方式，比如使用\n表示换行，它与\012 、\x0a是等价的。

与此类似的表示法，还有如下这些:

于是，要实现 hello + 回车 + world ，就有了第三种方法

到目前为止，我们掌握了三种转义的表示法。

已经非常难得了，让我们的脑洞再大一点吧，接下来再介绍两种。

ASCII 码表所能表示字符实在太有限了，想打印一个中文汉字，抱歉，你得借助Unicode码。

Unicode编码由4个16进制数值组合而成

什么？我为什么知道中的 unicode 是\u4E2D？像下面这样打印就知道啦

由此，要实现hello + 回车 + world ，就有了第四种方法。

看到这里，你是不是以为要结束啦？

不，还没有。下面还有一种。

Unicode 编码其实还可以由 8 个32进制数值组合而成，为了以前面的区分开来，这里用\U开头。

好啦，目前我们掌握了五种转义的表示法。

为什么说转义也可以炫技呢？

试想一下，假如你的同事，在打印日志时，使用这种 unicode 编码，然后你在定位问题的时候使用这个关键词去搜，却发现什么都搜不到？这就扑街了。

3. raw 字符串

当一个字符串中具有转义的字符时，我们使用print打印后，正常情况下，输出的不是我们原来在字符串中看到的那样子。

那如果我们需要输出hello\nworld ，不希望Python将\n转义成换行符呢？

这种情况下，你可以在定义时将字符串定义成raw字符串，只要在字符串前面加个r或者R即可。

然而，不是所有时候都可以加 r 的，比如当你的字符串是由某个程序/函数返回给你的，而不是你自己生成的

这个时候打印它，\n就是换行打印。

4. 使用 repr

对于上面那种无法使用r的情况，可以试一下repr来解决这个需求：

经过repr函数的处理后，为让print后的结果，接近字符串本身的样子，它实际上做了两件事

将\变为了\\

在字符串的首尾添加'或者"

你可以在Python Shell下敲入变量回车，就可以能看出端倪。

首尾是添加'还是"，取决于你原字符串。

5. 使用 string_escape

如果你还在使用Python 2 ，其实还可以使用另一种方法。

那就是使用string.encode('string_escape')的方法，它同样可以达到repr的效果

6. 查看原生字符串

综上，想查看原生字符串有两种方法：

如果你在Python Shell交互模式下，那么敲击变量回车

如果不在Python Shell交互模式下，可先使用repr处理一下，再使用print打印

7. 恢复转义：转成原字符串

经过repr处理过或者\\取消转义过的字符串，有没有办法再回退出去，变成原先的有转义的字符串呢？

答案是：有。

如果你使用Python 2，可以这样：

如果你使用Python 3 ，可以这样：

什么？还要区分Python 2和Python 3？太麻烦了吧。

明哥教你用一种可以兼容Python 2和Python 3的写法。

首先是在Python 2中的输出

然后再看看 Python 3 中的输出

可以看到Pyhton 2中的输出有一个u ，而Python 3的输出没有了u，但无论如何，他们都取消了转义。

以上，就是我为大家整理的关于Python中转义的全部内容了，整理的过程，不断的发现新知识，帮助到大家的同时，自己也对转义的一些内容有了更深的理解。

🤗 总结归纳

\开头并接三位0-7的数值（八进制） --- 可以表示所有ASCII 字符

\x开头并接两位0-f的数值（十六进制） --- 可以表示所有ASCII 字符

\u开头并接四位0-f的数值（十六进制） --- 可以表示所有 Unicode 字符

\U开头并接八位0-f的数值（三十二进制）） --- 可以表示所有 Unicode 字符

\开头后接除x、u、U之外的特定字符 --- 仅可表示部分字符

📎 参考文章

一些引用

引用文章

💡

有关Notion安装或者使用上的问题，欢迎您在底部评论区留言，一起交流~

详解Python的生成器与协程

Fri, 21 Feb 2025 00:00:00 GMT

😀

从今天开始，我们将开始进入Python的难点，那就是协程。

为了写明白协程的知识点，我查阅了网上的很多相关资料。发现很难有一个讲得系统，讲得全面的文章，导致我们在学习的时候，往往半知半解，学完还是一脸懵逼。

学习协程的第一门课程，是要认识生成器，有了生成器的基础，才能更好地理解协程。

如果你是新手，那么你应该知道迭代器，对生成器应该是比较陌生的吧。没关系，看完这系列文章，你也能从小白成功过渡为Ptyhon高手。

📝 主旨内容

1. 可迭代、迭代器、生成器

初学Python的时候，对于这三货真的是傻傻分不清。甚至还认为他们是等价的。

其实，他们是不一样的。

可迭代的对象，很好理解，我们很熟悉的：字符串，list，dict，tuple，deque等

为了验证我说的，需要借助collections.abc这个模块（Python2没有），使用isinstance()来类别一个对象是否是可迭代的（Iterable），是否是迭代器（Iterator），是否是生成器（Generator）。

这几个判断方法，在这里适用，但并不是绝对适用，原因见后面补充说明。

输出结果

从结果来看，这些可迭代对象都不是迭代器，也不是生成器。它们有一个共同点，就是它们都可以使用for来循环。这一点，大家都知道，我们就不去验证了。

关于可迭代对象，有几点需要补充说明

可以通过，dir()方法查看，若有有__iter__说明是可迭代的，但是如果没有，也不能说明不可迭代，原因见第二条。

判断是否可迭代，不能仅看是否有__iter__ 来草率决定，因为只实现了__getitem__ 方法的也有可能是可迭代的。因为当没有__iter__时， Python 解释器会去找__getitem__，尝试按顺序（从索引0开始）获取元素，不抛异常，即是可迭代。

所以，最好的判断方法应该是通过 for循环或者iter() 去真实运行。

接下来是，迭代器。对比可迭代对象，迭代器其实就只是多了一个函数而已。就是__next__()，我们可以不再使用for循环来间断获取元素值。而可以直接使用next()方法来实现。

迭代器，是在可迭代的基础上实现的。要创建一个迭代器，我们首先，得有一个可迭代对象。现在就来看看，如何创建一个可迭代对象，并以可迭代对象为基础创建一个迭代器。

输出

如果上面的代码太多，也可以看这边，你更能理解。

补充说明:

迭代器，是其内部实现了，__next__这个魔术方法。(Python3.x)

可以通过，dir()方法来查看是否有__next__来判断一个变量是否是迭代器的。

接下来，是我们的重点，生成器。

生成器的概念在 Python 2.2 中首次出现，之所以引入生成器，是为了实现一个在计算下一个值时不需要浪费空间的结构。

前面我们说，迭代器，是在可迭代的基础上，加了一个next()方法。而生成器，则是在迭代器的基础上（可以用for循环，可以使用next()），再实现了yield。

yield是什么东西呢，它相当于我们函数里的return。在每次next()，或者for遍历的时候，都会yield这里将新的值返回回去，并在这里阻塞，等待下一次的调用。正是由于这个机制，才使用生成器在Python编程中大放异彩。实现节省内存，实现异步编程。

如何创建一个生成器，主要有如下两种方法

使用列表生成式

实现yield的函数

可迭代对象和迭代器，是将所有的值都生成存放在内存中，而生成器则是需要元素才临时生成，节省时间，节省空间。

2. 如何运行/激活生成器

由于生成器并不是一次生成所有元素，而是一次一次的执行返回，那么如何刺激生成器执行(或者说激活)呢？

激活主要有两个方法

使用next()

使用generator.send(None)

分别看下例子，你就知道了。

输出

3. 生成器的执行状态

生成器在其生命周期中，会有如下四个状态

GEN_CREATED # 等待开始执行 GEN_RUNNING # 解释器正在执行（只有在多线程应用中才能看到这个状态） GEN_SUSPENDED # 在yield表达式处暂停 GEN_CLOSED # 执行结束

通过代码来感受一下，为了不增加代码理解难度，GEN_RUNNING这个状态，我就不举例了。有兴趣的同学，可以去尝试一下多线程。若有疑问，可在后台回复我。

输出

4. 生成器的异常处理

在生成器工作过程中，若生成器不满足生成元素的条件，就会/应该 抛出异常（StopIteration）。

通过列表生成式构建的生成器，其内部已经自动帮我们实现了抛出异常这一步。不信我们来看一下。

所以我们在自己定义一个生成器的时候，我们也应该在不满足生成元素条件的时候，抛出异常。拿上面的代码来修改一下。

5. 从生成器过渡到协程：yield

通过上面的介绍，我们知道生成器为我们引入了暂停函数执行（yield）的功能。当有了暂停的功能之后，人们就想能不能在生成器暂停的时候向其发送一点东西（其实上面也有提及：send(None)）。这种向暂停的生成器发送信息的功能通过 PEP 342进入Python 2.5 中，并催生了Python中协程的诞生。根据wikipedia中的定义

协程是为非抢占式多任务产生子程序的计算机程序组件，协程允许不同入口点在不同位置暂停或开始执行程序。

注意从本质上而言，协程并不属于语言中的概念，而是编程模型上的概念。

协程和线程，有相似点，多个协程之间和线程一样，只会交叉串行执行；也有不同点，线程之间要频繁进行切换，加锁，解锁，从复杂度和效率来看，和协程相比，这确是一个痛点。协程通过使用yield暂停生成器，可以将程序的执行流程交给其他的子程序，从而实现不同子程序的之间的交替执行。

下面通过一个简明的演示来看看，如何向生成器中发送消息。

输出。

这里解释下为什么这么输出。重点是jump = yield index这个语句。

分成两部分：

yield index是将indexreturn给外部调用程序。

jump = yield可以接收外部程序通过send()发送的信息，并赋值给jump

以上这些，都是讲协程并发的基础必备知识，请一定要亲自去实践并理解它，不然后面的内容，将会变得枯燥无味，晦涩难懂。

🤗 总结归纳

总结文章的内容

📎 参考文章

一些引用

引用文章

💡

有关Notion安装或者使用上的问题，欢迎您在底部评论区留言，一起交流~

深入理解Python中的yield from语法

Fri, 21 Feb 2025 00:00:00 GMT

😀

我们都知道，get_html()等待返回网页是非常耗IO的，一个网页还好，如果我们爬取的网页数据极其庞大，这个等待时间就非常惊人，是极大的浪费。

聪明的程序员，当然会想如果能在get_html()这里暂停一下，不用傻乎乎地去等待网页返回，而是去做别的事。等过段时间再回过头来到刚刚暂停的地方，接收返回的html内容，然后还可以接下去解析parse_html(html)。

利用常规的方法，几乎是没办法实现如上我们想要的效果的。所以Python想得很周到，从语言本身给我们实现了这样的功能，这就是yield语法。可以实现在某一函数中暂停的效果。

📝 主旨内容

友情提醒：本系列所有的代码均在Python3下编写。Python2中可能有所差异。

1. 为什么要使用协程

在上一篇中，我们从生成器的基本认识与使用，成功过渡到了协程。

但一定有许多人，只知道协程是个什么东西，但并不知道为什么要用协程？换句话来说，并不知道在什么情况下用协程？它相比多线程来说，有哪些过人之处呢？

在开始讲yield from之前，我想先解决一下这个给很多人带来困惑的问题。

举个例子。假如我们做一个爬虫。我们要爬取多个网页，这里简单举例两个网页(两个spider函数)，获取HTML（耗IO耗时），然后再对HTML对行解析取得我们感兴趣的数据。

我们的代码结构精简如下：

我们都知道，get_html()等待返回网页是非常耗IO的，一个网页还好，如果我们爬取的网页数据极其庞大，这个等待时间就非常惊人，是极大的浪费。

试着思考一下，假如没有协程，我们要写一个并发程序。可能有以下问题

使用最常规的同步编程要实现异步并发效果并不理想，或者难度极高。

由于GIL锁的存在，多线程的运行需要频繁的加锁解锁，切换线程，这极大地降低了并发性能；

而协程的出现，刚好可以解决以上的问题。它的特点有

协程是在单线程里实现任务的切换的

利用同步的方式去实现异步

不再需要锁，提高了并发性能

2. yield from的用法详解

yield from 是在Python3.3才出现的语法。所以这个特性在Python2中是没有的。

yield from 后面需要加的是可迭代对象，它可以是普通的可迭代对象，也可以是迭代器，甚至是生成器。

2.1 简单应用：拼接可迭代对象

我们可以用一个使用yield和一个使用yield from的例子来对比看下。

使用yield

使用yield from

由上面两种方式对比，可以看出，yield from后面加上可迭代对象，他可以把可迭代对象里的每个元素一个一个的yield出来，对比yield来说代码更加简洁，结构更加清晰。

2.2 复杂应用：生成器的嵌套

如果你认为只是 yield from 仅仅只有上述的功能的话，那你就太小瞧了它，它的更强大的功能还在后面。

当 yield from 后面加上一个生成器后，就实现了生成的嵌套。

当然实现生成器的嵌套，并不是一定必须要使用yield from，而是使用yield from可以让我们避免让我们自己处理各种料想不到的异常，而让我们专注于业务代码的实现。

如果自己用yield去实现，那只会加大代码的编写难度，降低开发效率，降低代码的可读性。既然Python已经想得这么周到，我们当然要好好利用起来。

讲解它之前，首先要知道这个几个概念

1、调用方：调用委派生成器的客户端（调用方）代码 2、委托生成器：包含yield from表达式的生成器函数 3、子生成器：yield from后面加的生成器函数

你可能不知道他们都是什么意思，没关系，来看下这个例子。

这个例子，是实现实时计算平均值的。比如，第一次传入10，那返回平均数自然是10. 第二次传入20，那返回平均数是(10+20)/2=15 第三次传入30，那返回平均数(10+20+30)/3=20

认真阅读以上代码，你应该很容易能理解，调用方、委托生成器、子生成器之间的关系。我就不多说了

委托生成器的作用是：在调用方与子生成器之间建立一个双向通道。

所谓的双向通道是什么意思呢？调用方可以通过send()直接发送消息给子生成器，而子生成器yield的值，也是直接返回给调用方。

你可能会经常看到有些代码，还可以在yield from前面看到可以赋值。这是什么用法？

你可能会以为，子生成器yield回来的值，被委托生成器给拦截了。你可以亲自写个demo运行试验一下，并不是你想的那样。因为我们之前说了，委托生成器，只起一个桥梁作用，它建立的是一个双向通道，它并没有权利也没有办法，对子生成器yield回来的内容做拦截。

为了解释这个用法，我还是用上述的例子，并对其进行了一些改造。添加了一些注释，希望你能看得明白。

按照惯例，我们还是举个例子。

运行后，输出

3. 为什么要使用yield from

学到这里，我相信你肯定要问，既然委托生成器，起到的只是一个双向通道的作用，我还需要委托生成器做什么？我调用方直接调用子生成器不就好啦？

高能预警~

下面我们来一起探讨一下，到底yield from 有什么过人之处，让我们非要用它不可。

3.1 因为它可以帮我们处理异常

如果我们去掉委托生成器，而直接调用子生成器。那我们就需要把代码改成像下面这样，我们需要自己捕获异常并处理。而不像使yield from那样省心。

此时的你，可能会说，不就一个StopIteration的异常吗？自己捕获也没什么大不了的。

你要是知道yield from在背后为我们默默无闻地做了哪些事，你就不会这样说了。

具体yield from为我们做了哪些事，可以参考如下这段代码。

🤗 总结归纳

以上的代码，稍微有点复杂，有兴趣的同学可以结合以下说明去研究看看。

迭代器（即可指子生成器）产生的值直接返还给调用者

任何使用send()方法发给委派生产器（即外部生产器）的值被直接传递给迭代器。如果send值是None，则调用迭代器next()方法；如果不为None，则调用迭代器的send()方法。如果对迭代器的调用产生StopIteration异常，委派生产器恢复继续执行yield from后面的语句；若迭代器产生其他任何异常，则都传递给委派生产器。

子生成器可能只是一个迭代器，并不是一个作为协程的生成器，所以它不支持.throw()和.close()方法,即可能会产生AttributeError 异常。

除了GeneratorExit 异常外的其他抛给委派生产器的异常，将会被传递到迭代器的throw()方法。如果迭代器throw()调用产生了StopIteration异常，委派生产器恢复并继续执行，其他异常则传递给委派生产器。

如果GeneratorExit异常被抛给委派生产器，或者委派生产器的close()方法被调用，如果迭代器有close()的话也将被调用。如果close()调用产生异常，异常将传递给委派生产器。否则，委派生产器将抛出GeneratorExit 异常。

当迭代器结束并抛出异常时，yield from表达式的值是其StopIteration异常中的第一个参数。

一个生成器中的return expr语句将会从生成器退出并抛出 StopIteration(expr)异常。

没兴趣看的同学，只要知道，yield from帮我们做了很多的异常处理，而且全面，而这些如果我们要自己去实现的话，一个是编写代码难度增加，写出来的代码可读性极差，这些我们就不说了，最主要的是很可能有遗漏，只要哪个异常没考虑到，都有可能导致程序崩溃什么的。

📎 参考文章

一些引用

引用文章

💡

有关Notion安装或者使用上的问题，欢迎您在底部评论区留言，一起交流~

Python并发编程（四）：详解 Python线程消息通信机制

Thu, 20 Feb 2025 00:00:00 GMT

😀

这里写文章的前言：一个简单的开头,简述这篇文章讨论的问题、目标、人物、背景是什么？并简述你给出的答案。

可以说说你的故事：阻碍、努力、结果成果，意外与转折。

📝 主旨内容

前面我已经向大家介绍了，如何使用创建线程，启动线程。相信大家都会有这样一个想法，线程无非就是创建一下，然后再start()下，实在是太简单了。

可是要知道，在真实的项目中，实际场景可要我们举的例子要复杂的多得多，不同线程的执行可能是有顺序的，或者说他们的执行是有条件的，是要受控制的。如果仅仅依靠前面学的那点浅薄的知识，是远远不够的。

那今天，我们就来探讨一下如何控制线程的触发执行。

要实现对多个线程进行控制，其实本质上就是消息通信机制在起作用，利用这个机制发送指令，告诉线程，什么时候可以执行，什么时候不可以执行，执行什么内容。

经过我的总结，线程中通信方法大致有如下三种：

threading.Event

threading.Condition

queue.Queue

接下来我们来一一探讨下。

2.4.1 Event事件

Python提供了非常简单的通信机制 Threading.Event，通用的条件变量。多个线程可以等待某个事件的发生，在事件发生后，所有的线程都会被激活。

关于Event的使用也超级简单，就三个函数

举个例子来看下。

执行一下，看看结果

可见在所有线程都启动（start()）后，并不会执行完，而是都在self.event.wait()止住了，需要我们通过event.set()来给所有线程发送执行指令才能往下执行。

2.4.2 Condition

Condition和Event 是类似的，并没有多大区别。

同样，Condition也只需要掌握几个函数即可。

举个网上一个比较趣的捉迷藏的例子来看看

通过cond来通信，阻塞自己，并使对方执行。从而，达到有顺序的执行。

看下结果

2.4.3 Queue队列

最后一个，队列，它是本节的重点，因为它是我们日常开发中最使用频率最高的。

从一个线程向另一个线程发送数据最安全的方式可能就是使用 queue 库中的队列了。创建一个被多个线程共享的 Queue 对象，这些线程通过使用put() 和 get() 操作来向队列中发送和获取元素。

同样，对于Queue，我们也只需要掌握几个函数即可。

以下三个方法，知道就好，一般不需要使用

函数会比之前的多一些，同时也从另一方面说明了其功能更加丰富。

我来举个老师点名的例子。

运行结果如下

其实 queue 还有一个很重要的方法，Queue.task_done()

如果不明白它的原理，我们在写程序，就很有可能卡死。

当我们使用 Queue.get() 从队列取出数据后，这个数据有没有被正常消费，是很重要的。

如果数据没有被正常消费，那么Queue会认为这个任务还在执行中，此时你使用 Queue.join() 会一直阻塞，即使此时你的队列里已经没有消息了。

那么如何解决这种一直阻塞的问题呢？

就是在我们正常消费完数据后，记得调用一下 Queue.task_done()，说明队列这个任务已经结束了。

当队列内部的任务计数器归于零时，调用 Queue.join() 就不会再阻塞了。

要理解这个过程，请参考 http://python.iswbm.com/en/latest/c02/c02_06.html 里自定义线程池的的例子。

🤗 总结归纳

学习了以上三种通信方法，我们很容易就能发现Event和Condition是threading模块原生提供的模块，原理简单，功能单一，它能发送True和False的指令，所以只能适用于某些简单的场景中。

而Queue则是比较高级的模块，它可能发送任何类型的消息，包括字符串、字典等。其内部实现其实也引用了Condition模块（譬如put和get函数的阻塞），正是其对Condition进行了功能扩展，所以功能更加丰富，更能满足实际应用。

📎 参考文章

一些引用

引用文章

💡

有关Notion安装或者使用上的问题，欢迎您在底部评论区留言，一起交流~

Python并发编程（三）：谈谈 Python线程中的“锁机制”

Thu, 20 Feb 2025 00:00:00 GMT

😀

在开发中，锁可以理解为通行证

当你对一段逻辑代码加锁时，意味着在同一时间有且仅能有一个线程在执行这段代码。

在 Python 中的锁可以分为两种：

互斥锁

可重入锁

1.什么是锁？

在开发中，锁可以理解为通行证。

当你对一段逻辑代码加锁时，意味着在同一时间有且仅能有一个线程在执行这段代码。

在 Python 中的锁可以分为两种：

互斥锁

可重入锁

2.互斥锁的使用

来简单看下代码，学习如何加锁，获取钥匙，释放锁。

需要注意的是，lock.acquire() 和 lock.release()必须成对出现。否则就有可能造成死锁。

很多时候，我们虽然知道，他们必须成对出现，但是还是难免会有忘记的时候。为了，规避这个问题。我推荐使用使用上下文管理器来加锁。

with 语句会在这个代码块执行前自动获取锁，在执行结束后自动释放锁。

3. 为何要使用锁？

你现在肯定还是一脸懵逼，这么麻烦，我不用锁不行吗？有的时候还真不行。

那么为了说明锁存在的意义。我们分别来看下，不用锁的情形有怎样的问题。

定义两个函数，分别在两个线程中执行。这两个函数 共用 一个变量 n 。

看代码貌似没什么问题，执行下看看输出

是不是很乱？完全不是我们预想的那样。

解释下这是为什么？因为两个线程共用一个全局变量，又由于两线程是交替执行的，当job1 执行三次 +1 操作时，job2就不管三七二十一给n做了+10操作。两个线程之间，执行完全没有规矩，没有约束。所以会看到输出当然也很乱。

加了锁后，这个问题也就解决，来看看

由于job1的线程，率先拿到了锁，所以在for循环中，没有人有权限对n进行操作。当job1执行完毕释放锁后，job2这才拿到了锁，开始自己的for循环。

看看执行结果，真如我们预想的那样。

这里，你应该也知道了，加锁是为了对锁内资源（变量）进行锁定，避免其他线程篡改已被锁定的资源，以达到我们预期的效果。

为了避免大家忘记释放锁，后面的例子，我将都使用with上下文管理器来加锁。大家注意一下。

4. 可重入锁（RLock）

有时候在同一个线程中，我们可能会多次请求同一资源，俗称锁嵌套。

如果还是按照常规的做法，会造成死锁的。比如，下面这段代码，你可以试着运行一下。会发现并没有输出结果。

是因为第二次获取锁(通行证)时，发现锁(通行证)已经被同一线程的人拿走了，拿东西总有个先来后到，别人拿走了，你要想用，你就得干等着，直到有人归还锁（通行证），假如别人一直不归还，那程序就会在这里一直阻塞。

上面的代码中，使用了嵌套锁，在锁还没有释放的时候，又再一次请求锁，这就当然会造成死锁了。

那么如何解决这个问题呢？

threading模块除了提供Lock锁之外，还提供了一种可重入锁RLock，专门来处理这个问题。

执行一下，发现已经有输出了。

需要注意的是，可重入锁（RLock），只在同一线程里放松对锁(通行证)的获取，意思是，只要在同一线程里，程序就当你是同一个人，这个锁就可以复用，其他的话与Lock并无区别。

5. 防止死锁的加锁机制

在编写多线程程序时，可能无意中就会写了一个死锁。可以说，死锁的形式有多种多样，但是本质都是相同的，都是对资源不合理竞争的结果。

以本人的经验总结，死锁通常以下几种

同一线程，嵌套获取同把互斥锁，造成死锁。

多个线程，不按顺序同时获取多个锁。造成死锁

对于第一种，上面已经说过了，使用可重入锁。

主要是第二种。可能你还没明白，是如何死锁的。

举个例子。

线程1，嵌套获取A,B两个锁，线程2，嵌套获取B,A两个锁。由于两个线程是交替执行的，是有机会遇到线程1获取到锁A，而未获取到锁B，在同一时刻，线程2获取到锁B，而未获取到锁A。由于锁B已经被线程2获取了，所以线程1就卡在了获取锁B处，由于是嵌套锁，线程1未获取并释放B，是不能释放锁A的，这是导致线程2也获取不到锁A，也卡住了。两个线程，各执一锁，各不让步。造成死锁。

经过数学证明，只要两个（或多个）线程获取嵌套锁时，按照固定顺序就能保证程序不会进入死锁状态。

那么问题就转化成如何保证这些锁是按顺序的？

有两个办法

人工自觉，人工识别。

写一个辅助函数来对锁进行排序。

第一种，就不说了。

第二种，可以参考如下代码

如何使用呢？

看到没有，表面上thread_1的先获取锁x，再获取锁y，而thread_2是先获取锁y，再获取x。但是实际上，acquire函数，已经对x，y两个锁进行了排序。所以thread_1，hread_2都是以同一顺序来获取锁的，是不是造成死锁的。

6. 饱受争议的GIL（全局锁）

在第一章的时候，我就和大家介绍到，多线程和多进程是不一样的。

多进程是真正的并行，而多线程是伪并行，实际上他只是交替执行。

是什么导致多线程，只能交替执行呢？是一个叫GIL（Global Interpreter Lock，全局解释器锁）的东西。

什么是GIL呢？

任何Python线程执行前，必须先获得GIL锁，然后，每执行100条字节码，解释器就自动释放GIL锁，让别的线程有机会执行。这个GIL全局锁实际上把所有线程的执行代码都给上了锁，所以，多线程在Python中只能交替执行，即使100个线程跑在100核CPU上，也只能用到1个核。

需要注意的是，GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。而Python解释器，并不是只有CPython，除它之外，还有PyPy，Psyco，JPython，IronPython等。

在绝大多数情况下，我们通常都认为 Python == CPython，所以也就默许了Python具有GIL锁这个事。

🤗 总结归纳

都知道GIL影响性能，那么如何避免受到GIL的影响？

使用多进程代替多线程。

更换Python解释器，不使用CPython

📎 参考文章

一些引用

引用文章

💡

有关Notion安装或者使用上的问题，欢迎您在底部评论区留言，一起交流~

Python并发编程（二）：创建多线程的几种方法

Wed, 19 Feb 2025 00:00:00 GMT

😀

这里写文章的前言：一个简单的开头,简述这篇文章讨论的问题、目标、人物、背景是什么？并简述你给出的答案。

可以说说你的故事：阻碍、努力、结果成果，意外与转折。

📝 主旨内容

1. 用函数创建多线程

在Python3中，Python提供了一个内置模块 threading.Thread，可以很方便地让我们创建多线程。

threading.Thread() 一般接收两个参数：

线程函数名：要放置线程让其后台执行的函数，由我们自已定义，注意不要加()；

线程函数的参数：线程函数名所需的参数，以元组的形式传入。若不需要参数，可以不指定。

举个例子

可以看到输出

2. 用类创建多线程

相比较函数而言，使用类创建线程，会比较麻烦一点。

首先，我们要自定义一个类，对于这个类有两点要求，

必须继承 threading.Thread 这个父类；

必须复写 run 方法。

这里的 run 方法，和我们上面线程函数的性质是一样的，可以写我们的业务逻辑程序。在 start() 后将会调用。

来看一下例子为了方便对比，run函数我复用上面的main。

当然结果也是一样的。

3. 线程对象的方法

上面介绍了当前 Python 中创建线程两种主要方法。

创建线程是件很容易的事，但要想用好线程，还需要学习线程对象的几个函数。

经过我的总结，大约常用的方法有如下这些：

至此，Python线程基础知识，我们大概都介绍完了。

🤗 总结归纳

总结文章的内容

📎 参考文章

一些引用

引用文章

💡

有关Notion安装或者使用上的问题，欢迎您在底部评论区留言，一起交流~