ShowMeAI-人工智能工具笔记-六-

ShowMeAI 人工智能工具笔记（六）

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P17：17）函数进阶 - ShowMeAI - BV1yg411c7Nw

好的，在这个视频中我们将深入探讨函数，特别是参数和不同的处理方式。例如，你可以在一个函数内定义另一个函数。这太疯狂了。因此，让我们深入看看。

好的，我们先从简单的开始。我们讨论的是没有参数，没有争论。我们只会做我们之前做过的事情，这样我们就有一个良好的基础来开始。我们已经做过多次了。因此，我们将只打印出来，并说这是正常的。函数，这算是我们的起点。我们将开始一段小旅程。

我们将要做的是潜入疯狂的深渊，看看会变得多疯狂。因此。我们现在就来调用这个。你注意到我把这个放在这里吗？这些是转义字符。返回换行符和一些破折号及参数。我们将把它分开，因为在这个视频中我们会有很多输出。

我们希望能够看到这里发生了什么。因此，我会在进行时复制和粘贴这些。我们正在调用这个函数。它按预期工作。如果这一切在此时看起来不清楚，你需要停止观看这个视频，去看前面的16个视频，以真正理解我们将要讨论的内容，因为我们将毫无保留地直接潜入深水区。

让我们去掉辅助轮，谈谈位置参数和关键字参数。好的，这里会变得非常复杂，非常快。所以我们要定义一个叫做message的函数。我们要说名称。消息。然后我们需要一个年龄。所以我们有几种不同的数据类型要处理。

很明显，它会像一个字符串和一个蚂蚁，所以我会说打印。你好。然后我们想要名称。接着是消息。你是。然后无论多少年。他们告诉我们。因此，从根本上看。这似乎并不是火箭科学，但我们可以开始做一些非常，非常疯狂的事情。所以我会把这个抛出来。

位置关键字参数，所以当我们运行这个时，我们会看到输出被分开。我们来定义消息。并按照你预期的那样调用它。现在。我们在这里做的称为位置。你注意到有名称、消息和年龄。这些是位置。把它想象成一个列表。它是零基的，所以是0，1，2。

我们不需要给它一个索引。它足够聪明，知道索引是什么。但我会说。布莱恩。假设，早上好。然后给它一个年龄。假设我22岁，天哪，我希望我22岁。其实我并不是。这是位置参数。继续运行这个。我们将看到。果然，嘿，布莱恩。早上好。你22岁了。所以看起来不错。

让我们抓住这个，稍微玩一下。😊，我们将使用位置参数。但我们将使用错误的顺序。让我们搞砸这个。所以我会说22。和。早上好，所以我们真正做的是把这些调换过来。输出突然没有意义。嘿，布莱恩22，你是早上好岁。

这完全没有意义。这就像是一个连环杀手写的东西。好吧，所以。我们在这里做的是定位，并且我们搞错了顺序。那么我们如何修复它呢？我们使用所谓的关键字。所以我们要做同样的事情。我们要保存消息。在这里，我们要说。MSg等于。你可以在Visual Studio代码中看到这个。

它有那个括号和一点小块。它足够聪明，知道我们在尝试调用参数消息。带有参数的。早上好。现在你会立刻注意到，我们完全无视顺序，因为消息是。好吧，第二个而我们给它第一个。正如你将要看到的，这真的没有关系。

假设年龄等于，假设为46。然后，名字。等于。Rightan。让我们继续运行这个。果然，它显示，哈喽，布莱恩，早上好，你46岁了，现在一切正常。我们不需要给它一个特定的顺序。我们正在处理E单词。我希望他们把这个叫做Raammeteral参数或类似的东西。

但基本上就是关键字。所以发生的事情是Python正在将这些参数转化为关键字。在内部它有某种列表，告诉它，嘿。如果你给我一个关键字并将其放进去。它会神奇地知道如何排列它们，以及它们需要以什么顺序排列。

你也可以同时使用两者，所以让我们抓住这个家伙。让我们抓住这个。让我说，布莱恩。然后让我们调换这些。所以你可以随意混合和搭配。所以你可以说位置参数后跟关键字，让我们运行，看看它的效果。无论你怎么做，它都会有效。极酷。

我非常喜欢Python的这一点。让我们再让它复杂一些。我们将讨论内部或内联函数。内部和内联之间有微妙的区别。我们讨论的是内部函数，本质上是函数内部的函数。

所以我们要说“计数器”。在计数器内部，我们会立即调用另一个函数或创建一个名为“显示”的函数。我们想要说，计数是0。所以实际上我们所做的只是一个函数内有一个函数。注意它足够聪明，可以换行，所以它知道自己有自己的作用域。

我们将打印出来，并说“永恒”，这样我们就知道我本来要做的是圣·马尔。但我们就说“内部”，这样我们知道自己在哪里，然后打印出计数。在内部，这实际上是很复杂的，但我们做起来却超级简单，我们只需一个函数。

我们定义了另一个函数，该函数有自己的小作用域。我们现在可以在这里跳出并说一些类似这样的话。“4 x in range。”说五。这里没有太大的变化。让我们去调用我们的“显示”函数。我们将用X来调用它。所以我们说“4 x in range”。

所以它将这样做五次，并会说“调用显示1”。1，2，3，4，5。真有趣。让我们看看实际效果。我稍微复制和粘贴一下笔记，我们将讨论内部函数，并调用计数器函数。果然，0，1，2，3，4。我总是忘记从0开始，这让我困惑。好的。

所以我们在这里调用一个函数，它有一个内部函数，这个内部函数在内部调用自己，只是在内部进行所有这些疯狂的操作。所以我们来看看这个计数器。抓住这个名为“显示”的内部函数。试着调用它，所以我们现在提高了一个档次。让我们看看能否调用它。果然，我们不能。

我们得到了一个名称错误，显示未定义。记住，当你看到“未定义”时，意味着Python不知道这是什么，因为它在我们工作的作用域中不存在。所以你猜到了，你会折叠它，显示不存在。它在这里的作用域内部。

这很酷，但也很令人困惑，所以如果你要使用这个，请小心你如何调用它，否则你会遇到某种错误。好的，让我给你一个噩梦场景。老板走进来。你是一个新手Python程序员，他说：“我想让你写一个函数，但我不会告诉你我会给你多少参数。”

我希望你的函数能自动找出这些参数。我们在这里谈论的是“星号参数”，星号代表通配符。这是一个位置变量长度参数。好的，那么我们在谈论的位置是什么？

好吧，我们之前在这里稍微谈到过位置，这不是我们所谈论的内容。我们要谈论的是这里。我们要说“de”。让我们乘以“as”，我们可以随意命名它。现在，我们将传入一堆参数，这些参数将基于一个位置。

所以我们来设定，Z等于1。或者名。在作为。然后我们继续打印出来，这样我们可以看到发生了什么。现在我们只是要乘以这个，我们会说，Z乘以这个数字。现在让我们打印出来。从我的笔记中复制粘贴一点，只是为了在输出中图形化地看到我们的位置。让我们来称之为乘法。或者实际上是多个。

我们会说老板给我们三个数字。数字一，数字二，数字三。这就是我所说的位置。它将按照我们给出的确切顺序，1，2，3。我们可以交换这个，说2，3，1。你会看到位置变成231。好的，非常，非常简单，很容易理解。这里的主要收获是我们没有受到限制。

我们可以将这个提升到一个荒谬的水平。我们可以做这样的事情。

诶。按预期工作。

让我们来设想一个噩梦般的场景，我们的老板简直就是个混蛋。我们要说，好吧，他会进来并说，我将给你随机信息。我不会告诉你我会给你多少信息，也不会按特定顺序给你。是的，这真是个噩梦。

所以我们讨论的是关键词，这基本上是同样的事情，只不过我们使用的是关键词，而不是位置。我们之前提到过关键词，早些时候讨论过我们如何混合搭配，做其他很酷的事情。但我们会尽量简化，因为是的，这可能会很复杂。主要要注意的是，这里有两个星号。所以我们就说去掉配置文件。这就是老板要对我们做的事情。他会说，我将给你一个人。这个人只是一些数据。

你需要搞清楚该怎么做。所以我们要打印出我们的人。现在，让我们暂时跳出这里。我会说，添加我们的分隔符，这样我们就知道我们在输出中，并且让我们称之为。这就是我说的配置文件。现在，它足够聪明，知道选择关键词弧。

这给了我们双星号，现在我们要定义要给出什么信息。我只会说名字。如果你在想我从哪里得到名字，我实际上只是随便从脑海中抓出一些东西。这里给什么都无所谓。所以我们把名字设为布莱恩，然后我们继续设定年龄等于46。让我们运行这个看看会发生什么。我们正在打印这个人，所以注意它现在转化为字典。没错。所以现在我们可以像使用字典一样使用它，这个过程非常酷。好了。

让我们继续，安。使用内部函数，我将说。N 显示。让我们继续显示 K。现在我们要进行一些测试。我们在字典视频中涵盖了这一点，我们将说如果 K，它在。这个人。第一次。然后我们想打印出来。如果这太令人困惑。

我强烈建议你回到播放列表中观看我们讨论字典的视频。现在我们可以直接使用这个字典，因此我们在一个函数中有一个函数。这个内部函数显示只是会说如果这个关键字在人员键中，因为记住它正在将其转换为字典。然后继续打印出键并打印出值。

现在我们有了这个内部函数，接下来就调用它。我将说。他们玩。并给它一个关键字名称。现在，注意我们实际上是硬编码这个。你可以做不同的事情。所以我将说名称。年龄。我们在开会时，他们提到要增加一个宠物。

但他们实际上还没有这样做，这就是我们说如果关键字在键中。因为我们已经做到了，如果我们不必担心未定义。它将打印出名称。年龄，好的。市场部的人回来问，难道如果他们有一个宠物，不会很酷吗？

所以让我们把它加进去。现在你可以看到布赖恩 46 岁和凯，我们有两个不同的调用。因此，第一个没有宠物，第二个有宠物。它的工作方式正如你所期待的那样。现在我们可以测试这个或其他事情。因此，例如，假设。食物。是比萨。我们在这里做了什么，我们添加了一个我们没有使用的关键字。

它不会使你的应用程序崩溃，因为它在说。如果它在这里而我们甚至还没有调用它，所以让我们做相反的事，让我们。去这里，我不知道那是什么。我们只是在瞎搞。不会崩溃，因为它不在里面。非常酷，非常简单的工作方式。

理解起来超级简单，但我们真正想要强调的是这些是关键字参数而不是位置参数。位置根本不重要。好了，让我们简单谈谈 Lambda 或匿名函数。

你会听到它们被称为 Lambda 函数，但它们实际上并不是 Lambda 函数，而是匿名函数。我们使用 Lambda 来创建一个匿名函数。所以让我们迅速定义一下。首先，我们将制作一个普通的。作为参考，有些人可能会说。是的。

让我们称之为 make。S Q X T。所以我们在计算平方英尺。我们将说宽度。默认值和高度。也有默认值。我们只是返回。宽度和高度。所以我们实际上是在获取平方英尺。超级简单，超级容易理解。继续打印出来。让我说打印。实际上，我要暂停一下。

我们要添加一个小的分隔符，这样我们就能在输出中看到它。好的，回到我们正在做的事情上。我们将打印出平方英尺。让我们两种方式都来做一下，我们可以说宽度等于。试着想一个合适的数字，这里是10。高度，有没有观众，任何人。

有人叫它八，为什么不呢？你也可以直接说F。然后计算平方英尺，假设是15乘以8。我们可以两种方式调用。去吧，运行它，你会看到。哈，这里是我们的数字。现在让我们使用Lambda关键字来创建一个匿名函数。我故意称其为Lambda函数，尽管它们是匿名函数，因为你会听到人们说。

好吧，我要创建一个Lambda函数。我们实际上是将lambda关键字作为Q.F.T。等于。那么我们在做什么呢？我们在创建一个变量。我们将说lambda。现在我想慢下来，我在这里放一个注释。我们必须以某种特定的格式来做这件事。所以我们有一个变量，lambda关键字。

一个或多个变量的列表，然后是一些代码。所以我们在说lambda。让我们继续说宽度。等于，假设是零。好的。那么零。现在我们进入我们的代码，所以如果你看这个，实际上我们在说lambda将替换所有这些。

然后我们有我们的信息，我特意将这些命名相同，这样你可以在屏幕上看到它们被高亮显示。让我们再做一次。现在我们有了参数，现在我们有了代码。如果我们想的话，我们可以抓取这些，通过复制粘贴的魔力，而不是函数调用来计算平方英尺。我们将只是把这个变量SQFT，它的功能完全一样。看，8120，8120。

这简直就是巫术，我的意思是，这就像是老程序员们的巫毒魔法。但是，实际上在后台发生的事情是，当你调用lambda时，Python基本上是在做这个。但它都是在一行中完成的。作为程序员，这让你的生活轻松一点，因为它都在一行中。

你只需要记住这个变量名。它存在于全局作用域中，所以我们可以像对待函数一样对待它。如果我们将鼠标悬停在上面，你会看到它足够聪明，知道这是对lambda的调用。因此它是在创建一个匿名函数。我个人不是匿名函数的忠实粉丝，但它们在编程世界中确实有其存在的地方。

特别是当你进入图形用户界面编程和套接字编程等领域时。你会看到人们非常重视这些。有些人喜欢它们，有些人讨厌它们。就我个人而言，我更喜欢定义我要使用的内容，而不是依赖某些疯狂的巫术。我不想偏离这个Lada，它非常强大且实用。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P18：18）打包和解包数据 - ShowMeAI - BV1yg411c7Nw

大家好，欢迎回来，我是布莱恩，我们要谈论打包和解包数据。现在我们到底在谈论什么呢？好吧，我们在 Arg 和关键字 Arg 的问题是我们无法轻松使用列表、集合、元组和字典，相反，我们必须打包和解包数据，这就是这段视频要深入探讨的内容，让我们看看。

所以让我们看看打包数据。这听起来好像会非常复杂。但实际上，按照 Python 的精神，这非常非常简单。所以我只是要创建一个名为 pack 的函数。我们将在这里创建一个参数，叫做 nuns。这是一个星号，意味着一个或多个变量。在这里，我们要说，继续打印出来。

这样我们就能看到我们实际得到了什么。现在，让我们调用这个 pack。我想打包 1，2 和 3。看看这里实际发生了什么。果然，它创建了一个元组。从这里，我们可以很容易地说或 X 在 nus 中。然后做类似的事情。将这些单独的数字取出来，看看元组内部到底发生了什么。超级。

非常简单，易于理解。这如预期般工作。然而，这里有一些问题。让我们看看如何解包数据。

好的，打包数据很好，简单，而且我们以前做过。但是如果我们尝试做相反的事情，解包数据，我们到底在谈论什么呢？解包，所以让我们做一个例子，我说 F 解包。并给它三个变量。A，B 和 C。从这里开始，我将打印出来。解包，这样我们就能看到发生了什么。

按租金跟随。我们可以直接抓取这些。超级简单。可能是我们写过的最简单的函数。说 BC，当然，把它们排列好。U B 和 C。看着这个函数，它相当直接，很明显会发生什么。但现在让我们引入一个问题，我要说。Numb。结个。😊，我想创建一个数字列表。

1，ma 2，逗号 3。如果我们说解包。并只给它我们的变量。你认为会发生什么呢？在 telesc 中已经告诉我们这里会有问题。没有参数值，它说，哦。看。😊，缺少两个必需的可选位置参数 B 和 C。等等，什么？但是我给了它一个列表，这个列表中有三个元素。

实际上发生了什么，我们必须具体告诉Python取这个列表并解包，我们只需在这里加一个星号。我们再试一次。我将清空这个。现在它神奇地工作了。所以我们要强调的是，当你看到这个星号，不管在什么上下文中，无论你使用AGs还是关键字参数。

或者你在这里用作参数，或者你用作参数。把这看作是告诉Python你将要打包或解包数据，而Python。我要你处理所有麻烦的细节，这样我就不用了。

与所有编程相关的事物一样，这并不简单。让我们看看另一个问题。字典问题。让我们创建一个字典，并说。B等于字典，并且必须说名称等于瑞安。年龄等于46。还有。它等于猫。随意输入你想要的任何值，只需要一个包含三个元素的字典。现在。

让我们打印一下。打包字典。接下来我们试着打包这个。所以我们将调用我们的打包函数。我们现在足够聪明，知道需要在这里放一个星号，因为我们要告诉Python你处理细节，我们将把字典放在那里。

继续清理我们这里的结果，看看会发生什么。哦哦，我们遇到了问题。它只获取了键。确实成功获取了键，但它只是获取了键。记住我们的字典是一个键值对，所以。这很让人沮丧。让我们尝试相反的。让我们尝试解包它。接下来我们说。解包。安迪，那里有个小函数名。

再次运行，解包，再次，ABC，它只是获取了键。所以你完全正确。我们必须以特殊的方式处理字典，让我们看看。看看字典的问题，它只获取了键，我们必须以特殊的方式处理它。所以我们将查看一个如何打包字典的例子。现在。

当你说打包字典时，我脑海中浮现出将字典放进书包去上学的画面。这正是我们在做的事情。所以我们要说定义。打包一个字典。接下来我们说，我们要使用星号。请注意，双星号代表通配符。

所以我们告诉它我们将得到两个东西。如果这看起来有些熟悉，那是因为我们在谈论，你猜对了，关键字as。字典无非就是键值对。这正是我们在谈论的内容。关键字it。让我们打印一下。实际上把它打印出来。

我想看看我们从Python世界得到的是什么。Nuns等于。然后让我们打印出来。现在，我们来调用这个。我想说。让我们给它一些任意的数据。随便编造你想要的，只要有三个值，它根本不在乎。我只是说名字是Brian。

8等于46。APa等于。Ats。运行这个，果然numbs。等于看这些小波浪线。一个字典对象。所以它自动。为我们完成了这件事，基本上在后台，它调用了diict函数，并将所有这些关键字参数转换为字典森林。

处理起来简单得离谱，这就是要打印的内容。接下来我们要说的是。我们实际上想要的是，进行一次循环，而不是一个一个地取出这些元素。或者k。然后。最后一分钟，计划有变。所以这是我们的关键字。然后我们想说等于。并给它我们的键，来吧。说Ron，让我们看看这看起来怎么样，果然如此。Pt名称。

只要里面有双星号，年龄和宠物按预期工作。你现在可以将整个对象作为字典访问。为了总结这一切。我们要做相反的事情，我们现在要解包一个字典。所以我们接下来要说D EF。解包它。哎呀，这是个有趣的名字。我可能会在评论中受到一些批评。

但是名称、年龄和宠物，我们就继续使用这个以及一个小范式。接下来我们要说打印。我们要在这里解包一个字典对象。接下来我们要说打印。你猜对了，这真的是太简单了。做魔术复制粘贴，我将加速这一过程。好吧，现在来调用这个。

嗯。我们实际上该如何调用这个呢？我们有一个字典对象在那儿。所以我们要重新使用那个字典对象，顺便说一下，就是这个家伙，我将把它抓过来。就这样重新创造轮子。它已经设置好了，我将再次设置，以便你能在屏幕上看到。我们要解包那个字典对象。

因为我们在使用字典，我们需要双星号告诉它，嘿。我们在后台使用关键字作为。看看这个东西的运行效果。所以它会创建一个字典。然后我们要告诉Python将其解包。看看，将一个名为Brian、年龄46的字典解包成猫。所以这个视频。看似简单。

我们实际上在后台做了很多工作，我应该说Python为我们做了所有的工作。我们在打包和解包数据，我们已经给出了如何打包和解包列表、集合和元组的示例，以及如何打包和解包字典对象及其出现的一些问题。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P19：19）函数和参数 - ShowMeAI - BV1yg411c7Nw

好吧，函数和参数，函数真的很酷。但如果你可以在函数中使用函数呢？我们所指的是什么？假设我们要做类似这样的事情，de。测试。在这里，我们将做一些像测试二或测试一之类的事情，或者我们想做的任何事情。

不完全是我们要怎么做，但确实，我们将使用函数作为参数。让我们深入研究一下。让我们直接进入这里。我们将查看一个函数作为参数。这听起来有点古怪，但让我们看看。所以我将说。定义测试。

我们将有一些参数。我将说名称、年龄和宠物。我们在之前的视频中见过这种情况。好的，打印出来。有些人说打印。做匹配。复制并粘贴，我们可以稍微加快这个过程。这将是一个超级简单的小函数。所以我们只是打印出名称、年龄和宠物。

我们本可以用更简单的方法来完成这一点。但我想逐行打印出到目前为止我们学到的信息。从这里开始，我们将创建一个名为获取数据的函数。这种做法在 Python 中非常常见，但几乎所有编程语言中都存在，你会有一个函数返回某种类型的数据，另一个函数实际使用这些数据。

所以，在这里，我们将返回字典。使用相同类型的模式。有些人说。输入你想要的任何年龄。如果你输入的年龄比实际年轻或年长，我不会告诉任何人。如果你喜欢这样，我不知道。所以我将返回一个包含名称、年龄和宠物的字典。

现在我们在这里有一些基本问题。例如，我们如何将这两者结合使用？

好吧，有我称之为的标准方式。你只需调用这个，单独获取数据。但现在你必须像这样输入。最好。你必须做得很长，令人烦恼。你必须把顺序弄对，所有这些其他麻烦事，实际上一点也不好玩。你可以这样做一整天。当然，如果你改变一件事。

你必须改变其他一切。这会变得非常麻烦，但确实有效。是的，我们确实考虑过一种更简单的方式来打包或解包数据，我应该这么说。我们要说测试。现在，我们要调用。数据。然而这里有一个根本性的问题。如果我们这样调用，实际上是在调用那个函数。

我们正在返回一个字典，但现在我们需要解包它。例如，如果我只是运行它。它会说缺少两个必需的位置参数。代理宠物。所以现在我们就告诉Python解包它。保存并运行，现在它可以工作了。非常简单，非常容易，你可以在一行中完成。这种工作方式太酷了。

好的，我们将讨论一些稍微不同的内容。这是一个作为参数的函数。我们已经在这里讨论了一个作为参数的函数，其中我们说了测试。然后我们用这些括号调用获取数据，我们得到了所有这些特殊字符，按照特定顺序处理，否则就无法工作。

我们将做一些简单一点的事情。我将说def。并且我需要一个好名字。我们叫它bunky吧。为什么不呢。我不知道该给它什么名字。所以我们称其为funky。我们将有一个名为数据的变量。到目前为止，一切都非常抽象。什么都没有真正定义，我们只有一个叫做数据的变量。

我们要创建另一个变量D。它将是数据的结果。请注意，数据是像函数一样被调用的，尽管它也是一个变量。在其他语言中，你会称其为函数指针，但基本上发生的事情是，我们说。抓住一些函数然后调用它，无论我们怎么命名它，我们可以把它叫做。小猫。

然后D将是小猫的结果。名称并不重要。重要的是我们将把它作为函数调用。Python足够智能，知道嘿。那个变量在内部是一个函数指针。做一些事情。所以我将继续打印。第一。现在为了做到这一点，我将说。放见。

我们将重用我们上面提到的Gi数据函数。它将返回一个字典对象。所以这里是重点。我想说的是。请注意，没有星号。没有额外的参数。它看起来不会像这样。它只是一个单词，yet data。我实际上要在这里放一个特别的备注。

让我们运行一下，看看效果如何。这就是结果。它是我们的字典。如果我们对此非常担心，我们可以说。E等于。然后运行一下以验证D等于。等等，等等。那么，这里发生的事情是我们说我们的函数将有一个变量。

我们将把那个变量当作一个函数来处理。Python足够智能，可以识别出这个家伙。我们现在将其转换为函数的一个参数，这实在是太酷了。只要一切都能正常工作，我们就可以继续做一些这样的事情。😊，假设打印一下。

我们可以用很多不同的方法来做到这一点。我将用较长的方式来做，为什么不呢。然后继续去D。我们又得担心单引号和双引号的问题了。还有其他方法可以做到这一点。如果你在想我这些输入是从哪里来的，其实是从我们上面的字典对象。所以我知道我们有一个名字、一个年龄和一个宠物。

所以我们继续把宠物也抓取过来。我们可以用很多不同的方法来做这个。我们可以使用for循环。我们也可以测试它是否在字典的键中，随便以我们想要的方式抓取这个项目。而Ta就是这样工作。这里的主要收获是，我们实际上可以将一个函数作为参数，然后将那个变量用作函数。

这种方式真酷。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P2：2）Python变量 - ShowMeAI - BV1yg411c7Nw

欢迎回来，我叫布莱恩，我们将继续讨论Python 3。无论你使用哪个IDE，请创建一个新文件并给它起个名字。我会把它命名为playground，名字并不重要，你只需要一个可以玩的文件。记住，这些视频假设你没有经验，所以我们实际上是从一个空白的状态开始。

你将学习的第一件事是变量是什么，我将在这里写下来。好吧，变量只是一些会变化的东西，例如，如果我声明一个名为X的变量。我必须给它分配某种值。试着打印X，看看会发生什么。注意，它会出现某种错误，它会说名称错误，名称X未定义。

这是什么意思？好吧，显然，我们定义了它。就在这里。实际上，Python想告诉你的是它并没有任何值。所以我会说，42。现在我们重新运行一下。突然之间它显示42。所以如果你得到的是未定义的，那么你实际上是在说你没有设置那个值。

你注意到这是一个数字。这就是我所说的变量是会变化的东西。我很容易就可以说，Hats。注意cats是一个字符串。字符串只是一系列字符，但我想强调的是它不是一个数字。如果我们运行这个。

它工作得很好。

所以在后台，你在这里看到的是Python知道它足够聪明，知道我们在这个变量中存储什么类型的信息，并且我们可以随时更改它。例如，我们有x等于cats，然后让我们抓取这个，进行复制粘贴操作。我们会说，x等于。我需要某种数字。为什么不呢？而IDE对我不太满意。

说无效的令牌。我只想去掉那个0。也许这样能解决。并没有。让我们继续，哦，它好了，让我们运行这个。你知道它是怎么说cats的。然后它有一个数字。所以我们可以用这个变量进行更改。Python在后台足够聪明，知道X是一个字符串，而X是一个整数。

所以我们真正要深入探讨的内容是数据类型，当我说很多时间时，我将不得不把它分成多个视频，因为每种数据类型，无论是字符串，还是像这里的整数这样的数字。

变量具有不同的属性，你可以访问它们。因此，关于变量的简单答案就是，它是某种会变化的东西。就这么简单。许多讲师可能需要几个月的时间来解释变量是什么以及它在内存中的存活方式，等等，作为程序员，我们对此并不关心，我们只想要它能够工作。

这就是计算机编程的基础。你声明某种类型的变量，设置值，而该值有某种类型，利用这个类型，你现在可以进行操作。有趣的是，如果你来自其他语言，或者对编程有所了解，Python中你不需要声明数据类型，例如，在其他语言中。

你可能需要说类似于 int X equals 3 的话。所以我们真正要做的是告诉解释器，这是我们要使用的数据类型。我们不需要这样做，Python聪明到能够自己搞定。好吧，让我们稍微偏离一下话题。现在，我们要讨论的是动态和强类型，Python同时具备这两个特性。

这对人们来说常常是令人困惑的，尤其是来自其他语言的程序员。正如你看到的，我们不需要声明数据类型，Python足够聪明可以知道。在其他语言中，你确实需要声明，这常常让人感到困惑。因此，我们经常被问到这个问题：为什么Python是动态语言，同时也是强类型语言。

这两者究竟是什么意思。动态性就是这样的，它是动态的。你不需要声明变量类型，并且可以随时更改。正如你在这里看到的，我们从字符串变成了变量。Python足够聪明，可以跟踪一切，并且没有抛出任何错误。

在其他语言中，你会遇到巨大的错误，因为我们声明了一个数据类型后，它就永远不能是其他任何类型。

这有点复杂。最好的答案是Python是强类型语言，因为解释器跟踪所有变量类型，意味着Python本身足够聪明，知道你想让它做什么，但它也在后台保证一旦你赋值，它会保持那个变量类型，直到你覆盖或更改它。记住这一点。

变量是会变化的东西。在Python中，这非常非常真实，因为你可以将它更改为完全不同的数据类型。在许多其他语言中，你根本无法做到这一点。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P20：20）全局关键字 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好，我是Brian，我们将继续探索Python 3与全局关键字。这非常酷，非常简单，并解决了一个复杂的问题。😊例如，我们之前见过这段代码。X是1。我们有一个函数x是6。如果我们运行这个，结果会怎样？让我们找出答案。所以我们有6和1。基本上，X是两个不同的变量。

它们的处理方式不同，因为这是两个不同的作用域。记住，每当你定义一个函数时，你实际上是在定义一个作用域。所以，全局关键字允许我们修改变量。没错，就是全局作用域。让我们深入看看。

好的，如果你跳过了关于作用域的视频，我们真正要深入探讨的是代码块。我们正在定义一个有自己作用域的函数。问题是Python是词法或静态作用域，这意味着如果我们运行这个，我们有两个不同的变量。然而，这很令人沮丧。如果你注释掉这个。

它将访问全局作用域。因此，我们想要能够访问和修改，这正是全局关键字的作用。所以，首先，现在我们理解了这个基本前提，先来测试一下这段代码。果然，1，1。我们可以在更高的作用域中访问。让我们看看如何修改。

让我们来定义一个全局变量。好，这就行了。其实真的是这么简单。仅仅因为我们把它放在这一行。没有多余的填充。这就是在文件的边缘。这现在被视为全局作用域。让我们深入看看作用域问题，假设作用域问题。

现在我们来定义一个名为count的函数，它将有一个最大计数的数字。现在，如果没有全局关键字，Python会非常非常快地变得混乱。我们来演示一下。因此，我会说，Counter。等于，实际上，little'll做加等于。我们将立即增加这个值。

有时Python会让你这样做，有时不会。其他时候它会完全崩溃，搞不清楚你在做什么。但在我们运行之前，你现在可以看到，它说，未定义变量counter。这令人困惑，因为它就在这里。所以记住我们的对话。

我们正在访问它。但现在它突然说，哦，它没有定义。这令人沮丧。让我们试着运行它，假设我们说，输出。我们只是尝试计数一次看看会发生什么。哦，未绑定的局部变量，局部错误。抱歉，局部变量counter在赋值前被引用。

之前提到的赋值前引用真的给了我们线索，说明这里发生了什么。它所说的是。现在正在创建一个新变量。然后试图在我们实际赋值之前对其进行递增。所以记住，Python的类型有点。好吧，是个谜。我们不知道那是一个字符串。实际上，一旦它被创建，它就是未定义的。所以如果你取未定义的。

如果你尝试给它加一，预期的行为是什么？记住，未定义并不是0。它只是简单地什么都没有，字面上什么都没有。它根本不知道它是什么类型。因此，Python会变得非常困惑，非常、非常快。让我们继续输入，看看这会变得多糟，我们要说。

计数器。如果大于或等于最大值，那么我们就直接返回false。否则，我们就返回true。你看，问题相同。所以在这里，它认为没问题。它实际上知道这是一个整数，但在这里，它却说这是未定义的。这就是我所说的Python会非常快地变得非常困惑。哦，这真让人沮丧。

所以我们要通过说。Logo。Mouner来修复这个问题。注意它有完全相同的名称。所以我们实际上是在说使用名为计数器的全局变量，并在这里赋予它同样的名称。保存它。保存后，你会注意到IntelliSense足够聪明地知道，嘿。这实际上是现在定义的，我们可以开始使用它，而且它知道这是一个整数。

让我们看看全局关键字在这里的实际应用。我将创建一个名为limit的变量。它将是5。我想用这个来递增我们的计数器。所以我说4 x在范围内。我们将使用我们的限制。从那个函数中获取一个变量。使用那个限制。

让我们打印出来。或者打印我们的计数器。为了好玩，让我们打印出来。完成。所以我们可以看到它确实有效。继续运行，果然。哦，我完成了。所以现在一切都按预期工作，这一切都要归功于这个简单的小关键字。在标准实践中，我倾向于避免在函数内部修改全局变量，正是出于这个原因。

比如，假设。我想抓住这个。并把它做成一个完整的新函数。我去。家里，我不需要那个全局变量。我只想要一个名为计数器的变量。我不需要那个。现在，突然，你猜到了，我们又回到了同样的问题。所以现在很难搞清楚我们在谈论哪个计数器以及在什么函数中。

你可以很容易地通过这样做来修复它，但当然。现在你又回到了修改全局变量，这实际上不是一个好的编程实践。当你有疑问时。我们稍后会讨论封装，但你希望封装或使用几乎所有内部作用域的内容，而不是去修改其他作用域。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P21：21）海象运算符 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家。在这个视频中，我们将讨论海象运算符。没错，就是它。海象运算符，这个名字有趣，它源于这种语法。它是冒号和等号。如果你侧着头看，它确实有点像海象。它有小眼睛和獠牙，样子很可爱。

这就是它名字的由来。😊这有点让人困惑，可能会让你脑袋疼。而且为了让它更复杂，你必须有正确的版本，这在Python 3.8或更高版本中才可用。海象运算符允许我们从表达式中为一个变量赋值。

这意味着我们将把一段代码的最终结果转变为变量，而不需要做很多复杂的事情。如果你在想版本问题，记住如果你打开一个终端，有不同的方式可以做到这一点。你可以看到在角落里，我使用的是Python 3.6.9。安装了不同的版本。例如，如果我输入Python，那是2.7。嗯。

我的系统是Python 3.6.9，所以这行不通。我得用3.8。我有3.8.6。如果你没有安装3.8或更高版本，就得去Python官网下载、安装并配置Python 3.8或更高版本。

按照你的操作系统的说明，如果你有问题，谷歌是你最好的朋友，或者你可以在Voros Facebook小组找到我。视频结尾有详细信息。就我们这里的目的而言。

我们会下去选择Python 3，然后选择正确的工作区，应该是Python 3.8或更高版本。突然间，所有东西都开始弹出，问你想安装这个，想安装那个。我不会为这个视频做任何事情。如果一直弹出，我很抱歉。

不过，来吧。我们来深入探讨一下。让我们看看一些常见问题。我在这里放了括号是有原因的，因为这将是你在使用海象运算符时最大的问题。例如，如果我说“why”，然后是“walrus”，我只是想说“walrus”。len（“hello”）。你觉得我们在做什么？好吧，让我们试着打印“why”出来。呃哦。

在IDE中没有图形错误，因为实际上没有安装linter。我可以安装kite或其他类似的工具。但我只是想切换版本，看看它是如何工作的。结果显示语法错误，语法无效。你说什么？我在用海象运算符，而且我有正确的Python版本。嗯。

这就是我所说的，让我们抓住这个。然后把相同的内容放在这里的括号里。我将在最后添加一些注释。只为下载代码的任何人，让他们知道发生了什么。让我们把这个给注释掉。但我不是在最后加了什么吗？好了。

让我们重新运行这个。现在，突然间，我们得到了输出 L 5，它是有效的。但根据 Python 的官方网站，这并不推荐。为什么？因为看这里发生的事情会让人感到困惑。几乎就像我们在调用一个函数，记住，在编程和数学中。

括号内的任何内容几乎都是首先完成的。所以我们真正告诉 Python 的是，当你在阅读这个时，停止你正在做的事情。运行括号之间的所有内容，然后用值五替换掉这些括号。所以这实际上会生成一个名为五的变量。看起来令人困惑。确实是10次中有9次。

这将是你最大的麻烦，就是你忘记在括号里放入内容。所以让我们看一个现实世界的例子，我必须说。人等于。我们将创建一个人的列表。所以我，我的妻子安，家庭狗，大而臭的傻狗。他可能正在下面想要一块零食。

但他没有得到一个，因为我在这里录制视频。可怜的狗。所以我将说如果。然后是海象运算符。我们将仅获取该变量的长度。然后我想说小于或等于 3。然后继续打印出来。我们将打印出 n。有点令人困惑。但这里发生了什么？

我在说 n 是海象运算符等于这个表达式。人的长度。在这种情况下，应该是三，因为我有三个元素。我们在说如果它小于或等于 3，就继续打印出来。但当我们运行这个时，我们被背叛了。它实际上说是 2。怎么回事？为什么它是真的？因为我们忘了加括号，让我们用同样的东西再试一次。

让我们继续。在这里迅速添加括号。重新运行，结果我们得到了三。所以在10次中有9次，如果你在使用海象运算符时遇到问题，那是因为你漏掉了括号。我不喜欢在没有示例的情况下引入新概念。所以让我们来做这个。超级简短，但也超级令人困惑，因为海象运算符确实让人困惑。

好的，我将说 lines 等于，我们将创建一个列表。我们将使用一个函数。可以添加。默认最多五个。这将决定我们是否可以添加到该列表中。我们将说。嗯。漏宝。Lines。我不喜欢这样做，因为我们现在所说的是我们可以修改这个。

但我想确保 Python 知道我们想要这个列表。我们不是在创建某个新变量。这变得有点麻烦。当不确定时，你实际上应该将其作为参数/论据传递。让我们使用 walrus 操作符。让我们释放我们内心的 walrus。我将说 allowed 等于，知道 allowedud 未定义。

所以我们在做的是让 walrus 操作符定义这个变量。所以如果你担心会出现未定义错误，不用担心，这不会发生。但是每当你看到 walrus，就要想“walrus”需要张嘴。如果你看不到这些括号，你将会有一个糟糕的时间。

让我们继续说。这将是计数。而且再次，walrus 操作符。所以我们需要某种括号，但我们将使用一个函数。然后，我们将获取这些行的长度。现在我们要说我们想要最大值。这看起来真的很疯狂和混乱，但我们在这里做什么呢，我们正在创建一个。

两个变量，我们在说 allowed 将是这个代码表达式。如果我的鼠标想要合作，这个代码表达式。而 count 将是这个代码表达式。无论你看到这些括号。你正在处理某种表达式或范围，但通常两者都有。让我们继续打印。

我们要说 F。你可以输入。我们想要最大值，这个是计数。更多。所以我们想要实时告诉用户他们实际上还可以输入多少。我们将回退并说它返回。我们将返回这是否被允许。这看起来超级混乱。但 walrus 操作符的重点是我们减少了代码。

我们现在有一个变量被赋值为一个表达式。我们不需要说类似 aloud 等于某个东西，然后把 allowedud 放入 if 语句中。它会自动为我们完成所有这些。为了进一步让这个变得复杂，让我们做一些我看到人们总是做的事情。

我将说“while”，然后一个函数将返回一个布尔值。我们将循环，直到那个函数说我们不能再这样做。让这些行。你必须写下来。我们要创建另一个变量，叫做 L。我将获取输入。我们向用户。哇，太疯狂了，所以。我们在这里创建了第三个变量。

让我们继续，并打印出我们完成了。好的。突出显示墙的操作，看看我们在这里的小示例。我们正在创建一个、两个、三个变量。每当你看到“walrus”时，请立即想到左边的是我们正在创建的内容。右边，无论“walrus”嘴里有什么，就是我们用来创建它的。

有点疯狂。如果允许的话。计数减去最大值。然后我们将继续进行最大值减去计数的计算，这真的很混乱。我们将返回一个布尔值，并使用这个布尔值，然后在一行中获取这个输入的值。真的。

这确实减少了我们的代码，但也让代码变得稍微难以阅读。所以我想说我们只需输入一些内容。一个，我们可以输入四个，三个，两个，一个。你输入后，它会给我们一个整齐的小列表。这里的主要收获是，海象运算符非常方便，但也可能非常复杂。

每当你看到海象运算符时，一定要立即想起下方的牙齿。你需要口部，也就是这些括号。而括号内的内容将被赋值给变量，因为你实际上是在将一个表达式放入变量中。

你还需要 Python 3.8 或更高版本，否则你会遇到很多奇怪的错误，因为早期版本的 Python 根本不知道你在说什么。简而言之，这就是海象运算符。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P22：22）文件夹操作 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好，我是Brian，我们现在要讨论Python 3中的文件夹导航。在我们开始之前，剧透警告，有多种方法可以完成某事。这在每种编程语言和每个计算机操作系统中都是如此。基本上，随着计算机的发展，编程语言和人们用来创建程序的平台也在不断演变。

它们在幕后变得复杂无比，但在前端使用时却变得极其简单。但它们也隐藏了很多复杂性，这导致了很多困惑，特别是新手，因为他们会问做某事的最佳方法是什么。简短的答案是没有一个。使用对你有效的方式。我们将讨论几种情况。

但你会看到评论区里的人说，是否使用那种方式。相反，使用另一种方式，再次回到黄金法则，使用对你有效的方式。

让我们深入了解一下！

首先，我们要做的是导入一个模块。你可能会说等一下。我以为我们要处理的是导航文件夹。我们将了解文件夹是文件系统的一部分，它可能变得非常复杂，而很多内容都集成在Python的核心中。

但我们需要与他人的代码一起工作。其中一些代码已经集成在Python中。我们只需告诉Python我们想使用它们。因此，我们将导入OS模块。如果你在想模块是什么，那是一组我们可以使用的代码。

其他人已经编写了这段代码，我们可以随意使用它。所以首先，导入OS，这样我们就导入了一个模块。一旦模块被导入，我们就可以开始使用它。因此，我将创建一个变量，叫做D。代表当前工作目录的缩写。

如果你在想那是什么。每个应用程序都在某个目录中运行。每一个。它们都是你系统上的某个文件。那个文件位于某个目录内。如果你使用的是Linux、Unix或Mac，它在根目录中，看起来像这样，仅仅是一个斜杠。如果你在Windows环境中。

它看起来会像这样。现在。这是OS的根目录。但很可能你并不在根目录中。你在OS的某个深处。所以让我们弄清楚我们实际在哪里。因此，我将说打印。让我们格式化一下。我将说当前。

我们只是想知道我们在操作系统中的位置。有时这就像是在深蓝色的海洋中导航一样，我们不知道自己在哪里。所以我们将获取当前工作目录。或者我们可以使用已经提取出的变量。现在，我必须指出，这是当前目录。

这并不意味着每个程序都在这个目录中运行。它只是表示我们的程序正在运行的目录。所有其他程序都在不同的目录中运行，甚至在同一个目录中，这会让人感到困惑。好吧，在我的虚拟机上，我们当前在/home/root/shell中，这是我当前的帐户。

slash code slash Python 3。所以你可以看到我们不在根目录中，而是在几个级别下的子文件夹中。

假设我们不太喜欢这个文件夹，只是想用不同的文件夹看看能否实现，那么我们就来更改文件夹。我必须输入O S . C H D，代表更改目录。C W D是获取当前工作目录。

我们将进行C H D或更改目录。掌握术语似乎有点混乱。现在，你实际上可以硬编码这个，比如说我们可以使用home . Obs files，某些东西，或者如果你在Windows上，它就像C \，随你所需。或者你可以使用所谓的当前路径，这意味着你没有任何路径在其中。

这有点高级，我将使用dot dot。你可能在想这个dot dot是什么意思。它实际上代表当前目录及其父目录，因此我们实际上是向上移动两个级别。这听起来有点混乱，但我们来看一下。我将抓取一些代码，打印当前的目录。

我们将说O S get current working directory。注意我们没有重用D，我将抓取这个以备将来参考，让我们运行这个。我们又上升了一层，因此我们在Python 3，现在在code中。我们只是简单地上升到父目录。所以当你看到dot dot时，实际上我们就是在上升一层。

我们将在这里重用这个变量，我将说OS . C D，并跳回到该目录的字符串表示。抓住它，粘贴，然后清除一下以防万一，运行。我们从Python 3上升到父目录，然后再回到Python 3。所以Python 3上升到父目录再回到Python 3。导航文件夹结构非常简单。

如果你知道路径，那真是太简单了，但你只需输入一个字符串，咔嚓一下就可以了。现在，这是假设它确实存在。我们将在未来的视频中讨论如果它不存在该怎么办。但请知道，如果你尝试给它一个不存在的东西。

你会过得很糟糕。

记得我开始这个视频时，我基本上说过有多种方法可以做同样的事情。我们将开始查看其中一些。第一个是列出。这可能是最简单的方法。所以我们将说 4 F 在 O S。记得我们添加的那个导入吗？我们将去。任何 Drmerel，列表。好了。

这是一个函数。我们必须有括号。我们可以指定目录，我们可以使用当前目录。现在，如果我们只是打印出来，它就很好。打印，看看这里发生了什么。没什么特别的。它只是有一个文件加上这个小点 VS code。VS code 就是这个文件夹。

其中有另一个文件。所以我们正在获取文件夹和文件。如果你的目录中有很多文件，你会看到它们全部。很有趣。那么我们如何实际确定每一个是什么呢？让我们把这个美化一下。注意这只是 Ithon 3-22，脚本的名称，但我们没有获取完整路径。

让我们继续说，王子。让我们格式化一下。路径。这就是下面评论区的人们开始互相争论的地方。我会说哦，路径，我想获取 A B，S 或绝对路径。这将告诉我们绝对路径，下面某人可能会说。

你为什么不使用真实文件或类似的东西？再说一次，这是个人偏好。这是我想要的。让我们继续运行，哦。哎呀，这些敏感性又让我受到了影响。好了，现在它按我们预期的工作，路径给出了完整路径，而不仅仅是文件的名称。

所以这里的区别是我们有文件名，然后我们有绝对路径。让我们把这个变得稍微复杂一点，我想让 OS 做 F。让我们确保它是一个目录。现在我们只需打印出来。我们可以采用相同的模式并重复它。所以我们将说如果它是一个目录。

只需打印目录，然后无论是什么。如果它是一个文件，它会继续打印文件及其内容。让我们再加一个，仅仅是为了好玩，那就是链接。你可能在想链接是什么。这是文件领域中的一种特殊符号，基本上说的是我不是正确的那个。

转到这个其他位置。它实际上只是指向另一个位置。你可以称它们为快捷方式或符号链接，这真的取决于你的操作系统。注意，这在 Windows 6.0 之前总是会返回错误，因为 Windows 6.0 之前没有符号链接。你可能在想，Windows 6 是什么。

我们是否收到了 Windows 6 的广告，这是 Windows 版本管理的方式，微软有时候就是有点傻。但基本上，如果你有一个旧版本的 Windows，它永远不会返回 true。让我们继续保存并运行。你可以看到我们的路径，它是一个文件，然后我们的路径和一半，它是一个目录，所以它按预期工作，我们现在可以确定它是一个文件还是目录，并且我们可以获取绝对路径。

所以，Listister。连同 OS dotpath 实际上相当复杂，并且可以完成你可能需要的绝大多数功能。稍微倒回一下视频，你会记得我说过，嘿，随着计算机变得越来越复杂，代码变得更简单，但细节却变得有些模糊，而这是一个完美的例子。Scanander，这在 Python 3.5 或更高版本中出现，我们一直在使用 Ler。你可能会问自己。

我们为什么需要 scanander。Lister 似乎完成了我们想要做的几乎所有事情。好吧，scanander，这里最大的卖点是它被封装在一个类中，并且速度更快。虽然我只想说，除非你在进行一些高编码，否则你真的看不到巨大的性能提升。

你可能会感到困惑，想知道你为什么要使用它。但如果有疑问，我们就深入研究一下。我将说 scanander，然后我们来打印出来。K，我在里面有 E。当我运行这个时，你将看到一些神奇的事情发生。Ta，它说 D entry，然后是名字。这意味着什么呢，这是一种奇怪的语法。

每当你看到被括号包围的内容时，这意味着 Python 正在给我们一个类。我们将在未来的视频中讨论类。但现在，重要的信念是，类仅仅是一个自定义数据类型。它实际上是别人定义的对象的蓝图。

我们将在不久的将来学习如何构建我们自己的类和蓝图。但现在，你真正需要理解的是，我们有一个名为 DR entry 的自定义数据类型。说到数据类型，我们指的是像字符串、数字、列表以及类似的东西。它的条目只是另一种数据类型。

让我们来处理一下这个。我们要说 print。这就是我所说的，你会在复杂性中迷失一点的意思。我们有点困惑，想弄清楚。我们需要打印什么，所以你必须实际去查阅文档或观看这个视频的其余部分。

我们要说 E dot。我们想要名字。接下来获取路径，所以我将抓取这个。因此，整个目的就是让生活变得更简单。但与此同时，Scner 的速度确实比 Ler 快。Ta，现在它在路径中工作。让我们继续。并且。运行一个小问题。当我说运行一个小问题时。

我们想要获取目录、文件和符号链接，和之前的方式差不多。所以我会抓取这个。这就是这里会变得有些令人费解的地方。如果我说 E 点是 D 是文件是符号链接。你会觉得这很简单，然后说，好的，试试这个。但实际上我们在背后微妙地创造了一个问题。

我在想有没有人能真的发现这个问题。让我们先抓取这个名字。现在我们进行了一些修改。O quiz，有人能发现问题吗，举手？

那么这里发生了什么？他们的 entry.dotvscode，我们说 dotvscode 实际上是一个目录。看，它就在那儿。但它却打印出 D 文件和链接，等等。它不可能同时是三者。那么这里发生的事情是我们实际上在调用一个函数。或者至少我们应该是。我想演示这一点，因为有人可能会遇到忘记加括号的问题。

然后他们得到了奇怪的结果。再运行一次，你会发现现在它按预期工作了。但它实际上并没有抛出任何错误。这就是令人困惑的地方。所以如果你在扫描中遇到奇怪的结果，确保你放上了那些括号。好的。

好的，让我们来谈谈 Gob。我提到 Gob 有多种方式，因为到目前为止我们已经介绍了另外两种方法。TheBob 代表第三种方法，而 Gob，虽然听起来很糟糕，但实际上真的很酷。简而言之，使用适合你的方法。我们之所以讨论 Glob，是因为这个原因，我在这里放了链接。一个典型的 Stack Overflow 问题，就是，如何扫描所有文件夹和子文件夹，或者说是递归的。

扫描。如果你稍微理解一下递归扫描是什么。我们在这个 Python 3 文件夹中，要跳到上一级目录。我想知道这些文件夹的所有内容。如果其中一个文件夹里面还有一个文件夹，我想进入那个文件夹，依此类推。

我们将进行递归扫描。现在，在某些语言和框架中。这并不是一个简单的事情。但 Gloob 让它变得极其简单。所以我们需要做的第一件事是导入 Gob。

我不知道你为什么会想要一个 glob，但无论如何。我希望他们能给这个起个更好的名字。所以我们要更改目录。我们要上到上一级目录。所以我们要进入一个更高的目录。现在，我要在这里定义一个变量。这个变量将是 O S。然后我们将获取当前的。

我会说获取当前工作目录。现在我们实际上要处理 G。我会说 4。文件名。和 G。gllo 会变得非常混乱，我们不会深入探讨 Gob 的所有部分，但要知道你可以用 Gob 做很多不同的事情，实际上只是触及了表面。所以我们会说 Gob，Gob。听起来就像是在酒吧里和一个醉汉交谈。Gb，glob。

不管怎样，blob，我们想要给它一个路径名。我们将在这里得到一些帮助。所以半个名称，我会说，等于我们的目录。我们将提供一些通配符。我们需要告诉 Gloob 要做什么。我会说。任何东西后面跟着任何东西。每当我们看到星号，那就是我们的通配符，然后我们想要递归。

等于 true。所以我们告诉 Gb。不仅仅是这个目录，还有里面的所有目录。继续施展你的魔法。继续以格式化的方式打印出来。我想要将其 glob 化。像是现在卡在我脑海里的，gal glob，不管怎样。你知道，可能有一群程序员围坐在房间里说我们做了这个非常棒的东西。

我们称之为什么呢？我们就称它为 Gob，然后他们似乎认真对待了这个名字。好了。GloB 有很多内容，你可以看到我在里面还有其他项目的代码，包括 C++ 文件、make 文件、文本文件，以及我做过的其他 Python 脚本。诸如此类。所以 Glob 现在已经读取了所有这些内容。

为了展示有多种方法来做到这一点。我们再换一种方式来做。所以我会说 4。让我们走。当前路径。Ooldders。和文件。在 O，我们的 gobu O 进行遍历。基本上，我们会告诉操作系统在我们当前目录中走一圈。现在，记住。点点是父目录，点是当前目录。所以我们只会说 O S。

锁定当前目录。我要继续说 4。文件在文件中。这并不是一个递归的操作，但这里给你一些细节。假设我们继续打印。让我们继续处理这些，我会说，哦，路径。那连接。所以我们要做的是将所有这些连接起来。我们想知道当前路径。

和文件。如果你对我在哪里获得当前路径和文件感到困惑，它就在这里。所以实际上，OS S Walk 返回的是一个元组。我相信我们只是从中提取那些元素，然后使用 OS 路径连接将它们连接起来，使其看起来像这样。相当有趣，也很容易理解。所以总结一下，有，嗯。

实际上有多种方法来做几乎相同的事情。每种方法都有自己的优缺点和小问题，以及不同的实现方式。使用适合你的方法。这个视频涵盖了如何更改文件夹，Ler，Scer，Gloob，以及 O S 遍历。你会在其他人的代码中看到所有这些。我们之前在谈论递归，它有自己的一系列复杂性。

我们将在未来的视频中也会涉及这个主题。😊这是初学者的指南，我们只是触及了我们能做的表面。！

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P23：23）写入文本文件 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好，我是布莱恩。我们将讨论读取文本文件。这个过程非常简单，任何人都能做到。因此，如果你对文件系统感到害怕，不用担心，这非常简单。让我们深入探讨一下。

首先，我们先获取一个文件名。你的操作系统里有很多文件，但我们想要读取一个文件而不干扰任何其他应用程序。所以我们要读取自己。也就是说，这个你在屏幕上看到的文件。我们要读取它。因此，我们必须将这个脚本的文件名获取到。我们该怎么做呢？好吧。

有几种不同的方法。我们将展示几种方法。所以我们将说 OOS 和 cis，我们将导入这两个模块。你只需放一个逗号。我们可以通过一行代码导入模块。我只是想一次性完成。让我们说，打印。

你会在互联网上看到很多这样的情况。有人会说类似的话。每当你看到双下划线，它就像是 Python 中内置的一小段信息。变得稍微复杂一点，但只需理解双下划线意味着内置。你看到这个。

我们已经得到了脚本的完整路径。现在，这里有一个问题。问题是，这可能并不总是存在，有时你会遇到这种情况，这根本不起作用。所以，再次回到我们之前的讨论，总是有多种方法可以做到这一点。因此，我们将展示我认为更好的方法。我们将使用参数。

现在，关于参数，通常并不是好事。通常你希望避免争论。但在这种情况下，我们想直接进入它们。所以我们将打印出内容。我们想要 Arg B。这到底是怎么回事呢？在后台，当 Python 调用你的脚本时，这个家伙，Python da da da。它实际上会发送给你一个参数列表，你有过这样的经历吗？

在你的文件浏览器中，双击一个文件，你的操作系统知道用哪个程序打开它。这些是参数，所以它会调用你的脚本。还有另一个参数，它像是逗号，然后是你想要处理的内容。所以只需知道 Python 将发送给你的第一个参数是，嗯，就是你的名字。

你当前正在运行的内容，让这变得超级简单。现在，让我们继续说。我们想获取完整路径，只为确保。我们想要操作系统路径，我们想要ABS路径。现在。很多评论的人会问，为什么使用ABS路径或绝对路径。为什么不使用另一个。我们这样做只是为了演示。

我们还没有深入复杂性。我会做一个完整的视频，讲述不同类型的路径，它们的含义，以及哪个最好等等。但现在，我们仍然是新手。我们将只处理ABS路径。

然后我们将开始读取这个文件。让我们继续运行这个。结果就是这样。所以它只是简单地给我们返回了一个参数列表。第一个或零位置总是当前运行的脚本。

我真的想演示的一件事是，它是否存在。如果我们正在运行自己的文件，我们知道它是存在的，如果我们要运行这个并读取它，我们知道它存在，因为我们当前正在编辑它。但仅仅是为了好玩，我想讨论一下如何确定文件是否存在。伊恩，这就是存在主义问题。

文件是否存在。我们是否存在，Intering。所以，不管怎样，让我们说如果。然后让我们继续，假设不。哦。问一下路径。Exists你可能想知道不是什么。不类似于某种东西。与之不等，它是那种的简短缩写，但我只是想说如果不是OS路径存在。那么我想给出我们的文件名。我们在这里得到了它。如果它不存在。

然后我想说嘿。Rt。让我们打印那个文件，不绑定。因为如果我们尝试处理一个不存在的文件，我们会收到一个错误信息。最终我们会得到像这样的结果：文件未找到错误，这将在后面详细说明。

所以如果你只是一直在进行，并且给出了错误的文件名。你会过得很糟糕。但现在我们知道文件不存在。我们不想继续。所以我将说退出。我必须给它某种退出代码。我就说一个。让你感到好奇。

正常退出代码是0，然后你会给出某种错误信息，比如访问被拒绝或其他。但通常供应商会有不同的退出代码。所以我就说一个。这样我们可以告诉程序，嘿，发生了一些不好的事情。但因为我们正在读取自己的文件，它应该能正常工作。所以让我们运行这个。确实运行得很好。

让我们继续这个并给它一个我知道的名字，简单地说就是不在那里。Nope。txD。让我们再次运行这个。文件未找到，然后它退出。运行得很正常。现在到了令人困惑的部分，我们将真正开始处理文件。我们将从打开文件开始，如果在这个过程中你遇到文件未找到错误。

这意味着你有错误的文件路径，你没有遵循说明。或者有些地方出了严重问题。所以我们要做的是我们将说 f 等于，我们想调用打开。听起来非常简单，确实是。现在我们只需给它一个路径。现在来点混淆，我们必须给它一个所谓的模式。

现在我要做另一个关于模式的视频，但这一个将只涵盖读取文本文件。所以我必须说。二。只代表读取，我们将读取纯文本。但这个过程将会出去。在你的操作系统中。确保那个文件存在，如果没有，你会得到一个文件未找到错误。

然后它将尝试打开文件进行读取。并且它会将光标放在文件的零位置。它会把一个文件对象返回给你。所以这一小行中，实际上有很多复杂的内容。

现在我们已经打开文件，让我们继续读取一行，我将说行等于。我们将使用那个文件变量，并且我想说我们读取。你注意到我们有很多选项。读取、读取一碗、读取行和读取多行。我们想要读取多行。所以我们只读取一行。

让我们继续打印出来。保存 Ron 并读取一个文本文件，因此它读取了我们文件的第一行。非常，非常酷，你也会注意到它在这里放了这个小返回，因为猜猜看，那里有一个返回。在这个结尾，有一个不可见的 slash R slash n 或 slash N。具体取决于你的操作系统。只需知道。它还会包括这个。

所以当我们打印出来时，我们必须将其去掉。但是我们已经成功读取了一行。现在，如果读取一行很酷，你会真的喜欢这个。我们实际上可以控制这个。我将读取一定数量的字母。所以我将说 cares 等于 F.dot.read。

请注意，它想要一个数字，所以我们将读取 10。让我们继续打印出来。我将实际格式化这个，称为 cares。我们将放入星星。然后。我们实际上在读取的内容。所以如果你看看我们的文件，这里写着读取文本文件。现在光标在这里，让我们运行这个看看会发生什么。

你看到它说 cares star，然后有一个换行符。获取 A FiI，然后是 star。因此，我们实际上控制了我们读取了多少字符。我想这样做是为了真正展示这里的复杂性。请注意，我们在这里切掉了这个强制换行，我们可能并不想要它。

如果你使用read函数，你会遇到一些奇怪的事情。这就是为什么我在处理文本文件时倾向于使用read line。现在，非常细心的人会注意到，随着我们的阅读，事情在向前移动。这意味着我们读取了一行。然后我们读取了若干个字符。它说，get A FI。

它没有重新开始阅读。那么这里发生了什么。随着我们的阅读，有一个不可见的光标，就像在这个文本文件中一样。你看到那个光标就在那儿。它总是从0开始。因此，隐形中那里有一个0。它就像列表、元组或任何类似的东西。它是一个0为基础的索引。

它将从0开始。随着我们读取，它会向前移动。所以当它说read line时，它会移动到那里。当我们说ray 10时，它会移动到那里。因此它实际上会计数。这个不可见的光标将不断移动。我现在想做的是显示位置。我们如何确定自己在文件中的位置。

这有点高级，可能在初学者阶段对你来说不太明白。但当你进入高级文件处理时，你需要能够在文件中前后移动。所以我想相对较早地介绍这个概念。让我们说print。我们将格式化这个，让我们看看。位置。我希望他们称其为位置。

但他们称之为tell。所以我们将称之为tell函数。它将告诉我们位置。现在，我想说of。因为我想知道这个文件实际上有多大。所以说O S。我们将调用统计信息。我们将使用之前的S文件变量。

我想知道S T。下划线大小。如果这让你感到非常困惑，有时intelligencetelst会帮助你，如果你在使用像kitite这样的高级telece系统。但你可以浏览文档，或者你可以信任我。O，执行stat。文件名ST下划线大小，所以我们得到的是一个整数。

现在，大小是文件的字节大小，让我们运行这个。所以我们的位置是31的529，随着我们添加更多内容，你会看到这个位置变化。即使它是一个注释，文件的大小在增长，让我们再运行一次。足够了，5，38。移除那个和530，因为我们删除了一些内容。这就是你确定自己在文件和文件大小的方法。

这里的主要 takeaway 是，在我们阅读时，那个不可见的光标在移动。现在，我想把它放回最开始。所以我们将调用seek。再一次，这是一个更高级的函数，但我想很早就介绍它。这始终是8。0为基数。记住我们关于列表、元组和字典的对话。

它总是从零开始的索引。所以我会说我们的文件对象执行 seek。我们将要定位到 0。现在，如果你注意到我在打字时。你会看到这个可寻址的。有些文件是不可寻址的，因此如果你在做一些自定义工作时可能会出现问题。但就我们的目的而言，它应该工作得很好，我们只是告诉它去哪里查找。

所以 seek 0 会告诉我们返回到最上面。如果我们在工作，只是在阅读、阅读、阅读、阅读，seek 0 会说，回到这个零点。让我们运行这个，从图形上看没有效果，但如果我们再读取一次。你会看到它实际上重新开始，就像我们即将演示的那样。

现在我们理解了这个看不见的光标和定位，并且知道如何控制它的位置。我们已将其设置回零位置，现在让我们读取所有行。我在这里放入这一长行，我们将打印出来，以便将其分开，这样我们就可以看到它的实际效果。我想说的是 4 L 和 F dot。读取，我们想读取行，注意有 read line。

这将进行单行读取，而 read lines 将持续不断地读取。我们将逐行读取整个文件。我想说打印。它将返回给我一个字符串。所以我想说 L，我们想要剔除它。现在。strip 的作用是移除任何多余的空白。因此，这些硬回车就像这里。

我们是如何得到这些小东西的。返回值，如果我们不这样做，它将被剔除。我们会得到一些非常奇怪的结果，我会演示给你看。所以我们来运行这个。看。这儿停下来了。所以这是我们文件的开始，它一直延续到现在，非常酷。现在如果我们把这个注释掉。然后只抓取这个。这就是我所说的，如果你不剔除它，你会得到一些奇怪的结果，因为打印自动会加入。

回车换行符。让我们清除所有这些。你可以看到现在每行之间有了额外的空白。因此，这就是我们需要调用 strip 的原因。让我们把它重新放回原来的样子。今天。它就是这样工作的。好吧，系统资源 101，任何你打开的东西，你都必须关闭。

所以我们现在要关闭那个文件。把文件想象成在寒冷的日子里的一扇门。你打开那扇门。你让所有的天气进来了。现在你想关闭它。所以关闭操作做的事情有很多，但就我们的目的来说，它非常简单。它允许其他应用程序与之协作。如果我们打开这个，而底层操作系统锁定了文件以进行读取。

这意味着没有其他人可以对其进行修改。别担心，简单得离谱。F close。总是，永远。每当你打开一个文件时，关闭它。你不想有所谓的悬挂资源，现在 Python。大多数情况下，当你的脚本完成时，它会自动关闭文件。但不要依赖于此。有时你会看到，如果你打开一个文件却忘记关闭它。

它将永远保持打开状态。这非常令人沮丧，离成功如此之近。你不会看到任何图形上的变化，但现在它关闭了那扇门，以便其他人可以打开它并做他们想做的事情。快速回顾一下，这段视频我们讨论了读取文本文件时文件系统的复杂性。文本文件与二进制文件是不同的。

我们将在未来的视频中讨论二进制文件，所以我们这里只讨论普通文本。我们谈到了导入，获取当前文件，确定文件是否存在，打开文件，读取一些行和字母，以及如何在位置之间移动所有行，以及如何实际关闭文件。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P24：24）二进制文件操作 - ShowMeAI - BV1yg411c7Nw

大家欢迎回来。我是布赖恩，我们将继续我们的Python 3之旅，我们要谈论如何写入文本文件。这是纯文本，而不是二进制。我们将在未来的视频中讨论如何写入二进制文件。我们将利用上一个视频学到的知识，使用函数进行过度简化。上一个视频有点冗长。我想让生活简单得多。

我们的首要目标是简化模式的使用。现在，我们在谈论什么。我们将覆盖两种不同的模式。我们要谈论写入和追加。它们做的事情完全不同。但我们可以使用相同的代码。那我们就来写一个函数。我将说到文件。还有。

让我们保存文件名。模式。数据，我听到我身后有割草机的声音。抱歉麦克风录到了。只是有点。Covid-19。对此你无能为力。我的邻居喜欢一天割草100000次。所以我会说打开。我们要打开那个文件名。我们需要模式。现在，记住。

在上一个视频中，我们用读取文本或R模式打开它。我们将使用W和A。但它们可以使用相同的代码非常相似地工作。正如我们将要演示的。我将说4我在范围内。我们就说，环，让我们选一个数字5。然后我们继续写出这个数字。我想说那个数字的字符串表示形式。

如果你不这样做，你将会收到某种错误信息。继续吧。在那里加一个小冒号。连同数据。让我们继续添加一个换行符，行结束符。/lash R/，这些就是我们谈到的转义字符，当我们在字符串La中时。实际上，我们要做的就是使用STR将数字的字符串表示形式写出，将其从整数转换为字符串。

然后我们将添加一个冒号，不论我们处于什么数据，然后RN数据将作为参数传递给我们的函数。现在。确实存在做类似事情的倾向。你会看到这个flush。我会将其注释掉。flush的作用是什么，为什么人们在他们的代码中使用它。当你写入文件时。

背景中有一个看不见的缓冲区。我应该说是Python有。那个缓冲区会填满，因为你添加的速度比它写入磁盘的速度快，特别是如果你的硬盘较慢。想想嵌入式系统，它们会变得非常缓慢。你实际上不需要调用flush。如果你要。

完成文件操作后请关闭文件，关闭时Ithon会自动调用此操作。然而，如果你在进行某种操作，比如顺序写入，想要分块写入文件，就需要定期刷新，以确保数据被写入磁盘。

我想把这个放在那里，因为我知道有人会问，为什么不刷新内容。你不需要这样做，因为关闭会自动调用这个操作。我讨厌这个名字，但同时，这让我感到好笑，因为你要刷新它。我总是想象着看着一个马桶，尽管这看起来令人作呕。

你就像是把数据扔进马桶然后冲掉。但这实际上是将所有缓冲区的数据冲到硬盘中。

我们将讨论两种模式，第一个是写入。当你听到“写入”这个词时，写入将会覆盖，这意味着它将完全擦除现有文件，并从头开始。在执行此操作时，你需要小心，因为如果你有敏感信息或者希望保存的内容。

这将彻底消除该数据，数据将不再存在，也不会在回收站中，永远消失。因此，在这里你需要小心。我们将要写入文件，假设我需要一个特殊的变量名，比如IL name，就这样。我们将调用这个文件功能，文件名的模式为数据。

那么，让我们继续执行这个操作。我们将调用我们的函数。我们将重用变量文件名，模式将切换为W（写入），我们将输入的数据为“Hello”。记住，写入将会覆盖，完全摧毁原有内容并重新开始。

我们要讨论的另一个模式是追加。现在，追加将会添加内容。因此，写入将会覆盖，而追加将会添加。这会打开文件，看到……记得我们谈过的寻址，移动文件中的位置，它会移动到文件的末尾，然后开始添加内容。

这就是我所说的简化模式使用。我们可以直接将其复制，然后简单地将其更改为A以进行追加。接着我们再将其改回ao。因此，在这里将会调用写入，它会彻底消灭文件，重新开始，然后……最多到5，它将显示“hellello world”。接着我们将调用追加。

它将添加内容。好的，这里的直接目标是写入aend，但我想要重新读取这个文件。因此，我想使用并导入，将其放在文件的最顶部。这不是强制性的，但几乎可以说是行业标准，应该把导入放在最上面。

而不是直接在这里添加，实际上你可以。但让我们把它放在顶部，这样。我们刚刚处理的任何内容，使用OS时也会得到它。如果我们决定回去修改这些函数并使用，我们就不必意外地多次导入它。因此，总之，总是把你的导入放在文件的顶部。

我们将说de，让我们继续读取文件。我需要一个特殊的变量名。某个真正突出的东西，比如，我不知道。文件名。我们可以把它命名为fuzzy button kitten或者我们想要的任何名称。好吧，我们要说如果没有，我们想要O S。让我们继续说路径。那存在。我们只会确保我们尝试读取的文件确实存在。

否则我们将遇到一些糟糕的错误。现在，我不想退出。我只是想直接返回这个函数，而不是终止整个脚本。现在，我想说。我们要打开这个文件，这就是使用Python处理文件时的简单程度。给它一个模式。因为我们打开了某个东西，让我们继续。在我们做其他任何事情之前。

现在关闭。在打开和关闭之间，我们可以做任何想做的事情。例如。我可以说4。A line。在F dot。Readed lines。像这样。或者如果我们真的想要过于简单化。我们可以一次读取整个文件。而我们只会调用。现在，剧透警告，如果你在一个非常大的文件上这样做。

否则你会有非常糟糕的经历，因为你可能会耗尽内存，你的小应用可能会崩溃。例如，如果你有3GB的内存。你试图读取一个30GB的文件。它根本无法做到。它会在那里待三小时才崩溃，但最终会崩溃。这就是为什么我们使用像or line in read lines这样的东西，因为它一次读取一行。

不要全部都读。好的，我们警告一下关于在一个函数中阅读全部内容。如果你有一个巨大的文件，尽管如此。我们就这样留下它，纯粹是为了演示目的。因为我们将处理一个非常小的文件。我们将看到它的实际应用。我会说我的文件。我们可以把它命名为任何我们想要的。好吧，让我们命名为Ho dot C。

X T。首先，我们要写这个文件。只是调用我们的函数。现在。让我们继续结束文件。然后让我们继续读取文件。我们将代码拆分成函数是有原因的，这样我们就可以重用这段代码。你在编程中会经常听到“代码重用”这个术语。

与其硬编码文件名，然后调用，或者说为每个文件重写这个函数，不如使用一个变量来重用代码。所以让我们继续执行这个。你看到它说。0到4，Hello world。然后这里有一些其他内容。Hello again。现在让我们来演示一下。

所以让我们去掉这个附加。让我们只做对的事。注意我们已经有一个文件在那儿，我们实际上可以打开它。它看起来就是这样。让我们去掉那个附加，看看我所说的对的文件将会覆盖。这个就是为什么它如此危险。你好世界，从0到4。如果我们重新打开文件。

你可以看到。你好世界，所有的再次问候，已经消失，因为它抹去了那个文件并重新写入了它。现在我们可以这样做。它回到了我们想要的方式。再次和再次。主要的收获是写入将会覆盖，且将寻址到末尾并追加。我们可以让读取文件变得极其简单。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P25：25）读取文本文件 - ShowMeAI - BV1yg411c7Nw

大家好，欢迎回来，我是布莱恩，这是第25集，关于处理二进制文件。首先，什么是二进制？我们之前处理过纯文本，但什么是二进制呢？听起来有点疯狂，几乎像是《黑客帝国》中的东西。残酷的现实是，二进制确实是你不太想直接处理的东西。

我会解释为什么要去扩展选项卡。让我们安装一个十六进制编辑器。现在剧透一下，你并不需要这个特定的十六进制编辑器。你甚至不需要我正在使用的这个 IDE（VS Code），任何旧的十六进制编辑器都可以。十六进制就是十六进制，只要你能查看实际的十六进制表示就行。

一旦安装完成，我们就会返回文件。我们将处理当前的这个文件。我们右键点击。从这里，我们将选择用我们刚安装的十六进制编辑器打开。你可以看到我们有十六进制编码的字节，还有解码的文本。这就是我所说的，解码。

这是计算机处理的内容。这是机器读取的内容。这里是我们通常处理的纯文本。例如，# 的十六进制是 23。然后是 57，对应大写字母 W，6 F。想象一下，试着把你的名字以十六进制方式输入，那会很长也很烦人。所以当我们谈论二进制时。

我们讨论的是计算机处理的原始数据。这并不是我们想直接处理的内容。我们希望处理的是该数据的表示。因此，当我们提到二进制时，这就是我们所说的。我们想给计算机提供二进制数据的表示，让计算机为我们完成所有艰苦的工作。

我们不是在处理纯文本。我们可以处理代表纯文本的单个字节，但我们并不在处理纯文本本身。

好的，我们需要离开二进制的世界，回到文件的世界，这就是我们一直在处理的文件。你会记录一些笔记，它只会说安装微软文本编辑器扩展，实际上不一定需要是微软的那个。

但接下来是一些关于如何处理它的一般说明，以防你在跟随这些视频。现在我们要添加一些导入，在继续其他任何内容之前，我们需要先完成这一步。所以我要导入随机模块。这里的随机是指我们并不是随便导入什么，而是导入一个名为 random 的模块，它将帮助我们生成随机数。

我们将导入操作符模块。这有一个名为 equals 或 EQ 的小函数，我们将用它来比较两个列表，以确保我们生成的信息以及我们保存和加载的信息都一致，且一切按预期工作。

让我们来处理那个随机模块，我们将创建一些随机字节。让我们创建一个函数。我们称之为随机字节。从这里开始。我们将有一个参数叫做 size。让我们创建一个列表。这个列表里什么也没有。现在，我们将说 4 x 在范围内。

我们想要一个范围等于大小。我们从我们的参数中获取这个值。让我们继续附加 Ar less，所以。灯光。现在我们想要实际说随机。我们需要一个范围。所以我必须说 R range。如果你对字节了解一些，它通常从 0 到 55。你可以做一些疯狂的事情。

我们将坚持使用 0 到 255 的标准。非常简单。任何人都能理解，我们不是在讨论某些灰度编码方案或其他任何东西。就是 0 到 255。我们只要这个。从这里开始。我们将返回。字节。所以我们将返回那个列表。所以随机在这里将生成一个随机数。

在 0 到 255 之间的范围内。所以我们将有最多 256 个可能的数字。现在，随机。你可以做种子和所有这些其他花哨的东西。但我们不打算这样做。所以它将使用当前系统时间作为随机数种子。如果你想要一些超级安全的东西，你需要做些不同的事情。

但我们暂时会将一切保留为默认设置。现在让我们打印出来，确保我们得到了，你猜对了某种随机数字列表，所以说 de 并显示字节。继续。我们将在这个视频中介绍几个概念。

有些东西我们还没有讨论过。所以我会创建一个字符串。现在。我想乘以这个。所以我们会说。乘以 20。看起来有点奇怪，但我们要做的是说把这个字符串做 20 次。所以我们说这个字符串乘以 20。现在我们将继续进行。

我们将使用枚举函数来处理这个字节列表。我会说 Thor 索引。那么 item。在。枚举，枚举将把整个对象拆分成多个部分。我们可以使用的东西，你看到那里说的枚举对象会生成包含从开始计数的对，默认为 0。所以我们会告诉它处理那个字节列表并进行枚举。我们不想从 0 开始。

我们想从1开始，因为人不是计算机。我们喜欢从1开始，而不是0。我们只是想让这个可读。现在我们将继续格式化输出，并假设。索引。等于。我们想要这个项目。现在，我们一直在使用十六进制编辑器。

我想给你展示一个简单的小技巧。我们可以简单地说hex。我们想要为这个项目制作一个X表示，以便我们可以稍后将其与十六进制编辑器进行比较，确保一切完全按照我们期望的方式对齐。

我将抓取那个小打印函数，回到下方。确保它对齐，这样我们就不必在每个循环中都做，但在for循环完成后。让我们测试一下。所以我将只。抓住我们的随机字节函数。哦，抓得太多了，显然。来了。

现在我们就假设10，仅此而已，没有太疯狂。现在，我想继续显示。那个列表，让我们看看这是什么样子。所以当然，我们得到了一个列表。它是从1到10的人类可读，起始于1，在底层其实是0。但我们使用这个小开始来递增它。

然后我们有该数据的十进制和十六进制表示。

好的，删除了我们的测试，然后我们现在将继续，写一些字节。现在我们必须以稍微不同的方式进行，因为我们一直在处理纯文本，而我们正在处理二进制文件。这不是人类可读的，所以我们必须告诉Python我们不想让人类参与，我们希望计算机来处理。因此，我们将说def。写，字节。

你需要一个文件名和字节列表。现在那个列表只是一个整数列表。所以在字节上说得有点误导。这个函数将把这些整数转换为字节并存储在文件中。我们将引入一些稍微不同的东西。它将是with关键字。我们将说with。with将采用返回变量的一些代码函数。

使用变量。所以让我们去演示一下。所以我们将使用open。我们要打开文件名。我们需要给它一个模式，我们希望以二进制写入。如果我们只用了W，它将是纯文本，所以我们需要在其中加上B。正如。Wile。所以我们在这里真正要做的是说。使用。😊，这个函数，运行这个函数。

返回一个变量并称之为文件。所以将一些函数作为文件，读起来就像是这作为这个变量。现在我们得到了那个变量。我们可以直接使用它。我将说4 B。并且上字节。我们可以使用从W语句中获得的变量。对吧。而我们要获取那个单独的小数字。我将说2。下划线灯。

将B表示为字节有点误导。这实际上是一个整数列表。因此，我很容易剪切一组。我叫它什么并不重要。所以我们要将其转换为字节。现在我们想将其转换为一个字节。如果你是计算机专家并理解这一点，我们将给它一个大端序。

所以我会说字节。顺序。等于大端。你不知道那是什么？别担心。我们只是为了演示目的使用它。除非你特别想要一个大端或其他东西，否则这真的无所谓。好了，这就是了，我们完成了。你可能会说，等等，我们有一个文件对象。

我们不需要关闭它吗？难道我们不应该做类似文件关闭的操作？好吧，不。这会导致错误。而那。不会导致错误。但实际上并不需要，因为宽度在完成时会销毁它。当那个变量被销毁时，它会自动调用关闭。所以我们实际上已经完成了。

“你会注意到，随着我们在Python中变得更加高级，尽管我们编写了更高级的代码，但代码实际上变得越来越短。这是Python非常酷的事情之一。如果我们想的话，我们甚至可以进一步缩短它，但我们仍然在初学者阶段。

所以这是我为这个视频所做的最简短的内容。😊。

现在我们已经写入了字节，我们想做完全相反的操作。我们想把那些字节读回来。我会故意让这个函数变得比需要的大。只是因为我们仍处于初学者阶段，我不想让任何人感到困惑。所以我会说de。读取字节，我这样说是因为你会看到评论区有人说。

这很冗长，为什么你这样做，而不可以直接用一行代码？每个看的人都会觉得我不明白他们在说什么。所以我要说字节，我们要创建一个空列表。我们要说与。打开。

我们要获取文件名。这是个技巧。我们需要做相反的操作。我们要读取字节，而不是读取纯文本。我捕捉到了字节，但这是以二进制方式读取的。作为文件。现在。我将进行一个循环，我必须说永远为真。循环对新手来说很大且可怕，所以别担心，我们会告诉它何时停止循环，以免进入无限循环。

我会说B等于文件。读取，我们想读取一个。现在我们不是在读取数字一，而是从那个文件中读取一个字节。如果没有。B。我想我们讨论过不是，或者它与之相同。像这样。不等于，但我们只是说不是。比。我们要继续并中断。

Break将直接跳出那个循环。然而，如果我们仍然在Loopland中，我们想说字节。结束。我们继续取整数。我们在这里做的正好相反，取两个字节，而是从字节中取。所以我们把一个字节转换为整数。这很简单。

我们只是会取出我们从文件中读取的字节。如果我们真的想这样做，我们会设置字节顺序。好的，进入后，我们会回到这里，然后返回。我们的完成列表，看起来又大又吓人。

但实际上，我们只是做了正确操作的反面，我们只是在说，嘿，创建一个空白列表。然后使用打开，获取一个文件。只要我们能逐个读取，就将其附加到我们的整数列表中并返回。

看起来又大又吓人，但实际上，一旦你理解了，这很简单。

现在我们已经把所有部分结合在一起，让我们看看实际效果。这就是我喜欢编程的原因。它很像玩乐高。一旦你把零件组合在一起，就能做出更大更好的东西。所以让我们看看实际效果。我们要做的第一件事是创建。😊，随机字节。

所以我会说输出字节，你可以随便命名，这并不一定要是输出字节。这将是我们的随机字节函数。我们继续，只保持10。我不想要太疯狂的东西，因为我们必须在屏幕上看到它。

让我们继续显示一下，这样我们就能看到输出字节。我会逐步走过这个过程，所以我们继续运行它。我们以前见过这个，我把它分开了。所以每次显示时，它都会有这个整齐的小括号。现在我们要把所有内容写入文件。

所以我会说文件路径。让我们称之为test.dot TXT。这会让一些人生气，因为我们正在违反操作系统的一些基本概念。人们期望一个.dot TXT文件是一个纯文本。而我这样做是为了说明文件名和扩展名与里面的数据完全没有关系。

所以现在我们有了文件名，我会说，好吧，文件名。我们可以简单地将该文件名与输出字节一起取出，并将其转储到文件中。让我们再次运行这个。哦，文件名未找到，哦，我有文件路径。这就是为什么，嗯。令人震惊的是，变量必须对齐。好吧，让我们再试一次。

清除它，运行它，好吧，屏幕上看起来没有发生任何事情。但在这里我们有了这个小的.dot Txt文件，如果我打开它，我得到一些疯狂的字符。这是什么，这看起来像胡言乱语。我们的硬盘损坏了吗？不，让我们继续。

打开我们的十六进制编辑器，看看这里发生了什么。如果我们向上滚动，你可以看到我们有1等于84。但是接着我们进入了一种恐慌，觉得它是54。怎么回事呢？好吧，84的十六进制版本是54。然后我们有F1，F1。或者你可以看到这里发生了什么，有人会问，为什么它说0 x，这有点像我们处理十六进制数据的通用表示。

所以在你心中，稍微忽略掉那个0 x，关注x之后的一切。所以我们有54 F1，4 E1 D3，你可以看到它现在正如预期那样工作。这就是我所说的，很多人当你告诉他们需要处理二进制数据时，会有点慌乱，因为他们并不真正理解这点，他们觉得自己的电脑出了一些可怕的故障，或者他们的程序工作得不太好，因为他们看着数据感到困惑。

哦，哦，它说54，但我应该写84，他们试图弄清楚到底发生了什么。这就是我所说的，我们并不是直接处理二进制数据。我们在处理二进制数据的表示。我们让计算机为我们搞定这一切。继续，快完成了。现在我们只需读取那个文件。

所以我会说在字节中。等于，我们将继续读取字节。我们将读取那个文件。好了，一旦我们有了这个，我们将继续显示它。现在我们需要回到这个视频的开头，当时我们说过要使用运算符导入并进行比较。所以我想说打印。假设我们说匹配，我只是想知道它们是否匹配，就像。

那个约会网站match.com，真的是匹配。那么，我会说运算符。那一q。现在我们需要输入一些列表。所以我想看看。Bs和bys，再次。这些名字其实不重要。现在，因为我们使用的是基于时间的随机数生成器，所以每次运行时，这些数字都会变化，因为时间在不断变化。

只想提醒一下，所以如果你期待的是84，241，4，等等，你将会有一个很大的惊喜。或者现在我告诉你会发生什么，可能不会。让我们运行这个，看看这里发生了什么。它说匹配为真。那么这里发生了什么，让我。向上滚动。我们有我们的输出。在我们的输入中，当然。

每一项都排列整齐，两个列表现在匹配。所以我们所做的事情是这个冗长的版本。向上滚动到这里。我们创建了一个随机整数的列表。它说是随机字节，但其实是整数。然后我们可以显示这些数据，再把它们写入文件，然后作为字节写入。然后我们可以把它们读回来，把这些字节读入整数，并放回列表中返回。

我们实际上可以检查确保所有内容匹配，因此我们写入的内容和现在读取的内容匹配。大问题是，你将如何修改这些信息？

假设你想进行某种工作，你会在将输出写入文件之前对其进行处理。所有的更改都会被写入其中。看，我们的文件就在这里，如果我们用我们的编辑器打开它，就能看到它的漂亮呈现。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P26：26）使用 JSON - ShowMeAI - BV1yg411c7Nw

大家好，欢迎回来，我是布莱恩，这是第26集，我们继续我们的Python 3之旅，今天讨论的是JO文件，这有点误导。它实际上不必是一个文件，我们讨论的是数据。让我在这里发布一些JSON数据。我用这三重引号包住，以免IDE生气。但实际上我们要看的就是这部分。在括号之间的所有内容。

所以我们有开始和结束，然后有键值对。现在JSON可以复杂得多，但我想保持简单，因为我们并不是在学习JSON的复杂性。我们只是想学习如何在Python中使用它。首先，为什么你需要JSON？这是什么，你需要它做什么？它是用于应用程序。对应用程序。在某些场合。现在。

当我说通信时，这可以是从网络到远程调用，甚至只是简单的写入和读取文件。JSON旨在作为一种数据格式，因此不一定是文件格式。你可以在网络、内存等各个方面进行这些操作。但它将是一个达成一致的格式。所以假设我写一个程序，而你写另一个程序。

你想能够读取我创建的内容。我们必须有一个“达成一致的格式”。这就是JSON的本质。

正如你可能猜到的，JSON可能有点复杂。因此，在我们深入探讨之前，我们需要一些导入。实际上，我们只需要一个。我们将导入。JSON。使事情简单得多。我知道它看起来很复杂，但我们需要导入这个模块，因为我们不想重新发明轮子。

我们想使用已经编写并且有效的代码。让我们继续创建一个变量，我将称之为文件名。我们会一次又一次地使用它。我将称之为Jason。At T X T。

让我们开始吧。超级简单。所以我们将把一些字典转换为相邻格式的字符串。快五次说这个。虽然有点令人困惑，但这就是我们要做的。我将创建一个名为outd的变量。你可以随意命名。

但我只是想知道这是输出字典。这就是我们要转换的内容。所以我会说。字典函数。我想创建一个包含键值对的字典：姓名。布莱恩。年龄46。还有。那只猫。所以我们将取这个字典，并将其输出为J格式，所以让我们抓住它。稍微复制一下。

我想说 S 等于。我们想使用 J 模块。我们想要转储 S。不是简单的转储。现在，如果你的 IDE 可能会显示一些不同的内容。你可能会看到 dump 和 dumps，后者带 S。我们需要 S，代表字符串。所以它将输出一个字符串。

我将把我们的变量传递进去。实际上，我要借助复制粘贴的魔力，在那里放一个小备注，以防有人对 D 和 D S 之间的区别感到困惑。通常，当你被转储时，这是一件坏事。但在这种情况下，这会让我们非常高兴。好的，实际上这有点悲伤。我们要说，字符串将是。

我们的输出。让我们运行一下，看看那是什么样子。所以确认一下字符串。看，它看起来像个字典。这就是我喜欢字典和 Python 与 Jason 一致的地方，因为它们几乎看起来一模一样。很容易看出，并准确理解发生了什么，因为我们有键值对。😊

让我们继续将其输出到文件中。现在，记住，我说过。随着我们在 Python 中变得更加复杂，我们实际上写的代码更少。我发现这非常真实。这是 Python 的一个奇怪之处。所以我将说 with。打开。我们要去哪里。对。我会命名我们的变量。然后我们将写入它。

我们要创建一个名为 app 的变量。现在我们要说 Jason。转储。注意有两个转储。一个是 D 和 dump S。当我们看到 S 时，它代表字符串。我们想转储这个。我们想将我们的字典输出到文件中。我会在这里放一些备注，以防有人对发生的事情感到有些困惑。

非常非常简单，易于理解。让我们运行一下。它给出了相同的输出。现在我们有这个 J.txt。如果我们打开它，它包含字符串。我应该说是字符串化的 Jason，或者我们实际的字典以 Jason 格式呈现。它可能看起来完全像一个 Python 字典。这就是人们常常混淆的原因。他们会去。

哦，你在来回传递 Python。实际上，我们在传递 Jason 和数据。它看起来与 Python 中的字典对象非常相似。现在，让我们做一个完全相反的事情。我想从字符串中读取。所以我们要回到这里，并取这个 S 变量。

记住，Jason 进行了转储，或者说转储字符串到这个小家伙。现在我们来处理它。我想做一个与转储相反的操作，那就是加载。我想说 indie。一波。Jason。如果你在想像 D 这样的名字，没错，Python 开发者确实有幽默感。所以请耐心等待这些视频中的一些内容。

我们将要加载S。注意，不是load，而是load S，表示字符串。我们将把那个字符串输入。我会在这里加一些注释。以防有人有点困惑，所以从字符串加载字典。我将其命名为In，你可以随意命名，实际上无所谓。

我要进行一些魔法，把它复制并粘贴到这里。让我们继续运行这个。你可以看到我们的字典现在已经加载完成。这个工作方式非常酷。而且它看起来几乎是一样的。所以，是的，这会让很多人感到困惑。但请放心。我们正在处理Jason。现在，为了反向操作。

我们现在要从文件加载这个，所以我们回到这里，我们说用打开的文件以文本写入模式作为F。然后我们进行了转储，将那个字典转储出来。我们要做的正是相反的事情。必须说，用。打开。我想要文件名。我们将其作为纯文本读取。作为F。然后让我们创建一个我们之前没有用过的变量。

所以显而易见，这正在加载它。所以我会说文件字典或F D。等于Jason。我们想要。加载，而不是load S，因为那将是一个字符串。我们想要load。这将告诉它从文件源加载。如果你真的好奇，不。变量名称并不重要。我实际上可以将其命名为person或P或Brian。

无论我想做什么都无所谓。所以现在我们已经加载了它。好吧。现在复杂的部分来了。我们只需使用它。真的是非常简单。我说复杂时，我有点开玩笑。这真是简单得几乎令人恐惧。如果你来自其他语言和其他框架，你可能会觉得。

这怎么会这么简单，真是令人震惊。所以我会在这里调用类型函数。只是为了我们能看到。P是什么类型，什么数据类型？

这是我对Python的一点小抱怨，IDE很好，但如果你只是把它放在一个纯文本编辑器中，而不是IDE。你可能会看着它，试图弄清楚load到底在做什么，它返回什么。所以类型函数将打印出来，或者我应该说给我们返回数据类型，这样我们就可以把它打印出来。

然后让我们继续，安。打印出实际的变量。我们再运行一次。所以，输入。Lss di。所以这是一个类字典。记住，类是我们将在不久的将来讨论的内容。类是一个对象的蓝图。这是一个字典数据类型。它等于你猜的，就是我们刚从文件中加载的信息。

这现在是一个字典。非常简单，非常容易。主要的要点是。Jason是一种用于在应用程序之间交换数据的数据格式。这是一个应用到应用的通信数据标准。世界各地的人，不同国家。语言障碍无所谓，会说，嘿，把相邻的文件给我。

而且使用起来非常简单。当你查看它时，它是一个字符串。因此，只需在记事本或文本编辑器中打开它，如果需要可以轻松修改。但在编程层面上，操作起来也极其简单。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P27：27）导入工具库 - ShowMeAI - BV1yg411c7Nw

大家好，欢迎回来，我是布莱恩，今天我们要讨论导入。在这个视频中，导入使我们的代码可以被其他脚本使用，也让我们可以使用其他人的脚本。但最重要的是，导入实际上使我们能够简化事情，我们现在可以结构化我们的代码，并根据需要导入内容。现在导入系统实际上相当复杂，所以在这个视频中我们只是触及表面。

我们将讨论一些高级问题。我想展示如何将代码拆分成不同的文件。我们将不得不将这个拆分成多个视频。因此，在这个系列中我们将不断回到导入系统，逐步增加复杂性。

让我们深入了解。

首先，我们想要创建一个单独的文件，所以我将放入一些笔记。我们将创建一个文件，并且我会在里面留下这个注释，以便任何没有观看这个视频而只是在GitHub上找到代码的人可以看到。

它只会说，继续查看我的代码 Py，我们要去这里，实际上我们将创建一个新文件，我们将其命名为 mycode py。在这个文件中，我们将添加一些代码。所以我会说 name equals。嗯。不管你的名字是什么，我真是搞砸了。我连自己的名字都拼错了。其实，我拼对了。

我刚刚有一个大小写问题。我们将创建一个名为 greet 的函数。我其实是即兴发挥的。我并没有什么具体的想法。我们将添加一些代码和函数。所以我会创建一个函数叫 G，它将打印出 hello 和名字。

注意这里的作用域，name 实际上位于这个文件的全局作用域中。我会说 de。然后我们继续说 two file。我们已经在之前的视频中学会了如何处理文件系统。如果你错过了，赶快回到播放列表观看那个视频。M say file name。我不。其实不需要说 global，因为我们并不是想要修改它。

我们只是想读取它。Python 对此比较宽松，但为了安全起见，我们还是会说 global。然后打开文件名。我们希望再次写入那个文件。如果你完全跳过了那个视频，我强烈建议你去看一下。然后我们就会说 F right，写入所有内容到文件中。

在这种情况下，我们只是简单地写下名称，我们就这样做。非常简单的模式。然后改变一下。所以现在我们从文件中读取，准备以读取模式打开它。然后我们将这里做完全相反的事情。快速回顾一下，当我们说“with”时。完成后，它会自动关闭那个文件。

所以我们不必担心任何复杂性。好的。我们的文件都完成了，它并不难，只是有一个变量和一些函数。

让我们回到最初的Python文件，这实际上什么也不做。实际上。让我们跳回去确保你保存了它。现在，我们要做的是使用“import as”。我想我们已经涉及到这个，但我们还没有真正深入探讨发生了什么。所以我会说import。你想要我的代码。作为。让我们给它一个名称，叫做person。

这可以是我们想要的任何东西。我们可以称之为“冰淇淋圆锥小猫”。代码，随心所欲。但这里真正发生的事情是导入在说，导入这个模块。现在。模块是我们还没有真正覆盖的概念，我们将在未来的视频中讨论。但现在，当我说模块这个词时，只需想象外部代码，这些代码在我们的文件之外。

所以导入将查看，并且隐形地，这里有一个小点。它将在当前目录中查找名为“我的代码”的东西，导入的目录结构有点混乱。我们将在未来的视频中讨论这一点。所以现在所有东西都在你项目的根文件夹中。因此导入这个文件，最后有一个隐形的.py。

如果你拼错了这个，它将找不到它。现在我们说as。Person。所以它在做的事情是导入这个整个文件。我们已经写的这个东西有一个变量。所以现在它创建了一个名为person的变量。你可以看到person现在是我的代码。

所以整个文件现在保存在这个变量中供我们使用。比这要复杂得多，但这是我能解释得最简单的。基本上，我们将整个文件转换成一个变量。

现在，在这一点上，我强烈鼓励你测试一下，只需简单地运行它。它应该什么也不做，但如果你有某种拼写错误或其他问题。你会得到类似这个的“模块未找到”错误。然后“没有名为Na的模块”是你的关键。名称拼写错误。

所以让我们继续修复它。只是想演示一下。让我们讨论一些作用域问题。我们可以运行这个，看看它是否按预期工作，接下来我们清除它。我们来用我们的全局变量，来说明全局名称。不是错误。谢谢，In teleence。全局名称。继续打印出来。这儿发生了什么？名称，错误。名称。

名称未定义。等一下，什么？在我们的文件中，我们有名称，并且我们通过全局作用域在使用它。那么这里究竟发生了什么？我们试图说明的是，一个模块有自己的作用域。因此，模块的全局作用域并不是你脚本或应用程序的全局作用域。

两个完全不同的作用域。所以，即使我们可以明确地尝试强行将其推入全局，尽管它已经是全局的，我们也可以尝试将其放入全局。这真的没有帮助。它仍然未定义。现在，如果我这样做，注释掉这个，运行它会发生什么？同样的事情。名称，名称未定义。所以无论你试哪种方式都没有关系。哦，这太棒了。

如果你是新手，这会非常令人沮丧。那么我们该如何从这里获取名称呢？好吧，记住，我们已经将整个文件转换成了一个变量。我们几乎创建了自己的数据类型。所以我们将继续打印Person，或者无论你给它取什么名字。现在我们想要的是名称属性。

它自动知道这是一个字符串，所以生活现在会很好。让我们把它放在这里，以便在Github上任何人都可以轻松看到发生了什么。清除这个并运行。哦，是因为我还把它留在这里。对此感到抱歉。让我们再试一次。好了，来吧，Brian Karen。

所以如果你像我一样忘记将其注释掉，你会遇到那个令人厌恶的错误。这是一个很好的作用域说明，涉及导入和模块。每当你有一个新文件时，想想它有不同的作用域。有一些方法可以在它们之间跳转。但是从实际的角度来看，它们是两个不同的作用域，你应该将它们视为这样。

我们需要做的最后一件事就是进行一些测试。所以我们将继续测试代码。我将添加一些空间，以便获得一些屏幕真实空间。让我们继续说person.name等于，我将把这个改成Brian而不是Brian Karen。然后继续执行person.greet。所有的功能。让我们就这样做person.file。

让我们给这个起一个非常简单的名字。Test.dotEXT。它只是会将该名称转储到一个文件中。让我们继续说person.name。什么是Tammy。再执行一次问候，以便我们可以看到我们确实改变了那个变量。让我们加载那个文件。现在，只要我们的文件名匹配，就可以正常加载。再问候一次，以便我们可以看到我们确实从文件中加载了那个名称。

让我们继续运行，看看会发生什么。最初的名字是布莱恩·卡斯，我把它改成了布莱恩。然后改成了塔米，接着我们从文件中加载它。现在我们可以看到这个测试文本在这里。所以总的来说，简单回顾一下，导入是一个非常棒的代码结构方式，确实简化了许多事情。

它确实有一些复杂性，我们将在未来的视频中讨论这些问题，我们在这里也稍微提到了一些作用域的问题。实际上，它比这复杂得多，因为我们真正涉及到的导入，是模块的基石或基础。不幸的是，在我们深入了解模块之前，我们需要先学习其他一些东西，比如，类。

这很快就会到来。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P28：28）主函数 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好。我是Brian。今天我们要讨论Python中的主函数。现在，如果你在想大多数编程语言中的主函数是什么，你会看到类似这样的东西。这只是一个字面上叫做main的函数，当你的应用程序执行时，它将是第一个运行的函数或入口点。

没有主函数，你的应用程序根本无法运行。好吧，正如我们在Python中看到的，你并不需要主函数。这是完全可以的。那么，你如何让代码自动运行，这正是我们在这个视频中要讨论的内容。

让我们来看一下这个。所以我们首先需要确定我们的脚本是如何运行的。如果你一直在YouTube的播放列表中关注这个系列，你就会知道你可以直接运行脚本，脚本也可以被导入。所以我们要确保确切知道这个脚本是如何运行的。

所以我们来打印一下。我们要说F。我们要格式化并说名称等于。现在我们将使用一个特殊变量underscore， underscore name。每当你看到那个双下划线时，这就是内置于Python中的。我们将打印出来。现在我们把它改成文件。

我在之前的视频中提到过这可能有效也可能无效。所以如果你遇到问题与underscore underscore file有关，你需要观看我谈到的关于使用传递给脚本的系统参数的那个视频。大多数情况下，这应该可以正常工作。我们来运行一下。

你可以看到我们的名称是underscore，underscore main，所以记住。双下划线意味着它是内置于Python中的。而文件名就是我们当前运行的文件。这条剧透可能会改变。所以不要依赖它。我所说的是，如果我们以特殊方式基于导入来调用我们的代码。

文件名实际上不会是我们当前脚本的名称。所以你要稍微小心一点。但我想强调这些内容。最重要的一点是我们的名称是underscore underscore main，这意味着我们知道Python直接运行这个文件。这是主脚本文件。

现在，让我们在这里创建一些代码。我们的脚本实际上什么都不做。所以我们想做点什么。我们将创建一个测试函数。我并不在乎它做什么，只要它能在屏幕上打印出一些内容，以便我能看到它正在运行。现在我们将在这里创建一个主函数。注意名称是mainine。去打印一下。

让我们开个玩笑，直接在这里调用我们的另一个函数。实际上，我们想要做的是让这个脚本自动运行这个主函数。这样我们就知道我们在做什么，然后调用这个其他函数，开始一系列事件，进行一些代码处理之类的。所以，让我们先清除这些内容。

让我们看看很多刚接触Python的人犯的错误。他们会说，哦，我知道我在做什么，然后就去运行，但什么也没有发生。这真让人失望。所以，是的，在Python中，主函数实际上并不会自动调用，我们必须特别调用它。

现在，你可能会想我知道该怎么做。我只需在这里调用主函数。它就会工作。看看它在运行，确实运行了。这是主函数。这是一个测试函数，所以我们在调用它。问题出在这个名称上。我们将在这个部分之后演示。

我们将向你展示如果我们从另一个脚本运行这个会发生什么。我们不一定想要这段代码执行。也就是说，如果我们将这个文件作为变量导入到另一个文件中，我不希望这个函数被调用。因此，我们希望它自动运行。

但只有在某个特定条件被设定时。继续说主函数。我们将自动打印这段代码。这是我的ID。你可能需要手动输入，但我们会说如果__name__等于__main__，那么就执行。它实际上将不会做任何事情。所以我将把这个。所有主函数直接处理。

继续，保存并运行。果然，它运行了我们的主函数。它在说名称等于主函数，所以我们知道Python是在直接运行这个主函数。继续调用这个。

一旦你搞清楚了__name__等于__main__之间的区别，并且你知道这意味着Python正在直接运行这个，我们就可以做一些稍微不同的事情。我们可以实际上将这个代码文件拿出来。让我这里记一些笔记。然后我们可以从另一个脚本运行它，只是为了看看这里的区别。

所以我们将创建一个名为test.py的文件，我将故意犯一些错误只是为了展示发生了什么。我经常犯错，但这次，我确实是想给你展示发生了什么。首先，我们要做的是导入这个文件。所以让我们回去这里。我想说导入Python，注意到Intelligence正在帮助我们。

从我们之前的视频中，你知道我们正在做的是将整个文件转换成一个我们可以使用的变量。在我们进一步之前，让我们运行这个，注意我们得到了一个无效的语法错误。它有这个小的。

这里的箭头指向这个括号。所以它告诉我们，它不喜欢这个。我们的文件命名约定需要改变。我们可以做的是，右键点击这个。将其命名为code_file.pyy。功能没有改变。所以，例如，我们将运行代码文件。

之前使用的是Python 3.28。你会看到，它按预期工作，只有文件名改变。所以功能没有改变，只有名称。我们得回去更改名称。清除这个。让我们运行这个测试do.py。你可以看到，第一眼看到的就是名称。

代码文件，文件名，代码文件。这里发生了什么，我们运行了test.py。但是它正在打印这个。当我们点击导入时，它会从上到下读取我们的文件，并且实际上会采取一些行动。这有点危险。为了演示，我将抓取这个。进入这里。假设。

让我们讨论这个测试名称。和测试文件，以便将它们分开。清除这个，重新运行。现在你看到它们都在触发，即使我在运行test.py。导入先发生。所以它说导入代码文件，它去到代码文件，执行这个代码。它没有执行我们的函数。因为名称不同，它没有执行这个。看看。

名称是代码文件。所以名称不再是__main__，而是很好。简单来说，代码文件的短版本没有目录。没有.py的扩展名。这就是为什么我们需要if name == '__main__'。所以现在在这里，我们可以直接调用这个。保存，运行，看看效果，果然如此。

这是一个测试函数。主程序从未触发。这可能有点令人困惑，所以快速回顾一下。如果你打算将文件作为导入使用，命名时要小心。一些字符是非法的，比如之前看到的连字符。如果你要自动运行，你需要检查名称是否等于__main__。

因为如果我们把这个文件当作导入来运行，它会给我们文件的名称，前面没有下划线。这并不能保证是文件的名称。Python可以给我们任何我们想要的。关键是__main__意味着Python直接运行这个。为了说明这一点，我们将再次运行代码文件。看看。

名称是__main__。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P29：29）导入自建工具库 - ShowMeAI - BV1yg411c7Nw

大家欢迎回来。我是布赖恩。在这个视频中，我们将谈论导入的疯狂。是的，我们将深入探讨这里的疯狂。所以我们谈论的是下划线。在它里面，下划线是什么，我们为什么需要它。😊

首先，我们需要创建一个子文件夹并向其中添加一些代码。所以我将写一些笔记。我们将创建一个文件夹，叫它sub。所以我在这里说新建文件夹sub。在我们的子文件夹内，确保你已经选中。你的IDE可能会根据你正在使用的不同而有所不同。

我们将添加两个文件。第一个文件将非常简单，命名为Test.py。我们将添加一些代码，为了节省时间，我将复制并粘贴。只是一个简单的函数，do_test，它只打印出“这里做点什么”，真的是不值得奖的代码。

我们还要添加另一个文件。这个文件必须命名为__init__.py。记住，每当你看到双下划线时，你就应该想到Python内部的东西。现在，一些论坛上关于是否在旧版Python中真的需要这个有很多争论。在较现代的Python版本中，确实需要，但这仍然有争议。

但我把它放在这里只是为了让我们理解。我会在这里写一些笔记，这些笔记有点多。这是必要的，因为我们在一个子文件夹中。每当你看到文件夹时，我希望你想到模块。记住，我们谈论过模块一点，但模块不仅仅是一个文件，它是整个文件夹结构。

创建某种文件夹结构的问题在于，Python需要理解如何处理该文件夹结构。所以在最简单的情况下，它可以只是一个空文件，但它也可以执行包的初始化代码。这就是复杂性所在。所以如果我们在处理类似于socket服务器或数据库的东西。

我们实际上可以初始化一些代码。我们可以说像port等于80或者用户名。你在生产环境中绝对不会这样做，但用户名可能是admin之类的。你可以在这个文件中直接指定所有这些内容。所以我们非常简单地使用这个文件，因为我们希望Python理解如何处理这个文件。

所以我们要在这里稍微修改一下。我们要说从 test 导入 St。我们之前见过 import，但还没见过这个。这到底是什么情况？所以我们所做的是说从 .test 导入星号。from 基本上就是在说，去找到这个。这里有一个小点，如果我们省略掉它。

我们可能会遇到一些糟糕的事情，它可能并不知道我们在这里试图做什么。所以在大多数情况下，我们必须把它放进去。然后神奇地，它知道这是目录，如果你曾经感到困惑。这是当前的目录。而且，我这是父目录。所以基本上我们所说的是从当前目录开始，然后取一个文件名test。

它的结尾没有 PY。继续导入，然后所有内容。所以我们是在说，把这个文件的全部内容拿进 Python 中。

让我们先玩一下 imports。我们将切换回主文件。在这里我们将玩一下 imports。让我们尝试用我们之前尝试过的几种不同方式来导入。我们只是简单地说，import Sub.test as code。然后，code.do_test。

我们实际上可以这样做。看看这个。现在，如果我们运行它，一切都运作良好，但我们跳过了这个初始化文件。在旧版本的 Python 中，这可能不适用。你可能会遇到一些小麻烦。如果你尝试说像从当前目录 .sub.test.do_do，你可能会，具体取决于你的 Python 版本，遇到类似无效语法的错误。那么我们该如何导入这个文件，以及如果我们还有其他文件呢？你猜对了，我们需要这个初始化文件，而且我们有一种特殊的方法来做到这一点。

所以我们要做的是回到这里，去掉所有那些东西。我们要说从。记住，当你看到 from 关键字时，我们是在说去找一个位置。所以从 sub。Sub 是文件夹的名称。所以从这个文件夹中，继续导入星号，也就是说，从这个文件夹中，导入所有内容。现在，这很大也很吓人，因为如果这里有成千上万个文件怎么办。

没错，我们要导入成千上万个文件。这就是这个 init.py 真正派上用场的地方，或者说初始化文件，简称为此。因为它将指示 Python 该做什么。

可能有一些文件我们想要直接导入，还有一些文件我们不想自动导入。我们可能想设置一些变量或一些设置或一些文件结构。我们会在这里做到这一切，如果需要的话，我们可以调用函数。这比这更深入得多。再说一次，我们仍然在初学者阶段。如果我们真的想要的话。

我们可以稍微玩味一下这些。我们可以说类似于from S import，然后是一个特定的文件。记住，这将是test.py，但你不需要写.py。所以我们是在说从文件夹中导入一个文件作为这个变量。这看起来有点冗长，似乎有点困惑，直到你真正理解它，但这非常简单。

一旦你理解了，就非常简单。这里的一个主要收获是如果你有一个子文件夹，你应该在其中包含__init__.py或初始化文件。如果跳过这一步，旧版本的Python将无法正常工作。

你可能会遇到一些奇怪的问题，如果你想在所有这些文件中进行任何初始化，几乎是必须的。好吧，一旦我们到了这一点，真的只剩下一个事情就是实际看到它的效果。所以我们将在这里调用代码。假设是DE main，如果你跟着我并且试着做些什么。

编辑器中的代码可能会背叛你，所以要小心。因此，我将说main。而此刻，我只会说pass。记住，Python中的pass意味着什么都不做。如果__name__，它将在这里下降。等号，等号。遵循之前视频的内容，我们说如果__name__等于main，就自动运行这个函数。

如果我们要导入这个文件，它不会启动这段代码。让我们去掉这个，并且我们会说print("这是主函数")。让我们调用我们的导入。因为我们做了from sub import *，这意味着导入所有内容。它将在这里读取这个初始化文件并说from test import *。

它将导入我们所有的代码。我们有一些东西需要处理。所以借助旧的复制粘贴魔法，我可以抓取它，跳回这里并说est，我们可以直接调用它并且它就能工作。看，做点什么。因为我们做了from sub import test as code，我们可以这样处理。

做同样的事情，但把它放在一个变量里面。现在，我可以说code.do_test。非常简单，非常容易，按预期工作。那么哪种方式是正确的，你应该使用哪一个？

就我个人而言，我倾向于选择第二行，因为从每个文件导入。如果你有名称冲突怎么办？如果有一个test2文件也有相同的do_test函数，你会想将它们分开到两个不同的变量或作用域中。记住，每个文件在作用域方面都是一个孤岛。

至少这是你应该在脑海中思考的方式。因此，从这一点来看，初始化文件很重要，如果省略了它，你可能会在Python中遇到麻烦。你确实需要它来初始化Python的工作方式，还有不同的导入方式进一步增加了导入的复杂性。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P3：3）Python注释、布尔值和比较 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好。我是布莱恩。我们将继续我们的 Python 3 之旅。不论你使用的是哪个 IDE，请创建一个空白文件，我的文件名是 Python 33。在这个阶段，名字并不重要，只需准备好一个空白文件即可。我们将涵盖三个关键内容：注释、布尔值和比较。让我们马上开始吧。

好吧，注释，你们实际上见过它们，但我们还没有真正讨论过它们。什么是注释而不写任何代码，继续运行你的脚本。你会看到，它确实什么都不做。我们将按下井号并输入一些内容。这是一个注释。那么，这到底有什么用呢？如果我们运行我们的程序。

你会发现没有任何变化，它确实什么都没有做。注释就是注释，它对代码的存在仅仅是为了你，程序员，以便你可以保留一些笔记。例如，你可以说。这是我们的第三个。这个也有。你会注意到你可以添加字母、数字，或者你想要的任何东西。

当我们运行它时，它不会抛出任何错误信息。这完全是为了你。这是你的笔记。现在，如果你来自其他编程语言，你可能希望有一个多行注释。这意味着如果你有几行，比如“你好，世界”。我喜欢猫。哦，你会注意到我在输入时。

它试图帮助我，并且放入了我们称之为“智能提示”的内容，这些是已经为我们预写好的代码。不过，我们其实并不需要这个。所以它导致了各种错误。现在，如果我在输入一个注释，我会说“你好，世界”。我喜欢。你会发现智能提示突然并没有出现。

我可以通过按下控制键和空格键强制它弹出。但是它并不真正知道我们在做什么，因为我们在注释中。多行注释就像如果你有，我只是抓一些文本。这不是一个注释，即使它说它是一个注释，实际上它并不是。如果我们尝试运行它，哦。

你会看到“无效语法”。因为它试图将这个解释为代码。现在，我们可以在每个前面加上一个井号。例如，先来看看这个。还有这个。如果你需要处理大约 100 行代码，那就会变得非常乏味。所以许多 Python 开发者会这样做。这。

它们只需要用三重引号包围，三重引号内的任何内容都会变成字符串。这个我们将在另一段视频中深入探讨。只需知道这是一种数据类型。我们并不是在真正地写注释，而是在创建一个字符串。但这个字符串确实什么都不做。所以如果我们再运行一次，没有错误信息。

让我们清除这个讨厌的错误，以便你可以看到。你可以全天运行这个，且没有错误信息。但我们确实创建了一个变量，信不信由你。所以我不推荐这样做，要小心，这可能会导致后面的麻烦。尤其是如果你进入文档字符串等内容。

我们将在本系列后面讨论这个内容。所以你可能会问。注释的功能目的是什么？它仅仅是为你，开发者，提供的备注。你也可以使用注释启用和禁用代码。所以，例如，假设 x 等于 1。打印 X。你可以看到它现在打印出 1。我们也可以将其更改为。你好，世界。

这是我们在前一个视频中做的。现在，如果我们注释掉这个。这 X 在技术上不再存在。你看到它给我们一个小红色波浪线。它在说未定义变量。如果我们尝试运行这个，你猜对了，轰，名称 X 未定义。所以我们可以通过注释掉来禁用这段代码。我们可以通过简单地删除那一行来重新启用它。

那么我们来介绍第一个真正的数据类型，这非常基础，它叫布尔。有人简称它为布尔值。它是真或假。想象一下像房间里的灯开关。它要么开启，要么关闭，这就是这个数据类型所表示的。好吧，我们做几个。

我实际上会将这段代码注释掉。让我们做一些。我会说。X 等于 true。注意它的大写 T，智能提示正在帮助我们，嘿。它必须是大写。y 等于 false。同样，大写 F。如果你来自其他语言，可能会倾向于给它一个数据类型像这样。

你这么做的话，坏事会发生。它不会知道你想做什么。我们实际上可以尝试运行这个，你会明白我的意思。呃。无效语法。所以它不理解发生了什么。当我们去掉那个时，突然，神奇地它就正常工作了。清除那个错误，这样不会让任何人困惑。不啦。再次强调，这些是大小写敏感的。

所以如果我把它改为小写，你会看到智能提示不再把它标为蓝色。如果我们尝试运行这个，就会出现一个讨厌的小问题。名称 true 未定义。记住，当你看到未定义时。这是解释器的方式在说，嘿。我不知道你在这里想做什么。仅仅因为它不存在。

所以让我们把这个改回大写 T，生活很好。我要在这里复制粘贴一些备注。注意你可以将注释放在自己的行上，或者在之后，如果你把它放在之前，例如。如果我把它移动到这里，它会将那一行之后的所有内容变成注释。

所以这样做要非常小心。这些注释对我们的代码没有任何影响。例如，我们可以全天运行这些，完全没有错误消息。然后清除这一切。现在我们明白，我们想要做一些基本的比较。这就是我们接下来要讨论的内容。好的，让我们谈谈比较。首先。

什么是比较？好吧，它是编程逻辑的一个基础构件。因此，比较是逻辑的基础。这意味着我们想要某个值。将该值与另一个值进行比较，以查看我们在编程逻辑中需要做什么。例如，我只是打印出X和Y。我会稍微不同一些。

我将放入字母F，代表格式化。然后我会说x等于。括号。然后，X。看起来有点混乱，但实际上，我们只是在说，打印出X。但要以一种花哨的方式做。看。X X，现在我可以把这个改成y。这变得非常简单，易于理解。X是真的，Y是假的。

我们现在要比较这两个。我们要做的第一个比较是相等。其实相当简单，所以我只是抓住这个。我们来设定h。我们要在这里做逻辑，然后说。进行相等比较时要小心，因为如果你只这样做。

你实际上是在赋值。这些被称为运算符。这是赋值运算符。我们现在在说x等于y。我们不想这样做。我们想比较。所以我们要说x等于y。我们只是在比较。然后说那个的相反。我想要不等。注意这是一个感叹号，每当你看到感叹号时，想想你想要的完全相反。

我们想要的是什么？这是相等的反面，还是不等，让我们继续运行这个。看看会发生什么。你可以看到x是真的，而y是假的，它们不相等。当我们测试不等时，它实际上给我们一个真。能做到这一点真是太酷了。在这一系列中，我们对编程几乎一无所知。

但我们已经拥有了计算机逻辑的基础，真和假。我们可以测试这些条件。😊，让我们进一步推进。我们要做的是大于和大于等于。所以我会抓住其中一个。然后我说。大于。这非常，非常简单。

我们要说打印输出是x大于y。现在我想说大于，或者等于。这与不等于2的语法非常相似，我们在说大于等于2。接下来让我们做相反的，来说小于。然后把这些翻转过来。让我们继续运行这个，你可以看到这里是大于真，大于或等于。

true，小于false，小于或等于false。

这些确实对你来说不会很有意义，对吧？

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P30：30）类介绍 - ShowMeAI - BV1yg411c7Nw

大家好，欢迎回来，我是布赖恩，我们将继续探索Python3的旅程。我们已经说了30多集，我们要讨论类，今天终于开始讨论类。在深入之前，我们需要覆盖一些基本概念。首先，最重要的是。

你听说过OOP或面向对象编程。这是其基础。基本上，类是一个蓝图，用于创建对象。你会听到人们交替使用类和对象，但它们是两个不同的概念。类是一个蓝图或计划，用于描述对象应该如何被创建。

当Python或其他语言实际创建该类的对象或实例时，就是对象的生成。我们将要创建蓝图。类也是一个非常庞大的主题，远远超出我们在单个视频中能够覆盖的内容。因此，我们将把这个内容分成多个视频。让我们深入了解一下。

好的，类可以变得非常复杂，我们将创建一个简单的类。

所以我将直接粘贴评论，创建一个类。我们将在一个单独的文件中完成这个，但你也可以在一个文件中完成，正如你将在未来的视频中看到的，但我只想展示一下人们在实际工作中是如何做到的，所以我将创建一个新文件。

我们将把这个文件命名为cat.py，因为我们将在这里创建自己的猫类。我将粘贴一些笔记。猫类中的self是第一个参数。我想把它放在这里，因为人们常常忘记这一点。如果你来自其他语言，它相当于其他语言中的this。那么我们在这里讨论什么呢？

这就是人们感到困惑的原因。类和对象的概念很混淆。类是一个蓝图，描述对象将如何被创建。一旦对象被创建，它就成为一个实例。所以我将要提到这一点。如果我们处于一个实例中，因为你可以有多个实例。正如你在这个视频中将看到的，我们会创建多个猫对象，你需要引用当前实例，你需要使用this或者在Python中使用self。

所以，人们常常认为self和类是同一回事，但它们不是。它们是两个不同的概念。每当听到类时，就是蓝图。那么我们来制作蓝图。对。就是这么简单。现在我们需要添加一些属性。所以我将说name等于。就留空。而且我们可以说age等于。

每个人都有自己处理这个问题的方式。这只是我的做法。随意采用你自己的风格或你所工作的公司的标准。但这就是我的做法。我想知道变量。而每当你看到一个类并且看到这个缩进时，想想作用域。

这些存在于猫的作用域内。每个实例将有独立的变量，不会共享。虽然你可以展示它们，我们将在另一个视频中讨论。我知道你可能已经厌倦了我说，我们将在另一个视频中讨论，但编码有很多内容，无法一次性覆盖。所以现在我们将说de in knit。现在。

记住，双下划线意味着它是Python内置的东西。这就是构造函数。我的意思是，当我们创建这个类的实例时，就会调用它，以便执行代码。把这看作是类的主函数。当Python创建CA的实例时，我们将自动运行这个函数，你可以随意省略它。

这被称为默认构造函数，当你根本没有定义时。或者你可以自己定义它。现在，记住，我说过。Self是第一个参数，所以我们需要说self。它是我们需要的第一个参数，引用当前对象。现在我将粘贴一些笔记。基本上。

显而易见的是，self是必需的，其他参数是可选的。我们继续填写，因为我们想引用当前对象，或者说self.dot。Name等于name参数。从这里开始，这只是复制和粘贴的课程，因为我们想完成其余部分。所以我们只是简单地初始化这些变量。它将复制和粘贴出来。

也许可以这样。所以我们说self.name，这个变量等于参数，或者实际上是参数name。Age，age，color，color变得相当自明。现在我将打印出一些内容，以便我们知道它被构造了。我将说self.name的构造函数。从这里开始，其实相当简单。

我们可以定义任何真实的代码或函数，比如，我们可以说。Deaf Neow。如果你这样做，你会在什么都不起作用时感到非常困惑。记住。你必须将self作为第一个参数。否则。你只会有糟糕的体验。什么都不会正常工作。

缩进可能会让你抓狂。记住，你只需与当前作用域对齐。所以类作用域、函数作用域，依此类推。然后，我将说。Print F。让我们继续说。Self name和meow。我要稍微加快速度，因为我们之前已经讨论过函数。但这里的主要要点是你有一个蓝图，你可以定义这个对象创建后的样子。

完成了。现在注意我如何将它们混合在一起。我们在定义蓝图，同时也在定义对象创建后的行为。这就是人们混淆的原因。继续。制作一个sleep函数。让我们在这里疯狂一点。继续说。Hungry，并且。去掉这个。

或者在范围内的X。我不想做任何太激烈的事情。就5。然后我们将说self.dot miow。所以当我们说self时。记住。我们在获取这个蓝图的当前实例，正在内存中运行的内容。我们将调用这个函数。所以如果你有两只猫，我们在获取其中一只并说。

现在让这只猫叫“Miow”，我们将调用这个函数。所以在你自己的类中工作变得非常简单。现在，从这里开始，我只是想说。继续。再加几个，只是为了展示你可以在这里做一些事情。我想再加一个。我们将说描述。

在这里，我想打印一些东西，所以。我们将打印出颜色，因为我想知道这只猫是什么颜色。说是歌剧英语吗？所以我们说名字是颜色。是。妈妈，谁是。几岁。这个小函数很简单，但我们想展示的是你几乎可以做任何事情。你可以让函数调用函数，做复杂的数学运算。

你实际上可以创建其他类的实例，几乎可以做任何你想做的事情。但现在我们已经完全定义了一个猫的蓝图。这个猫将有一个构造函数，我们正在设置变量，它会叫、睡觉，饿的时候会叫很多次，因为猫就是这样做的，我们可以让它吃东西。

我们还可以获得那只猫的描述。到目前为止，我们的类并没有做任何事情。这是因为我们还没有创建一个实例。记住，类只是一个蓝图。现在我们必须实际创建一个可以工作的对象或实例。所以让我们回到文件中。我们需要做的第一件事是导入它，这样我们才能实际使用它。

现在我们必须导入这个，因为它在另一个文件中。如果它在同一个文件中，我们就不需要导入，但让我们继续。导入。At。现在我们可以直接使用它，或者如果我们真的想的话。我们可以说这样的内容，从。At。导入，然后我们可以导入猫类。

所以现在我们可以说，从猫文件中，导入这段代码。当我们进入这里时，就是猫类。所以如果你在这里有多个类，它只会导入猫。而导入猫则会导入该文件中的所有内容。

所以这就是为什么你会看到这两个在外面出现。

现在重要的部分，让我们继续使用这个类。现在，当我说使用一个类时，我们实际上是在创建这个类的实例。我想做一个名为test的函数。现在你可能会想，为什么这里没有self。你一直在说self，因为我们不在一个类里。

我们没有当前对象。因此没有当前对象或实例。我们在全局范围内运行。我们根本不需要它。如果我们尝试使用它，实际上我们只是创建一个需要传入不存在的对象的参数。所以这没有意义。如果听起来让人困惑。

这是因为在这里放self没有意义。所以我们将说B等于cat。现在。你会注意到从其他语言来看，你需要像new那样的关键字。在Python中不需要这样。它自动处理。你确实需要括号，所以。现在我们需要给它一个名字、一个年龄和一个颜色。如果你在想我如何得到这些。

这是因为我们在构造函数中定义了它，它需要一个名称。年龄和颜色。我们没有调用self，因为Python会自动处理。实际上发生的是，它在说，创建一个猫类的实例，然后在背后隐形地把self放在那里。或者说X，就是那个类的实例。我们不需要自己去做。

Python为我们做了这一切。这是一个隐藏的小陷阱。你可能在想self来自哪里，Python会为你处理。好了，我们有了这个猫。让我们再创建一只猫。我们叫它Beello，这曾是我的一只猫。它是一只非常棒的猫。我非常想念它。它是一只黑猫。

很多人不喜欢黑猫。他们认为黑猫带来厄运。但这是我一生中拥有过的最好的猫。所以我们有了两个实例B和C，它们是两个不同的东西。让我们打印出B的描述和C的描述。如果我们想的话，我们可以进一步展开。

我们可以说C是Miow。如果你在想，是的，你可以给它一个更复杂的变量名。你实际上可以叫它kit cat或Deer或你想要的任何名字。让我们继续调用sleep。C会感到饥饿。因为猫总是很饿。然后我们将说，你知道吗。B不饿，B要吃。如果。名称。等于，我们之前在另一个教程中做过这个。

但以防万一。我们在检查Python是否直接运行这个。如果是的话，我们想运行一些代码。现在，我说这是主函数。我们实际上不需要一个叫main的函数。我们可以做任何我们想做的事情。这就是Python的美妙之处。我将说X。

我们将给这个命名为测试，注意年龄和颜色已经有了默认值。因此我们不需要它们，但必须有一个名称。我们在函数视频中涵盖了所有内容。我接下来将打印出X。我还不打算调用这个测试函数，我想先给你展示一些东西。

Name E White是不对的。我们在这里搞错了什么。让我们进入这里。我们在Cat do Py的第7行。好吧。有趣。Name white没有定义。Aim white没有定义。你觉得这里发生了什么，我们有第12行。color white，这就是我们缺失的。我本来是在处理某种不存在的对象。所以如果你遇到没有定义的情况。

有点即兴解释，这就是为什么我们简单地，而不是一个字符串。我们试图传递一个对象，这个修复非常简单。但有一瞬间。这确实让我感到困惑。好了，现在让我们清理这个，再次运行。好了。所以你会看到这个，你会认为你有一个错误。

但实际上这里发生的事情是在告诉我们。下划线cat是文件名。点。帽子，所以我们可以实际进入这里，看到它到底在做什么，然后对象。所以现在我们有一个正在处理的对象，面向对象编程的一个实例。它位于这个位置。现在，这看起来确实很困惑。

这实际上是一个内存位置。所以如果你来自像C或C++这样的语言，实际上可以直接操作内存。这就是内存位置。这真的很酷。所以现在我们可以知道这里发生了什么。让我们回到这里，实际上。Brenent出。好吧。让我们清理这个，同时调用我们的测试函数。让我们看看这个整个过程。

现在我们知道了。我们代码中的严重错误已经修复。我们知道这个类可以正常工作。我们可以开始创建更多实例。那么，快问一下。我们正在创建多少个这个类的实例？三个，你是对的。1、2和3。让我们运行一下，看看它的实际效果。好的，向上滚动到底部。实际上。

我就要把这整个事情提出来。所以我们有。猫，猫对象在这个位置。然后你会看到构造函数为kittca和Othello触发。所以构造函数被调用。即使我们没有调用，它也是自动调用的。把这看作类的主函数。如果你对那是什么感到困惑。

再次回顾一下，这是一个下划线构造函数。回到输出这里。你现在可以看到我们在这个位置有一个猫对象，在那个位置也有一个猫对象，你不需要记住这些数字。但是如果你看一下最后几个字符，你可以看到它们在不同的位置，这就是你知道它们是不同对象的方式。因为Python在三个不同的内存位置创建了三个不同的对象。

我们可以独立地处理它们。Kit cat是一只1岁大的虎斑猫，而fellow是一只6岁大的黑猫。这是面向对象编程的基石。然后我们可以直接与这些对象进行操作，并几乎可以做任何我们想做的事情。所以，视频的主要要点是，我们正在讨论面向对象编程，并且我们在谈论类。

这些是对象的蓝图。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P31：31）类继承 - ShowMeAI - BV1yg411c7Nw

大家欢迎回来。我是Brian。我们将继续Python 3的学习，讨论类继承。现在，当我们谈论继承时，我们并不是在谈论一个亲人去世后留下给我们的所有财物。我们在讨论一个类如何继承😊，或包含其他类的属性。所以，比如说，你出生在这个世界上。你有母亲和父亲。

你有发色和眼睛颜色，这些都是来自你的母亲和父亲。你继承了这些特征。这就是我们谈论类时的真正含义。这可能会变得非常复杂，我们将看看一些可能出现的问题。

好吧，我们将以极快的速度浏览这一部分，因为我们之前已经讨论过了。我不想浪费你们太多时间。我们现在要创建一个猫科类，记住，Gass只是一个蓝图。我将说猫科。然后我将继续定义我们的构造函数。Self，我们给它一个名字。这样就好了。请注意一件事情。

我们在说self name，但我们实际上并没有声明一个名字变量。请特别注意这一点。因为我们将会发现这真的是个糟糕的主意。这就是我为什么说我尽量在顶部声明所有变量。这样。

我立刻知道这个类包含什么，并且它已经被声明。这将会回来并被利用。我会说，正在创建一个D行。所以我们有一个构造函数在这里。现在我只是为了加快速度，准备在猫科类中加入一些函数。它现在可以了，我们可以设置名字。实际上，我们所做的就是Mao打印出自己的名字meo并设置名字。

你猜到了，打印出设置名字。然后我们继续设置那个变量。记住，我们还没有声明这个。

现在，我想创建一个继承自猫科类的另一个类。你会注意到当我将鼠标悬停在这里时，它显示的是猫科猫科。所以这只是一个自包含的类，没有继承。我们将创建一个类。我需要一个响亮的名字，让我来查查我的笔记。我们要创建狮子类。

我们要说class。Lion。你可能会好奇为什么类后面会有一个括号。好吧，我们马上就要知道。Eline，这就是我们在这里所做的。我们在说狮子将使用括号中的所有内容。它首先使用的是猫科类。这就是我们如何继承。现在，我们说deaf。Rar。再次强调，我们必须在其中包含self。

我们可以直接打印一些内容。好了， looks super， super simple。好吧。让我们在代码中玩一下。所以我们可以说C等于B line。我们得给它起个名字。就叫这个kitty吧。继续打印C出来。并且说看Miow。继续运行这个。它说正在创建一个feline。

所以我们的feline类的构造函数被调用了。我们有一个。Main。注意它有下划线main，所以我们在主部分。这意味着这是Python的根。它在这个内存位置创建了一个feline对象，而kitty在喵喵叫。现在，让我们来创建一些lions。我得说L等于一个lion。

让我们称这个为Leo。继续打印那个对象，以便我们能看到底下发生了什么。我们还可以说L.dot Miow。现在，你注意到一些神奇的事情刚刚发生了吗？狮子类没有meo函数。它是从feline继承的。所以简而言之，你继承的一切，你现在都有访问权。这是非常酷的。

我们也可以向这个类添加内容。所以我们说狮子不仅仅是fee line。所有这些类，所有这些蓝图，还有我们可以定义的额外内容。所以现在我们可以说像L.dot。Rar。继续运行这个。果然。正在创建一个fe line。你注意到fe line的构造函数被调用了吗？然后狮子被创建。

有趣的是它是如何工作的。我们没有为lions定义构造函数。所以我们看到的是fe line的默认构造函数，很有趣。这在下一部分会回来困扰我们。我一直在说我们会有个糟糕的时光，而那就在眼前。

但我希望你理解这里发生了什么。Hython正在创建一个fee line并创建一个line，这两个合并成一个对象在这个位置。但它会简单地说main.dot line。现在main，当然就是这个文件。而Leo将会喵，Leo将会吼，如果我只是稍微向上移动一点。

你可以看到小猫在喵，狮子在喵，狮子在吼。所以一切按预期工作。现在，系好安全带，因为事情将会变得非常，非常颠簸。

让我们在这里创建另一个类。我们将称之为虎类，因为我们将继承feline类。差点说成计时器。那会很有趣。好了，我们有了feline类。现在。有件事我要做。我会在这里抓取这个。我想引起你对默认构造函数的注意，我不应该说默认的。

我们的猫类的构造函数，其中有一个self和一个name。记得我说过我们没有初始化那个变量的原因吗？我们现在就在这个构造函数中初始化它。但我现在要做的是去这个ti类，猜猜我把它放在这里。我打算去掉name，因为猜猜看，我们在继承。猫类有一个名字。

所以我不想在老虎身上搞乱它。所以现在我有一个不同的构造函数。尽管你可以看到我们正在构建一只猫，但坏事即将发生。好吧，让我们继续说构建一只老虎。我想在这里添加一些注释。它们可能现在看起来没什么意义。Super让我们可以访问父类。

当我说父类时，我们在谈论的就是这一点。我们所继承的或者说基本类，如果我们忘记了。这将导致后续问题，意味着我们可以说super parent。在这种情况下，就是猫类。调用构造函数时使用一个名字。我们只会设置no name。没有。

我要把那个注释掉。我们只会说正在创建一只老虎。哦，天哪。我们这里有一些问题。所以现在让我们继续制作另一个函数。我们会说停止。现在我试图在进行中解释这个，以便你理解为什么会失败，因为它确实会失败。我们在这里做的事情。

我们试图依赖Python为我们管理所有这些。我们必须确保。在父类中设置了name。当我们说父类时，我们在谈论super或基本类。这被认为是“先看再跳”。我们正在动态添加属性。我的意思是，动态添加属性。就在这里。

我们在猫类的构造函数中添加它，如果我们在老虎类中使用自己的构造函数而跳过猫类的构造函数，那么那个变量就不存在。当你调用一个不存在的变量时，会发生什么？你会得到一个未定义的错误。所以让我们打印一下。我们将进行格式化打印，并且我们会说self不是name。注意，telecus说这是有效的，因为我们正在使用蓝图。

不是一个对象。更糟的是，我们认为这会起作用。让我们继续再添加一个函数。假设我想能够重命名它。我们会说super，因为我们知道有一个super的概念。我们实际上是在访问猫类，并且我们将调用猫类的set name。

如果你在想，是的，我们实际上可以调用老虎的set name并直接设置名字。但我想向你展示，如果你想的话，可以直接上升到super并调用猫类。如果这看起来非常复杂，那是因为它本来就是这样。我试图向你展示，super是一个与老虎不同的对象。

即使它们合并为一个类，但它仍然是 Python 理解和追踪的一个独立实体。因此，称呼 super set name 和仅仅说 set name 之间的区别非常微妙。Set name 是在 ti 类中设置名称，而 super 则是说，嘿，去上面的 feline 类中调用这个函数。因为记住，当我们创建一个类时。

第一个创建的是我们的父类或 super。天哪，这真是让人超级困惑。因此，这是我们在这里要处理的微妙复杂性之一。因此，主要的收获是我们设计得糟糕的 Tiger。我们基本上创建了自己的构造函数。😊，我想在这里插入一个注释，覆盖构造函数是个坏主意，因为我们现在有了“鸡或蛋”问题，其中 self.dot name 并不存在，这甚至没有被定义。

让我们展示这一切，只是为了表明它会爆炸。所以我要说 Tiger。我想在这里插入一个注释，是一个 feline，但有不同的构造函数。我们生活在不同的构造函数中。所以现在没有名称，我们已经偏离了我们的类设计。让我们打印出来。

保存并创建一只老虎。注意主老虎对象是如何被创建的。它没有爆炸。现在，回到 stock。记住，我们要打印 self.dot name。但我们从未说过名称。哦，哦，坏事要发生了。让我们看看这次失败，然后理解为什么会失败。哦。

属性 air ti 对象没有属性 name。记住，我们在覆盖这个构造函数，因此我们必须初始化它，这只是因为我们没有像这样做。如果我们在这里，它会在 feline 中被初始化，并且每当 feline 被构造时，它会强制初始化。但因为我们没有这样做，我们依赖于 feline 构造函数，而在 tiger 中。

我们定义了自己的构造函数，它在 feline 中从未被调用。这真是让人困惑。因此，主要的收获是，除非没有其他选择，否则不要在子类中覆盖构造函数。始终依赖于父类的构造函数。否则，你必须确保你在这里调用。要么是构造函数，要么在这里初始化变量。

哦，这就是为什么这个叫做“三思而后行”，因为我们想确保我们实际上可以做些什么。我们想确保名称在父类中，这就是“在精英之前”的原则。所以我们在这里做的是确保它存在，三思而后行还有很多其他内容，但这就是基础。现在让我们继续运行这个。突然，没有名称追踪。

它从哪里获得没有名称？它正是从这里获得的，所以我们在说 Tiger 创建。然后我们说，去 fee line 调用那个构造函数，但我们没有名称。因此我们只是说没有名称。我们可以在那里放任何我们想要的东西，它都会很好地工作。让我们现在重命名它，所以我必须说 t.dot rename。让我们叫它 Tony。

让我们说 T meow，只是为了证明我们在继承猫科动物的属性。T dot stock。再叫一遍。我将把这个提得更高，以便我们看到实际效果。清理一下并运行。好的，那么这里发生了什么？创建一个猫科动物，创建一只老虎。老虎已经创建。没有名称在潜行。我们已将其重命名为托尼。

托尼现在在喵喵叫并潜行。如果我们回到构造函数的领域，并注释掉这个。我们将会有麻烦。我想真正强调一下，崩溃的原因是因为我们绕过了这个构造函数，而名称从未定义。

让我们再看看它是如何失败的。果然，老虎对象没有属性名称。好的，所以从这个视频中主要得出的结论是，继承非常酷，非常强大，但有一些隐藏的问题你真的需要注意。除非你绝对知道自己在做什么，否则不要重写构造函数，并确保如果这样做，你要控制这个过程。

调用 super 的最简单方法是在其中调用父类的构造函数。但还有其他小问题，你需要确保在行动之前仔细查看，或者做某种错误检查，否则你会遇到一些疯狂的问题。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P32：32）多重继承 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好，我是布莱恩，我们要谈谈多重继承。我们已经覆盖了类，已经讨论了从另一个类继承。但是，如果你有多个类想要继承呢？

这正是我们要做的。有些语言甚至不允许这样，因为它变得非常复杂。让我们深入看看。

让我们在这里继续创建一个类。所以我们要创建一个车辆类。或者说是类。别说。如果你记得上一段视频，我绝对喜欢确保变量的实例确实被创建，这样我们就不会遇到那种讨厌的。

未定义错误。我们要继续保存驾驶。不是说我们没有放入初始化，这里我们根本不需要它。我们将保留默认构造函数。我会说，因此。逗号，然后是速度。我们会把这些保持得非常简单。我们会说驾驶，我们会设置速度，我们会简单地复制并粘贴这个。

我想要另一个叫做停止的函数。我们将把速度设置为0。我们不需要。那个参数。现在让我们继续创建另一个函数。全部显示。这个地方会变得有点有趣。特别注意这个函数，因为我们将在另一个类中再次使用这个函数。

当说打印。我们只会简单地说以某个速度行驶。

非常简单的小自包含类。

让我们继续创建另一个非常、非常简单的类。我只打算创建一个冷冻机类。这个东西存在的唯一目的是冷冻食物。有一个冷冻机。让我们继续创建一个变量。我们叫它temp，等于0。所以我们将在这里默认将温度设置为20。现在，我会说困难。冷冻。

所以我们能够在特定温度下冷冻一些食物。我必须说，自我.温度。是我们刚传入的温度。现在我们来打印一下。正在冷冻，以便我们知道冷冻机实际上会，你知道，令人震惊地冷冻食物。现在我要从车辆类中实际获取这个，显示自我。

我们将修改这个，但我们会把它放在冷冻机类中。你不必完全复制和粘贴，只要名称相同即可。我们要做的是故意在这两个类之间创建命名冲突。因此车辆和冷冻机都有一个显示函数。我必须说正在冷冻。自我.温度。

因为冷藏类中没有速度。非常简单，非常容易理解。所以我们可以独立调用这些，调用display，看看到底发生了什么。现在让我们看看如果使用多重继承并将这两者结合在一起会发生什么。

好的，让我们继续将这两者结合在一起。我们要创建一个冷藏卡车类。我将说class FreezerTruck。我们需要一个冷冻机和一辆车。我们将把它们合并成一个巨大的类，最初我只会说pass。所以我们只是声明这个类，它没有其他功能，这就是在 Python 中pass的作用。

然后我们将继续创建它。我将说T = FreezerTruck()。T.drive()，我们希望以每小时50英里的速度行驶，在美国这实际上相对较快。然后我们将说T.freeze()，我会把这个设置为负30。无论我们携带什么，我们都不希望它在去商店的路上融化。

然后我将继续打印。现在，我们将打印出一些破折号，以便进行分隔。现在，我们要说tea display和小测验。我们有多个显示。我们有冷藏类显示和车辆显示。哪一个将被显示？所以我们要么看到Freezing，要么看到Driving，到底哪个会发生呢？

让我们找出，保存并运行。以负30的速度冷冻。我们没有速度。我们看不到驾驶。因此，现在我们有多个问题，我们希望能够看到这两个。但是我们所定义的，无论我们意识到与否，是一个新概念，称为方法解析顺序，或称 MRO。你会一次又一次地听到这个。

你会看到论坛上的人们在问如何访问或为什么会发生这种情况。所以顺序非常简单。先来先服务。所以我们先定义了冷冻机。因此，它将显示冷冻机。如果我们只是交换这两个，我们仍然在做同样的事情。我们仍然在继承这两个。

但是看看这里会发生什么。以50的速度驾驶。所以这就是方法解析顺序。先来先服务。这真让人沮丧。那么我们怎么能解决这个问题呢？让我们说def display()。走吧，让我们继续，并打印这些，假设是print()。我想给你展示一个小把戏。我想确保这些实际上是子类。

所以我将说is a FreezerTruck。我们希望它是Sb.Basss。基本上我们是在给当前类定义，所以它是冷藏卡车。诶，Freezer。然后我们只会说，is a Vehicle。抓住这个。不错，听着，看看当我们现在调用display时会发生什么。是冷藏吗？是车辆吗？

现在我们调用自己的函数，实际上我们可以判断它是否继承特定类。你想检查的类总是放在第一位。你想对比的类放在第二位。现在。让我们看看我们如何解决这个问题。我将说super。所以我们要调用父类，问题是我们现在有两个父类。

那么我们试着独立调用它们。比如，冰箱。自己。那个显示。我要使用同样的东西。但我们要用车辆。所以我们在说“super”。调用车辆，super，使用当前对象调用冰箱，然后直接调用显示，看看这里会发生什么。哦，我们遇到了麻烦。

所以让我们在这里深入看看，在第42行，T显示，这个家伙在这里。然后它跳到第36行，就是这个家伙。Super对象没有属性显示。现在，等一下。我们是有的。如果我们看冰箱，它就在那。那么这里发生了什么。好吧，再次。

方法解析顺序出现了问题，提示我们“不能这样做”。所以为了证明这一点，我们先把冰箱和那些车辆注释掉，然后再运行一次。一切神奇地运作了。这真让人沮丧。好的，我们继续把这些注释掉。这并不是我认为的正确做法。

不过我会在这里添加一些注释，以防有人抓取源代码。那么，做这件事的最佳或正确方法是什么呢？我们将直接调用那个类，还有其他方法，可能还有更好的方法。但这就是我们在目前有限的Python知识下要做的。

我们要说冰箱.显示。记住我说过，当我们继承一个对象时，Python正在创建它。所以它知道冰箱卡车里有一个冰箱。因此，我们要调用冰箱的显示。我们要调用车辆的显示。让我们看看这个运作情况。现在我们可以看到我们在冷冻和驾驶。哦，天哪，超级 confusing。

所以这段视频的主要要点是，Python确实允许多重继承，但它有一些陷阱，主要是命名冲突。例如，我们看到车辆和冰箱都有一个显示函数。但是一旦我们同时继承它们，MO就会介入并说我们只会使用第一个。所以如果我们想使用多个。

我们必须独立调用它们。😊，超级具有挑战性，但一旦我们理解了这一点，它也是非常优雅的。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P33：33）构建宠物店应用程序 - ShowMeAI - BV1yg411c7Nw

欢迎回来大家，我是布莱恩。我们将把迄今为止学到的所有知识应用到一个宠物店应用程序中。这将像一个迷你库存系统。所以在深入之前，我们先快速谈谈设计。

首先要发生的事情是Python将启动我们的脚本。从那里开始，我们将去桌面加载任何现有的文件。然后我们将进入一个循环，让我找一个好的循环示例。这个循环只是会问他们想做什么？

它将会做一些类似于这样的事情，你可以选择几个选项。任何一个选项都会回到循环中，所以让我抓取这个。直接上到这里。最终，我们将退出程序，此时它会自动保存进度。

最终结果将看起来像这样。开始加载循环的一些选项。然后当我们退出时会保存。让我们深入看看。

好的，接下来我们将导入，我将在这里插入一些注释，这样我们可以看到之前小节中的结构。我们将创建一个类。这个类将有一些函数。

我们将有我们的主函数。然后我们将进行一些测试。但首先，我们需要导入我们将要使用的东西。所以我们将导入两个东西。我们将导入J和OS.path。杰森将用于保存和加载文件。我们希望有一个字典，能够将其持久化到磁盘。然后进行导入。

我们将使用OS路径，虽然有更现代的方式，但我们想检查文件是否存在。所以我们将使用OS路径，因为这有点像老派的做法。

一旦我们完成这些导入，就可以开始了。

现在，库存系统可能会变得有些复杂，所以我想创建一个类。我想将功能封装在这个类中，这样如果我们有多个库存，就可以分别处理。某个类。库存。接下来我们创建一个字典。我们将创建一些函数。所以我们将进行初始化。

对于这些初始的内容，我将暂时放入pass，因为我们现在不想在这里添加任何代码。我们将随着进展来填充这些内容。想要添加。我们可以稍微加快这个过程。因此我们将添加remove。我确实想能够显示库存中的内容。显然，我们还想能够保存，因为我们将把它输出到文件中。

而且因为我们可以说我们也想加载这个。现在你可能会想，为什么我不把它放到一个单独的文件中。我有点想要一个一体化的解决方案，只是想给你展示我们实际上可以做到这一点。下一步，现在我们有了类，我们将开始填充这些函数。

好的，到目前为止，我们有了一个类。这是这个类的一个高层次的视图。它包含init、add、remove、display、save和load。我们将填充并编写init和add。让我们下去看看我们的init。老实说，我想保持这部分简单到极点。我们在一开始就说，一旦这个东西启动，我们就想能够加载。

我会说self。😊，加载，我们将把所有功能放入这个函数中。现在，add在这里会稍有不同。我将去掉这个pass，并且我们将修改函数本身。我们想要一个关键字和一个数量。前提是，当我们添加时，我们会添加某种动物，比如猫。

一只狗或者其他什么，还有我们要添加到库存中的数量。所以我会说数量的简写Q将是零。现在，如果你看字典，它里面绝对什么都没有。所以我们不能直接去获取关键字。我们必须先测试它是否存在。所以它的关键字在self dot pets中。

然后我们将继续获取当前值，比如说我们在库存中实际上有多少。self dot pets。我们想要获取关键字。接着我们会更新我们的数量。也就是说取当前值并加上数量。现在，我们有了相反的情况。它根本不在库存中。

在这种情况下，我们将说Q等于。Thequ。从这里开始，相对简单。我们将说self dot pets。无论关键字是什么，我们只需用更新后的数量更新它。从这里开始。我将放入一些内容。为了节省时间，我将复制并粘贴。

添加了数量和关键字，当前总数就是我们库存系统中实际的数量。所以这相当简单，但这里有几个关键概念需要理解。首先，我们不想相信这个关键字真的在里面。我们需要测试以确保它存在，并且需要一些功能以防它不在那里。

在文件顶部，我们完成了导入。我们创建了类，填充并添加，现在我们将进行删除和显示。因此让我们到这里，删除一个显示，稍微跳过它们。所以我首先要做的是去添加，然后我想复制这个。

这样一来，我们就有一个非常相似、非常结构化的API来添加或删除，只需要一个键和一个数量。我们不会有任何奇怪的数据需要处理。所以删除正好是这里的相反，但我们实际上可以提取出这部分内容。例如，我们可以把整个结构直接复制到这里。所以我们将从0开始，我们会说如果键存在。

然后继续获取键。数量将是减法，而不是加法。然后我们想要一些其他的值。例如，我实际上不需要else，因为Q已经设置为0。实际上，让我把它放在正确的行上。我们现在要做的是测试，确保没有减去太多。

假设如果Q小于0。那么。我们想确保Q等于0。换句话说，你不希望在库存中出现负余额，这显然是没有任何意义的。然后，当然，我们正在更新库存，现在我们有某种输出给最终用户的显示。我们会说移除的数量键。

总数现在是，无论总数是多少。对于我们的显示，这将非常简单。或键值在。我们希望进入self.dot pets。如果我所谈论的任何内容让你感到困惑，我强烈建议你去观看我们讨论这些关键主题的视频。

例如，我们讨论过类。我们讨论过字典。我们讨论过四个循环和类似的事情。我们还讨论过Jason，以及几乎我们在这里谈论的所有内容。这些都在我们制作的32个其他视频中。现在让我们继续打印出来。

我将要说打印。并且我想要进行格式化打印。接下来我要说的是键。等于。然后是任何值。现在，在我们开始进行输入输出之前，我通常会在这一点上先运行一下，以确保没有任何奇怪的错误。

脚本将完全不执行任何操作。我们甚至没有主函数。我们只想确保没有任何奇怪的语法错误，类似的东西。好的，在我们的类中，我们处于保存部分，让我们一直往下到保存，我们将分别处理保存和加载部分。因此我们只专注于保存。所以我要去掉这个pass。

我想要提醒用户，我们要做一些事情，因为。好吧，因为我们在使用 Python，我会非常诚实地告诉你。我们不知道这将运行在什么样的终端设备上。它可能是一个高端的超快速服务器，也可能是一个极其缓慢的嵌入式设备。

我们根本不知道。所以我想告诉他们，我们要做一些事情，保存库存。当我处理任何 IO 相关的事情时，我通常会在之前和之后告诉用户，意思是我将要做某事，我已完成它，或者我遇到了一些错误。所以我会以这样的结构开始：保存和已保存。然后我会实际处理 IO。

原因是。如果你正在使用电脑，电脑的硬件驱动可能非常快。但如果你使用的是嵌入式 Linux 设备，脚本在上面运行，可能会非常慢。或者，如果硬盘进入休眠状态呢。

我相信你之前遇到过这种情况，保存文件时，听到硬盘转动的声音。我们希望确保用户知道我们的应用程序没有冻结。所以我们要说，打开，假设是 inventory.txt。现在，为了节省时间，我们要稍微打破自己的规则。

我们在谈论将所有这些放入一个类中，以便可以重用。问题是我现在在硬编码文件名。这不是个大问题，但如果你打算用于任何生产用途，你确实希望能够动态设置该字符串。好的。

所以使用 open，我们将以写模式打开这个文件，普通文本，FF 是文件的缩写。现在我们想做一个 J。记住，dump 和 dumps。你看到末尾的 S，这是我们要将其转换为字符串。我们不想这样。我们希望将内容实际导出到文件中。所以首先。

我们必须传递对象，在这种情况下，是 self.pets，以及我们要导出到的文件。关于 with 关键字，之前的视频中我们已经讨论过，它会自动为我们关闭文件，所以我们不必担心刷新内容或关闭文件。然后 JSON 将把这个字典转换为 JSON 格式。

将内容导出到文件中，然后 with 会为我们关闭文件。接着我们只需打印出已保存，这样最终用户就会知道，我们实际上已完成了 IO 操作，并且没有错误。

我们只剩下一个了。加载功能。哎呀，帮我选择对了。所以这是我们的类。我试着缩进一下，以便让函数在类内部看起来更明显。我们还有一个加载。它当然会加载文件。我们已经完成了保存，因此我们可以借用这里的小结构。

所以让我们抓住这个。😊，然后粘贴它。我们可以说我们可以拼写对，加载库存。然后加载它。请记住，文件名很重要。所以我们必须说使用同一个文件，我们将以纯文本格式读取它。现在。我们想要做的是转储的相反操作。因此在这里我们需要放慢速度。

我们在这里有点急于求成，我在想你是否能看到问题。如果你看不到的话。使用打开文件时，我们只是假设在加载时文件是存在的，我们需要对此稍微小心一些，因为这可能会引发一些真正的问题。但这就是我们一开始进行导入 OS 路径的原因，因为我们要检查文件是否存在。

所以让我们回到这里。我们会说。如果没有，O，S。点路径，点存在。在这里我们要确保文件名相同，所以我将字面上复制这个。然后粘贴它。接下来，我们想说。跳过加载。然后让我们退出这里。我们这样做是因为当调用加载功能时。

它会打印出加载库存。如果我们只是返回的话，它看起来像是程序挂起了，因为它会说加载库存并停止。因此我们要确保文件存在，如果不存在。然后我们会说跳过，没有要加载的内容，这样用户就知道那里根本没有文件。

你可以让这个看起来更好一点。然后我们会转到，如果有文件的话。我们将说用打开。以读取模式打开该文件。现在我们需要进行一个 J 加载，而不是转储。我必须说 self 点 pets。等于。Jason 点 load。请记住，如果以 S 结尾，则它会将其转换为字符串。

我们不想要这种情况。所以我们想加载，我们只需给它我们的文件。最后但同样重要的是，我们要打印出加载的信息，这样最终用户就知道，嘿。我们成功完成了输入输出操作，没有遇到任何问题。再次提醒，我喜欢运行。脚本不会做任何事情，但如果我有一个重大的语法错误。

它肯定会输出并告诉我。我们就可以继续了。看看我们的流程。我们已经走了很长一段路，我们完成了导入，整个类也做完了，现在我们要放入主函数。所以我要一直到底部。然后我会说。主，这会自动为我放入这里。

根据你的IDE，你可能需要实际输入这个，或者说如果名字是main。这意味着Python直接运行这个文件，那么我想要。调用一个主函数。很多人会想将其当作某种函数使用。我不喜欢这样做。我更喜欢实际创建自己的主函数。

这样我实际上可以直接复制并粘贴这个函数，在其他地方使用。无论我想做什么。所以我们需要创建一个实例。我们的库存，因为记住，一个类是一个蓝图。它并不是实际的对象。现在我们可以用这个蓝图告诉Python，拿去这个蓝图。

创建一个对象并将其以名为I N V的变量形式提供，I N V是库存的缩写。现在我们有了这个，我们可以创建一个循环。我知道在过去的视频中，我说过循环是万恶之源。应该避免，除非你知道自己在做什么，但。如果你一直在跟着。

到了这个阶段，我们应该知道自己在做什么。首先，我们要做的就是提示用户进行某种操作。所以我会说操作等于。我们想要输入。然后告诉用户，嘿。告诉我们你想做什么，我已经准备好这些内容，在我笔记中准备就绪。我应该说在屏幕的旁边。所以我们要说你可以添加、移除、列出。

保存或退出。这些是我们将在这里具体化的操作。所以首先。如果操作等于退出。那么我们就直接跳出这个循环。注意我没有返回，因为我想在最后做一些事情，让我回到这里。我们要说I和V，点保存。因此无论用户采取什么操作。

一旦我们完成这个循环，库存将在程序退出之前自动保存。我将把它放在这里。退出。Python处理脚本的方式是，一旦没有其他事情可做，它就会直接退出Python本身，这就是你看到它在这里停止的原因。好的，所以。一旦我们把这个放好，现在我们真正要具体化其他操作。所以，我要说。如果。

我们实际上可以复制这个，简化生活，老实说。我是复制和粘贴的忠实粉丝。如果操作是列出。那么我想要I N B那显示。如果操作是保存。我们可以直接说I和B，点保存。你可以做加载和其他所有操作，你注意到我没有把加载放进去，因为库存将会自动加载。

在构造函数中。但如果你真的想疯狂一下，你可以把那个操作放进去，Defite放进去如果你想要。现在。我将在这里放入一些逻辑，我们要说如果操作是添加。或者。操作是移除。那么我们将大致相同的内容。

这里的功能类型没有关系，无论是添加还是移除。我们有相同的API。让我们稍微向上滚动一下。所以移除时，我们需要键和数量，添加时也需要键和数量。所以无论我们在做什么，这里都没关系。在这里，我会说键等于输入。成熟。一个动物。而数量则是输入。一旦他们输入。

关闭了y。现在我们有了这两个，我们需要弄清楚实际调用的是哪个。所以我会说操作等于添加。然后做点什么。如果你已经了解一点Python，你可能知道有更好的方法来做这个，但我们只是使用到目前为止学到的东西。所以我得稍微简单点，不想说降低难度。

不过我得把它做得简单一点。所以，这就是障碍。我们将分支逻辑，假设是添加就做一件事，假设是移除就做另一件事。好了。最好实际调用移除。否则，我们就会添加两次。这就是拥有相同类型API的美妙之处。

如果你愿意，你现在可以开始将功能包装在这里，使其超级简化，超级容易跟随。😊所以遵循我们的逻辑，让我在这里抓取一些屏幕空间。当我们进入主程序时，我们将创建一个库存实例，然后开始一个循环。循环完成后，无论用户做了什么，我们都会保存这个库存。

在循环中，我们将不断询问用户：你想做什么，然后根据他们输入的内容采取行动。

剩下的事情就是系好安全带，测试一下。如果你有__name__等于__main__，并且你有主函数，没有语法错误，你应该就可以开始了。让我们抓取一些区域，这样我们就可以看到程序运行的情况，我们将运行这个。

它说正在加载库存，跳过没有可加载的内容，因为我们这里没有相邻的文件。它将显示操作：添加、移除、列表、保存和退出。所以让我们添加。我想输入一只猫。我输入数量为六只猫。因为生活中必须有六只猫，这是强制性的。

假设我们添加了6只猫，总数是6。所以让我们添加。我想在这里添加三只猫。所以我们添加了三只猫，现在总数是63。我们的程序中有一个bug。让我们结束这个终端。找出我们做错了什么。嗯。注意到输出有什么异常吗？它显示63而不是9。我们现在需要转换这个。

进行整数操作。记得我们简要讨论过类型转换。可以把类型转换想象成一个拿着魔法杖的巫师，他将施展法术，把一个东西转换成另一个。实际上，我们在幕后所做的是在说数量，然后动作添加到这里。它在说 V 加上 QTY，这就是 Python 及类似语言的祝福与诅咒，因为你没有类型。

它知道它们都是字符串，因此它只是将它们作为字符串相加。因此，一个字符串。它看起来像这样，正是我们刚刚看到的。够了。让我们重新运行这个。现在，由于我们关闭了控制台，我们仍然没有 JSson 文件。这正是我们此时想要的，所以让我们重新运行这个。好的，让我们再试一次。

添加。在6，因为你得有六只猫。和我一起说。我们要添加。在。我们想要添加3。现在我们总共有9。所以我们的逻辑现在按预期工作。让我们继续添加。一只狗。我说我们想要99只狗。然后我们意识到那太多了。我们真的不能有99只狗和9只猫。所以我们就。

放慢一点。让我们移除。狗。伙计，你知道，我喜欢狗和喜欢猫一样多。这对我来说是个很艰难的时刻。让我们继续。移除98只狗。我非常抱歉，狗们。今天不是你们的日子。我们已经移除了98只狗。现在我们总共有一只。现在，我们可以输入保存。但我将直接退出。保存的库存已保存。

所以它为我们自动保存了，并且生成了这个库存 TxT。如果我们出去看一下，我们有九只猫和一只狗，一切都如预期般工作。我将清除我们的控制台。然后重新运行，这里会发生一些神奇的事情。加载库存低。让我们调用列表。我们有九只猫和一只狗，所以它现在已经加载了那个 Json Voil，并将其装载到字典中。

一切都按预期工作。我将继续说，只需按下，按下，按下。你可以看到，由于没有有效的输入，它只是回到了循环中。我将输入一些垃圾数据。无论我们做什么都没关系。我将继续添加。鱼。我想要45条鱼。我将故意保存这个。保存的库存已保存。

我将继续显示。基本上，你可以一直这样做，但哦哦，显示。我不想显示，我想要列表。你可以看到我们有九只猫、一只狗和45条鱼。我们可以这样做整天，但我真正想表达的是，现在我们有了一些编程逻辑，一切都按预期工作。所以我将退出。我们将保存我们的库存。

我们可以去看看，果然一切都和我们完成应用时完全一样。好吧，这段视频的主要收获是。这是我们迄今为止所学内容的总结。我们学习了导入、类、函数、控制流程，了解了Ma，并进行了测试。

我们已经了解了Jason、O路径，以及在这里进行的拆解。😊，总是，永远，永远初始化你的变量，即使只是空的，因为你不想让某个变量未定义。构造函数是你的朋友，因为你可以设置某种默认行为。在不确定的时候，永远检查你的数据类型。确保你给用户提供某种视觉反馈。

生活有时并不那么简单，你需要检查文件是否存在或者类似的东西。我们还讨论了像with关键字以及如何以纯文本读取和写入文件，我想我们也涵盖了二进制文件。

但一个主要的收获是，不要像我那样将文件名硬编码。我这样做只是为了节省时间，但你可能真的想询问一下。如果你想进行一些调整，可以创建另一个函数并将其放入构造函数中，基本上说如果我们没有文件，你想使用哪个文件，让用户输入一些内容？

希望你觉得这次内容既有教育意义又有娱乐性，请在下面留言告诉我你的想法。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P34：34）底层核心 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好。我是Bryan。在这个视频中，我们将讨论下划线。下划线通常被忽视，具有多种用法，确实让人感到困惑。学习不仅仅是Python，而是任何语言的一个障碍就是语法，而Python的语法与其他语言略有不同。因此，它常常让人感到困惑。

甚至季节性程序员对这些东西感到有些困惑。例如，你可以有一个单下划线，可以有一个双下划线。它可以在前，也可以在后，或者是前后结合。但这些不同的方法各有其存在的原因。

我们将深入研究并看看。😊 我们要做的第一个用例是一个单一的，它将是跳过。现在，当我还是个小男孩的时候，我常常逃学，这并没有给我带来多少好处。但在这种情况下，跳过实际上是件好事。我们将说4 X在范围内。我只想打印出hello，并且我想打印出hello。

比如说五次，做一些类似的事情。所以我就要在这里放一个数字。现在，你注意到了一个根本问题，X吗？它没有被使用。代码运行得很好。但如果你通过任何流线程序或任何试图告诉你如何让程序更快更好的解释器运行它，它将开始抱怨X没有被使用。

所以我们可以简单地用一个单下划线替换X。继续清空我们的程序，你会看到它运行得完全如预期。基本上，通过使用下划线作为变量，你是在说我不在乎。我只需要一个变量，我永远不会使用它，Python。

创建一个变量然后把它去掉，这实际上就是我们所说的，因此在某种意义上我们现在跳过了整个变量过程。

现在，为了深入探讨下划线的复杂性，我们需要创建一个可以在这里玩弄的测试类。所以我将进入这里。说person点P，Y。我们继续说class person。暂时我只想说pass。因此我们所做的只是简单地创建那个类。

然后我们将继续导入它。或者说从person导入start。请知道我们将会在脚本和类之间来回切换，因为我想真正演示许多下划线的用法，除非你在类内部工作，否则并不明显为什么需要它。

我们要看的第一件事情是所谓的弱私有，它是单个下划线。如果你向上滚动，这就是它的样子。它仅供内部使用，称为弱私有是因为我们在玩弄作用域。这就是我为什么要创建一个类，正如我们即将看到的那样。所以我要去掉这个pass。

我必须说，我们的自豪感。因此，当你在脑海中想象一个弱私有时，我们在谈论什么？我们谈论的是内部或外部的作用域。如果某样东西是私有的，它对于这个类来说是内部的，如果是公共的，则是这个类的外部。弱私有意味着它对于这个类来说是内部的。

但是这个保护措施很弱，这意味着你可以在类外访问。即使你真的不应该这样做，我们还是来演示一下。所以我必须说下划线名字。等于。有名字。我们在这里做了什么？我们创建了一个变量叫做下划线名字，等于无名字。

单个下划线表示它是一个弱私有。我们在告诉世界，嘿。我们想要在内部使用这个。我们并不希望外界干预。然而，我们可以演示为什么这是一个弱私有，因为我们实际上可以随意操作它。如果我们愿意的话。现在，我强烈建议你不要随意操作私有属性。

但是如果你真的想这么做，只需，嗯，确保你把这件事藏好。我们要说self.underscoreing_name。等于name。我们在这里做的事情非常明显。我们只是说self。这个家伙的名字将等于那个参数。现在我们可以打印出来，验证一下它确实改变了。

让我们回到这里，看看它的实际效果。我们要说P等于Person.y。然后我们想设置名字Ran。继续运行，看看会发生什么。果然，名字被改成了Bryan。所以它的工作如预期般正常。现在，通常情况下，你会被问到。如果你输入变量点，智能提示会弹出。你会看到所有这些带下划线的东西。

还有underscore_name。有趣的是，实际上我们可以抓住这个家伙并对其进行操作，即使我们真的不应该这样做。我们来演示一下。所以我打算说弱私有。让我们继续把这个改为P_name。现在我们实际上可以读取这个弱私有。

即使我们真的不应该。我只是想说，不。即使我们真的不应该。我们可以访问和修改私有的。我放了无，因为你绝对不应该这样做。如果你看到有下划线的东西，请不要尝试修改它，尽管Python会让你这样做。坏事可能会发生。那个下划线，单个下划线，表示仅供内部使用。

当我们说内部时，它在其作用域内。在这种情况下，就是类。所以是的。无论是谁创建了这个类，都很不错，让你访问它。你真的不应该。你不应该依赖于此。相反，你应该依赖于函数来获取和设置值。

好吧，让我们退一步，想想作用域。我们谈过仅供内部使用的弱私有。但现在我们要谈谈。双重。它在这之前仅供内部使用，并避免在子类中的冲突，并告诉 Python 重写名称。这也叫做名字改编。那么我们到底在谈论什么呢？

好吧，我们在谈论一个前面带有两个斜杠的变量。我们正在告诉 Python，我们希望它仅用于内部使用，并采取额外一步自动更改变量名称。哦，这听起来有点可怕。那么让我们搞清楚需要做什么。让我们进入我们的类。😰，我将在这里做个笔记，以免迷路。

强私有。这就是我们在讨论的内容。你想要一个强私有。开个玩笑，让我们看看这里。有人说是哑巴。我想要下划线，下划线，思考。所以。其实想一想，这看起来相当简单，所以我会打印。心想。我的意思是，没有人能真正读懂你的想法。如果可以的话。那么。

我们可能都会陷入很多麻烦。我们要说哑巴，并且我们将创建另一个名为 work 的函数。我将说 self。下划线。谢谢。因为我们在同一作用域，一切按预期工作。但现在让我们引入另一个类。Child。我们之前谈过继承。

所以这应该没什么新鲜事。只需继承人类。我们要说哑巴。T 双重，它需要一个名字。我真的不在乎是什么。我们要说 self。下划线和 u O。注意。尽管我们从人类继承，但它看不到下划线。下划线，思考。它只是有那个。好吧，让我们试着强迫它。

所以我们要抓住整个东西。让我们看看会发生什么。接下来保存我们的类，跳回脚本文件。我将这里创建一个新的实例。所以我会说玩得好的人。可以重用另一个实例，但我们只是做一个全新的。

我会说 P dot org。让我们看看这实际上是如何工作的。所以我在想，我可以按预期调用它。现在，我们要做的就是尝试做与一周相同的事情，我们要在这里说 P。不是下划线，下划线。想想看，inc是否会在这里帮助我们。我们将尝试运行它，但哦哦。没有属性。

这里发生的事情是，我们现在使它强制性。私有，并且在后台进行混淆以处理子类。所以我们甚至无法访问那个函数。它就消失了。根本无法从外部世界看到它。但我们可以在我们的内部类中完美地看到它。哦，天哪，好的，让我们来看看。我将C设为。孩子。记住，孩子实际上是从人那里继承的。在子类中。我们有一个测试双胞胎，它将调用self__think。

这实际上是一个人的一部分。你在哪里，你就在哪里。这是混淆将在这里真正演示的地方，有人说C。我想说，测试双胞胎。有人猜测这里会发生什么，让我们先清除一下。保存运行，哦哦。子对象没有属性。孩子们想，所以。

这里真正发生的是，我们说它仅在声明它的类中被允许。几乎有数以百万计的用途，但你需要知道的是，如果你想让某个东西对那个类及仅对那个类私有。

你将使用双下划线。我将注释掉这些，以便我们可以继续。

让我们来演示一个非常酷的功能。我们将讨论任何之后的内容。现在。我们在这里谈论任何之后的内容，任何数量的斜杠之后。这里有一个很好的用法。假设我想创建一个类对象，我将称之为。人。有人在我运行之前看到这个问题吗，举手，你在后面。哦。

类。你猜对了，语法无效，因为类是一个关键字。哦，这真令人沮丧。我真的想给这个类命名。好吧，这就是我们可以做的事情，实际上我们创建了一个全新的名称。但我们仍然可以称之为类。美化它，这甚至算是一个词吗，美化它。

所以我们可以使用单词类，但仍然不会与任何关键字发生命名冲突，这正是设计它的目的。它有助于避免与关键字的命名冲突，然后从这里。我们可以简单地说类似于无打印。类，然后我们可以打印出来。

根据我们的想法来使用它。看，他创建了一个对象，一切都将如我们所预期的那样工作。把这一切都包起来，我们将讨论后续的内容，我们之前也用过这个。这被认为是Python中对像init和main等功能的特殊处理，我们之前见过。但我想深入了解我们的类，看看我们如何实际使用它。所以。

我们来这里。我们要说前和后，当然，我们已经做过了。在其中。如果你跳过那个视频，基本上这是构造函数。但你注意到这里的语法了。我们有双前和双后。所以基本上，我们告诉Python这是类内部的内容。

我们想避免命名冲突。同时，它不会为子类混淆。但每个子类将有自己的实例。这就是我们可以为人类和儿童提供构造函数的方式。我们在关于初始化器的视频中讨论过这一点。所以让我们使用前后自己创建一个函数，我要说死亡。哦。

如果我第一次拼写正确那就太酷了。好了。我将说打印。太棒了。所以看起来很简单。实际上，这符合Python的精神。它简单到死，而且如预期那样工作。让我们继续说P等于。人。E点双下划线。

你会注意到这里有很多以双下划线开头的内容。我会说调用。我们只是在这里调用一个函数。说运行并调用某人，它就能正常工作。现在，旁注，我不建议以下划线开头来命名任何想要在这个类外部访问的函数。因为下划线意味着弱私有。

这基本上是在对外界说，嘿，这将是类内部的内容。而且从那里开始更强烈，你实际上可以开始混淆它。或者你可以告诉大家，嘿。内部，不希望你使用它，但也不要混淆。这就是前和后。当你有疑问时，双下划线是你的朋友。前和后。

如果你用强私有的混淆效果，可能会开始出现一些奇怪的问题。所以总是记住这一点。但一般经验法则是，任何私有的东西都会以一个下划线开头，并且不要在不同的作用域中访问任何私有内容。

尽管我们已经演示了如何做到这一点，但这并不是做事的最佳方法。你应该使用getter和setter，我们在这里展示过，比如设置名字。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P35：35）装饰器 - ShowMeAI - BV1yg411c7Nw

大家好，欢迎回来。这是布赖恩。在这一集里，我们要谈论装饰器。而且不是为了让事物变得更美观，尽管在屏幕上看起来确实好看。所以在Python中一切都是对象。这意味着即使函数也可以作为对象使用。这正是装饰器将要展示的。我们可以做一些非常酷的事情。

在核心，装饰器接受一个函数，😊，添加一些功能并返回它。关键词返回它。

好的，让我们深入看看。

所以我会做一个装饰器，我会故意做错。我要故意做错，以展示装饰器实际上是如何工作的。我们会说de，假设deck或ator。我想给它一个函数。注意这只是一个变量，这是因为在Python中一切都是对象，所以说打印。

然后我们要真正调用那个函数。如果你有点困惑，我们有一个叫做funk的变量，它实际上是一个函数的引用。这是因为你可以像变量一样传递函数。因此它简单地表示在之前和之后，所以我们继续保存运行，但没有发生任何事情，因为我们没有调用这个函数。

现在，让我们介绍装饰器的概念，简单地说就是做一些事情。现在我们继续说打印做事情。如果你看看这两个函数，它们非常基础，我的意思是，这很容易理解。你有一个函数，它以另一个函数作为参数。

我们将获取那个参数，然后在内部调用它，所以它只是在调用另一个函数。因此我们有我们的做事情。现在，装饰器的真正目的是什么。可以说像这样。F等于。所以我们要获取某个函数。我们要说测试装饰器，做事情。这正是装饰器的目的所在。

所以让我们去掉那个，调用装饰器，这是许多新手真的很困惑的地方。创建装饰器真的很简单。你只需在你想装饰的函数上方加一个@符号和函数名。现在，这里有一个狡猾的小问题。

这个测试装饰器没有返回任何东西。所以当我运行这个时，你猜会发生什么。我将清除它，以便你可以看到。你发现问题了吗？我们从未调用这两个函数，但它却执行了。这是因为Python在后台做的是它取了这个并说在测试装饰器中。

它将拿着这个。放在这里，然后立即调用它。所以代码正在执行，即使我们没有直接执行代码。这是一个初学者的基本错误。所以请非常注意这一点。让我们看看一个真实的装饰器的例子，我们将以正确的方式来做。

这非常非常相似。我将说“de”。我想让它加粗。我们将遵循相同的模式。然后我将定义一个内部函数。现在，在我做任何事情之前，我将立即返回这个内部函数，而不调用它。

实际上，我所做的就是传回一个变量。这非常非常重要。你需要理解我们在这里做的概念。我们正在创建一个函数，并且我们在一个函数内部还有一个函数，我们返回内部函数。所以在这里的内部函数，我将继续遵循相同的模式。

所以现在我们有一个前后对比，因为我们要加粗，我们就说我们在处理一些HTML。所以我们只需做HTML的不同代码，如果你不知道HTML，基本上我们说的是开始加粗，停止加粗，就这么简单。好的，那么现在。我们可以拿这个来说，是的。

打印名字。把这个首字母大写，只是为了看起来好一点。然后我们将继续打印你叫什么名字。现在。我们从上一个部分学到，函数名前的@符号才是真正的装饰器。所以我将复制那个名字，去@，然后加粗。现在。

看我运行这个时发生了什么，我们会看到这里执行，但我们实际上看不到“Bryan Karens”。好的，所以实际上我们在这里做的事情是做一个等同于，我将在屏幕上复制一些东西。假设在屏幕外，我们说“@加粗等于函数等于加粗打印名字”然后调用那个函数。

但这个函数调用只是返回这个内部函数，如果这让你感到困惑，就这样想。我们说加粗，所以我们在说加粗，把这个函数作为变量。然后。我们将说“返回”将是。打印，调用我们的函数，打印。然后返回“返回”而不实际调用它。

现在我们有了可以操作的变量。哇，这似乎超级混乱。但实际上，在这里操作非常简单。现在我们可以说这样的事情。打印名字并调用我们的函数。记住，在后台，发生的事情是它会经过所有这些装饰器，返回这个内部函数。

当我们调用 print name 时，实际上它会调用。make bold 然后调用这个代码，变得有点困惑，但结果。是相当惊人的。好吧，以防你需要快速回顾一下。@符号意味着我们正在使用装饰器。我们在调用这个函数。我们把这个作为参数返回给函数。

然后内部函数将运行一些代码。我们只是将那个内部函数作为变量返回。因此基本上，我们在这里做的是。我们调用那个内部函数。可是我们没有直接访问它，这就是为什么人们对装饰器感到困惑。

一旦你理解了这一点，它们其实相当简单。

好吧，如果这还不够令人困惑，现在让我们让它更复杂。假如我们想要向这个传递参数，我们该如何向所有这些传递参数呢？你知道，函数和内部函数还有所有这些有趣的东西。所以这就是我们在这个小部分中真正要看的内容。带参数的装饰器。

所以假设我们想要创建某种函数。叫做 divide。这个函数应该。令人震惊地进行除法。我们在 Python 中遇到的问题是，嗯，它是非常。弱类型的。我的意思是 A 和 B 是整数吗？是浮点数还是字符串，是类？例如，你能用猫去除 A 吗？这是个很好的问题。所以我们需要做的是。

像这样打印。A 除以 B。现在，如果我们要，我只是。放一些东西在这里。复制并粘贴。你认为如果我们进行 100 除以 3，会发生什么？那 100 除以 0 呢？你会得到除以 0 的错误。100 除以一个字符串呢？好吧，你会得到一些非常糟糕的结果。我们来运行一下看看。没错，除以零。

噼里啪啦，让我们尝试一下。我传递这个，然后再试一次。结果是不支持的操作，字符串类型。超级，超级令人沮丧。我们想要的是一个装饰器。它将检查我们是否能够进行除法。如果可以的话，实际上进行除法并返回结果。

这意味着我们现在正在进行类型检查，并且我们正在传递参数。我们来快速实现一下。所以我创建一个网站。我们把这个叫做 numb check。我差点想叫它 nubchuck。得表现得好点。好了，numb check，数字检查的简称。这将是我们的装饰器，我们将在这里放入两个函数，我必须说一下。

检查整数。并不一定要是整数，但作为示例。我们将确保它是一个整数。我会立刻传递。然后我们假设输入。在内部，我们需要一个 x 和一个 y。你会注意到这有一个定义的参数数量。这里发生了什么。我们在匹配。

函数调用看我们有一个，2 和一个，2。因此我们基本上有两个参数。我们想确保与这两个参数对齐。我们将在下一个部分向你展示如何解决这个问题。但我想先展示如何传递参数。

这就是为什么我在一个特定的数字，1，2 和 1，2。这么说吧，在我们的内部。我会简单地说。F。不。检查。然后我想检查 X。我们将说。或者不。检查。我要检查为什么，因为我们将检查这两个。确保它们都是。数字。如果它们不是，我们将返回。我注意到我们没有返回内部。我们只是返回。

因此，它将完全不采取任何行动。然后我们将在这里退出，说明否则。我们将返回。该函数。如果你对我们从哪里得到这个感到困惑。它是我们装饰器的参数就在这里。我们将返回。X，Y。现在。让我们返回。我们的内部。如果这让人困惑。

这实在是太让人困惑了。我很抱歉，确实如此。我喜欢装饰器。但这些实在是太令人困惑了。所以😊，一旦我们将其变成装饰器。现在就让我们这样做。Python 会说 numch。然后它将说 divide，将 divide 传递给这个。

这将进入我们的内部和其他所有东西。它会像烫手山芋一样被传递，并试图搞清楚。这很让人困惑。实在是太让人困惑了。我们先来进行检查整数。然后我们将一步一步地处理这一切。确保我们理解这里的逻辑。

所以会说 F 是实例。0ero，逗号。我们只是进行一些类型检查。这是一些非常基础的类型检查。然后在类型检查之外，我们遇到了除以零的问题。因此如果它是一个整数，我们想确保如果。哦。等于零。想让用户知道这里发生了一些事情，打印。并且不除以 0。

然后我们只想返回假。好的。如果我们已经过了这一切。让我们在这里退出。我们将返回真，因为它不是 0 且它是一个整数。因此我们应该能够进行某种除法。如果我们已经到了这一点而还没有返回真或假。我只是想说打印，这不是一个数字。然后我们会解决这个恼人的字符串问题。

然后我们将返回假。好的，因此。这里的基本逻辑。伙计。为这个系好安全带。我们的装饰器将是 numbmchuck 一些函数。我们的内部将在这里下来，并说，好吧，我们有两个参数 X 和 Y，如果没有。然后检查 X 和检查 Y。检查将会说，它是一个整数吗。

如果它是一个整数。然后我们要问它是否为 0，如果是 0，那么我们将返回 false。然而，如果它是一个整数，我们将返回 true。如果我们没有从那里返回出去。我们将返回 false，并说这不是一个数字。可能有一种更优雅的方式来做到这一点。我只是快速写了一些代码。

一旦我们说，好吧，它不是一个整数，或者它没有通过这个检查。我们将不返回任何内容。然而，如果我们能够做到这一点，那么我们将返回函数 X Y，这意味着它实际上会为我们执行除法。哇，真是疯狂的艺术。我们的装饰器在这里。让我们用 103 来测试一下。运行。

确实，它返回了 3。3 重复。让我们尝试用 0 除以。不能被零除。所以它捕捉到了这一点。现在，让我们尝试用 100 除以猫。而猫不是一个数字。非常酷。非常实用的设计，而不需要做太多的来回。我们可以简单地定义一个装饰器。然后。你猜对了，使用它。

我们可以一次又一次地使用这个。一旦我们达到这一点，它就变得如此简单。

好的，最后一小节真的非常混乱。但这里的主要收获是，你可以通过一个简单的装饰器获得一些非常复杂的功能。最大的问题是我们有两个参数，而只有两个。如果我们想要有一个未知数量的参数，并且我们想将它们链在一起呢。

让我们来看一下。所以我要制作两个装饰器，叫做 de。和 outline。最初，我只是要传递。我可以复制这个。称其为 list items。现在我们要创建另一个函数，称之为 display。display 只是会显示一个名为 message 或 MSG 的变量。非常简单。

只是打印出来。不确定复制和粘贴在何处背叛了我，来了。好的，非常简单，非常容易理解的结构。我们将把这两个链在一起。当我说链时。我们说的是这样的东西。所以我们创建了一个链，它看起来像一条链，因为你有这些小的 at 符号或链中的链接。

这些可以。只是为了给你一个图形表示，看来你有一条链向下延伸在屏幕上。其实，这是一种先到先服务的方式。所以 outline 会首先被调用，然后 list items 会第二个被调用。如果我们想的话，我们可以不断地添加。

但这就是我们必须返回内部函数的主要原因。所以让我们开始详细阐述这些内容。现在，我想说的是。表示零个或多个参数，或者。零个或多个关键字参数。如果你跳过了那个视频。我强烈建议你回过头去看播放列表，链接在下面。

观看视频，理解 as 和关键词 as 之间的区别。然后，打印。我们只会打印出。T灯。I 的 20。因为大纲会令人震惊地概述我们在这里输出的内容。现在我们将调用我们的函数。用我们的 star as。和 Heward arks。一旦我们到了这一点，非常简单，只需返回。我们的内部。

我们的第一个装饰器差不多完成了。它将做的就是概述。我们的函数。非常简单。现在，列表项稍微复杂一些，但也不太复杂。首先，让我们下去修复这个。MS G。好了。更明显地展示 display 实际上将做什么。所以我们将输入。我们可以。

直接上去，抓住这个。保存作为稍微打字。好了。所以我们要做的第一件事就是，嗯。我一定是点了什么。好了。我们要做的第一件事就是调用我们的函数。然后我们想要能够列出它。但在那之前，我先打印。F。我们将说 as 等于。

我只是想看看 Python 实际上给了我们什么，这样你可以更好地理解。我们可以用我们的关键词 args 做同样的事情。让我们继续返回。我们的内部。所以现在我们有两个不同的装饰器，它们做两件完全不同的事情。然后我们可以调用我们的函数。看看它们的实际效果。所以。我们得到了 Hello world Args Args。

这实际上应该是关键词 as。注意，如果你期待的是 hello world 和一堆波浪线在下面，会发生什么。没有。所以基本上，列表项是在大纲内部被调用的。这是链式调用的一部分。大纲首先被调用。因为我们现在正在传递这个其他装饰器，它现在形成了那个链。看看这是如何工作的。我们的结束就在这里。

为了打破这个，我们实际上可以把它变成像一个加号之类的东西。只是为了让你看到开始和结束。对。叫呢。Asems start finish。非常，非常有趣。它的工作方式。我绝对喜欢它。😊 但注意，第一眼这里。Args 是一个元组。关键词 args 是一个字典。哦，好吧，这确切地告诉我们如何遍历这些东西。

有人说，4 x 和 as。让我们继续，打印。我们将格式化那个。我要 Arg 等于。然后，x。我们可以为我们的关键词 as 做非常非常相似的事情。只不过那是一个字典，所以我们要做一个键值对。如果我刚刚在屏幕上所做的看起来像黑魔法，回到播放列表。

链接在下面，观看关于字典中 for 循环的视频，我们将使用关键词 as。项。然后我们将说键等于 x，而值等于。实际上不是 x，抱歉。E 是 K，值是 V。好了。保存运行，确实如此，我们的 hello world，注意它没有。这个字典中没有任何内容，因为我们没有关键词参数。看。

我们只是在处理一个普通的参数。所以，让我们继续。在这里做些不同的事情。我们说生日。我想要一些关键字 a，名字。等于。随便什么，年龄等于零。我会说打印。格式。生日快乐。随便名字是什么。你是。随便他们的年龄是多少。岁。现在，让我们用关键字参数来调用我们的函数。

我们可以继续重用这些装饰器，所以我只是会直接复制。并粘贴。注意，这里有两个不同的函数，做着完全不同的事情，它们甚至有不同的参数类型，但我们可以使用相同的装饰器。让我们看看它的实际效果。生日快乐，布莱恩，你46岁了，现在我们没有作为。

但是我们有这个漂亮的字典，我们从中获取键和值。如果我只是。向上走。你可以看到它们都被触发了，一切都如预期般正常工作。所以装饰器的主要收获在于，它们很复杂，真的会很快变得令人困惑。但你应该从装饰器中真正理解的最大收获，从一开始就是它将调用这个函数。

如果你不返回，内部函数只会执行代码。所以一个真正的装饰器看起来像这样。你有你的函数，你有你的装饰器。装饰器将有一个内部函数，你将返回一个指向该内部函数的变量。从那里，实际上，你的想象力是唯一的限制。

你几乎可以做任何你想做的事情，这些变得高度可重用，你可以将它们简单或复杂化，随你的意愿而定，并且可以在许多不同类型的函数中重用它们。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P36：36）迭代器 - ShowMeAI - BV1yg411c7Nw

大家欢迎回来。这是布莱恩。在这一集里，我们将谈论迭代器。它们使计数变得简单，我们之前实际上已经使用过这些，但我们将深入探讨它们是如何工作的。因此，例如，如果你对迭代器感到困惑，就说。😊，1，2，3，4。

我们有一个简单的元组。我们将说4个x在。Qi。当打印。运行这个。看，1，2，3，4，但这到底是如何工作的，Python是如何知道如何遍历每一个项目以及如何处理每个项目的，这正是我们要深入探讨的内容。

让我们打开引擎盖看看这里发生了什么，所以我们在谈论迭代器的基础。好吧，列表、元组、字典、集合，甚至字符串以及大量其他对象都是可迭代的。我们使用一个称为iter的函数来获取可迭代对象。让我们看看这里。我将说people等于。我们将创建一个简单的列表。布莱恩，田明。

我们的家庭狗，老懒狗，臭狗，Rango。我们想要通过它。因此我将说，我等于迭代器。我们将使用那个列表。如果我们打印出来，快速看一下我到底是什么。这是一个列表迭代器对象，所以这是一个与我们的列表分开的对象。它不是列表。

这是一个迭代器，它告诉Python如何遍历那个列表。好的，很棒。现在让我们实际来看看。我将说打印。我将调用下一个函数。它会告诉迭代器，嘿，移动到下一个位置。假设从一开始，这个下一个位置是布莱恩，所以让我们继续运行这个。

当然，布莱恩就在这里。现在，我们不需要知道某种索引，只需说下一个。下一个，下一个。看，布莱恩，塔米，罗，它将继续移动或遍历那个列表。现在有一个有趣的地方是，如果我们试图超出那个列表的范围。注意它抛出了一个错误，这是停止迭代。

这就是Python在内部使用的方式，告诉自己需要停止遍历，因为它简单地达到了末尾。所以我们可以继续，我将把这段注释掉。但你必须明白什么是停止迭代，以及它存在的原因。它只是告诉Python，嘿，我们到了末尾，停止处理这个。

现在我们理解了基本概念，我们将创建自己的类。我们将说对我们自定义类的4个x进行迭代，在内部它将调用next等有趣的东西。我们不会玩停迭代，但我想让你理解这个概念的存在。如果你试图推进next并得到某种错误，你会知道它在做什么。

较旧的教程中，你实际上需要自己提高这一点，所以会有点混乱。我们将采用简单的方法，或者说是Python3的方法。我们将说import random，并创建一个随机数生成器或彩票类。很多人都想赢得彩票，我也是。天啊，如果我赢得彩票，我会做些什么。

所以我们将说def __init__(self)。这仅仅是我们的构造函数。我们将说self._max = 5，如果你不知道为什么有个下划线，请查看之前的视频。然后我们想调用iter()，这就是我们真正偏离其他教程的地方，因为其他教程会有__iter__，你会有一个next函数，并且你需要追踪你在某个内部列表中的位置。

我们不会做任何这些，因为我们根本不需要。因此在__iter__函数中，我们将使用所谓的yield。yield是非常酷的。我会在这里记一些笔记。yield语句暂停函数的执行并返回一个值，就像return返回一个值一样。然而，😊，我们不会返回，而是停留在这里。

我们保留足够的状态以继续我们离开的地方。这是极其强大的。因此，不返回，这将中断。然后我们不断调用这个函数，我们将说for _ in range。我们只需说self.do_square(max)。

我们将继续调用我们的生成器。我们要创建一个随机数。我们希望一个范围在0到彩票委员会希望的最大值之间。好吧，现在我们想允许他们进行调整。如果他们想的话。所以我会说，仅仅因为我是个好人，设置下一个自我值。

使用我们的小彩票类的人可以设置最大值。如果他们想的话。从这里开始，使用起来变得非常简单，你会看到其他教程中有许多功能，你还在追踪某个内部计数器，但我们不打算玩这些。

然后打印。只是想在屏幕上分开一下。我们去创建一个彩票类的实例。我们将说lotto._max。我希望最大值为10。现在来了有趣的部分，我们将说for x in lotto。所以让我们运行一下，看看今天发生了什么，我们得到了随机数。

我们甚至可以说我们想要说50个这样的数字。所以这将会输出很多数字，我们先清除一下，看看。这就是我们生成的50个随机数字。这种方式非常酷，所以快速回顾一下。我们在这里做的只是简单地创建一个类。

调用构造函数设置一些内部值，然后我们有这个迭代器函数。在其他教程中，你会看到类似的内容，但后面会有一些暂定位。接下来，你会有一些代码。我们不需要那样。因为我们使用的是yield。与return不同，yield将返回值。

但在当前上下文中要暂时停止。当执行恢复时，它会继续正常进行。这非常酷，功能强大，让生活变得非常简单，相较于以前的方式。真是太喜欢Python3了。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P37：37）异常处理 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好。这是布莱恩。我们将继续深入Python 3中的异常处理。所以，基本上，坏事会发生，我们需要知道如何处理它们。我们在这些视频中已经看到了这一点，我相信你在使用计算机时也见过无数次，系统提示错误或未知错误，或者其他一些疯狂的事情。但我们需要理解这里的细微差别。

错误大多发生在运行时。它属于一种未检查的类型。这是一些像你的硬件故障或网络连接中断之类的事情，完全是意外的事情，我们真的无能为力。另一方面，异常发生在运行时和编译时，主要由开发人员编写的代码引起。

意味着我们现在正在创造自己的问题。所以，是的，我们可以编写代码来防御错误。但我们永远无法真正做到100%防御错误。就像你怎么防止你的CPU爆炸，你就是无法做到，你的代码将停止工作。另一方面，异常就像除以零、错误的数据类型等等。

所以这就是我们将在这个视频中深入探讨的内容。此外，在开始之前，我会放一个简单的装饰器，我们在之前的视频中讨论过这个，但为了防止这看起来像古埃及代数，我再做一个快速回顾。装饰器是一个函数调用，被另一个函数调用用来装饰它，基本上就是这样。

我们有一个内部函数，它将返回一个接受任意数量的参数或关键字参数的函数。我们将简单地打印出来。当我说打印出来时，你会看到在调用该函数前后有一堆破折号。为了增加一些风味，我加入了函数名，我们将在每一个函数中使用它。

首先，我们将查看try、except和finally。现在，这在一开始可能会有点难以理解，但我们真正要做的是创建一些特殊的作用域，而这些作用域存在是有特殊原因的。所以，首先的事情就是这样。

我将创建一个名为test 1的函数，给它的参数是x和y。我会立即调用pass。我们将再次使用我们的装饰器。如果你对装饰器没有任何概念，或者觉得这个看起来很糟糕，或者不理解这个内容，请观看我之前关于装饰器的视频。但基本上，当我们调用这个时。

这将会打印。首先调用函数，然后再打印。这就是我们所做的，尽管看起来有点混乱。好了，现在我们来深入了解一下。我们将使用 usery。你会注意到，在我们的 IDE 中有一些选项，你的可能看起来大相径庭。这些看起来令人困惑。试试，trycept 其他的，最后，如此等等。

我们将逐一讲解这些。但我首先要做的就是尝试。必须以 Col 结束。我将继续暂时跳过，并且我们将要。捕获。我们将再次跳过。只是想把这个完善，然后最后。我想逐一讨论这些。如果你来自另一种语言。

这基本上就是一个 try catch finally。try 意味着我们将尝试一些代码。它可能会工作，也可能不会。所以，例如，我们可以说 z 等于 X 除以 y。然后我们只会打印出来。哎呀，我们要打印出来，看看我的意思。我在这里制造自己的错误。结果。这段代码看起来真的很无聊。

这只是基本的除法。但我们在这里可能会做得非常、非常错误。我们可能会做类似于除以 0 的操作。而且由于 Python 不是严格类型的，我们可以发送非数值的值到这里，并崩溃整个东西。我们之前见过这个。在这个系列中我之前做过。所以我们必须对此进行防御。

我们想要做的是 except，这是其他语言中 catch 的基本版本。我实际上会把它作为注释放在这里，catch。所以如果你来自另一种语言，这就是 catch。用其他语言更容易解释，就像接球。

你在捕获异常，或者有人掉了婴儿，你在它掉到地板之前捕获它。在这个类比中，程序当然就是你的婴儿。所以我们要在程序失败之前保持我们的程序或捕获我们的程序。现在我们将执行某种逻辑。发生了一些事情。

现在这个问题是我们并不真正确定发生了什么。我们只知道发生了一些糟糕的事情。我们将在视频的后面看看如何确定发生了什么，并根据此采取具体的行动。好了，但现在我们真的处于初学者阶段，我们只想知道发生了一些糟糕的事情。现在，finally。无论如何，finally 都会被调用。所以 try 是一个尝试。Zempt 是捕获它。

如果它失败，你知道，就会发生一些糟糕的事情。我们必须在它遇到可怕的、意外的死亡之前捕获它。继续进行是我称之为 finally 的部分。无论上面发生了什么，finally 都会被调用。我们来看看。所以我将简单地打印出来。完整的，顺便问一下我的手动输入。是的。

大多数编程错误都是拼写错误、输入错误之类的，或者只是数据类型不匹配，类似的情况。让我们来看一下这个实际操作。我们要说的是Test1。让我们用5和0来测试一下。显而易见的是，零，这个非常糟糕，让我们检查一下。哎呀。函数test1，发生了些坏事，所以马上。

与其让我们的程序因除以零错误崩溃，我们能够捕获它，并采取一些措施。现在，让我们给它另一次不幸的结局，进行子测试1。假设我们用5和猫。你如何用猫来除以5，我对此非常感兴趣。但是我们再试一次。果然，发生了坏事，5和猫的操作出错了。

所以我们知道这不是可行的。让我们先这样做。让我们来除法。复制粘贴让我失望了。好了，让我们用2除以5，看看我们得到什么。所以结果是2.5。我们现在知道我们的函数可以正常工作，并且可以防范异常。这个视频片段中最重要的收获是，你需要一个try。

在一个尝试异常的情况下，会有catch和finally。这无论发生什么情况都会被调用。你可以在每一个示例中看到，无论是发生了坏事还是成功运行，finally都会被调用。那就是你的清理代码。所以我们将其更改为清理。所以要考虑到这一点，就像IO一样。

你将要写入一个文件，你将尝试打开该文件并写入。如果发生了什么坏事，那么你将无论如何都要关闭文件。

有很多内置异常，我们正在查看官方Python文档。我将向下滚动。我们不会逐一浏览这些，因为我们会在这里呆上一整天。但有一些通用的高级异常，然后它进入非常具体的内容，比如算术、缓冲区、断言。现在我们将谈论断言，但我想让你了解正在发生的事情。

断言并不是一个真正的错误。这是我们实际上创建的东西。所以我们将断言一个条件为真。如果是真的，那么就没有任何事情发生。如果是假的，那么会抛出错误。当断言语句失败时，会引发错误，我们现在要做这个。同时要理解，你可以有很多这样的断言，甚至可以定义你自己的。

哇，吸收了很多信息，但我将留一个链接。把它放在那里。我们将从最后一个复制一点。然后进行一些修改。所有这些测试，二。好的，所以我们有我们的尝试、捕获和finally，让我们稍微改动一下。

我想做的第一件事是添加一个N else。因此现在把这个想象成一个巨大的if语句。我们说如果。然后如果，然后else。因此，当我们到达else时。我们信任这段代码，这段代码应该运行，我不喜欢这样做。因为如果发生了什么事情，那你最终会在这里做另一个尝试豁免块。

我不喜欢一遍又一遍地在线做这件事。这会变得非常麻烦，所以。我们将把它移到这里。我将称之为可信代码，个人上我不信任代码。我通常在这里做，但你会在外面看到人们会说。否则就这样做。当到达这里时，你会毫无保留地信任这个。它不会出错。

因此尝试现在是我们必须进行一些测试的事情，所以我们将进行断言。现在。如果你是家长，你知道断言到底是什么，因为你走到孩子面前说。你现在要清理你的房间。如果他们不遵守，如果你得到一个假的返回，那么。坏事就发生了。他们会被禁足。因此我们将说x大于0。

Sert将进入并评估这个条件，如果它是真的，没什么坏事发生，然而。如果是假的，坏事会很快发生，这意味着。它会说失败，并且会抛出一个断言错误。我们将在这里的其他捕获条件中称之为豁免。因此，让我们抓住。

之前。我们有的测试。让我们重新命名这些，得看看，复制粘贴，让生活简单些。好吧，我们将进行5除以0，5猫，5，2。让我们继续测试一下。把这个往上移动。好吧，现在我们可以看到。我们的断言正在工作。因此函数是测试2。发生了一些坏事。因此它立即表示，Serert失败，然后打印出这个。

Asert是一个强大的工具，但它并不完美。我们想知道到底发生了什么，并希望能够根据具体情况处理事情。因此通常。我会把这个改成。异常作为E或错误或你想放入这里的任何东西。然后我会实际添加问题。然后E，当然。

如果你想深入了解，具有其他属性。但我们将把它保持简单，只在这里打印E，并让我们清空这个。然后重新运行，看看发生了什么。好吧，发生了一些坏事。问题在于它在字符串和int的实例之间不支持。

现在我们有某种类型问题。但请注意，除以0从未被捕获。因此我们有几个选择，我们可以将其留在捕获所有中，或者可以做一个除以0的错误，或者我们可以制作一个自定义错误。然而，我们希望这样做。如果我们想捕获一个特定条件。我们将说。除了。断言错误。那么，我会说。阻止F。并未能断言X。以及原因。

当你现在查看这个时，我们处理了两个异常。我们有断言错误和一个通用的捕获所有。所以我将在这里指定。你可以将这些链接到无穷大。你可以基本上处理每一个错误。但我将做的是处理我预期会出现的事情，比如如果我失败了一个断言。

我想知道用户给我们的只是垃圾数据，还是发生了更高层次的问题。我希望能够捕获到这一点。但我想能够在应用程序中区分这两者之间的差异。所以如果我们失败了一个断言。这将在其他事情发生时被调用，明白吗？

让我们试一下。好吧，发生了不好的事情。好的，然后断言失败。所以你可以看到这里触发了两个不同的。断言失败，意味着我们测试失败了。断言y大于零，让我看看我能不能腾出一些空间。这失败了，触发了这个。但然后你会注意到，如果这是猫大于零。

Python如何开始评估这个问题，它不能，所以它跳过并说发生了坏事。我们无法比较这两个，所以它跳到这里的异常代码。因此，对于我们的断言逻辑，它将为其他事情执行这个。我们的捕获所有将被触发。这实际上非常强大。但有一件事。

我真的要提醒你不要过于夸张。所以，例如，如果你尝试做一个……豁免。嗯，我在找什么类型？空气。然后我们可以说错误类型。让我们清除并重新运行。你会看到现在它说错误类型X，猫不能进行比较。

但我在这里所做的事情是我的代码越来越长且越来越复杂。所以我会说，寻找你绝对必须处理的特定错误，让其他所有错误都落入一个捕获所有的情况。至少，你应该有一个捕获所有，这仍然是可以接受的，但你希望能够捕获问题。我很少使用else，因为现在我完全信任所有这些代码能够顺利运行，没有任何问题。

如果我们这样做，会发生什么？我只是按了空格。这里就有一个空白。去吧，清除它，然后让我们运行。注意我们的程序，即使我们已经将所有安全性考虑在内，现在也崩溃了，而我的IDE没有告诉我，嘿，这里有个问题。这就是我倾向于不使用else的原因。

让我先去修复这个问题，然后再继续，确保一切正常。如你所见，这可能变得非常复杂。我是说，我们的小函数现在比屏幕还大。我得要么缩小视图，这会让代码变小且难以阅读，要么我得……嗯，想出别的办法。所以我们将在这里增加另一个复杂性。

我们将创建一个用户定义的异常并将其引发。这意味着我们将创建自己的错误，然后捕获它并展示你为什么想要这样做。所以这在文件 I/O 中是相当典型的。但首先。让我们创建一个类，称之为猫错误。

因为每只猫都有某种错误。为什么不呢？所以猫错误将继承运行时错误。我们将使用内置类运行时错误来继承它。现在我们有了所有这些功能，让我们继续说 De。我们将以。和作为。然后我只是想说 self 的。Args。我总是喜欢那个词。

听起来像个海盗。无论如何，我们可以说这就是艺术，所以。非常，非常简单的课程。你可以随意把它复杂化，但只需知道。这个错误类的生命周期是非常短暂的。这些的生命周期基本上是从事情发生到被捕获的时间。

你不想让这些东西徘徊。它们的唯一目的是传递关于发生了什么的信息。好吧。所以我将说 at。Outline，因为我们将再次使用我们的装饰器。我要定义。我们称之为，测试猫。我们将测试猫的数量。然后我要做一个 try。现在你开始理解一开始所有这些无聊的智能弹出的原因了。

我们可以做一个 try exempt。我们可以做一个 try exempt else finally，等等，任何其他组合，我只是选择 try except finally，它将为我们执行代码。现在，我并不需要所有这些东西。所以我将稍微改变一下。以适应我的需要，Intelence 很棒，但并不总是要按他们想要的方式来。

所以现在我有一个 try、except 和 finally。我们在这里要做的是我将说。在我们的 try 中。如果不是。他的实例。那么我们将测试确保 Q T Y 实际上是一个整数。因为你可以知道，传入一个字符串，我们不想对字符串进行某种数学运算。现在，如果不是。一个整数，我们想引发。现在引发基本上就像扔球一样。

我们在说，你知道吗，这是一个错误，你去修复它，我们在扔。一个石头或球向窗户，说，来，抓住它。如果你抓不住。你的程序将会崩溃，就像窗户一样。也许我刚刚开了个关于微软 Windows 的玩笑。我不知道。无论如何，随你怎么解读。

所以我们将引发某种类型的错误。当我说错误类型时，我并不是指。这个。类类型错误。我是说，这可以是一个断言错误。或者任何基本上继承错误或运行时错误的东西。但在这个案例中。我们将做一个类型错误，因为我们知道存在一个特定的问题。然后从这里开始。

我们要说。必须是一个提示。所以当你引发错误时，你要非常小心，以确保引发正确的类型。这是 Python 非常非常非常关心类型的少数几次之一。如果你试图引发像字符串这样的东西，你会得到一些奇怪的结果。虽然我怀疑你可能确实可以做到。好吧。现在我们要。检查数量。

所以我们要回到这里，说如果。数量，如果我们到了这一点，我们知道。因为这个没有被引发。我们知道这是一个整数。我们可以在数学上处理它。所以现在我可以说数量小于 9，那么。好吧，谁会理智地拥有少于9只猫。所以我要引发我们的猫错误，并说，必须。

哦，嗯。超过 9 只猫。因为我不知道什么疯子会理智地拥有少于九只猫。这就是猫类错误的存在原因。但现在我真正想展示的是，只要我们继承运行时错误，我们就可以创建自己的自定义类，并且可以抛出或引发。

就像任何其他设置类型一样。非常，非常酷。好吧，所以。既然我们有了这个。我就要说打印。我们将进行格式化。我只想说“哎呀”。这是我们的捕捉点。我们要说像“哎呀，未知错误。对不起，我错了。”然后我们要说 E 进行。现在，最后，我要说。认。完成。

注意，这比上面的这个大而笨重的东西简化了很多，很多，很多。这就是我所说的。空气处理可以非常复杂，并且发展得很快。因此，一般的经验法则是尽量保持简短、简单并切中要点。好吧。我们来测试一下我们的 CAs 类。我要说测试猫。我们希望。

有些疯狂的人只有三只猫。有些疯狂的人有12只。三只猫。我不知道你怎么会有三只猫。这有点可怕。然后我们要。测试11只猫。如果我们想的话，甚至可以让这个事情转个弯，直接说 ABC。让我们清空结果并发出指令。好吧，所以。我们看到，必须是一个整数。

必须拥有超过9只猫。必须是一个整数。我是说，现在这运行得如预期一样。所以这必须是一个整数。必须拥有超过9只猫。必须是一个整数。然后 Ta。最后，我们有一些理智的人，他们确实遵循了指示。为了清晰起见，我要说，你拥有 X 只猫。把这最后一次清楚地说出来。你拥有 11 只猫。

你可以看到你拥有 11 只或者你拥有的任何不在其中的数量，因为我们抛出了并捕获了异常。所以每当你看到尝试，就想象这像是在打棒球或某种运动，他们拿着球。如果发生他们不喜欢的事情，他们会把球扔出去。然后由其他东西来接住它。不论发生什么。

运动解说员将会，说就像这个赛季一样，说，安，我们完了，大家。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P38：38）使用 Pickle 进行序列化 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好，我是布莱恩，在这个视频中我们将讨论pickle，大家最喜欢的。那么，pickle到底是什么呢？当我第一次阅读它时，我忍不住笑了。腌制是一种保存食物的方法。这是一种非常古老的做法。我们将对对象做同样的事情。所以我们将对它们进行序列化。

这是一个更现代的术语，但我们将保存一个对象。这个对象可以保存在另一个位置，例如，硬盘上。😊。没错，你可以创建一个对象，保存它，重新启动程序后重新加载这个对象，仿佛什么都没发生过。这非常酷。这被称为序列化，并且变得非常复杂。Pickle。

虽然很棒，但并不完美。它确实有一些局限性。我鼓励你去研究dill，D I L L。还有其他序列化工具可以克服pickle的一些缺点。我们将仅讨论pickling的基础知识。那么，你首先能pickle什么呢？

几乎所有的Python数据类型和顶级类。意思是如果你在类中再定义一个类，再在那个类中定义一个类，你会遇到问题。所以首先，让我们导入pickle。好的，直接进入这里。我们要做的第一件事是添加一个装饰器。

我们使用的装饰器和之前视频中相同，如果你错过了我的装饰器视频，可以回到播放列表观看装饰器教程。你错过了它。它将仅仅打印一行，打印函数名，所有的函数，并打印一行。好的，所以我们的类会非常简单，因为我专注于序列化和反序列化。

我们只是在查看序列化的基础知识。所以我们将说cat。然后，我们想去定义一个方法。我将要定义它。我们希望它包含name，age和info。所以name和age似乎很简单明了。我们要找的像是一个字符串和一个整数。但info是什么呢？这就是我们想深入探讨这个视频的原因，事情并不总是看起来那么简单。

我们将说self.name等于name。然后通过复制和粘贴的魔法，我最好直接从顶部抓取它。哎呀，我们不想搞混它们。好了，差点给我们带来了一些麻烦。所以我们会说self._name，self._age，self._info。再次强调，底线符号表示这些是类内部的。

我们不想让其他人玩弄它们。所以接下来我们将创建一个功能。我们想显示某种类型的消息。让我们使用我们的装饰器。只是为了装饰一下，让它在屏幕上看起来漂亮整齐。然后我们将打印出消息。不管消息是什么。

但现在我们也想打印。我们想放入。或者说名字。还有年龄。是的。或者我应该说，是岁。那样不太有意义，是吗？

我帮忙拼写了所有这些。好了，猫的名字是年龄岁的猫。好了，现在更有意义了，然后我们将获取信息，这将是一个字典项。所以我会说四。好的，变成自我信息项。这样我们就可以迭代这些字典项并打印出来。

然后我们要说。就是这样。这里发生的事情很明显。如你所见，这并不是一个超级复杂的类。我只是想覆盖一下基础内容。让你确切知道我们在做什么。我将继续创建这个实例。我会说“哦，奥赛罗”。这是我一只猫的名字。不幸的是，猫咪去世了。

他可能是我拥有过的最好的猫，但我爱他如命。好了，奥赛罗。15。然后我们将创建一个字典。并填充。哦，等一下，他是一只非常胖的猫。他喜欢。吃东西，这几乎是他的爱好，对这只猫来说，简直就像是一项竞技运动。然后我们将说。哦，奥赛罗，显示一下。只是想测试一下。

在我们做其他任何事情之前，我要说显示。接下来。相同运行，自我信息。我们这里有什么，38。9ine30h是的。有点问题。请参阅我之前关于错误处理的教程。好了，所以让我们去清理一下。好了。所以函数。现在我们可以看到我们的装饰器按预期工作。那就是我们的行。

这里是函数名，我们的消息，然后是奥赛罗的15岁猫的颜色、黑色、体重、喜欢吃东西。然后在装饰器中。所以一切现在都在正常运作。😊。接下来我们将实际进行序列化和反序列化这个对象。注意我们没有谈论序列化类。因为类是一个蓝图。

我们要序列化实际对象。好的，系好安全带。腌黄瓜来了。我几乎觉得我应该有个穿着斗篷的腌黄瓜。但我要说的是。让我们看看，哪一个是“序列化的猫”的简写。我们将说序列化的猫是腌黄瓜。说这话时我觉得像是个腌黄瓜。

所以我们将转储S。如果你记得之前的视频，如果它以S结尾，那就是字符串。所以这正是这里发生的事情。Sam约定。所以我们将转储为字符串，并将奥赛罗这个猫的实例转储为字符串。现在，我将继续打印出来。说运行。

这就是 Othello 在被腌制后看起来的样子。天哪，这腌制一只猫听起来真是太可怕了。不过你可以在这里看到一些熟悉的东西。强调主要内容，这样你就能确切知道那个对象在哪里。然后它有一个名字。然后你会看到 Othello，这里有一些数据。所以这实际上就是 pickle 所做的，它将数据转储到一个腌制格式中。

这个格式与 Python 之外的应用程序不兼容，并且不是什么你可以称之为向后兼容的东西。也就是说，你不能用最新版本的 pickle 来序列化某个东西，然后用旧版本的 pickle 来加载它。这是一个更高级的视频，我们将在未来深入探讨，但请记住这一点。

pickle 将尝试使用最新版本。😊，所以让我们保存这个。有人可能会说用。打开。我们想要某种生物在 cat。TXT。我们想要。以二进制方式写入。因为这是一个二进制文件。我们将把它写出。作为 F，记住，如果我们使用 with，它将打开它，并给我们一个名为 F 的变量。

代表文件，它会在我们完成时自动关闭。好的，所以我们有这个。我们将说 pickle。Dump，这是 dump S 和不带 S 的 dump 之间的区别。D 表示你想要转储什么，我将给它一个对象，并告诉它位置。因此我们将把它转储到一个文件中。

继续清理这个，让我们运行它。所以现在我们有这个猫文件，它说文件在编辑器中未显示，因为它使用了不支持的文本编码。好的，所以我们将右键点击，并打开它。在之前的视频中，我向你展示了如何安装十六进制编辑器。

但以防万一你在这里输入 Hex。有一个十六进制编辑器。你只需安装它。因此回到之前的内容，我们实际上要去掉这个。右键点击。用 exed 打开。这就是序列化对象的样子。你可以看到它与原文完全相同，但我们将这些字节写入了一个二进制文件。

我们现在可以拿这个文件。可以通过电子邮件发送它，或者在网络上传输，或者让它静静地放在硬盘上。无论我们想怎么做，都可以有另一个 Python 程序来反序列化或者重新打开它。好的，现在我们已经序列化了，并且对序列化或腌制过程有了一个清晰的理解。我们将进行反序列化，这正好是相反的过程。它是在读取信息。

有人可能会说，我的猫。等于，我想说 pickle。那 load S。因为我们要加载一个字符串。这个字符串是我们在这里序列化的猫。所以我们将抓住它。把它放在这里。我将打印。从字符串。只是为了让我们知道在控制台上的位置。我们实际上可以说。我的猫。来显示。

从字符串。所以实际上，我们所做的是取那个猫的字符串表示，注意它前面有一个 eat。这表示这是二进制的。所以我应该说，是字节。但它会将其作为字符串，放入序列化中，然后加载回一个可以调用函数并运行代码的可用对象。这真是太酷了。😊所以那里。Rumstring，rumstring。它完全是原来的样子。

它描述了一只15岁的猫。它是黑色的15岁，喜欢吃东西。所以我们把我的猫从死里复活了。听起来很疯狂。我们复活了我的猫。所以这真的非常酷。为了证明我们可以从文件中做到这一点。我们将字面上拿这个。复制，粘贴。然后我们将说，设置为写入二进制。

它是一个以二进制格式读取的文件，我们要进行序列化加载，而不是加载 S。我们想要加载那个文件。我将说。磁盘。取名为 disco cat，为什么不呢？

然后我们将取那个。接着我们会说从磁盘显示。这个代码将会去打开这个二进制文件。用十六进制编辑器打开，它将从文件中加载字节，创建一个对象。然后我们现在可以使用这个对象，但即使它们来自同一数据源，这些现在是不同的对象。

诶。R diskk。Othello，黑色，重15，喜欢吃东西。现在，如果我们做一些有趣的事情。为了总结一下。我将打印这些出来。我将打印。我的猫。我将打印。这个猫，来给你展示这里发生了什么。你可以看到。帽子对象在。然后它们是两个。不同的内存位置。

这意味着现在这两个对象是不同的。这是关于序列化和反序列化的小心故事之一，你实际上可以保存一个对象，然后多次加载该对象，但你可能不想要两个 Othello。就我个人而言，我希望有两个那个帽子。

但这可能不是你的本意，所以在反序列化对象时要稍微小心一些。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P39：39）Map函数 - ShowMeAI - BV1yg411c7Nw

大家欢迎回来，我是布莱恩，我们将讨论map函数。具体来说，这是在没有实际循环的情况下进行循环。其背后是将一个函数调用映射到一组项目上，类似于我们对任何集合使用的map函数。例如，我们可以有一个列表，并将列表中的每个项传递给函数。

让我们深入看看。

让我们从一些基本用法开始，我们将得到一个人名单。在这个人名单中，有Matt、Brian、Tammy、Marcus，我们希望将其传递给一个函数。并计算每个项的长度。我们希望获得一个包含这些长度的列表。因此，我们将覆盖旧的方式和现代方式。所以我们先做旧的方式。

旧的方式是像这样。counts。等于，我们将创建一个空列表，然后对于x in。结播。然后我们只想做一些类似的事情。Counce do append。我们在这里做的事情非常简单。我们说Ly。并希望获取每个元素的长度。然后完成后，我们只想将其打印出来。

所以我们将说print。所有旧的方式。让我们直接打印出来。非常简单，易于理解，确实按你想的方式工作。并且它有点啰嗦。现在，现代方式将使用map函数。我们要简化这个。记得我在一开始就说过，随着代码变得越来越复杂。

实际上，我们需要写的内容变得更短，更难理解。这是一个很好的例子。所以我实际上要先从print开始。然后我们将格式化它。相同的map。我想把它大写，这样它就能突出。现在我们将说list，实际上将其转换为列表，逐个列出每个元素。

我们正在调用map函数。在map函数内部，我们将调用L。年的。表格。这看起来很疯狂，让我们运行一下。确实，它按预期工作。那么这里发生了什么呢？我们在说，好吧。调用print，然后我们将列出map。现在map将做的是，它将获取这些人。

然后将其放入一个函数中。在这个例子中，我们使用内置的长度函数L，来获取大小。因此，实际上我们用一行代码替代了所有这些代码。这非常非常酷。然而，这个小段落的主要收获是，我们正在处理一组项目，并逐个将每个项目发送到该函数。

我们得到了一个map对象，因此我们必须将其转换为列表。

让我们更深入地进入复杂的领域，我们将使这变得更加复杂。我们将结合元素。我放了一些笔记，注意不同的链接。我们还传递了多个参数。那么我们在这里要做的事情，我已经准备了一些内容，准备粘贴。名字和姓氏。

我们有两个元组。我们将结合苹果和派，巧克力和蛋糕，软糖和布朗尼。哦，注意比萨饼没有我们可以配对的东西。我们将检查这如何工作以及它的行为。我们还将定义自己的函数。有些必须说解合并和合并，我们将有A和B。

它只是简单地返回。诶？😊，加上一些空格。加上B，非常简单的函数。就这样，它所需要做的就是返回一些东西。无论我们返回什么，都将被添加到映射对象中。因此，让我们说x等于映射。我们将使用我们刚刚写的合并函数。

现在我们将合并名字和姓氏。所以实际上，当我们看这个时，它应该是这样的参数。因此，我们可以有零个或多个参数。所以我应该说一个或多个参数。所以他们最初是这样做的。因此，我们将把我们的合并函数映射到这两个参数，名字和姓氏。

这些就是这里的元组。让我们打印X并看看我们得到什么。这是新手们经常被绊倒的地方。他们会问这是什么，我们有一个映射对象。那么，我们如何处理这个映射对象呢？问题是你不想直接使用它。你实际上要做的是将其转换为我们可以使用的东西。

所以我们将说打印。列表。我们将简单列出X。这将进入映射对象，并说给我每一个项目。然后，它将转换或转换为我们可以使用的列表。例如，苹果空格派，巧克力空格蛋糕，软糖空格布朗尼。

请注意，这些是合并在一起的独立项目，并且没有比萨饼。因此，因为没有任何我们可以配对的内容，所以它悄无声息地失败了，我们不必担心它会崩溃我们的程序。好的，我只想说，如果你是新手而且跳过了任何视频。

你即将经历一次糟糕的时光，所以我们将做多个函数。这意味着我们将结合函数，并在一个映射调用中调用多个函数。如果你没有跟着走，你即将面临非常混乱的时光。因此，我将支付一些函数，加、减、乘和除，它们非常简单。加广告。

减去，减法，乘法和除法，震惊的是除法。我不想让这些变得复杂，因为我不想关注数学。我们将创建另一个函数，死亡。屌我。它将有funk。还有Noumb。Bunk将是一个函数，而numb将是一个数字列表。我们将返回。

函数调用。与U0和nu1。所以我们所做的只是说获取列表的第一个元素并获取列表的第二个元素。所以匹配这两个，基本上，加。Numb 0，nu 1。所以这将是像bad nu 0。然后是nu1，类似那样。然后减法、乘法和除法等等。在生产级应用中，你会想确保这实际上有两个元素，并且它们是正确的数据类型。

等等，我不想关注任何这些复杂性。我只是想向你展示这是我们将使用的基本结构。现在我们将创建一个列表，或者实际上，在这种情况下是一个元组。包含加、减、乘和除。这些是我们之前粘贴的函数。

请记住，Python中的函数是上层对象，因此我们可以将它们视为变量作为对象。所以我只是制作了一个填充这些函数的元组。现在我要创建一些值。这将有点困惑。我们以前没有做过。我们将把一个列表放在另一个列表里，几乎是5和3的组合。如果看起来很困惑。

这是因为我们在一个列表里面有一个列表。这是该列表中的唯一元素。它可以是这样的。所以你在这个列表中会有1，2，3，4项。所以，是的。你可以将列表和其他东西放在列表中。非常酷。你可以这样做。我们还没有真正触及这个复杂性。但是今天就是那一天。

现在我要创建我们的数字。😊，我将提取值。将其反转为一个列表。这将乘以我们函数的链接。所以基本上，我会拿这个。然后问， 我们有多少个函数 1，2，3，4？

加，减，乘和除，我将按那个数字乘以。从这里开始。只需按暂停按钮。让我们打印出我们所拥有的，以确保我们所做的确实有某种逻辑意义。所以我们将打印出F，那是我们的函数。然后让我们打印出N。只是为了看看这是什么。保存运行。好的，所以F是函数a，函数减法。

函数乘法和函数除法。你可以看到每个函数的内存位置。现在我们有了数据列表。这是列表值乘以长度，分别是1，2，3。或者。这很重要，因为如果你向上滚动，记住我们在组合姓和名时。如果没有匹配的伙伴，它会静默跳过它。

我们想确保每一个函数调用都有一个列表，这将是加、减、乘和除。这就是我们得到这个非零数字 1 的原因。所以在这种情况下，零是 5，1 是 3。希望这能让你明白。如果不行，你可能需要重看一次。我尽量解释得清楚一些。

但是如果你一直跳过视频，或者没有完整观看，它可能完全没有意义。所以现在我们将说 M 等于 map。我们将调用映射函数，并将“do all”映射到 F 和 N。这是什么巫术？我们刚才做了什么？基本上。

我们只是想把“do all”功能映射到我们的函数列表上，每个函数要放入的数据是……这个大列表的列表，所以每个函数都有自己的一小段数据。哇。它会返回一个映射对象。所以我们就打印出来。然后我们想把这个映射对象转换成一个列表。继续保存并运行。

结果将是 8、15 和 1.6。那么这里发生了什么？嗯，5 和 3 是 8，5 - 3 是 2，5 乘以 3 是 15，5 除以 3 是 1.6 这个很长的数字。但这真的非常酷。我们基本上只是说在一个小调用中执行很多功能，并给出了每个函数将使用的信息。在我们结束这个视频之前，快速回顾一下，map 函数是非常。

非常强大的。一旦你理解了它，你将有一个函数，然后你会有某种可迭代对象，并且可以有多个可迭代对象。但它们必须排好顺序才能调用。😊，例如，名字和姓氏。

我们其实没有任何和比萨饼相关的东西，所以没有深盘比萨饼之类的。但我们有苹果派、巧克力蛋糕、软糖布朗尼。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P4：4）Python数字和基本数字运算 - ShowMeAI - BV1yg411c7Nw

大家好，我是Brian。我们将继续探索Python 3。在这个视频中，我们将讨论数字，数字数据类型，特别是int、float和complex数据类型。我们还将讨论一些基本的数值运算。例如，加法、减法等等。不论你使用什么IDE。

继续并创建一个空文件。我创建的文件名为Python 34 Py。此时文件名并不重要。你只需一个空文件来开始。

上一个视频我们谈到了牛。这次我们要讨论数字。我知道大家都喜欢数字。那么我们就从整数类型开始吧。我们这里要创建一个简单的变量，叫做Ival。我们给它赋值为34。不过，赋什么值并不重要。比如，打印并。

我们这里将打印一些内容。好了。让我们称之为Ival等于。我们只想打印出这个值。只是为了看看这个是什么样子，Dave运行。这是非常基础的。你大概可以猜到它会做什么。它会说Ival等于34。非常简单，容易理解。

现在，我们将通过复制和粘贴来进行演示。我们将创建一个float。此时float听起来非常好，比如说ripier float之类的。但是我们在谈论数字，而不是ripier float。不幸的是。所以我们将创建一个浮点值，它将是3.14。运行时，表面上看。

我们正在做的看起来非常基础，但在幕后，Python为我们做了所有的工作。我们无需担心实际发生了什么。因此，比如说，整数和浮点数之间有一个根本的区别。在后台有很多精度问题。

而且我们甚至不需要考虑这个。Python会为我们处理好这一切。我将导入。这个cis模块将允许我们使用他人的代码，我们将在另一个视频中深入讨论这一点。但现在请大胆相信，我们正在使用别人的代码。这实际上是Python的一部分，但我们需要导入它。再说一次，这有点令人困惑。

我们将在另一个视频中深入讨论。通常它位于文件顶部。我们就放在这里。不过我们希望能够获取一些额外的信息。有些事情我必须说cis模块做的。加载信息，让我们复制并粘贴一些笔记到这里，以便了解情况。我要把这个放进去。那是官方的Python文档。

如果你想出去，看看究竟发生了什么。我们可以运行它，看看底层。Python 在谈论浮点数时实际上在跟踪的就是这些。所以我们有系统浮点信息。你有一个最大值，确实是一个非常非常大的数字。你还可以有一个最大指数，你可以深入探讨这些内容。现在。

如果你对数字或数学感兴趣，你可能知道这些是什么。但我们这些凡人。通常并不在乎。基本上，如果你有一个有小数点的数字。你将使用浮点数。否则，你将使用整数。现在我们要谈论另一个，它叫复数，确实，复杂。现在，当我说复杂时。

事实上，Python 使工作变得超级简单，但数据类型本身在底层。你猜对了，不是超级简单，而是复杂，它看起来像这样。复数由两个数字组成，一个真实数字和一个虚构数字。听起来有点奇怪。但我们来看看。所以我们将说 C v 等于。

假设是3。加上6 J，这是一个我知道自己在做什么的巨大信心跃进。那实际上会做什么，它会让那个复数？

我们来抓取这个名字。Cval，Cval，然后打印出来。看起来我们没做太多，它只是说 Cval 等于 3 加上 6 J，正是我输入的内容。我们将其拆分开来。我们将展示另一种创建复数值的方法。你可以用 Floni 来做到这一点，但用复数更能强调这个要点。

所以我要说复杂的。注意它如何想要，它们浮动。在图像中。我们继续给它们一个鞠躬。所以必须说5，3。我们继续，我只是要通过魔法。复制并粘贴在这里。抓住这个。我们说。称之为。现在我想打印出来。真实的。而我们想要继续抓住这个。再粘贴。

我们想要那个数字的第二部分，以便看看它是什么。继续保存并运行。所以现在你可以看到复数由两个部分组成，实际上如果我。按照应该的方式来做，会更好。好了，真实和虚构。两个不同的部分。这就是使它成为复数的原因。我们要传达的基本点是，数字是非常基本和简单的数据类型。

但它们可以很快变得非常复杂，Python 去除了很多复杂性。如果你来自 Python 2 或其他语言。你会注意到这似乎过于简单化，而这正是设计使然。Python 3 基本上重塑了数字系统，消除了许多旧的头痛。

所以它非常简单。一般的经验法则。如果没有小数点，使用整数；如果有小数点，使用浮点数。如果你需要其他的，使用复数。还有其他数据类型，我们将在未来的视频中介绍，但这应该让我们现在开始。好的。让我们谈谈基本的数字运算，不用担心，我们不会变得超级复杂。

我们在谈论基础。Python可以做一些非常复杂的事情。例如，你可以进行计算、三角函数，几乎任何你能想象到的数学运算。Python实际上被用于科学计算，并且可以实现像人工智能这样的功能。我们从基础开始，需要讨论基础。我将说x等于3。

这就是一个整数。现在，我要打印出来。我会使用旧的打印函数，这样可以节省一点时间。没有什么特别的。但现在我们要做的是创建另一个变量。我们称它为Y。我们将说y等于x加3。那么我们实际上做了什么呢？

我们已经进行了基本的加法。让我们抓住这个。我们称之为add。这将是y。这是我们的基本模式，我们将做一些事情。然后我们将显示结果。我会说add，这样我们就知道自己在做什么。保存并运行，果然，add等于6，因为x是3。

我们加上3，3加3等于6。再次强调基础。现在。我们将开始加快这个过程，因为我认为你可能足够聪明以理解基本数学。我们将抓住这个。你猜对了，开始快速处理。所以如果我们可以加法，我们也可以减法。让我们说我们想要-1。运行，你可以看到。

3减去1实际上是2，所以这样没问题。正如你所期望的那样。所以我乘法。我们将说，嗯。这是其他语言中很难做到的事情。Python使这一切变得非常简单。所以我们将说6.846。我们使用什么数字并不重要，只要有这个。现在，如果你看，X是一个整数。

但我们在做什么呢？我们将其乘以一个浮点数。那么在这里发生的事情是，Python将确定输入值的类型。它会变成整数还是浮点数？

你会注意到当我们将鼠标悬停在Inence上时，它并没有真正告诉我们，因为解释器还没有完成工作，所以它根本不知道。所以让我们称之为multiply，最终结果是20.538，所以这是一个浮点数。现在我们要进行一些除法。让我们进行这个操作。我们想说x将被0.5除。

再次，它在后台进行所有繁重的数字计算。它实际上在做的叫做类型转换。当你想到类型转换时，可以想象一个巫师挥动魔法棒，把某个东西从一种数据类型转换为另一种。这是自动为我们发生的。我们不必考虑它。现在。

它不会总是自动为我们发生，但在这个特定情况下是的。并且这非常、非常方便。别担心，我们将在另一段视频中深入讨论类型转换。现在我们还在基础知识上。让我们稍微玩一下。我们将进行一个幂运算。所以我们说，这就是幂。3的平方是9，还有一个。

只是为了在这里玩玩。让我们来做取余。我认为这叫做模运算符。我们将得到这个。你不知道这是什么。这有点像相反的。我不应该说是相反的。这有点像进行除法并得到那个值的余数。这有点奇怪。让我们来看一下这里。所以0。5。

所以我们这里的做法是从x为3开始。然后我们得到2。5的余数，实际上是0。5。非常简单，非常易用。所以我们想要强调的基本概念是，有一些数字数据类型：int、float和complex。你可以进行一些基本的数值操作。Python让这些数值操作变得非常简单，因为它处理了所有复杂性。

这是我们的幕后工作。我们甚至不需要考虑它。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P40：40）过滤函数 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家。在这个视频中，我们将介绍过滤函数。这与我们在上一个视频中讨论的映射函数非常相似，我们有某种函数。我实际上把它称为fun，因为我认为过滤器很有趣，还有某种可迭代容器。如果匹配过滤条件，它将返回true。这很重要。😊如果它匹配过滤器。

它将被放入结果中。否则，它将不会。这是一种非常强大的过滤方式。我们将看两个过滤函数的示例用法。第一个只是简单地获取一个子范围。当我说简单时，这实际上相当强大。所以我将导入一个随机数。我们之前讨论过随机数。然后我将说一些值，我们将创建一个空的值列表。对于x在范围内。我们将创建10个项目。在这10个项目中，我们想获取一个随机数。某种必须说V添加。我们将说或随机。那。随机范围。

这将从1，我应该说，从0开始，一直到我们所需的范围。所以我们要说R范围。然后我们只需打印出来。这样我们就可以看到我们的范围实际返回了什么。我们来运行一下，所以我们得到一些随机数96，我是说。

你会看到它们到处都是，如果我多次运行这个，你会看到下面的数字在变化。那么我们现在要做的是说，我想注意这个的下半部分。老板走进房间说，我不想要超过50的东西。好的。所以我将创建一个小函数。我们将获取我们的值。我将说如果值。

是否小于50。然后我想对它做点什么。我想返回。真实。因为老板说他只想看到小于50的值，否则我将说else。我们将返回。假。这就是最简单的过滤。这就是过滤器的基本功能。是否匹配，是或不是。这就是全部。

这真的是它需要的复杂程度。所以我要说F等于。我们将继续过滤。使用下限函数。记住，我们在上一个视频中讨论过这个。因此我们有函数调用，然后是我们的值。这个值列表中的每一个都会被调用。

所以它将调用57、72，等等。这里的逻辑是，它将说，像57这样的单独值。它是否小于50是假的，70是假的，是真的。我想你明白这里的逻辑了。那么我们继续吧。打印出来，我要说打印F。我想说小于。如果我把它放在实际的投票中，那就更好了，少于50。

当你的键盘背叛你时，好吧，我们将把它转换为一个列表。否则，我们只会得到一个函数对象，这对我们帮助不大。所以这是我们的数字集合，以及小于50的项目，17、33、45和11。这就是我所说的，它非常有趣且强大。非常快。

你能否在这里拿一个数据集，然后说，我只想查看某些项目，然后构建某种自定义逻辑来获取该数据的子范围？虽然这个视频系列是针对完全的新手，但我不喜欢在新手阶段停留太久。因此，我们将跳入一个稍微高级一点的主题。

我们实际上要过滤类型。所以当我说过滤类型时，我们是在谈论类。我们将过滤一种动物。我们将在这里快速创建一个类，并设置你的名字。我的名字错误。我的键盘背叛了我。我们将说这里是构造函数。请耐心等我快速写一些代码，让我们的构造函数开始运行。

self.dot.name。好的，现在我们已经有了我们的动物类。我不会让它变得超级复杂。我们可以简单地复制一下。让我们称之为帽子。它将继承动物。因为我们在继承，我们可以去掉这个和这个。从这里开始超级简单。

我们就说超级。让它超级简单。无论如何，我不会辞掉我的日常工作。我们将用名字初始化它。我实际上可以拼写出名字。好了。因为我知道外面也有狗狗爱好者。我们还将创建一个狗类。任何了解狗和猫的人都知道，它们通常不太容易和谐相处。

尽管我在生活中非常幸运，每一对狗和猫的组合都相处得很好。所以动物。😊 我们有一只猫，它是动物；有一只狗，它也是动物，但这两个类根本不知道对方的存在。这就是复杂性所在，你将一次又一次地看到这一点。

我们刚刚做了什么？好吧，我们正在创建一个名为动物的列表。我们将把一些狗放入同一个列表中。有些可以说在范围内的可怜的X。我们希望在10以下。我应该说从0到9，但我们将继续，假设。如果。然后我们将做一些奇怪的事情。我们将说x模0。

基本上，我们在这里所做的就是，我们只想要偶数。然后我们将继续说animals.dot.append。我们将创建一只新的猫，并给它一些名字。所以让我们回到这里。我要说名字等于。动物加上，无论数字是多少。好的。

所以一旦我们达到这一点，如果它不是偶数，那就是，你猜的对，是奇数。我们可以简单地抓住这个。也许我应该反向操作，因为猫是奇数。狗通常是偶数，但猫通常真的很奇怪。好的，反正。我们已经得到了。现在我们将继续打印出我们的动物。

这样我们可以看到它们的混合，果然，屏幕上出现了一些神奇的东西。但我们有猫狗，猫狗，猫狗，猫狗。非常简单。非常容易理解我们刚刚做了什么。我们做了一个包含猫和狗的列表，只是一个杂乱的集合。现在，我想稍微整理一下。不能在动物中说4a。

我只是要把它打印出来，让它在屏幕上看起来漂亮。我今天过得很好，享受我的咖啡。我们说动物。做这个真是聪明。现在，看起来非常棒。我会给老板留下深刻印象，我会得到加薪，哦，名字。是的，因为我们硬编码了这个。修复它非常简单。是的。

我的老板正在转角走来。我将向他展示这个。我将为公司节省数百万美元。果然，我在这里有我漂亮的小动物集合。老板说，太好了。😊，但是。我只想要猫。然后我只想要狗。我想要两个不同的列表。

但你必须保持这个单一列表。现在，我得写下所有这些代码。好吧。这就是过滤函数的用武之地，正如你可能猜到的，某些人会说聋猫。我们要创建一个猫过滤器。听起来真的很酷，一个猫过滤器。所以我们将转为实例。我会说，这个值。是猫类的实例吗？

就这样，这就是我们需要使其复杂的程度。我们只想确保它是一个实例。我们可以对狗做同样的事情。然后我们可以使用那个过滤函数。充分利用这两个函数。因此，我要说4 C，然后我想创建一个列表。我们将进行过滤。因为记住。

filter将返回一个过滤对象。我们需要将其转换为一个较少的。我们要过滤猫。使用动物。慢下来一点。这在这里是合理的。我们将继续打印。实际上，我要说猫。我会解释这一点，以防你完全迷失方向。别担心。好的。

所以我们所做的与我们在动物中的4A非常相似。除了我们说4 C，我们将从过滤器给我们的任何内容中创建一个列表，我们告诉过滤器。使用猫的函数。并使用动物集合。记住，动物是猫和狗的混合。我们只是说对每个项目。

确定它是否是猫，这将返回实例。然后我们可以做同样的事情。或者是狗。非常简单，容易理解，当我们现在运行时，我们已经很好地将这些分开了。现在，我们有猫。这些是偶数，然后我们有狗，这些是奇数。好的。这段视频大致总结就是，filter将返回一个替代对象。

我们需要传递一个函数和某种可迭代容器。从那里，它只需要返回真或假。如果是真，它将最终出现在结果列表中。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P41：41）日志基础 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好。我是布莱恩。在这个视频中，我们将讨论日志记录的基础知识。那么，什么是日志记录呢？我们并不是在砍树之类的。目前为止，我们一直在使用方便的打印函数，但日志记录比打印要酷得多。这已经成为一种事实上的标准，但我们实际上还没有能够进行这个对话，因为我们还没有涵盖所有需要的技术来展开这个对话。

😊，那么，为什么日志记录比打印更酷呢？因为打印只是将某些内容输出到屏幕上，但日志记录，你可以有不同的级别。例如，你可以说这是一个调试消息、信息、警告、错误、严重，某些内容应该是自解释的。调试只是为了你，开发者，你想知道发生了什么。信息则只是嘿，发生了一些事情。

你可能希望用户看到这个，也可能不想。战争是，嘿，如果这种情况持续下去或者没有修复，可能会发生一些糟糕的事情。错误（Arrir）是自解释的，而严重（critical）则比错误更糟，所以。这些是不同的级别。首先，我们将导入日志模块。

你也可以这样做，从 Lologging 导入，接下来我们将导入根日志记录器。之所以添加这一点，是因为你需要理解，默认情况下有一个根日志记录器，当我说根时，我指的是顶层，你可以定义其他日志记录器，定制日志记录器，但我们将使用顶层日志记录器。好的。

所以我将把这段注释掉，这样人们就不会对我们正在处理哪个感到困惑。我们这里只是导入整个模块。我要使用基本的日志记录。注意，它们默认情况下不会显示。这是本节的主要要点。如果你不注意这一点，可能会非常混乱。

所以我要定义一个函数。我们将反复使用这个函数。它将只是简单的测试。我们将打印一些行。我们就打印20个吧。为什么不呢？然后我将把它复制。这样，当我们打印时，所有这些将会被分开。现在，从这里开始，我们想做几件事。

我想说。日志记录（Logging）。我们想调试。现在这有点混淆，因为我们并没有真正调试任何东西，我们是在说日志记录，生成一个调试消息，或者更具体地说，我们将在根日志记录器上发送一个严重性为调试的消息。

记住，我们在谈论日志记录的级别。调试（Dbug）是最低的，严重（critical）意味着嘿，你的程序刚崩溃了，发生了什么。所以我们将说。这里的调试消息。然后我们可以采用相同的模式，你猜到了，复制和粘贴时间。谁。林方。现在，信息性日志，其实，这些信息并不是特别重要。它只是。

嘿，文件被更改或某些东西修改了警告。然而，这时事情开始变得有点严重。你是否给过你的孩子警告，嘿，你最好去清理你的房间，否则就完了。并不提倡打孩子，但有时你就是得让他们清理房间。所以我们有调试、信息、警告。

随着我们进一步深入，这些数字在变化。后台有一个数字，我们稍后会真正回顾。现在，超过警告的是什么？你猜对了，是错误。我们讨论过错误处理和错误条件等问题。

这正是我们在这里所做的。我们在说，嘿，发生了一种错误，但使用这个不会抛出错误。我们只是记录发生了错误。而最后但并非最不重要的是严重错误。当你听到计算机中的“严重”这个词时，你需要相信这是至关重要的，意味着你所知道的一切都已停止存在。

你需要专注于这一点，否则你所知道的一切就会消失，因为它已经失效。这基本上就是在计算机术语中“严重错误”的意思。现在，我们要调用这个测试函数，看看会发生什么。注意它们并不会默认全部显示。我们继续运行。

我们看到的都是警告、错误和严重错误，但调试和信息在哪呢？要真正理解这一点，我们需要设置级别。当我谈到级别时，我们指的是调试、信息、警告和严重错误。实际上，每个级别都有一个数字分配给它。

想象一下，就像一栋建筑的级别，从底部到顶部，最重要的在上，最不重要的在下。好的，我们将设置一个级别。等于。我想进行日志记录。我们将使用日志记录模块。我们将获取级别名称。这将把后台的数字转换为字符串表示。但。

当然，这并不那么简单。我们现在必须进行日志记录。然而，日志记录器。这将获取根日志记录器，具有讽刺意味的是，我们已经在使用它。但问题是，你可以指定一个名称，这样你就可以有不同类型的日志记录器执行不同的操作。我们只需获取根日志记录器，然后我们将说获取有效级别。

获取有效级别将返回我们当前正在处理的日志级别。从这里开始，我们只需将其打印出来。所以打印出来。F。我们将说一个日志级别。好的，所以我们的日志级别当前是警告。我们将在下一节查看如何指定该级别。但我真正想谈的是，这个级别真正意味着什么，意思是警告。

意味着任何更关键的信息都将被包含，因此我们不仅会处理警告，还会处理错误和严重错误。但我们并不真正关心调试和信息。这是日志类的一个小陷阱，默认情况下人们会从这里开始并开始发送调试消息，然后什么都没有发生，他们会想，嗯，为什么，这就是我们需要设置级别的原因。

现在我们理解了日志级别的概念。让我们看看如何操纵它们，我们将获取和设置日志级别。这实际上允许进行过滤。而你想这样做的原因是在典型应用程序中。你会有很多信息在快速流动，你不想在屏幕上同时看到所有这些。

你只想看到对你重要的内容。因此，我们在这里要做的第一件事是获取根记录器。现在，根记录器是默认包含的。但我想实际去获取它，以便向你展示我们得到了一个对象。所以我将说根日志。等于记录器，或者我抱歉，记录模块的记录器。

看看这有点令人困惑。如果你有多个记录器，你将看到每个记录器的名称。如果没有名称，它就是根记录器或主记录器。从这里开始。我们将抓取这个，因为它看起来实在太糟糕了。我必须说打印。我们将打印级别。

想要把它粘贴在这里。所以我们在说记录。是的，级别名称。这有点误导，因为我们并不是在处理主记录器。我们在处理日志模块。我们在说模块。应该获取级别名称。现在我们希望从根记录器获取它。因此，实际上，我们不只是说这个。

我们可以用那个来替换。所以，记录模块，获取我们正在使用的任何日志的级别名称。获取有效级别，底层级别只是一个数字。让我们继续运行这个。所以警告级别，我实际上会放入一些内容来分开它。这样我们就知道我们处于警告级别，并且我们一直都知道这一点。

但现在我们将其设置为调试。那设置为调试意味着什么？嗯。这意味着我们将包括调试和任何更关键的信息。顶部的调试是链的顶端。任何内容都会被包括在内，不仅仅是调试。因此，我们将说根日志。设置级别。然后我们将说记录模块。调试。

然后我们可以调用我们的便捷测试函数，它包含所有这些。美丽的小记录器正在运行。果然，我们现在看到了调试信息、警告、错误和严重错误。因此，它按预期工作。我将抓取这个。我们可以非常快速地根据需要开始更改级别。有些改变只是过于关键而已。

记住，关键是好，Cri，这意味着像是某样东西爆炸了或者即将爆炸。我们将运行这个，你可以看到日志级别现在是关键的。我们可以看到，这里发生的事情很容易理解。然而，你需要明白的是，级别并不会使这些消息神奇地消失。

这只是意味着我们没有记录它们或捕获它们。这些消息仍然在发出。好的，现在我们再做一次。我想将其设置为警告。回到我们之前的状态。在关键根。这里是关键消息，你可能会想知道这个根是什么，这个根是什么？

好吧，这就是我们正在使用的实际记录器。这就是我为什么称其为根记录器的原因，因为我们正在使用根记录器。如果我们有不同的记录器，它将在那里显示记录器的名称。这种工作方式其实相当优雅，你可以根据需要随意切换这些。

所以，如果你获得了大量的详细信息而你只想看到关键的信息，你可以将其设置为关键。这样你就不会收到警告，因此你设置为警告。现在你获得了适合你需要看到的信息级别。

现在，虽然这很酷，但如果我们能够直接将日志记录到文件中，那将更酷。因此，当事件发生时，它会直接转储到文件中。这正是我们要做的。但我想给你展示一些东西，这将一次又一次地让你感到愤怒。😊如果你去谷歌搜索如何使用记录器。

你将会得到类似这样的输出：logging that basic config，设置为文件名。大家都非常兴奋。文件模式，对，没错，这将会有效。你甚至可以定义格式。这真的很酷。因此，我们要说级别和消息。然后我们要说级别等于logging dot debug。😊请注意这在做什么。

这正在设置配置，它设置了一些处理程序和所有这些有趣的东西。所以人们非常兴奋。然后他们做了类似这样的事情。Loging dot Ebu。我们要发送一个仅包含你好（hello）的调试信息。因此，理论上，当我们运行这个时，日志记录将调用调试，消息为“你好”，并将创建文件app。

在写模式下创建txt文件。然后它将以这种格式写入。我们知道这是因为我们设置了logging debug。所以，Rm roll。什么都没发生。没错，绝对没发生。因此，人们会非常沮丧，他们会做类似的事情去谷歌搜索“为什么日志没有记录”。这实际上是其中最流行的谷歌搜索之一。原因非常简单。

基本配置在我们已经配置了记录器的情况下将不起作用。需要在采取任何行动之前完成，因此我们已经在使用根记录器，并且已经配置了它。基本配置没有任何作用。没错。它绝对没有作用。这真让人沮丧。所以我只是打算写一些注释。然后我会把它们注释掉。

我们将向你展示如何解决这个问题。现在，如果这实际上是第一行，比如说如果我们把它放在这里。它会很好地工作，但由于我们做了所有这些，它根本无法工作。所以我们需要一个处理器。我将说 logging.dot。我们想要一个文件处理器。处理器的作用就是处理进来的日志信息。

我必须说文件的名称可以随便命名，真的没关系。现在我们想为那个处理器定义一个格式化器。我将说格式化器。你知道，这些是构造函数，所以在幕后，我们实际上是在创建类。现在。我会稍微复制粘贴一下，因为我们可能会花一天时间看我打这些。

我们要做的是获取时间、字符串表示、名称、级别和消息。如果你想知道名称是什么，它是记录器的名称。所以它将显示时间、记录器名称、级别和实际消息。你可以定义任何你想要的格式，官方文档中有指南。

重点是，一旦我们有了处理器和格式化器，我们就可以开始了。从这里，我们可以说，处理器.dot set。格式化器。那将告诉处理器如何格式化它正在处理的信息。然后我们可以简单地说 root。我们将说我们的根日志添加处理器。现在，我们可以进去，像这样说，让我把它提升到调试级别。

现在我们可以将其设置为 logging debug。然后我们可以说，根日志.dot debug。作为保存运行。果然，我们的输出文件被创建，并且格式如我们所希望的那样。这非常酷。我们甚至可以调用我们的测试函数。因为我们的日志级别在调试，并且我们设置了处理器和格式，因此我们可以返回到我们的文件日志，所有信息格式都很漂亮。

所以我们有日期时间，有记录器，有级别，有消息。你可以看到它甚至为我们进行了颜色编码。这真是超级令人印象深刻！

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P42：42）构建简单的应用程序：目录统计 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好。我是布莱恩，我们将创建一个名为D Stats的简单应用程序。这个程序将递归扫描一个目录。你是编程新手，可能会问这是什么意思。假设你有一个目录，里面有子文件夹。

而这些文件夹又有子文件夹，依此类推。你有一个漂亮的树状结构，类似于我们这里所看到的。😊我们希望能够扫描整个树结构。

让我们看看一个简单的图示，不用担心，我会放大。但我们有一个开始和一个结束，我们的整体逻辑将是非常线性的，非常容易理解。让我们放大一下。我们将开始，进入主函数，获取一些用户输入。

我们将验证这个文件夹在操作系统中确实存在。如果不存在，我们将直接跳到完成。不过，如果它确实存在，我们将进入一个for循环。这是递归部分。我们将对每个项目进行处理。如果它有子项目。

然后回去扫描这些项目，依此类推，直到目录树的底部。如果我们扫描完所有项目，那就完成了。我们将结果显示给用户。非常简单，逻辑也很容易理解。

让我们深入探讨一下。

好吧，首先，我们想要进行一些导入并创建一个全局变量。我们的导入，只需简单使用OS。现在，OS本身，这个模块真的可以让我们深入操作系统，获取一些细节。我们将用它来获取文件夹结构以及文件大小等信息。

所以让我们现在创建一个字典。我将称之为stats。我们想要一个非常简单的字典，我必须说，路径等于个人。虽然我并不喜欢全局变量，但它们确实有其用途。我认为这是其中一种情况。所以我们将说路径，然后存储文件。

如果你在想，这实际上只会存储我们要扫描的度量。比如链接，然后是总大小（以字节为单位）。请运行这个，确保没有拼写错误，没有错误，那么我们可以开始了。

好的，起点，我们需要获取用户输入。我们必须有一些东西来扫描。所以我们将说深度输入。这个函数将非常简单，但我们需要解释一些复杂性。因此，第一件事我们要做的是使用这个全局变量。所以我们需要使用 global 关键字。

所以全局变量。如果我们忘记使用 global 关键字，我们现在正在创建一个新变量。然后 Python 将根据 Python 的版本选择使用全局变量或在函数内部创建一个全新的变量。所以我们想告诉 Python 从这里使用全局变量，我们将获取用户输入。

我们要说 RE 等于，并且我们将稍微不同地处理，而不是仅仅说输入然后获取输入。我们希望将其转换为路径，全部在一行中。所以有人会说 O S dot path。当我们想要绝对路径时，现在我们想获取用户输入。我们将简单地在一行中完成这一切。

我们将说获取用户输入并将其转换为绝对路径。很酷，现在我们有了这个小家伙。我们可以检查它是否真的存在。我们将使用 OS.path.exist。注意我们在说如果不是，这意味着如果它不存在，这将返回错误。

然后我们想采取某种行动。在这种情况下，我只是想让用户知道，嘿，你搞砸了。我们不能继续这个程序，所以。抱歉，路径不存在。然后我将退出我们的应用程序。如果你不知道退出代码是什么。通常，当你运行一个应用程序时，它会运行，做它的事情，然后退出。当它退出时。

它告诉操作系统发生了什么。0 意味着没有问题。这按预期工作。但显然，情况并非如此。所以我们将给它一个退出代码 1。这实际上取决于你作为开发者来确定这些退出代码是什么。可以是 1，可以是 99，91，随我们想要的，我们只会用 1。

这告诉操作系统这并没有按预期工作，如果我们有最终用户，他们可能会说，哦，程序给了我退出代码一，你可以说，“是的，你给了我错误的路径。”现在，我们想说如果不是 O S path，并且我们想确保这是一条目录，因为有时我们的用户并不是那么聪明，他们会给我们一个文件或类似的东西。

所以我们要说抱歉，那条路径不是目录。然后我们假设退出代码是 2，我们可以定义我们想要的任何内容。现在我们已经达到了这一点，我们知道我们有一个有效的路径，并且它存在且是一个目录。所以我们将更新我们的全局变量，在这里我们有一半。

所以这就是我们要在这里更新的内容。并且说统计信息。half等于。所以我们只是在设置字典值路径为他们输入的任何文件夹。非常简单，逻辑非常容易理解。现在我们已经得到了用户输入，并且知道他们想要扫描的路径，我们想要递归地扫描那个路径。我们将在一个函数中做到这一点。

所以我们将说de scan。给它一个路径。同样。我们想使用那个全局变量，所以我们可以说global。Thats。我喜欢这个词。统计信息让我想起医生之类的。如果我们想要非常好，我们实际上可以打印出我们正在做的事情。所以我们会说扫描。

然后无论我们的路径是什么。现在你可能会想，为什么我们要使用一个变量，当路径实际上在统计信息中。原因是我们将递归地做到这一点。意味着这个路径变量在这里会随着时间的推移而变化，而字典中的路径是根目录。所以这实际上可以是一个文件夹的文件夹的文件夹，类似的东西。

所以这就是为什么如果你在想这个问题。现在来了个花哨的部分。我们要使用一个叫做O S.dot walk的东西。我想先说明一下，有一百万种不同的方法来做到这一点。我们只是使用一种方法。所以我实际上会列出数百万种方法来做这件事。我相信评论区里会有人说，你不应该使用OSW。

你应该使用其他方法或Gob之类的，我们只是会使用OS walk，因为它简单易懂。所以我们会说四。Walk将返回三个值，它会说根目录、目录和文件。所以根目录显然是根目录，目录是目录的列表，文件是文件的列表。我喜欢这个非常自解释的方式。所以这将在O，S.dot walk中。

这就是我喜欢使用walk的原因，因为它非常简单易用。非常容易理解。我们将扫描那个路径，如果我能正确拼写路径的话。然后我想说在错误时。我们将其设置为none。我们必须这样做，因为会有一些文件夹你根本无法访问，比如你会得到访问被拒绝，或者你会遇到某种奇怪的硬盘错误，或者你不想让你的程序崩溃。

所以我们将说在错误时等于none。我们可以将其设置为一个函数或我们想做的任何事情。但是我们只会说none。所以不采取任何行动。然后跟随链接。我们将其设置为alts。这意味着如果你有一个链接。想象一下，它像是指向其他地方的快捷方式。如果那被设置为true。

你可以扫描很远的地方。所以比如说，如果你有一个文件夹一。为了注释掉这一点。假设你有文件夹一，在文件夹一里面有一个链接。那个链接指向文件夹三。你大概能看到这里发生了什么。Azure正在扫描文件夹1。如果你跟随那个链接，你将跳到一个完全不同的文件夹，即使说是文件夹3。

在根级别，就像上面那样，所以我们不想这样做。我们想确保不跟随那些链接。好的，从这里开始。我们将说 stats。我们想在这里更新我们的指标。所以我们想知道文件夹。文件夹将是 plus equals，我们想要链接。你猜对了，是你的。

所以这将是一个列表。我们想获取那个列表的长度或项目数量。我不记得它实际上是列表还是元组。但 Telec 告诉我它是一个列表，files 也将是一个列表。列出你的元组，我不在乎。我们现在只会获取它的长度，现在我们将说 files。

我们也将更新文件的指标。你需要小心一点，它是 folders。filess，我们拼写这些时要正确，否则我们实际上是在添加一个完全不同的键。从这里开始。我们想说。或者。Name in files。我们将逐一扫描每个文件。

我们将说 full name。等于 O dot。Half。At join。这样做将允许我们将根目录或文件夹名称与实际文件名连接起来。这将是两件不同的事情。这就像实际的路径，而这只是没有附加目录名称的名称。

所以这可能是类似于 S dot T X T，而不是实际的完整路径。我们想确保将它们连接在一起。O path join 正是这样，连接两个或多个路径名称组件。好的。这为我们解决了很多麻烦，所以我们不必担心它。从这里开始。

让我们继续获取一个大小。我们将说 O，S dot path。你看我们在很大程度上使用 O S，尤其是 path。所以 O S 的 path，我们想获取大小。这将获取那个文件的大小，我们将使用完整的路径名称，而不仅仅是名称。一旦我们得到了那个大小，我们可以进入这里，我们可以说 stats。然后跳上去。

让我们看看我们在这里使用的键，size。所以我们可以直接使用。Size。然后让我们增加它。所以，从顶部开始，我们将扫描一个路径，我们将不断扫描那个路径。这就是我喜欢这个的原因。现在，有一点你应该知道，这有点误导。其实我们如果想的话，可以完成我们的 stats。

但我希望在需要时能在其他地方使用这个，通过允许我们跳入那个路径。你稍后会明白我的意思。

现在我们已经递归扫描，我们只想简单地向用户展示我们到目前为止所做的事情。这实际上是在程序退出之前的最后一步。所以我们将说 depth display。再一次，我们可以用很多不同的方法来做到这一点。我们继续将其转换为小写。实际上，我们只想打印出我们的字典。

这就是我把所有东西放在字典里的原因，因为它整齐且紧凑。所以我们将说全局统计数据。现在你知道全局关键字的作用了。我们将打印单词结果。然后我们将打印字典中的键值对。所以我将说四。Acom a v。也了。那。还有个因思。那将给我们键值对。

然后从这里开始就非常简单，租赁。我们将格式化它。我想打印键，带等号，然后是值。非常简单的函数。但在屏幕上看起来会非常优雅。好了，是时候在这里结束了。让我们做我们的主函数。好吧，让我们继续说。De mean。一些Python nus将会说。

我们真的需要做一个主函数吗？我的意思是，如果我们想的话，技术上可以做一些像如果名称等于的事情。然后我们想说__main__。然后我们可以在这里做我们的代码。你绝对可以这样做。我不喜欢这样做。我喜欢把所有东西放在一个整洁的函数里，以防我想后期更换函数，这样我就不用复制粘贴做其他事情。

所以我只会在这里实际调用我们的主函数。现在记住，我们在这里做的是检查这个文件，这个单独脚本是如何运行的，如果它是由Python解释器直接运行的，它的名称将是__main__，我们之前谈过下划线。但这些是Python用来确定的特殊字符，嘿，这是Python内部的。

所以如果Python运行它，名称将是main。如果是其他名称，意味着另一个脚本在调用它。我不想触发这个主函数，而是调用脚本。调用脚本可能想要调用显示或扫描。这就是我为什么留着那里的原因，而不是使用这个全局。哇，很多解释。但我想你现在能理解了。一旦我们走到这一步。我们可以说，全局。那。实际上，我不需要那些。所以我们将告诉它，嘿，我们想要使用全局变量。从这里，我们将继续获取用户输入。

我们本可以稍微不同地做这件事。我们本可以让获取输入返回一个值。但相反，我想把所有东西封装在里面。这样，如果其他函数调用它，所有内容都直接融入我们的全局变量。这是一个设计选择。你可能需要根据你的需求进行调整。现在，让我们继续扫描。

注意我们现在有一个路径，我们必须提供这个，我们可以简单地说统计。半。我们正在获取路径。从git输入。如果我们想的话，我们可以很容易地把它硬编码到应用程序中。最后，让我们继续向用户显示最终结果。我们可以稍微简化一下，让它在视觉上更容易些。

所以主要逻辑非常简单。我们将使用我们的全局变量，获取输入。我们将扫描该路径，然后显示结果。让我们开始这个过程，看看会发生什么。好的，输入一个文件夹路径。如果我想扫描当前路径，只需按一个点，因为记住，点代表当前目录，而点点代表父目录。

结果显示，当前目录确实是这里的这个，Python 3。有两个文件夹，两个文件，长度为零，总大小为2594字节。好的。所以到目前为止，这个程序相当不错，简单。它易于理解和使用，但同时也在执行一些相当复杂的逻辑，适合初学者。

主要收获是，是的，你可以使用全局变量。尽管这可能并不总是最佳设计选择。始终，始终，始终验证用户输入，你绝对不想完全信任最终用户。我的意思是，例如，如果我运行这个，输入“猫”。抱歉，该路径不存在。

如果我们尝试扫描“猫”，你的程序将崩溃。现在，扫描。从这个过程中的主要收获是，有成千上万种不同的实现方式。我使用了OS S walk，选择适合你的方式。我个人更喜欢OS walk，因为它让我可以轻松地在需要时中断，因为它在一个整齐的for循环中。所以如果我想深入几层，我可以再次构建那个逻辑。

显示时，我们基本上只是使用目录项来获取键值对，然后打印出来。接着我们讨论了Python内部的命名约定。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P5：5）Python字符串 - ShowMeAI - BV1yg411c7Nw

大家好，欢迎回来。我是布莱恩，我们将讨论字符串。那么字符串是什么？这是个很好的问题，我们面前有一个简单的图示。单词hello H E LLO，旁边有一些数字，我们将解释这些。实际上，字符串是一个列表。没错，字符中的每个字符都转换为一个数值。

如果你低头看你的键盘，把它看作字母H。那个字母，依赖于是否按下了shift键，将是104。我提到“依赖”是因为小写和大写之间有数值差异。这里我们讨论的是小写。有些人会说。

哦，那是ASCI，我以前听说过，这其实不是ASI，而是Unicode。具体来说是UTF-8，我想是通用文本格式8位或版本8，我忘了。但是基本上Python在底层以UTF-8处理。因此无论你是在输入英语、韩语还是西班牙语，都是一样的。

古希腊或某些数学算法。每个字母都有一个分配的数字。

计算机知道那是什么，并为你处理这一切，所以你不必担心。你应该关注的两件主要事是，构成字符串的字母，以及下面这个，位置。所有内容都是一个列表。所以当你看到H，E，L，L，O时，那里有五个字母，且从0开始有五个数字。这是一个基于0的索引，0。

1，2，3，4。所以如果我说给我第三个位置的字母。H，EL，这个家伙。实际上是数字2，因为它是基于0的。如果你是新手，可能会有点困惑，你会想等一下。实际上是数字3。记住，它是从0开始的。所以第一个总是0。我们考虑计算机的角度，0，1，2。这个家伙就在这里？

一旦你理解了这一点，你就比大多数人更了解这个问题，老实说，这并不太难。你只需理解屏幕上看到的每一件事都有某种数字与之关联，计算机处理那个数字。你只需要关注字母和位置。我们将深入探讨这一点。好的。

让我们翻转一下单独的Studio代码，我们将复制并粘贴一些代码，这看起来绝对是你之前见过的任何东西。别担心，只需迈出信心的一步。我们将在未来的视频中讲解这一点。

但实际上我们在做的是，针对字符串hello中的每个字母，打印出字母及其数值。你可以看到104，101，108- 108111。把它们变成内存104，101，108，108111。如果我们回头看看，这正是我告诉你的结果。那么让我们深入了解一下，看看发生了什么。

现在，我们将在未来的视频中讨论循环。这不是这个视频。我们专注于字符串。所以你要做的第一件事是如何制作字符串，简单得很。只需创建一个变量并赋值。再来一次。注意第一个名字或第一个变量。使用了双引号。

当姓氏或第二个变量使用单引号时。在 Python 中，你可以两种方式都做。他们这样做并不是为了让你困惑，而是因为作为程序员，你会在生活中发现很多小问题。

这非常方便，你可以随心所欲地调整它。所以你首先要尝试的就是简单地将它们合并成一个更大的字符串或打印出来。所以我们要打印。我想说 first。是。和 last 现在你认为这里会发生什么。

你注意到我们在使用加号吗？如果你是数学迷，你会说，哦。这会输出一些奇怪的数字，实际上不是。它会说你猜对了，我想这个术语叫做连接。它会把它们合并成一个内存中的字符串。

所以它说的是第一个带空格的布莱恩。和最后的，卡伦斯。非常简单。你还可以做一些叫格式化的事情，我们之前做过。这确实可以帮助你在长期内避免错误。所以你可以这样说。print F。注意我使用了引号，无论是单引号还是双引号都无所谓。

我要说的是，您好，我的名字是。然后，让我们看看。好吧。我得看看我的键盘来找出那是什么。然后我们只需输入变量名。First。然后是 last。现在，我们倾向于使用格式化来避免问题。你已经看到我这样做过，但你可能还没有真正意识到为什么。我们将在这里稍微讨论一下。

嗨，大家好，我叫布莱恩·卡伦斯。为了加深你的理解，让我们创建一个叫做 hers 的变量。我们要说 Others。注意我如何混合这些内容。我使用双引号，以便 Python 知道，嘿，这就是字符串，但我们也可以使用单引号，这样就会变得非常混乱。

它会取第一个，它会说，哦，你正在使用双引号来构造字符串，所以如果我把它改成单引号。注意这个字母突然变成了白色。即使我用单引号结束，它也会对我非常不满。看，语法错误，无效语法。

如果你看到语法错误，实际上，Python 想告诉你的是，你搞错了什么，它会告诉你具体在什么地方。在这个文件的第 11 行，Dat.dot do 和 hers。然后在 S 下面有一个小箭头。它不知道该如何处理这个，因为它不在字符串中。改变它。

它放了双引号，然后神奇地修复了它。看，这并没有太多意义，所以让我们改回去。这就是你可以混合搭配的原因，它让事情变得超级简单。我们可以直接打印出来，效果如预期那样，这是我们的小单引号，我们不需要担心任何特殊编码或格式或其他事情。

好的，为了巩固这一点，从底层来说，字符串是一个Unicode字符序列，特别格式化为UTF-8。如果你想要其他格式而不是UTF-8，你得去谷歌一下怎么做。我只是说我们还没有覆盖这个，将来可能会，但如果你需要立即的东西，去谷歌一下绝对没错。

字符串是一系列一个或多个字符，这些字符是数值，这正是我们现在要强调的。让我们创建一个变量，叫做S1。我们希望这是一个字符。注意它在寻找一个整数。返回一个包含字符的Unicode字符串，然后它给你一些示例。我将说，因为我把72记在脑海里。

然后我们要再创建一个。试一试这个字符，我们说105。现在，你看不到，但我这里有点作弊。我在看UTF规格和字符表，你可以通过访问这些链接和其他链接看到它们。它将给你数字值。如果你想做这样的事情。

你其实并不需要这样做。我只是演示一下，可以做到。所以我们说S1加S2。让我们运行一下，它拼出单词high。注意这是大写H和小写i。72。现在，小写h是104，大写H是72。这就是我所说的大写和小写之间的根本差异。现在，你可能会倾向于问，粗体和斜体呢，这实际上不在其中。

那些不是字母。它们只是你在屏幕上看到的样式和格式。因此，我们讨论的实际上是大写和小写。它实际上远不止于此，你可以这样做。比如说打印。我要说字符。我真的得作弊一下，看我的笔记，8，7，1，0。这就来了。

远不止于提问。让我们继续保存并运行，看看这是什么样子。砰！就是这个小数学符号。没错，它里面包含了数学符号。你可以用简单的字符做一些非常酷的事情。😊

你可能听说过转义字符。那么，什么是转义字符？这并不是小说中的东西，虽然它可能是。但基本上，不必记住这些奇怪的数字，它们实际上内置在大多数语言和操作系统中，称为转义字符。这意味着你可以转义字符串并打印出特殊字符，看看这如何在这里工作。

我们甚至会格式化这个，只是为了展示这个是如何工作的。我将说，您好，然后是世界。注意我把它们搞得有些混在一起。现在你可以这样做，你可以说，好吧，我查了一下，13表示硬回车，加上，我想做一个字符10表示换行。这会把它放在两行上。

我不得不去查这些数字，因为我没有记住，但它确实有效。你好，世界，或者你可以简单地做这样的事情。我们将把它抓取，去掉那些无用的内容。反斜杠R表示回车，反斜杠n表示换行，保存并运行。这会产生完全相同的效果。所以在幕后，这个小家伙反斜杠R。

注意，转义字符以反斜杠开始。我们说反斜杠R表示回车或N表示新行。效果是完全相同的。在实际使用中，你会看到这两种方式，有些程序员会要求你使用字符，有些程序员则会要求你使用转义字符。

这有点让人困惑，直到你习惯它，但其实超级简单。你可以做这样的事情。实际上，我们要做的就是打印出来。你好，世界，中间加一个制表符。反斜杠T表示制表符。当有疑问时，可以去谷歌搜索一下“什么是转义字符”。

它会给你一份完整的列表。有很多很多的，但它们非常简单易用。这是带有制表符的你好，世界。你可能会想，为什么要使用转义字符。这似乎有点基础。让我们回到这个问题。我们想把它放进去，结果如果这样做就可以。

在双引号中，但当我们将其改为单引号时，记住我们会遇到某种问题，它不会识别X，会提示你“猜猜看，这是无效的语法”。那么，不必逐一更改所有字符串。

我们只需在前面加个反斜杠。大多数情况下，这样会有效。它会正确转义。继续保存以清除这些内容。让我们实际上清除这个，给你展示它会有效。没有更多的语法错误。我们可以打印出这个坏东西。所以转义实际上成为了一种非常方便的方法。

打破你应该使用哪个引号的限制。我知道我会不断被问到我应该使用单引号还是双引号，其实这并不重要。只需选择一个并坚持使用，如果需要切换，可以随时跳出。其实并不难。你也可以这样做。

这是我经常被问到的，不仅仅是Python，而是几乎每种语言。所以我要说引号等于。你看到我们在做什么吗？

你可以有多个转义。其实没关系。基本上，我们在这里说的是，一旦你做了这个斜杠，计算机会尝试搞清楚你在做什么，如果无法搞定，它会给你一个错误信息，此时你可能需要像这样处理，或者你只是使用了错误的转义字符。如果有疑问，就去试试。通常在这里操作起来很简单，所以我们就继续。然后他说。

引号，霍，给我。

现在，你可能想知道，阅读书籍或观看Python视频时，格式化到底是什么回事。它们会深入探讨格式化及其重要性。实际上，你格式化是为了避免错误，尤其是在处理字符串时。让我给你一个很简单的演示，比如。名字是布莱恩。46岁。哇。

我今天感觉46岁。昨天我整天在扫落叶。哇，是的，真糟糕。好吧，我们要打印出来。我会说名字加上。然后我们要年龄。哦，这样可以。会很美妙，对吧？好吧，猜猜看。不，它并不能。这有个原因，乍一看并不聪明。我们将说第36行。

在这个模块中，打印，并且不会显示小箭头。但它确实告诉我们必须是STR而不是。它真正谈论的是这个。你要做的是把所有这些当作一个巨大的数字，然后把它们相加。我们正在尝试做基本的数值运算，而这些我们已经覆盖过了。

而Python不允许我们这样做。那么我们就把它去掉。这里放个注释。现在让我们展示一下如何正确处理这个问题，方法有几种。我们可以用我们一直在做的方式，即在字符串前加个F。然后我们说我们现在在格式化它。其实并不难。我们之前做过这个。

但如果你想要更多的控制，有其他方法可以做到。我们不会深入探讨每一种可能的方法。我只是给你展示我最常用的两个。这是下一个。我们只要打印。我想说，我们用双引号，为什么不呢，我的意思是。

在这里，我们要做的是说明我们想要什么。发送 S。我们在这里做的是创建自己的特殊自定义字符串，并且格式已嵌入其中。我是，然后我想要一个百分号 I。或者整数。从我在这里开始，不过，现在我们需要做一个百分号，并告诉它，嘿。我们将给你一些值。

这些值将被命名为名字和年龄。现在，我通常不喜欢这样做。因为你必须阅读整个内容。跳到这个百分号，然后看看这个小家伙，弄清楚我们要发送什么。好的，所以名字是第一个字符串，好的，然后年龄是第一个整数。好的。那么让我们运行一下，看看结果。它说我的名字是布赖恩。我46岁。

让我们来玩一玩。让我们放入 I 和 S。只是想看看我们能否轻易地破坏它。果然，我们几乎没有任何努力就破坏了它。类型错误。所以我真的倾向于简单的格式化，因为我们不需要在这些上面浪费时间或者担心搞砸。但如果你需要特殊格式，这真的非常简单，可以直接放进去。

如果有疑问，谷歌是你的朋友，老实说，有成千上万的教程可以帮助你深入学习。不过我们不会花太多时间在这上面。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P6：6）Python字符串操作 - ShowMeAI - BV1yg411c7Nw

欢迎大家回来，我是布赖恩，我们将继续我们的Python 3之旅，现在要继续基本的字符串操作。当我说字符串是复杂的数据类型时，我并不是在开玩笑，而我们不可能在这两段小视频中涵盖所有内容。

特别是因为我们甚至还没有涵盖编程的基本逻辑。因此，我们现在必须坚持基础知识。别担心，在系列的后面部分，我们会重新审视一些更高级的内容。但现在，你必须学会爬行，然后才能走路。所以，让我们开始爬行吧。

我将说变量STR将是：“Hello world，这是一串字符。”非常，非常简单，我们就从这里开始。我们在这个视频中要做的事情是获取字符串的长度，重复字符串，替换字符等操作。

甚至可以切片并获取字符串中的特定索引或位置。

让我们深入基本操作。因此，第一件事。假设我们想要获取长度。我将说“print”。我们将调用len函数，这不仅限于字符串，但它对字符串来说超级有用。我们将再次调用它，简单地打印一个注释，获取长度。当我们运行这个。

我们可以看到这有30个字符。现在，你可能会倾向于说“等一下，这是基于零的，所以实际上是29。”不，这实际上获取的是长度，而不是位置，这在后面你会看到是根本不同的。因此，现在我们得到了长度，我们还可以做其他事情。

假设我们想要重复一个字符串，这会让你大脑稍微痛一下。我们谈过字符串不能进行数学运算。记住吗？我们试图将一个整数和一个字符串相加。好吧，你可以进行所谓的字符串数学。这就是我所说的，它会让你的大脑受点刺激。

我们将说SR乘以3。现在，我知道你在想什么。你在想你会得到某种奇怪的东西，因为你在尝试相乘。但实际上你告诉Python做的是取这个字符串。没错，乘以3并返回一个巨大的字符串。让我们演示一下。“Hello world，Hello world，Hello world。”

所以它确实完全按照我们的预期工作。是的，第一次我这样做的时候，我坐在椅子上，想，等等，这到底是什么。但这确实是Python的一个特性。如果你来自其他语言，你可能会呆呆地盯着屏幕，心想，这是什么巫术？

但如果你需要重复一个字符串，这实际上非常方便。现在让我们看看替换。如果你来自其他语言，嗯，这正是你想的那样。它简单得令人发指。所以在 Python 中，字符串是一种数据类型，但它们也是一等对象，这意味着它们内置了函数。

我们还没有真正讨论函数，但只需知道，你可以在变量名后加一个点，然后调用一些代码。我们将调用替换函数。这将会做什么呢？它将取出字符串并替换其中的一部分。比如说，我想把 hello 替换为 Hla，所以如果你来自墨西哥、西班牙或任何讲西班牙语的国家。

这将是正确的说法，hellla 是 Holla。我在发音上有点失误，但你明白我的意思。你可以简单地替换它，所以 Oah world，这是一个字符串。这样做非常简单。你不必弄清楚事物的位置。你也可以做类似分割字符串的操作。所以如果你来自其他语言。

你之前做过这个。我想说 SDR，我想要分割。注意它在寻找一个分隔符。所以让我们在那个逗号上分割。如果你不是来自其他语言，你可能会想，等等，等等，慢点。什么是分割？所以我们将把这个字符串转换为两个字符串。

我们在寻找一个分隔符值。在这种情况下，就是这里的逗号。所以它将说 hello world。然后这是一个字符串。它将返回两个字符串。好了。Hello world。现在你可能会想，等一下，这个逗号在这里。

看看这些小括号。你有这个括号，这是开始括号。它创建了一种我们还没有讨论过的数据类型，但我们将在接下来的几个视频中讨论。它把两个字符串放入那个数据类型中，然后交给我们。这是一种非常方便的方式，告诉我们，嘿，分开它们。当你继续编程时。

你实际上会经常用到这一点。现在，假设我们想知道这是否以某个东西开头。所以我想说 SR。我想说，以……开头。是否以字母 H 开头？我几乎不好意思输入这个，因为它显而易见，但以防万一，它将返回一个布尔值，并告诉我们，嘿，是的。

如果我们把这个改成 J，是否以 J 开头？非常简单。方便判断发生了什么。我们可以通过神奇的复制和粘贴，把它改成以 ends width 结尾。假设我们想确保它以感叹号结尾。真。真。好了。现在让我们看看大写、小写和首字母大写。

我们将说print。我们想要upper。它将给我们hello world。这是一个全大写的字符串。你注意到它有这些括号吗？那是因为这是一个函数。如果我们省略这些括号，我们将获得一个内置的字符串对象的upper。然后这个数字。

你见过这样的东西吗？基本上，你想要做的就是在没有括号的情况下调用一个函数。你需要那些括号，你可能会想这个数字是什么，那是内存中的一个位置。因此，一个对象实际上就是在内存中存在的某样东西，而这就是它的位置。老实说，这条信息对于初学者来说并不是特别有帮助，但我只是想解释一下这是什么。

为了补充这个，我们说lower，我想要capitalize。所以现在我们有了全大写、全小写，并且以正确的方式首字母大写。让我们看看切片，当我第一次听到这个术语时，我实际上有一种拿出光剑切东西一半的幻想。

实际上，这与我们所讨论的内容并没有太大区别。我们在谈论获取一个子字符串。现在，当我说substr时，请记住，这个字符串只是字符的序列，每个字符都有一个位置，所以零的位置在这里。然后是1，以此类推。

所以我们想要做的是获取一个子字符串或切片。想象一下你面前有一个派，你要切一片，而不是把整个东西都拿走。所以例如，我可以说我想要单词“world”，或者我只想要这个单词“this”中的“T H”，或者我想获取到某个特定位置的所有内容。你可以这样做，非常简单。

在Python中，这个过程非常迅速。如果你来自其他语言，我要告诉你，一旦你理解了它，这个非常酷。所以我会说print。我们将使用我们的变量。现在我们将添加这些括号，这表明我们正在获取一个切片。这里的格式非常简单。我们想要开始的位置。

一个冒号和一个结束位置。在这种情况下，起始位置我们将说是0，或者说是起始位置，我们将结束在5。这将获取前五个字符。这是一个零基索引。让我们打印出来看看会发生什么。一，二，三，四。

五，hello是五个字母，好的，所以它确实完成了我们想要做的事情。正如我所说的，最开始看起来有点混乱，但一旦你开始理解它，就不是特别困难。现在我想从第六个位置开始，而我将省略结束位置。我们在这里所做的就是，我们希望从第六个位置一直获取到末尾。

所以当你发出某个东西时，它会自动默认到开始或结束，具体取决于你选择的哪个位置。所以第六个位置是你猜的。“世界”。就在这里。T按预期工作。让我们抓住这个，试试不同的东西。我们将从负7开始。现在，你可能在想。

等等，什么负数，我们怎么会有负7。好吧，当你有负数时，实际上是从结尾开始的。所以因为我们是从负数开始的，它将从这里开始并向后计数。实际上这个工作方式挺酷的。让我们运行这个。最后的七是字符串感叹号，真是挺酷的。

尝试用其他语言做这个，有些会很酷，有些则会让你完全恼火，具体取决于语言。现在让我们获取一个子串，我们要说从6到11。我们想得到。6到11。只是为了记录，看看那是什么样的，它是“世界”。非常酷，非常简单。

非常简单。现在，如果你来自其他语言，可能仍然困惑于这一点。别担心，每当你看到那个负号时，只需想象你是从结尾开始向后工作。切片很酷，但除非你能自动获取数字，否则并不太有帮助，因为没有人想在这里数东西。

对吧？所以让我们看看如何获取某个东西的索引或位置。我将说L等于。我们要找逗号。现在如果我们看看原始字符串，这里有个逗号，但我们不知道它的位置，所以我将把它隐藏在屏幕外，我们只想知道嘿。

我们想寻找这个。我们将用两种不同的方法来做。我们将说。C等于SDR查找。这就是我喜欢Python的地方。它非常直观。Fine确实做了你认为它会做的事，它找到了一些东西。它会告诉我们我们要找的是L，并且会告诉我们它的位置。

如果找不到它，比如说负一，如果不绑定。我们来打印一下。我想说。好的，返回。C。让我们运行这个，看看它做了什么。哦，实际上“fine”拼错了。修正一下。所以找返回C。它在第11个位置。我们不需要在这里数1，2，3，4。否则我们会在这里呆一天。相反。

我们希望电脑为我们做这些工作。所以我们知道这是在第11个位置。现在我们把这个改成别的。我们就用一个T。你会看到找返回负一。所以在这种情况下，当你看到负一时，可以说它根本不存在。它不会返回到0，因为记住，0是起始位置。所以，Findd确实是。

非常酷，但如果你来自另一种语言，你可能在寻找index of，那是完全不同的东西。所以我将说i = SDR.index。我们将给它相同的内容，L。现在我们想要这个。我们会说find返回。好吧，让我们看看这会做什么。现在，记得。

我们这里有这个t。这里的t在哪里？它就在这里，但它是小写的，而不是大写的。所以它应该返回负一，或者实际上，它不返回。相反，它给你一个叫做值错误的提示，substr not found。这是一种方便的方式来表示，嘿，那个必须存在，否则就会抛出错误。这是我们将在未来的视频中讨论的内容。

只需知道find不会返回错误，而index会返回错误。所以大多数时候你会想用find。但如果你来自其他语言，你可能认为你想用index，其实你真的想用find。这很令人困惑。有时候会有行和错误。我们只是想确保将这一点写在这里以防万一。现在我们切换回去。

你可以看到它们都返回11。因为我们在寻找那个逗号，记得吗？index会抛出一个错误，而find只会简单地返回负一。总结一下，我们想要从子字符串创建一个新字符串，我们该怎么做？

所以我们想说x等于SDR。我们要对这个字符串进行切片。我们要从起始位置开始，因为我们想从头开始，并且只想到这个逗号的位置。如果这看起来非常困惑，我们放慢速度。我们有一个字符串，内容是，hellello world，这是一条字符串的感叹句。

所以我们在寻找这个字符，发现它在第11个位置。我们在说，好吧，从最开始。Eello world实际上是要把整个内容复制到这里。复制这个，把它作为注释放在这里。好了。我们将从这里开始，一直到我们找到的位置。

我们想要创建一个字符串，称之为X。现在，我们想要取出这个字符串并打印出来。你好，世界，超级简单。快速回顾一下。在Python中，字符串是第一类对象。它们默认是Unicode，编码为UTF-8，虽然你可以指定其他方式。如果你需要立即这样做，谷歌是你的朋友。

你可以做一些很酷的事情，比如获取长度、重复、替换、拆分。确保它以某个字符串开头或结尾，或者转换为大写或小写。你可以切片、切割，做你想做的任何事情。你还可以在字符串中搜索或查找内容。如果需要在不存在时抛出错误，你可以使用index。

我不推荐这样做，因为在大多数情况下抛出错误并不是一个好主意。你可以很简单地从子字符串创建自己的字符串。😊。