我将讨论我们为数据科学初学者 掌握 Python 的课程的重点。
因此，让我解释一下我们在这门 特定课程中最关注的领域。
事实上，因为这是一门课程，对于初学者来说 ，那是一门初级课程，我们不是
假设课程学习者对任何 计算机编程有任何经验
之前的语言，甚至不是问题， 问题解决范式在于计算机
科学。所以，我们会，我们将专注 于解决问题。我们将真正开始
从一开始什么是解决问题，特别是 在计算机科学中。这
这门课程的第二个重点，主要是 告诉你我们为什么选择 Python，
为什么 Python 如此重要，尤其是对于 数据科学问题。第三个重点和
主要的核心重点是学习Python，显然，一旦 我们知道什么是什么技术是什么
解决一个问题。一旦我们知道 Python 可能是一种非常好的语言
有了，那么Python是什么，怎么学呢？ 嗯，Python 是主要的核心和主要的
这门课程的重点，显然，我们将 从一开始，非常，非常开始，
这意味着我们将从如何安装 Python 开始，我们将从那里开始，
然后我们将看到什么是变量，我 的意思是，非常非常开始，然后逐步
我们将不断地从数据结构 到复杂的结构，但是
从 02 年开始过渡，过渡将非常 非常顺利。我的意思是，无论
你知道，到目前为止，在课程中 ，这将帮助你获得更复杂的结构
非常非常容易地理解 很多结构。
所以在这个 Python 中，我们将概括地包含 Python 的所有概念。而且，还有一件事，
在我的意思是学习之后，尽管 在我们组织这门课程的方式上
这个 Python，你也会理解其他 语言。我的意思是内容
这里以如此一般的方式解释了 整个 Python 语法，但一般但
但是这些概念以非常笼统的方式 表达，我们选择解决的问题
因为练习是如此通用，以至于你会 在这门特定的 Python 课程之后，你会
对编程语言有一般的了解。所以 数据科学是另一个重点
在这门课程中，实际上，整个 课程的组织方式是教给你的
关于 Python，它教你解决问题， 它教你一些关于整体编程的知识
语言以及如何使用计算机 来解决不同的问题。
并且使用 Python，当然， 然后我们将介绍数据科学包
在 Python 中可用，因为它们 非常非常快，非常基础，
非常易于使用，并且非常非常强大 ，可以非常快速地处理大量数据
用于数据理解、可视化、 清理、处理和很多东西，
我们没有关注什么，因为那 很重要。知道什么样的事情
是我们没有覆盖的东西，例如 ，我们没有覆盖面向对象
编程，我们不涉及异常处理 ，我们不做网络开发，
或者任何可以在 Python 中完成的一般 任务，我们不关注这些事情。
每个人每天都在解决不同的问题 。有些问题很容易解决，而且
有些是困难的。然而有些是不可能解决 的。它们被称为无法解决的问题。
但是想想需要再次解决的 同一问题的不同实例
再次。例如，对销售记录进行排序 。假设我们正在整理销售记录
关于销售价值。我们必须 每八小时后做一次。如果数
如果这个数字很大，最佳选择 是自动化解决方案，如果
自动化是可能的，但是如何 想出自动化的解决方案来
具有适用于某些问题的每个实例 的通用解决方案。那是一回事。
但是让该解决方案在计算机上运行 又是另一回事
问题解决涉及形式化适用于每 个实例的通用解决方案。
和编程语言，比如 Python 处理 在计算机上运行该解决方案。
正如我们将看到的，Python 实现了从 解决问题到运行解决方案的转变
更容易和更快。这是 Python 的一 大优势。很多话，我知道很多
的话。让我举个例子来澄清 我所说的，坚持到这结束
视频。我会把到目前为止我所说的一切 都说得一清二楚。所以让我们举个例子。
让我们深入一个例子，看看我刚才说了 什么。假设您是 a，而您的朋友是
B. 你的朋友 B 总是愿意帮助你 。假设您找到了这样的朋友。
然后一个刚刚说，我想休息几天。 但不得不说，不过什么ghobadi享受。
他说，在我不在的情况下，必须有人来做我的 工作。然后被说，就这样？是你的
问题？我有空？和往常一样，伙计，享受。 男人。他说，太好了。你是一个真实的
朋友。好的，我要走了，哇。只是说 ，嘿，等等，我该怎么办？什么是
你的工作？归根结底，我会做你的工作 。你的工作是什么？你是什​​么
做？然后他说，每八小时后，在 最大的时候选择客户的电子邮件
销售量。所以这就是你必须做的。他说，好 。但从那里，我的意思是，我必须选择
那个客户的电子邮件来自哪里， 记录在哪里？他说，嗯，有
销售记录。我的意思是，在工作场所 ，有销售记录。你必须选择
销售额最高的客户的电子邮件。我们说 ，哦，好吧。但是等等，什么，应该怎么做
我如何处理我刚刚选择的电子邮件 ？然后他说，哦，还有一个记录叫
优先记录，八小时后写那封 邮件，纯粹地写那封邮件
记录。然后说，就是这样。这就是你的 全部工作。他说，在如此放松之后，
他说，是的，那是我的工作。就这样。不 ，认为他离开了，那天晚些时候会收到
B 打来的电话。 B 说，我真的不知道 该怎么办。你能一步一步告诉我吗？
该怎么办？再次关注，我正在再次阅读 这个特定的句子。你能告诉我吗
一步一步做什么？我有销售记录 ，我有上次的所有记录
八个小时，怎么办，我只是把一切都搞 砸了。我不知道该怎么办。然后在
打电话，他只是描述了一个适合他工作 的程序。那个程序或者一个通用的解决方案，
让我们看看解决方案。他说第一， 从第一条记录开始，可能会有
几列记录，客户姓名 ，客户电话，客户
电子邮件、他购买的客户产品 和总销售额。在第一点
说，他说，从第一条记录开始 ，只关注销售栏。好的，
然后，再之后，逐条查找下 一条记录，找到最大的记录
销售量。显然，一旦你关注了销售 栏，你就只是在比较销售额
不同的记录相互之间，并 最终会拿出一个记录
最大销售额。第三。
如果有多个记录的最大销售额 ，则可能是最大销售额
价值让我们说是 100，无论单位是什么 ，可能有两个或三个，或者可能
5 个最大销售额为 100 的记录。然后 选择哪一个，如步骤中所述
三、如果销量最大的记录不止 一条，则选择第一条
从上到下，忽略其余部分，以唯一 为准。所以让我们说你有
销售价值最大的五个记录，从上 到下哪个记录最先出现，只是
选择那个并忽略其余的。这可能 是一项可能打破平局的政策
政策，但只是这样做。然后 第四步关注记录的email栏
你在第三步中找到了。在第三步中， 您找到了销售额最大的列。第五步，
查看电子邮件地址并将该地址写在 优先级记录中。所以这是为了
八小时，然后重复这个过程，看 第六步，然后重复这个过程，
每八小时后，我会重复这个过程 ，我的意思是，你会看到
解决方案a在这种步骤中正 在沟通中。它给了我它
给出了一个准确的想法。不过 ，可能有一些，可能有一些问题
成为可能是问，例如，B 可能会 问如何找出最大值，B 可能是
那个不知道如何找出最大值的 人。第三，例如，​​另一个
我们可能会问的问题 是，当我打算在
优先摇滚唱片，我应该在哪里写 在最顶部或最后或某个地方
或者，但归根结底，一个解决方案 需要一个循序渐进的解决方案来进行沟通，
这种如果你看到解决方案，虽然 它有一些它可能会在那里解释
应该添加更多步骤，但是如果您 看到解决方案，逐步解决方案，
这是一个通用的解决方案。这是一个通用的 解决方案，对于每一个更通用的解决方案
例如，但我的意思是，每 八小时后，你都会有一些
记录，并且您必须对那八个小时 的记录执行此程序。进而
在那之后，在那八个小时之后，你 将有更多的记录需要处理。所以
每八小时后，你有相同的， 问题是相同的，但实例
不同，因为八小时后的记录不同 。但是，但是，但是解决方案
说无论你是对的什么情况 ，现在，无论你是什么情况
在，只需执行这些，这些步骤 ，逐步解决方案，逐步提出
步骤解决方案是解决问题的一 个模块中的一个模块。还有
逐步解决方案称为算法。
算法。显然，并不总是需要 传达逐步解决方案
用简单的英语或自然语言，您 可能会想出速记或快捷方式
解释这些逐步解决方案。所以 ，捷径越多越精确和独特
意思是您在逐步解决方案中使用 的关键字，更好的沟通
你的解决方案发生了。从这个一 步一步的解决方案开始，这只是
用简单的英语，从这个到一个 更简洁和独特的程序，那个
那种工作可以让我们从那里 到那里的一步，我们
将在下一个视频中看到将被称为 伪代码。从那里的伪代码
将采取几个步骤，将带我们到 第二个主要问题，即问题问题
语言将解决在计算机上运行 的解决方案。所以我只是在
这个视频我想向你解释解决 一个问题可能并不难，我
意思是，想出一个问题 的解决方案可能不是
很难，但要传达该解决方案，或 以某种形式编写该解决方案
可以解决需要逐步解决该 问题的每个实例的程序
程序的步骤处理。那些 应该按顺序链接的步骤
他们应该是明确的。如果一个特定的步骤 需要更多的细化，那一步
可能会分解为进一步的步骤。但是 在最后一步一步的解决方案
一天被称为算法。现在该算法 可能是英文的，但我们将在
后来的视频说有比英语 更好的表达算法的方法
或优于自然语言。所以，所以， 如果你有另一个问题，想出一个
逐步解决这个问题，但是，应该 解决该问题的每个实例
通过逐步解决方案，这称为算法 。在下一个视频中，我们将
看看如何实际上如何消除与我们 一起使用英语的需要以及如何
结合使用这些步骤或算法 的理解的独特性
伪代码的概念。在伪代码之后， 我们会看到它会很快跳转
任何编程语言，我们将看到 Python 非常接近人类
一般认为，我的意思是，这很容易， 过渡会非常非常容易。所以，希望
在下一个视频中见到你，我将解释算法 in a in a in a in a more kind of关键字
道路。并且，在同一个视频中，我们将重点介绍 伪代码，这些伪代码基本上是前步骤
脱离任何编程语言的实际核心 。所以，希望下次再见
视频。好的，在上一个视频中 ，我们讨论了算法是什么算法
是以及如何表达任何算法，我们 看到该算法只是一步一步
步骤程序。但是，但是如何表达算法可能 会有所不同，我的意思是，您不必总是
用简单的英语或任何自然语言 来表达算法。原因是
自然语言通常如此富有表现力， 他们可能拥有的每一个句子
多重含义。因此，提出一种结构化 的表达方式是个好主意
一种算法，使得每个语句都完全 明确。还有这样一种方式
是使用流程图来表达算法流程图 是我们表达的图形方式
算法。在这里，我们正在采取。 我们这里讨论的问题是计算PE
一些公司的不同员工。我 的意思是，如果有几个
员工，让我们雇用一名员工雇用三 名员工，依此类推。假设有几个
一家公司的员工，让每个员工都有姓名 、电话号码、电子邮件和所有
证书。然后假设工资是按 小时计算的，每个员工
已经工作了一定的时间，例如八小时 ，每个员工都有一个小时费率
可能比方说 100 个单位，无论单位 是什么
例如，受雇于可能工作了 7 小时，但该员工的小时费率
可能是 200 名不同的员工，他们 可能工作了不同的小时数，
每个员工可以有不同的小时费率 ，具体取决于员工的能力
或员工从事的工作性质等。所以， 所以，所以，如果我们想计算
所有员工的工资，一一计算 工资的程序保持不变，实例
他们对员工一不同，我们的 价值是八，攻略100的价值
程序的员工将保持不变我们的最终 费率的值他们会有所不同
那么程序应该是什么，程序 可能是你接受输入
假设雇用一名或任何 您要计算薪水的员工
占位符中 a 中的小时小时值调用该 位置或将该占位符称为我们的
占位符或变量 y 这被称为变量 ，因为对于不同的雇主
这个值会有所不同，我们 会为每个员工取八
一个这个这个变量，这个占位符将为 第二个员工取值七，依此类推。
类似地，一旦雇佣了任何 你要计算工资的雇员，
如果您从某些工作记录中提取了 某些记录的小时数，则取费率
也适用于同一个雇主。所以输入普渡 大学的第一步，也就是第二步，
这两个步骤的顺序可能会发生变化 ，例如，您采取您采取的步骤
首先是比率值，然后是我们的值， 但无论哪种方式，这是一种方式
这是表达这个过程的一种 方式。然后你计算工资
这个公式。所以小时数乘以费率。 所以也许这会让写明星感到困惑。
也许也许我们应该写这个十字符号 ，因为这在数学中更常见。
或者，也许整条线可以由这条特定线 替换，也许。所以工资是
等于乘以小时。和率。也许这更 具表现力，但这完全取决于，
我的意思是，当您开始编写伪代码 或正在编写的任何伪代码时，
类型的关键字开始是一个关键字并且是一 个关键字，您使用的是什么类型的关键字，
并保留这些关键字，例如，如果 要使用关键字输入来获取
获取要处理的值，然后输入应该 留在我们想要的任何地方
做这样的操作。例如，如果您正在 使用，则该值是 get 而不是
input 然后使用 get always 但提出一些 富有表现力的关键字集，
以及简洁，然后取这些语句 的顺序，每一个语句
应该有唯一的意义，不应该 有歧义，并且顺序
应该在序列中描述正在发生的事情 的流程，正在发生的事情。所以，
首先我们需要几个小时，然后我们为任何 类型的员工对这两个值进行评分，
然后我们将它们相乘，相乘后 ，无论我们想要什么场景
制作，基于这个支付，我们会这样做 ，我们可能会记录这个值，显示值
在其他一些记录登记处，我们可能 会在打印单上打印该值，我们
可能已将此值通过电子邮件发送给其他 某个部门或任何我们想要查看的内容
制作，但程序真的还在这里， 然后根据支付我们的任何行动
将要这样做可能会有所不同。同样，如果 我们去，这是我的意思，某种
被称为伪代码的算法的表达 能力的结构化示例。
你要使用什么样的关键字，没有 一般的关键字，我的意思是，
有些人可能会使用 get 有些人可能 会使用不同种类的关键字，但它
最好提出一组关键字 来描述描述解决方案
例如流程图中问题的解决方案 ，每一个语句的所有内容
在这里，在伪代码中，每个 语句都被描述为不同的形状
不同类型语句的形状。如果 你想接受输入，那么你必须
用平行四边形描述那个动作 。如果你要做一些计算，你
必须使用矩形表示开始符号 和结束符号表示开始和
流程图中任何程序的结尾，它们 由椭圆形描述 例如，这个椭圆形
在那个椭圆形中，流程图通常 是从上到下的，但总是好的
只需打印箭头来描述流程， 因为在复杂的流程图中有
有循环，如果条件有这么 多东西。所以总是好的
使用箭头描述流程。所以，现在 的问题是流程图或伪代码
因为流程图看起来也是一种非常 酷的写作方式。表达算法和
伪代码也是一种表达算法的方式 。那么，将流程图转换为实际
编程代码有些繁琐，事先写 个伪代码，可读性强，
这是精确、简洁且明确的， 然后将该伪代码转换为
任何编程语言，不那么 难，编写流程图很简单
对于非常复杂的问题有点 乏味，因为那么它也需要
从流程图到反应式编程代码的另一 种转变。这就是为什么要写伪代码
更可行，如果目标最终 是将该伪代码转换为
编程语言。因此，您可以使用 流程图，也可以使用伪代码
一种很好，但更可行的算法表达 方式是伪代码。那只是
一个非常简单的例子。我的意思是计算 ，计算编写程序的员工的工资
为了那个原因。我的意思是，这太简单了 ，没有人让你的写作成为那种写作解决方案。
将这种问题作为算法或伪代码 作为流程图。但该
基本思想是，是一样的，即使 你有一个复杂的问题，即使
您可能有更多步骤的问题， 但想法仍然相同。在中
下一个视频，我们将看到一个 程序，例如如何泡茶，这可能
这在你看来可能很有趣，我的意思是 ，我们真的想要吗，我们真的想知道
泡茶的步骤？嗯，这个想法不 是学习如何泡茶，而是学习
如何表达这个问题 的解决方案
关于如何将该问题的解决方案 表达为伪代码。和我们
还将看到另一个流程图示例。所以 希望在下一个视频中见到你。
好的。在上一个视频中，我们看到了流程 图和伪代码，我们只是举了一个例子
我们举了一个非常简单的例子，计算给 定时间的公司员工的工资或薪酬
和率。我还描述了weatherflow， 流程图和伪代码的比较。
我说伪代码更接近某些 编程语言的核心，最终
我们需要，因为最终我们需要 解决问题的自动化。为此，
我们需要一个数字的代码解决方案 的代码，一些编程中的通用解决方案
语言，所以流程图和伪代码， 然后是一些编程语言的核心
像 Python，
解决问题或设计通用解决方案 有时在某种程度上很方便
流程图中第一步的任何问题，因为 它更具表现力，而且更多
通用的，更通用的，也许以图形 方式。然后一旦概念证明是
清楚，一旦明确这确实是一个通用 的解决方案，它内部就没有错误
它没有错误，它将始终有效，然后我们 可以采取另一个步骤来转换该流程图
到伪代码。然后伪代码可以 转换为任何代码的代码
在某种编程语言中。但是立即 编写伪代码，我的意思是，从
从没有流程图开始也是一种常见的做法 。无论哪种方式，哪种方式都适合
你。在这个特定的视频中，我 将讨论问题是煮茶的问题。
您可能会想，我在泡茶时遇到的 这个问题有哪些不同的实例
正在泡茶。有哪些不同的 实例？嗯，一个人可能
例如，喜欢含 1.5 个单位糖的茶 ，无论单位是多少，而另一个
一个人可能想要一杯茶，比方说，两 个单位的糖，一个人可能，可能需要
例如，一个 D 点五个单位的牛奶 ，另一个可能是不同的单位
牛奶等。所以泡茶的程序 应该保持不变。和实例
意味着不同的人想要不同种类的茶，这些 组合可能会有所不同。那么让我们
让我们先看一个过程和流程 图。然后在伪代码中，对于
泡茶，用来泡茶。所以让我们 开始吧，这可能看起来像
你看着你一种可笑的问题。但这 是一个真正的问题。例如，
如果你想泡茶，这个算法是什么？ 所以首先我们开始，然后是第一个
我们所做的步骤是将茶包放入杯子中 ，这可能是第一步。你可以争论应该
这是第一步，应该是第二步， 依此类推，顺便说一句，
解决一个问题，你可以有 多种算法。并做不同的算法
即使您有相同的语句，也可能因语句 的顺序而有所不同。所以我
不是说算法或一般解决方案 是唯一的。你可以有多个
不同的一般解决方案或程序。 例如，在杯子里放一个茶包
这可能是第一步，或者第一步 可能是煮沸，煮沸水并倒入
把水倒在杯子里，然后把茶放回去 。两个都很好，我的意思是
这样或那样。所以让我们从在杯子 里放一个茶包开始。所以这是一个
一个输入。我们从某处拿走茶包。这 是我们上次的意见，我做你那
输入被视为平行四边形将茶包放入 杯子中，然后忘记那个杯子，
在某处煮水 有水 我是 说从某处取水并煮沸
看看在让我们说五个或六个或七个 时间单位之后，无论时间单位如何
是，看看水是否煮沸 假设 有一个测试告诉你
水煮沸与否。所以，有一个测试可供 您使用。所以，你应用那个测试
检查水是否煮沸，如果不 是油，则继续煮沸。所以
再煮一次。并假设在正常情况下 有一个将水煮沸的程序，
沸水只是发生在我的意思是保持 高温或放置那个东西
把一壶水放在火上或类似的东西 ，但这本身就是一个程序。
所以，
当水再次煮沸时再次检查水是否 煮沸如果没有然后煮沸
再说一遍。如果没有再次煮沸，则检查 是否没有然后再次煮沸，这称为循环
这称为循环或重复，你一次 又一次地做同样的事情。
直到满足特定条件为止。 所以在这种情况下，条件
是在水没有沸腾的情况下 ，继续重复相同的过程。
这称为重复或循环。所以 你再次烧开水，检查条件
如果条件为真，例如，水沸腾 了，那么出来。那你就
那么你可以退出这个循环并出来 。然后倒入水，将水倒入
杯子。这里我们应该听到我们应该描述 的是，是同一个杯子还是不同的杯子？
嗯，这个看到你在这里捡起来充当 占位符，在那里这个茶包和
水要进去了 所以我们有一个杯子 我们 把茶包放进去 然后我们把开水
在里面，但在倒入开水之前。我们 只是把水烧开。好的，还有
那么当我们在杯子里放了水，在杯子里放了一 个茶包之后，接下来我们应该做什么呢？我们其实
我们实际上首先测试一种糖还是需要更多 的糖？如果是，然后加糖。那么让我们
应用一些箭头。如果是的话，加他们加糖 。然后再问你需要吗 你需要吗
加糖？还是现在一颗糖？是的，加糖。 一颗糖。是的，加糖，这又是一个
循环又是一个循环，而你想要糖 的时候。我的意思是你测试那个
糖好不好。在这里你测试 糖是否可以或任何糖
你需要。如果可以吗？在不满足 该条件之前，您继续添加
糖，再次加入一茶匙，然后 测试一茶匙再次循环或重复。
一旦你知道满足条件，然后退出这个 循环并询问什么牛奶，因为有些
人们只喝茶而不喝牛奶。也许有人想要 牛奶，也许有人不想要。好想要
牛奶？是的。所以加牛奶。所以这是 一个错误，这个循环应该去那里。那里
在那里。这条线不应该在那里。 那是错的。加牛奶然后问
什么牛奶？是的，管理员，这又是一个循环 。一旦你退出循环，然后你问需要
引导。是的，转向，然后再问。 这条线不应该再出现。所以那是
另一个循环。一旦你退出这个循环，那么 T 就准备好了，你服务那个 D 完成你
完成程序。现在让我们看看 伪代码程序中的相同过程是
关键字，这就是程序名称的意思 program make D 关键字是什么 将茶包放入杯中
while water not while while 是关键字，while this is not while this condition is
不满意，继续这样做。无论在 while 和 while is 中写的是身体
这种重复被称为循环。所以当水没有 沸腾时，把水烧开。然后又
检查热水器不知道是什么了。我 一直在沸腾。所以这是重复。
一旦水煮沸，这意味着这种情况 会变成假的，而不是油变成的
false 所以水沸腾，然后你退出这个循环 ，你把水倒进杯子里，这又是一个
关键词，你在杯子里，然后你问，好 吗，需要糖吗？是的，加糖，需要糖，
是的，加糖。所以你继续这样做 ，直到你不再需要糖。所以那是
又是一个循环。所以，所以，你可能会 想，为什么我们写这篇文章要加糖和
这个烧水给作者这个，这就是为什么 我们真的要缩进这种风格
伪代码只是显示这是在 this 这是这个特定的语句或
一组语句被称为循环体， 这个结束油应该在这里
在这一行中对齐，因此，这张幻灯片 中有一个错误，这应该
是
这里好，一旦这个条件是假糖，不 需要那么你可以退出这个循环
你去这里时需要牛奶是加牛奶，再次 检查需要牛奶是加牛奶牛奶
需要是加牛奶。一旦这种情况变成不 需要假奶，那么你就可以退出
循环，你可以去这里。虽然这里 最新的需要转向 D 需要转向是的
坚强 他昨天在那里，一旦这种情况是假的， 就出去，你的茶已经准备好了 做
无论你想做什么。这个例子很简单 ，但它表达了一个非常强大的
工具在伪代码以及流程图中。 这个工具有时被称为循环
是否要重复特定程序，无论 您想再次重复什么程序
并再次 to 直到满足特定条件， 即存在循环循环。所以，
这张幻灯片的目的只 是为了让你相信和
让你对伪代码和流程图感到 满意我们不会谈论流程图
从这里开始，我们 将只讨论伪代码
或另外两个视频。然后我们 会直接走向我们会很舒服
伪代码足以解决某些类型 的问题，然后我们最终将
正在从伪代码转向实际的 Python 代码 。而且我敢打赌我会告诉你
下一个视频中我将解释 的伪代码将非常非常
很容易将转换为实际的确切 Python 代码 。所以在下一个视频中，我们
将实际解决从值列表中 找出最小值的问题，有时
称为搜索问题，我们将首先 使用伪代码来解决它。和
然后在后面的视频中，我们将看到 如何为该问题编写实际的 Python 代码。
所以希望在下一个视频中见到你。好的 ，让我们深入研究真正的问题。假设你是
给定，你得到了一个数字列表，假设 ，假设 l 是一些列表。用数字，
假设我们通过这些定义列表，这些 方括号，假设列表包含 23。
假设这是一个减去 4 的值，该 值为零，即值 73。那是一个
值，也许是负 10。那是一个值，也许 是 13。那是一个值。那么让我们
举个例子，我们在一个列表中有 123456 个值 。所以那个列表基本上是我们
将这里的列表作为 L 并且我们只是描述 让我们说列表是由或声明的
用方括号表示，列表 的元素之间用
逗号。这只是我们对 此类问题的约定
这段代码。而且我还没有谈论 任何特定的编程语言。这个
只是一个数字列表。假设我们 想要一个找出最小值的过程
任何列表的值。嗯，首先，为什么 这个问题有多个实例。好，
我们需要想出一个适用于任何列表的 解决方案，例如，如果列表是 if
列表有这六个值，那么程序应该找出 这个列表中的最小值，
所有值中此列表中的最小值 为负 10。
因为负 10 比其他所有值 都小。 23大减四小
比23.零比负四大， 因为负号的值更小
具有正号的值。但是如果 你有两个带负号的值，
数值越大，就量级而言，实际上 在负面意义上越小。所以
如果比较负四和负 10，负 10 会 更小。在负域中的负中，在
正域，结果不同。所以我 在谈论为什么这个问题有
多个实例，为什么你需要一个 通用的解决方案，那就更少了
找出负 10 的最小值。回家快乐吗 ？嗯，我们需要一个解决方案
适用于另一个列表。另一个具有 不同数字的列表。也许不同的数字
的数字。也许在这个列表中，我们有六个 数字，另一个列表可能有 74 个数字，
另一个列表可能有 1 万亿个 数字，我们想提出一个程序
找出该列表中的最小值。显然 ，最小值可能会重复，我
意味着，最小值在列表中可能出现 不止一次。那么什么是最小值
而不是知道发生了多少次，最 小值是多少，这是一个问题
找出一个最小值，我们想找出 ，我们想提出一个程序
找出最小值，无论列表如何 ，无论列表是什么，这个过程
应该实际返回或最终找出最小 值。所以，在这个特殊的
同样，对于这个特定示例 ，最小值为负 10。我们将
以这个列表为例，我们将看到如何 为此编写一个过程。所以但是但是
在开始这个程序之前，我们真正 需要做什么样的事情，来写一个
伪代码。对于此类问题，我们可以 从编写该程序开始，例如
以前的视频，节目名称作为搜索。然后 我们获取输入或输入列表，然后我们
取输入，列表中值的数量是 值的总数，然后我们移动
就像我们想要继续一样。但是用 伪代码写出一个过程，它是
在伪代码中避免这些输入语句总是 好的。并且总是提供任何东西
无论需要什么，始终从外部 提供实例并假设该实例
提供，然后只在该实例上工作 。而不是阅读实例。而不是
从代码内部获取实例的值， 一个特定的实例，它总是
从外部提供实例的好习惯， 因此从某个地方提供列表，
这 n 确实是列表的大小。在这 种特殊情况下，让我们说如果
是列表，然后该列表将在那里，从 某个地方提供，但我们将看到如何
供应那个。这里的 n 值，在 这种特殊情况下，N 值是六
列表中值的总数为 12345，六个， 这些是六个值。所以它是一个
好的做法，而不是编写程序然后 这个，只需写下程序的名称
在这种特殊情况下，您将要解决的问题 名称是列表中的搜索最小值。
然后这个特殊的我们正在谈论 这个列表 l 与元素总数
作为 n 无论 L 中的值是什么，我们都不 知道，并且这个 n 可能会采用不同的
值，l 可以不同，对于不同的实例 ，这个 n 可以不同。但它
在这里从内部获取输入不是一个 好习惯。然后，另一个约定是
也就是说，假设两个列表表示列表 中的第二个元素。在这个特殊的
情况下，L of two 基本上是 L of two 基本上 是列表中的第二个元素，即减号
四，假设三的 L 是此列表中的第三 个元素，即零，依此类推。
所以让我们采取一个约定，每当 我们想要访问列表的元素时，
无论何时您想从列表中读取元素 ，我们都会读取元素编号
通过在这里给出元素编号，让我们 说无论我们写 AI 的 L，这意味着
它表示列表的 ayat 元素。
所以，首先我们取一个变量，我们 在这里假设列表提供给我们的总数
列表中的元素数量提供给我们 。所以我们首先取最小值，
我们，我们真的想计算我们想要计算 的最小值，但任何列表都可以
在此过程中提供。那么程序是 什么，我们想要的最小值
为了计算，我们只考虑在这种情况 下列表的第一个值，第一个
值为 23，我们认为这是最小值 。显然，这是错误的，这不是
最小值，最小值可能在别处 ，或者这个可能在别处，
但我们不确定列表中的第一个 值是最小值。但是，让我们
稍等片刻，继续前进。假设 最小值是这里，这是
称为分配作业。这个最小值是一 个占位符或一个变量，并且
我已将这个值分配给它一个。现在 ，从这里开始，最小值将是
be 的值为 23。在这种特殊情况 下，好的，所以最小值是
this, 即 23. 现在，让我们声明，让我们 声明另一个变量，它被称为
计数器，我们可能需要这个计数器。让我们 用两个来声明，为什么我们要声明
这与两个稍后将变得清楚。所以 现在我们现在这么敏谷，为此
特定列表，最小值取值 23。 因此，计数器取值 2，这些
这两个变量是两件事。 现在，当计数器小于
n 小于等于 n。请记住，此特定 示例的 n 值为 6，并且
这里的柜台是两个。所以因为计数器 的值为二，而二小于或等于
六、首先检查这个条件是真 还是假，因为如果这个条件
为真，那么你将转到循环体， 然后整个框将执行。如果
此条件变为假，然后您将退出循环 ，我们将退出。所以现在反
是对所以二小于或等于六。真 假。那是真实的。所以条件
是二确实小于等于六，这 是真的。所以我们要进去
到盒子里，看看会发生什么。然后我们 将做什么，我们将选择一个值
从索引柜台。现在计数器的值 为 L off counter 意味着选择
值，因为计数器具有选择第二 个值的值，即负四和
从列表中选择该值减去四， 选择该值并复制该值或分配
将该值转换为变量 v。这是一个我们 可能需要的新变量。之前
最小值是一个变量， 它包含第一个值 23。
现在我们选择了第二个值，计数器值 为 2。所以我们选择了第二个
列表中的值，即减四。现在 我们比较现在的值是否为负
四是该值小于我们的最小值。到目前 为止，到目前为止的最小值是
是 23。所以负四小于 23。是的 ，条件为真，如果条件是
true，我们会进入这个区块，否则 我们将进入这个区块。所以现在
条件为真。所以我们将进入这 个块，最小值将被替换为
新值。现在的新值是负 四。所以因为负四是
小于 23，所以我们在这个身体里， 如果条件成立，你在这个身体里
体，最小值变为 V 中的任何值， 并且对于本示例来说是正确的，
V 中的值是负四。好的？所以如果 如果你进入 if 条件，那么你就是
不进入 else 部分，要么你要去 F 部分，要么在 else 部分之一
他们。好的，那么我们往回走哦，这里有一 个错误，我们需要添加计数器。我们
在此之后需要在此处增加计数器 。在这之前。还有一个说法
增加计数器。递增计数器。这 是另一个语句增量计数器。
所以现在如果部分增加计数器，则 在此之后增加计数器，并且计数器
会变成三。现在，我们将重复 该过程并检查三是否小于
六，是的，我们进去，我们现在 选择计数器值是三，我们就去
并选择第三个条目。现在第三个 条目将在 V 中，V 现在将包含
零。以前它包含负四，现在 它将包含零最小值包含
现在减四，所以零小于减四 ，不，如果零小于减四，
然后这样做。但是零不小于负 四，那就去else部分吧。和
至于只是说继续什么都不做，我的意思 是什么都不做。所以当你在这里
除非条件再次增加计数器，否则不 要做任何事情。现在，你增加
counter 计数器值将变为 4 并且 值相加为 73。 首先
检查是否小于等于 6 是的， 我们将包含索引 4 处的值
是 7373 小于负四，什么都不做 ，给计数器检查 if 条件
检查 while 条件现在计数器将 是 5 5 小于或等于 6 是的，
选择第五个条目因为国家的第五 个条目是负 10
负 10 小于负 4 是好的。用 新值替换最小值。现在
最小值将包含负 10 好吧，因为如果 已经执行 else 将不会执行，你
退出 if 条件，然后增加计数 器，计数器将变为 6。现在
六小于等于六 是的，因为 六等于六所以条件为真。
现在，您去选择第六个条目， 即 13。检查 13 小于负 10，因为
min 值包含负 10。到目前为止， 没有错误，转到 else 条件，
其他两个部分继续什么都不做，增加 计数器，现在计数器将变为七
然后你回去检查条件七小于 等于六假退出循环。
好了，退出循环，转到这个条件 ，转到这个语句。现在你没了
循环并返回最小值。并看到 这里的最小值包含实际
最小值为负 10。所以这就是我们搜索 最小值的方式，这个返回也是
一个关键字。所以这意味着如果我们只是如果 我们只是如果我们只是使用那个函数，如果
如果我们只是使用该伪代码，如果 我们只是使用该伪代码来表示不同的
各种大小的列表，无论列表 是什么，这只是一个例子
如果我们链接列表，该过程将 在代码中的一个错误是增量
counter 语句不存在，它应该在 结束 F 之后和结束之前存在
在这里。所以这就是搜索最小值 的伪代码。在下一个视频中
我们将使用这个伪代码，我们 将看到如何重新排列这些值
列表或排序列表的值， 以便所有较小的值
变得早于较大的值。这个 问题叫做排序。所以在
下一个视频我们将讨论另一个 问题，非常有名的问题叫做
排序问题。在那个问题之后， 我们将转向 Python。因为经过
那个问题，你会有一个很好的 想法如何解决一个问题如何写作
问题的伪代码。我们编写 伪代码的方式非常接近
实际的 Python 代码对您来说将变得 如此清晰。所以希望下次再见
视频。好的，在我们讨论的上一个视频 中，我们讨论了如何找出最小值
值列表中的值。我们想出了一个 算法，其中的名字搜索男人来自
列表。这里我们只是做了一点修改 ，而不是仅仅返回最小值
值，我们还返回列表中 最小值的位置。例如，
如果列表是 17024，让我们用九个字母说 这是我们的列表。里面有七个数字
列表中，最小值为零。所以 最小值本身的值为零，但是
出现在位置三。所以当这个 过程结束时，最小值将
包含零和 ID x 是达到 最小值的位置
这将包含三个所以，不仅 我们不仅要找出最小值，
但我们也在找出最小值 的位置。
这个程序，我们的伪代码其实描述了一个 很简单，很简单的概念，你考虑一下
第一个值作为最小值 ，第一个位置作为
取最小值，然后逐个元素 遍历list，看看有没有找到
迄今为止小于最小值的任何 值，如果找到，则替换
您的最小值与新的最小值并更新 您的位置编号。进而
继续前进，直到列表的末尾。所以， 就是这样，这就是背后的概念
这个算法的背后是从列表中搜索 最小值。并遍历列表我们
使用这个循环 while 循环。所以接下来我们 解决一个叫做排序问题的问题，非常非常
计算机科学中的著名问题。所以问题 真的是假设我们有一个列表，
比方说 14035。 七，比方 说 排序顺序 升序排序
是列表显示的顺序，以便 最小值首先出现，然后
第二个最小值，然后是第三个最小值 ，依此类推。所以这个特定的排序顺序
列表将是这个，所以这是结果 ，这应该是这个排序的结果
程序。那么让我们看看我们如何解决这个 问题，我们将这个算法命名为 sorted
列表和排序列表包含这个 L。在这 种特殊情况下，L 就是这个。和
这 n 是列表的大小。在这种特殊情况下 ，列表的大小是六，所以六，
现在我两个是空的。所以虽然我们 必须填充 l 两个，但现在它
是空的。再次计数器，我们用 1 初始化计数器。而且只要
征服者小于六，我们继续我们 继续在这个，这个块内移动，
这就是循环的主体。所以我们 要做的是传递列表和大小
的名单。我们使用前面的算法从 列表中找出最小值。所以
列表中的最小值将被发现为 零，其位置将被发现为三。
所以最小值将包含零，而Id x 将包含三 个，那么我们做什么，我们选择这个
最小值和插入在 L 两个 l 两个最初 是空的。所以我们插入L 2，我们
插入最小值，到目前为止为零 。然后只是在原始列表中 l
我们删除位置索引处的值 。例如，索引位置是三，
所以我们删除了这个特定的值。所以 我们真正做的是删除这个值，我们删除
这个特殊的价值。现在列表变成了大小 为 1234 和 5，所以我们要做的是
我们用 1 减少大小，然后我们继续 前进，现在国家又是一个，
N 值而不是六个。现在 N 值 是 5，所以 1 小于 5，但是
列表中现在没有零，因为它被删除 了，我们再次搜索最小值，然后
我们在列表中插入最小值。现在最 小值将是新列表中的一个。和我们
从列表中删除该值。我们减少我们 继续移动的大小，最终
列表 l 两个将像这样填充。还 有一次。一旦这个 n 值变为负数，
这是减一，我们将退出循环，我们 将返回排序列表。但是看
这个排序过程如何实际使用 我们在 RPB 中定义的算法
之前的视频。
我不是说这种排序算法 是最著名的排序算法。
有高效的算法，非常好的 排序算法。但是这个想法
这里并不是要真正教排序 这里的想法来实际提出伪代码
对于这个排序问题。并且还 向您展示如何使用伪代码
可以使用现有的伪核作为其他伪代码 中的指令。所以这就是全部
问题解决。如果你真的了解 选择排序和所有的程序
真的很好，你实际上很擅长解决 问题，至少是解决问题的能力
是我们在逻辑中遇到需要 解决不同种类的问题
在计算机科学中。在下一个视频 中，我将实际转换这些伪代码
到 Python 代码。你需要什么？ Doo doo doo， 对这个排序列表的程序实际上是正确的
python 编程语言，以及如何 从列表中更改搜索最小值
实际的python编程语言，我们会 一点一点的看Python的细节，
从右零开始，以 Python 的非常高 的细节结束。所以，在接下来的
视频，我将向您展示如何转换此 代码。但是当我们开始学习
Python，我们将从零 开始，我们将在
细节。所以别担心。在下一个视频中，如果 你看到，我的意思是，像长和弦这样的东西
一开始，这些只是因为我们得到 了一个伪代码。这个很，
我只是想向你展示那些非常易于 表达的伪代码，它们是如何
可以轻松转换为Python编程， 只为向你展示强大和简单
Python 编程语言。所以在下一 个视频中，我将转换这些伪
代码到 Python 代码实际编程代码。所以 希望在下一个视频中见到你。
好的，在上一个视频中，我们 只是通过使用此选择来解决问题
排序称为排序过程。这个想法只 是使用这个程序来解决这个问题
种问题。我们看到了细节，而不是那个 细节，我们只是刷了一遍，但是
我们看到了如何编写伪代码来 解决排序问题，这实际上需要
要按升序排序的列表。例如 ，在这个视频中，我要转换
首先这个代码从列表中搜索最小值， 你看到那个代码，你完全知道那个代码，
我们首先要在 Python 代码中转换 该代码，然后我们将转换这个
Python 代码中的代码。所以一步一 步看，有什么变化。首先，在Python中
我们将详细了解。当你定义程序 时，不同种类的程序，
它们在 Python 中被称为函数。而不是 写这个，我们必须写一个 def
它之前的语句，然后是我们想要 写出的任何名称，其余的东西
保持不变，除了在最后，我们 必须写一个冒号。这是语法
Python。所以从这里到这里的变化 是一个 def 语句，它定义了使用
用于定义 def 用于定义。然后在最后，我们 写一个冒号。接下来我们要做的
会详细看的，不用担心
如果你是，如果你只是看到我们为什么要 搞砸嘴唇。这么早，我们会看到事情
详细。但只是为了比较 in 伪代码 。通常列表被索引索引
的列表从一个开始。但是在 Python 编程语言中，第一个索引
列表通常从零开始。所以 他们的最小值是第一个值
在这里列出，第一个值实际上 是索引，Python 为零，其余的
是一样的，你用伪代码声明变量。 在 Python 中也是如此。他们是
因为索引是一。所以计数器 比索引值多一。
在这里，计数器只是一，我们需要 在这里 ID x ID x 等于零，我们
刚刚错过。前面的 ID x 是 1，所以这里 的 ID x 为零，没关系。好的，
然后接下来，我们在 counter 小于或等于 n 时写入。同样的事情，而计数器是
这里小于或等于 n。所以这里我们只写 了，最后的冒号，我们可能已经写了
这个等号，这个等号，我们 只是错过了等号等号
在那儿。所以现在，但是看看这里的区别 ，紫罗兰朝那个方向走，我们有
末尾有一个冒号，其余的完全 一样。现在，v 等于 L 计数器
如果 v 小于最小值，则 v 等于 L 计数器相同的事情，相同的事情
如果 v 小于伪代码中的最小 值。 Python 完全一样。只是
看到末尾的冒号，while 语句 的末尾有冒号，我们有冒号
在定义的末尾，我们在 if 语句 的末尾有冒号。另一个
伪代码中的语句。在 Python 中完全一样 。现在，在伪代码中，我们有 l 语句。
在 Python 中，我们有 l 语句。如果我们 想写一个 else 语句，我们有写
末尾有一个冒号。然后在 Python 的伪代码 中，我们有一个过去的语句 Python
在我们过去的陈述中，伪代码中的内容相同。 我们有 n 个定义，只是为了描述这个
f 结束。在 Python 中，一切都由缩进 样式来描述。所以如果这个缩进
继续，如果我们有如果你在这里，那么 如果这出去了，那么我们就不需要了
每天写完。同样，邪恶的身体 有这种缩进风格，这就是全部
while 体，不管是什么，比 this 更早的都不是野体。
因此，与其编写令牌和 while 以及 Python 是否使用
缩进，所以如果不需要 end while 就不 需要 end 哦，我们没有，对，我们没有
在这里写了一个计数器。所以我们要在这里 写一个计数器加加号，所以计数器。所以
同样的语句，我们在 Python 代码中遗漏 了这个语句。所以同样的陈述，正是
这里也有同样的说法。就是这样。剩下 的故事是一样的，我们不需要
在这里结束搜索。这里的目标是表明 伪代码是，我的意思是，你的方式
编写伪代码，它们是高度的，
它们与 Python 中的实际代码非常相似 ，Python 是富有表现力的 Python
是非常非常高级的语言。我的意思 是，你的方式你思考问题的方式
在伪代码中，实际的 Python 代码 与它非常相似。所以学习Python
非常非常简单。 Python 的简单性确实 是 Python 的一大优点。和
这是 Python 流行的一大原因 。现在返回语句是相同的
一切都一样，然后我们走向排序。 再次，我们有排序列表，我们有
写Define def定义，然后我们 有这个冒号，我们必须写
那里的冒号, then let's do 被定义为 空，它在 Python 中也是空的。
计数器从 0 开始，因为它们是从索引 1 开始的列表。在 Python 中，
列表从零开始，所以我们在零，而与 这个相同。在这里我们有这个
冒号，也许，也许是等号，也许等 号应该出现在这里。我猜我们
缺少等号。但无论哪种方式 ，代码或多或少是相同的
语句和这个语句完全一样，我们在L 中插入了两个，这里，我们写一个
带附加功能，我用的是 Python，这里用 ID 用 Python 来引导这个，我们有一个戴尔
声明，其余的故事完全相同。所以 你看到将伪代码转换为 Python
代码是，更容易。这 不是这不是正式介绍
到 Python。我的意思是，在这些会话 视频中，此视频的目标只是
向您介绍解决问题的方法。但我发现 了这个，我的意思是，我发现这很有用
向您展示伪代码实际上与实际的 Python 代码非常相似，尽管
我们将处理变量列表，while 循环，if 条件，所有这些类型的东西
在他们的一个大而巨大的细节。当我们 在即将发布的视频中，当我们将介绍
Python 语法和变量等等 。事实上，你会掌握
Python 中的一切。而且，更进一步，你 不能把这些冗长的和弦写下来
用 Python 做东西，我的意思是，整个 爸爸的事情就是你写 l 点排序，你是
完毕。我的意思是，你不需要用 Python 编写 很多行代码。在这里，我就在这里
我只是告诉你，如果你有一个程序，你可以 ，如果你有一个伪代码，它看起来
就像Python一样，它实际上 告诉你表达能力
Python 和 Python 的简单性，以及它 如何更接近您的想法。但实际
解决问题
在Python中不需要那么多行代码， 我的意思是，有那么多功能，
这么多强大的程序。对于那些 你只写一行和大量工作的人
已为您完成。并且有非常好的 Python 衬垫，我的意思是 for for for
用 Python 编程，你没有写很多代码 来做一些事情。我的意思是
几行代码甚至一行代码都可以 为您做很多事情。为此你
需要知道 Python 的特性 特性 的特性和不同种类的
语法、特性、库、包以及 Python 的可用功能。
我告诉你几乎每样东西都是可用的，只是 你需要知道什么是可用的。一次
你知道什么什么什么是可用 的东西。你不需要写
您现在需要冗长的代码来为自己 构建大量逻辑。东西准备好了，
他们在等你，你只需要 弄清楚他们要做什么
如果你知道你已经完成了，那么 Python 中有什么样的特性。所以你需要
不要编写这些类型的代码 和冗长的代码。虽然知道
都知道是一个是一个是一个巨大的 优势，但做一个越来越大的东西。
Python 会给你很多特性很多 你不需要用到的功能，
并且您无需为它编写大量代码。这 就是 Python 的第二个力量。一
是简单。其次，它给了你 很多特性很多功能，很多
为你准备好的内置东西，你 想做某事，它可能就在那里
在 Python 中，你需要知道它在哪里。为 此，我们有关于 Python 的整个未来系列
了解 Python 中的每一步，并了解 Python 中的重要包。
因为知道重要的包和知道如何 用 Python 编码会节省很多时间
为你。因此，花一些时间学习 Python 将节省您的大量时间。
解决实际的纯问题。无论你在 做什么问题，你都会去解决。
Python 是一种真正的编程语言 授予编程语言，知道这一点
语言差不多就够了。所以希望在 我们将开始的下一个视频中见到你
Python 从零开始。我们将详细 了解 Python 的所有内容。希望
下个视频见。如果您是数据科学 的新手，您可能会坚持选择
数据科学的最佳语言。在这个 视频中，我要去我要说话
关于 Python，它是迄今为止最伟大 的数据科学语言。解释特征
关于 Python，让我首先回顾一下 Python 从 它开始的地方开始的一点点历史。
它基本上始于1980年代。它于 1980 年代 首次推出。但随着不断的改进
和很多错误修复。它于 1989 年 正式推出。九年后。它是
由 Guido van Rossum 创建，它是开源 的，这意味着每个人都可以访问它。
尽管它是开源的。它可以用于 商业目的。 Python的主要目标
是为了让代码更易于使用和理解。其庞大 的图书馆使数据科学家能够
使用动态输入的现成工具可以 更快地工作。所以变量
你被定义你正在定义它们 是自动定义的，你不需要
设置类型无论引入什么内容 ，类型都会被自动定义。
与其他代码相比，它更具可读性并且 使用更少的代码来执行相同的任务
编程语言。它灵活、便携，可以轻松 地在任何平台上运行。这是
可扩展，并且可以轻松地与其他 第三方软件集成。 Python编程
易于使用，并且具有简单快速的学习 曲线。新的数据科学家可以很容易地
了解 Python，但它易于使用语法和更 好的可读性。所以就是这样
这一点基本上是如果你是新手， 它真的是一个初学者友好的
编程。好吧，Python 为您提供了一 个非常简单的环境。它还提供
大量的数据处理工具，有助于 更好地处理数据。 Python很重要
对于数据科学家来说，因为它提供 了大量用于数据的应用程序
科学，它还在机器学习和深度学习 领域提供了更大的灵活性
学习。
它有，它有很多包，比如 TensorFlow，Kara 的 tiano。这有助于数据科学家
非常非常快速地专门开发流行 的深度学习算法。所以
基本上，这项运动，机器学习和深度 学习的运动在 Python 中是巨大的。
那是巨大的。就像许多其他 编程语言一样？可用
导致 Python 成功的库大约有 72,000 个可用包。在 Python 中
包索引，有时由 pi、Python 调用。为什么 ？ Python 包索引增加了大约 72,000
包可用，而且它们一直很好。如此 庞大数量的包成熟包
可用。它是免费开源的， 因此，任何人都可以编写库
包以扩展其功能。数据 科学已成为早期受益者
这些人特别考虑了他们所有人 的大爸爸。 Python 的另一个优点
是否有数百万用户乐于提供 意见或建议。当你拿到时
卡在某处，很可能是其他人 先卡在了那里。所以很多社区
在那里，有很多包，它是开源 的，它很容易使用，很容易
学习。它简单，可读，更 接近人类语言，是高级语言，
你代码少你做更多，我的意思是， 你写了几行代码，你就实现了
很多工作。所以，我的意思是，我也在这里 讲了很多动词。我的意思是，解释一下
Python 确实是最适合数据科学的 语言。但是让我来介绍一下
你对Python的一些统计，Python 的流行就大就
关于它的使用，以及关于 Python 中 的工作机会。例如，
如果你看到这张图表，在前 10 名语言的 排名中，Python 仍然位居榜首。所以
这是最新的统计数据，收集于 2019 年，2019 年 2 月。
语言的总份额，我的意思是， 大约 26%，只用于 Python，而
趋势正在上升，这意味着人们对 Python 更感兴趣，我的意思是，
与其他几种语言相比，使用 Python 的趋势​​越来越大
像 Java、JavaScript、C、sharp、bhB、C、我们的目标 c、swift 和 MATLAB。我的意思是，很多
其中一些用于数据科学，但 Python 仍然 位居榜首。我的意思是，这很受欢迎
语。此外，如果你看到，例如 ，Python 的工作机会，那么
说，我在 Facebook、Julia 等不同的公司工作 ，我在 Google 和几个不同的公司工作
公司。这张实际图表显示， 从 2014 年起，就业机会和
不同语言的职位发布数量是 多少，你可以看到图表
Python的，虽然起步有点低，但是 后来熬夜熬夜，也就是说
80 如果您看到占总作业数 85% 的数字 ，则仅适用于 Python。而且不仅如此，
我的意思是，Python 不仅用于数据科学 ，它还是一种通用编程语言，
它是开源的，可用于执行 嵌入式编程的任何类型的任务
用于，呃，用于发布，我的意思是，在 Raspberry Pi 上编写代码或嵌入代码以进行 Web 开发
什么的。你可以你可以，你可以在 上面做桌面开发，你可以使用
您可以使用数据科学的 Web 开发人员知识 ，我的意思是，我的意思是，这是通用的
编程语言。在其他学科做它 的表现非常好。但数据科学
对于数据科学，它几乎是当今的 默认语言。
所以，我的意思是，如果你要学习数据科学 ，真的，我们需要 Python。我的意思是，Python
真的是选择，默认选择，我们 需要它。在这个特殊的课程中，
我们将要，我们将从各个方面向您 介绍 Python，我的意思是，我们
将从最开始的级别开始 。我们将逐步走向最
Python 中的高级编程，包括 对数据科学包的介绍，
像 pandas 和 matplotlib，用于可视化，以及 NumPy，用于处理数字数据和其他东西
像这样。所以，在这个特定的课程 中，我们真的要教你 Python，而且
我们不假设您之前有任何编程 经验。所以这是一个加分项
的蟒蛇。我的意思是，无论你是工程师 ，你来自健康科学，你是
来自生物学，你来自艺术、人文 或任何地方。 Python是什么东西
这很容易上手。所以如果你 不假设你有任何编程
背景，你没有任何数据科学背景 。所以我们将从零开始
我们将逐渐移动到 200。所以 ，包括对数据科学的介绍
包。所以Python是最好的，它是默认的。 如果你打算从事数据科学工作，Python
是默认值。我们将 要向您介绍 Python
开始就很专业。所以希望在这门 课程中见到你。好吧，实际上之前
讨论 Python 的最佳 ID，尤其是数据科学的 最佳 ID，让我们首先讨论什么
他是一个 ID，当你开始你的编码之旅时，你们 中的许多人更喜欢在文本编辑器中编码
也许像记事本 plus plus，你在那里写 代码，然后打开一个终端窗口
执行你的代码。当您的代码 中检测到错误时，您切换回
文本编辑器，更正你的错误，错别字 并在终端中再次运行代码，一切
很好。然而，通常，对于大规模 问题，您不仅要编码，还要
还需要确保您的代码适用于所有 场景，这意味着您还需要一个
测试模块。很多时候你有多个编码 和测试文件，并在之间切换
编辑器和终端经常变得既混乱又 高效。所以需要一个环境，
在您可以编写的地方，您可以在一处 运行和使用您的代码。所以那个
为您提供的不仅仅是编码的能力 ，不仅仅是编写代码，而是
还测试您的代码，运行您的代码 突出显示您的语法，括号匹配，
自动完成、调试代码、代码 建议以及更多功能。那
称为 ID II 或集成开发环境 。现在，有几个ID是
对于不同的 Python 语言，有几 个想法，例如 Jupyter Notebook
是魅力的 ID IE 是 ID IE 蜘蛛是 IP ID 和思想不能是心血来潮的原子和
还有很多，其中有几个。现在 的问题是关于数据科学，
特别是，Id E 是最好的，或者是 人们认为最好的。所以
在实际向您展示哪个是 最好的统计数据之前
向您展示实际数字，显示哪个 更好的统计数字，什么
其他的让我来看看其中的 一些简单和它们的功能
和东西。然后我们将转向统计 数据和一些将显示的数字
哪个优于另一个。所以让我 从这个 Jupyter Notebook 开始。
在过去的几年里，Jupyter Notebook 在以下方面越来越受欢迎
编码和调试。 notebooks 重新 定义了 ID E 的概念，并且
在其上添加越来越多的功能。木星 是在其前身之后于 2014 年推出的
ipython 从那时起，它真的被认为 是编码社区的福音。
木星代表我在有些人说木星 代表 Giulia Python r 但那
我进来的首字母缩略词不仅仅意味着 这个。我的意思是 Jupyter Notebook 今天支持
不仅仅是 Giulia、Python 和 R 顺便说一句 ，这个 Giulia Python、R 和 R 所有这些
是开源语言，它们最适合 数据科学。这个 Jupyter
笔记本，它有降价编辑器。它允许 您编写 HTML 代码，它允许您编写
里面的乳胶。我还有很多。进一步这个 Jupyter Notebook。它是一个基于 Web 的应用程序
服务器客户端结构，易于使用 ，允许您创建、分析和
操纵文件。所有这些文件都是笔记本 的形式。由于它是一个
web web 界面，它可以与许多现有 的 web 库集成。例如，
用于数据可视化。 Jupiter 有很多 功能，你可以用它来编写公式
labtech 运行 Python 代码和可视化。例如 ，使用 matplotlib 的原始音频信号
绘图库，都在同一个笔记本中。 Jupyter Notebook 不仅仅是他的一个想法，而是
它被广泛使用，是一种用于演示甚至 用于编写博客的教育工具。你
可以将您的笔记本从 iPython Notebook 格式 导出为 PDF 或 HTML 甚至 to.py，
是 Python 文件。 Jupiter 的用户界面 使其成为最受欢迎的工具，尤其是
在数据科学界中。这个木星 的一个优点是，它非常快
开始，我的意思是，非常容易且非常快速地 开始，我的意思是，没有太多的火箭科学
写你的第一个目标，你想写你 的HelloWorld它非常非常快。和
你最好去这样做。通过魅力，如果我 讨论圆周率魅力，但是，如果我讨论
它的一些属性，让我来讨论一下， 首先，PI 魅力所在的管道是
JetBrains 公司。如果您从未使用过 japin JetBrains 其他 ID，例如 Java ID，那么
成功运行你的第一个代码可能会 占用你一点时间，实际上，
你的大量时间可能就像我的意思 ，通过魅力设置翻译。经过
然而，魅力在于，对于 处理多个脚本，处理多个
文件并将它们链接在一起以及巨大 的大规模编码产品。好的方面
Python 是否支持 Anaconda。结果， 属于 Anaconda 的所有软件包
char pi 魅力也支持。以及包括 NumPy、Sai、pi 在内的那些包
matplotlib 等。就像其他IDE一样，ease pi魅力有一个强大的调试器。和
图形界面。提供jet集成，有技巧 ，有shell终端，有烦恼
控制系统。 Python，它是可定制 的，它允许您在不同的
主题、配色方案和键绑定等等 。此外，Python 允许您添加
非pythonic文件的插件。这些 插件负责缩进突出显示
即时错误和关键字。所以 Python 也提供了我的意思是巨大的支持
用于编码 Python。但是，我的意思是，Python 的一件坏事，也没有那么糟，
但一件坏事是它是内存密集型的。它占用 了大量内存。这是一件很沉重的事情。
其次，我的意思是开始使用 PI 魅力并不是那么快。一世
意味着，要花很多时间才能做到这一点。 然而，Spider 是一个轻量级的、开放的
source ID 哦，顺便说一句，this by 但 this by 魅力是不是我的意思是它有专业
版和社区版，它没有完全 开源。然而蜘蛛，
是一个轻量级的开源，即预装 了 Anaconda。它是建造的
主要面向数据科学从业者和工程师 。它的外观和感觉很像
MATLAB。所以如果你是一个 MATLAB 程序员 ，如果你以前用过 MATLAB，你就切换到
Spyder 和你得到的外观和感觉 一样不能顺便说一下
不能与 MATLAB 具有大致相同的外观 和感觉
所以，Spider 是为数据科学社区 构建的，它集成了基本的
以数据为中心的库，如 NumPy、Sai、pi、matplotlib、pandas、ipython 等等。
内置功能可以通过插件进一步 扩展，API 的 Spyder 包含
具有语法高亮代码完成功能的文本编辑器 、静态代码分析、调试等功能
变量探索，它还具有递归确定 运行时间和数量的分析器
文件中每个函数和方法调用的调用 次数。我的意思是，没有想法
不可能有供应商的原子，有 很多只是用于 Python 语言。
但问题真的是成为一名数据 科学家，你应该选择哪一个
选择成为初学者？你应该选择哪 一个？即使是专业人士，如果
你想留在数据科学领域，你会更 喜欢他的哪个 ID？我的意思是，
有这么多。我刚刚描述了其中的三四 个。所以让我们看看一些统计数据
根据数据科学不同ID的流行度 ，然后决定哪个更好
在另一个之上。例如，这个 数据这个分析，我展示的图表
在这里，这个分析是由凯蒂掘金 和链接完成的，它显示
直到 2018 年 12 月最受欢迎的 Python 编辑器，你可以看到 Jupiter
在顶部，第二个是 pi 魅力，然后是蜘蛛 ，然后是 Visual Studio 代码和崇高
标签，然后加上原子女人还有 很多其他的，但木星在顶部，
我的意思是，这些都是针对数据 科学社区列出的。所以
在数据科学社区中哪个 Python ID 他是最好的，和 Jupiter
木星在顶部我的意思是它是出路 。原因之一是它的简单性。
它支持这么多不同的格式 。它是一个交互式文档
它使网页具有交互性，您只需 更改您可以制作的代码
另一个网页等等。你可以你可以在 本地系统上运行它你可以运行它
在线调查系统等等 我的意思是它 有很大的灵活性和非常快速的启动
并且易于使用。例如， 如果您看到 Python ID 在
就业然后你可以看到整体木星 相比之下一直是赢家
如果您仍然看到公司或自雇人士，那么 pi 魅力蜘蛛也是您的代码和崇高的
木星是 V out 如果你从学生 的角度来看，木星是
选择。如果你去学术界或大学，如果 你正在工作，木星是你的选择
政府或非营利性木星是我在木星 的选择 我的意思是木星有点
离群的是它在任何地方都保持在顶部 。此外，如果您分析受欢迎程度
在 Python 中，就区域而言，再一 次，总体而言，木星是赢家。
如果你看到美国或加拿大木星最 受欢迎的欧洲，木星是赢家
亚洲，木星是赢家，美国使用木星 sevinor效应非洲和中东木星，
澳大利亚、新西兰木星。我的意思 是，这些数字表明木星是
在顶部，而不仅仅是在顶部。这很容易 ，我的意思是，也许这就是为什么木星
站在数据科学的顶端。所以这些 数字和所有这些统计数据表明
我们应该使用 Jupyter Notebook for Python。 我们将这样做。事实上，对于这
在特定课程中，我们将使用 Jupiter 进行各种编码。而在
下一个视频，我将向您展示如何 安装
Jupiter 环境如何安装 Python 基本 以及如何运行 Jupiter 的第一个
时间从它。所以我希望在下一个视频中 见到你。好的，在这个视频中，我将展示
你如何安装Python。有多种安装 Python 的方法，您可以访问 python.org
并从那里安装 Python 我建议使用 它有 Python 的 Anaconda 发行版
它预先安装了很多软件包，也 有 Jupyter Notebook。所以安装
通过 Anaconda 也更容易。因此， 例如，如果您正在使用 Windows
您应该下载 Windows 的可执行 文件，我们将使用 Python
三个而不是 Python 两个。所以 你应该安装你应该下载Python
无论最新版本是三点。此外，如果 您的系统是 64 位，您应该
正在安装 64 位版本，否则您将 安装 32 位版本。那么让我们
假设您已经下载了适用于 Windows 的 可执行文件，然后在下载后您只需
从该 xe 文件并按照步骤操作，一旦 安装完成，您就可以安装 Anaconda
安装 Anaconda 然后在搜索栏中 输入 Anaconda prompt 和 Anaconda
我的鼠标指向的提示符号会 出现在你面前，你只是
运行它你会看到这样的命令提示符 。然后在其中输入 Jupyter Notebook
然后按回车键，你就会看到木星 在你面前运行。让我让我展示
你在我的系统上。怎么做。让我们 来看看。例如，这是我的搜索
酒吧。让我输入和 conda 提示，所以这 是 Anaconda 提示。所以如果我点击它，
它运行然后我只是输入例如，木星 记事本然后我按回车键。为了
第一次运行需要几秒钟。所以让我们拭目以待 吧。所以是的，它运行并且
它会在你面前显示一种浏览器 。这就是木星进入界面
是。然后我们将看到如何从这个 Jupiter 如何编写代码 如何制作代码
文件和东西，但这就是安装 Anaconda 后从 Anaconda 安装的方式
你将如何发射木星。所以这很容易 ，没问题。然后，例如，
你可以安装你可以安装 Python 如果 你在 Linux 上工作，只需下载
Linux 的版本。然后而不是 例如，假设您的文件
下载到 Downloads 文件夹中，然后 运行此命令 bash 和 this.sh
文档名称。为了继续安装 过程，安装程序提示我
在这些类型的命令中会出现 Press Enter to Continue 然后按 Yes，然后
安装程序将完成感谢信息 。之后，你只需去下载
文件夹并输入 Jupyter Notebook 和 Jupyter Notebook。 interface 基于浏览器的界面
会出现在你的面前。如果你在 Mac 上工作，你可以拥有，你可以
你可以在你可以下载 Mac 的 Anaconda 发行版 ，然后你会找到一个 anaconda Anaconda
导航器，您可以启动的启动板 ，然后只需单击木星图标
在你面前只需按下启动按钮 ，你就会让你的木星运行
在你面前。所以在这个视频中，我们 只讨论了如何安装 Python。如果你
使用 Anaconda 安装 Python，您也 将拥有 Jupyter Notebook。下一个
视频，我们将看到如何实际使用 Jupyter Notebook 界面，例如，我
在 Windows 上工作，所以我将拥有 这种界面，尽管界面看起来
一样，因为它是基于浏览器的基于 Web 的界面。在下一个视频中，我会
向您展示如何适应 Jupiter，我们 还将编写我们的第一个 HelloWorld
用 Python 编写程序。所以希望在下一个视频中 见到你。好的，所以在这个视频中，我会
给你看
如何在 Python 中编写第一个程序基本上 是 HelloWorld 程序。在此之前，在
在上一个视频中，我向您展示了我向您展示 了如何启动 Jupyter Notebook。所以一旦你启动
Jupyter Notebook，无论您是在 Windows 上工作，还是在 Linux 上工作
或者 Mac，不管怎样，当你启动 Jupyter Notebook 时，你会看到这个基于网络的
界面。在这里你在右上角你可以 看到新的按钮，你只需点击
它，你会选择Python三，你会 看到一个漂亮的界面在前面
你允许你去这里，有很多 文件编辑视图有很多
父母内核和许多控件在这里我们将 在继续前进时看到它们。但这是
你如何，这就是编码环境，这是一 种编辑器，也是我的意思
这样就完成了，即界面呈现在你面前 。那么让我们稍微看一下这个界面
少量。至少一步一步地控制我们 需要的。首先，你看到
我的光标移动的地方。那是文件名 或笔记本名称。你可以改变
笔记本名称，或者您可以只写例如 。不管笔记本叫什么名字
例如，您想要由 Thorne 掌握
为了
初学者。好吧，假设您正在掌握 Python，假设您已经掌握了零
对英雄，也许。假设这是您的归档 文件，您只需创建该文件即可
看到这个掌握 Python 零到英雄，用 这个文件创建的文件被重命名。
第二。这是您要在其中键入代码的单元格 。代码，我的意思是，两个
编写方式之一是您可以编写 Python 代码。另一种方法是你可以写
降价。降价在某种程度上很 重要，如果你想描述你的
代码，如果你想写Python代码以外的 其他东西，你可以使用这些markdown
细胞和它们 我们将帮助您。例如 ，如果我选择这个降价，我
只需选择这个降价，然后我在这里输入 ，例如，
这是 THON 导演的。然后我按 Shift Enter，它将显示为标题。
一个新的单元格将被降级。这也是一 个细胞。但这是一个降价单元格。
正如你所看到的，现在在这个单元格中，这是一 个代码单元格，你可以从代码中切换一个单元格
只需按转义键即可降价，当 您按转义键时，您会看到
这里的颜色会改变，你可以按Escape 键，然后如果你按M，它会改变
降价。如果您按 Y，它将更改为代码 单元格。有几个我的意思是快捷方式
这是可用的键盘快捷键，如果 你只是看到，如果你去帮助和
看到这个键盘快捷键，前面 会有几个快捷键
我们。例如，如果按 Esc，然后 按 F，则可以执行查找和替换
手术。如果你按下回车键，就会进入 编辑编辑模式，如果这很重要的话，
如果你按 Shift 键，回车，单元格 将运行，新的光标将进入新的
细胞。并且有很多控件你应该看到 其中的大部分，我的意思是，让
很好地掌握这些控件将帮助您在 此 Jupyter Notebook 中快速入门。
例如，这是一个 Python 教程，它是 一个 Markdown 单元格，您还可以创建
这个，这个单元格也作为一个降价单元格 。然后你可以在这里输入例如。这是
我们的第一个 Python 程序。例如 ，它是从这里开始的，它只是
看起来像一个描述。再一次，一个新 的单元被创建下来，你可以在那里
写你的代码。那么让我们编写第一个 Python 代码 HelloWorld。所以首先，你
将写 Brent Brent 命令将允许您在 屏幕上打印任何内容。布兰塔斯
说双码，开始结束。在双重代码 中，你想写什么就写什么
例如，打印在屏幕上。你好，
世界。
一旦你写好了代码，只需按 Shift 并输入，这段代码就会
在你面前执行。这就是打印在您面前 的 HelloWorld。这是我们的第一个
程序，我的意思是，在 Jupyter Notebook 中编写 第一个程序。就是这么容易。不是
只是，这个 Jupyter Notebook 将被创建， 你可以我的意思是描述任何东西，
你可以写标题，你可以在其中写 HTML，你可以写数学，使用 lattic。
例如，让我让我写 lattic，或者 mat 在你面前只是让我们说
你正在制作一个需要一些数学 知识的笔记本。它允许你写
数学也一样。例如，A 等于 B 加 C，按 Shift Enter，看起来像
一个数学方程，不仅仅是这个，你可以 写出非常复杂的方程。我的意思是，
和，整个笔记本将包含您 的 HTML 或 latech 描述，
或描述，代码和所有这些混在一起的 东西，不管怎样。最后，你会，你
可以，你可以下载这个。你可以 随意下载这个，这个笔记本
PDF 文件 PDF 文件。如果你想要一个笔记本 文件，如果你想延迟，它是一个输出文件
例如，如果您想要幻灯片，则只需要一 个 Python 文件。我的意思是，你可以下载
和幻灯片一样。它会为你制作幻灯片 。所以有很多使用方法
这个笔记本。这是一个现成的文件。我的 意思是，你结束编码，文件准备好了
为你。所以这个 notebook 真的非常强大 的 Jupyter Notebook 并在其中进行编码
不仅仅是编码。我的意思是，它正在准备 一份文件。如果你想准备一份文件，
你想描述任何你想添加图像的 东西，在一天结束的时候，它
将是您的 HTML 文档。它可以在网络上共享 。我的意思是，它已经准备好了。没有
我们想进一步完成它。这就是我们用 Python 编写的 HelloWorld 程序。我们会
继续构建这个字节掌握 Python 零 到英雄笔记本，我们将继续编码
在那我们将描述标题，我们将编写 降价单元格和所有这些东西。
我们将在本课程结束时，您将拥有 一本笔记本，其中包含各种
其中的描述和代码。之后你可以 使用那个笔记本，我们将构建
一本笔记本，一本完整的 Python 笔记本 。就是这样。这就是你好
世界。在下一个视频中 ，我们将看到如何在
Python，什么是变量和其他东西 。但在那之前，我也想证明
这款笔记本是ipython shell 的升级版 ，是一款增强版。我也
也想向您展示 ipython shell。所以在 下一个视频中，我们将只看到 ipython
shell，我们将看到我们如何通过 使用将 Python 视为计算器
ipython 外壳。所以希望在下一个视频中见到 你。好的，所以在这个特定的视频中，
我将向您展示 ipython shell 就像以前 一样打开 Anaconda 提示符，
就像你想打开一个 Jupyter Notebook，那么 你只需在此处输入 Jupyter Notebook。
并且您将在笔记本单词 Jupyter Notebook 单词中出现。但是如果
您只需输入 ipython 并按回车键 ，就会为您打开一个彩色提示
道路。在这里可以编写任何类型 的 Python 代码。实际上，该
Jupyter Notebook 使用 ipython 进行了 更多增强和更多功能。基本上一切
我买的，ipython 中有，Jupyter Notebook 中也有。但它
有更多功能更多文档和东西。例如 ，如果我只写一个 Python 代码
这里，
你好世界，假设它也可以在 ipython shell 中工作。但请记住，之前在
在 Jupyter Notebook 中，我们键入 Shift Enter 以在此处运行特定命令，我们只需按
输入，一切都会好起来的。如果 你想在这里清屏，不管怎样
我们在这里输入，如果你想清除它， 如果你在 Windows Ctrl 上，只需按 Ctrl l
我将在 Windows 上工作。现在 ipython 就 像，你可以在这个特殊的地方使用 Python
shell就像一个计算器，比如 你要加三，按回车，就是
五、假设是九乘以七，答案 是63。你可以写一个复杂的
语句也是一样，例如45减8是静态 的，或者乘法，静态是实现的
乘法是通过一个静态符号七来 实现的。然后你可以有这个减号
然后除以二，然后按 Enter 键。 这就是答案 16.0。例如，如果
顺便说一句，我刚刚按了向上箭头键 ，最后一个命令就出现了。我有
再次按下向上箭头键。出现倒数 第二个命令。我按向上箭头
再次键，出现倒数第三个命令 ，现在我按下向下箭头键。
所以例如这个，你可能会得到 任何结果，你可能会乘以
减 10 减或加减 15。所以结果 是减 145，依此类推。所以
这个Python ipython shell，你可以写的 很复杂的都差不多了，完整的
Python 编码可以用 ipython shell 编写 。您可以将此外壳仅用于计算器。
现在让我们看看，例如，你计算这个 结果，比方说 45 减 45 减九
假设你计算了这个结果，不管结果 是什么，你把结果保存在
一个符号，让我将该符号称为变量 。在这里变量是所以假设你保存
在 a 中，然后你有另一个变量，比方 说 B，和三个静态 45，或者也许
三个立体 2.6，保存在 B 中。现在 ，你已经完成了这个特殊的计算，
你知道 45 减 9 在 a 中，结果在 a 中，然后你有这个特殊的
结果在 B 中。 现在，您只想将两 个结果加在一起，并且您想要
打印
什么普通计算器不支持 保存结果和重复使用
他们。但是这里在 Python 中，即使你只是 想使用 Python，也只是作为一个计算器，
你可以声明尽可能多的变量， 你可以保存以前的结果，你
可以检索以前的结果。并且可以 使用以前的结果，保存新的结果
等等。这些用于保存结果 的符号，然后它们可以
只是在之后使用，这些被称为变量 。我们的下一个视频将是关于变量的，
这些变量是什么，类型是什么 ，Python支持什么类型的变量
一种或另一种方式，如果你想超越 计算器，你需要某些结果
保存和检索后检索 。变量是构造
变量是实际执行此操作的功能。 所以计算器很好，你可以使用
这个 ipython shell 就像一个计算器 。但如果你想做有趣的编程，
复杂的程序，我的意思是，你 想要完成一项涉及更多计算的任务
一种或另一种方式，您必须将某些 结果保存在某处。然后你必须
将结果组合在一起，因为通常较 长的问题会分解为较小的问题
一块问题。每个较小的问题都有 一个结果应该保存在某个地方
然后将几个结果组合起来， 达到我们想要的结果
之后。所以如果你 要做一些有趣的或
复杂的计算或计算。所以你， 顺便说一下，在拥有这些之前
Jupyter Notebooks 只是吐出这个 ipython shell 的增强版本，iPod ipython
shell 只是人们过去常常在 ipython shell 中编写大量 Python 编程。乃至
即使在今天，仍有几个人在 ipython shell 中编写完整的代码。但该
Jupyter Notebook 更加增强，因为它 记录的更多，我的意思是，它有
更好的界面和一些比仅使用 ipython shell 更好的功能。
所以你已经看到了这个 ipython shell， 它非常强大，很棒，一切都很好
它。但是我们将使用 Jupyter notebooks， 它只是这个的增强变体
ipython 用于我们即将进行的编码。所以 这个视频的目的只是为了介绍
你使用 ipython shell 只是为了告诉 你你可以将 Python 用作计算器
甚至更多，在下一个视频中，我们 将在 Jupyter 中引入变量
Notebook，我们将看到 Python 或 Python 真的比仅仅强大得多
一个计算器。所以希望在下一个视频中见到 你。好的，在这个视频中，我们将讨论
变量和运算符 可以对变量 执行的操作。一个变量
通俗地说，基本上就是一个符号， 用来存储一些以后可以使用的数据
在。例如，这个 x 是一个符号校正器或一个 符号 y 是一个符号 x y 是一个符号
通常，这些被称为变量的名称 。例如，这是一个变量
name x, y 是变量名 y, x y 是变量名本身 。现在，这些变量，他们可以
存储不同类型的数据，我的意思是， 每当您想要再次使用特定数据时
再一次，最好是保存该数据或 通过描述性的符号来标记该数据
名称，以便您可以检索该团队使用该 标签或符号检索该数据。所以
一种或另一种方式。这个这个变量实际上 是你想要的数据的描述
使用我们的商店，并且您希望稍后在 您的程序中使用。不同类型的数据
例如，是否存在整数类型数据。
例如，如果你要存储的数据是整数 类型，它是一个数字和数字
只是整数它没有小数 点扩展是一种类型
数据并且可以存储在变量中， 在这种情况下，变量类型本身
将是整数，您在存储时不 需要指定变量的类型
data to it 将数据存储到变量 有时称为将数据分配给变量
或任务。例如，如果您的变量是 x， 并且您正在分配一个值，让我们
说二，那么二是整数值，它的 整数没有十进制扩展，当
to 被赋值给 x，根据 to 的内容，to 基本上是一个整数类型的值，
自动将 x 的类型设置为 整数。这有时被称为
动态类型 Python 是动态类型语言 或动态类型，你不需要
指定变量的类型您分配 给变量的内容，它们
将动态定义变量的类型 。和分配例如，在这里
我正在存储两个 Insight x ，下次如果 我想打印，例如，那里有什么
在 x 中，打印值将为 2。现在 ，这种符号很热就在那里
没有看起来像这样的键盘符号 ，所以不要写这个符号来赋值，
通常使用等号符号进行 赋值，例如，x 等于 2
这意味着在 x 中分配了两个 5 等于 5 等于 5 意味着分配了 5
在 y 7.2 等于 x y 等于 7.2x y 完全 是一个新变量，与它无关
x 或 y。有时建议变量 的名称很方便
描述性太强，非常非常具有描述性 ，以增加可读性和管理
代码，因为稍后你会 看到你什么时候工作
数据科学和其他东西。您将 要编写的程序可能不是很
短节目，它们可能是冗长的节目 。所以程序和管理的可读性
如果您不分配变量的名称 ，程序的名称就会成为问题
小心。但是，如果您以非常具有 描述性的方式写下名称，只需写下
变量的名称通过创建变量 符号或或或名称，它
告诉更好的外观和感觉里面有什么样 的数据，我应该用它做什么。
所以，我在谈论这个等号，这个 等号用于赋值。在这里为
示例当 7.2 被分配给变量 x y 时 ，自动指定 x y 变量的类型
设置为浮点整数浮点数浮点数 是 in 中的数据类型
描述特定数据是实数值 的 Python 可能有小数
不仅整数和浮点数是 Python 中 唯一的数据类型，还有扩展
例如其他几个，如果你愿意 ，你可以定义复数
可以例如，定义一个复数 可能是例如，你写的名字
C，你写二加四 j 如果你在这里 写符号 j，它会自动变成
复杂的。现在你可以用这个 来看看复数应该是怎样的
创建。同样，还有其他数据 类型，如分数小数，还有
进一步的数据类型，称为字符串的对象 。例如，如果您如果您分配让我们
say s 等于双引号 Hello
那么 S 也是一个变量，这个变量 的类型字符串只是一个
许多收藏家的序列，他是 收藏家是收藏家 L 是收藏家
L 是一个收集器，收集器 W 总是一个 向量。当我们定义任何东西时，
双引号内的任何字符序列， 然后在此处结束双引号，
或单引号，单引号和双课程任一 种方式，那么 this 的类型是
变成字符串。这些角色应该 按原样创建。例如，如果
我们有另一个变量 s 2，我们只是 用双引号表示一、二。现在这
二不再是 12 作为整数。它是一 个字符序列，其中第一个字符
是一个，其他毕业生是两个，我们将 在即将发布的视频中详细讨论字符串
但只是为了让您感受一下 Python 实际上支持很多数据类型，
很多有趣的数据类型，包括最 重要的数据类型是整型浮点数
和字符串以及我们将详细看到的。您 可以进一步分配您可以分配更多
在一行中的多个值到 多个变量有时被称为
多重赋值。例如，如果你写一个逗号 b 等于四个逗号 5.00，那么四个
将分配给 a 并且 5.0 将分配给 B。 注意一件事，虽然 5.0 看起来
就像一个整数，但是当你写一个 小数展开式时，它会自动变成
漂浮。所以，如果你现在输入类型，如果 你现在检查 a 的类型，它将是整数
如果您检查 B 的类型，它将是 浮动的。一旦你声明了很多变量，
它们留在内存中，它们占据内存内部 的特定空间。例如，x 是
只是内存中位于某处的内存 的标签。类似地，y
也位于内存中的某处。同样，xy 也位于内存中的某处。和
这是该内存中的数据。这些 将留在记忆中并占据
记忆。如果您决定不再 使用特定变量和未来
在程序中，那么你可以调用这个函数 d l 空间，不管变量名是什么，并且
它将删除它将从内存中删除变量 ，就像它从未存在过一样。和
一旦变量不再在内存中，它 就不可访问。如果您现在访问
再次变量，你会得到一个错误。让我们 看看所有这些概念。让我们看看
Jupyter Notebook 中的大部分概念， 让我们实际上，让我们实际上
定义某些变量，使用它们，打印 它们，进行一些多重赋值并查看
Jupyter Notebook 中有很多东西。那么让 我们来看看 Jupyter Notebook。所以那是
我们正在做的笔记本，我们实际上 是在上一次工作。那么让我们
假设我定义了一个变量 X，假设 x 是 2。 为什么不？为什么不？我应该描述一下。
因为我们在这里做的是让我们说变量 。所以只是给我们现在的标题
在变量中，所以变量中，注意现在我 在一个代码单元中。以前我在一个
降价单元格，注意这个特定单元格 的这个变化，这是降价
特定的单元格，这是代码单元格，C 去，好吧，x 等于比方说，三，
让我们进入这个。现在 x 被赋值 为 3。如果你想知道有多少变量
现在在内存中，我们可以写 这个命令，这是一个百分比
符号，如果你写一个符号百分比， 然后只输入一个命令，w o s，它会
告诉你现在在内存中 的所有变量。对
现在内存有一个名为 x 的变量， 它的类型是整数，里面的数据
变量是三个，这就是你现在看到 的内存视图。好的，如果你愿意
要明确检查 x 的类型，您可以 打印类型 x。例如，这个函数
type 实际上会找出你在里面给出 的任何变量的类型，然后
此打印功能将帮助您将其打印 在笔记本上。所以如果你看到
x 的类型，类型基本上是它的整数类型。 现在，
例如，如果您将 x 的值更改为 3， 假设为 5.7。所以你有同样的
变量，但您只需将值从 3 更改为 5.7。 所以让我们看看现在会发生什么。
所以如果我们再次调用我们，我们现在 变量名仍然是 x，但它的类型自动
它的类型自动更改为浮点数 ，因为我们分配
一个浮点数。如果我们要 明确检查，这就是数据
这个 x 的类型，现在是浮动类 ，进一步。假设我们有另一个变量
A B C D。这是一个变量名，假设我们 分配一个值 55 六点，三，二，
这就是价值。如果我们现在调用 who 函数 who 的命令，我们将有
两个特定值，一个变量为 ABCD，其 类型为 float。另一个变量是 x，
它的类型是浮动的，就在那里。例如 ，如果我们进行多项赋值，对于
例如，一个逗号，当你写逗号时，第一 个变量结束，第二个变量开始
A、B、C、D、F，假设这是五个变量。 如果你给五个变量分配五个值，
再次在逗号分隔列表中，356， 点 07，点二，假设减三。
所以如果你输入那个，然后你现在检查 内存的状态，因为现在所有这些
值被分配给各自的变量，如果你现在 检查内存视图，a 是一个
值为 3 ABCD 的整数类型变量， 我们之前分配的旧变量，
它已经是浮点数 B 也是整数，它的值为 5 看到浮点数，看到浮点数所有这些
6.0 看起来很像整数。但是当你 明确地写出一个观点时，它
变成浮点数。所以 D 又是， 浮点数为 7.2，f 是整数，
现在零五。 x 是我们已经知道的旧 变量。现在，如果我们，例如，
删除一个特定的变量，例如， 我们不再想使用 ABCD 变量
A B C D。这是我们将来不想使用的一个 变量。现在如果我们再次看到，
内存的视图，我们没有这个，如果 我们现在想要访问这个，例如，
如果我们想打印这个 ABCD，我们会得到一 个错误，我们会得到一个错误，我们应该
我们应该得到一个错误，因为这个特定 的变量在内存中不存在，它
指向没有数据，它已经消失了，它像从来没有 一样消失了，它从来没有存在过。所以
那是关于变量。我们刚刚谈到 整数和浮点数，有几种
其他变量类型也是如此。 例如，让我给你举个例子
一个复数，如果你真的对那是一个 复数感兴趣，如果你打印它
type 使类型复杂。同样，你可以 有一个字符串变量，比方说
你好吗？这是一个字符串变量，如果 你带上这个类型，你会得到
一个字符串，我们将拥有一整套字符串 数据类型的视频，因为这是
非常重要的数据类型我们将详细 介绍。但这里的目的只是
告诉你Python支持的数据类型 很多，而且Python是动态的
键入您分配给变量的任何 内容，该内容决定类型
您不需要指定的屏幕。
所以我在这里结束这个视频。在下一 个视频中，我们将主要讨论运营商
什么样的所以一旦我们决定一旦 我们宣布一旦我们定义了很多
的变量，我们可以用这些变量做什么， 我们可以将两个变量相加得到
存储在另一个变量中的结果我们 可以将两个变量相乘吗？
例如，有一个像加法或混合类型这样 的操作，一个变量是一个浮动的
number 和其他变量是 integer number 整数类型 ，我们可以混淆那些可以我们添加
两种不同类型的变量放在一起 并得到结果那么类型是什么
结果等等。所以很多关于运算符 的讨论都是非常基本的算术
这些变量上的运算符，特别是 整数和浮点变量，我们将看到
在下一个视频中，所以希望在下一个视频 中见到你。所以在上一个视频中，我们
看到了变量，我们特别看到 了整型变量和浮点型变量
类型。我们还非常简要地看到了 Jupyter 笔记本很复杂，字符串也是如此。
所以在这个视频中，我们将讨论 运算符，基本上是算术运算符。
显然，如果您正在定义变量 ，则不是将它们定义为变量
只是为了稍后查看它们。您很可能 会将数据存储到变量中
然后你正在对一组变量进行 一些计算。比较
新结果保存并做一些事情 ，很可能你会添加到变量
在程序内部以某种方式或另一种方式， 您可能需要添加两个变量，您可能
必须从另一个变量中减去一个变量， 您可能必须除以一个变量，您可能
例如，必须计算，这些是算术运算 符，让我让我就这个加上
符号用于添加到变量。这个 减号或减法是用来减
来自另一个变量值的变量值。显然 ，这些都是对值进行操作的，
不是名字。除法，顾名思义 ，就是如果你想除法
将此人应用于两个不同变量时 的符号，如果 x 在左侧
y 在右边，它做了什么，它实际 上将 x 除以 y，并检查余数
例如，如果 x 是 27，y 是 5，那么 余数是多少？你怎么认为？
如果我们将 27 除以 5，余数是 多少？二 是的，所以结果
这里会有两个。所以这计算了余数 。这个乘法这个星号被使用
就像数学中的乘法一样，我们 通常会写这个十字符号。但在
Python，在大多数编程语言中 ，星号是用来实现乘法的。
这个双斜线就像除法，但 它是除法，结果流向
商。我要说的是以下内容。 例如，如果你除以 10。
乘以三，结果将是一个浮点数 ，结果将是 3.33。某物
像这样。但是如果你只想要商而 不是余数，如果你想要整数，
那是商值，然后你写 双斜杠三，它会返回
只是在十进制扩展之前存在 的值。所以这个值会
被退回。所以这是一种整数 除法或地板除法，这个双星
用于计算功率。例如，如果 你想计算到正确的双星，
四，即数学中二的四次 方，我们写成如下。
结果将是 16，您可以将该结果保存 在另一个变量中，或者您可以
打印它或者你可以把它写在任何文件 中。所以这些是最重要的。运营商。
我想告诉你的一件事是，这些运算符 不仅适用于整数和浮点数
点数，这些算子的应用比这些要 广泛得多，后面我们会
查看属于集合的对象或数据类型 。非常，我的意思是，数据类型
超出这些整数和浮点数，仍然 存在，这个加减除法，
所有这些都是所有这些，它们在 那里有它们的含义。甚至连
这个加号用于优势。现在想想， 如果你有一个字符串，让我们说
你好。
你有另一个字符串，例如， 假设这是一个字符串，你有
另一个字符串，让我们说 s 两个，这 就是为什么 Python 允许您甚至添加这些
类型的数据类型，尽管有些对这些 类型的字符串没有任何意义
变量，但我们将看到四种 不同的数据类型。的定义
这些运营商，他们实际上相应地 改变或适应了。例如，在数学中，
我们在 Debian 加减法中更流畅地 使用四加法，这是有道理的
将两个整数相加以从另一 个浮点数中减去一个浮点数
等等，但是对于您现在不熟悉的数据 类型，这些运算符可能不会
对你有意义。但是那里有定义，有 一些方法可以使用这些变量。
对于甚至存在甚至超出整数 和浮点数的数据类型
数字，当我们继续前进时，我们将看到 所有这些细节，当我们继续前进时
到视频。我的意思是，正如稍后，我们 将详细了解所有这些内容，但是
只是告诉你，这些运算符 不仅限于整数和浮点数
点数或复数，它们可以应用 于几种不同的数据类型。
这么多话，我猜你已经出生了 现在， 让我们去 Jupyter Notebook 玩得开心
与我们正在处理的这些概念。所以是的 ，在这里。所以让我们先按下
逃脱，然后我只是将其更改为降价， 然后将其作为标题生成的好 scape 。
我在这里写，让我们说运营商，然后 shift 输入它的运行，然后自动
去代码。好的，现在假设我有一个变量。所以 让我们说我已经有了什么样的变量
有。在上一个视频中，我们使用了它 。所以我们已经有了这些类型的变量
和我们。现在，让我定义一个新变量 是什么，让我们说 A、B 的总和，那就是
一个新的变量 sum 下划线 AB，这是一 个变量名，你可以有一个更好的方法
可能会命名 A 和 B 中的一些，这可能 是一个变量名。很高兴拥有
描述数据的描述性变量名称 。因为在程序中，
程序变得易于管理、可读， 并且有很多好处。所以总和
a 和 b，假设这是一个变量名。 你加a，b，你就写一个加b。
让我把缩放级别调高一点，以便您 可以清楚地看到它。所以a加b，
让我们说就在那里。如果您按 Shift 键， 请输入，然后是您的品牌。一些由
方式，如果你写了一些你不需要写 所有的东西，只需按tab键，然后
它将自动完成变量的剩余 部分并按 Shift Enter
你有八个。如果你检查这个变量 的类型，一些选项卡会自动
完成制表符完成，称为制表 符完成，而它是整数，类型
这个特定的变量是整数，这是一 个新变量，为什么和类型是整数
因为a是整数，B是整数。而 整数加整数就是整数。什么
如果我们添加一个带有浮点数的整数 ？你怎么认为？应该是什么
结果？如果我只输入类型？ A, 那是 一个整数加上带有一些浮点数的 d
数字。所以加上 d，结果将在这里， 以及该结果的类型。将是什么
结果的类型？你怎么认为？让我 在这里暂停几分钟，哦，不，
不，不，不是几分钟。几秒钟， 也许几秒钟，也许两三秒钟，
结果会怎样？整数和浮点 组合的类型是什么？
嗯，类型是加成本的，这 意味着浮点数，结果将
是一个浮点数。原因是，默认 情况下每个整数都是浮点数
点数，浮点数是一个上层类， 或者你可以说是一个超集。
因此，在 Python 中，在 Python 中，默认情况下，类型 的成本会增加到超级超集。所以在这里
整数加一个浮点数，结果将是 一个浮点数。这就是结果，
您可能会想为什么我们没有将结果 存储在另一个变量中。好，
如果我们想将结果存储在另一个变量中 ，我们可以，或者如果我们只是计算
结果并对其应用一些操作，我们可以 做到这一点。例如。我们可以做到
下面，例如，加 d。这就是结果 被提升到 3 次方，不管
结果是，不管结果是什么，除以四 。我们只是把它保存在一个
新变量。让我们说。假设新变量 是 V。假设我们保存该值，
和 V. 现在我们打印我们，我们有结果 给我。哇。所以我们可以做很多
与这些类型的变量的东西。让我给你 看一个我们稍后会看到的花哨的东西
在。如果您没有将它作为一个来理解，请 不要担心，例如，一个是 Hello。你好，
假设两个是世界。我们还有另 一个变量，比如说 s，它是 s
一加二。它会做的是将它们 连接在一起。我们会看到
字符串很多以后。但只是告诉你 这个加号不仅仅是为了数字，
它适用于其他数据类型，非常花哨 的数据类型。还有一件事，让我们
假设我们定义了 10 并将其除以 3，我们想要一个商，商是 3。
但是，如果我们将 10 除以 3，按 Shift Enter， 结果实际上是 3.33，依此类推
继续，您可能想知道我们没有将该结果 保存在特定变量中。那么在哪里
结果被保存，实际上，如果你不， 如果你不保存结果，如果你不
给结果赋值，比如这样，结果 会被赋值给一个变量
或者，但如果您不将结果存储 在特定变量中，则不赋值
显式地，默认情况下，Python 中有一 个变量，它是 underscore underscore
包含您没有明确存储在特定 变量中的最后一个结果。
因此，如果您愿意，该下划线基本上 是结果的一个默认变量，
不要尝试更新此下划线，只需阅读 它不要为下划线分配任何内容。
例如，如果您将某些东西分配给 下划线分配将完成，但是属性
下划线将不再存在，因为它们在 Python 内置属性中。好的，
所以，就是这样，我想。这就是 运营商，我们将更多地看到运营商
以后还会有更多。但在结束这个视频 之前，我给你留下一个问题。所以
问题是，我们看到了变量名，如 a 和 b 之和 X，Y 变量名可以可以
可以是冗长的，可以是描述性的，也可以 是简短的。所以问题真的是，可以
变量名以数字开头？例如 ？变量名真的有可能吗
是从变量名开始，例如从一个 数字开始？是 3x 吗？有效的
变量名？或者，例如，在速度 为什么是一个变量名？
或者，例如，这个符号乘以两次 x，这是一个变量名吗？有哪些约定
to 变量名？我们可以写点 什么吗？在左边？正确的
让我们说3倍？等于四吗？这意味着 3x 现在是一个变量名。这是真的吗
Python？或者是否有定义变量名称 的约定？所以？
是的，考虑一下。在下一个视频中与 您一起回答这个问题。所以我希望你
会，你将得到这个问题的答案。希望在下 一个视频中见到你。可以，然后呢
在上一个视频中，我问了你一 个关于奇数变量命名约定的问题
名称。特别是，我问你 3x 在 Python 中是否是一个适当的变量名？
那么你的答案是什么？是的。你怎么认为 ？有多少人说，有多少人说不？如何
你们很多人说是吗？好吧，顺便说一 句，您可能已经尝试过，声明该变量
name 和 Jupyter Notebook，然后您可能已经 得到了以下答案之一？好，
让我告诉你，答案是否定的。变量 不能以数字开头。不与，不与，
以不带哈希符号的速度，不带我的 意思是，有几个
除了一些因素外，其他特殊字符都 不存在。其中之一是下划线。
让我们去看看 Jupyter Notebook 并检查 一下。因此，例如，3x 等于
五个错误，无效的语法，假设 y 的 激活等于 4。无效星 d 等于四
错误。嗯，一个例外是下划线下划线 E 等于 6，这是允许的。启动变量
允许带下划线的名称，它不同于 下划线内置的下划线
这个下划线 E 与简单的下划线 不同。所以最好不要申报
从这些开始的变量名称，因为 您将进一步得到错误。多变的
名称应该是描述性的。他们应该 给你一个数据的外观和感觉
包含，您可以自由定义变量 名称，如您所愿。所以
是一个很好的做法，以更好的方式 开始编写变量名称。一，一个更好
表示法，一种更好的定义这些变量 名的表示法，甚至是函数名，
我们稍后会看到这些功能。定义这些 的一种方法是使用骆驼符号。
骆驼表示法 骆驼表示法是 以变量名开头，例如，小写
字母，假设您的变量是课程的开始 时间。让我们说那是你的
变量名。所以你写开始，一个 字写完，然后下一个字应该
从大写T开始，课程开始时间 ，比方说。所以这种记法
称为骆驼符号。非常有名，尤其是 Java 开发人员，他们通常
按照这个和其他几个开发人员 。但是你应该想出一个符号
是一种表示法，还有其他方法 可以保持一致的策略
定义变量。还有其他几种方式，这 是一种方式。所以开始时间
课程是让我们说 2.0。就是这样。所以 这是一个变量名，如果你现在
检查，这是一个变量名。但是现在， 如果你看到这个变量，只是名字
提示里面的数据是做什么的？所以名字 应该是描述性的，我的意思是，
让它成为一种习惯。所以，是的，我想我们 现在已经非常具体地回答了我们的问题，
变量名不能以数字开头，不 能以任何特殊字符开头
下划线，好吧。在下一个视频 中，我将介绍与变量的比较。
例如，如果您想比较一个变量 是否小于另一个变量或
不是？如果您想比较它们所包含的两个 变量是否包含它们的值，该怎么办？
是否相同？如果您想对存储在内部的 数据进行比较，该怎么办？
变量，并根据比较的结果 ，您想做其他事情。
所以在接下来的视频中，我们将看到一个 非常非常有名的 bool 数据类型，它是
在决策中大量使用。我们将 看到有时称为比较运算符
下一个视频中的关系运算符，所以希望 在下一个视频中见到你。好的，
在本视频中，我们将讨论一种 称为 bool 的数据类型。那很，
非常有名的数据类型。实际上，它 是最著名的数据类型，因为它用于
决策制定所有控制流的大部分 控制，因此取决于此数据类型。
虽然是非常非常有名，非常适用 的数据类型，但是非常简单。它
是只有两个状态和两个值的数据 类型。顺便说一句，有能力
不同的数据类型。例如，在 T 整数 中，
您可以存储的不同类型的值是巨大 的，您可以存储任何负数
在里面，可以存储零，可以存储 任意正数，浮动的容量
点数或它可以保存的 值的数量甚至更高
比整数和复数甚至更高等 等。但是布尔数据
类型，它只有两种状态，一种状态为 真。它只有两个值。 True 是一个值。
而 false 是一个值，只是这两条直线是 true 或 false。在一些编程语言中，
真用一表示，假用零表示 。但在 Python 中，真正的
是真的那件事和假是假的。就 是这样。如果你例如，定义
一个变量让我们说任何变量名称，无论名称 是什么，让我们说 B 并且您分配 true
那么它的默认数据类型将变为 bool。 如果你有另一个变量，让我们
看看哪个是假的。那么 C 也是布尔值 。一件事很重要，还有其他操作
除了我们看到的算术运算符，加上 减法除法和其他东西，还有
是我们可以应用于 bool 数据类型的其他 运算符。例如，一个 true and 是一个
结合 true 和 true 的关键字。如果有 一个变量，让我们说一个有一个
数据为真的布尔变量 a。如果有一 个布尔变量 b 的数据为真，则
a 和 b 也是如此。假设我使用了这个 变量 D 来存储这个 A 和 B，
D 也将是真的。所以真实和真实 总是真实的。进一步真假，这
总是假的。如果例如，true and true 是 true，true and
假是假，假是真，假是假，假是假 。所以，如果你申请一个运营商
and 关键字将两个布尔变量组合在一起 ，如果两者都为真，则 and will
否则结果为真，除此之外 的结果为假，并且有
是否还有另一个，还有另一个运算符、 关键字等，结果为 false。如果两者
是假的，假的，假的，假的，假的或假的 是假的。如果其中任何一项为真，那么
结果是真的。记住 n 和 R 之间的差异， 如果其中任何一个都将导致错误
两个操作数至少两个操作数之一为 假，
那么结果是假的。如果两者都是或都 是 anvisa 真，如果两个操作数都为真，
否则是假的
如果两个选项都为 false 或 false，则结果 为 false。否则就是真的。所以，
你现在知道了，你现在知道还有一 个叫 not 的运营商。这不是这样
not 例如，返回不正确。结果假而 不假。返回真。伟大的。
所以结是一元运算符。一元意味 着它只需要它只需要一个变量
对其进行操作，并且是一个二元运算符 ，就像 plus 是一个二元运算符。需要两个
要操作的变量，或者是它操作的二元运算 符，它需要两个运算符，它需要
要操作的两个变量，依此类推。 所以记住，记住这些事情，一，
如果两个变量都为真，我们将 返回真，否则结果为假，或
将导致错误。如果两者都是假的。否则 ，它将返回 true 而不仅仅是翻转
状态。所以不真就是假，不假就是 真。所以这些是基本的，那就是
如何将布尔变量组合在一起。 在下一个视频中，我们将看到
如何应用这些比较运算符， 结果将是布尔类型。如何
我们能否将布尔类型组合在一起 以构建更好的决策。所以在
这个特定的视频，我只是，我刚刚 为您介绍了布尔数据类型。在
下一个视频，我们将看到布尔数据类型 实际出现的位置，以及它如何影响
我们的，我们的编程风格或思维风格 或编码风格。所以希望见到你
在下一个视频中使用实际生成 布尔变量的比较运算符。
希望在下一个视频中见到你。好的，在 上一个视频中，我讨论了布尔数据类型
我讨论了一个布尔变量要么是 真要么是假，我们可以结合
这些布尔变量与我们的运算符 一起。然后我们可以打一个结
特定变量的运算符。我们 看到一个真和真返回真和
否则它也返回false。同样假或 假是假的。否则，或总是
在实际讨论这些比较运算符之前 返回真值。让我们做吧
只需转到 Jupiter 并使用布尔 数据类型即可。只为只为
片刻。让我们将其转换为降价单元格 ，然后就哭了。这两个词都是布尔值
多变的。所以假设A是真的，B是真的 ，C是假的。错误的。好吧，所以这些
是变量。让我们按这些来看看它们 的状态。所以，a 是一个布尔变量
值为真 B 是值为真的布尔变量 C 是值为真的布尔变量
错误的。所以，现在是真的 B 是真的，C 是 假的。所以这意味着，让我打印打印一个
b，你怎么看？会是什么结果 ？让我打印一个看看是什么
将是结果。让我布伦特？ C 和 A。 所以因为 a 和 b 都是真的，第一个
结果会是真的，因为C是假的，假的 ，真的，真的是真的。另外两个声明
他们将导致错误。所以第一个值将是真 ，然后是假假。所以是的，真的，假的
错误的。让我们检查或打印。顺便 说一句，让我们将其存储在另一个
变量，假设 A 为真，或 C 为假 。所以你觉得结果会怎样
在这里，因为 or 当两者都为假时给 出假，这里为真。所以 d 的值将
是真实的
对于非a，因为a为真，非a必为假。 同样，不是B，B是真的。所以
不是B会是假的。不是 C，C 是真的，C 是 假的，而不是 C 会是真的。相似地，
不是 D，我们可以将结果保存在另一个变量 中，比如说 D。我们可以检查类型
D 如果我们想要，那是一个布尔值， 我们也可以检查 D 中的值，那就是
错误的。所以，是的，不仅如此，我的意思是，我们 可以我们可以我们可以我们可以在更高的水平上结合
例如，A 和 A 和 B，无论结果如何 ，或 C 或 D，无论结果如何
是，无论结果如何都不是。我的意思 是，我们可以将它们组合在一个非常
复杂的方式。如果我们想要 a 和 b 结果将 是一些布尔值，那个布尔值和那个
布尔那里
是
结果最终将是一个布尔值，然后没有 那个。所以让我们检查一下
结果是假的，好吧，为什么结果是 假的。找出为什么结果是假的，
让我去比较运算符。所以， 比较运算符，让我来看看
比较运算符。 this equal to it 比较两个变量是否
无论变量是什么，它们是否是整数 浮点数，无论如何，是否
两个变量是，它们是否具有相同 的数据，例如，x 等于两个 y。
如果 x 和 y，它们都具有相同的数据， 那将是正确的。例如，如果 X 有值
4，并且 y 的值为 4，那么我们只是 检查 x 是否等于购买或不购买，
结果将是布尔值。因为 X 可能不 是布尔变量 y 可能不是布尔变量
多变的。如果我们想比较 x 和 y 的 值，那么我们写 w 等于而不是
里面的一个空间。请记住，如果我们编写 单个相等，那将是一个赋值运算符。
如果我们写 w 相等，则意味着我们 正在检查两个值是否相同。相似地，
如果我们写这个特殊的符号来检查 两个值是否不相等，对于
例如，x 不等于 y，如果 x 以及为什么 它们都不同，则结果将为真
值，否则结果为假。记住 ，比较的结果总是
一个布尔值，它是真或假。好的， 接下来我们检查是否小于 So 例如，
如果 x 小于 y，则结果为真 。如果 x 的值确实小于
y，假设 x 是 2，y 是 10。在这种 情况下，结果将为真，否则
结果将是错误的。同样 ，我们可以使用大于
我们可以通过less比较两个变量 或者是否一个变量小于
或等于另一个。例如，如果 X 小于 或等于 y，则结果将为真
如果 X 的值不大于原因， 则此比较的结果将为真
只要 x 和 y 相等或 x 小于 y 无论如何，结果将为真
否则为假。同样，大于或等于。好 的，所以我在这里结束这个视频
下一个视频，我们将搬到木星 并与这些运营商一起玩，
并查看布尔值的返回类型。然后 将它们与 ands 组合在一起
ORS 并用它做有趣的事情。在这个 特别的视频中，我只是说说
关于比较运算符、布尔数据类型 以及通过和或不组合它们。
在下一个视频中，我们将首先移至 Jupiter，我们将看到比较运算符，
我们将在 Jupiter 中编写所有这些 语句，然后好好掌握它。
然后我们将继续进行诗歌。所以希望 在下一个视频中见到你。所以在最后
视频，我讲的是比较，w等于 不等于小于，大于，小于
大于或等于，大于或等于。所以 让我们去 Jupyter Notebook 看看如何
他们实际上工作。所以让我先输入一个 Markdown 单元格并输入比较。转移
输入比较。所以我们可以通过首先 将它们分配给不同的值来比较它们
变量。然后比较这些变量，或者 我们可以直接比较这些值
或例如，租金。二小于三。 你认为第二课是第三课，
result will be what 记住，比较运算符 的结果总是布尔值，它
是真的还是假的。所以在这种情况 下，二小于三。所以结果会
因为这个说法是正确的。所以结果将 是真实的，真实的将被计数。更远，
我们可以将结果存储在另一个变量 中，例如 to 小于三，无论
结果是，结果为真，结果将保存 在一个变量中，看看，如果
我们检查看到的类型
拒绝看到的类型，只要让我们打印 C 的值。这样你就可以看到类型
of C 是布尔值，在这种特殊情况下 ，C 为真。此外，例如，让我们
三等于四。这是真的还是 假的？你认为三等于四，
三、w等于四，即为假，三不 等于四。让我们保存这个
结果在 D 中，记住三个 double 等于 4，这是一个运算结果是
错误的。这个等于是一个赋值 运算符，假值将被分配给
变量 D. 在这里我们可以看到 Brent D. Burn 它是假的。同样，你怎么看？
三双等于3.0？结果会怎样？ 请记住，三是整数。 3.0 是
一个浮点数。我正在比较三个 double 等于 3.01 是整数，并且
另一个是浮点数。那么结果 会怎样呢？假设结果是
true，因为它们通过丢弃小 数位来比较值。更远，
让我们来看看。三小于或等于 所以假设 x 等于四，y 等于
九。 z 等于 8.3。并且 r 等于 负三，让我们说这些
是我们的变量。让我们来看看。那么 你认为这里 x 较小的结果是什么
比y。 x 小于 y 的结果 是什么，结果为真
z 小于 z 小于 y。结果 再次成立，因为越小
比 y 或 r r 是 r 等于例如 x。 所以你觉得结果会怎样
在这之后的最后，所以，让我们先 看看这将是真的，这将再次发生
真的，那是假的。好的。所以，这个 true and true 将返回 true and true 或任何东西，
结果最终结果为真。因此，这将 返回或返回 true。但是，如果
我只是如果我只是切换顺序，例如 ，如果我只是写这个语句，其中
是错误的，这里的这个特殊陈述然后 我这样做了，现在会是什么结果，
现在看，x 小于 y 是真的，r 等于 x 是假的。所以，这个结果
最终将是假的，并且 z 小于 y，结果是 z 小于 y，
让我说 z 大于 1，让我检查 z 是否大于 y，z 是否更大
比我只是为了告诉你而已。所以 ，这是真的，这是假的。这两个
让我让我切换让我切换 列表 r 等于 x，我只想
向您展示 r 和 x 小于 y 的先例。所以 现在，如果你看到这是假的，
这是真的，假的和真的是真的，真的 是假的，真的是假的，这也是假的。
结果总体上是错误的。它应该发生 ，但是如果，如果这首先发生呢，
如果先这样，我的意思是，我想告诉 你是否和 AR，他们中的哪一个会
先操作。所以，在这种特殊情况下， 结果是错误的，但它可能发生让
我让我告诉你更多和两个，或假和 真或假。和
真的，
你觉得这里的结果会是什么，是 真的还是假的，是真的还是假的
操作先操作，如果真或假操作 先，结果为真，真假，
结果是真的。但是，如果让我在这里 写一个假的话。如果所有操作
首先，如果所有的都先操作，那么false 或false就是false，false和true就是结果
最终是假的。如果和先操作，那么 false and true就是false，false or false
在这两种情况下的结果都是错误的。 所以，一种更好的方式来表示这些
有时有时他们会混淆，有时 他们会混淆，例如，
如果我们在这里有一个真，如果你在这里 有一个假，例如，假和真
我怎么会这样，假的，假的，假的还是真的。所以 ，在这种情况下，如果在这种情况下，如果假
or true那个操作 首先，结果 会是真假假假假真
结果最终会是假的。但是，如果 n 操作 First，结果将是 false
在这里， false 或 true 结果将是 true。所以 ，这里 if and apply if you apply if n
首先应用，然后结果整体结果 将是真实的。但如果全部应用
首先，那么总体结果将是错误的 。所以很高兴知道是否和将会
在这种特殊情况下首先应用或 关闭将首先应用并将应用
首先即使你即使你改变这个即使 你改变这个顺序，例如，
如果你即使你选择这个东西并在 这里申请，结果仍然并将被应用
首先或将在之后应用，这总是 好的，而不是一种方法是记住
先例，然后将首先应用，或者 ，我的意思是考虑先例是好的。
另一个好处是使用括号指定 顺序。例如，现在，我们指定
这首先我们将被应用，然后四个 并将被应用。所以，它有利于可读性
始终应用这些括号并 检查 ands 和 ORS 和
将应用组合。因此，无论 如何，这些比较的结果将
成为金条。问题，这里会有什么结果 ？所以，不至于不等于三且为真
或假与真。看一会儿这张幻灯片 。即使你想暂停视频，暂停
视频，看到了吗？并回答 Brent 将 返回 true 或 false。这个问题好
我结束这个视频。在这个特定的视频中， 我们刚刚看到了 Jupyter Notebook 上的比较。
看看比较如何返回真、真或 假。我们结合了不同的工具
以及使用 ands 和 ORS 的不同布尔值。 这里有一个问题要问你。好的，
我将在下一个视频中看到你回​​答 这个问题。所以我给你留下了一个问题
在最后一个视频中。所以这就是你 是否记得的问题。所以问题是，
这是什么结果？那么你的答案 是什么？对或错？结果，要么
将是 true 或 false，因为这些 都是布尔值的比较和组合。
所以让我们一步一步来看看。首先让 我们看看这两个不等于三个的结果
是二不等于三 是的，这是真的， 二不等于三 那是真的。所以
不是真的不是真的是假的。所以，这是错误的 。所以，这整件事都是假的。现在是假的和
真假真假。所以，直到这里的 整个事情都是假的。现在我们
have or or then we have false and true false and true is false. have or or then we have false and true false and true is false.所以，这整件事
是假的，这整件事都是假的，或者 介于假或假之间，它是假的。所以
这样做的结果。所以这个问题 的答案是错误的。让我让我说服
您可以在 Jupyter Notebook 中输入语句 。所以，如果你记得我们有布伦特。
布伦特，不是二不等于三然后 我们有我猜和假的，是的，
那是另一回事。真的，对不起， 那是真的。所以这是真的，然后
我们有我们的
然后我们有这些虚假和真实。所以 前端到这里，结果是哦，
我有一些我有一些括号不匹配。所以 不是真的，这没关系，我应该有这个
一个我想这去那里，这去那里 ，我想是的。所以结果是
错误的。结果是假的。这个问题 的目的不仅仅是为了这个目的
这个问题实际上是为了欣赏 我们如何组合不同的布尔值
值到以实现最终的布尔值 ，这些类型的组合将
在控制流程中变得非常非常有帮助 ，我们将看到 if 条件和
决策和东西所以这个问题的答案是 错误的。是的，我结束了这一切
视频在这里。在下一个视频中，我们 将看到 Python 的一些有用功能。和
看到一些有用的，有很多 功能后，我们会看到
只是其中一些非常有用。看到 这些功能之后，我们就会
直接跳转到控制流基本上是 if条件和你会看到的东西
这些比较，这些布尔值在更 适用的意义上，然后更早。
所以希望在下一个视频中见到你 。好的，让我们快速浏览一下
Python 中的一些有用函数。显然 ，Python中有很多函数，但是
我将只介绍其中的几个。我认为 随着时间的推移，我们会
覆盖越来越多但让我们开始一 个功能有时，特别是一个内置的
in function is 基本上是为用户 提供的语言的一个功能
来完成特定的任务。例如，围绕功能 。例如，如果你给圆，围绕，
让我们说 4.6。这个 4.6 是一个浮点数 ，四舍五入意味着把它变成整数。
而 round 的作用是找到最接近 4.6 的整数。和最接近的整数
这种情况是五，因为五更接近于 4.6， 然后是四。但是，如果你打电话，
例如，在四点上，假设是三， 那么结果将是四，因为四
比 5 更接近 4.3。所以这是八 轮的一种用途，基本上是轮
一个浮点数到最接近的整数。轮的 另一个用途是如果你给另一个
被称为函数的参数的参数 。例如，当你写
布伦特。 Brent，比方说a，这个a 被 称为函数Brent 的参数。同样，圆
是一个函数 4.6 是一个参数 round 是 函数 4.3 是一个参数，我们将看到函数
详细，我们也将编写我们自己 的函数。但现在，只是
请耐心等待，功能就 是这些可用的功能。
但是，我们稍后将编写自己的函数 。所以这个特定的函数接受
两个参数环绕有两种不同 的实现。一是当它接受
只有一个输入参数，它返回最接近的 整数，如果它接受一个浮点数
点数以及像这里这样的另一个参数 我们有三个，这意味着在之后
点，小数点后，只到三位，然后 向上舍入，然后舍入，例如，
这个 4.55 然后是 8 将根据它的下一 个值四舍五入。如果下一个值更大
比五，然后八会去九停止 。如果下一个值小于五，
然后它将保持为八，并且结果将 在此之后保留三位小数。所以
让我们在 Jupyter Notebook 上快速练习 此轮函数。让我们来看看。
所以我们来了。所以让我们看看租金 ，比方说 4.556。在这种情况下，结果
将是 4.5。原因是4.5。它被四舍五 入，它保持为 5 和原因
这是 4.556，它更接近 5 然后
比四个。但是，如果你只是打印圆形 ，四点，比方说 345。让我们看看，
结果将是因为 4.345 更接近 于 4。但是，如果您调用
这个圆形函数有多个参数，例如 4.556789 假设或有参数，
让我们这样做意味着结果应该 在小数点后只有两位小数
观点。所以在这种情况下，结果是 4.56。 原因是，这五个是基于四舍五入的
在下一个数字上并且下一个数字大于五 。因此它被四舍五入。所以 4.56
但是，如果我将这个函数称为 三个 那么你认为结果会是什么
它将是 4.55。六将在七的基础 上四舍五入，它会变成
4.557。是的。但是，例如，如果 在 7 的位置有一个值，
如果有一个值，比如说三个，那么你 调用这个函数，然后是 4.556。进而
根据下一个值三，六将保持 为六而不是九，并且
结果将是 4.556。是的，就是这样， 就是这样，这就是圆函数。基本上，
另一个函数是 diff 模式，diff 模式函数 基本上是除法并返回商，并且，
和余数。所以在下一个视频中，我们 将详细了解这种差异模式是如何
实际工作以及如何，如何有用。所以 在这个特定的视频中我们看到了
在下一个视频中，我们将看到 diff 模式，还有更多的功能
我们将在接下来的视频中看到。所以 希望在下一个视频中见到你。所以在
上一个视频，我们看到有时接受一个参数 有时接受一个参数的圆形函数
两个论点并相应地采取行动。在这个 特定的视频中，我们将看到另一个
功能开发模式。它接受两个参数，两 个不同的参数，但可能相同或
不同的论点。它返回两个输出 ，两个数字，两个术语
商和余数。例如，在这种特殊 情况下，商为 5，并且
余数是 2，因为如果 5 除以 如果 27 除以 5，结果是
五，但剩下的就是二。结果 以一种有序的形式返回
一对。这些有两个或更多元素 的集合，我们称之为
集合作为元组，我们将在看到 数据结构模块时详细介绍
本课程的。但是现在请耐心等待 它返回两个数字，两个元素，
并且这两个元素在有序对中 排序，称为元组。元组是
不只是一个有序的对，它可以有三个更多 的三个、四个、五个或七个，或者也许
几个要素。但是现在我们将元组 只是一个有序列表，我们将
详细看。那么让我们看看 Jupyter 中 的刚性模式函数的工作原理。笔记本。
让我们来看看。所以假设我们有开发 模式。比方说，我们有 34 个。然后
我们有很多。或者让我们说 九，那么你认为商数是多少
剩下的会是什么。所以 918 27 所以三，三是商。而剩下的
余数是七。所以三是商，鲑鱼 是余数。所以如果你
保存结果，例如，如果你将结果保存 在一个变量中，让我们说 G。所以
如果你看到 G 的类型 G 如果你只是 输入类型 如果你只是找到
ci 的类型它是一个元组，我们 将详细了解它，如果您看到
G如果你看到G的内容gr三和 鲑鱼的内容，如果你想
独立访问每个元素，然后您可以 访问该元素的第一个元素，因为
如果一个变量中有多个 元素通常是那种变量
被称为集合，我们将在后面 详细介绍。这些是索引
定位从零开始，而不是从一开始 。所以 g 零表示的第一个元素
G 在这种情况下是三，G 的第二 个元素是一
一，即七。所以，这基本上 就是所谓的索引或位置
这个特定集合中的元素或数据，我们 将看到这些索引和所有这些类型
在数据结构分数中详细收集 集合，我们将看到数组
和应变和不同种类的结构。但是 ，默认有时是，基本上是
有时它是有帮助的。顺便说一句，您 可以通过另一个人实现开发模式
事物。例如，如果你想达到更多的 34 个 9，你可以做同样的事情
比方说 34 除以双除以 9 会给你一个商。和
问题是三个，如果你写 34， 剩下的九个，那会给你
您需要的剩余部分。所以你可以调用该 函数 Dave 模式。或者你可以使用这些
两个有多种方法可以做同样的事情。好的？ 所以，是的，所以，我的意思是，有时
当您要了解这种返回商 的函数时，它很有用
和余数。好的，下一个更有用 的函数是 stance，我们会看到
这个功能在下一个视频中。所以希望 在下一个视频中见到你 好吧，这个
函数在 stance 中，它实际上返回 true 或 false。它只是检查
特定的给定数据值是否属于这 种类型。例如，如果您想检查
是否有整数类型，所以，你可以 顺便检查一下使用这个函数，
你知道一个是整数类型，那么 你可能会想为什么一个人应该
有兴趣检查一个人的类型， 如果有人不是老师，有时，
我们有某些变量，某些数据 存储在其中，我们想检查
它里面的数据属于哪种类型， 在某些情况下是这个变量的值
不是由我们分配的 它可能是从某个文件 中读取的，也可能是通过用户提供的输入
一些数字或类似的东西。因此， 有时检查类型变得很重要
如果我们期待特定类型 的输入和输入
与此功能不同可能会有所帮助。某处。 无论哪种方式，这是一个函数
在 Python 中可用，它检查给定 的值是否具有特定类型的 not。
所以实例一 int 返回 true 是实例 1.0 可能返回 false 的整数，因为
这是一个浮点数，你可以 检查一个特定的值属于
无论是否为多种类型，您都可以在元组 中给出多种类型。你可以检查
不管它是否属于这个，这个。所以， 让我们去 Jupyter Notebook 看看，实际上
这个怎么运作。所以，顺便说一下，这 就是我们所拥有的、我们正在填充的笔记本。
所以，等一下，在一天结束时，我们 将完成一个笔记本。所以，
立场是实例，假设三个 是整数的实例结果是
在这种特殊情况下为真，例如，如果 我们检查立场 3.4 中的是否为
nmt？那是最终用户吗？答案是否定的 ，它不会以 Deezer 结束。例如，如果
我们检查这是否不是性质，那么也许它是 一个浮动？答案是肯定的。或者可能
我们检查一下。例如，如果该值是 浮点数或整数，如果它是以下之一
这些，那么我的意思是检查这个特定 情况下的特定值 3.4 它是否属于
例如，对于这些类型之一，我们可以 增加这些类型。所以，假设我们给了
这里是一个复数并检查是在立场上 让我们说二加三 j 这是一个复数
数字。假设我们问它是 整数还是浮点数，结果
显然是假的。原因是，它既不是整数 也不是浮点数，或者即使我们
给字符串 str，所以，它仍然会说不 ，它不是
不是其中任何一个，但如果你看到它，也许有 一个复杂的数据类型，那就是，是的，
因为它很复杂。所以有时这个实例 变得非常有用。下一个函数
是权力。因此，您可以通过使用 的方式计算功率，例如，
如果你想计算 x 的 y 次方 ，你可以使用双星并计算
正好 x 升到 y 次方，或者等效地， 您可以调用函数 POW x 逗号 y 和
这将为您提供与此相同的结果 。但权力有时需要三个参数
以及。在这种情况下，它以 不同的行为执行幂函数。
因此，例如，如果您提供三个参数 ，它会提高 y 以等于 x raise
无论结果是什么，它的幂 BI， 然后它取 z 的余数并给出
结果。那么让我们看看这个幂函数在 Jupyter Notebook 中的作用。那么让我们
说 Baba，我想计算结果的 乘方是 16。没问题。到
提高到 4 次方，我也可以这样 计算结果 16。但这里是另一个
方式，无论结果如何，我们如何使用 它来提升功率，那么我想
取余数，比方说，我想将余数 减去七或二，所以我们已经
得到 4 是 16，那么如果我们将余数 除以 7，结果将是 2。那就是
结果二。这就是您如何使用此 幂函数的方法。我只是介绍
你有一些可用的内置功能 ，有很多可用的功能，
我只是让您对这些功能感到 满意，以便将来如果您
看到他在这里没有看到的另一个 功能，您将能够使用它并应用它。
所以在这个特定的视频中，我们 看到了站立函数和幂函数。
在下一个视频中，我们将看到 另一个功能，它允许您从
用户。到目前为止，我们都是直接 为变量提供值或赋值，如果在
飞，我们想给出值，这些 值应该分配给变量。
所以在下一个视频中，我们将看到该 功能，我们将看到一个允许您
从键盘输入，希望在下一个视频中见到 你。所以在这个视频中，我们
将看到一个非常重要的函数，称为 输入。这个功能是我的意思，这个
有利于从用户的键盘获取输入 。以及调用这个函数的方式
你是输入法吗？然后输入一条 实际描述预期条目的消息
例如，如果你想要某人或 告诉某人只是招致某事
比方说，一个数字，你可以写成一 个数字，或者任何规范来帮助用户
输入用户想要正确感兴趣的任何 输入。一件事是不管怎样
用户将输入，变量 a 的类型为 字符串 str。所以即使你输入
一个数字，比方说 12 或 34 或其他数字 ，它将作为字符串接收。进而
如果确实是数字，则有多种方法可以 将字符串转换为数字。所以无论你
使用输入函数接收将是一个字符串 。然后有办法解决这个问题
字符串，如果是数字，如何将该字符串 转换为数字，等等。所以
例如，让我们看看，在 Jupyter Notebook 上看看它 是如何工作的。所以让我们看看，对于
例如，x 等于输入，输入一个数字。让 我们来看看。然后如果我按 Shift
回车，你面前会出现一个提示 ，要求你输入一个数字
例如，如果我输入，比方说 56，然后我 按 Enter，而不是 Shift Enter，Enter，然后
x 将得到 56。现在，你可能认为这个 56 是一个整数，所以 x 的类型应该
是一个整数。但这不是 x 的类型 将是字符串的情况。和原因
是，您输入的任何内容都会作为字符 5 和 6 接收，即使您输入了某些内容
否则将作为字符序列接收 。所以这不再是五
作为数字五，六作为数字六。 这些是一些字符的字符序列。
现在，如果你愿意，
我的意思是，有一些方法可以转换这个 x，例如，也许你想要，比方说，y
或 x 作为 int x。所以这意味着您现在 已将此字符串转换为整数，然后
无论结果如何，如果 您现在看到类型
x 类型的 x，结果是整数。例如 ，您可以打印 x 减 34。并且
结果是 22。因为 X 是 X 是 56。所以这个 输入函数是我的意思，它是一个
顺便说一句，如果您期望整数 或浮点值，例如，
假设你期望一个浮点值，那么 写输入是很好的，让我们说
输入一个实数，可能或任何消息， 任何消息，然后在这个特定的时间
在导入的时候，那么把那个东西 转成float就可以了，它会变成
一个浮动。是的，就是这样。因此，现在，例如 ，如果您看到现在的类型，则输入 12.5，
a 的类型将是浮动的。但是有问题 ，例如，如果你是，如果你是
期待浮动并且有人进入了不浮动的 东西，例如，或者让我们
说 B 等于负载，输入 Enter 是实数 ，假设然后按 Shift Enter 和
有人只是感兴趣，让我们说 ABC。 所以，现在，这不是浮点 ABC 不能转换
无论如何都是实数。所以，你会发现 一个错误，有办法避免这些
使用异常处理的各种错误和 编程程序中断，还有其他
方法，但要小心我的意思是 用户不是我的意思是要进入
如果该用户没有受到足够的限制，请输入输入，那么您 可能会收到错误消息。所以，我的意思是，
情况并非如此，您将输入的任何 内容都将转换为浮点数，如果它
真的，如果你输入的任何东西真的 要转换它真的可以转换为浮点数
然后它可以转换为浮点数， 否则不能。而在输入时，有
没有限制，您不能限制键盘进入水 或诸如此类的东西，尽管有
是方法虽然有办法做到这一点。 这就是输入函数。所以，我们
已经看到了一些功能，让我让 我快速浏览一下我们看到的
我们见过的输入是在支架上，我们见 过差异模式，我们还没有见过幂函数，
我们已经看到了 round 函数，还有其他 几个。是的，所以从现在开始，我们
实际上将朝着基本基于决策的 方向发展，有时我们会使用
这些类型的函数，大多数情况下你 会使用输入函数，但有时我们会
可能正在使用其他功能，例如 这些功能。有时我们会做
基于轻松性和诸如此类的东西做出 决策，我想告诉你的一件事
例如，如果您知道函数名称 ，某些函数，例如功率，
你知道，POW 的力量是一个函数，但 你不知道如何使用那个函数。
一种方法是在它前面输入问号 ，然后按 Shift Enter，
在你面前，力量的文件会 打开，所以它会告诉你
这就是力量，这就是它应该被调用 的方式，然后一些描述将在前面
相当于 x 的 y 次幂， 没有参数，两个参数
等价于 x 的 y 次幂余数，z 带有三个参数，并且
依此类推，如果您还想查看此 功能的实现。我们将看到功能
稍后，但如果您想查看有关帮助的 更多信息，可以键入 double Sam equal
一个双重问号，更多的事情应该在 你面前展开。所以，在这个特殊的
在这种情况下，小函数在 Python 中没有实现。所以，唯一的问题
标记和双问号相同的另一 种方法是使用帮助功能
提供帮助，您将获得大量有关 电源的信息，例如，帮助构建
和内置模块中的功能电源。 所以 这是电源这相当于这个一些
键类型和诸如此类的东西，或者例如 ，您想知道我如何使用输入功能
例如，您可以编写有关输入的帮助 ，这就是如何使用它。所以有时候
如果您知道某个函数的 名称，并且您知道如何
使用它，您可以直接在 Jupyter Notebook 中打开文档，方法是使用
一个帮助功能，或者您可以只在名称 前面使用一个问号等等。所以那是
关于功能。在下一个视频中 ，我们将看到比较的力量和
决策或有时称为控制流 。所以真正的乐趣将从
下一个视频，因为我们将实际 决定应该运行代码的哪一部分
以及基于某些条件不应运行 的部分。所以希望见到你
在下一个视频中。好的，我们在控制 流中，这是任何编程中最有趣的部分
语言将假设您有两个数字，您从 用户 a 处获取了两个数字，
您已经使用输入从用户那里获取了 该号码，但我没有提供输入消息
在这里，消息是可选的。这是一个描述， 如果你提供那没关系，如果你不提供
即便如此，也没关系。所以 A 是用户 将在代码中提供的某个数字
will run B 是用户将在代码运行时提供 的某个数字。现在，一旦你有
a 和 b 在你面前，显然用户 会即时提供，你不知道
a 和 b 的值是什么。因为当程序 运行时，只有在那个时候，
A 将被填充，B 将被填充。 你的任务是 a 的值是什么
是你不知道 b 的值是 你不知道，用户会
提供这些值的值，您 的任务是打印大于
两个都。例如，如果 a 大于 B， 则打印 a 如果 b 大于 a，则
打印 B. 所以无论更大的值是多少， 打印那个值。假设这是你的任务。
你怎么能这样做？所以问题是 Python 如何允许我们 Python 允许我们
要做到这一点，例如，如果 a 大于我们 应该打印 a，如果 b 大于我们
应该打印 B，再次记住，我们 再次讨论的是，如果 A 是
更大，如果是这样的话 这是这样 如果 a 比 B 大，那么这个条件
会是真的。这就像比较。所以这 是真的，但是我们必须有一个
F条件也一样。如果A比什么大 ，那么如果a比B大，那么做某些
事物。否则，不要这样做。那种东西 。所以这个 if 条件真的是，
非常强大，适用于所有编程语言。 在这里，例如，让我们看看
如果 a 是输入 B 是输入，写一个 if 条件 ，那就是 if 是一个关键字。那是
我们之前也做过一个比较 。然后语法需要一个冒号
在那之前。所以如果这个条件为真 ，如果这个结果，如果这个比较结果
记住比较，他们返回布尔值，如果 这个比较，如果这个，不管
这个操作的结果是如果这是真的 ，那么你进入这个块。随便
里面的语句是do that，例如 print b大于a。
现在我的问题是，这已经完成了 吗？我们完成任务了吗，任务是
打印更大的数字。如果 b 大于 a， 那么 B 将被打印或者他们可能
已经打印过，例如，我们可能已经 打印而不是写了我们可能有的
已经打印，假设只打印 B 因为 b 更大。如果 b 不大于 a，什么
将要？我们会怎么做。是的。如果 b 大于 a 那么 B 将被打印？是的。
因为那样你就会在里面。 如果 b 不大于此条件为假。
那我们会怎么做？所以这是一个问题。 所以现在我只是在 Jupyter 中编写代码。
笔记本。然后我们将看到如果 b 不大于 a 类，我们将如何处理
条件？那么我们先来看看if条件和 Jupyter Notebook的加持。是的，
所以让我们说 a 是一个整数。假设您期待 一个整数输入。输入，让我们说
然后你写如果，假设 B 又是一个整数 输入，也许。让我们说如果一个
大于 b，则打印 a。就是这样。那 是你的程序。记住，这个缩进，
我没有在这里写过这张照片 。这是定义块的缩进
a 比方说如果我想打印 a，那么我想打印 ，比方说，我还在里面。如果
条件，条件等等，无论从这个 开始，无论从哪个开始 Form
无论从这个对齐开始，如果我 在这里写一些东西，假设 x 是
等于五，所有那个块所有那个块 被称为 if 条件的主体，如果
它从这个对齐开始，但是，如果我输入 了一个语句，但是我输入了那个语句
在那种对齐方式中，像这样的对齐 方式，这不再在if条件之内。
因此，例如，在这里我输入 I am 在 if 条件之外。所以，写作的目的
这些多行只是 if 条件 不需要只包含一行
代码，它可以包含一个完整的代码 块多行代码。所以，这不再是
在 if 条件中。所以，现在我们将输入 一个输入 B，无论数字是什么
是，如果 a 中的值将大于 B， 那么这将被打印，这将
被打印。一旦打印了这两个， 那么无论值如何都必须打印
a和b，因为这不是最后一个 sprint语句，所以不依赖。
这不依赖于 a 和 b 的值， 它具有 if 条件没有影响
关于这一点，这只是一系列的陈述 。 if 条件，里面的语句
如果只是这两个。例如，如果 a 不大于 B，那么这也不会
执行，也不会执行。但这仍然 会执行，因为这是什么都没有
与条件有关。所以让我们运行这段代码， 看看它是如何工作的。所以让我们设置
值一见描述的力量。如果我们 可以写一个描述，那么
描述本来可以出现在这里 。但让我们说这是价值
的 a 比方说 12。 b 的值比方说，比方 说 10。在这种特殊情况下，因为
b 的值是 10，如果这个条件成立 ，a 的值是 1212 大于 B，
这个说法成立。每当此 条件成立时，您就在
打印您在 if 条件内。现在这个 打印执行，你会好起来的
这个打印执行，你得到我仍然 在 if 条件中，这必须执行
不管 NBR 的值是多少，现在让 我阅读一下并给出其他值
b 假设 a 的值为 10。假设 b 的值为 45。现在，这个
这个条件会不会因为 10 大于 45 而 变为假呢？这不是真的，这
是假的。所以每当这个条件为假时 ，你永远不会进入 if 条件
然后你从 if 条件中退出。所以 这些是 if 中的语句
健康）状况
它们无法执行，因为你从不访问 它们，它们只能在条件下执行
变成真的。那么一旦你退出 if 条件，那就是语句
无论如何都会被处决。所以是 的，这就是查看 if 条件的味道
这是返回布尔值的比较 运算符。你可能有
此处进行不同类型的比较或此处进行比较 的组合 不，没问题，具体取决于
根据你的逻辑。但问题是，我们 完成了吗，我们将只打印更大的
我们有数字，我们已经打印了一个如果 a 更大的数字，我们已经打印了
如果 b 更大，我们还没有解决这个 任务。这是我们还没有解决的任务
任务呢。那么如何去做。好的。所以是 的，它看起来很复杂。如何只打印
那个更大的数字。所以如果 b 大于 a， 那么我们将打印 B。 也许也许
我们应该使也许我们应该应用另一 个 if 条件。如果 b 大于 a 则打印
B. 如果 A 比 B 大，那么打印八，也许。是 的，为什么不呢？所以
嗯，
例如，让我们转到 Jupyter Notebook 并编写以下内容。让我让我
在这里编写一个全新的程序。 A 等于 和导入。好吧，让我们不要留言
并输入然后如果A大于B，则打印 a。好的。但是，如果 B 更大
然后打印B，我想我们已经完成了 。如果这个条件成立，那么我们是
在这里，我们知道如果这个条件 成立，那么这个条件就不能成立，
因为它不可能在那里发生，因为 那么 B 和 B 都比 a 这更大
不可能发生。所以，无论更大的数字 是什么，你都会进一步执行
可以看到我有这个 if 条件和这个 if 条件，它们以某种方式对齐
this if 条件不是 this 第二个 if 条件不在第一个的主体内
如果有条件，我们会在需要时 看到这种情况。但是现在，
我想我们已经完成了。如果A大于 B，则打印a，如果b大于a则打印
B 并且只有其中一个条件 成立，因为 A 大于 B B
大于a，这两个陈述不能同时为真 。所以，让我们看看。所以
A 是 10，b 是 45。所以答案是 45。好吧， 因为 45 更大。所以让我们再次运行它。
所以 A 是 22。b 是 4，结果 是 22。因为 32 更大，
我想我们已经完成了任务，我们 已经使用了两次 if 条件来实现
打印更大的数字和两个数字的 任务我们同时取了两个数字
从键盘 是的，我在这里结束这个视频。 在下一个视频中，我会告诉你更多
这个 if 条件的特征特别是 L 语句，无论我们做了什么
最近与另一个 if 可以通过 更强大的 L 语句实现
并且更具可读性。所以在下一个视频 中，我将讨论 ELS 声明，这是一部分
F 所以希望在下一个视频中见到你。好 的，在上一个视频中，我们看到了条件
我们实际上有一个例子， 我们想知道我们只想打印
更大的数字。所以我们输入一个数字 a 我们输入一个数字 B 如果 b 大于
a 我们打印了大于 8，然后我们应用 了另一个 if 条件来检查是否
a 大于 b，然后绘制一个 else 子句或 f 的 else 部分与
顾名思义，如果此条件为真。所以 ，如果这个条件为真，这个特殊的
条件为真，然后去那里。如果这不是 真的，这意味着 else 如果这是真的，
然后去那里，否则去那里。所以如果这是真的 ，那么你在这里学到了，如果这是假的，
那么你肯定会学到其他部分。这就 是我的意思，如果 b 大于 a if
这个条件是真的，然后你打印这个 东西。否则，a 可能大于
B 或 A 可能等于 b 无论你在其他部分 学习的方式。所以这如果和否则他们
两者都有这种对齐方式，但是随后 ELL 块从这个特定的对齐方式开始，
也许你在这里有更多的陈述，这个 if 块结构的对齐方式，以及
你可能在这里有更多的陈述。所以 让我们去 Jupyter Notebook 看看 else
跑步。所以让我们说一个等于和输入和 B 是
B 是 int 输入，我们说好的，如果 a 大于 b，则标记 a
else else 租金 else 品牌在别处超出 B. 现在 B 将被打印，即使它是相等的
到 A 或者如果它大于任何一种方式，B 将被打印。所以让我们看看。让我们
只需运行它，看看会发生什么。所以Shift Enter。 所以输入一个数字。所以A是让我们说
10，而 B 是让我们说，12。那么当 我按下回车键时你觉得会是什么
打印，B或A，B，B打印，这就是B打印的内容 。现在，如果我再次运行它，并且
a 完成，B 完成，仍然会打印 10。所以 让我们修改它，让我们，让我们
只是说，打印。如果部分。所以这意味着 我们进入了 if 部分。否则，我们降落在
埃尔斯伯格。所以更详细地说，让我们 说 10 和 10。我们降落在 L 运动中。
原因是如果a大于b， 那么10大于b 10大于
10. 错误。所以你有两个 L 和 LS 块，整个块刚刚执行。所以那是
还有什么是，无论何时，拥有 L 状态 或其他任何东西真的非常好，
如果这是假的，不管那个条件是什么， 如果那是假的，那么你在 else 中学习。
所以是的，这就是现在的健康部分，好吧 。所以，我们有这个 f l 结构，我们可以
用这个 F 多一个幂，如果我们想要怎么 办，如果 a 如果 b 大于 a，那么你
打印 B。否则，如果 A 等于 b，则 打印它们相等。如果这是假的，
并且这个条件是假的，如果这两 个条件都是假的，那么你去 else
部分。所以基本上, if else if else if else, if else, so, 你可以有很深的结构
例如，在这个特定的例子中，如果 b 大于 a，那么你在这个
部分 else，如果这个 L 只是 else 的 简写形式，else 表示 B 不大于 else，
你可以再次检查 elsif A 等于 b， 然后做什么？
升
l，如果我们可以多一张支票，我们可以 多一张支票，我们可以多张支票，
然后 else else 只会在所有 if 条件或 elsif 部分位于顶部时执行。他们的
条件，它们是假的，只有这样 else 才 会被执行。所以让我们看看这些 l
在 Jupyter 上运行的差异。笔记本。好的， 所以让我们说 a is and so 而不是接受输入，
让我们说是一，B 是让我们说五。假设我们 已经采取了这些输入是一个 B 是
五、如果A是if a等于b，那么rent 这个词就等于l l F，即else if
现在，因为这是如果你必须 在这里写一个条件，要么
对或错。如果 A 大于 B，那么怎么 办？然后打印，比方说，a。另外，
假设你的大脑没事。就是这样了。 而这个声明，租金不在 if 条件下
不，不 in 如果这是外部完整的， 如果条件及其所有 L 是完整的
和 LDAP 部分，这里面不再赘述。所以 让我们运行这个。你觉得什么
如果 A 是 1 B 是 5，则结果是 ，否则 bar 将运行，因为 A
不等于 B，A 等于 b 是假 的大于 B 也是假的。
所以你会在 export 中学习，然后 打印 B 然后打印一条语句
这不是 F。所以是的，所以打印的是 B 而 不是 F。如果 b 是 10，那么会发生什么？
A 等于 B 是假的，所以你不会在这里着陆 。否则，如果 A 大于 B，则为真。
你会在这里着陆，因为你在这里着陆， 否则不会执行。所以他会被打印出来
然后还不够。如果 A 是 10 并且 b 也被 禁止，比方说，那么你有平等。是的，
所以这就是 elsif。好的，这就是 if else if else if 或短形式是 lf l 结构。
在下一个视频中，我们将更多 地讨论这个 if else if else 结构
再详细一点。我们还将为您提供 这份 ELL 指南的简短形式
if elsif elberfeld 的结构。所以希望在下 一个视频中见到你。好的，一种方式
写这个，如果 elsif else 类型的结构 也有一个简短的形式，写成
例如，在这个绿色的地方。这与 我们在 中看到的代码相同
最后一个视频，但那是简短的形式 ，假设 a 等于 9，B 等于 10，然后
如果 A 大于 B，则打印 a，否则打印 这个特定的东西，如果 A 等于 b，
l sprint 认为这是完全相同的一种 结构，例如，打印 a，如果 A 是
大于 B，所以你只是读到如果 a 大于 B，然后打印一个 else if A is
等于 b，然后打印相等，否则打印那个 。所以这是一种简短的写作形式
这种 if Elif else 结构。但我 会，我会推荐使用，我在
这种特殊的水平形式的结构 。而不是写在这个特定的
道路。因为这种结构，那 种横向的结构要多得多
可读，更易于管理。这可能是 这个结构可能会混淆一些
是时候给某种读者了，或者 ，如果这种结构继续下去，
上，我们将在今天的示例 中看到。写的很深很长
简短形式的结构不太可行。所以虽然 但是但是这个功能是存在的
如果您喜欢以这种方式编写 if elsif else 类型的结构，则可以在
Python。好的，让我们在 Jupyter 上 好好掌握这个 f LS f l 结构。笔记本。
让我们继续讨论 Jupyter Notebook。看一个 例子，只是一个例子。所以让我们说
这个例子是用户将输入一个数字，假设 是 int 输入，假设是输入标记，
假设输入特定主题的标记，假设 用户输入一些标记。
我们的目标是如果分数大于 85，那么 我们将打印一个等级。如果标记
大于大于 80，但小于小于 80， 所以如果标记大于等于
到 85，然后我们将打印一个等级。否则 ，如果标记大于等于 80，但小于
大于 85，那么我们将打印一个 减号。如果如果标记大于大于
等于 75，但小于 80，我们将 绘制我们将打印例如，b 级为
例如，b 级，等等，让我们打印这个 让我们制作的整个嵌套结构
这个别的。 if else if elsif 那种 结构有点空，让我们舒服点
用它。所以如果a大于或等于 85以增强可读性，最好包括
空格是变量和空格之后的空格 ，但实际上不要在里面写空格
那里因为更大和等于没有空格的组合 是一个运算符。所以如果 a 更大
大于 85，然后打印让我们说等级率 l 如果 A 大于或等于 D 并且
E 小于 85。所以让我以更易读的 形式来写这个。否则如果 A 是
小于 85 且大于或等于 80 那么 我们有时应该这样做
很好地包含这些括号有时 只是制作这些东西很好
更具可读性，这是一个块。这是一 个这是一个布尔值 这是一个布尔值
这是一个看，这个字体 是E，虽然不写括号也是
好的。但是写括号会使代码更 具可读性。所以，例如，如果
a 小于 85 且 a 大于 80，如果这 是真的，那么，记住并且是真的
只有当左侧为真而右侧 都为真时，则整个条件
变成真的。我向你保证，我会 向你展示比较的力量，实际上
使用 ands 和 ORS 以及诸如此类的东西 组合布尔变量。所以你来了
看到一个。在这种情况下，让我们说品牌。让 我们说一个二进制喷洒和 Elif 如果他
是如果他小于如果他小于 80。 并且 a 大于或等于 75。如果
既然如此，那我们该怎么办呢？ 让我省略括号只是为了表明
无论写括号还是不写括号 都可以。我只是推荐
右括号，因此代码变得比其他方式 更具可读性。好的，那我们
有布伦特，比方说，b 级。让我们 再说一个 lF lF。如果 A 小于 75。
并且 a 大于或等于让我们说
70.samedi，然后布伦特 b 减去等级，让我们 说。让我们完成这个让我们其他
打印。以下。例如，平均而言，假设就是 这样，那是我们的，这就是我们的记录。
所以，我们将我们将输入数字，如果 数字大于 85，那么一个等级，如果，
当此条件为真时，将执行 此打印。我们将走出
结构就在那里。如果此条件 为假，则将检查此条件。
如果此条件为真，则将执行 此打印。我们将离开
这种结构。如果这是假的，并且这 是假的，那么这将被检查。如果这
是真的，然后我们打印降级，我们就 出局了。但如果这是假的，那么这将
被检查。如果这是真的，那么我们将 打印 b 减级。我们会出去的。如果
这也是错误的，然后我们将深入到 L 运动 ，我们会说好的，低于平均水平。
因此，让我们看看，例如，假设标记 为 2。所以减分。那个那个那个
这是有道理的，一个负分， 因为分数小于 85 并且大于
大于或等于 80。所以减分。让我们， 让我们再次运行它。我们可以说
分数比平均水平低 64 分。好的，太好了。 所以你看到这个 if Elif, Elif Elif else this
可以随心所欲，具体取决于您的 逻辑。很好。更进一步，你可以
结合几个比较几十亿，加上 ands和ORS，和nots，不管
你喜欢做什么就做什么。让我 再给你一件或一件更美的事。
让我们创建一个 L 而不写 else 或者让我们只写
lF 并完全实现 ELS，所以我们 不会明确地编写 ELS，但我们
将要编写一个实际模拟 ELS 的程序 所以 让我们看看，如果 a 等于让我们
说，三个。如果 A 大于 10，那么 Brent 比这更大。现在，我们不是
打算写别的，但我们要实现航空 运动。
告诉如果
不是，
a 大于 10。看，然后打印你看，我 的意思是，这很漂亮。如果这
条件为真，然后去那里。如果这个 条件是假的，那么没有假是
真的，那么你在这里学习。如果你 想要我已经实现了，你不需要写一个专家
我已经使用 l f 实现了 l spark。所以看到了 。所以我火花，所以我们现在是火花。
如果 A 是 13，那么我们会认为还好，而不 只是为了好玩，只是为了好玩，好吧。
好的，太好了。所以，我们看到如果 条件它是速记和 LDAP 结构在更多一点，
漫长的道路。所以在下一 个视频中，我们将看到
另一个 if 条件，称为嵌套 F。所以 希望在下一个视频中见到您。
在上一个视频中我们看到了 if 结构， 在这个特定的视频中，我们将看到嵌套
F，或者在另一个 F 的主体内被简单 地调用。 所以让我们举个例子
理解嵌套 if 条件是什么我们可以 理解 if 条件在另一个内部
如果条件成立，那么故事的其余部分 都是相同的。它的工作方式，即使
实际上，它在另一个人的身体内，如果 或或在任何地方。所以假设我们有输入
一个数字，然后我们检查 x 是否 大于 10，然后您进入 if 条件。
如果这是真的。如果那是假的，那么你在 这里，无论你在这里写什么，它都会
从这里开始工作。但是假设 x 大于 10，那么您打印的数字更大
比 10，你的数字在 10 以上。假设让我们 看看布伦特，在这之后，之后
这个语句，你移动到这个语句， 然后你再做一次检查 x 是否更大
比 20. 现在你看到这个 if 条件。这个 特别的陈述在这个特别的里面
如果条件，如果这个，这个条件 才成立，然后你潜入，否则你
不是。所以在这里你要检查 x 是否 大于 10，然后你在里面和里面移动
做更多的检查。例如，如果 x 大于 10，那么你打印或做一些
这里的东西，然后你应用更多， 更多检查更多渐进性，无论你
逻辑是。所以让我们在这里说你正在检查 x 是否大于 20。 现在，如果这个条件
是真的，那么你移到这里 else now this else is of this if 如果 x 不大于
20，然后你移动到这个 else l 蹲下，你就 在这里。所以我们可以有另一个如果
在这个特定的 F 或在这个 L 运动中的 F 等等。所以如果在 F 内部被调用
嵌套如果，我们可以让我的意思是深层结构 ，例如，如果那么某事那么如果那么
如果是这样的话，如果嵌套 if 结构取决于 ，也许我们可以有一个非常冗长的结构
在逻辑上。所以让我们让自己舒服点。一如既往 ，通过在 Jupyter 上编写代码
笔记本，因为这更有意义。当我们 看到在笔记本上运行的东西时。
所以让我们说 a 是让我们再说一遍， 假设我们取一些数字，如果 a 更大
大于 10，然后我们说好的，布伦特，大于 10 并做更多的事情，布伦特。那是里面。
如果条件好，那么也许我们再 检查一次 A 是否大于 20 那么
说租金大于 20 是的，大于 20。你可以租
现在租里面嵌套如果，好吧。 else 租 l sprint，小于等于 20，更小
等于 20。然后品牌，例如，在嵌套 的 L 火花内，如果是这样，
你可以在这里打印，品牌外面一切 都很好。所以就是这样就是那样
结构。所以让我们看看，让我们给出 一个大于，顺便说一下，如果
输入不大于10，这个如果条件为 假，那么你直接跳到这个打印
语句，所有这些结构都不会被 执行，这就是完整的东西
被称为此 if 条件的主体，并且 主体仅在满足条件时才会执行
变为真，无论该条件只是 一个条件，还是您有组合
很多比较和很多布尔值， 如果这个条件成立，
无论该条件以何种形式出现，然后， 只有这样您才能深入到这一部分。
当你在这个部分时，那就是一个 全新的宇宙，然后你就靠自己了
在新的部分，在新的部分，例如， 如果这个条件成立，那么你是
在这一部分，这是这个特定 if 条件 的主体，那是 else 的主体
部分，如果条件有这种对齐方式 ，请查看顶部的主体，所有语句
在 if 条件的主体中，它们开始 相同的对齐方式，并且所有条件
在这个特定 if 条件的主体中 的所有语句，它们都有自己的
自己的对齐方式，这个缩进是必要的， 只是为了定义，例如，哪个语句
例如，在什么样的块中，如果我只是按一 个选项卡，然后按另一个选项卡，那么这个
打印语句在这个 L 运动 中，这是定义位置的缩进
这张印刷品，例如，如果我按下我将 它与这个对齐，这个特殊的结构
在这里，那么这个打印语句在 这个 if 条件中，这是缩进
即定义不同语句的位置。 如果打印从这里开始，
那么它完全在所有 if 条件之外 。所以让我们运行这个板
看看会发生什么。比方说我们打品牌比方 说我们刚刚哭了 比方说 12。所以，
你认为应该打印什么，如果 A 是 12 那么首先这个条件
是真的。所以大于 10 将被打印 在顶部如果要打印，那么
将执行此检查并且此条件将 变为假，因为 12 不大于
小于 20 那么你将转到 else 部分并且 小于或等于 20 这个数字这个字符串
将被打印，然后在嵌套 if 的 else 部分内被打印，然后
如果条件然后在将打印的所有 F 之外， 您将被排除在外。那么让我们
看看我们说的对不对。所以 是的，里面大于 10
如果在所有 F 之外的嵌套 f 的 else 部分内小于或等于 20，则为 top
是的。这就是嵌套 F 的含义。顺便 说一句，你可以拥有你可以拥有的
例如，嵌套 ifs 中的更多 if 条件 ，例如，您可以多一个条件
在这里，例如，如果 A 大于 30， 那么执行然后打印它大于
30 也是。而对于品牌来说，也许不 一定你总是写印刷声明你
可以做任何有趣的事情
在嵌套 if 的嵌套 if 里面找到然后 你可以写这个的 else 部分
特别是如果您愿意或我的意思 是这里的条件，您可以很有趣
你想要的结构，但这完全取决于 逻辑，或者你可能有一个
例如，如果条件在那个 l 点这里，你可以 在这里写一个 if 条件，如果有的话
那也是，那也完全没问题。所以 ，如果 a 大于 20，那么你打印
this 如果 A 大于 30，那么 this， 例如，直接写 else 部分
否则，打印小于或等于 30。 我们可以在嵌套里面打印
嵌套 if 的所有嵌套 if 的 else，好吧， 所以，当你看到那个程序时，让
我让我把它缩小，这样你就可以看到 完全看到那个程序。我的意思是，
是的，这对我来说很有意义，例如 ，你接受一个输入，如果它更大
超过 10，那么你就在这里。如果它大于 20，那么你就在这里。如果不是更大
超过20，那么你就在这里。好的。 所以假设它大于 20。如果它更大
比20，那么你在这里更远，如果它 大于30，那么你就在这里。除此以外，
你在这里。顺便说一句， 如果A不大于10，那么你直接
这里。哇。所以让我们运行这段代码。 让我把它缩小，这样你就可以看到它
更多的。你可以看到更多的文字。让我们来看看。所以 让我们运行这个。没有错误。伟大的。那么让我们
假设数字是 25。那么，你期望 结果如何。所以数字是25
如果在嵌套内部大于 20，则 在顶部内部大于 10，如果是
小于或等于 30。所以在嵌套 if off 的 else 部分内嵌套 if and then
在所有臀部条件之外。伟大的。是的。 你喜欢那个。我很喜欢。速度。好的，
所以这就是关于嵌套的，如果我已经 告诉过你的另一件事，但只是让
我告诉你缩进的力量。例如，您 在这里，在这种情况下，如果
条件，那是 if 条件，那是嵌套 的 if，那是 else 部分
如果您将这个 L 运动移入 缩进或与此对齐，如果
那么这就是这个 if 的 else 部分，这不是 这个 if 的 else 部分 如果是这样，记住
缩进的力量 this 是定义哪个 部分属于什么的缩进
Python 中的一种块或结构。在其他语言 中。有时，例如，在 c++ 中，
他们通常用来写这些大括号 来定义一个块和它们的缩进
真的没有关系。但是在 Python 中 ，这是实际定义每个的缩进
和所有。因此，例如，如果 else 只是 向后移动，则这是一个关键示例
并与此对齐 如果这两个如果是 L 结构，则您将得到此 else，
如果没有 L 运动，这仍然是嵌套 的。如果这在两者之间移动
我的意思是如果你得到一个语法，这与 this 不一致，如果 this 与 this 不一致
错误，因为这不是正确的缩进。 所以专注于缩进，这是真的
重要的。是的，所以虽然我已经 告诉过你缩进已经告诉你了
你，但我只是我刚刚发现在其他地方 制作幻灯片，因为这很重要。
有时你可能会困惑这个 else 是属于这个 F 还是那个 F
缩进定义了这个LS属于什么？好的， 我结束这个
控制流缩进在这里。因此，从下一个 视频开始，我们将跳向循环。但之前
循环，我只想我只想在 F LS 中 编写一个冗长的程序 f 有组合。
我只想写一个 Jupiter 程序 让你熟悉 F 嵌套 f
ands 和 ORS 和 nots 的条件是这样 的。所以在下一个视频中
我们将在木星上练习更多的 if 条件，然后从下一个到下一个
视频。我们将跳向循环，这是 非常强大的结构。好的。希望
下个视频见。好的，让我们 稍微练习一下 if 条件
更多在这个特定的视频中，我们将完成 特定的任务。所以让我们设计
这里有一些任务。顺便说一句，这有评论 ，评论，评论是，它从哈希开始
象征。这是一个永远不会被执行的 语句。这只是描述你的代码，
例如。所以喜欢它，就像，它不存在。但 它作为文本存在，而不是作为代码
文件。像哈希有时代表。单行 注释或描述。如果你的
注释是多行的，最好写 多行注释。所以是单身
行注释，例如单行注释，多 行注释，它们以三个开头
引号，然后以三个和弦结束。所以无论 你在里面写什么，在这些，在这个
特定块，这是一个多行注释。所以让我们 用这个模态来描述我们的问题
行注释，因为这是文本形式 的问题。然后我们将解决
使用代码的问题。所以这只 是问题的描述，让我们说
用户将输入装载点编号。数字，比方说 230 8.915。让我们来看看。好的，你的
任务是，所以让我们调整更具可读性， 你的任务是
找出老师整数，部分，整数 部分，小数点之前，
让我们说对于这个点，在这种情况下，在这 种情况下，它是 238。然后，
和
然后检查那个老师部分是否 是偶数。所以只需打印 yes
或没有。所以即使是偶数也打印， 否则打印奇数。所以这就是那个
问题陈述。这就是我们要 解决的问题。而这只是
现在提交我们在多行注释的命令 之外。是的，所以如何如何
解决那个问题？如何解决这个问题？那么 让我们开始解决这个问题。我要去
花一些时间在这个程序上只 是为了适应 if 条件，让我们
假设数字是 x 是输入，让我 转换该输入
进入我们的
实数。就是这样。好的，我们只是假设 用户将输入一个实数。它是
实数。实数可能是我的意思是 38.0， 那是一个实数或 238 本身，
这也是实数。没关系。但 我们不假设用户会进入，
让我们说一些像 ABC 这样的字符或 类似的东西只是假设。好的，
现在，假设 x 包含实数，它可能是一 个整数。默认情况下，也许用户
只需输入 10。就是这样。所以它可能已经 是一个整数，那么我们必须检查
无论那个10是那个10是偶数还是不 是，或者用户可以输入11.7，或者
用户可以输入负 34.7。或者用户可以 只输入零或者用户可以只输入零
点 30 535. 用户想出的这个 exe 可以包含很多可能性
任何一种数字，我们都要根据它来检查。 那么我们如何移动让我们看看，是否
这个数字让我们只提取小数部分 ，即点之前的部分。让我们只是
提取那个我们怎么提取 有两个条件首先我们看
如果 x 是正数，那么还做什么做什么 ？所以让我们先试试这个结构。事实
是积极的，那我们该怎么办？如果 x 是负数，那我们该怎么办？
那么如果 x 是正数，那么我们该怎么办？我们 ，我们就是这样，我们该怎么办？我只是卡住了
这里。我们如何提取小数部分 ，没有这个特殊的部分
事物？我们如何提取它？也就是说，这很 棘手。这有点棘手。是的。所以任何，
有任何想法吗？我猜这个？我拥有 的结构，我正在使用让我们先想想
x 是正数，只是让我们的生活更轻松。 然后如果 x 是正数，它就是正数
数字。我们怎样才能把这部分提取 出来？只是下面的数字？那是之前
小数点，但我们该怎么办？我们可以 我们可以在函数周围应用应用吗？
那会有帮助吗？ X？那会有帮助吗？有帮助 。是的。但是没有圆函数？所以让我们说 y
那么包含 x 的舍入值，那又怎样 ？那么如何提取我们如何提取
小数部分，整数部分？或者 也许有一个函数
实际上四舍五入？让我检查一下 是否有函数 float ？不，漂浮
不是一个函数，我猜。所以让我们说第x轮 。好的，现在 y 包含四舍五入的 vol 值
永远是我们现在假设 x 为正的 X，好 吧，然后呢？现在，如果，如果
y 大于 x，这意味着我们向上移动。好 的，我们上升了，回合上升。在那里面
情况下，我们所做的只是减去。所以 让我所以我们只减去整数部分。
所以让我在老师部分，假设这是 我们的变量名，然后是整数
部分只是 y 减 1 是正确的吗？那 是对的吗？如果 y 大于 x，则
整数部分只是 y 减一。 例如，例如，只是想想
它，如果当，当，例如，如果值 为 29.6，则四舍五入的值将变为
30，所以 30 减 1 就是 29。这就是我们 感兴趣的东西。所以，是的，
所以否则，如果例如，else，else， 如果 y 不大于 x，那么 y 本身就是
整数部分。
Y 本身是一个整数部分。那是对的吗？我 的意思是，这对你有意义吗？那
例如，如果 x 大于效果，则 大于如果 x 的舍入值更大
比大于 x 本身，那么我们只需减去 1 就可以得到比例。除此以外，
舍入后的值本身就是部分，只是 让我们运行它，运行此代码
现在检查我们到目前为止所做的 一切是否正确。所以在那之后，
只是打印，让我们说整数部分。 和老师部分，让我们打印出来。
好的。所以输入一个数字。假设数字 是 25.3 45.367。让我们说，显然，
这里的整数部分是 25。所以让我们 看看我们的程序返回 25。现在
哦，结果是 25。神奇地哦，我的天啊。我们 找到了 25。让我们再次运行它。让我们跑
再说一遍。只是看看。好的，让我们再运行 一​​次。这次下令让我们把它交给
45.8.好的，整数部分是 45。但是当我们 四舍五入时，我们将得到 46 和 46
减一，我们将深入研究这个特殊的 if 条件 。让我们来看看。所有的结果都是
45.我们是我们仍然非常法案。伟大的 。那个，太好了。所以，好吧，让我们
玩它。让我们，让我们给，让我们 给 0.2 结果应该是零，它是零，
对？让我们再次运行它，让我们看看 ，让我们说四个。就是这样，结果
现在应该是四个，它是四个。伟大的。所以 ，我们工作得很好，我们已经提取了
整数部分，只要数字是正数 。好吧，对了。如果数怎么办
会是负的吗？假设那是真的，如果 那是真的，那么整个逻辑都有效，
如果 x 是正数，那么如果 x 是正数，那么 整个逻辑就可以正常工作，否则
我们应该做什么？如果 x 是正的，那么 这个逻辑的作用效果不是正的，
那么会发生什么呢？那么我们如何 找出整数部分，因为首先我们有
找出整数部分，然后我们必须 找出它们是否是整数
部分是偶数或不知道它们是否 确实是 部分是偶数 可能
简单点。但首先，我们必须找出 整数部分。例如，让我们
检查圆形函数对负数的行为， 假设在负 9.3 左右。所以
结果是负九。好的？如果我们说 好，圆，负 9.6，结果将是负
10. 所以它看起来和在正数下 工作一样。所以圆函数是
实际上的工作方式与它在正数下的工作 方式大致相同。好的。所以呢
我们应该在这里做什么？任何的想法？也许 ，也许我们先转换？也许你首先转换，
顺便一提？是的，也许首先转换 数字，假设 y 再次等于 x 左右，
像以前一样，但是然后呢？然后呢？所以 也许这个四舍五入有同样的帮助？也许
四舍五入也有同样的帮助。我们 应该从这里提取出来，因为它
也将在其他部分工作，为什么 要计算它，为什么要写这个多余的
代码？那么为什么是轮 x 比方说如果 y 大于 x，我们应该怎么做？如果
它是负 y 大于那么什么 将是什么部分？这将是
整数部分将是什么？
y 减一还是一？你加一？是的，你得到答案 了吗？那就是你加一。伟大的。和
否则我想我们在未来的部分。等于 Whitesell， 我猜，是的，我猜这就是
这就是好处。这很酷。顺便说一下， 我想这是检查过的，但我想这就是
代码。顺便说一下，这个 else 部分是， 这个 else 部分在这两个条件下都是相同的。
所以也许，也许我们可以结合这段代码 ，写一个更优雅的代码，但我猜这个
会工作。让我们打印整数部分 ，只是为了检查我们是否在工作
好吧，到目前为止与否。所以让我们进入让 我们看看12.3 结果是12年级。所以它做到了
不改变我们以前的我猜我们以前的 逻辑。所以假设有负 9.8。现在
整数部分应该是负九，哦，是返回 10，这是为什么呢？为什么是
那？哦，天哪，这应该是圆的时候 改变的。它可能会这样或当它
rounds 它实际上变得小于 10。 因为当它舍入时它会上升并变成
小于一个否定词。这种情况应该翻转 。是的。所以我们犯了一个错误
这里。让我们解决这个问题。好的，让我们 再运行一​​次。看看让我们说减去九分
减九 d 3.2。减去 93。太好了。那么我们 让我们看看，让我们再次运行它。减
8.9.减八。是的，我们工作得很好 。一旦我们有了整数部分，
我们就在这里。最后，如果整数 部分是你的部分，余数为二，
如果等于零，如果等于零，布伦特 ，甚至，否则，否则，品牌。
艺术。就是这样。这就是整个程序。让我们 来看看。让我们看看，它是如何运行的？
假设 22.6。它是偶数，比方说负 87.3。 那是奇数。所以你看到了力量，
如果条件和，以及我们如何在编写这些 程序和诸如此类的东西时进行思考？
那是一个更长的视频，我知道。但我 想你会得到一个很好的外观和感觉，
if 条件、思考和构建逻辑等等 。所以在下一个视频中，
我们将开始循环。所以这是一个美丽 的结构，希望在下一个视频中见到你，
理解循环的最好方法是在 重复的结构中思考或重复
结构体。让我给你举个例子。他们 会，我们将深入研究这段代码
等一下。这个例子是假设用户给 了你一个数字，假设是整数。
你想打印所有数字直到那个 数字，假设你从一个开始，
只要你达到那个数字，你就会 继续移动并打印所有数字。
例如，如果用户输入，比方说，五 ，您的目标是打印一个，然后打印
二，然后打印三，然后打印四，然后 停止，然后停止，或者，假设
用户打印，如果用户输入，比方说，三个 ，那么你打印一个，你打印两个，然后
你停下来。这很简单。如果用户输入 n，我们就可以打印，我们可以写
这个东西，打印。 Brent, I，让我们用一 个 Brent I 初始化一个变量，然后
I 等于 2 i 加 1，或者在 Python 中，我们 可以快速编写它，因为 i plus 等于
一个意味着我
这意味着在我存储一个加一，这 是写这个的简短形式。然后之后
那，你只需应用一个 if 条件。例如 ，在这里，您可以应用 if 条件
然后说，好吧，如果我小于 n， 你继续打印，打印后，你
只需再次增加这个，然后检查 if 条件并继续前进。那么，那个
如果 n 是 5，或者 n 是 3，那么是可见的，如果 n 是比方说，如果 t 1000。我的意思是，
你一遍又一遍地编写所有这些结构。然后 再次。我的意思是，这是很多
代码。好吧，当您想要时，循环 只是这种结构的解决方案
再次执行相同类型的任务，循环再次 为您提供执行此操作的便利。
例如，让我们只考虑 VI 循环。 这又是一个类似于条件的条件
在像 if 条件一样的 if 条件中， 你计算这个布尔表达式，然后就是
结果为布尔值的表达式。当 此条件成立时，您将留下
在这个块中，一旦你再次检查这个条件 ，在执行整个块之后，如果这个
条件再次为真，您将再次潜入 此块。然后检查条件
潜入块然后检查条件潜入 块。只要这个条件
保持真实，你留在块中，你 在块内移动。一旦这个条件
为假，然后退出此 while 循环，然后 循环终止，然后继续执行
进一步处理就像 if 条件 一样 if 条件 if if
变为假，您接受如果条件并且您可以 继续前进，继续前进。所以在这个
特殊情况，例如，如果 n 是 5， 假设 n 是 5，用户给出一个整数
5 的数 I 等于 1，现在 1 小于 5，条件是
真的，我们往里面移动，你打印 I，i 的 值是 1。所以这就是你打印的，你
打印一个，然后你改变一个，你用 1 增加 i，这意味着 i 等于 i 加 1，
所以我变成了两个。现在循环的主体 完成了，这就是循环的整个主体，
循环体可以有很多很多语句，一整块 代码。一旦我变成两个，
你继续检查，好吗？二小于五， 是的，是真的，你往里走
再次块，打印两个，然后更新 I， 循环体完成。一旦循环体
完成后，您再去检查条件， 该条件是否仍然为真，
我是三我是三比五小， 是的，你搬进去，你
打印三，你更新，我，你检查 条件四小于五，是的，
你在里面移动你打印四，然后你 更新 I 然后你继续现在五是
小于五假。一旦条件为假 ，你就不会潜入体内
在循环中，您将退出循环并打印 完成。就这样完成了。所以这
循环变得非常、非常、非常方便 。在具有代表性的应用程序中
结构。而在大多数有趣的程序 中，大多数有趣的问题，
这些是发挥非常重要作用的循环。所以 让我们去木星只是为了得到我们的
手，把我们的手放在这个循环上。例如 ，假设 x 又是，那是结束或 n，
让我们取 n 并输入。让我把它 弄大一点，就去做吧。让我们说
input 和 input 是一个数字，假设 n 我是 你的外科医生，假设我们说一个，
当 I 小于 n 时，您可能已经写 了这个括号只是为了创建
可读性只是为了提高可读性。否则 我的意思是，这也可以，那就是
完全没问题。如果只要我小于 n，继续做下面的你什么
你做的是带来，例如，我的正方 形画了我的正方形，那个正方形
它，让我们说，然后你说，格兰特 ，例如。这是一个问题编号。进而
你只要打印 I，那是我有循环的 迭代数。
那是方程式编号我这只是弹簧 ，这只是一个字符串。那就是
我们的变量，它的值将被打印出来。这个 打印函数接受尽可能多的参数
你过关了。所以你可以在这里写一个 逗号，然后继续你想打印的任何内容。
这是非常灵活的功能。好吧， 那你说什么，好吧，我加等于
一。顺便说一下，这个 i 加等于 1 和 i 等于 i 加 1 是一样的。你看，
我刚刚在这里发表评论只是为了解释 这是在做什么。如果我只写 i 等于
我加上一个在 Python 中也是正确 的，但这是一种速记。好的。
就是这样。现在，再一次，当我缩进时 ，我在循环之外，比如说冲刺。环形
完成，例如。这就是例如代码。所以 让我们运行这段代码。让我们跑
这段代码。例如。假设 n 等于 5， 那么我们有 5。所以这是一个，
这是侵略数字一，然后二个 正方形是四，这是侵略数字
二，然后三的平方是九，侵略数字 三，然后四的平方是 16。这个
是第四次迭代，然后循环结束 。就是这样。这是第一个
循环的快照。我们将在下一个 视频中从这里开始，我会
向您展示这个循环越来越多的味道。所以 请稍等，等待下一个视频。好的，
在上一个视频中，我们看到了一个 while 循环 ，我们看到了一个。一个与 while 相关的程序
循环，只是打印 只是打印一堆数字 直到一个特定的数字。好，
当你在循环体内时，这是一 个全新的你可以写任何东西
你想写，例如，你可以在 正文中应用一个 if 条件
并检查在每次迭代中是否应该 做出特定决定。例如，
在这种特殊情况下，只要我是偶数 ，我就会打印 I，所以，我是一些
number 如果它是偶数然后打印，否则通过 这个 pass 语句，例如，只是一个
什么都不做的声明这只是写作 的捷径，我们什么都不做
我们是否可以省略整个 else 部分 以及这个 pass 并且仍然是代码
是等价的，但有时写过去 会使代码可读，所以写
这个老板的声明只是意味着什么都不做 ，继续前进。如果我们省略 else 语句，
我们省略了这个老板，这完全没问题。因此 ，例如，让我们在乐谱上尝试一下。
假设 n 是假设 n 是 5 i 等于 1 小于 5 是的，1 不是
偶数。所以转到 else 部分 else 意味 着老板，这意味着继续然后递增
我这个打印语句在循环之外 这是与这个对齐的，而它是
否则不在循环体内， 它应该在内部缩进
现在我增加了我变成现在 回到小于五年。二余
二是零 是的。所以品牌二，所以两个 将被印刷。因为如果执行 else 会
不执行，我将递增，因为 我不在 if 条件内
循环体。所以我增加了我变成 三你回去，三比五小
年。三、余数为二为零假。所以通过 我我加一，所以我变成四，四
小于五年，余数二为零，是的， 所以布伦特四。所以否则会
现在不执行增量 i，一旦你增加 i，你 就会得到，例如，I 等于 5，现在
五小于五假，所以你退出 循环并打印下来。那就是
这段代码是什么。因此，您可以在循环 内使用 if 条件，也可以在 if 内嵌套
循环
您可以在循环嵌套循环中使用循环， 我们还将看到嵌套循环的示例。
我的意思是，这就是允许的，有时很少 需要。好的。那么，接下来有
有两个重要的声明，一个是中断， 一个是继续，我想集中注意力
这些语句是因为它们与循环有很 深的联系。任何地方的 break 语句
写在循环体内部告诉我们， 每当这个时候立即退出循环
遇到刹车，每当执行此刹车 时，它立即退出循环并
将您带到循环体之外。这就是 它的破坏。例如，如果我变成
如果 I 可以被 17 整除而余数变 为 0，您将打印一个 break 然后
当这个 break 语句执行时 ，你将立即退出循环
AI 的价值是什么 中断退出循环 的其他状态是什么 好的
伟大的。现在，在任何遇到 continue 的 地方， continue continue 语句 continue 语句
无论剩余的剩余语句如何 ，都会加载下一次迭代
循环例如，当这个 continue 将 被执行时，无论有多少语句
有没有在那里，在循环体 中，循环不会完成它的
迭代通过遍历所有剩余的语句 进行迭代，但它将开始
立即进行另一次迭代。所以 continue 基本上跳过了剩余的正文
循环并开始另一个迭代。我在这里 写了这个。 true true 意思是 true
意味着总是运行。你可能会想总是 运行它是一个无限循环会吗
当我们退出循环时，因为这个 true 语句将始终保持 true。不是
改变这真的了。这里没有条件。确实 如此。虽然 true 意味着总是
进入循环，但是一旦遇到这个 Break 他，你就在循环之外
立即循环。并且此中断存在，循环 确实继续跳过剩余的剩余部分
循环体的一部分并开始新的迭代 开始另一个迭代。所以这
continue 意味着立即开始另一个迭代 ，跳过语句的其余部分。
所以循环体内的其余语句。好的 ，让我们练习一下这个休息时间
并仅在 Jupyter Notebook 中继续，以获得 更好的循环外观和感觉。
所以假设我们有，让我们再说一次， 假设 n 等于 10。或者我们可能有
将其作为输入，假设 n 等于 10。虽然 为真，这意味着继续前进，
它可能在这里取得了一些价值，我等于，让 我们说一个，而真实的，如果我余数
比方说，九，如果它等于零， 那么只需打破循环告诉 ELS。
否则，你所做的实际上是你增加一个 else 你所做的是，如果我是，如果我不是
能被九整除，那么你所做的就是 i 等于 i 加 1，这是真的。顺便说一下，以前，
我们是这样写的。所以无论 你写一个简短的表格还是
这种形式，所以其他这没关系。就 是这样，循环结束。这就是循环。
循环后，你只要写好，打印，循环就 完成了。那么让我们看看是什么
输出？输出是直接完成的。原因是 ，为什么是 哦，一个不是一个
可以被九整除，只有这样你才能打破。 虽然是真的。为什么？为什么是循环？
哦，它不打印任何东西，我们可以 打印一些语句，以便我们知道
我们是否进入了循环。好的，所以在里面，如果 是这样，例如，布伦特。
别的里面。所以让我们再次运行它。 哦，好的，很好，内部销售，内部销售
铁路内的销售，第一次进去，如果 那个时候坏了，它出去了
裤子下来。这就是这个 break 语句的 作用。那么让我们看看连续的应用
陈述。例如，只需将该代码复制并粘贴 到另一个单元格中，然后查看
这是如何继续工作的。所以，假设我们 有一个这样的循环。所以，我们说的是
这，如果我是九不等于零。如果是 这种情况，如果 I 不能被整除
九，你做的是你得到i plus等于 1然后继续继续下一个
陈述。无论你在这里写什么 ，例如，给某物贴上烙印
其他任何东西，无论将要打印的 内容以及想要继续的内容都将
每当这个眼睛被 9 整除时，就 会遇到这种情况。如果我
例如，一旦这个 AI 被九整除， 你就继续，那么你就不会跟随
那么你不会深入研究这个 if 条件， 只有这两个语句才会被打印出来。
因为这个继续将不允许任何应该 发生的事情发生。还有一次
这些被打印出来，假设我们在那里 打破了我们的循环，假设例如
第一次不能被九整除，所以 我等于二。所以继续这些
下一个循环下一个循环不会 执行三个语句。下一个 If 条件
变为false，这个continue就不会运行了， 然后我们打印这个语句，那么只有
然后我们将打印此语句，然后 我们才会中断并退出循环
并打印数据。所以让我们在这里打印。布伦特里面，如果 是这样，让我们​​运行这段代码，让我们
运行这段代码，看看会发生什么。这就 是好处
我应该我应该只是是的，NASA 更好的字体，让 我们运行这段代码。所以，当代码是
跑进去如果在里面如果你看到你什么时候 你在里面如果当你继续当什么时候
这是 if 条件的主体，当 if 条件完成 时，它应该打印这两件事，
但是 continue 是告诉光标返回到下一 次迭代并继续前进。还有一次
这如果条件变为假，只有这样你 才能得到这个独特的打印这个东西
如果这个中断不在那里，你做你 然后再次进入while循环，你
将运行一个无限循环，然后 你已经完成了，这就是继续
和休息。所以，在下一个视频 中，我们将看到另一种循环
在这里，我们在下一个视频中看到了 while 循环， 我们将看到一个非常强大且非常强大的 for 循环
一种著名的循环，它与 while 循环几乎相同，而 while 循环
根据条件运行它们触发 for 循环 它根据合同运行一个计数器
循环多次它应该运行等等。所以 我们会看到for循环的细节
和应用程序下一个视频中的 for 循环 希望在下一个视频中见到你。好的
在本视频中，我们将讨论前面 的 for 循环和其他类型的循环
我们看到的视频 while 循环虽然大多数 东西几乎所有东西都可以实现
通过 while 循环，有时应用 for 循环 变得很方便。在这个特殊的
例如，我要填充一个列表。所以 在真正转向 for 循环之前，让我们
很快就会看到列表是什么 ，尽管我们将要或要探索
当我们将讨论数据结构模块时 ，本课会更详细，但只是
例如，列表是不同类型 元素的集合，例如
234，这是三个元素的列表。所以两 个三和四个列表可以包含不同的
类型值，例如两个 3.4 之类的东西 ，我们可以访问不同的元素
例如，零的 L 表示索引的 第一个元素 这称为索引，
索引从零开始，然后索引一就是这样 ，如果我们打印，例如，Brent Elif
零结果将打印的结果将是 两个类似的我们可以追加
列表中的更多值追加比方说 53 并在此追加操作后列出
列表将有这些值 234 53 我们可以 删除删除、更新和做很多事情
东西我们会详细看到列表，但就这个 例子来说，只是认为列表是
很多元素的集合，我们可以添加 插入更多元素，我们可以删除元素，
我们可以改变元素等等。或者我们 可以只用一个空的列表初始化列表
list 并开始一个一个地插入元素并 扩展该列表。好的。现在，这是
例如，一个空列表，而四只是这个 范围内 i 的一个变量，不是更大吗
range then 表示从零开始，从 零开始，依次给出一个数字
例如，一个礼物 num 给数字一个一 个，第一次给零我将包含零秒
时间给 1/3 时间给两个，依此类推，在 每个方程之后，范围将给出另一个
数字只要他们小于 10 的数字。所以 ，这个范围的最后一个数字
将返回将九。所以里面写的任何 东西都不包括在内，它开始
从零开始。所以只要我在这个 范围内低于10只要你那个
循环体就像 while 循环体一样 。所以第一次我将是零
零小于 10 好吧，你打印 i i 加一并放弃它的平方
在一个列表中。那么下次这个 范围将自动返回下一个数字
一、现在下一次我会包含一个 下一 次我会包含两个 下次我会继续
三、四或5678加九，一旦AI 的值变成九，那就是最后
循环体的迭代。之后循环 结束。所以让我们写
在这非常第一次当循环第一 次进入它的主体时我将为零
I 将为零，将打印 1，因为我们 正在打印 i 加 1，那时
列表和空列表将有一个数字 为零平方。所以列表将
只有一个数字零，因为零平方， 所以，下次我将是一，我们
将打印两个，列表将包含一个正方形 ，它是一，下次我将是三
我们将我将是两个我们将打印 三个我们将有一个二的正方形
是 4，依此类推，直到 10 在这里 ，当我 9 岁时，我们将打印 10。
在这个列表中，我们将有 9 个正 方形，我猜是 81，然后是循环
完成，我们将退出这个循环。
好的，让我们看看这个。让我们看看这个 例子，在木星中只是为了让自己更舒服
with with list 以及 for 循环。让我们 看看，假设我们有一个空列表，
让我们说一个空列表。仅仅考虑 这样的列表 L 只是一个变量，你
可以给另一个变量写一个名字，那就是 变量名L。好吧。所以对于 i 在范围内，
in 是一个关键字范围是一个函数 in 是一 个关键字，i 在范围内。例如，让我们
那么说，你做的就是你的品牌，你的品牌我 加一个或者你想做的任何事情，那就是
循环体和 Eldad 带，这是列表 的函数，我们将看到
在数据结构会话中详细说明。好的 ，就是这样，循环结束。什么时候
你完成循环，只需打印整个列表 。所以让我们打印列表。你可以
查看结果 1-234-567-8910。这 就是列表中的值。作为
我之前提到过，所有的小价值。顺便说 一句，这个范围函数实际上，
如果我们想让它跳不止一个怎么 办，例如，我们想让它从
零，它达到 10。假设我们希望将 两次跳跃视为两次而不是一次
和一个。所以这是第一次，所以 这是开始位置。那是终点位置
不包括的起始位置包括在内，位置 不包括在内。这是一个
一步的大小。所以第一次我会 是一个你搬进去，然后跳两个
下次我会这么第一次AI 为零，然后你搬进去
然后跳两个，然后你向内移动 然后跳两个然后你向内移动
只要您保持小于 10，您就会在 循环的循环体内移动。所以
让我们看看现在打印了什么让我们 只打印 I 而不是我加一个有错误
是错误 00 范围函数没有冒号， 它实际上有逗号。对不起，
我的错。我只是一个 MATLAB 用户。所以 MATLAB实际上有这个冒号的东西。
所以我只是混淆了 MATLAB 符号。好 的，太好了。所以我第一次是
零，下次跳两个，我变成两个。下一 个跳到 AI 的目标变成了四个，然后
我变成六，然后我变成八。下次 我变成10。但不包括10。
所以你已经脱离了循环。这就是 你得到的方块。这不是必要的
你总是从零开始，你可以从 一开始，你可以跳跃，例如
三人跳。并且没有必要你只是 接触到你可以接触到的
示例 20 完全由您决定。 在那种情况下，你有这个
一种振动。所以这个范围 函数真的有助于创建一个
循环体或结构。好的，太好了。 这就是 for 循环的介绍，我们有
在我们的列表上迭代这里，我们实际上 只是使用 for 循环填充了一个列表。
好的，在下一个视频中，我们将看到有关此 for 循环 的更多细节和更多有趣的东西。好的，
希望在下一个视频中见到你。上次，我们 在上个视频中看到了四个，而且神奇
这与 Python 中的 for 循环有关。 那么这个 else 子句是有道理的
for F. 但在 for 循环中它几乎没有意义 。但让我让我让我试着弄明白
用于 follow 的 else 子句在 Python 中也 有 for 循环的 else 部分，而不是在
其他语言。我不知道有这种 L 火花 的任何其他语言也许有一些
但我不知道。
所以 Python 中的这个 else 部分，特别是 在后面，这个 else 部分或者 else 是
只有当四个完成其迭代时，blocked 才 会执行。例如，这是一个集合
像列表一样的集合是一个 集合列表由方括号定义
用大括号表示，这个集合就像数学 中的集合一样，我们会看到
set 在数据结构中详细列出 元组字典和许多这些数据结构
部分，但只是我介绍过这个， 只考虑这个集合有三个元素
苹果 4.9 和杰瑞。苹果是一个对象或 一个数据。 4.9 是一个数据，是一个浮动
点数据和 Jerry 是一种数据，它是一个字符串 数据。好的，所以这个 S 有三个元素，
三个不同的元素。所以现在对于这个 集合中的 x，只要 x 在这个集合中，
第一次 x 将是 Apple，所以它 会打印 Apple，下次 x 将包含
a 4.9 只要这样我就创建了这个集合 ，只要 x 在集合大元素里面
一张一张，然后全部打印出来。 好的，我们期望当 x 是 Apple 时
第一次 x 将是 Apple，它会打印 Apple 下次 x 将是 4.9 它会打印
4.9.下次 x 是cherry 时，它会打印 cherry，循环结束，因为有
集合中没有要迭代的项目。因为循环 在那里完成了它的完整迭代
预计进行 3 次迭代，循环完成 ，现在 else 部分将执行
你会说好的，循环完成。所以 迭代。好吧，你会想知道
什么情况下else不会else不会执行 。如果您应用任何刹车声明
在循环体内，这意味着您 强行删除了一些迭代
将要执行但循环没有完成 它没有完成引用，
那么L点将不会运行。所以让我们在木星 中看一个例子来获得一个好的
抓住这个其他。好的，让我们定义一个集合 S。S 是一个变量名。你可以有任何
变量名称说它 Apple，或者让我们 说 4.9 我猜然后我们有，让我们
说，雪莉，如果这些拼写是正确的，我猜是 果冻。好的，那么对于 PES 中的 x，如
只要 x 是 ns 品牌 X. Fine ELLs 咆哮 ，当你完成法律终止成功，
或所有迭代 它完成了所有迭代 。这是一个完全是
在循环之外。一边循环，让我们运行 这个。所以你可以看到苹果4.9樱桃
循环在循环外成功终止。好的。 现在你可能会想在什么情况下
this else 不会执行。好的，如果， 例如，只要 x 是 N，如果我说好的，
假设我在这里拿了一个计数器，我等于 一个，那是一个计数器，比方说，每个
时间我只是增​​加我，我加等于一 ，然后我检查我是否等于三。如果
y 等于 3，然后就断了。让我们说
else 只是为了可读性 else 现在这个 else 是这四个中的 else。还有这个
这个 if 和这个 POS 语句的 else 只 是一个什么都不做的语句。怎么办
你做当等于一你布伦特这个 我加等于我变成两个二等于
三假，让你传你继续前进。 下次x会打印4.9，我会变成3
并且三等于三，没错，break 会执行，这意味着循环
应该再有一次迭代，但中断 只会破坏另一次迭代
应该在那里，因为循环无法完成 它的迭代，因为这个特定的
条件，循环的这个else部分 不会执行，你会直接到外面
这个循环。因此，让我们运行此代码并 查看结果。所以你可以看到这个苹果四
由九外循环。我会推荐虽然 这还有 for 循环，
但我建议在开始时避免使用 ELS， 我的意思是，您可能会感到困惑
this else 顺便说一句，这里有 一个错误，这个 l 应该以
这里有一个冒号，好吧。所以我建议 不要在开始时将 LS 子句用于 for 循环
直到你真的需要它。因为 您可能会将 else 与 L 混淆
F 条件。你可能会想到别的东西 ，程序的行为方式不同
道路。因此，无论哪种方式，如果您想将 LS LS 用于 for 循环，Python 中都有。好的，
再举一个 for 循环的例子。在这里我们 使用字典，我正在介绍一些数据
这里的结构只是为了好玩，我们 稍后会详细介绍这些数据结构。
所以字典，这是一个键值周期，就像 set， 但是一个项目由两个数字组成，
这叫做钥匙。这就是所谓的价值 。那是一把钥匙。这是一个像
字典，我们有键和值。所以现在 只要x是一个X，X就代表两个key
d 是我们的字典，D off x 表示 x 指向的任何值，例如，
Apple 是指向 44 的键。Cherry 是 指向增益的键。例如，如果
我们是 ID，苹果，苹果，结果将是 44。同样，杰瑞的 d，结果将是
成为游戏。好的，让我们使用这个 for 循环来创建这个字典。我都在展示
你认为这个 for 循环非常非常 方便地创建不同的数据结构
以及大量的数据和东西。而文件 while 循环更方便并检查
条件和东西。虽然你可以使用 while 循环做所有的事情，但你总是可以
使用 for 循环的东西，但在某些情况 下，一个比另一个插入更好。所以
那让我们为字典运行它。假设我 有一本字典 D。它是定义的
就像一个集合，假设我的键是 a，我的 值是 10。假设我的键是 B，值是
负 19。假设我的键是 C，我的 值是假设 ABC，假设那是我的
字典。所以对于 Brent 中的 x 键 以及该键的值。所以现在你
可以看到key是一个Stan的值key 是B这个key里面的值是负90
C的值ABC。所以这个远循环真的 很方便并且迭代了很多数据
结构和东西虽然它也有其他应用 程序，但这很方便。好的
伟大的。这就是循环的循环。 和 while 循环 这是两种循环
重要循环这是两种重要的 循环，它们在
Python，在下一个视频中我将直接转到 Jupiter 和 Jupiter notebook，我们
将为此练习 for 循环或 while 循环 。我们将练习我们的循环
将做嵌套循环的实际示例 我们将实际解决一个问题
就像我们在 if 条件中所做的那样 ，我们解决了问题 以前，我们为
它。在这里，我们还将编写代码， 我们将很好地掌握循环。所以希望
在下一个视频中，我们将直接在 Jupyter Notebook 中解决一个问题。好的，
希望在下一个视频中见到你。好的，欢迎 回来。在这个特定的视频中，我们将
练习 for 循环基本上是循环。所以让 我们有一个问题陈述。第一的，
我们要解决什么问题让我们发表 评论。而我们要解决的问题
解决是让我们定义给定的数字列表，数字 。例如，I II，让我们说 124
减五，一个 7932，像这样，制作另一个列表 ，制作另一个包含所有内容的列表
从最小到最大排序的项目，即 ，您的结果将是另一个列表。
就像，在这种特殊情况下，我们 将有负五，这是最小的，然后
我们会有一个，然后我们会有两个 ，然后我们会有两个，然后我们会
有两个，然后我们将有三个。所以 所有项目，但从最小到最大排序
订购，然后我们有我猜，四个， 然后我们将有七个，然后我们将有
九。这就是你的，那应该是你在另一 个列表中的输出。所以假设这个列表
可供您使用，或者任何列表可供您 使用，假设此列表可供您使用。
那么如何解决这个问题呢？开始吧 。好的，让我们假设该列表可用。
就是这样，这是我们要排序的列表 。假设这是可用的。好的。好的。
那么，逻辑应该是怎样的呢？应该是什么 逻辑？我们怎样才能解决这个问题？
这是，这是一个看起来很容易的问题， 但它并不那么容易。让我们先说对。
让我们将这个问题简化为从 列表中找出最小值。让我们
假设我们得到了一个 列表，我们只想从
列表。那么我们如何才能移动它。所以 让我们说 M 是一些数字。所以M是第一个
列表的值，让我们 MSP 我们的变量 ，假设这是第一个值。还有什么
我们做的是for i in the for i n L，只要 I是L，如果I AI小于m，那么
如果 AI 小于 m，则 m 应包含 AI。否则 什么都不做。就是这样。所以在
最后，租金为 m，然后是最后的 m。所以 ，布伦特，最小的数字，太好了。
所以这很糟糕，基本上。所以是 的，这就是我们将发现的方式
最小值。所以让我们运行这段 代码。并且最小值是负五可用
我们。如果我们想存储最小值以及 该值的位置怎么办？为了
例如，我们不仅想找出最小数 是多少，我们还想知道
找出在什么索引处，例如，这里是 012，以及 三个，在第三个索引处，我们找到了
最低限度，如果我们也对索引感兴趣 怎么办。所以让我们一开始就说，
指数为零。然后我们要做的是
我们继续前进，我们说，好吧，我们维护 一个计数器，假设一个计数器是 C 等于
c 等于 0，例如，现在，而 C，只是 加等于 1，这是一个计数器
然后这个 ID x 就是那个 C，不管那个 c 是 什么。所以无论那个索引是什么，当
我们找到了这个 C，那个索引也在那里 。所以让我们打印索引以及最小值
价值。好吧，所以在位置三，在 索引三，我们找到了最小值，
好的，现在我们已经编写了一个代码块 来帮助我们找出最小值。
我们怎样才能真正怎样我们怎样才 能怎样行动？所以基本逻辑是你
找到最小值并将该值与第一个 值交换，好的，太好了。和
然后移动循环下次从剩余 列表中找出最小值并
将该最小值与第二个值交换。 下次找到最小值时，只要
作为位置并将其与第三个值交换， 依此类推。所以做那些事，只是
使用这个但是重新排列相同的列表 ，但是这样的逻辑怎么能找出
最小值。所以发生了第一个值， 然后从两个开始直到结束开始
从剩余的值开始，用第一 个值找到最小值 so appid
的剩余列表，然后逐步减少 列表，您将有一个排序
订单，但如何开始，如何找到 这样的方法。所以，任何想法
例如，在这种特殊情况下 ，如果我想交换列表，
我会做的是我会说好的，在零处 与零交换，所以，我会
包含一个临时变量，临时变量 将包含零值，这个零，
所以我要做的至少是零，正确 的最小值和最小值。所以
在零处你写出最小值，但在这个特定 的索引处，从那里，我们发现
最小值，只需将值放在最 开始的位置。所以在
之后，在该操作之后，最小值 将位于第一个位置，或第零个
索引，该值将是某个最 小值将与第一个交换
价值。所以让我们运行这段代码，看看在 那个好之后列表是什么样的。那么你
看，例如，最小值被第一个 值扫过，无论第一个值如何
是，但我们希望对列表的其余部分 逐步执行此操作，我们希望找到
找出最低限度并跟进列表其余 部分的第一个，并继续前进。
我们怎么做？所以是的，那是，那是， 让我定义四个。所以让我先进去
深入一点，让我们说控制将缩进我所有 代码的正确基础。所以对于 j
范围，列表的长度，无论列表的长度如何 ，让我们说 G 就是这样，所以我
do is M 是 gf 值，索引现在 是 J，C 也是 C 也是 Convert
C也是从J开始的，好吧，太好了。现在，我们 希望它以两个开始，现在我们想要这个
我从 J 开始，然后在这里继续前进。所以 让我们说 i 在范围内，从 G 开始然后去
直到长度L，一一，一步一步。好的 ，太好了。那么接下来呢？现在
在那种情况下，值将是 I 的 L，而不是 I 的 L，而不是 I
做这个。
好的，索引只是 C。好的，太好 了。继续继续介绍这个索引，
在这个循环之后，你要做的是选择 gf 值，用最小值拍打 gf 值。
你这样做。就是这样，您在外 循环完成后继续前进并提供。
如果您对列表进行分支，您将对列表进行 排序，或者至少我们希望如此。所以
也许代码中存在错误，或者代码 中存在问题。但我们希望
这会起作用。我们正在逐步做的事情 顺便 说一下，这是一个嵌套循环。这是
循环内的循环，然后我们 在嵌套内有一个 if 条件
环形。在循环内循环。伟大的。让我们 看看它是如何工作的。如果没有哦那里
是范围的错误长度。哦，我们还没有 在那里写冒号。不要忘记这个冒号。
这是个问题。哦，我们有一个排序的顺序 。我的天啊。我们有一个结果。你看
这个的应用。哦，一三不见了。 我们是三个，我们有两个三分球
哦，我们这里写的输出是错误的 ，没有两个三，只有一个三。
所以你已经对一个列表进行了排序 。如果你还记得，我们已经在
问题。所以问题解决会议很早 ，我们在那里解决这个问题
选择排序，但它们是我们刚刚写的 伪代码。在这里我们有一个代码
比实际的 Python 代码更简单 。如果问题只是排序有内置
在函数中做到这一点，但我只是 告诉你这些循环和 if 条件和
所有这些东西都可以用来 相互交流以相互匹配
在遇到问题时实际执行解决问题 的任务。虽然我们会看到
后来在 Python 中，大部分问题解决 任务，我的意思是更多，有
一个内置函数，用于那些你不需要 编写所有可用函数的函数
那些东西，但要掌握到掌握 任何编程语言，你必须经历
这些构造。所以对于一个新问题， 或者对于一个非常大、复杂的问题，
最终你可能需要这些结构 。所以掌握这些结构
通常对于解决问题和编程非常 重要。好吧，就是这样
循环和 if 条件和控制。所以，所有 这些，在下一个视频中，我会我会
开始谈论功能。所以你已经看到了 这个 L e m 数据函数，你已经看到了
这个范围，那就是函数偶像崇拜者。虽然 你已经看到了周围的功能，但你
看过def模式，看过print函数，如果 我们想自己写函数怎么办？
我们怎么做？在下一个视频中，我 将向您展示我们如何编写自己的
功能？哇，是不是很棒？那太棒了。所以 希望在下一个视频中见到你。在这
视频，我来谈谈功能。几乎所有 编程中的一个非常强大的构造
语。 Python 也支持函数。什么 是功能，让我来描述一下
让我通过一个场景来描述该功能 的需求。让我给你一个场景。
假设您正在编写一个非常 冗长的程序，该程序需要
在需要时打印特定消息，例如 ，您需要打印此特定消息
消息任务，任务成功，假设 你需要打印这个。进而
你必须打印移动到下一个任务也许 是为了通知某人也许是为了通知
你的客户。然后你要问，好吧，把下 一个任务发给我。因为我已经完成了
上一个任务，假设你想打印这个 ，或者你想打印更多或做
还有一些东西。假设您想再次执行 此操作。再次，在需要时。
在某个地方，每当您完成特定任务 或某事时，您都想打印所有这些
消息，然后在其他地方，每当发生 特定事件时，您都需要打印
再次所有这些消息。现在一种 方法是只编写这些打印语句
在程序中需要时。一种方法是，如果 您想执行一项任务并且该任务
有很多编码，也许可能是非常少量 的编码，也可能是非常大的编码
编码的数量或幅度。在这种情况 下，我们只有三个语句，但也许
我们有一项要一次又一次执行的任务 ，这确实是一个非常漫长的过程
编码方面的任务。
因此，一种方法是在某处 编写所有编码并定义
一个函数，该函数意味着该函数 包含您需要执行的所有任务，
每当您需要执行该特定任务时。 就在您的编码中，只需调用它
一项声明，仅此一项声明，以及 在此之下编写的整个任务
在此内容下，将此作为将自动 执行的标题，但我的意思是，
我的意思是，这个标题下的任务 可能很长，也可能很短，可能
复杂，可能很简单，但需要 的是我们要执行此任务
每当我们需要。我们不会一次又一 次地写代码，我们不会写代码
我们不想写我们不想一次 又一次地写相同的代码行
再次。再次在我们的程序中。一旦 定义，只需编写此特定代码行
一个函数，就像一个任务。每当 您需要执行该任务时，只需调用标题
或函数的名称。并且该函数 下的整个任务将执行函数
在几乎所有的编程语言中。他们甚至 在数学中也这样做。他们这样做
在 Python 中，定义函数的语法是 你，如果你想定义一个函数，你
必须先以D E F开头的意思是定义 或定义，然后你需要写名字
该函数的名称 该函数的名称 函数名称和变量名称 相似，
我的意思是，函数的名称应该是描述性的 ，它应该，它应该描述函数的内容
其实是在做。所以，最好 写好建议函数的名称
这些描述性很强，使代码可读 和可管理。所以，我在这里写了
函数名是sprint success，你可以写 任何名字，然后你开始括号
然后你结束括号，然后你写一 个冒号，就像你写的冒号一样
if 条件是 for 循环或任何其他结构 。然后你像身体一样缩进
for 循环就像 if 条件的主体 ，这是函数的主体，
功能都应该全部对齐，然后你 写所有的任务，所有的编码
每当调用或调用此函数时 都需要执行，此主体可以
包含内部循环的 if 条件，我的 意思是，这可以有很多编码
在里面。每当你调用这个函数 时，每当你输入这个命令时，
在你编码的任何地方，这下的 整个任务将再次自动执行
并在您喜欢时再次使用。那么，让我们 来看看在 Jupyter 中定义我们的第一个函数。
笔记本。让我们只是猜测，是的。所以，是 的，那是我们的笔记本，我们正在填充
那个笔记本。顺便说一句，如果 你想知道这个笔记本的位置，
例如，如果我想再次调用该笔记本 ，则何时运行 Jupyter Notebook
从 Anaconda 提示符处，您将拥有 您正在处理的所有文件。和
例如，一个文件，您只需单击该文件， 您的文件就是一个或多个文件，
无论你想打开什么，都会在 Jupyter 中 打开。笔记本。是的，原来如此
打开，这是一个很长的文件，所以可能 需要一秒钟。好的。让我只要
采取更好的缩放级别，只是为了 好的，所以 我们正在处理那个笔记本，让我们定义
我们的第一个函数，假设 D，F，定义 。假设函数名称是 Brent。成功。
那是一个，那是一个语法，然后按回车，Brent， 我完成了。然后布伦特，再给我寄一个
任务。让我们来看看。就是 这样。假设这就是函数体，
这里的函数体只包含两条​​语句 ，好吧，那么你运行这个，你
运行这个命令，就像 Shift Enter 一样，你运行 这个。以便
是在符号表里报的，Python 里面有一个符号表
维护Python就是维护所有变量 里面的所有函数信息。
所以一旦你运行这个单元格，那么 这个打印成功函数就会被注册
到 Python。这样无论何时你想调用 这个函数，它都会再次可用。
现在如果你想执行这个任务， 假设你想执行，假设你想要
随时执行此任务。所以你只要 调用这个函数，这就是调用
函数的调用。无论我现在在做什么 ，当成功就是这样，你按下
Shift 回车，这下的所有语句 都会被执行。你也是
一些其他的东西，让我们说三加八， 也就是 11 做一些其他的事情。和
之后，如果您想再次执行相同的 过程，则再次调用此函数并
函数内部的所有编码都会被执行 ，非常非常方便。如果一个特定的
task 如果你想重复执行那个任务， 最好只为此编写一个代码
函数中的任务，然后在需要时调用 函数。它提供了很多管理
电源，如果您有错误，例如在 函数内部有很多调试功能，
您只需转到代码我们只需转到 函数本身的代码并修复错误
然后回来如果你还没有定义，你 不需要你不需要遍历所有的代码
函数，并且您在主代码中的任何 地方都调用了这些代码行，
那么它会变得很难处理而且 函数实际上提供了很多
许多管理和可读性的简单性，以及 从这个意义上说的模块化方法。
所以那是我们的第一次。那是我们的 第一个功能。我们将谈论更多，我们将
在下一个视频中更多地讨论这个 功能。所以希望下次再见
视频。函数名应该是描述性 的，没关系。但有时更重要
有一个有时称为文档字符串的函数 文档，文档字符串允许
你来写函数的描述。但是那个 描述永远不会被执行，
只要您需要帮助，它就会随时可用。或者 你需要知道这个函数是做什么的。
有时你的函数可能包含很多代码 ，例如，你有一个特定的
函数，比方说，有趣，比方说它包含 def，fun，它做了很多很多复杂的事情
里面的东西。有时需要知道 这个函数实际上在做什么。
所以这个文档字符串是描述函数正在 做什么的一种方式。你可能在想
如果你在编码的 where 里面 写这个文档字符串
函数应该是写出来的，我们应该 打开那个编码文件，看看是什么函数
正在做，或者我们应该真正 打开这个函数实现的地方
代码写好了。然后我们必须阅读函数 在做什么。实际上，Python
给你另一种力量。如果你在里面 写了文档字符串，那应该是
在第一个编码语句之前的 top 语句。无论 您想要什么描述，都可以作为文档
字符串，它将在不实际打开的 情况下可用而不实际看到什么
在 funk 中，而无需实际 打开包含实现的文件
这个功能的。让我们看看，让我们看看。 Jupyter 中的两个，笔记本 imore，完全无所谓
我现在就说。例如，让我们定义 一个函数。 def 打印成功。让我们
说函数名，这个函数是打印 成功到函数名是打印成功
二、虽然不是很形象的名字 ，但是标本也是不对的，
不过没关系。打印成功到这里我只是 定义了一个文件 Strank。文档字符串
可能只包含一行，也可能 是多行，就像多行
评论，或者如果你愿意，也可以 单行评论。但它以三个引号开头
并以三个引号结尾。假设我 在这里写这个函数除了
出租。消息，打印消息，让我们说 句号。然后我进一步定义让我们
说我的定义更多是说该消息是
你好，让我们说，让我们说你想要这个 功能的任何描述。现在，这是一个
文档字符串，您可以随时 使用。现在这里是编码
开始，让我们说你，就在这里，再次 ，你好，让我们运行这段代码。
现在，假设我们没有看到此功能 ，因为我们无法使用此功能。
我们无法提供此功能的代码 。我们想知道这个函数是什么
实际上确实如此。首先，如果我们写pri， 我们就可以直接写，然后按tab，tab
将允许我们访问所有可用前缀 pri 的函数。那么让我们
说我们去印刷成功，品牌成功。大脑 成功在这里大脑成功，应该如此
成为资本，布伦特成功，让我们说打印 成功让我们说，我们写一个问题
在它前面打上记号，然后直接按Shift Enter，它会拉出文档字符串它
无论我们写了什么，都会拉动 文档强度，我们将了解什么
其实这是这样做的。所以这个文档 字符串实际上做了很多工作
如果我的意思是这就是当我们需要知道 一个函数在做什么的时候。
文档字符串是一种检查正在 发生的事情的方法。对
现在这个函数实现就摆在我们 面前了 但是在几次之后，函数实现
不会在我们面前多次出现 ，我们将访问其他功能
人们在他们的图书馆里写过。我们 需要知道这些函数在做什么。
所以文档字符串是一种非常非常健康 的描述我们函数的方式。我会的
建议养成每次编写函数时编写 文档字符串的习惯。
我告诉你，如果你写一个双 问号，那么它不仅会拉
您的文档字符串，它也会拉出 整个实现。所以现在如果
你看你，他们说的是文档字符串 ，这就是实现。所以整个实现
如果您愿意，将可用。这对于那些 是的功能来说是正确的，
第三方函数或其他 人编写的函数
那个功能等等。例如，你知道， 一个函数长度，我们称之为函数
几次。所以让我们让我们看看 ，还返回了文档字符串，
我们容器中的项目数，长度函数 不是我们写的，有人有
顺便说一下，写了一个内置函数的 函数。我们可以，这个文件串
告诉我们，好吧，这个函数在做 什么，我们没有那个函数的实现，
显然，有人写了那个函数。而且， 如果我们写双倍，那么我们应该
只要实现不是在 c++ 中就得到一个 实现，我没有告诉你很多
Python 本身的很多实现都是用 C 和其他一些语言完成的
主要有C。所以几个内置函数， 因为它们的速度，它们是
用 C 实现，如果你想得到他们 的实现，他们会得到他们的
代码，该代码将不适用于大多数 功能。所以每当你
写一个双问号，答案 和单问号一样，就是
表明此特定函数不是用纯 Python 编写的，而是编写的
在其他一些语言中，并在 Python 中使用 。换句话说，就是多样性或灵活性
Python的，里面可以搞多种语言， 好吧，还有一件事，我可以写
帮助，帮助命令，我可以得到这个布伦特的 成功
也成功。只需键入此帮助命令 即可帮助打印成功。所以这
帮助会告诉我们，你看到帮助是告诉我们 文件罢工我的意思是，这个帮助
这个函数，如果和这个，这 是我们写的函数，这就是函数
我们已经写过，这个函数除了我们给出 的任何描述之外什么都不做
那里。如果在某个时候，如果我们向 某人提供此功能，或者制作一个包
很多功能，我们正在编写这些 文件，字符串将有助于获得
了解如何使用这些功能。只要知道 函数名，我们就可以，这个文件
string 实际上告诉我们函数在 做什么。虽然很棒哦，由
方式，我们还没有调用这个函数 ，我们只是在玩文档字符串，
让我们调用函数print。现在我们知道 函数在做什么了。让我们打印，让我们
调用这个函数。并且在函数里面写的 任何东西都会被称为 See，这只是
称之为这只是作为一个评论，它基本上 是一个评论。是的。好的，太好了。
和我们在一起。我们将告诉您更多 关于函数的内容。希望看到
你在下一个视频中。好的，在上一个视频中， 我们看到了文档强度。或者你可能是
想一想，如果它正在做一些静态任务 ，这个功能的力量是什么？那么，在
这个视频，我要告诉你这个 函数可以编码或行为
函数可以是动态的，基于 基于某些属性的参数
您将在通话时间定义。例如 ，该功能几乎在所有
编程语言，函数，最 有趣的函数是函数
接收一个参数。并且一个参数只是 作为一个变量被认为是一个参数
并根据该参数执行其任务 。争论。只拿一个
简单的例子。假设我们有一 个函数而不是函数打印成功
打印消息，它打印它收到的任何 消息。例如，在通话时间，
我们像这样调用这个函数打印消息。 假设我们称之为，让我们说，
成功。假设现在将打印成功。下次 我们调用该函数时，我们给出
另一个参数可能在一个字符串中，假设 有 74 个错误，让我们看看，那将是
将被打印或任何东西，我的意思是 ，你提供的任何东西都将被打印。
哇，是不是很棒？我的意思是一种功能 。你可能会想到普通的印刷品
功能不，这是什么力量？嗯 ，我只是告诉你的功能
该函数不仅包含一行，我的意思是，它 可以是一项完整的任务，具体取决于
这个输入参数。整个任务 将根据什么动态执行
您在那里提供的输入参数。 你注意到一件事，我只是
忘了，我定义的这个函数是什么东西 ？我想一切都很好。我刚刚
漏了东西哦，文件串，我 应该写文件串。虽然文件
字符串不是必需的。如果你不写文档 字符串，那完全没问题。这
函数将运行，但这是一个很好的 做法。经常写作是一个好习惯
一个文档字符串。好的，让我们再次看看 输入参数的威力，转到我们的
好朋友 Jupyter 笔记本。好的，让我们 看看。假设我们定义了一个函数
Brent grant 消息，比方说，edit 收到 一个参数消息。而这个论点是
只是一个变量，它只是一个变量。 假设我们说好的，打印消息或进一步，
假设你说，如果是立场信息喷洒 ，如果这是喷洒，那么简单地
然后简单地打上烙印。如果这不是一个字符串 ，那么就说好的，品牌，你的输入参数
不是字符串。然后你说，好的，这是你 所拥有的，幻灯片。然后你说，
好的，无论你有什么幻灯片，请看，好的，留言 。就是这样，就是这样，就是这样
函数，我们可能已经为它编写了 一个文档屏幕。功能租用消息
由用户或大脑提供的信息不 是强度的形式。虽然不要
担心，我们必须详细查看字符串 ，我们将详细查看 sprint 函数
同样，因为冲刺与字符串有很多 关系。所以就目前而言，我
意思是，这就是我们的函数打印消息， 假设消息是字符串类型的，这个
字符串不好，这应该是简单 的 str 这不应该是即时的
像这样的牛排，您的输入参数 不是您提供的字符串。这里
就是你所拥有的。所以在这里，我们可以， 我们可以说这里是这里是这里是类型
什么的
你已经提供了。然后我们可以只打印类型 ，类型 MSC。所以这里的目标是
如果该消息是纯字符串形式，只需 创建一个打印消息的函数。如果
它不是一个字符串，然后它会打印 出来，好吧，你是你签署的不是
一个字符串，它不是字符串形式的正确 消息。假设这个打印消息功能
接收一个字符串，假设这是我们的逻辑或其他 东西。所以让我们运行这个。首先
所有，让我们看看它对租用消息有什么 帮助。因此该函数打印提供的消息
由用户。如果您愿意，我们可以通过问号 访问相同的帮助，它为我们提供
文档字符串如果然而，我们也 想要实现，那么我们写可读
代码和实现也是可用的。虽然 Python 年级真的很棒。好的，
让我们调用这个函数。让我们调用 这个函数，Brent，消息。不管你
想要打印，比方说，这是消息 。这是消息，假设您想要
打印这个。这是打印的消息。 好的，现在，假设你称之为
过一段时间再运行一次，你提供 23。它会说你的输入参数不是
一个字符串，这里是你提供的类型， 它是一个整数类型的比率，你可以
你可以拥有，你可以拥有，你可以通过 以下方式调用这个函数，假设你
定义一个变量 y，变量 y 包含
你好。
你好呀。
就是这样，那是你的，然后你调用， 然后你在 y 上调用这个函数。它会
在那里打印 hello，因为 y 也是一个字符串。伟大 的。所以这就是你能你能你能的方式，
您可以传递不同的参数并指示函数 ，它应该如何在没有
实际上把整个任务的逻辑写一遍，再 写一遍，如果写了所有的逻辑，
曾经，实际上，这实际上是从这里 开始的逻辑。这就是任务
到，这就是您要执行的任务。你 不需要再写这个。然后再次，
每当您需要此类东西时，您只 需调用该函数提供的参数，
它会按照你想要的方式表现。伟大的 。所以你可能会想，函数只有
接收一个参数，也许我们想要提供 多个参数，也许，也许两个
争论，也许三个，也许四个，也许 五个，也许我们想提供几个
论据。我们想根据这些参数的 值来做一些任务，或者那些
变量。所以在下一个视频中，我将 向您展示多个参数。好的。希望
下个视频见。所以在上一个视频中，我们 看到我们可以定义一个函数，并且
我们可以为它提供输入参数。在这个 视频中，我们将看到我们可以
实际上向函数发送多个参数 ，这些参数只是变量，
这些只是变量，无论我们将动态 提供给它们什么值，因为
Python 是动态动态类型的，它们 的类型将被定义。例如，
这里我们只提供了两个变量，我们 只是打印了它们，但是基于
提供多个输入参数，并基于 我们将要执行的逻辑，
我们可以做任何事情，我们可以做任何事情 。所以凭经验猜测，允许我们提供多个
函数的输入参数，我们 可以，我们可以根据
无论我们要处理什么逻辑。那么让 我们去看看我们的朋友 Jupyter Notebook
并查看具有多个输入参数的 函数示例。让我们说函数
B 定义一个函数，比方说，我的权力，比方 说，我的权力，我的权力，比方说，
你还记得 Python 中有一个 POW 函数 ，它是一个内置函数。我要去
要编写我自己的函数，假设它包含 a 和 b。好吧，文档字符串。我的这个功能
计算
力量
就像内置的电源功能一样。伟大的。 那是文档屏幕。好的。怎么办
我们想要做的是我们想要打印好的，让我们 ，让我们创建另一个变量，看，
那是一个幂 B。好的，然后我们打印这个 C， 我们就完成了。就是这样。那是我们的
目标。因此， 我们只需按
在 Jupyter Notebook 中 shift 输入。现在我们 检查这个函数的作用。嗯，这个
函数可以是马力，就像内置的功率 函数一样。好的，只是为了提醒
你一次又一次，文件强度的重要性 ，我一次又一次地写这个，
让我们运行这个功能，我的力量，让我们 说三种治愈疾病的方法。所以
结果是 81。天哪。所以，顺便说一句 ，如果你没有随身携带 POW 功能，
虽然你有，你可以创建你 的函数，只要你想使用，
你可以使用你的功能，没什么大不了的。 顺便说一句，如果你呢？如果你怎么办
如果，让我们说，你可以，你可以定义一个有 两个以上参数的函数来查找，让我们
说，显示类型。就是这样，这就是您 的功能显示类型。而你所知道的，
是我们的检查参数，比方说，检查我们的 x。就是这样，这就是你的功能，A，
B、C、D，让我们说 E，这些是输入 参数。比方说，在某些任务中，你
想知道您在某处工作的 所有五个变量是否
它们都是数值与否。如果它们 不是数值，则您不会移动
在，你正在做一些事情，因为你 是多余的，假设你是，假设你是
从某处读取文件或其他内容 获取输入。你需要，你需要
在继续之前检查 A、B、C、D 和 E 是否处于疼痛漂浮状态。
否则，如果它们中的任何一个不是浮动 的，那么你就没有处理，那么你就是
不继续，您将再次检查输入 参数，依此类推。这些种类
有很多函数是因为每当你调用某个 函数时，无论何时你想要进行处理
在数据上，有时需要检查 数据的类型是否提供了数据
以您期望的方式等等。所以让我们 让这个函数检查 Oryx。我是
不在这里写文档字符串，我想， 我已经告诉你足够写文档字符串了
一次又一次。所以让我们看看。如果是实例。 A、instance int是否是浮点数？如果这是真的？
和
是不是让我们只有三个变量只是 为了专注于 if 是实例，然后
B. 并且 是实例查看是否所有这些都是？我摔倒
他们是？如果它们都是整数或浮点数， 那么做一些事情然后让我们说布伦特，
a 加 b，加 C，也许，或 a 加 b 加 c，提升到只打印它们的能力
正方形，假设它们都是整数 或浮点数，那么做一些
有趣的任务这里有一些任务。否则，你 可以说好的，打印，
空气。输入参数不符合预期。但是没 关系。你有这个功能，让我们
说，让我们调用这个函数。
功能是检查圆弧。所以让我们检查弧线， 检查。弧线，检查弧线，让我们说三个，
四个或五个。所以现在你拥有所有 这些都很棒。假设您有喷射弧。和
你称之为检查ARDS。
在，
比方说，三，四，但是这五是一个字符串 ，比方说，哎呀。现在我们将有
一个错误。输入参数并非所有 预期类型。其中一个或多个
他们或其他什么。是的，还有一 件事这个函数需要三个参数
如果你用少于三个或多于三个的 参数调用这个函数，你会得到
一个错误，例如三四虽然这个 函数接受三个参数，你
只用两个调用它你会得到一个 错误，因为你没有指定所有的
函数需要的参数，尽管 您提供的参数
是它所期望的类型，但 您没有提供参数的数量
该功能正在期待。同样，如果你 调用这个函数的次数超过三个
参数，虽然它需要三个参数，但你会 再次得到一个错误，因为它是
期望三个参数，而您没有提供 三个参数。稍后的。在以后
接下来，我们将看到如何编写一个 接受可变数量参数的函数，我们
会看到，但现在，以这种特殊的方式 ，如果你编写函数，如果你定义
以这种特殊方式的函数， 你必须定义参数的数量
它期望的参数数量，您必须提供 完全相同的数量。除此以外
你得到一个错误。好的，这就是关于 多个参数。好的，接下来怎么办？
好吧，下次，在下一个视频中 ，我们将看到什么是重要的
这些输入参数的顺序？如果我只是 交换消息以赢得消息会发生什么
一？这会改变行为吗？或者有什么 顺序吗？与第一次混乱？
第一个变量，第二个变量，第三 个变量？里面有没有下单
输入参数？是的，有。让我们在下 一个视频中，在上一个视频中，
我们看到，我们如何传递多个如何 定义一个具有多个输入的函数
参数，重要的是要知道输入 参数的顺序是真的，真的
重要的。因此，无论调用时的任何 参数，例如，如果您调用此特定
函数，函数的名字是 f，这不是一 个好名字，你应该有一个名字
一个描述性的，但我建议写好名字， 假设这是 f，那是一个函数，
第一个变量是C到第二个变量 c一个，第三个变量是C三个。
现在你让我们说像这样调用这个 函数，让我们说二、四和九，什么
会发生的是 this too 将在 C 中复制 两个，这四个将在这个 C 中复制
一和这九会被复制到这三中。 现在，C two 的值是 2，c one 有
值四和 C 三的值是九。如果 您更改符号或变量
在这里排序，无论你在那里写 了什么顺序，第一个传递的值
无论第一个变量的名称是什么，调用 时间都将传递给第一个变量，
调用时的第二个值被复制到第二 个符号中，无论名称是什么
符号是。所以，这个顺序 真的很重要。一种解决方法
因为这是在调用时，您实际上 定义了变量名称及其值。
例如，您称您为 F 并且您说好 的 c 具有此特定值，但是
这样您就需要知道定义中的 符号名称恰好是 c 之一。
所以，C一有这个值，C二有这个值 ，C三有这个值，一旦你在调用
时间，如果您已经定义了变量 名称及其值，那么您就可以
自由。现在你改变任何东西， 例如，你这样称呼 c 2 是 b，
c one is a now 不管你以什么顺序 调用这些，
这个 C 一将被复制到 C 一中，C 二将被复制到 C 二中，并且
对于具有更多参数的函数，C 3 将被复制到 C 3 中，
以这种特殊方式调用函数 是好的。如果有
以不同的顺序调用函数可能 会变得混乱和东西
像这样。这实际上可以让您更好地解决 这个排序问题。如果如果如果你是如果
如果你很聪明，你会很高兴， 当你说好的时，我会一直提供
特定的顺序，我总是先读取文档字符串 ，然后我会调用那个函数，
没关系。否则，这也是通话 时可用的功能，您分配
定义时存在的函数 值。现在不管
您调用该函数的顺序是，看到一个 出现在第三个位置 c 出现了两个
在第一个位置，相对值将根据它们 的名称进行复制。所以和
这是一个很好的功能。这是一个非常好的功能 。让我们看看，例如，一个正在运行的
Python 中的示例。在 Jupyter 中，笔记本，好吧 ，定义，让我们说函数 f，让我们
假设它接收 a、b 和 c，让我们说三个值 。让我们说印刷品。 A，是这样吗
它，冲刺，一个，是一个。你会说好的 ，B 是 B。然后它打印好的。见，C，C
是，无论 c 的值是多少，这就是 C，好 吗？现在，让我们调用这个函数 f，
比方说，二、三和游戏。所以， 他们会说，好吧，A 对 B 是三，C
是游戏，很好，很棒。现在，这个工具 将被复制到一个无论如何如果我们
改变这个，如果我们改变这个调用顺序 ，例如，如果我们改变这个顺序，
我们只是我们刚刚搬到我们刚刚搬到这个 特定的顺序，我们只是说好的，这个
是三，这是游戏，这就是所谓的 like，所以现在在游戏中复制三
将被复制到 B 和两个将是能力。而且 ，如果如果那是你的行为
想要，那你就可以走了。 否则，调用函数很方便
下面的方法就解决了，还好，a是a就 可以了。 B 是三个。而 C 是让我们说
再一次，如果你想要这些数字，现在， 如果你调用这样的函数，那将会发生。
现在，如果您更改顺序，无论您 添加调用时间的顺序是什么
与，它将保持不变。例如， 你去说好的，C 在第一个位置。
a 在第二个位置，比方说 二，B 在第三个位置三，
输出将保持不变。那是一个，那 是一个美丽的，那是一个美丽的
事物。所以这是处理订单的一种方式 。如果你如果你在电话中思考
时间定义变量名很重要， 但它有一个你需要的问题
要知道您需要知道确切的变量名称。如果 变量名是 C 那里的一个，你需要
要知道它是什么，你不需要我的 意思是 C 与它必须匹配的 C 匹配
与C一，C二必须与C二匹配，依此类推 。所以你需要知道这些名字。好的，
伟大的。在即将发布的视频中 ，更多的功能特性将会出现
进行讨论。所以留在我们身边，希望在下一 个视频中见到你。所以我们在上一个视频中，
我们看到了函数中输入参数的 顺序。
我们看到了解决方法。我的意思是， 如果你如果有机会，你可能会错过
正确的顺序，有一种方法可以解决我们在上 一个视频中看到的问题。在这里，我们有
另一件事要讨论这个 x 变量 x 输入参数 这是变量
虽然它接收的值是从某处复制 的，但在函数内部定义
否则，但它是在函数内部定义 的，该函数也是函数变量或
或在函数体内的函数 范围内的变量
功能类似这样它可能很方便 。例如，假设你想要你计算
你对你的输入做一些处理。无论结果 如何，您都可以保存该结果
在另一个变量中。假设现在您 需要这个变量的值。做一些
进一步的过程，比方说，你做的是让我们 在通话时间说，也就是说，让我们说
这是函数的 this 并说，这 是完整的函数。让我们说
a 等于 12。B 等于，比方 说 7。假设你调用函数
添加a，b，现在a的值将被复制到 x中，d的值将被复制到Y中，
好的，现在，您需要在这里接收 a 和 b 的总和，在一个变量中，您想要
应保存结果的变量。例如 ，假设一个变量是
D，比方说，然后你想对D做更 多的处理，比方说d doublestar
五，mod 3，也许你需要应用一 个 if 条件，如果它等于
零，然后做一些其他的事情，所以 假设你需要这个变量，什么会
发生的是这个 C 变量在这个函数 之外是不可访问的。原因是
当函数体完成执行时，C 被定义在函数内部，
C 丢失了，看不到更多可用的，C 是 在进行函数调用时定义的，当
当你执行语句 C 被定义 并创建一个内存位置时
在 C 中有时称为创建的内存 或进程空间中的函数空间
在记忆中。但是一旦函数的所有主体 都执行了内部的所有函数
他们丢失的变量，你怎么 能收到这个值？你怎么
接收内部的值，看到外部的这个函数 ？所以，也就是说，这是问题
这张幻灯片，我们如何进一步做到这一点，
此特定函数可以访问此函数 中未定义的所有变量，
但在此功能之外可用并且已经 定义。例如，让我们
说我有一个功能，f。假设我 有一个函数 f。所以如果
这个函数是定义的，就像 f 一样， 假设 F 是你的函数，它必须找到
像 D、E、F，仅此而已。在这里它打 印出一些变量，比如说a。让我们
现在你知道这个变量不再在 F 中 甚至不在 F 中定义，但只要
this 定义了一个变量，例如在调用 F 之前，这就是我们所在的单元格
写代码，我们说好的，a 等于 7，然后我们就叫这个 F，因为
a 在调用 f 之前可用 a will 可 在此处访问。所以，函数变量
在调用之前可用，它们 在函数内部可用，但变量
在函数内部定义的，它们在外部 不可用。那就是问题所在
此外，如果我们现在定义此广告 等于 2，则此 a 有时称为
局部变量或函数，其中变量是函数 的局部变量。现在，这
a is is 在函数内部定义，所有 对 a 的访问都将访问此值
而不是被认为是声音的声音在内存 中有一个单独的位置，而这个
也有单独的位置和内存，两者都 有名字a，但是这个a只会被引用
to 当函数正在执行时， 在函数执行完成之后
这已经从记忆中消失了 ，这仍然可用，七个将
仍然可用。所以很高兴知道，顺便 说一下，如果这里没有定义 a，
然后你仍然调用 F，那么你要么会得到 一个错误，要么这 a 可能是一个
全局变量或在您已经加载 的某些包中可用或类似
因此，在这种情况下，如果它是全局变量或 可访问的，则这八个将被访问。所以，
最好知道函数内变量的范围 ，因为当你调用时
如果 x 已经定义，例如，如果 x 已经定义，它们的功能是什么
像34然后这个x就是34，只要这里 没有定义这个x，如果x被定义了
在这里，这是这个 x 实际上是 本地副本，它将在内部访问
功能。一旦函数再次消失，x 将是 34。所以，最好知道本地
复制或或函数空间本身。但是 ，这里的问题是如何访问
他们。这个变量是这个变量在 函数之外的值，因为这完全是
内部定义
如何访问？嗯，嗯，有一个修复 ，这个修复被称为 return 语句。
例如，如果您编写 return 语句，您将 返回此值。所以 x 加 y，你可能
已经保存了这些值，您可能已经保存 了这些值，例如，C 等于 x 加
y，没关系。然后你说，好吧，回来，看 ，无论你有什么，都会发生什么
调用这个函数，d等于add，我们做 三个。现在，这个值，这个值 C，
在这种特殊情况下是 5，该值 将在 D 中返回，并且所有属性
这个变量的一部分在 D 中返回。所以 就像 C 被复制到 D 中一样，这是可用的
此外，无论你想用这个 D 做什么。好 的，是的，所以 return 语句就在那里。
因此，在下一个视频中，我们将实际在 Jupyter Notebook 中对此进行编码并查看返回
语句运行，我们将看到变量的范围 以及 Jupyter Notebook 中的所有内容。
所以希望在下一个视频中见到你。在上一个 视频中，我们看到了一个变量的作用域，特别是
如果一个函数如果一个变量定义在一 个函数内，它是否可以在函数外访问
如果在函数外部定义了一个变量，它是否 可以在函数内部访问，反之亦然
反之？等等。所以我们讨论了 那些有时被称为学校的事情
变量的作用域。此外，我们讨论了如果我们 想要什么，如果我们想要一个值
计算某个变量的值或计算 出的某个结果的函数
在函数里面？如果我们希望 在函数外部访问它怎么办？
所以我们在上一个视频中详细讨论了 这一点，让我们看看所有这些概念
Jupyter 中的一种运行形式。笔记本。那么让我们 看看它是如何工作的。所以首先，让我们定义
变量，让我们定义一个函数，让我们说 定义，让我们说，我的广告。让我们说
它接收两个参数，假设 a 和 b。然后 让我们说 C 是一个加 b，让我们
说 C 是我们的 c 值，那是一个 c 值 或某个值，不管你想要什么
调用那个值，一些值。就是这样。假设 我们做到了，我们做到了。现在我们要
从函数外部访问某个值。画一些 价值。顺便说一下，让我们
首先调用这个函数，假设我的应用程序， 添加四个值，假设两个，三个。所以
二将被复制到三将被复制到 B。那么 ，让我们访问让我们尝试访问
这个值，某个值，它会抛出一个错误 。原因是这个变量，一些值
在此功能之外无法访问。如果我们 想访问，因为这是定义的怎么办
在函数里面？如果我们想访问它怎么办 ？我的意思是，如果我们想计算一些
结果然后在函数之外使用该 结果？所以出路，如讨论
最后一个视频是退货声明。返回值 。现在如果我们再次调用，让
如果我们再次打电话，我让我走。现在，顺便 说一下，我们实际上还没有注册的东西，
记住这个，那个，那是我在那个时代犯 的一个常见错误，很多很多很多次。
如果你改变了函数的实现，你必须 重新运行那个单元格，你必须注册
将函数的更新副本复制到 Python，否则 ，您将收到错误消息。大概，
是的。这里有什么问题？现在，当有人 哦，我们，哦，还有人还没有
仍然无法访问。因为某些值不是 不可访问的，所以它是一个变量
在其作用域内的函数内部定义， 它的这个变量的作用域，就是
函数体。所以让我们在变量 D 中 接收这个输出。然后让我们
打印 D 和 D 是五。伟大的。所以还有一件 事。假设我们在这里定义了一个变量，
函数外的变量，假设这是一个 标签名称。这是一个很长的
名称，但假设这是名称变量。 好在保存价值的功能之外
是三。进而
然后让我们在某处定义另一个函数。 让我们看看，让我们定义另一个函数
在某处，假设定义 F，也许是 G，它什么 也没收到，但它打印了这个，那就是
一个变量。功能之外。就是这样。就 是这样，这是一个功能。现在，当
我们称这个函数，这个变量在函数 外部，可以在函数内部访问
功能。所以，和，如果这个函数， 如果这个变量里面没有定义
在这里，如果在其他地方定义了 this， 并且它是全局的或可访问的，它将
仍然可以访问。但是，如果我们 定义一个同名的函数，比如说变量，
外面，在函数外，比方说五个，现在， 这个函数将打印五个，如果我们
因为那是局部变量，那是函数 中的局部变量。现在，这
将在此打印语句中访问。让我们 来看看。现在结果将是五个。但
如果你在外面打印变量，现在 值将是三，因为这个变量，
函数内部的这个特定变量 ，当函数被销毁时
完成。这再次可用。所以是的，所以 你需要知道，顺便说一下，它是
无论何时，无论何时，只要您想访问 内部的特定变量，都是一个好习惯，
将该变量作为输入参数传递以最大 程度地减少混淆是一种很好的做法
因为这会造成很多混乱。所以这 是一个很好的做法，虽然功能
是可用的，有时也很有用 。但始终建议传递值
作为输入参数，无论您想在函数 内部访问什么。好的，所以一个
更重要的是，这个，这个函数 g 什么 都不返回。例如，它没有返回
任何东西，它只是打印，让我们说点什么， 让我们说它不打印任何东西，让我们
说，假设这是一条评论，假设它没有 打印任何内容。所以这个，和
然后我们称之为这个，就是这样。所以它没有 返回值。顺便说一句，在 Python 中，即使
如果你即使有任何函数，即使一个函数 没有返回任何东西，它仍然会返回
一个值，称为 none，您可以在此处看到 。所以在 Python 中，一个函数总是
返回一个值。如果你明确地写了一个 return 语句，它会返回，如果你没有
写return语句，当函数体 结束时，自动返回none。
让我们看看这个输出的类型。这个 输出的类型是什么？什么是类型
这个人，这是什么类型的数据？让我们来看看 。这是一个 n 类型，我的意思是，那是
Python 中的一种类型。所以downs都是非类型的， 输出，怎么花样嘛，还有一件事，返回
语句不仅用于返回特定值， 例如，如果您在特定
函数，让我在这里写一个函数。让 我们说 df，那是函数是 H。然后
在那个函数里面，你做一些事情，比如说 打印，a，然后你定义一个
变量，假设 a 等于 3， 假设 B 等于 5，然后
你将这些值 A 和 B 相加。然后你做一些 其他的事情，比如说种植一些东西。
然后你只写一个没有任何输出的返回 语句，或者我的意思是它没有返回
任何事物。你仍然可以 你仍然可以 我 的意思是继续编写更多的函数体
更多的。但会发生的是，每当遇到 第一个返回时，
该函数从那里返回。所以 函数的有效体就是函数
从那里返回。如果您返回一个 特定的值，例如 C，您可以收到
函数外的那个值。如果您不返回 任何内容，只需键入 return 语句。
这意味着立即退出该功能。它的工作 原理类似于 break 语句和循环。记住
break 语句它类似于 break 兴奋 公告意味着退出函数
马上，没问题。顺便说一句，当 return 被调用时，默认返回值
如果在没有参数的情况下调用返回 值，则返回的类型为 none 类型，
例如，让我们运行这个函数。让我们来看看 。让我们调用该函数 啊，是的。
所以它打印一个，然后它带来一些东西 ，然后它返回。例如，它会返回。
它只返回 anon。它返回与否。 如果你没有看到，例如，说，
然后它返回
a C，C 的值，即八。而这 次这个类型，返回值不再
none 类型，它可能是一个整数类型。让我们来 看看。是的，在这里。所以它确实是一种类型
有道理？是的。所以return语句有两 个目的，一，可以返回一个值，
二、可以返回，可以返回 控件，退出函数就好了
中断和循环。只是还有一件事。 return 语句可以返回多个值。
例如，假设我们已经定义了一个函数，假设 是 J。假设 G，G，我们已经有了
定义，我们可以重新定义它。但是让我们说我们 的就是我们的功能。我们只是有一个平等的
五，b 等于七，D 等于让我们说点什么 。然后我们就返回给他们一个，
b、A、D、D。所以return语句可以在 一个序列中返回多个值。现在，
如果您收到这些值，假设 X、Y 和 Z 等于 r，那么 a 将被复制到 a
是第一个返回值，它将在 X 中返回 ，它将在 x 中复制，b 将被复制
在 y 中，并且 D 将被复制到 z 中，就像您将序列保留在
return 语句，如果您相应地更改序列 和 return 语句。所以无论如何
这里的第一个值是这里的第一个值， 无论第二个值如何，这里是第二个
这里的价值，等等。所以让我们运行它 并打印所有这些东西 X、Y 和 Z。所以
是的，五条鲑鱼什么的。所以这个return语句 真的很强大。我的意思是，它可以
返回多个，不是所有的语言，实际上 ，不是所有的语言，它们有特性
返回多个值。但是 Python 确实 具有返回多个值的功能。和
任何类型 A 的多个值可以有不同 的类型，你可以有不同的类型，
你可以有不同的类型，等等 。这就是关于返回语句的内容，
以及变量作用域。以及是否 可以访问外部变量
函数或函数内部等等 ，诸如此类。下一个
视频，我们将讨论如果我们想访问 任意数量的输入参数怎么办。
我的意思是，我们不知道里面 会有多少争论。但无论多少
特定用户提供的参数，假设我们 要编写一个 add 函数。只是
举个例子，假设你想 写一个 add 函数来定义
添加说添加到另一个函数，添加 两个。假设它接收一个任意数字
论据。 D in 我不知道有多少并且 它有一些实现，然后任何人
想调用这个添加到它，如果那个人给出 两个或两个参数，那么只有两个
应该添加。如果此人给出三个参数 ，则应添加三个参数。我的意思是，
这个人可以给出任意数量的参数。 我们如何处理，因为因为
caller this is the call, this is the call, caller 可以给五个参数，六个参数，
七个论据。之前我们在定义 中看到，变量的总数
当我们指定时，我们必须肯定地传递 这么多参数。如果单个参数是
丢失，或者单个参数只是 多于指定的变量数，我们
会出错。但是我们如何 处理我们有任意或
可变数量的输入参数？我们该如何处理 ？所以要回答这个问题，或者得到，
我们怎么做？看我们的下一个视频？它来 了。在上一个视频中我们正在谈论
关于我们如何处理任意数量的 输入参数。例如，让我们
假设我们要编写一个 add 函数。那 应该是添加任意数量的让我们说
传入的整数或浮点数。 记得上次，我们讨论过
在之前的视频中，当你定义一 个函数时，变量的总数
您正在定义，您必须准确地暂停那些 许多输入参数。否则，你是
得到一个错误。但是这可能需要一些 时间，我们要添加一个通用的
一种具有接收任意数量参数的 能力的 add 函数。但不是
无论它接收多少个参数，它都只需 将它们全部添加并返回结果。这样的
一个功能（如果可用）将非常非常 有帮助。因为有时我们可能会打电话
该函数只有两个参数。有时我们 可能会添加可能正在调用该函数
比方说，
三个参数，有时更多的参数或更 少的参数等等。我们怎么能有
这种功能可用，但实现只是 一次实现？好吧，Python
有一种非常非常简单的方法来处理 这种任意或可变数量的输入。和
你这样做的方式是当你在定义 一个函数时收到，你只需写
一颗星，然后只是布伦特让我们说， 一个变量名，让我们说弧线。然后之后
那个，这种艺术会像一个清单 。我的意思是，它将有很多属性
这个艺术有一个属性，这个这个 x 喜欢列表，所以你会的所有参数
发送将被接收，就像你在一个列表 中接收那些一样。和所有
元素，它们是列表中的参数，它们 被不同的索引访问，我们
稍后将详细查看列表。但现在只是 认为它是一个收集所有的集合，
它由索引接收，例如 ARDS，第一个元素由
零，它在零位置。在零位置 ，第一个位置有一个三，
例如，位置索引第一，实际上 是第二外观，第四
将在此复制等等。现在，无论 你传递多少个参数列表，
它将是那个大小，并且有一个函数 长度 len 可以方便地检查如何
有很多论点。现在，如果你传递 两个参数，弧线将，长度
弧将是两个，如果你有三个， 如果你传递了三个参数，长度
的艺术将是三等。无论你传递 多少参数这个弧，它
将一一接收所有这些元素，并且 该弧中的所有元素都将被索引
012，从零开始直到弧的长度。所以 看，例如，在这里，他们
说总和等于零，让我们，假设我们 要在范围内为 i 添加所有这些。
在范围内，我们只给出这个 例子的弧长 12345，长度
arg 是五。所以我将从零开始 直到四，因为不包括五。
所以第一次我会是零，我们 下标零的鸡蛋实际上是
value 第一个变量的值，也就是 三，所以三加零，然后下一个
时间，我将一并添加位置一四 所在。所以三加等于四，
这意味着三等于三加四， 总和等于之前的某个值
下一次的总和加上，i 的值 将是 4，你知道这个循环
有效，我们详细讨论了循环和循环 。当你继续前进时，你实际上探索
所有这些数字。而这个变量 sum 实际上 包含了所有变量的总和。现在
您可以返回总和，并且在此特定函数 中就像一个函数的通用指南
接收任意数量的参数。多么酷啊 ？让我们在 Jupyter Notebook 中看到
更加确信它是如何工作的。所以假设 我们有定义，假设我们有任何
功能，我的广告，他们可能会添加，假设 功能可能会添加强大的功能，这是通用的
或通用。通用可能会添加通用，并且 它收到了星星，无论是什么
变量名称是，你可以读，你可以 写名字弧或者你可以写任何其他
其他可变限制。这就是这只是 这只是一个变量的名称。好吧
假设我们有假设我们有 s 等于零，这 是一些，那么我们只需应用一个
环形。我想你知道，我们对循环进行 了长时间的讨论，范围、长度、
这是一个内置的函数长度弧。好的， 那我们应该怎么做 s plus 等于 r x
i，这意味着一一访问所有 元素。这又与 S 相同
等于 s 加 r x i。无论你这样写还是 那样写，两种方式都可以。
然后当循环结束时， s 包含 Psalm， 只需返回它，你就完成了。哇。
现在，让我们调用这个 add 函数，我的 add 通用函数。让我们称这个函数为
两个，四个和五个，让我们打印 结果。让我们打印结果。
好的，结果是 11。好吧，因为二 加四加五是 11。现在让我们调用
这个函数让我们说，因为，让我们说 ，五个参数。有用。它添加了所有
这五个数字。哇，太棒了。我的意思是， 现在我们可以添加任何，我们有一个功能，
我们不需要为两个参数编写一个函数， 然后为三个参数编写另一个函数，
然后是四个参数的另一个函数， 依此类推。根据参数的数量，
我们不需要编写单独的函数。我们 只有一个功能适用于所有场景。
虽然如此，是的。这是可行的。我已经在 你面前完成了。没问题。是的，Python 允许
这个。
是的。在下一个视频中，我们将看到 我们如何实际处理相同类型的
设想。但是我们想以非常可控 的方式处理输入变量的顺序
道路。请记住，在今年之前的一些 内容中，按照输入参数的顺序，
请记住，我们收到三个参数，并 以非常可控的方式传递这三个参数
道路。然后不管这些是什么，如果我们 不在乎，我们不在乎这里的顺序，
如果我们想解决这个问题怎么办？或者 我们想对输入参数更加小心
订单。但是我们也想要任意数量 的参数。我们怎么做？是的，
等待下一个视频。我会告诉你你怎么能 做到这一点？在上一个视频中，我
向你保证，我将向你展示 如何实现输入变量的排序，
但仍然有任意数量的。记住 ，这看起来很熟悉
你，这是一个可以对函数进行的调用 。请记住，某些函数定义
上一张幻灯片可能是 C 一、C 二和 C 三。然后某事。如果
我们想要传递任意数量的参数， 但我们想要它们的控制。为了
例如，假设这个作为键的特定 变量符号名称，这是一个变量
名称，这就是价值。因此，让我 将变量名称称为键。让我们这个
是在变量中复制的值。这是另一 个键，它是一个值，那就是
另一个键是值等等，如果我们 有很多键值对怎么办？什么
如果我们有很多。我们还想检查 哪个值是哪个键，让我们
说我们要指定那些。但是我们 想指定任意数量的它们。让我们
在这里说，例如，只有三个，假设 我们要通过其中的五个，六个
其中，然后我们希望我们的功能 相应地执行。无论输入多少
它收到的论据。是的，也许在函数 内部，我们可能已经应用了
检查键值是否为C 1，则进行 此处理，如果键值为C
二，然后做那种处理等等， 比方说，基于不同的变量
符号名称，我们想以不同的方式处理值 ，我们如何实现这一点，以及
仍然需要这些数量的变量 可以可以在一个变量中，
可变长度，它们可以是任意数量 的。所以Python再次给你，
一个非常非常简单的方法。与其写一 个简单的单星，不如写一个双星，
然后你会收到任何变量名。 而现在在这个双双星意味着
您将收到一个键值对列表。这是 一个键值对列表。我们会看到
这类似于两个类似于 Python 中 称为字典的数据结构。我们
稍后将详细查看字典， 但现在只需考虑此输入
参数这个输入变量 C，它包含一 个，它包含一个键值对列表，
然后你就可以在大海上进行迭代 ，你可以应用一个 for 循环来检查
这个的内容 记住，我们实际上已经 在，在部分中做过那种事情
的循环。是的，在这里。记住那 是一把钥匙。这是一个关键的价值
是一个价值。我们做了那件事， 我们可以探索我们能够探索字典，
只是使用 for 循环。是的，这里也是 一样的。不完全是，但你可以认为
那是完全一样的事情。所以你 可以探索它，看到看起来像
一本字典。现在这是关键，这是价值， 这是关键，这是价值。这是关键，这
有值，你可以这个x点，第一个 键，然后x的C指向基于的值
基于键x，然后x指向第二 个键，然后第二个值和
所以对你来说，这是一个非常简单的过程 ，你只是打印所有的字典，但是
你可以，你正在打印所有的变量 名和值，但是你可以做很多
复杂的处理，如果你想，我们去我们 的朋友 Jupyter Notebook 来吧
确信这确实有效。让我们来看看。所以 让我们先定义一个函数。所以
d f, 那就是函数名是 Brent, all
变量、变量和值。所以这可能是 一个函数名。虽然那很长，
但是描述符一，也许我们可以让它 更具描述性，绘制所有变量，变量
名称和值，而这是更具描述性的猜测 。所以它接收，比方说，双星。
任何变量，让我们再说一遍变量 名，让我们说弧或任何东西，随便
你想要，那么我们所做的就是为 orgs 中的 x，只是布伦特，比方说，变量名只是
布伦特x，然后冲刺x然后就继续了 ，价值就是价值就是我们的蛋
X。所以让我们说你，你做了这个，你 做了这个。所以变量名是这个，而
值就是这个，好吧，你想为所有 人做这件事，所有的变量和值
您在通话时发送的配对。所以现在 让我们称这个品牌，所有变量
名称和值。让我们称之为变量 第一个变量名，让我们
说是一个，它的值为三。第二 个变量名是B，它的值是
大写B，假设第三个你第三个变量 名是C，它的值是CCC。和
让我们说第四个变量名，我的意思 是，你可以定义任意数量的参数
这里。哇，太神奇了。这是第四个变量 名，这就是为什么它的值为 6.7。和
进一步注意，你可以传递变量 和值都有不同的类型，我在
它们的数量不同。还有更多。是的，你 可以这样做。所以让我们称之为
仅具有四个变量及其值即可发挥作用。 让我们看看我们得到了什么。那么好，
变量名是a，值是三个 变量名是B，值是B，变量
名称是 C，值是 CCC，变量名称是原因 ，值是 6.7。你可以给一个任意的
如果您愿意，请在此处列出lampi。而 Python 只允许你这样做。它允许你
以非常非常简单的方式做到这一点。太 棒了。太棒了。我的意思是，那个，那个
为什么一个高级语言或广播，一个强大 的语言应该有一个特性。所以
Python 确实有这个特性。我真的很 惊讶。我真的，真的被时间惊呆了。
顺便说一句，我并不是说其他​​语言 没有这个。实际上有几种语言
支持这种特性，但 Python 以一种非常简单 的方式支持它。这很容易做到
那。我的意思是，这不是火箭科学。是 的。好的，现在我们有了一个任意的
即使排序确实受到控制，参数的 数量也是如此。
我们还有一两个关于函数的视频。 只是为了比我们多解释一点，然后
我们将在 Jupyter Notebook 上练习，我们 将练习我们将使用这些功能
很多。我们将在另一个函数中调用 一个函数，依此类推，我们将
拥有一个更好的程序，只是为了让自己 感到舒服而编写程序和面条 Jupyter Notebook
有了这个功能。但在此之前 ，让我们再讨论一两件事
功能。是的，让我们看看。所以我希望 在下一个视频中见到你。好吧，我真的
还想讨论函数的这些默认值 ，因为这很重要
并且最需要。默认值是 您分配的输入变量的值
好吧，当你定义一个函数时，如果 值是，例如，如果你调用
这个F，比方说，输入值三， 然后三将被复制到总和中
打印将是三个。但是如果你在没有输入 的情况下调用这个函数，那么这个值
就好像你已经通过了这个。所以 如果你不提供，这是默认值
值，这是将要运行的值。 顺便说一句，你可以有多个
具有默认值的变量，一些具有默认值 的变量定义了一些变量。
对于默认变量，未定义默认值， 依此类推。所以你可以拥有这个
这里必须取默认值，当 你实际定义函数时，
你编译这个函数，实际上，你在 Jupyter Notebook 中运行单元格移位输入。
就在那个时候，这个变量在那个特定 的时间被赋予了这个值，它是
通话时未分配。所以 sum 等于 0 已经存在，当你实际上
对于包含此代码的单元格，请按 Shift Enter。
现在稍后，如果您传递一个值，该 值将被某些人覆盖，如果您不
传递零值会继续，看起来很 容易，但我想提一个关心
这里我之前没有提到，在 Python 中，有一些变量是
引用而不是复制，我 将在复制中讨论引用
数据结构中的详细数据。但是让 我告诉你111个例子，让我们说你
定义一个列表，比如说一、二和三。 然后你做什么 你把这个列表复制到
另一个变量，比方说 l 两个，会发生 什么是在内存中，这个列表在一个特定的
方式，这不是内存的确切视图， 我只是向您展示，假设这是
这个 L 指向这个 L 的特定 内存布局是那个 l 的标签
也为此标记了两个，这意味 着实际上在内存中，这不是
制作的结构，我的意思是这 不像变量。例如，如果 a 是
等于三且 b 等于 a，a 将是 a 将 是内存中的一个位置，而 B 将是
在内存中是一个单独的位置。 那就是普通变量中的内存视图
是。但是内存中有一些变量只 是为了内存效率和成本效率
和时间。人们让人们以一种方式 设计这些数据结构，当您
复制它们，当您只是将一个变量分配 给另一个变量时，内存视图不会
改变只是它的另一个名称相同 的相同的相同的内存
地点。所以如果你改变任何值会发生 什么，假设我有两个，假设
我有两个，在非常，零并添加 零索引，假设您将其更改为减号
九，因为它是内存中相同的视图 ，减去九。现在如果你打印
L 的元素而不是 l 两个，你会得到 改变的值，你会看到变化
价值。这发生了。现在为什么这对于 这里的这些默认值很重要
功能。原因是，如果您接受一个列表 ，假设默认是一个列表，并且
您正在接受一个列表，并且您还为该列表 定义了一些默认值。如果那是
你的定义，让我们说这个列表 这个默认值是在广告中分配的
第一次第一次，这个L里面 真的是一个局部变量
内存里面。现在当这个单元格 运行时，而不是在
所以调用编译时间，当单元格运行时 ，这个 L 被分配了这个，那个只是
发生一次。现在，如果您将这个列表与其他 列表一起调用，让我们说 l 来让我们说两个
三和四。然后如果你把这个 L 称为两 个，我会去那里它会被复制到 L
一切都很好，但不要 期望 L 的内容与
保持 l 因为 l 是这个默认值。值 ，它们只分配一次。他们留下
事实上，每次调用该函数时，它们 都不会改变。他们没有被分配在
它们在编译时分配的调用时间并且它们 保持固定。所以这种关怀必须
被带走。我将很快在 Jupyter Notebook 中向您展示那个特定示例
在这一点上，这现在可能令人困惑，因为 我们还没有定义，我们还没有看到
详细列出。但我只想说明这 一点。我只想提这个因为
这是与普通变量的重要区别， 我的意思是默认值，只是，
我的意思是，就像一个值。如果 你不提供一个值，默认值只是
作品。但是对于变量引用的变量 ，您可能会期待其他东西。
Python 函数的行为可能有所不同。 那是因为这些默认值它们
在编译时分配它们不是在编译 时。实际上，这不是一个
编译语言，我不应该再次使用 编译这个词。再一次，想想
当我们定义这个函数，并在那个特定 的时间运行单元格时，默认的
值被赋值。并且默认值永远不会改变 。它保持固定。是的。所以我会
给你看那个例子。我们为什么不转向 Jupyter Notebook 并查看该示例？是的。
那么或者为什么我们不在下一个视频中这样做 呢？你怎么认为？这个视频，好吧，一样
和你。好的，让我们转到 Jupiter 和 mode notebook 并查看默认值。例如，
让我们来看看。
假设我们定义了一个函数， 假设是 GG，默认值 s 等于
四，假设这是一个默认值。我们 想打印假设 s，如果有的话。
从调用时间来看，如果不可用，则 将打印四个。现在我们立即打印
现在我们要打印，现在我们要 在那个时候按Shift Enter，S被赋值
to for S 没有值，因为它在那里分配。现在 我们称 GG，比方说，我们称 GG 没有
输入参数。现在将打印四个。如果我们 用一些输入参数调用这个 GG，
假设 56。现在将打印 56，没问题 ，一切正常。让我们来看看
关于名单。例如，假设列表是 ，假设 123，那个列表，然后
l two 简单地说 l two 是 L，那么我们 所做的就是改变 L 的内容
二，假设我们更改了 L2 中的第一 个值，然后将该值减去九，
然后我们打印 L。现在，你可能会期待 l 是不同的东西， l two 是不同的
事物。因为 l 和 l 两个，它们 都指向同一个内存。这，内容
通过 l 两个实际上改变了内存 视图， l 也改变了，这给了
结果在 L 中减去 9。好吧， 我想向您展示的行为在
默认值。例如，当我们谈论时 ，假设我们定义了一个函数，
f f 并且它接受一个列表并且默认值 为空列表，或者默认值
让我们说一，二，这是默认值 ，假设，如果没有传递列表，
默认列表是一二。现在，在这个特定 场景中，如果我们只是打印，那么
例如，对于列表中的 i，品牌，我假设我们 只是打印所有列表。就是这样。
现在我们将按 Shift Enter，这时候 这个 L 被赋予这个值，那就是
一个永远不会改变的默认值。 现在假设我们有一个 L 工具
那就是简单地让我们说二、三和四，或者 让我们说 12、三和四。还有什么
我们所做的就是调用 F，然后按 Shift Enter。 现在，为什么我们不调用 f f
任何事物。所以，默认列表被打印出来， 如果我们调用这个 f f with L to the L two will
被打印。现在注意到这个 L 两个实际上 是复制到这个 L 中的，因为我们提供了
它。所以 l 和 l 两个你可能倾向于 认为 l 现在也指向 L 到 L 也
和我两个一样的内容。所以如果 下次因为这些列表的行为
因为它们是引用。下次你做 你做的时候可能会想，因为
l 二在那里过去，所以l二L也是L，L 二以内存视图方式复制到L中
布局。所以 l 也有与 l 两次和下一次相同 的数据，如果我们调用这个函数而没有
输入参数，那么 l 可能指向 L 两个值。所以，12个三四
可能会被打印出来，但这不会发生 ，它们永远不会改变默认值。
所以，再一次，你会得到一个，两个 ，所以，这些引用类型变量的行为，
这通常是不同的，但是当你 在默认值结构中这样做时，
那，那，那可能会以不同的方式 工作。原因是，你，你必须知道
这些默认值是在创建 函数时分配的，
调用函数时不在函数处。 他们不会有任何改变。
所以，这就是默认值。顺便说一句 ，如果它是一个简单的默认值
概念，我想我通过告诉 你层和默认值和
创建这些变量，在什么时间和 调用时间，我把这变得复杂了，
我想，我不应该告诉你列表值和 所有这些东西。但不过如此
真的。我告诉你的都是真的。也许 我已经用很复杂的方式告诉过你
方式，但这是真的。是的。好的。
再放一个关于函数的视频， 然后我们将详细练习函数
在 Jupyter 笔记本上。所以就和我一起 做一个视频吧。希望下次再见
视频。好的，这可能是有关功能的最后 一个视频。是的，我们会，我们会
再放一个视频。但这就 像编码和练习所有概念
那我们学习一下功能不？不 是什么不是新的理论概念。
是的。所以让我问你一个问题 ，让你真正了解这个
滑动。让我去木星问你几 个问题。假设你有，
比方说，比方说你有这个特殊的功能， 你，比方说我的广告，我的广告
通用，假设我们已经编写了那个 函数，可能有两三个或三个视频
之前，假设你有这个函数， 你已经写了这个函数，你是
非常非常激动，哇，你产生了什么样 的杰作，它可以添加任意
传入的值的数量很好，但是这个 特殊的函数是写在这个里面的
特定文件，这是掌握 Python 零到英雄。以后再说两三
几个月后，您正在为某个项目编写 一些代码，或者您正在做某事
在某个地方，您正在编写代码，而您正是 需要的地方。
你只需要一个，你只需要一个 代码来将很多很多值加在一起。
然后你只记得，哦，我在某处写 了一些函数。你怎么能用那个
功能？一种方法是回到那个掌握 Python 零到英雄的文件，然后
复制这个函数，这个特定的代码并 粘贴到新文件中，运行它，注册
那然后叫那快乐。如果你想使用 比方说 100 种不同的功能，
假设您在许多不同的文件中编写 了许多函数。现在你想要
使用所有这些。而且，假设 这是多次重复的需求
你注意到这通常发生在这 种特殊的函数中，你需要
几乎每个项目中的几乎每一个，让 我们说一组可能有 50 或 60 个功能
总是需要的，一种方法是，正如 我告诉你的那样，直接复制粘贴
每个文件中的那些函数，运行它们并执行 此操作。另一种方法就是我的意思是，
使模块成为仅包含这些功能的文件 。每当这些功能中的任何一个
是必需的，只需将该模块导入到您 的编码文件中，该文件只有一行代码
然后访问所有功能，就好像 它们确实可用一样
在您正在处理的端口文件中。 这就是关于制作模块的内容
of so 模块基本上是一个 Python 文件， 其中包含您要在其中使用的函数
几个不同的编码项目或您不 想在函数中编写的函数。
拥有您不想在授权编码文件 中写入的实现，因此您
可以将其中几个函数保留 在不同目录中的其他位置
居住在那里，无论何时您想使用其中 任何一个，您只需导入整个模块
并使用这些功能。所以，所以模块只是 一个 Python 文件，它可以包含一个
为您编写的代码，只要您想使用， 就可以使用它。通常它包含函数
也许不止一个功能和几个功能。 通常，它包含您重复使用的功能
使用，并且您以非常仔细的方式编写 了一次。然后现在你想使用
它以几种不同的方式一遍又一 遍。您无需编写函数定义，
在您需要的每个编码文件中，您只需制作 一个编码文件，或者这是最多的
对您来说很重要，这称为模块 ，您可以在其中使用任何模块
该模块中存在的函数，您可以调用 它，您可以使用它。所以这是关于
我们将要制作的模块。我将向 您展示一个制作模块的示例
如何使用它。但是要使用模块， 我们需要实际指定路径在哪里
该模块实际上使用这个 cess 模块驻留 。然后我们必须做一些这样的事情
导入类型的命令。然后我的意思是 ，我们需要做一些工作才能真正做到
让这个模块在我们的代码中运行。所以 在下一个视频中，我会告诉你什么
额外的工作，很少的工作量你必须 做的额外工作。所以在这里，
例如，我的 funks.py，这是我的 Python 文件，它包含这两个函数。
假设我想使用其中一个在其他 文件中具有这两个功能，
并且该文件包含此特定代码。所以在下 一个视频中，我将向您展示如何
到如何实际制作和使用模块。是的， 所以希望在下一个视频中见到你。
好的，在上一个视频中，我告诉过 你模块模块只是一个 Python 文件
可以包含可以在任何地方使用的代码， 如果您通常需要，该模块。一般，
模块，它们包含很多函数，但 它们可以包含变量和其他值，
等等。所以想想文件 myfonts.py，它 包含这个、这两个函数，以及
考虑一个不同的文件，也许是 Jupiter， 也许你正在使用 Jupyter Notebook。
现在您要使用这两个功能。所以 你首先必须导入另一个模块
调用系统模块说你必须让 这个路径可用。那里
有很多内置模块已经 存在于路径中
搜索路径。当你想调用一个函数时， 它被写在某个已经存在的模块中
在搜索路径中。如果你正在制作你 的模块，你必须要么
要么将那些，那些模块复制到 内置模块中，要么如果你想
在其他地方单独维护它们，然后 您必须在搜索中添加这些路径
路径也是如此。实际插入此路径的 方法是 sis dot path dot append。和
然后你实际上写了一个或多个 这个模块文件的目录的路径
文件位于。将其添加到路径后， 现在您可以编写导入。和你
可以按原样导入您的文件和您的文件，或者 您可以将您的文件与其他文件一起导入
如果需要，可以随时重命名 。一旦导入，现在
您可以使用所有功能，例如内置 功能，这些功能的实现
您的编码文件中没有函数，您只是 在使用这些函数，现在可以导入
将此模块转换为其他文件并使用它们等等 。对于，对于，对于非常大的种类
的项目。制作模块很好。其实 做包比较好，其实就是
包含模块的目录结构。但 至少模块也非常好，
用于维护大量的，当然，或者 实际上是你想要的功能
一次又一次地使用。所以让我们让我们制作一个 模块，为什么不呢？所以让我们制作一个模块。
假设让我们转到 Jupyter Notebook。让我们创建 另一个文件。让我们创建另一个
文件，让我们说新的 Python 3，让我们 将此文件命名为我的 IE，让我们说
让我们将此文件命名为我的通用文件， 让我们使用下划线作为我的通用函数。
让我们对名称进行分类。让我们创建另 一个笔记本。现在它只是一个笔记本
定义了一些函数。假设我们想将一 个函数定义为 jack，所有 orgs。
假设这是它接收的函数，比方 说，
假设它接收像输入这样的字典。然后 它检查日期，比方说检查，
设置所有圆弧的检查类型。假设 你写了一个函数检查，如果没有
数字，比方说，比方说，你 想写一个函数，只接受一个
很多论点。你想检查是否有人 想过，如果有人没有想过
数字，你想返回比方说，一个标志。 否则，你想返回一个真，让我们
比如说，例如，您可能在多个 地方需要此功能。让我们说
在您的核心中，您期待数字输入 。如果输入是，让我们说
如果其中任何一个不是 ，您正在处理很多变量
数字，您可能想要检查所有所有 变量及其值。一种方式
这样做只是为了创建一个列表。就是 这样。我的意思是，你可能有几个
其中，我的意思是，你可以检查所有这些。 也许在这里，也许在这里，我们不需要
字典类的说法。所以也许我们只是 对一个感到满意。那么让我们
说是输出，让我们说输出是让 我们说，R 或该值的返回值。
让我们说这已经是真的了。我们会说好的 ，对于 ARDS 中的 x，让我们说对于 x 在
弧线。如果 x if 是 stance，x is 并且是浮动的， 如果这是真的，那么我们很高兴。但是如果
那不是真的，如果那不是真的，那就 有麻烦了，那么我们说好的，如果这
对于任何值都不是真的，那么我们就返回。错误的 。好的，我们只是返回false。我的意思是，
我们不需要破坏任何东西，我们只是返回 false 返回意味着返回，无论如何。除此以外，
如果我们完成这个循环，如果循环 成功完成，并且没有返回语句
那已经被调用了，然后我们返回，也许 是真的，我们需要不需要其实，这个
多变的。让我们来看看。 所以如果所有变量都是
整数或浮动。如果它们中的任何一个不是 这种类型，则此函数返回 false。嗯，我们
可以有另一个我们可以有另一个函数， 也许我们可以写几个函数，一样的
单元格或在不同的单元格中。无论哪种方式， 定义让我们说另一个功能，通用。或者
添加所有值，让我们添加 Numerix 中的所有值 ，以及所有 numerix。它也包含，让我们
说，弧线。这个函数的目标 只是将所有值相加并返回
和。所以让我们说 s 等于 0 for x in for x in ogs，因为加等于税，那就是
它，然后返回给我们，假设这是 两个函数。也许还有一个名字
这个，或者一些变量，比方说你，我的 意思是，这是两个函数。现在我们是
在函数之外，我们正在编写其他东西。 让我们说我的名字让我们说那是一个
变量，我的名字这个，这不是这个 我的名字变量不属于任何一个
这些功能。我的名字是 Python。当然，让我们 说那是我的。就是这样了。那是
文件名为我的通用函数。所以我们 要做的是将这个文件下载为 a.pi
文件.pi 文件。所以我们真正做的 是转到文件，让我把它缩小，这样
你可以看到下载选项。我们去文件 菜单，我们下载这个，我们下载
这作为
我们下载这个以及按文件，所以 Python 文件 。所以让我们下载这个，或者我们可以写
如果我们需要，这个 Python 文件就像在其他一些 编辑器中一样。所以打开文件夹，有一个Python
文件在这里，复制它。现在复制该文件。 现在你可以自由地去任何地方，例如，
任何，任何文件夹，如果你想，只是，例如 ，你去你的目录中的某个地方，和
创建一个新目录，也许，也许您 想创建另一个目录。例如，去
并创建一个目录，可能在 D 中，比方说，或者 可能是 E，比方说，或者可能在 C 中的某个地方
然后在任何地方制作一个模块。例如，在 C 中 ，创建一个新文件夹，将该文件夹命名为
作为我的，或任何名字，任何你想要的名字 ，例如，我的模块，或者让我们说 utils，
例如，实用程序或任何名称，我的意思 是，让我们称之为，让我们称之为
作为ABC，例如，ABC，随便。你刚刚 做了那个，然后复制那个 Python 文件
在这里，我的通用功能。现在，如果 你回去，如果你回到你的那里，那里
是木星，这里是木星。现在你回到 你的代码，这是你的文件，回去
对于您的代码，假设此文件不再存在 。你所做的就是导入 Sis，那就是
一个系统模块并说点路径点弯 曲。就在模块所在的路径上。
所以现在的模块位于 ABC，这是 模块的一部分。一旦完成，
您可以导入模块的名称是什么 ，您需要知道那是我的
我的话。所以我只是不记得名字了 ，让我们导入我的通用函数。
实际上，当我有 Eric 这部分时，它是 如何出现的，然后是这个导入命令和
轻拍完成后，只需获取该文件 。所以那个名字可能很
冗长。因此，您可以将其重命名为我的应用 程序或您想要的任何名称。那么你
导入后导入。现在，您可以根据 需要使用这些功能，因为
比如你可以查看我的efs.if的实现 ，你看到dot add Numerix，你
想检查一下执行情况。在这里 ，这个记住这个文件不再
在这个特定文件中位于其他地方 。你可以像这样调用这个函数
像内置函数一样，我的应用程序点添加 了所有数字。你可以有例如，
假设接受输入参数，假设为 234。 所有这些都是 6。就是这样。
那就是，那是返回值，您可以 将返回值保存在其他
变量，让我们看看。然后稍后，你可以 打印这个，看看我们做一些事情
这个。看，那是一回事。导入相同 内容的另一种方法是假设您
不想使用所有功能，您只需要 添加所有指标，假设就是
这是您想要一次又一次使用的 唯一功能。所以你不需要另一个
函数，假设对于这个特定文件， 您不需要其他函数，然后
你能做的就是你可以说好的， 从我的通用功能，导入，
添加所有Numerix，您可以重命名它，将这个 函数重命名为某个东西，您可以调用
以同样的方式发挥作用。所以你现在 就这样做。你不需要写任何点
事情，您只需调用 add all Numerix 因为它 现在很重要，然后您说，好吧 234567
然后你将它保存在一个 D 中，然后你可以 根据需要打印它，或者做任何事情
接着就，随即。就是这样，您可以导入 多个功能，也可以导入所有
他们。除了模块，我的意思是，对于复杂 的代码，我的意思是，这不是一个
那里的模块，我的意思是，有几 个模块。并且可以安排几个模块
在一个目录结构中，其中的 目录和子目录和子目录
等等。所以在目录结构中排列 的模块，虽然它们是
以同样的方式访问，该目录 结构有时称为包。和
这些基本上是最有用的 软件包。我们将看到
一些数据科学包，比如 NumPy 是一 个数据科学包。那么，我们将看到
pandas，这是一个数据科学包，我们 将看到 matplotlib，这是一个数据科学
用于绘图和可视化等内容的 包。所以包，只是模块
以目录结构排列。所以现在你知道 什么是模块了。而旧的，
金星二号，我们居然漏了导入 名字不得不看薇薇保存的名字
还有一个名字。那我们回去吧。让 我们回去做，看看如何，如何
很多东西都是可用的。让我们转到其他单元格 和空单元格。所以我的应用程序点
选项卡完成，我的名字可用。请记住， 有一个变量。是的，这是可用的。
所以名字是Python课程。所以这个 模块文件不需要只包含函数，
它可以包含任何信息、您想在其他文件 中使用的任何数据、其他编码
和东西，等等。所以，是的，那是关于 模块的。在下一个视频中，我们将
稍微练习一下这些函数，我们 将看到如何调用内部函数
另一个函数，如何制作很多互相 调用的函数等等。所以
我们将在 Jupyter 中更多地练习 这些功能，而不是理论上
笔记本，只是为了更好的体验更 多的功能。在那次练习之后，
然后我们将跳转到从字符串开始的 数据结构。所以希望见到你
在下一个视频中。好的，在继续之前， 让我们练习一些，一些，我的意思是，
让我们很好地掌握函数和多个 函数并处理它们。最好的
这样做的方法是解决实际问题。 记住，当我们解决问题时
我们，当我们完成 if 条件时 ，我们解决了另一个问题
当我们完成循环只是为了更好地掌握 循环时。让我们解决一个问题。
让我们使用函数来解决一个问题 ，只是为了更好地了解函数。
这里应该解决什么样的问题？我们 应该解决一个老问题吗？上次
我们使用对列表进行排序的循环来解决问题 ？我们为什么不呢？我们为什么不解决
同样的问题，但方式不同？所以让 我们去木星看看。查看我们的文件
木星文件？我们实际上已经解决了一个函数 ，它在某处使用循环，让我只是
找出来。哦，是的，他们来了。所以在这里。 所以给定一个数字列表，让我们这样做
另一个列表或可能包含按排序顺序的所有 项目的相同列表，从最小值开始
最大，您的结果将是另一个这样的列表 。我们使用循环来解决这个问题。
好的，让我们解决同样的问题。 完全相同的问题解决相同的问题
使用不同的方式使用不同的用户 使用功能只是为了掌握功能。
所以让我们说这是我们想要解决 的问题。那么问题又来了，我们
想解决那个。那么我们该如何解决呢？为了 解决这个问题，让我们首先定义一个函数。
让我们做一个函数。
让我们创建一个函数，让我们创建 一个函数，比如说定义，找到最小值
并且该函数接受一个列表。我们 不仅乘以列表中的最小值
列表的最小值，以及该最小值 的位置。所以找到最小值
以及找出一些最小值以及最 小值在列表中的位置。所以
我们怎样才能解决这个问题 ？那是一个独立的功能，不
无论您传入什么列表，它都会 找到最小值。好的？只要最小
是为列表项定义的，例如 列表项，或者说所有
指标，好吧，我们如何才能做到这一 点？让我们看看，最小值是列表。
零，也就是说，最小值 。现在指数处于最小值
是，让我们说，是零。好的？就像我们 在循环中所做的一样，就像是一样
目标，但让我们尝试它的功能。好 的。所以这就是功能，伙计。所以
我们如何进行？我们应该在这里写什么 ？让我们看看一个计数器。让我们
看。具体让我们或者它可能是现在的城市 计数器对于 L.K 中的 x 为零，如果
x 小于我们的最小值，如果这是真的 ，那么最小值确实是 x。
我们发现的指数很高，好吧，很棒。 否则什么都不做我的意思是，否则
刚刚离开。而我加等于一。所以继续前进 。所以 AI 只是位置，所以 AI 正在移动
不断地。当您按照列表操作 时，M 包含最小值和 Id X
变量包含最小值的位置 。这就是可读性的功能，
我们可能会添加一个 else 子句，只是 写球。这意味着 if 条件结束，
如果这个条件成立，我就去做，做 那些事，否则什么都不做。那只是
因为可读性。如果你愿意， 即使你不写else子句并通过
声明，即使那样一切都很好。所以 让我们调用这个函数只是为了测试
此功能是否正常工作。所以让我们 找到，哦，我们还没有回来
任何事物。我们需要，我们需要最小值 以及索引。所以返回一个最小值
值以及位置，因此返回。好的。哦 ，但我们确实认为将其退回内部
成为循环体中的循环。哦，不，不 ，不，不，不，那很糟糕。因为
即使在第一次迭代中，返回值也会 在第一次迭代中被称为偶数，
该函数将完成缩进，记住，缩进 。现在好多了。现在这是
不再在循环体内。伟大的。那是一个错误 。我们修好了，对吧？好的。
所以让我们去寻找，让我们接收一 个 B，所以 a 将包含最小值，我们将
包含最小值的索引。例如，如此 优秀的男人。名单让我们
让我们把清单给它。 13423409. 假设 现在最小值为零。而那个最低限度
值显示为 0123。这是第三个索引 。所以 b 应该是三个 a 应该是零。
那么让我们看看，它的价值是什么？结果如何 ？那么布伦特？甲，乙？所以A为零？是的。
最小的位置是三个，我想它工作 正常。速度。所以这是一个功能，
找到一个最小值？让我们找到另一个让我们编写 另一个函数。交换。所以定义。定义
另一个功能，让我们说交换值。我们 所做的是它实际上接受两个索引
索引一实际接受列表，然后是两 个索引，索引一和索引二。和
它所做的实际上是交换索引的值 。所以索引，一个值应该去
索引二位置和索引二值应该去索引同 一列表中的一个位置，
然后它返回列表。好的，太好了 。所以就这样吧，这样就好了
例如，它接受一个列表类型变量 ，它接受整数的索引类型变量。
伟大的。所以
让我们继续让我们定义一个包含 l ID x 索引一的变量 temp，只是
将其存储在一个临时变量中，然后在 此特定索引处，下一个，只需复制
这个值。别担心，我们将详细查看列表 。稍后在现在列表中。现在在索引一，
索引二的值被复制。但它不会 被覆盖，因为我们已经保存了
该复制出现之前某处的值。所以在 ID x 2 处的 l 只是潮湿。现在回来
列表。这就是您可以根据需要交换两个值 的方法。伟大的。所以让我们检查一下
它，无论是否扫过这两个值。所以让 我们说 list 是 236。 七，那就是
这就是清单。假设我们想要中 音，即扫掠值。假设我们通过
列表，我们希望将值扫描 到位置一和位置三，即
可以添加位置一，值为三， 因为位置从零开始，并且
在第三个位置，值为 7。所以我们 希望这些交换。所以结果会
是 276。三，让我们看看结果是什么？所以 让我们打印出两个。是的，它有效
伟大的。还有什么？我们还需要什么？所以 我们找到了一个最小函数，我们已经扫过
值函数。还有什么？所以是的，我们 该怎么办？现在让我们编写主函数
排序。让我们写那个函数。我们 将调用我们将使用这些类型的函数
当您调用这些函数时，在该函数内部。所以 让我们定义排序列表。让我们说那是
我们的函数，它接受一个列表并返回一个排序 的列表。好的，我们该怎么办？什么
你认为？我们第一次应该做什么 ？嗯，首先，我们应该
检查所有这些列表是否包含 列表包含的所有数值都不是
假设我们只是对数值执行此操作。 所以，我们应该首先检查所有
参数是否为数字类型，为此， 我们应该编写一个函数
应该这样做哦，记住函数 都写在一个模块中记住
模块是我们自己制作的？那么，如果我们 想要导入，我们可以导入该模块吗？
我记得我的通用功能，我们只需要 那个功能，我们只需要那个
功能一只是从我的通用功能导入什么 导入检查如果Numerix检查
如果不是数字，你可以把函数名写成 别的东西，但正义。所以你导入
那个功能。现在您可以使用该功能 了。所以在那之后，你可以使用
那个功能。如果检查，如果没有，数字 列表或记住该函数返回真如果
所有值都是数字，否则返回false。 所以如果它是真的，然后移动
如果不是真的。如果它不是真的，你应该 怎么做？如果不是真的？如果
这不是真的，那么您可能会打印 错误。错误。最后不包含数字
价值观，也许那样，然后你就回来了。返回 。就是这样。我的意思是，返回。不需要
写任何东西作为回报。美好的。伟大 的。所以 else 我们不需要写 else 因为
这个返回会处理这个问题，但它 是为了可读性。这很好，健康。
如果都是数字，那我们该怎么办？好 的，我们该怎么办？如果都是数字，
我们所做的是我们将做我们会做的 最低限度的事情。我们会发现
最小值，然后我们将从中交换最小值
我们应该做什么我们已经有一个 函数找到我们可以调用的最小值
马上我们就有了一个可以立即调用 的函数交换值。我们已经有了
用过这个功能。我们如何将所有这些功能 结合起来？我们如何使用所有这些
函数只是为了实现问题排序，我们 要无序列表。你怎么能这样做？
好的。是的，那个，那个，它看起来 像一个不同的东西。也许？也许。
所以，让我们写出来，让我们只为列表 中的 x，让我们在这里开始思考
列表中的每个元素 x 和列表我们 应该怎么做？我们应该找到
取出最小值并用 x r 拍打最小值 。所以，我们应该找出最小值为
以及最小值的索引，应该 用值 x 和所有东西拍打它
会变得很棒。是的，我想是的。好 的。所以，我们要做的是我们是
现在要维护一个计数器，计数器 为零，这只是索引，
我们要做的是找出最小 最小值和索引在哪里
最低限度的谎言。因此，通过在列表 中找到最小值，它将返回最小值为
以及最小值所在的索引，然后我们要 做的是，我们会说，好吧，好吧，
我们想要做的是，L 实际上是 L 是 交换，交换值与索引见交换值
并列出索引 c。因此，索引 c 应该 与 ID x 交换，并且 C 加等于 1，
这将与该工作一起工作吗？因此，在此之后 ，将对整个列表进行排序。所以，
让我们返回列表是真的，我的 意思是，我们正在找出最小值
一，唯一的问题是列表在这里更新。 而且，哦，有问题。什么时候我们
正在寻找，当我们寻找最小值 时，我们正在寻找最小值
列表。并且每次都会返回相同的最 小值。这是一个大问题。所以，
看起来这个很好的最小函数并没有完成 我们的工作，我们真正需要做的是
，我们应该去找到最小函数并给 它开始你的股票你的最终最小值
从一个特定的索引。所以，不要搜索 整个列表来找到最小值，开始
例如，从以下索引中找出 最小值。让我们开始吧
索引，也可能是结束索引。但让我们 开始下一步。所以开始搜索最小值
从那里。我们现在如何更改所有 代码？哦，那是坏事。
让我们更改代码。假设这是开始索引 。开始索引。就是这样。这个
现在的索引是开始索引，我也在 启动 VB 我们可以使用范围函数
在这里，这对我们来说可能更可行。 因此，让我们使用范围函数。相当
比这让我们彻底改变编码。这 是一件坏事，我们需要改变
i 在范围内的代码
从起始索引开始，从起始索引 开始，到长度结束
列出并做一个步骤 好的。现在 x 真的 是 x 真的列在索引 i 上，如果
x 小于 m 那么这是一个索引是 AI。否则我们不需要这样做
因为这是自动发生的。其余的故事 是一样的，我想是的。
那会解决的。好的，太好了。哦，有 问题。哦，我们刚刚错过了这个专栏
这里。伟大的。我们修复它。好的。现在，如果 存在价值，也许这可行。也许没有
也许有一个错误。让我们看看，让我们 调用这个函数。所以让我们称之为
功能 l 二是排序列表。让我们将列表传递 给 153。减去 870。让我们看看。
那就是这个列表的老板，看看它返回什么。如果 它返回良好，我们可能会很高兴。除此以外，
我们将看到错误在哪里？如果 有bug，哦，这个不包含数值。
为什么不？列表不包含数值。 为什么会这样？幸福其实包含
所有美国价值观。我们阅读问题，检查 是否不是数字，让我们看看让我们
请参阅检查如果不是数字的实现。让我们 看看。查看。如果不是数字，让我们
见实施。还有一个错误。因为这些 都是数字。所以检查是否
不是弧中的数字 x，如果不是实例， 则返回 false。所以如果一切都是 int
或浮点数，所以如果 x 是整数或浮点数， 则返回，否则返回真。所以它返回真
如果我们所有如果我们所有的数字。所以如果我们 所有的 Numerix so not true 意味着它返回 true
错误的。为什么为什么会为我们 返回？所以这只是让我们看看
为什么它返回false。那就 是发生错误的坏消息。
让我们看看这是如何工作的。所以这只 是检查。检查，如果不是数字。和
让我们通过列表这个列表。让我们 看看返回了什么。让我们打印返回
事物。但它要么是真的，要么是假的。所以 它返回一个错误，为什么它返回一个错误。
这是一件坏事。为什么他们变成假 的？让我们转到文件。让我们去
文件。这里。对不起。让我们转到文件 。在这个目录中。让我们打开这个。
也许在简单的旧坏中打开这个。也许是一个 老坏，为什么不呢？或者也许是其他一些幻想
编辑。让我们打开它，看看发生了什么 。广告格式字体，让我们有一个更大的
继续，看看发生了什么。
自我面对 20 个错误之一是不好的，它们对 x 和 ogs 来说真的很糟糕。好的？如果不是
实例。所以首先是这个，它总是 会返回 true 。如果不是真的，
这意味着错误。然后我们将继续前进 ，如果你在任何地方，循环就会运行
它正在找出它基本上在哪里 发现。所以这真的有效
美好的。让我们，让我们把这个函数写在我们 笔记本的某个地方，看看会发生什么
是让我们说而不是这个。假设这 个函数就像检查指标以检查数字
检查它不是数字让我们调用该函数 ，看看会发生什么检查数字
它再次返回false。为什么返回false？ 太棒了。哪里是假的？
所以二是整数？是的。一个是整数。是的。如此 真实。真的。真的。真的。所有这些都是真的。
哦减去八可能是一个问题。减八可能是 个问题。让我们来看看。也许。我不
知道。好吧，好吧，还是有假的。我的意思是 ，我被困在这里。伙计们。我被困在这里。
我不知道该怎么办。我不知道该怎么 办。我必须调试这个功能，我有
进入该功能并查看发生了什么 。所以我们真的是鸡蛋。哦
我的天，大麻烦大麻烦。是的，我找到 了空气。我们正在传递一个列表。和
该列表只是一个论据。这不是很多 我们必须通过所有这些的论点
以不同的方式论证。我的意思是 ，如果你愿意，你就会得到
错误，错误是我们传递了一个变量， 不是很多 2153 817 这些还不是全部
不同的变量。例如，如果我们只是 进入并打印 x，对于第一个 x，它
是所有它是所有它是所有列表。 这是所有的清单。这不是变量
逐个。让我们来看看。是的，我发现了这个错误 。发现错误。等待。是的，看，不是吗？
它不是很多，也不是很多变数。这 不是很多争论。这只是一个
参数是放置变量的形式。这是令人难以 置信的。我们应该做什么？应该
我们进去并添加另一个函数检查 列表是否不是 Americ，而不是变量
参数的数量。我们应该做什么？让 我们编写另一个函数来检查
列表。让我们在这里写检查数字 到它包含考试列表只接受列表
hello 或者 l 或者任何 x 或 art 只是简单 地，你可以调用或 l 列表。而它
遍历所有列表。并做与以前相同 的工作。所以现在这将起作用。
所以我们模块中的函数不再起 作用，它也不会起作用。
所以我们不打算使用模块中 的函数，我们将编写另一个
在这里可以帮助我们的功能。我们已经 写好了，我们开始吧。它只是连锁
那个功能。我们只是再次将其 扔掉。让我们看看会发生什么
现在。哦，还有另一个错误 。找人失踪一 o v v 没找到
这个消防员缺少起始索引。所以 起始指标是C率。
对？这是个问题。这是一个巨大的问题。让 我们整理一下哦，我的上帝名单终于
排序。哦，巨大的，巨大的，巨大的。所以 你看，你可以调用其他函数内部的函数，
您可以从模块调用函数。如果 他们不再工作或不再有益
对你来说，你可以编写新的函数，你 可以调用它们。是的，所有这些东西。
我想那个冗长的视频教了你 很多课程，如何实际编码。
这实际上发生在您执行非常 大的任务时。你必须定义
不同的功能，你需要为模块化的方法 定义不同的功能，并关注
在每个功能上作为一个单独的实体 。这使得管理变得更加简单
代码和错误修复以及所有这些东西。 你看，我只是注意到了这个错误
仅仅通过专注于这个功能。 我没有想别的，只是专注
在该功能上，查看其他所有内容 保持不变的实现修复。是的，
在这里交换太长了。好的，现在 你已经做了很多关于函数的练习，
循环，还有很多东西。这就是 Python 中的所有基本编程。在中
下一个视频，从下一个视频中，我们将 看到真正的力量，更真实的力量
Python，你不需要写很多循环 和很多金子，你仍然可以
实现很多东西。为此， 我们需要通过数据结构
在 Python 中可用。所以从下一个 视频开始，我们将开始看到优势
那个研究或结构，我们将看到较少的细节 ，我们将看到详细的设置，我们将看到
详细字典我们将详细看到元组 。在经历了所有这些之后
数据结构，并很好地掌握数据 结构。那么最后我们会
我们将转向可用于数据科学 的软件包，尤其是 NumPy，
熊猫 matplotlib。我们会看到也许 我包括也许我包括一两个视频
也用于通灵学习。所以希望见到 你 对于 Python 的全新阶段，
数据结构，所以我们希望在下一个视频 中看到。好的，让我们深入探讨
等待的字符串。字符串基本上只 是一个字符序列。这是一个数据
类型，它是一种数据类型。在 Python 中，它要强大得多。原因，原因
的，我的意思是，在几乎所有语言中，使 之成为一种全新的数据类型是，原因
就是几乎所有的数据都是按字符顺序 出现的所有文本，所以使得
那个序列的更正，整个文本 作为一种数据类型，写特殊
可能需要某种功能来处理 该文本。这就是字符串
是。例如，在 Python 中，您可以声明一 个字符串变量 s，或任何变量名，
只是双引号，让我们说 ABC，是 我们每月相等的单引号，要么
方法很好，df。所以无论哪种方式都可以 ，您可以使用双引号或单引号声明
报价，无论哪种方式都可以。一件事是， 小心，不要混合。我的意思是，不要开始
通过单引号，并认为现在我将以 双引号结束，这样就可以了。
所以不要把它们混在一起。如果您使用 单引号，请使用单引号，如果您是
使用双引号，使用双引号，不要将 它们混合在一起，那可能会更多
稍后混淆。所以假设这个 S 是一 个字符串，Python 是最好的语言
数据科学。那是一个 D 是另一个 由单引号定义的字符串。在这
当然，我们要学习Python，然后你 可以打印s，不同的在不同的
方式，假设你会打电话给你可以打电话 给品牌，你可以打电话给 D。或者你
可以顺便说一下，你可以添加两 个字符串变量 s 和 D。 结果是
一个新变量。这就是加号在字符串中的 工作方式是加号在字符串中意味着
只是连接将它们连接在一起。所以 首先，你只需复制这个字符串，整个
字符串，然后您只需将另一个 字符串与它连接起来。结果是
新字符串。现在这是一个新变量， 您可以使用该变量并做很多事情
用它。所以让我们去 Python 看看实际上 ，在运行中的字符串中的大脑
形式。所以让我们说 S 是
字符串，让我们说，正确的语言，让我们 说。让我们有另一个字符串 T，
那是使用单引号。这对数据科学 、科幻很有好处。好的，这对
数据科学，让我们运行这两个，看看 s 的类型是 s 的类型。方式
是str字符串，str，这就是类型。如果 你只打印 s，它就会被打印出来。
Python是一门好语言。请记住，到目前为止， 我们正在使用这个 sprint。我们总是使用
这种你好或类似的东西。那基本上 是一个字符串，因为由
方式，sprint 函数，实际上，它需要 任意数量的参数，我们可以打印
你好，然后我们可以打印其他类型的任何东西 ，然后我们可以打印另一个你好，让我们
向你问好，这是一个多变量 参数函数打印，然后我们
可以有另一个字符串也许你是谁 。然后可能是一个浮点数 5.9。
所以我们使用了这些，我们使用 了这些，我的意思是很多。我们
使用过打印功能。我们一次又一 次地使用这些双引号。但是但是
这些实际上是我们稍后将在那里 使用的字符串。于是春天
函数实际上接受字符串和所有这些类型 的正常情况下，每当您使用打印时，
通常，您通常会使用它来实际 显示一些文本，也许您正在
将该文本写入某个文件等等。所以 这个字符串非常非常有用。最多
的数据在屏幕形式的文本 形式中可用。我们要处理
我们要找出数据中的异常数据， 我们要再次修复它们，我们要
留在正文中。所以拥有一个实际上 有很多功能的数据类型是很好的
处理所有这些东西。所以让我们看看 ，例如，另一个，让我们看看如何
我们可以连接两个字符串吗，例如，SMT。 假设我们有 B，即 s 加 T，
那是串联的。 B. 那就是弗兰基。我们 将得到一个广告。虽然比肯
是一门好语言。这对数据科学有好处 。嗯，它是串联的。但是没有
两个之间的空格，因为第一个字符串在哪里 结束，第二个字符串就从哪里开始
从那里。如果我们可以输入三个字符串 怎么办？ s 加上另一个只包含的字符串
空间校正器？那么这个字符串呢 ？为什么我们用双引号括起来，
或单引号，无论如何，一个跟踪字符 的校正器，所有这些东西都被称为
字符串。所以现在我们连接起来，三个字 符串一起作为一个空格，一个空格字符串
只包含一个大于 T 的空间。让我们 看看现在会发生什么。所以Python
是一个很好的语言空间，有利于数据科学 等等。那么，所以
是的，这基本上就是字符串的 介绍。例如，如果我们想要
连接？如果我们想要，我们有一个变量 A，它是 12。假设我们有变量
b，这是这本书的价格，我们说 这本书的价格，a是12。所以
假设这是我们的价格。现在价格 是整数形式 S 是书本形式，比方说
我们想制作另一个字符串， 包含以下内容，价格
这本书是，然后无论私人价格是 多少，都应该在那里。那怎么办
我们能做到吗？所以让我们说 s，加上，也许 ，也许另一个字符串可能是一个空格。
那么在那之后价格出现？现在，如果 我们正确加和正确的价格，价格是
不再是字符串，它是一个整数， 并且一个整数不能连接字符串
以一种直截了当的方式，比如 加号，我们如何才能像
这本书的价格是，无论价格 是多少，一种方法是
convert the variable price, the Convert the type of the price of the variable, from integer
到字符串，这意味着无论值如何， 在这种情况下，写入 12，都会变成
一串字符一和二。现在它 可以与其余的连接起来
的字符串，我们将包含我们想要的消息 。例如，如果我们现在看到什么
是免费的，就是这本书的价格是 这本书是12。哦，我们没有空位
前。所以让我们输入一个空格，他们 的空格也是一个校正器可以在
强度，而这就是我们可以将不同类型转换 为字符串的方式。我们可以有一个浮动
类型，我们可以将其转换为字符串，等等 。做同样的事情或实现的另一种方式
同样的东西是写布伦特，这本书 的价格是我的意思，我们可以用
then price 的可变数量参数的力量 ，那是完全一样的事情。
这本书的价格是12，这本书的 价格，但是，考虑一件事，
打印函数自动为不同类型的 参数添加空间。你可以
看到这里，是的，你不需要指定一 个说明符空间，这个空间是自动的
如果它被认为是打印函数中 的不同参数，则添加。
好的，太好了。这就是字符串的 引入。我们将深入探索字符串
在即将到来的视频中会有更详细的介绍，所以 和我们在一起，我们将看到一个字符串
更详细。好的，希望在下一个视频 中见到你。一个字符串可能非常
冗长，或可能跨越 我很冗长，可能 跨越不止一行。或者也许
格式化是一种你想要的方式， 即使它不是很长，你也会
仍然希望同一字符串的不同块 出现在不同的行中。所以
有一种方法可以使用 三个单引号或
三个双引号。然后是三个双引号 或单引号。无论什么约定
你跟着然后你把所有的字符串都写 进去，不管你想要多少行，然后
一个变量实际上包含一个多行字符串 。例如，如果您现在打印，如果
你在这个多行上调用打印函数， 那是顺便说一句，一个变量名，
包含此数据的多行字符串， 多行，多行，多行，现在
在这里拼写我们的拼写，我 只是创建了多行，如果你
调用该打印函数，这将打印 将显示字符串，因为它是
那里。所以让我们看看 和 顺便说 一下，相同的多行字符串类型
请记住，这也用于评论 。如果您的评论跨越多个
行，你可以使用这个。所以这个多行字符串真的 是如果它没有保存在变量中
并在代码中的某处使用，然后 作为多行注释。伟大的。
那么让我们在 Jupyter 中练习多行字符串。 笔记本。让我们来看看。那么让我们
假设我们有一个变量 A，它是多行字 符串。让我们说春天是这样的
第一行。
然后是第二行，然后是最后 一行。而这条线是三。
就是这样。好的，太好了。那是一个多行字符串 。让我们来看看。怎么可能布伦特一个，什么
发生？所以这是第一行，这是第二 行，这是最后一行，这是第三行？
为什么这个？第一个这是移动一个校正器 ，对吗？哦，这里有空。让我们删除
如果不需要，那个空间。并再次运行。 虽然因为空间是一个校正器，它将
如果需要，可以打印。好吧，如果 你真的想要真的想要下面的那种
的东西，你有，让我们说品牌。 所以你真正要做的是你想带来以下
以下选项可用。选项是，让我们 说轻拍，轻拍，轻拍，让我们
看到一个连字符，a。这确实是从一个什么 都不做的地方开始的。然后我们让我们
说连字符 B，他们也什么也不做。 假设您希望我们的信息被绘制
以这种方式，会发生什么？让我们 来看看。好的，以下选项可用
连字符没有连字符 B 我的意思是，所有 这些都是字符串多行字符串，这些
你认为它们不存在的饼干，这些 是空间，它们是我的意思是空间
画在这里，空间画在这里， 我们说没有印刷，这些是
打印在那里的空间。所以有时这个 多行字符串，它有助于格式化
以我们喜欢的方式传达我们的信息。所以 这在大多数情况下是有帮助的，如果
你写这个多行，顺便说一下， 如果你写这个多行，注释在
任何好的剧本的开始和结束。这意味 着如果您编写这种多行定义方式
任何好的脚本的开头和结尾的字符串 ，该代码脚本被注释为
我们之前也见过几次。因此， 例如，在解决问题时，请记住
我们定义所有？哦耶。所以这就是 评论。那是评论。即使一些代码
写在里面，不会被执行。对 。好的，这就是关于多行
细绳。在下一个视频中，我们将看到 因为字符串确实是，基本上是
所有这些字符的集合。如果我们 想访问一个特定的字符怎么办？
例如，这是第一个毕业生在这里 是 d，第二个格雷戈里在第三个
正确的？难道第四条记录是S，第五条格雷戈里 空间等等？如果我们想要怎么办
访问字符串中的特定字符 ？因为字符串包含很多
董事？如果我们想和弦内的一些 导演一起演奏怎么办？如何
我们可以访问不同的董事，例如 ，如果我们想访问第七个董事
字符串，我们怎么做？那么，让我们在 下一个视频中看到，我们如何索引不同的
字符串中的字符，我希望在下一个视频 中见到你。好的，在这个视频中，
我们将实际访问字符串 中的不同字符，有时称为
索引，术语切片基本上与数 组更相关，列表实际上是
不可变的结构，但我们会看到，
我只是比较一下，因为你可能会一 遍又一遍地听切片这个词，但真的
这个索引但我们有时会看到 索引或切片是你这两个词
可以互换使用，我们将在列表 中详细查看切片示例。和，
以及更详细的 NumPy 数组。但在这里 ，你只是认为索引和切片是
同样的事情。指数。例如，我有 这个，假设这是一个数组，并且
我想在这里访问它的第四个元素 ，第四个校正器元素是 E。通过
方式，这是一个变量，如果我想 访问索引的第一个校正器
数字，定位从整数零开始 ，即第一个校正器。
因此，如果我想打印出来，例如，如果 我访问，则会打印 g，如果我写
索引三，我们的意思是什么意思 是第四个元素，第四个元素是
他将打印什么，将打印什么，如果 我访问索引的第四个元素
对于 fi 访问这个东西或空间将被 打印，你将什么也看不到，因为
当一个空间被打印出来时，实际上，那里 没有打印任何彩色的东西，你可能会
想着哦，什么都没有打印出来，什么都没有 ，什么也没有访问过，其实是一个空格
校正器已被访问。所以，是的，我们 可以实际访问的更多，我们可以
实际上也访问字符串内的子字 符串。例如，我们要访问
例如，一个从索引 3 开始一直到 索引 8 的子字符串，但是
不包括索引八。所以它将包括索引 三处的校正器，也就是他
正确地在索引四，这是空间， 让我这样写空间。指数总监
五，哦，对了，读索引六，下一 条记录，是F，然后是空格，
是七，然后正确读八。所以 这不包括在内，可以访问。
这是包括在内，这是在里面，这是包括 在内。这不包括在内。所以我们可以
访问一个子串。所以从三点开始 ，八点结束。来看看吧
一个例子。几分钟后，您将再次回到 这张幻灯片。那么让我们
说我们有一个春天，让我们说，你好吗 ？你是谁？就是这样。那么让我们
去做。所以春天，好吧。我们真正 想要的是我们想要访问例如，
我们要访问元素要访问 元素，就得写方括号。
这是一个标准的符号。在 Python 中 。每当您有收藏并想访问时
不同的元素，该集合可能是一 个字符串，该集合稍后，我们将
看到可能是一个列表。也许元组字典可能是一 个集合。也许一个 NumPy 数组可能是一个
panda 的结构，我的意思是，任何是 集合的东西，通常它都被 It 访问
有不同的元素，我们想要索引 它们。索引划分是方括号。
索引总是从零而不是一开始 。在 Python 中。有一些语言
其中索引从 1 开始， 例如 MATLAB，索引从
一个，但在 Python 和其他几种语言中 。索引从零开始，其中有一些
好处或从一个开始它有一些好处 。所以从零开始是可以的
好的。因此，假设我们要访问索引 5 处的元素。索引 5 处的元素是
实际上是字符串中从零开始的第六个元素 。所以第一，第二，第三，第四，
第五，第六，所以我们的将被打印。所以让我们 看看。我们的打印出来了。让我们检查一下
检查此返回值的类型。让 我们检查这个元素的类型
是我们的字符串不同字符的不同 元素的子类型是什么类型
在字符串中？有哪些类型
那么它的类型是什么。所以类型也 是字符串。所以每一个校正器都是
也是字符串类型。在其他一些语言中 ，类型可能是修正器。校正器是
另一种类型，但在 Python 中，每 个字符也是一个字符串。更多的
比一个。正确性也是字符串，只要它们 是从字符串中访问的。好的，
例如，让我们访问第 3 个 元素到第 8 个元素。
所以结果是我们的 so 元素编号为三， 而不是三，实际上是从索引三开始，
这意味着第四个向量，即空间，然后 是 e、r、e，然后是空间，然后是
我们完成了。例如，如果你从三点 移到九点，比方说，然后集会
将是我们的原因，或者我们可能会从 ，例如，我们可能从一开始就开始。
例如，索引 0，我们可能会在索引 10 处结束，但不包括 10。所以
结果是，你好吗然后我的意思是，为什么 哦，而不是你包括在内，因为
那是索引号 10。和索引号 10。最后一个 索引不包括在内。伟大的。我们
字符串中也可以有负索引 。所以负索引只是索引
从右侧，而不是从左侧，例如 ，在负索引上。所以减一
指向最后一个校正器。例如， 你同样减去两个点到第二个
最后一个校正器，依此类推。所以减去一个 ，那就是成功了，你。同样，我们有负
三，这将访问为什么，或者我们 可能从假设开始，减去，从
比方说，减八，直到减 三，这意味着回到减负
八指数，然后移动到减三指数， 好吗？和减三。在这种情况下，
让我们看看结果是什么，那是什么？ 为什么是？哦，这是，我猜是这个
是？让我们来看看。所以这是 这个，你，这是减一减二减三，
那是一个 X 数字三。所以不包括 三个。不包括负三。所以
它必须停在这里。好的。那是 减四减五减六，减七加减
八。哦，太好了。所以应该打印，它 已经打印了。所以让我们说我们有
比负八，我们从负12开始， 升到负三。所以我们没事。
伟大的。所以我们也有负指数。 顺便说一句，这种获取这个
一种子串有时称为切片，我的意思 是，我们只是获取切片，
尽管术语切片在可变数据结构 中更受欢迎。什么什么
是可变数据结构吗？什么是不可变数据 结构？嗯，是的，我应该告诉
你现在，你可以改变，你不能改变 春天的任何校正器。那可能，
这对你来说可能是个坏消息。但是 一旦创建了弹簧，其中的元素
字符串是不可更改的。例如， 假设在第一位置，您想要
放置校正器。让我们看看，这是 不可能的。原因是，字符串是
一个数据结构，字符串是一个变量类型 一个数据类型是不可变的，不可变的，
是不变的。一旦创建，你就不能改变 它的内容，它们保持固定，你
不能改变它们，你不能改变它们 ，你不能从中删除某些内容
它。我的意思是，一旦创建，它就保持原样 ，您可以将其复制到另一个字符串中，您
可以复制和粘贴，但您可以获取子字符串并 复制到另一个变量中，例如，
但 s 的内容不能改变。
所以Python中所有的数据类型都是 不可改变的，内容是不可改变的。
它们被称为不可变的。而字符串是不可变 的。所以时间切片会产生更多
我的意思是说它在可变数据 结构中更受欢迎，即
虽然可变，但您可以交替使用 时间切片索引。但它指的是
大致参考获取子结构或子字 符串。在这种情况下，在
列表，它将是一个子列表等等。所以这就是 切片。是的。伟大的。我们为什么不
今年春天多一些乐趣？
是的，
让我向您展示这个排名的更多乐趣， 更多索引，假设您从索引零开始，
你转到索引 12，但不包括 12。然后你跳，你跳了 2
而不是一个，我们要做的是，它 将从索引开始获取所有校正器
零，一直到索引 12，但不包括 12。但它会跳两个而不是
而不是跳两个。所以首先大于两 次跳跃，然后选择一个校正器，
然后跳两个，然后选择一个校正器。 所以它实际上会选择所有其他字符
从零开始。所以让我们看看。例如 ，如果你记得字符串，那就是
字符串。所以它从 h Fine 开始，然后 跳过 Oh，然后转到 W，然后跳过 Bass
然后转到 a 然后它跳过 R 转到 E 然后 跳过空格然后转到 u 然后它跳过
哦，然后去一个鞋子，然后云实现，我们 就停在那里。哇。所以一般方式
切片或索引的一般方式是你有 一个开始下一个开始，然后你有
一个索引，然后你有一个步长 。如果不提步长。步骤
默认情况下，大小是我们已经 在做的。如果不提结局，
默认结束是建筑物和总列表 大小。如果不提开始
默认开始为零。例如，让我做 一个评论，然后练习一个
例如很少。让我们从零开始 我们不提开始让我们从
如果不提及从头开始的起始索引 ，则为零并转到 12
零到 12 点 好的。如果我们不提例如 ，我们从三个开始，我们做
没有提到结束，这意味着从 索引三开始直到结束，包括
最后一个校正器 好的，如果我们不 提及步骤，例如，如果您从一个开始
一直到12，我们没有提到步骤 ，默认步骤是1。有一个
扭转弦的方式，我的意思是非常漂亮的 方式我的意思是，你不你不开始
提你不提开始，不提 结束，然后就
以这种特殊的方式采取减一的步骤 。开始和结束索引他们是他们
只是被扫过，你就可以反转字符串了。 虽然如此，但反过来很棒。是不是
这么花哨？是的。好的，关于索引 的很多，你可以找出任何长度
string 通过使用 l m 函数，您可以根据 需要找出任何子字符串的长度
如果你有一个子串再次使用灯功能， 外星人，那没关系。好的，现在
您已经了解了如何访问子字符串以及 我们如何无法更改字符串的元素
因为它是不可变的，但是我们可以访问它们 ，我们可以访问它们，我们可以只显示
他们，我们可以分析他们等等。在下 一个视频中，我们将看到一些功能
提供用于字符串处理，我们可以用字符串 做什么，我的意思是我们如何操作
那些字符串，虽然我们不能操作字符串 的内容，但是我们可以复制
一个我们可能会得到解释的字符串，对其进行 操作并将其保存到另一个变量中以及如何
字符串数据结构字符串 中有哪些可用的函数
数据类型。让我们在下一个视频中看到这一点。 希望在下一个视频中见到你。好的，让我们
查看可用于演奏弦乐的不同 函数。在这密密麻麻的弦里
数据结构，假设你有很多空格 的字符串，这些是很多空格
开头和结尾有很多空格 ，中间有一些空格
以及。所以，有一个函数叫做 strip所有字符串的函数
通过取一个点来调用一个点的东西 这些被称为方法，你可以松散地调用
它们是函数，但是那些 与某些数据结构和
用点调用，它们有时被 称为方法。术语方法与
面向对象编程实际上字符串是一个 类。所以所有这些都是方法 但是
即使不知道它完全没问题，你 也可以称它为方法或函数
完全没问题。你可以，我的意思是，没 关系。不知道什么是班级也没关系
在不知道面向对象编程是什么的情况 下，这是一个运行的函数
就这一个。
方法和函数的一个区别是当你 用一个点调用一个函数时，你
调用一些函数，比如点条。 然后在函数的定义里面，
this a object 或 a 变量可用， 就像您已将该变量传递为
一个输入参数。这就是您需要了解 的物质和功能区别的全部内容，
故事的其余部分完全没问题。即使 你不知道那也没关系。好的，
8 outstrip，它对 a 进行操作，这意味 着 a 在此函数中作为刚刚传递
作为输入参数或者它在 函数实现中可用。进而
脚本函数，它的作用是删除 开头的所有空格，
并删除末尾的所有空格，并返回 另一个具有该空格的字符串
开头没有空格，结尾没有空格 ，复制新的字符串或者
在变量 b 中创建，让我们说我们相信 我们能做到的，我们可以有另一个
该变量的名称。所以让我们看看。 来看看这个脚本函数的运行形式
在我们的朋友 Jupyter 中。笔记本。所以 假设 a 是一个字符串变量。这是很多
空格 abcdef，很多空格和 hg gilwell， 等等。然后有很多空间，那就是
它，这是一个，然后我们有 B，比方说一 个点带。好的，这就是冲刺 B。所以
b 实际上是没有空格的所有内容，没有 起始空格。没有结尾的空格，
它不会伤害里面的空间。所以这 就是脚本函数，有时处理
数据。当我们从一个文件中读取 数据时，它可能有很多空格
从最后开始，可能是由于格式问题 或类似的问题，就是这样
功能可用。如果我们想从开头 或结尾删除这些空格。
让我们看看更多的功能。另一 个功能较低，顾名思义实际上
它实际上将所有字符串转换为小写。例如 ，假设我们有一个字符串，让我们
比如说，a B，A，假设我们有一个字符串 ，a 等于 A、B、C、D、E、F、G 和一些导演，
其他一些导演和 Q f，让我们说这是一个 字符串。现在我们所做的是 b 等于 a
点更低。它的作用是将所有字符串 转换为小写。对于字符
已经是小写的。它不会伤害 它。对于一无所有的角色
与小写大写有关 ，所有不在
小写和可以转换为小写，那些 转换为小写。和这个
可用。是的。伟大的。类似地，我们 有另一个名为 upper 的函数，例如，
C 等于一个点上，顾名思义 ，它转换所有字符
大写。好吧，让我们看看更多的功能 。哦，有一个功能替换替换
功能。它的作用是获取一个子字符串 并用另一个子字符串替换该子字符串。
好吧，让我们看看。例如，假设我们在 这里我们想要拥有相同的 a，让我们
说一个就是这个东西。假设这是 一个我们想要做的就是我们想要
用分号替换分号让我们说 用分号，我们要替换
带静力学的分号。所以我们能做的就是 我们可以说好的，d 等于一个点替换，
用空间代替分号。或者，是的 ，让我们看看 D 是什么。
所以每个分号都被一个空间取代 。顺便说一句，如果你想更换
例如，一个，一个暗替换，如果你 要替换一个是有一个分号一个
带字符串的分号。例如字符串 是star star, and, and hashtag or some
人。这意味着一个分号将被这个替换 ，用这个字符串查找，另一个
分号也将被这个屏幕取代。结果 将如预期的那样，每个分号
将被屏幕取代。这就是结果， 如果你愿意，它会更进一步，
例如，如果你想要，例如，假设 d 等于 一个点替换，如果你想要这个
特定的子字符串，包含两个 分号，如果你想要两个分号
要被另一个子字符串替换，假设 两个分号，假设。那就是
也可能我的意思是，你用另一个子字 符串替换一个子字符串。对？有
还有一个函数叫做 split。例如， 它所做的事情就是分裂所做的事情，
你有一个字符串，例如，假设 a 等于 一个字符串，假设，ABC，那么你
有这个冒号，然后你有 df，然后你 有分号，然后你有广告 g y，还有
丹分号，然后你有 y y 3223。就是这样 。那是你的字符串。假设你读了
来自某个 CSV 文件的那个字符串消失了。 现在你想要什么，你想要所有这些
要分离的值是由分号分隔 的值，也许这些
是不同的值，ABC是不同的值 ，然后用分号分号隔开
可能是下一个值开始的指示或 标记，依此类推。假设你想要
要将它们分开，假设您只想使用 特定的拆分器将它们全部拆分。
在这里，假设分隔符是分号。所以你 可以做的是你可以有一个列表
和一个点分裂。在拆分中， 您可以指定用于的校正器
在我们拆分之前和之后拆分 。记住， split 函数实际上
返回一个字符串列表，其中这是 列表的第一个元素，这是第二个
列表的元素，这是列表的第三个元素 ，这是列表的第四个元素
名单等等。因为一旦分开 ，就会有不同的元素
那是分裂出来的。因此，例如， 如果您的品牌，我们将列出不同的
优势，ABC等等，哦，不用担心 单一的代码，单一的核心和
双核是一回事。现在我们可以 访问例如第三个元素或
也许是索引一的第二个元素。这里 的第二个元素是 D、E、F，我们
可以在这方面做更多工作。好的。是这样 吗？我的意思是？这些是唯一的功能吗
可用的？剥离函数降低出生地和分裂 函数？或者就是这样？那是
所有的春天是什么？也许还有更 多功能？里面有多少个函数
细绳？我们如何使用它们 ？函数总数是多少？在哪里
是名单吗？大家访问文档？我们 应该遵循一些书吗？我们应该去
一些教程并找到所有字符串函数并查看 如何使用它们？好吧，如果你愿意
要做到这一点，你可以做到这一点。但还有 另一种聪明的方法。假设 a 是一个字符串
你知道，你写一个点，然后一 个按标签，以及所有的东西
在字符串中，他们会在几件事情 上出现在你面前。你可以
去这个，你可以去那个，你可以 去那个等等。所以你可以检查
例如，如果您按 a 及其作用 ，让我们看看 a 的文档。它是
一个字符串对象和所有这些东西。美好的。这是 一个字符串。因此，我们可以做进一步的事情。
因此，让我们说 a.we，按 A，然后按 Tab。 有没有什么东西是从a开始的
不？有没有从B开始的东西？没有 。有没有从 C 开始的东西？
是的，大写案例折叠中心计数 。这些是可用的功能
从 C 开始。
好的，让我们专注于大写。好吧，那 是什么东西怎么用呢？那是按
冒号，问号，看看这是什么 以及它做什么。好的，这是文档
这是一个返回大写的文档字符串 。我曾经担心字符串大写版本
的字符串。和上层一样吗？也许？所以 让我们看看。现在我们知道它的作用了。
让我们检查一下，打印一个大写， 看看结果是什么？哦，它有哦
不，它不会延迟整个屏幕， 是吗？他们有屏幕吗？
不将整个字符串大写？什么是什么 ？让我们看看什么是？ A 如下
string 是以下字符串，因此它不 会将整个字符串大写。哦，区别
大写之间也许？而上层呢 ？遇到的时候是大写吗
当它遇到？不，不，不大写只 是大写第一个校正器。让
我让我再次阅读文档字符串，返回 字符串的大写版本，更多
专门使第一个校正器大写 ，其余小写。好的，那个
意味着如果我们有一个混合值的字符串 ，大写的将执行以下操作。
它会将第一个字符转换为大写， 并将所有其余字符转换为小写。
哇，好厉害的功能。例如，如果您 有字符串、abs D、A、B 和 GG，请杀死
那说。然后我们称之为大写，大写，让我们 说。那么它实际上是做什么的
将第一任董事和所有其他 董事按原样大写。和
还有其他功能，一个点一个点， 让我们看看计数，它是做什么的
什么不算。那个东西是什么？让我们 来看看。或者我们可以检查
使用帮助。什么是零计数？那么让我们 看看什么是负载计数。这是一个建
在称为事物的函数中是一个 实例，它返回一些不重叠的
子串的出现。哦，我的上帝，如果 你是我的意思，那就是它是什么
写在那里，子串的非重叠学徒 。厉害了我的天。所以基本上，
有很多可用的字符 串函数，有几个
琴弦的使用，有几种方法 可以塑造和演奏琴弦，有些
在可用的功能中，有些您可以 自己制作，您可以自己制作
在此之上的模块，可以根据 您的要求定制您的编写。
其中有很多可用，您应该知道 如何使用它们。首先，如果你
想对字符串或 Python 中的任何数据 类型做一些事情，首先检查是否
某些方法是否可用。一种方法 就在离这里不远的地方。和
其他上网方式，看看我想用 Python 来做这件事。带字符串，是否
是否有可用的功能 很 有可能会有内置功能
这是可用的。在这种情况下， 我会鼓励使用该功能而不是
自己写一个，因为使用内置函数 ，或者绑定的方法
可能会比你最后编写 的函数快得多
即使你在算法方面太聪明了。是的 ，
所以这就是弹簧问题，还 有很多其他方法可用。
在下一个视频中，我们将看到更多一些 更多的操作和处理以及一些
更多地使用字符串。然后我们将转向 其他数据结构。好的，希望
下个视频见。在上一个视频中，我们 看到了一些字符串的方法。和
这些只是其中的一小部分，很多都 是可用的。我们只是讨论了一些
其中。在本视频中，我们将以特定 的方式更多地讨论字符串。为了
例如，如果您想找出字符串中是否 存在特定子字符串，该怎么办
或不。假设您有一个字符串并且 您想知道某个特定的子字符串
字符串里面有没有？好吧，您 可以使用 end 关键字轻松找到。
同样不是 in 意思是那个的相反 ，或者那个的补充或者不是
那。而 in 关键字 always 将返回 true 或 Boolean 或 false。如果在里面
屏幕，如果它不在里面，它将返回true， 它将返回false。所以让我们检查一下
这是在，在，在 Jupyter Notebook 中的实现 。所以让我们看看。所以让我们说
我们有一个字符串 ABC ABC。我们想检查 这个字符串是否存在于这个特定的
字符串与否。所以返回值是假的， 因为 ABC 作为子字符串不再存在。
A在那里。例如，在这里，B 在这里，但 ABC 不再存在。是的，所以如果我们，
例如，在某处有一个 ABC，至少一次 ，那么结果就是真的。在里面
最后，在最后一个视频中，或者在第一 个关于优势的视频中，我向你展示了
您可以将加号与字符串一起使用，您可以使用 小于或等于来比较两个字符串吗？一世
意思是，如何比较两个字符串，不管 它们是否相同，例如，ABC，就是
a 那是一个字符串 ABC，我想检查该 字符串是否与 ABC 相同，是什么
会是结果吗？所以问题是，这个 double 等于 is used 可以是
用于比较两个字符串？嗯，答案 是肯定的。或者是什么意思
小于一个字符串作为小于另一个 ？真的吗？例如，ABC，小于，
让我们说 df。真的吗？例如，如果它是 真的，它的真正含义是什么？如何
我们可以定义一个字符串吗？我的意思是，这 个字符串比另一个字符串少，也许这个，
也许这个运算符是根据字符串 的长度工作的。但即便如此，
那么这个长度和这个长度是一样的 。更准确地说，我们可以改变它
长度，例如，只是说，好吧，ABC，D，F，G，H，I， 我猜这个字符串
仍会小于正确的字符串。那么这种 比较是如何运作的呢？嗯，我
猜测比较是根据字母顺序 进行的，你知道，
字母顺序，B 在前，B 和 C 以及所有字母顺序
英文词典里有没有。这就是字符串 在这里的工作方式。和字母表
所有特殊字符的顺序也将 在 Python 中定义，例如，
一个特殊的毕业生，例如，也许 这个字符串比下面这个字符串小
细绳。是的，我们已经为 false 做了， 因为有特定的排序。在，在 Python 中
这是为这些字符定义的，这 成为第一个，就像，一个变成
第一个和B，B变成第一个和C，依此类 推。所以无论字母顺序是什么，基于
或者你可以比较两个字符串，没 问题。所以这些也是可用的。和
第三件事是在函数中也 可用于检查特定字符串
is inside a substring 是否在另一个 字符串中。我想要的另一件事
例如，如果你的目标是打印 以下内容，让我们来谈谈
假设您要打印以下内容，我们 正在学习。假设你想
用双引号打印字符串。我们在 这里学习字符串。假设你想
打印这个，你想让这个字符串出现在双引号 中，你怎么能在 Python 中做到这一点？
嗯，看起来是一样的。有什么困难 ？让我们调用打印函数。进而
就像在这里一样，我们正在学习。然后 在这里写双引号，刮。和这里。
就是这样。但有一个问题。原因是 ，原因是当我们调用它时，当
我们写这个双重代码，实际上，字符串到这里 结束，正好字符串到这里结束。和
当我们编写这个单一代码和这个双重代码时 ，另一个字符串从这里开始。和这个
不再是一个字符串。我的意思是，它 里面没有数据类型。那我们怎么能
在里面插入这些双引号？嗯，有几 种方法。一种方法是使用转义
序列和转义序列就像你使用 斜杠然后使用任何东西一样
被视为校正器。如果你想要另一个 ，在你现在正在使用的字符串中
双引号，您使用用户校正器 ，它是反斜杠或正斜杠
如果你使用它 那意味着 它面前的任何东西都应该
按原样使用，而不是考虑 这是一个特殊的字符串定义
象征。现在在这种特殊情况 下，您将获得双引号，并且
反斜杠刚刚出来，这是有道理的， 不要碰这个双重代码，它有
与定义字符串无关。只是 因为我想突出这个词。
还有一个。另一种更简单的方法 是使用单引号，例如，我们是
学习并使用双引号作为校正器。现在 里面的单引号，无论在哪里
它开始和结束，他们定义了字符串， 其他一切都是正确的。我们不需要
一个逃生饼干，我们想去哪里，好吧 ，太棒了。但是有很多转义字符，
例如，我们有 V，我们的反斜杠 n，这意味 着转到新行，我们现在在另一个
线。所以这个反斜杠 n 实际上把后面的所有内容 都放到了一个新行中。那是一个
逃脱修正器。类似地，我们有一个转义校正器 ，反斜杠 D，它实际上插入
一个选项卡。每当我们想要 Sophie 时，然后一个选项 卡，然后现在在另一行，现在在另一个选项卡上，
任何。所以有很多转义字符。我 在反斜杠，N，反斜杠 t 有
其他。所以知道这些是很好的。还 有一件事很重要。例如，让我们
说你想打印。假设你想在右边 打印一些地址，让我们
看，Mac 的斜杠反斜杠正斜杠不管 叫什么名字，反斜杠博士。
假设您想这样做。你的目标只 是打印那个盒子，会发生什么
这个反斜杠 n 将被视为换行符转义序列 。反斜杠 n 会告诉你
好的，转到下一行并创建其余的 东西。但是因为反斜杠 D 是
不是任何转义序列，它没有 列在里面，它被按原样对待
这个斜线也被视为导演。但在这里 因为如果这个斜线后面跟着
这个 n，这是一个已经存在的组合 ，用于在一个新行中处理
不同的方法。如果您希望将其用作 deus 而您不想要这些，则不要
想要这种行为，您只是希望所有 这些都应该以非常文字或
原始的感觉，那么你应该申请并且在 我们的意愿中告诉，好吧，那就是，
这是一个原始字符串，里面的所有东西 都把它当作一个原始字符串，没有转义
里面的顺序。伟大的。所以还有更多关于 字符串的内容，我们可以谈论但那
是我告诉过你的最重要的，至少 对我来说，我们可以探索更多
其实，你现在应该探索更小的字符串 还有哪些其他功能，怎么能
我们以另一种方式玩弦乐
很快。如果我谈论弦乐，我的意思是 ，我可以讲一整门关于弦乐的课程
以及。但在这里我只是给你一个字符串的快照 。如果您需要更多关于字符串的信息，
我的意思是你应该在互联网 上搜索查看文档和基本查看
根据您的要求，您想要什么， 搜索可能它们将是的功能
可用的。好的。在下一个视频中 ，我们将介绍列表倒置、集合和字典
我们之前讨论过的其他一些数据 结构，我们将要探索
下一个视频中更详细地介绍它们。希望 在下一个视频数据结构中见到你
非正式地或非常幼稚的意义基本上 是许多基本数据类型的集合
包含数据的一种结构包含大量 数据。我们有时可以定义几个
方法和几种特殊类型的函数 被定制和定义只是因为
该数据结构可以有效地执行不同 种类的我的意思是针对不同种类
在任务中，我们可能必须定义或我们 可能必须选择不同类型的数据结构。
Python 中可用的基本数据结构 是列表元组集和字典。
这些是可用的基本数据结构。 我们可以创建自己的数据结构
如果我们愿意。但是大部分问题几乎 所有问题大部分都解决了
通过这四种基本数据结构。虽然其中 很多都不是那么有效。那里
是定制类型问题的有效 方法，我们将看到效率
我们将处理比所有这些 都快的包 NumPy，但是
但我们会看到有什么样的限制可以 让它更快。总之，数据集
在一个非常松散的术语中是集合 ，它是很多值很多数据的集合
里面。所有这些数据结构都列出 了元组集和字典，它们是一个
异构类型数据的集合，这意味 着一个值可以是另一个整数
元素让我称一个元素，另一个元素或 项目，另一个项目或元素可以是
字符串类型，另一个元素可以关闭 ，让我们说浮点数另一个元素
是一个完整的列表本身，另一个元素 是倒塌，依此类推。那么不同的元素
可以是不同的类型。这使得 这四个数据的异质性
结构更适用，更抽象。 它们几乎可以应用于
所有的问题。所以让我们一一看看， 让我们把它们放在一起比较，因为
理解其中四个的最好方法 就是比较它们可以做什么
其余的。因此，让我们对它们进行比较 ，并了解如何详细使用它们。所以列出
首先是列表 列表是有序的 在这里排序 意味着它是可索引的，这意味着有
一个特定的第一个元素位于第一个 元素的位置，元素有一个排序
第一个元素第二个第三个第 25 个 元素，有一个元素的顺序
他们的位置。所以这就是我们所说 的有序可变或有时称为更多的意思
更合理的术语或更有用的术语是 可变的。可变意味着一旦创建列表
与字符串相反，一旦创建了列表，您 就可以更改其元素，例如，您
可以用另一个元素改变第三 个元素，这很好，你可以
改变它，我们所说的可变 或更普遍地称为可变重复
意味着列表可以包含不止一个 元素，我的意思是，在位置
第三，你可以有相同的项目和 位置第五你可以有相同的
项目，所以重复项是允许 tupple 然而，虽然有序，有
元素的排序有不同元素 的索引，这是不可变的，
你可以像字符串一样创建推翻 。模板一经创建就无法更改
元组中的不同元素，如果您愿意， 您必须创建一个新的倒置，但是
您不能更改元组中的项目， 并且允许再次设置重复项
另一方面是无序的，这意味 着没有索引没有定位，有
没有第一元素，没有第三元素， 没有第五元素，就是这样
没有实际索引的集合
因为您无法使用索引访问特定元素， 所以您无法更改它，但是什么
你可以做到你可以插入更多元素 ，如果你可以删除现有元素
想要。同样，数学集合中的集合 不包含任何重复项。所以一个
item 只出现一次，我们将看到示例字典，其中 包含非常、非常、非常强大的数据
结构体。再次，它是字典就像一 个集合，它是一个无序的集合。
再次，机会鞠躬，您可以更改它们， 但您可以更改您可以更改的项目和字典
口袋，它没有重复，因为 它基本上是一套它只是
就像我说的，字典的力量是每 个项目由一对和一个组成
啤酒中的一个值称为键，另一个 值称为值，例如，well 是键
对于 12 名称是乐队等的关键。 所以我们之前看过这本词典
循环和东西只是一种非常松散的方式 。但那真的是一个非常非常强大的
数据结构。稍后我们将在pandas中 看到基本上所有的数据都是
管理，就像一本字典，如果 你对字典有很好的了解，你
将很快掌握大数据科学 图书馆或大数据
被称为pandas的科学包，因为pandas 中的每一件事都被处理
就像你在处理字典一样。所以这 是一个非常强大的数据结构要知道
关于。
所以，所以
列表是可变的 字典是可变的 集合是可 变的，从某种意义上说，您可以插入
并删除元素。 topple 是不可变 的。这是理论上的比较 什么
在那里，所有这些类型，每 一个都是不同值的集合。
并且值可以有不同的类型。这 就是所有这些的抽象力量
数据结构。所以，在下一个视频中，我们 会，我们会，我们会真正尝试得到
很好地掌握字典中设置的列表倒置， 我们将实际定义它们的代码和
访问这些不同的方法， 我们将努力变得舒适
通过用 Python 编码来使用这些 数据结构。所以希望能在
下一个视频。好的，继续在之前 的视频中我们讨论了数据结构
最后一个视频。所以让我们去 Jupyter Notebook 看看如何定义或声明列表
如何定义或声明元组集和字典 ，让我们看看我们如何制作
Python中的这些数据结构？那么接下来 我们将一一比较如何访问
列表的元素？我们如何在列表中 插入更多元素元组在字典中
并查看所有这些操作的比较 。所以让我们看看。
所以让我们转到 Jupyter Notebook，我们的 朋友这个文件越来越长，冗长，让我们
让我们制作多个文件。假设这是第一 部分。只要保存它。让我们做
另一个让我们制作另一个文件。例如 ，让我们关闭这个文件，或者说
打开，让我们关闭这个文件并创建另一个 文件。蟒蛇三。是的，让我们命名它
文件作为第二部分，让我们开始一个 新文件，该文件所在的文件可以
也保留该文件。但是让我们制作 另一个文件。好的。所以只有
一个降价单元格。让我们有一个标题 。数据结构。记住降价单元格，
我刚刚介绍了他们，一开始就 介绍了那些。然后我们就忘了
他们。因为一遍又一遍地写这些描述 ，我们将在这里制作视频长度。
目的不是真正格式化笔记本 ，目的只是为了显示
你是 Python 的力量。所以我只 是越来越省略写这些描述，
但是只要在星星上写一些描述，然后 我们就会再次忘记。哦，那是
它。太棒了。让我们看看，找到一个列表。 所以列出来。任何变量名，就是一个变量
在列表中，让我们这么说吧。您 通过方括号和不同的元素来定义它
它们用逗号分隔，即 134，第 9 点 。说出我的意思，或五个，
或者也许又是三个。这就是清单 。好的。另一方面，韧性是
使用括号定义。所以让我们说 134. 第 9 点。就是这个名字。这是一个
再次三，没关系，这是一个元组 。元组定义在。所以当你写
括号，这意味着默认情况下推翻变量 名我的意思是，如果你有
写 t 与它无关，它是一个元组 。那是因为 Python 是动态的
打字。当您写括号时，表示 正在定义元组。让我们
定义一个集合 让我们把这个变量称为 S，这个集合是用这些大括号定义的。
所以让我们说 134。
第九点，我想告诉你，他们可以包含的 所有这些东西，每个元素都可以拥有
一种不同的类型。但是，即使我们再次 包含这三个，因为集合不能包含
副本，稍后，我们将看到 集合中只有三个副本，
另一个会，即使我们想包括它也不会 被包括在内。好的？那么让我们
说字典。字典再次被定义为一个 集合，但每个元素都是一对，
用冒号隔开。假设键值为 23 作为键值，即键和
价值。这是一个字符串，让我们说
二，
三，那就是看价值了。现在逗号 。现在有一个元素。这一元素
由键和值对组成，另一个元素 ，另一个元素可能有一个键
细绳。所以键可以是不同的类型 ，值可以是不同的类型，
如此抽象。所以关键是，让我们说， 让我们说 B. 而这个的价值是，让我们
说 43，那么也许我们可以有另一个 键值对，键为，比方说，c。和
值是，比方说，cc。 CCD。那是电荷耦合器件 。好吧，无论如何，所以。
再说一次，现在你知道如何定义 less 如何 定义一个topper，如何定义一个集合，
以及如何定义字典。区别在于 ，这里的主要区别在于字典，
因为一个元素由两个值而不是一个 值组成。好的，让我们打印出来
查看类型让我们打印所有类型 sprint 消失 了。所以让我们画它们。那种
L是。所以表 L 刚刚打印出来。那是 L， 让我们打印出来。让我们看看其他类型，
让我们也打印其余的。所以只需 复制它们，B 是列表的类型 L 是
倒塌的类型是 D。那是 D，然后 我们有 s 然后我们可以替换它
到 s。然后我们有，比方说，D 字典。那 就是，那是 D。好的，就这样，
所以L的类型少了t的类型推翻 了s的时间。 D的潜水
是字典。哦，太好了。这就是您可以定义 这些列表的方式。您可以定义列表
你可以找到topple，你可以定义set，你可以 定义dictionary，没问题。下一个，
让我们看看如何从这些数据结构 中访问不同的元素。什么是
例如，从列表中访问元素的 方式，让我们说元素编号
以 1 为索引的元素记住以 1 为索引的元素是元素号
二，因为索引从零开始。所以 你可以使用方括号访问它。
如果您想从与列表完全一样的 方括号再次从 topple 访问。
例如，在集合中，您不能索引它，因为 集合没有排序。第一第二第三
元素不再存在。但是你可以，你可以 ，你可以检查一个特定的元素是否
是否存在于集合中或未使用 in 关键 字。在字典中，例如，如果你想
检查特定元素或是否要访问 值，对于特定键，
您只需创建字典变量名称，然后 写入密钥，它就会返回
价值。好的，让我们在木星上练习 一下。让我们在木星上练习一下。
因此，让我们说索引 1 处的列表值。所以这 是全新的，这个列表添加了下一个，价值
应在索引一处打印为三个品牌 倒塌，再次，访问方式
相同的布伦特布伦特，无论是否三 个在s中，返回值都会是返回值
将是真的或假的。所以打印将 是真或假。然后打印并访问
键为 23 的值。让我们看看会发生什么 。所以我添加的索引一是三层
索引一是三个s，三年在S 是的。
键 23 的值是多少？该值 是值是二三。让我只要
描述更多关于这个 D. 例如，索引 B 的值是多少，现在我们必须给出
字符串格式的索引 B。那是 43。是的， 这就是我们可以访问它的方式。让我们
sprint s 也让我们看看 s 因为当我们 定义为我们已经定义了这个重复
三 但是如果你看到 s 的元素， 就没有重复的了。它不保持
即使是任何排序，我的意思是，我们 以不同的方式定义了 s，它维护了一切
也许以不同的方式，一三。是的， 哦，这样的顺序是一样的，但是
第一个或第二个或第三个元素没有 索引，依此类推。好的，就是这样
关于定义、声明或访问不同的元素 。在下一个视频中，我们
实际上会看到更多关于数据结构 的信息，实际上想花一些时间
关于数据结构，因为这将 是数据科学的基本构建块
包也是。如果我们非常了解 这些数据结构，这些数据结构，
我们将非常流利地使用数据科学 包并与之合作。好的，希望
下个视频见。好的，在上一个视频 中，我们定义了 less topple set 和
字典，我们实际上访问不同的值 。在这个视频中，我实际上要
我将实际介绍更多的索引，特别是 如何访问列表和推翻，
因为两者都非常非常容易索引，就 像字符串一样。我想告诉你
您在字符串中看到的各种索引 ，完全有效，列表以及
在元组中。所以让我们去木星，看看什么 是列表，例如，一个列表，如果你
打印列表，就是列表，它有这些类型 的值，如果你只看到列表，
例如，从索引 1 开始，到索引 3 结束，这意味着相同的大
例如切片。所以索引一值是 三，索引值是 4.9。而最后
元素不包括在内。所以，如果你得到了， 你就会得到 3 和 4.9。所以完全一样，
您在字符串中看到的相同类型 的索引，正是在这里工作
以及。例如，如果我说列表，从 头开始转到 N 但然后我只是
给减一它将反转整个列表，我的意思 是整个列表将被反转。我是
同样，我们在字符串索引中 看到的所有内容都保持不变
在 list 和 topple 中相同，所以 topple 例如，让我们从 let 访问元素
说从一开始直到第三个 元素，那不是第三个元素
直到索引三，实际上是第四个元素 。所以推翻除非他们完全
它们将完全按照原样进行索引。 所以所有的切片所有的索引都
子子列表，所有子子列表，它们 可以完全相同的方式访问
就像你一样，你已经通过了 字符串。这里的一个区别是
我稍后会解释，因为列表是可变的 它是可变的，我将讨论一件事
切片时使用的那个，当你得到一 个子列表时，它实际上是指
相同的内存，如果您更改子列表内容 ，实际列表和弦会发生变化。那
切片中的列表也是如此。对于 集合和字典也是如此，在
复制引用等。所以我稍后会 讨论这个。但剩下的事情
与它们在字符串索引中的大致 相同。实际上，索引几乎是
在 Python 中到处都是一样的，如果你知道 的话，它的这种切片几乎是一样的
索引，如何索引平面，你知道如何索引列表 ，如果你知道如何索引列表，
您知道如何索引对和字符串以及 所有内容。顺便说一句，如果你
知道如何索引强度列表，您将非常 流利和使用 NumPy。这就是非常
强大的数据结构。这是一种非常 强大的数组处理包。与
我们会看到一些防御措施，但是
当您处理大量数据时，即使 在熊猫中索引也是相同的
文件和诸如此类的东西索引或多或少 与您在仪器中看到的相同
我们将更详细地介绍索引 、屏蔽和奇特的索引
在 NumPy 中。但这与你在中看到的一样 ，在优势上 好的，现在可以了
我们可以扩展列表 我们可以添加更 多元素吗？我们可以插入更多元素到
列表？答案是肯定的。因为列表是可变的。 新麻烦你可以插入更多的元素。
插入那里的一种方法是调用添加 运算符，您可以添加加号和
您只需插入其他列表，就像两 个字符串由加两个列表连接
可以连接，或者通过加号再次组合 在一起，但有一个更快的功能
称为追加 l 点追加。这有时比我们 将看到的使用此运算符更快
那会推翻，因为它是不可变的。你不能 触及你不能触及的替身的任何内容
实际上将任何元素插入到翻转中，您 不能将任何元素删除到元组中。那里
例如，是变通方法，将元组转换为 最后一次更改，然后转换列表
到一个元组。有办法做到这一点。但是 真正意义上的 tupple，在字面意义上，
它是不可变的。你不能插入任何元素 你不能删除任何你不能改变的元素
任何元素。但是，您可以组合两个 元组。在一起，你可以连接两个
通过加号运算符再次将元组组合在一起 ，并将结果保存到可能的新双精度中
放。您可以使用 add 函数插入 元素 add 函数允许您只
插入一个元素。如果你想插入 多个元素，那么你可以调用
一个实际接受多个的更新函数， 该函数接受另一个需要的集合
被插入。那是可能的字典， 您可以仅通过新键插入新键
等于您只是为新键分配了一个 新值，并且刚刚插入了键值对
太好了，您可以使用 D l Command D 从列表中删除或删除任何元素
l l 表示从可能的列表中 删除此特定元素。
从元组中删除特定元素是不 可能的但是，您可以删除
整个变量整个推翻是可​​能的， 您可以使用从集合中删除元素
删除功能为点删除，然后 您只需提供要删除的元素
尽可能将其删除，您可以 删除整个删除整个变量
那总是可用的。同样，您可以 从字典中删除特定项目
例如，通过调用值的 D 来 删除，无论键是什么，
所以你用钥匙调用并调用删除 它会删除我想提到的所有内容
这里用于从列表中删除项目 还有其他方法和功能
可用我的意思是有一个删除功能，有一 个弹出功能，这些都是可用的。
同样，从字典中删除 元素，还有其他功能
可用。但只是为了比较它们，我使用 了这个 de l 命令，虽然有
也是做同样事情的其他方式。所以 让我们让我们结束这一切
视频在这里。在下一个视频中 ，我将向您展示所有这些连接操作
一起，插入更多的元素，删除不同 的元素，我会告诉你所有这些
Python中的东西。所以希望在下一个视频 中见到你。好的，在上一个视频中，
我们看到了如何将不同的元素插入 到不同的数据结构中。我们例如，
在元组的情况下，这是不可能的 。我们还看到了如何实际删除
尽可能使用不同的元素。所以让我们 去我们的朋友 Jupyter Notebook 看看
所有这些概念都以一种运行的形式存在。所以我们 走吧。好的，让我们举个例子，我们有
清单，这是我们的清单。让我们将一个元素 或更多的元素附加到列表中，即
L加。假设我们可以有另一个列表 ，例如
是
那是六个，然后你就是这样，这 两个列表将被附加到新列表中
将如您所见，我们可以使用 append 函数附加一个项目，例如
6.8 也将被附加，这将包含这些 类型的值。是的，所以
两个阵列都很好。这个加号是这个 加号可以用来追加到列表和
此 append 函数可用于简单地将带有 元素的列表附加到列表中。好的，
伟大的倾覆。你不能改变倒塌， 你不能改变倒塌。但是你什么
可以做的是你可以有两个元组，例如，T two 是不同的一对。假设一个 A
和 B，假设你有四五个，那 就是应该的，然后你可以
有第三个双，也就是双一和 双二的组合。而在这
情况下，你有双三，就是这样。 是的，所以双一和双二合二为一
在一起，但你不能真正插入到程序 集中，元组是不可变的，你
不能插入另一个元素，不能 删除现有元素，不能更新
任何元素等等。同理，作为集合 ，我们看看集合的状态，就是
set set God add 功能，你可以添加任何东西， 让我们如果在那里添加六个，以及
新的资产状态这个，或者你可以调用 更新函数。如果你更新方法，
如果要插入更多元素，例如 ，如果要插入多个元素
23. 再一次，假设您想插入一 个已经存在的元素。例如，
一，那么重复项将不再存在 ，但将插入新元素。
现在让我们看看D的状态，D的状态 是这样的。如果要添加另一个键
值对，你可以在这里添加一个键，例如 ，键可能是新的键，例如，新的
key 和 value 可能是 value 可能是， 例如，一个新值。那么，现在
如果你看到D，D，D的内容就​​变 了。嗯，这很简单。很好。
您可以使用加号运算符将两个字典 连接在一起吗？是否可以？是
可以将两个字典连接在一起吗？ 让我们看看我有另一个我有
另一个字典D字典二。那就是说 关键是为​​什么。和价值
为什么？然后我们有另一个关键字母 Z. 其值是。我们坐下，我可以吗
可以将 A D 和 D 两个放在一起吗？我可以 吗？我可以更新我的 D 并添加这些值吗？
在那里也插入这些值？好的。我把这个 问题留给了你。你试着回答
这个。在下一个视频中将回答这个 问题。但是试着回答这个问题
你自己。一种尝试的方法是 进入木星并潜水并检查是否
加号是否有效。或者也许有另一种 方法和类似的东西。好的，太好了。
希望能看到你。哦，我没用过 D l delete之类的东西。所以
这个问题就在那里，让我使用删除元素 。所以让我们说 l 是这个列表。
如果我想删除一个元素，让我们 说第三个元素，如果我想删除
索引三处的元素，即这个字符串名称 ，我可以简单地使用这个删除。而
L 是一切，但没有那个元素。同样 ，如果我想删除，我可以删除
S 中的任何元素，我都可以调用函数 remove。无论我想删除什么，让我们
说要删除游戏，游戏将不 再存在。
伟大的。如果我想从字典中删除一些 元素，再一次，让我们说那是
字典的视图。我可以调用 Add I can I can remove the element with key let's
说 C，无论带有键 C 的元素是什么 ，删除该元素，字典就有
这个项目的这个特殊状态，这个特殊的 项目消失了。好的，太好了。我可以
去做。但是 d L 并不是这样做的唯一 方法。有这么多方法。我的意思是，
有很多方法可以做到这一点。但只是 为了比较所有这些，我只是给你
尽可能多的相同点和不同点。好 的，太好了。所以我问过你
这个特定视频中的一个问题。我们 可以将两个字典连接在一起，特别是
带加号运算符？如果是，那么我们就完成 了。如果没有，那么还有其他方法吗？
这就是问题所在。所以希望在下 一个视频中见到你更多关于
这些数据结构。
好的，我上次问过你一个问题。我们 可以将这两个字典连接在一起吗
带加号运算符？那么你的答案是什么？是还 是不是？答案是否定的，是的，所以我们
无法将它们连接在一起，我们无法 在此字典中插入另一本字典
使用加号运算符。因为这个加号运算符 不是为字典定义的，我们可以
做的是我们可以调用一个更新函数，因为字典 也是一个集合，我的意思是，一组
键值对。但归根结底，它是一 个具有专门功能的集合，当然，
但是我们可以调用更新函数， 并在字典中插入整个新字典
如下。是的，所以答案是使用加号运算 符否，但是有一种方法可以使用
更新方法。对。那么接下来，我们 重点介绍复制功能，复制功能可用
对于较少的复制功能可用于 设置，复制功能可用于字典。
所以这里让我们看看这个复制功能 的需要，我希望你非常小心。因为
就是，这真的很重要。假设我们有一 个列表，比方说，那就是列表。和
顺便说一下，set 和dictionary 也是一样 ，不管我要对list 做什么，
让我们看一个列表。现在，你要做的 是复制列表 或者只是创建另一个变量，
就像你可以将 l 的值赋给另一个变量 l 2，你现在所做的就是 l
二是也有这个，现在这是两个不同的 变量，L是这个变量，l二是这个
多变的。所以你可能会认为我两个 是一个全新的东西。还有爱丽丝
新事物，您可能会认为两者都 是独立的。但是 Python 内部管理
数据结构，大多数数据结构的 方式是因为数据结构是
它拥有大量数据的集合消耗 大量内存，它的作用是
当您将一个变量或数据结构分配给 另一个变量时，实际上并没有
复制所有内容，它实际上并没有 创建新的内存，并存储内容
在这。实际上这个变量实际上也指向 与这个相同的内存。并且，
以及如果你改变任何值的结果， 例如，在 L 2 中，让我们说
您将索引从此更改为值，将索引 更改为值 4.9。现在你在工作
L 二，假设您将这个 L 值从 4.9 更改为 值。让我们 4.9。让我们看看你这样做。
所以你可能会认为这发生在 L 2 中 ，嗯，在 L 2 中，这已经发生了。
但它也做的是它在 L 中也做同样 的事情。所以我也会改变。这
原因是L和L两个，它们都指向内存 中的这个结构体。以及是否
你通过 L 接近那个结构，或者 你接近那个结构 2 l 2，你是
无论如何接近相同的记忆。这就是所谓 的引用，我的意思是，它不
创建数据，它实际上在内存中创建一 个引用来实际创建一个新名称
对于相同的内存。并且两者都指向 或访问相同的内存。而如果
你真的想要这样的行为，让我 两个变得不同于 L 和我什么我
用L做两个，那不应该影响L，那么你 应该调用copy函数。我两个是L
点复制。是的。这就是功能，我会复制 。现在你有我两个。现在你做什么都行
用L 2，它不会影响L。所以L 2， 例如，索引在索引2，你再次
说好吧，这是4.9。所以我有两个变化。现在 ，我有两个变化，但我没有改变，我没有
改变，我保持不变。现在这是不同的副本 ，相同的概念，随同一套。和一样
概念与字典一致。如果你只是 换一种方式将是两个 n
等于两个s，那么如果你改变s的内容 ，两个s就会改变。如果你不想
那，然后复制它 类似复制字典 ，因为推翻它们的内容
不可改变。复制功能不适用于 double。 因为即使你分配这个
T 到 T 2，你现在不能改变 D 2 因为它 是不可变的。所以有复制功能
在元组中没有意义。等待。
关于切片的另一件事。假设 您有 假设您有可用的戴尔
对你来说，那是 L 假设你通过 切片制作了另外三个列表 Let's
说一个列表，让我们说一到五，让我们 说。所以你从索引一开始，也就是
三个，你不包括五个就到五 个，这样，L 三个是自动的
一个副本，它不是一个子列表，它是引用。 所以我三个。所以我三是不同的我二
是一个全新的列表，一个新的内存视图 ，如果改变L中的内容，三，如果
你改变L三中的内容，例如，L三 ，或索引零，它应该从
三 比方说，三，如果你改变 L 三 中的内容，这些内容，这些
更改不会反映 L。因此，如果您进行 切片，则切片默认会选择一个副本，
它不选择参考。这是这个列表 和 NumPy 之间的巨大差异
数组，当你结束它时，我们会看到当 我们看到一个 NumPy 数组时，切片实际上
此外，再次引用相同的内存位置。 这可能是索引的一个不同之处，
在整个 Python 中建立索引，无论何时进行切片 ，都会得到一份副本。但是在 NumPy 中，
当我们详细了解 NumPy 时，在 NumPy 中， 当您进行切片时，您将再次获得视图
不是副本，如果您在切片 torian 中更改任何实际内容
也变了。并且有理由这样 做有一个有效率的理由
为了做到这一点，再一次， 点复制函数变成了复制函数
在那里也更适用。所以，所以，所以 你需要知道，即使你这样做，如果
你通常在 Python 中的任何数组中的任何 集合中进行切片，如果你这样做
甚至为像列表这样的可变对象选择一个集合， 你会得到一个副本，但是在 NumPy 数组中，
这些东西，这些东西，这个特别的 东西，还有很多其他的东西
但是这种索引方案实际上在变化 ，随着这种切片而变化。好的，
所以我是这里的这个视频，我的意思是，你 可以探索列表元组的更多功能，七
字典以及你可以用它们中的每一个做什么 ，以及你的意思，在哪种情况下，
什么样的东西更适合 对方完全看问题
在眼前。但是我们能做什么我们 将做什么我们将在接下来的更少
视频，我们将看到一些使用 just list 的一些功能。然后我就只是
让您探索元组集和 字典及其所有功能
你自己。并查看什么功能或什么方法 在做什么，为了什么，哪种
的数据结构。所以在下一个视频中， 我们将看到一些仅用于列表的方法
数据结构。希望在下一个视频中见到你 。就像在屏幕上一样。让我们一起探索
列表中有很多功能。虽然在， 在集合和字典和元组元组中，
以及。但是列表中还有更多功能可用。 顺便说一下，让我们看看有多少
东西在这个列表中。让我们说 l 点 选项卡，选项卡会打开很多东西
对我来说，阿班达我们知道已经清楚复制 ，复制，我们知道已经计数，我们不知道
知道 count、extend、index insert、pop remove 逆向这些函数中的一些。他们做了
通过调节器名称来感知。但是让我们一一 看看。让我们看看其中的一些。什么
他们是这样。一种方法是上网 看一些书或教程或其他东西
所以另一种方法就是写这个应用程序 。也许，也许帮助功能也许应用帮助
功能，它可能会帮助您如何使用它。 很棒，这个帮助功能很棒。如此遗弃
以对象的立场构建列表的对象方法 到列表的末尾。哦，它附加
一个对象到列表的末尾。意思是
我们也许可以将另一个列表附加 到列表中。你有没有想过。
append 方法只需要 111 个对象。也许 它需要很多列表。但后来它
一个列表可能被附加到另一 个列表中并且整个列表变成
一个元素，因为列表可以包含其他列表 作为元素，这是一个问题。是的。
所以让我们看看更多的功能。是的，所以 让我们看看清楚这清楚什么这是清楚
它能做什么？有时我使用帮助，有时 使用它从列表中删除所有项目，
哦，天哪，如果你明确表示列表是空 的，好吗？如果你只是打电话清除
列表中的函数将变为空。当心。好的，太 好了。还有什么？所以看到我有
这个功能可能，鲍勃，鲍勃看什么。 所以让我们看看。所以 Bob 移除并返回
索引中的项目默认为最后一个，这 意味着如果您也是默认值，请记住
默认值。所以，如果你调用一个没有 索引的部分函数，​​它会返回
它会删除索引 它会删除最后 一个项目 它会给你它会
如果您提供索引，则返回该索引， 它将删除该索引处的该值。它会
删除后它会返回给你。所以你可以在 任何你想要的地方使用它。所以有
例如还有更多功能，您可以 一一查看所有删除功能，
例如，reverse reverse，like，like， 顾名思义，如果你叫reverse
功能，列表将被颠倒。是的， 请记住，我们已经颠倒了列表
下面的方式也是如此，我们有办法扭转任何 方式，这种方式。所以现在如果你
看到列表又被颠倒了。所以我 想他们两个都在工作。相似地，
您可以从一组中探索多个功能， 然后说添加清除。清除可能有效
与交集交集和更新被破坏相同 的是另一个的子集。是的，
默认添加或默认更新，实际上采取 联合。所以我没有看到更新功能。
这是更新。哦，工会在那里更新 在那里，这意味着您看到的列表
这里不是您可能正在编写的完整 列表，启动的功能是什么
从你。所以这里是 和 和其他 几个。同样，你可以去字典
并调用几个函数从键中清除 副本获取项目。该项目可能是
有趣。这个项目是什么？它能做什么 ？哦，有错误吗？什么？那怎么能
你用这个？你如何使用这个功能？让我们 看看，哦，这只是一个对象，它
不是函数吗？我不知道。
再看看，是不是哪里都没有列出来？哦， 是物品不是物品。好的，物品。那是
也许是一个功能。所以这些是所有 项目 23 和这个，用那个新的钥匙，
等等。伟大的。所以实际上，这里 的目的不是告诉你每一个功能，
它会做什么，需要很多时间 。您可以去探索所有这些功能。
这里的目的是告诉你有什么样 的数据结构，有什么样的属性
以及它们之间有什么相同点和不同点 。所以如果你还记得这张幻灯片
对于列表，双七字典和上面 写出的一些文本，您将
非常了解在实践中在哪里选择 什么样的数据结构。所以
在下一个视频中，我将实际使用 Jupyter Notebook 作为我们的风格和
我将为您编码或解决一些涉及 列表倒置集或字典的问题
是其中之一，或者我们将根据 问题选择什么样的数据结构
好吧，所以我们会这样做。 但在那之前，我只想我只想
我只想提到列表元组集或字典 ，它们可以包含其中的任何项目
任何类型，这意味着一个列表可以包含另一个 列表。一个列表可以包含一个集合列表
可以包含字典，字典列表可以包含一 个列表，该列表本身包含一个
字典，我的意思是，这都是抽象的 ，这都是抽象的，一件事可以包含
另一件事可以包含一个实例，我的意思 是，一个列表可以包含多个列表。
这些列表可以包含更多或更少等等 。所以在真正解决问题之前
解决，让我给你一个味道，这些 东西是多么抽象。让我给
仅举几个例子，您就可以体会到 这一点。所以在下一个视频中我会
给你几个基于这些数据结构 的抽象混乱的例子。
从下一个视频开始，我们 可能会基于解决问题
在那。所以接下来的两个视频完全在 Jupyter notebook 上。所以准备好，我希望
下个视频见。好的，让我们看看 所有这些数据结构的抽象性。
我们只看一个例子。假设我们有 l 作为列表，我们有最富有的人
东西。所以假设我们已经设置了那个集合 ，假设 n，我们有字典，那是一个
字典。好的？所以假设我们有所有 这些可以在某处使用的东西。
所以让我们制作另一本字典。例如，假设 D、D、Ma，这是一个 D 工具。然后
字典有键值对 less 键是 a， 值是整个列表 l master
值是可能的。假设关键是 B. 价值只是为了推翻整体
推翻，这就是价值。假设键 是 C，值是集合。让我们
说键是D，值是字典，整个字典D 都是可能的。我的意思是，
你可以这样做，那只是一个例子 ，哦，哦，对不起，我应该有
我应该以这种方式合并。好的，所以 这是可能的。现在，例如，如果
我访问，如果我访问元素，比方说，a， 我会，我会得到整个列表。
不仅如此，我还可以再次访问整个 元素。然后在那之后，为此
元素，例如，我可以访问第三个元素 ，即索引三处的元素。所以这
特别是，这个特定的第一 级将提取列表。那将是
只是索引或该列表。看，例如 ，如果
我访问 D 两个，在工具里面， 如果我访问里面的字典，并且
假设我将该字典保存在 k 中，然后 我可以看到 K 的内容，但我只能
例如，this or I 可以访问这本字典 的所有元素，或者 k by just
有 4x 同性恋品牌，例如，x 和 x 中的 k， 就这样做吧，我可以，我可以这样做
我们也在循环中做到了这一点。所以 我想告诉你，这些即使例如，
如果你想创建一个列表，让我们说 l 三个假设你想创建一个列表
可以包含一个完整的列表，可以包含什么 将得到哦，我的意思是一个元素是
list another element is to pull another element is the entire dictionary inside 然后你
有一些其他元素让我们李的游戏 ，那很好，我明白我的意思是你
可以做到这一点，这些数据结构要抽象 得多，我的意思是，如果您例如，
访问索引二处的元素，即 字典，如果您如果
您检查将成为字典对象的元素 的类型，然后您可以提取
那个元素，按照你想玩的方式玩 什么的。如果可以，再做一件事
例如列表，我们可以说我们想 非常快速地制作一个列表列表
列出所有方块直到从零开始 列出所有方块直到
10 例如零平方一个平方到平方假设我们 想要一个列表。所以一种方式
这样做的快捷方式是只使用循环 ，例如，在循环中，我们
好吧，x 平方表示范围内的 x。 然后例如，所以它会从零开始
到九点，包括九点，你会一一得到 x。所有这些索引都是为了制作
x 方格的列表，其中 x 从零开始 并转到包括九个转到九个
一个接一个，这就是你可以列一个 清单的方式，我就是这样的人
捷径。同样，您可以进行销售 例如，假设您想制作一套
在范围内 x 的所有正方形中 ，比方说，从 2 开始，到
20. 你想迈出一步，比方说三步 。所以，从索引二开始直到
20不包括20，走三步，现在 可以有一套了，就是
这是这个。我的意思是，有很多 方法可以与这些一起工作
这些。一，人们可以越来越多地探索 这些东西，但是什么什么是什么
这些数据结构的基本内容是，它们 非常非常抽象，我的意思是，
一个列表可以包含一个字典 ，该字典可以包含一个倒置
有一个元素是另一个列表等等 。就是那么抽象，它让你
以这种方式做每一件事。好的，所以 我在下一个视频中结束这个视频，
我们将实际使用这些数据结构之一 解决问题，或者我们将尝试
选择其中之一。那个视频可能 很长，因为我们可能有
里面的虫子。我们将在下一个 视频中使用这些数据结构。
所以一定要参加下一个视频，因为 这真的是练习，你会得到你的手
在解决我们要解决的下一个问题 时，将很好地掌握数据结构
我们正在为您推出，好的，希望在下 一个视频中见到您。好的，让我们
看到一个问题只是为了适应这些 数据结构。所以让我们来设计
一些问题并在这里使用这些数据 结构解决该问题。所以问题
我在想的是，让我们说以下 。假设你是老师，
我应该输入所有这些东西吗？好的 ？假设你是老师，你是老师。和
你有
不同的学生记录来学习 包含学生ID的记录和
每个科目的分数列表，其中 不同的学生采取了不同的数字
的科目。所有这些记录 所有这些记录 都是硬拷贝。你想要奇怪的副本，
您想将所有数据输入计算机 并计算每个数据的平均分数
学生。并显示。那就是问题 所在。所以问题是，你有
例如，你有一份硬拷贝，你 有一些文件，上面有不同的
学生，每个学生都有不同的ID。 有些学生可能选了七门科目，
有些学生可能选了三门科目， 有些学生可能选了八门科目
等等，不同的学生可能选择了不同 的科目。不管在那里，你
想先录入每个学生，你要 先录入记录，我的意思是
所有的数据，然后你想从 这些数据中计算，你想计算
每个学生的平均成绩。例如，如果 学生选修了五门科目，那么
所有五个科目的分数都可用，您只 需将所有分数相加并除以五
这就是平均分。所以首先 ，让我们骑车走两条路
计算例如，只是收集数据，如何 收集数据。所以让我们写
一个功能。所以让我们说定义一个函数 ，让我们说从用户那里获取数据或
老师，让我们说，让我们说那个函数， 它返回数据。好的？所以我真正做的
我是说，好吧，而
真的，
我做了一个循环，while true，只是 从用户那里取数据，数据在
你先说的形式，好吧，身份证，学生证 ，我们说是inter，或者实际输入，
输入学生证。所以他输入的人输入学生证 。是的。所以采用，你
可能已经定义了一个字典，也许是一个字典 D，它现在是空的。但你可能，你
可以添加和删除不同的值。所以你要做的 是，你添加一个学生证，你会得到一个
学生ID，并以字符串形式，然后 你得到你得到的，例如，输入
作为标记列表。所以将列表标记为输入 。输入标记，
经过
逗号
分离的值。所以输入分数，例如 ，如果你有五个科目，只需
写五个主题标记，用逗号分隔每个 标记，好的，那么这个，让我们
看
更多的
学生等于让我们说输入，
进入，
是还是不是。
为了
添加更多学生，例如，如果您有 更多数据要插入，请按是，
否则人员。例如，这就是我们的设置 。所以我们会继续获得更多
并且更多，我们将继续从用户那里 获得越来越多的数据用户将继续
增加数据。但是我们必须知道的 一件事是，如果例如，一个学生
ID，学生证已经在D里了，如果已经 在D里了，那么我们应该给个消息
牌。已插入学生证的品牌。所以这 可能是其他信息。我们想要吗
要做别的事情，我们想做的 是以下。我们还想做的是
我们将制作一本字典，我们已经有了 一本以学生 ID 为关键字的字典，
那是我们的钥匙。在那个关键上，我们 所做的是选择标记列表，然后拆分
它使用逗号，因为您期望它们 将被保存为列表的所有标记。
所以这将返回一个列表。字符串值列表 。这些确实不是价值观，这些
是字符串值。但是所有这些列表都 用这个 ID 标记。所以这是一本字典
那将是我们将不断地被填充 。此外，如果我们检查 F
例如，更多的学生点低，例如， 让我们调用lower函数，因为
用户可能对较低的形式感兴趣，或者 如果这等于让我们说不，那就等于
不，如果是这种情况，或者例如 没有输入。
不
inter no inter 知道，插入时退出 ，插入节点插入。那么让我们
说这是你的信息。所以无论用户插入到 哪里，如果那是否，那么你就返回
就是这样。否则，你继续前进 。这就是整个目标。所以你保持
在询问，该，您不断询问越来越 多的值。如果每当老师进来
不，那你就回来。否则，你 继续，你做另一个等式，你
做另一个等式并继续前进。这就 是您获取数据的方式。所以数据会
可供您使用。一旦你完成了，那么 在那之后，我们将看到如何
一旦我们从用户那里收集了这些数据 ，那么我们将看到如何计算分数
每个学生的平均分数等等 。所以让我们看看这是否
功能是否有效。所以假设我们有我们 的字典，上面写着学生学生数据
等于从用户那里获取数据，让我们调用 该函数。让我们看看发生了什么。
好的。输入学生 ID，假设 ID 是 12。 好的，在用逗号分隔值的备注中，
让我们说，好吧，一个，让我们说
24,
逗号 65，逗号 87，让我们说第一个 工具中的前两个，然后有这些
三个科目，然后节间宽度，所以我 会输入别的东西。哦，是什么
问题？有一个问题。如果教的学生越 多，则学生越多，则未定义。
更多的学生，我猜，更多的学生 ，更多的学生，哦，拼写错误。
这是一个巨大的错误。所以我只是复制那里， 这些错误就在那里。那是生活的一部分。
实际上是编程生活的一部分。所以我想现在 它会起作用。所以让我们做这个过程
再次。所以 12，让我们说，标记是六 个逗号 45，逗号，让我们说一个坏主题
比方说， 13. 进不退出。不，我会 介绍一些别的东西，我会继续
移动。另一个学生是学生 ID 是 45，比方说。而这标志着
学生已经获得了，实际上，假设 这个学生已经，已注册已经注册
七个科目或让我们说五个科目 。分数是，比方说 44 到 5，6
到 677。让我们看一个不好的主题，让我们 说四个。好的，那么节点间，退出。不，
我想再插入一个，所以做除 No 之外的 其他任何事情。所以学生 ID，让我们说
现在学生 ID 是 12。再说一次， 假设想再次插入另一个 ID。
不管是什么标记，比方说 45 和 45。 同样，这是现在的节间宽度，不
别的东西。但是现在，消息在那里 ，12已经插入了，因为ID
键值索引，现在不能重复了 ，学生值也是。所以它不
插入了因为这可能是我的错误，所以 它再次询问。所以现在假设我输入
ID，比方说 23。那是 ID 或者可能 是不同的 ID。那是ID和标记
比方说 45，逗号，45。就是这样。和节点 间网格。所以假设我输入了 No。
就是这样。所以现在我收到了学生 数据，如果我给你看学生数据，
那个学生数据就是学生数据。 那是一本字典，那是一本字典
使用键 12。这是一个列表。但是这个 列表包含我们字符串的所有值
类型，我们将看到如何处理。那是一 个 45 作为键值，那是 ID，那是
标记列表。这就是那个小列表中的 ID。好的，太好了。现在我们有学生
数据。让我们编写另一个函数来帮助 我们处理学生数据，基本上，
我们想找出每个学生的平均成绩 。然后我们想打印这些。
所以让我们定义另一个函数并获得每 个学生的平均分数。这个功能实际上
收到这本字典，让我称它为 D， 任何变量，都是局部变量。
好的，所以我们想要做的是以下 内容。每个学生的平均分，
所以我们将定义另一个字典，让我们 看看everagemarks字典，让我们说
一开始是空的，也许，然后我们对D 中的x做了什么，让我们创建一遍
x 和 d，我们真正做的是去我们 发现位于 ELL 的列表是
位于 x L 基本上是 D sub x。就是这样，这 就是我们的清单。这是我们的清单
位于那里。那么我们在 L 中为 i 做什么 。所以对于所有是 L 的 i 或让我
称其为标记，L 中的标记。在这个特定列表 中，您所做的是您实际上拥有这个
sum的总和现在等于零，
没有标记。所以你所做的是 s plus 等于 两个标记，但将标记转换为
整数，因为它们已经是字符串格式 。我们已经拯救了一切本能
字符串格式，因此您可以填充所有 列表。完成此循环后，S 将
包含所有分数的总和，然后你要 做的是计算平均值，然后只是
将平均值保存在 ABG 中。标记装饰字典 ，让我们说平均分数，只是不要
使用单词deck，例如，您可以但让 我们保持渐进并添加x，您只需写
平均分数。平均分数可以 通过 s 除以长度来计算
清单，无论清单是什么。这 就是清单。是的，这是平均值
分数。一旦你一个一个地有了 N， 所有的平均分数都会被填充。和
一旦我们收到所有这些，我们将开始 然后我们可以通过填充来显示
平均分数。所以让我们看看，让我们调用 那个函数。所以让我们调用这个函数。
所以举个例子，ABG 分数，就等于拿到了 VG 分数，让我们把这些学生数据绑定起来
里面。如果没有错误，那么它将 返回所有内容。然后只需打印
每个学生在 Vgm 中 x 的平均分数 。品牌，让我们说学生和品牌 X
上帝平均标记为那么你只是 Brandt OK ABG m of x, x，然后会显示
一切哦，如果有错误，非类型对象 没有配备。我更喜欢九型
对象为什么非时间对象？我们犯了一些错误。是 的。也许。让我们来看看。让我们来看看，
例如，当我们运行它时，让我们运行它并 创建一个单元格让我们使用 alt 运行
回车创建一个单元格everage m 那是什么东西 ？哦，那没什么。为什么哦，我们没有
返回任何东西。这是一个糟糕的编程 。真是糟糕的编程。我们还没有回来
实际上。我们需要的价值。所以默认值 是none。突袭实际上并非如此
伟大的。好的，太好了。你有这个，现在 我们有阿联酋航空标志的东西。是的，
这是，现在我们可以填充它，我们 让这个学生 12 获得了平均分
38 学生 45 核心平均分 90 49.2 学生 20 他的平均分是 45.0 好的，
伟大的。所以这只是对字符串， 类型和海洋的拆分功能的回顾
int, 和一般输入函数中的函数 , and, 字典和列表等等
东西。所以虽然这只是一个小问题，但 它提供了一个很好的数据结构的味道
和字符串之类的东西。好的，这 就是数据结构。从下一个视频，
我们实际上正在深入研究数据 科学包。我们将从 NumPy 开始
我们将花一些时间在 NumPy 上， 然后我们将转向 Pandas，也就是
非常非常强大，建立在 NumPy 之上 ，之后，我们将转向 matplotlib
我们还将尝试为您提供一些通灵 学习的快照。所以希望见到你
在下一个视频中。好的，接下来 的几个视频我将讨论 NumPy
是非常流行的数值 Python 包。 实际上 NumPy 就像 list 但它
比列表快得多。
一一限制 如果我们限制了列表 记住，列表实际上是一个集合
大量的数据对象。这太抽象了，正如我们 在之前的视频中看到的那样，例如，
我们限制列表中的所有对象必须具有 相同类型的列表中的所有元素
例如，它们具有相同的类型，然后该 列表具有所有相同的类型，有什么
NumPy 看起来像，但 NumPy 非常 非常快。原因是，即使你
定义一个列表，其中包含相同类型 的所有元素 是的，但是因为列表
以抽象的方式可以处理异构类型 的对象，我们将应用的功能
在这些项目上，他们将不再更快 地存储我们必须存储的每个元素
NumPy 中该元素的信息或元数据 ，我的意思是，它是有效的
关于内存，因为如果类型 说我们不需要保存信息
关于每个元素，因为我们只需要 保存有关类型的信息，因为
当类型相同时，所有元素的类型 都相同，我们可以编写函数
这比列表要快得多。所以 NumPy 非常非常流行，它有
NumPy 中可用的方法提供了 非常快速的通用函数。和
这是一个包，我的意思是它是一个完整 的目录结构，里面包含很多包
很多模块，在一天结束时有很多 ，它只是简单的或外行的
术语，它就像一个包含所有相同类型对象 的列表，并且在以下情况下更有用
所有这些对象都是数字类型，尽管您 可以使用带有 spring 的 NumPy 数组
数据类型，我的意思是所有的 字符串都是一般对象，但最
NumPy 数组的威力将变得 更加明显，当我们
正在处理数字类型数据。所以 在这个特定的课程中，我们将
更多地关注数字数据而不是其他类型的 数据。所以这就是你编写 import 的方式
NumPy 已安装，或者如果您使用 Anaconda 安装了 Python，则 NumPy 已安装
它位于内置包的侧面包中。所以 导入 NumPy 我们可以留下来
照原样，但我们可以将这个 NumPy 重命名 为最流行的 NP，我们可以这样写
任何其他名称，但如果您看到书籍或互联网 或某个地方，这个 NP 不知何故变成
更受欢迎。好的。现在我们可以定义 一个数组，例如 NP 点数组该数组
只是一种 NP 类函数的方法。我们可以 使用列表定义一个数组，这是
几个数字的列表，或者我们也可以将 数组定义为倒塌。那么我们是否
给一个推翻是否我们给一个列表一个 数组被定义然后我们可以看到内容
这个数组，这个 NP 数组，所以让我们 去我们的朋友 Jupyter Notebook 和
让我们的手在这个 NumPy 上滴水不漏 。所以首先，我们需要导入 NumPy 包。
我们可能会更名为 NP，以备将来使用。 所以假设它是进口的。所以现在让我们
说 a 是一个数组，让我们说 NP 点数组， 那是一个函数，我们可能有一个列表和
比如说，让我们说 12357。让我们说这 是对的，我们也可以使用定义数组
推翻而不是列表，这是我们的选择 。我们以哪种方式定义数组。
235 让我们，也就是说，这是另一个数 组。所以如果我们打印，例如，它
会给我们一个，但如果我们只看到 a 的 类型，它将不再是列表，它将是
一个 ND 数组 numpy.md 数组，那个 n 维数组 ，好吧，太好了。所以，有这么多
这个a和这个B的属性一样。同样，如果 你看到 B 的类型，尽管我们有
定义这是使用元组。但类型是相同 的，它是一个 NumPy 对象而不是
比列表或推翻。
所以这就是你如何创建数 组 1111 更重要的事情
是检查a的属性，例如k dot d类型 ，它会告诉我们数据类型
例如，a 存储整数 32 的所有 数据。例如，在定义的时间，
如果我们愿意，我们可以指定数据类型 如果 我们愿意，我们可以指定类型。为了
例如，在老师这意味着就像在老师这里 一样，我们可以在这里定义，例如，
例如，类型为浮点数，因此数据 类型变为浮点数。还有其他几个
可用于定义数据类型的选项， 但是，即使我们没有定义
可以根据内容自动定义数据 类型。这就是动态类型
方法。所以如果我们现在定义类型，如果我们 ，如果我们现在检查 a 的类型，即，
再次在数字 32 中，但是如果您检查 类型是可能是浮点数的类型
数字，是的，这是浮点数 32。同样，也 有 64 位支持，我的意思是，我们可以
在这里定义 这里有几个可用的 选项。所以这就是我们能做的
定义刚刚开始使用 NumPy 数组的 NumPy 数组。在接下来的视频中，
我们将更多地使用这些数组。所以希望 在下一个视频中见到你。好的，
在上一个视频中，我介绍了 NumPy。 我们实际上使用了一个 NumPy 数组
列表以及推翻。在这个特定的 视频中，我们将看到一些属性
NumPy 数组变量或有时称为 对象的变量有几个
属性，但我将讨论例如，上 次我讨论了一个属性，它是
d type a dot d type, and that store 实际上 实际存储的信息
NP数组的数组元素的数据类型 ，记住NP数组，所有元素
NP 数组，它们必须具有相同的数据类型 ，它不能像它那样存储异构数组
是。好的。现在，还有另一个属性 有时称为维度是 n。这说明
实际上，数组的维度是多少 ，我需要解释这个术语维度
用下面的例子。比方说， 那是，那只是一个数组
考虑一个列表，例如 123，这是一 个列表。如果它是一个数组，
例如，如果 np.if 这是 NP 点阵。有了 这个列表，我们会说这个数组为
一个一维数组，因为我们只需要一 个索引来访问它。例如，如果
你需要访问这个数组中的任何元素 ，你只需要一个索引 01 或 2，
只有一个索引，没关系。所以在这种 情况下，我们只有一维数组。在
另一方面，例如，如果你在这里看到， 那是一个数组或一个列表，那是另一个
数组，另一个列表。这是另一个 包含列表的列表，例如。让我们
说数组一，那是数组二。 这只是两个不同的数组
数组。也就是说，这是一个数组，那是一 个数组。例如，一个 One 就是这个数组
一个二是这个数组。现在如果我们需要 访问这个特定数组中的任何元素，
我们需要两个索引。首先， 我们要确定我们是否要谈论
一或二，我们需要一个索引，例如 ，如果我们想定位一个，那
意味着我们将使用零元素访问 ，比方说，整个数组是
a 所以首先，我们说好的， 零意味着我们将从一个和
a 到其中之一。所以零意味着第一个， 好吧，现在是一个。现在在一个里面
元素，这是第零个元素，这是 第一个元素，这是第二个元素，
假设我们要访问第一个元素。所以 这意味着我们要谈论我们
正在谈论这个。所以非常松散地 说，所需的索引总数
访问数组内的元素称为数组 的维数。而他们实际上，
这实际上定义了实际上描述 了这个属性，维数的总数。
考虑一下，例如，这是一个二维数组 或二维数组，让我们开始
二维数组 A 一个，让那是另一 个二维数组一个 2，那就是
另一个二维数组，例如一个 三，假设这是一个数组
二维数组，比方说 NP 点数组。现在， 这就是整个数组，不管那是什么
数组是一个三维数组。原因是 访问任何元素，我们需要三个
指数。第一个索引将定义我们选择 其中的哪一个，例如，让我们
说你正在选择那个。所以需要一 个索引，例如索引是一，然后
在像这样的结构内部，我们需要 另外两个索引来定位特定的特定
指数。比如因为是二维数组，所以 有两个一维数组，所以
你是哪个一维数组，它有更 多，它有很多一维数组，
所以你想选择哪个一维数 组，假设第六个将用
索引 5，现在您已经找到了第五个或第六 个数组。现在在那个数组中，什么元素
让我们说第八个元素。所以我们需要三个 索引来访问一个特定的元素。所以
这个数组的维度是三。所以让我们 在 Jupyter，notebook 中使用它
只是为了更适应术语维度 。所以让我们说，例如，
我们有一个数组，假设 a 是 NP 点数 组。假设它包含一个列表，假设
123. 然后我们有另一个数组，一维数组 ，比方说四、五和六，那就是
另一个数组。这是这两个数组的 数组。所以这基本上是一个二维的
大批。它是数组的数组。列表列表，相等 的条目。所以这是一个例子，哦，
有什么问题？哦，我们还没有导入 NumPy， 我们应该导入。所以导入，导入NumPy
作为NP？好的，我们不需要每次都导入 。实际上，我是在录制此视频之后
几个小时后。我真的重新开始 了所有这些事情。所以我有
现在第一次导入。但是一旦在 笔记本中导入，只要一个笔记本
正在运行，您无需重新导入任何内容。 好的，例如国防部，然后是伊拉克
还有他们。所以这是听，因为有 两个维度。例如，如果我想要
访问第三个元素，这个元素，所以 这个元素位于第一个数组中
在具有第一个数组的两个数组 中，有两个索引为零的数组
或一个。所以我要查看第一个数组 ，它是 123。在那个数组中，我
将查找索引为 2 的元素编号为 2 的元素 。这就是你可以访问的方式
多维数组的元素是具有更 多、更多维数的数组。
假设我们有另一个数组只是为了 更熟悉 NP 数组，让我们
说，我们有一个清单。该列表实际上 包含该列表实际上包含三个
一维数组。不仅如此，实际上哦 ，我让你很困惑。让我知道让
我只是，假设我们有 123 个。假设 我们有三个一维数组。让我们
假设我们还有另一个 2459。数组的大小， 也许，也许，也许，我的意思是，也许
不同的。是的。真的吗？也许不同？是还 是不是？例如，让我们看看第一个
数组的大小为三，第二个数组 的总大小。可以吗？我猜是。
现在如果我们想访问，例如， 一个元素的元素，让我们说，
我想访问这个元素五，所以 在二级索引中有一个，然后
在该数组中，它的索引为 2。所以我访问了 这个元素，哦，我们没有太多的索引
对于数组。为什么？
这是为什么？为什么索引太多，对于一 个数组，B 选择了一个 B 点 n dems。进而
那是一维的，我必须，我 有这个一维数组。和这个
是另一个一维数组。我已经列出 了它。我在这是一维数组
和另一个将它们连接在一起的一维数组 ，所以我不应该访问这个元素。
问题是当你要定义 多维数组时，
每个维度的元素，它们应该保持 一致。例如，如果第一个数组
有三个元素，第二个数组必须有 三个元素，或者如果第二个数组有
四个元素，第一个必须有四个元素 。如果不是这种情况，则数组
不会像多维数组那样定义。例如 ，如果我们，例如，扩展
我们的第一个数组，比方说，减去一 个。现在，B 将有两个维度，没问题。
现在我们将能够访问例如这个元素 五，就像这样。所以我们会去
再次到 B，我们会看到好的，选择第二 个数组，然后在该数组中，选择索引，
选择由 2 索引的值，即 5。 所以访问没有问题。就这样
如果您要定义例如一个 三维数组，那么请让我
只是给你一个三维数组的例子，它 是一个 C 等于 NP 点数组。和
假设我们有 1、2 和 3。然后我们 有另一个数组，例如。 456,
记住或者让我们说，例如，我们可以 再拥有一个，我们可以拥有一个
更多清单，为什么不呢？所以假设我们 有一个 00 减 1，让我们说，这就是
那是。那是一个二维数组。那是 一个二维数组。伟大的。让我们
假设我们还有另一个二维数组 。假设我们有另一个二维
具有相同一致性的数组，元素的 数量和东西。让我们说这些元素
是我们的减号，其他的，假设有 减号，减号，减号，这是
加一。现在我们有了这个，如果你看到这个 东西，那就是一个二维数组。那是两
维数组，也就是二维数组 。二维数组的数组
基本上是一个三维数组。现在， 这是一个三维数组。这个，
C，所以如果你哦，我们有一些，哦， 我应该用逗号来定义它。而不是
而不是空格。实际上。是的。我这样做 的原因是 MATLAB。我也在 MATLAB 工作过。
所以 MATLAB 允许这个空格分隔的列表 ，但我只是把这些东西与 Python 混淆了
以及。但是 Python 需要逗号，它们没问题 。用 MATLAB。顺便说一下，作为一个方面
注意，MATLAB 允许你有逗号和 空格，但这个 Python 只是限制
一切以逗号。那太棒了。好的，那是 C。 所以现在，如果你检查 c dot n them that
第三，如果你想访问这个特定 的元素，你应该怎么做？
首先，您选择 2d 数组之一， 有两个 2d 数组。所以这
是第一个二维数组，这是第二个 二维数组。如果你例如，想要
访问这个特定的元素，这个特定的元素 ，它是负三，如果你想的话
要访问它，您首先必须访问两 个二维二维数组之一。
所以让我们用索引一访问第二个。 现在你在这个特定的二维数组中
在该数组中列出您正在谈论的一维数 组。所以我说的是非常
第一个一维数组，所以第一个一维数 组的索引为零，在那个 D 数组中，
你在谈论哪个元素。所以我 说的是这个有索引的元素
两个在这个特定的数组中。所以现在，如果 你按回车键，你会得到负三个哇。
所以这基本上是如何以及顺便说一下，你可以 制作一个四维数组，一个四维数组
维数组将是一个由三个维数组组成 的数组，依此类推，您可以制作，
例如，您可以制作 n 维数组 ，这就是我们称其为
nd数组，n维数组，不是C的nd 数组n维数组的类型，可以
添加任意数量的维度。太好了 ，我们将继续探索这个 NumPy
尤其是在即将发布的视频中 ，我将讨论这个形状属性
NumPy 我们已经讨论过我们讨论过的 D 类型，然后在下一个视频中，
我们将讨论形状，我们将更多地 讨论 NumPy。所以希望见到你
在下一个视频中。好的，在上一个视频 中，我们讨论了这个维度数或
任何 NumPy 数组的结束属性。我们 还看到了一个定义三的例子
Jupyter 中的维数组。笔记本 。让我们讨论另一个属性
是形状属性。让我们看看这个形状 实际上代表什么。所以我们走吧
到 Jupyter Notebook，看看这个形状 到底代表什么。例如，你有
在上一个视频中看到了这个 C，我们 将 C 定义为一个三维数组，其中包含
两个二维数组。每个二维数组包含三 个一维数组，每个一维数组包含
三个要素。那么我们所说的形状是什么意思呢？ 那么，如果我们只说形状呢？那个东西是什么？
所以形状是 233。让我告诉你这意味 着什么。返回是元组。所以那是
一个元组。那就是回到三和三。 这两个表示有多少个二维数组
在那里？我们这里有两个。那么在每 个二维数组中，有多少个一维数组
那里？那么，每一个三个，阵列 ？有多少个元素？嗯，三个。
所以基本上，这个 C 点形状， 零，告诉你二维数组的总数，
那也是。还有这个造型。例如。一个 告诉你在每个 2d 数组中，有多少个 1d
阵列在那里，这么多？而这个形状 ，例如，告诉你在每一个
数组，有多少个元素？嗯，三 年级？棒极了。是的。我能告诉
你的111屏是什么东西？您可以定义 一个 NumPy 数组，例如，作为
只有一个元素的 NP 点数组，假设 有两个。那是阵列突袭。是什么
这里的维数？你怎么认为？那是什么 ？那是一维数组吗？什么是
维数？奇怪的？这是一个一维数组。 是啊，就是。看到另一件事了吗？
例如，b 等于 NP 点阵。你用 三个来定义它。还有什么
是B的维度，看起来一样 ，B的维度应该是一
因为他们的A的维度是一，所以看 起来B的维度也是一。不，它是
零。因为那是一个数组。如果您将其作为 列表传递。它是一个 D 的数组，如果
您只需定义一个可以定义为 数组的数字 NumPy 允许您
但那个数字就像一个 yo D 数组。 现在如果你能进去，很多零日，
如果你连接最后一天，你得到一天 ，你得到一个职责。如果你得到
很多职责，你得到一个 3d 等等。看看 感觉 是的。所以就是这样。
所以是的，在这个视频中，我讨论 的形状还有另一个 有这么多
属性，让我来讨论一些属性， 让我们实际告诉总数的大小
of elements 完成数组中元素的 总数。那么，有多少个元素
那就是尺寸。还有我猜 m 自行车 属性，它告诉总数有多少
析构函数在内存中占用的字节 数。还有其他几个我
意思是属性，如果你只是应用一个选项 卡并获得某些东西，你会看到很多
职能。您可以检查其中 一些功能的许多属性
我们稍后会探讨。有时它们被 称为通用函数，我们会看到
因为它们非常非常快。而 这些函数是向量化的实现
这些功能。这就是 NumPy 如此之快的 原因，也是它如此受欢迎的原因。
无论如何，在下一个视频中，我们 将更多地探索 NumPy。我们会
使用 NumPy 向您展示更多有趣的东西。所以 希望在下一个视频中见到你。 NumPy 实际上
提供了很多创建数组的函数，特殊 类型的数组只是为了测试。
有时只是为了。我的意思是，有 很多方法可以从头开始创建数组，
例如，如果你想创建一个包含 全零的数组，那么有一个
NumPy NP 点零中的函数告诉你如何 做到这一点。同样，如果你想
生成很多生成一个包含很多个或 所有一个的数组，有一个函数
要做到这一点，像这样的东西，有 一些功能实际上使用了很多，
我想讨论这些。一个功能是NP点 排列，实际上，这是单个R，
这不是两个 Rs，这是单个 r NP 点排列，一个 R 和 NP 点排列
函数，它的作用是创建一个数组， 例如，如果你说 NP 点排列，它
创建一个数组，例如，如果你说好的，100。 所以它创建一个它创建的数组
一个一维数组，从该数组中的值 开始，从 012 开始，一直到 99。
所以这是一个数组。这是创建包含 所有数字的数组的快速方法，直到
100. 是的，所以让我们看看，让我们看看 在 Jupyter 中运行这个 NP 排列方法的例子
笔记本只是为了更好地了解它的工作原理 。所以让我们看看。所以让我们说
我们有一个等于 NP 点排列。让我们 看看 100。就是这样。如果你想看
里面是什么，你可以看到这是一个数 组，所有的值都是从零开始的
到 99。也许你想创建一个数组，从 一个特定的数字开始，结束于
特定号码。也许这两个数字 不同。也许这个安排功能
实际上允许。假设我想从 20 开始 。我想在 100 结束。然后
我想创建所有这样做的数组。所以 让我们说这个。所以没关系，从
20 和 100。但不包括最后一个元素最后 一个索引。这是可能的。最后但
至少，例如，如果您想从 20 开始并添加 100。假设您
想跳三。这是可能的。请 记住，这是否类似于
你已经知道的东西？还记得吗 ？是的，让我暂停一下，但是
不是一分钟，只是几秒钟。让我暂停 一下。你还记得这个安排NP吗
点脑功能？它看起来像什么？ 还记得 i 在范围内吗？是的。
例如，对于范围内的 i，从 20 开始。转到 200。以示例三为例。还记得吗？
那么它与范围函数有一些相似之处吗？是 的。虽然 range 是一个仲裁者。
什么是仲裁员？我为什么要告诉你 ？好吧，让我告诉你一个仲裁员
同样在这里，只需在此范围 功能上花几秒钟即可。你，
当我们调用这个范围时，你可能会想， 假设从它们开始，假设它们的范围，
你可能会认为它返回一个数字 列表，从零到九，但是
这不会发生。它什么都不返回。 实际上，当你真正调用它时
调用它它只返回一个对象。当您 在 for 循环或某处调用它时。它逐步
做。一个一个元素一个一个地舍入。 所以它返回一个元素，然后它水合
并返回另一个从不创建元素列表的 元素，它现在创建一个列表
为你。棒极了。实际上，它生成数字 ，它生成下一个数字，然后
继续前进时的下一个数字。所以它节省 了大量的内存和这些类型的对象，
他们被称为我玩过的陨石坑，他们 从来没有玩过。但如果你想，例如，
得到一个列表，如果你真的想得到一个列表 ，那么你可以做的就是你可以打电话
范围，让我们以同样的方式说，你 可以写一个列表。所以给我一个
list 不只是给我提供一个 ID。这会 给你一个清单。多么酷啊？对？
无论如何，这只是一个旁注。 无论如何，它与此排列功能无关。
所以NP点排列，它实际上返回 一个数组，它不像迭代器，
它返回一个数组，以您想要的方式 完成数组。所以这就是这个安排
与这个主要用于 for 循环的内置范围 函数相似。好的。下一个，
让我们来讨论这个 NP 点随机点排列 NP 点随机是一个包。而 P 是一个包，
它有很多子包作为一个包随机 内部。 Random有很多模块
一个模块是排列。还有很多其他模块 。所以让我们看看这个随机。
让我们看看它的作用。例如，假设 一个等于 NP 点的随机点，排列，
让我们说排列。我做的是我说好的 ，np dot排列，让我们看看10个什么
它确实是，这个 NP 点排列将返回 一个数组，其中包含所有零到
九，这些是10个值，然后是这 个包中的置换函数和P
MP 的随机数据包中的 dot random， 它实际上将所有值打乱并
以随机方式重新排列所有值 。他现在将是一个包含
相同的元素，但以不同的随机 顺序排列。所以让我知道打印
这一个，它将在一个真正洗牌的 过程中购买从零到九的所有元素
离开。这种洗牌是完全随机的。是 的，你看到了吗？有时你可能
可能会调用一些函数，你可能想在数组 上写一些函数。你可能想要
没有特定顺序的数组，只有 随机数组，只是
测试您的代码只是为了测试它如何在任何类型 的数组上工作。在这种情况下，一种方法
获得洗牌的数组。一种快速的 方法是只使用 NP 点随机点排列
功能。 NP点随机包不仅有 这个排列，还有很多
其他函数的随机数，例如，np dot random random dot Rand int，例如，
Rand int，创建一个随机整数。那就是，例如 ，如果我就是那样，让我打电话
这和我们有，如何使用？好的， 你可以从一开始就给一个低值，
我们可以给出一个高值，我的意思是，它 实际上创建了从低开始的随机整数
高位结束。这就是它的使用方式。 例如，让我将其称为 NP 点随机
dot Rand int，创建一个 20 到 30 之间的随机 数，创建一些随机整数，然后
它会返回一些 20 到 30 之间的随机整数 。如果我们再次调用它，它可能会返回
另一个是它再次返回 30、29。一次 又一次。现在两个回合 2932. 也许
我们可能想要生成 20 到 30 之间的随机 整数。所以它创建了一个随机
整数。您可能会注意到的一件 事是什么是返回值？这
返回值？例如，我们应该是 E 的类型还是您认为？这是
V 是一个数组？不，它是一个数字。它 是一个整数，VA的类型应该是一个整数
因为它返回一个随机整数它 返回一个整数但它正在选择
那个整数从 20 到 300 随机。所以 它应该是整数，是的。哇。
是的，
所以我们将在 NP 的随机包中探索 更多的函数，然后我们将
正在朝着这个称为 V 形的迷人 功能评分函数迈进。所以有
更多关于 NumPy 的内容，所以希望在下一 个视频中见到你。好的在最后一个视频
我们看到了一个 range 函数，这是一个非常 有用的函数，用于创建一个测试测试数组
并且只是查看特定操作或算法 的输出，只是在不同的
数组的种类。进一步我们看到了 NP dot random 中的置换函数 permutation function
包裹。我们看到这个置换函数， 实际上，它重新洗牌，它洗牌
如果数组应用于这个置换函数 ，它实际上是不同的奇怪
以完全随机的方式随机 打乱该数组的所有元素
道路。今天，我们将更多地探索这个随机包 ，然后我们将看到一个重塑
功能，但 reshape 基本上是这种 reshape，例如，如果你有一个
数组，比方说，数组，比方说，我们有 一个数组，比方说，10 个元素，和
如果我们调用一个点重塑，我们给， 比方说，2乘5，所以它会形成一个二维
a 中的数组，也就是 B，这将是一 个二乘五的矩阵 R，这将是一个
数组，或具有两行五列的矩阵。现在 我们可以了，我们可以工作了
有了这个B，就像它是一个二维数 组，我们可以，我们可以处理
这个 B 作为一个二维数组并 使用它。是有时变得好用
例如，如果我们想要，我们想要在 矩阵上测试某些操作。一个快速
制作矩阵的方法就是调用排列 函数，然后无论结果如何
只需将其重塑为所需的顺序矩阵 并测试算法。所以让我们去
让我们去 Jupyter Notebook 再检查 一下这个随机包，然后看看
重塑功能。那么让我们来看看 Jupyter。 笔记本。是的，所以有很多方法
生成这些随机数。一个例子， 我们已经看到了Rand int。和
其他方式例如数组，可以生成 数组，如 MP dot random dot RAND
功能。所以现在，如果我们创建这个，如果 我们创建，让我们如果我们通过假设 1000，随机
值数组将在 a 和 a 中生成， a 的每个值将是一个随机数
零和一之间。所以所有这些数字 都只是零到一之间的随机数
number 是零和一个随机数。 而且，这个分布基本上是分布
这个随机数的所有分布都是均匀 的。例如，如果您想绘制
直方图，直方图或分布看起来 像均匀的。让我只要
给你一两张图，使用 matplotlib 包，虽然我们会看到 matplotlib
稍后打包。但是让我们假设这只 是一个绘图包。这只是一个
帮助我们绘图的包只需导入导入 mat plot lib.pi plot 作为 PLT 导入
那。导入后，您只需绘制直方图 PLT 点直方图，例如，
通过 a，您可以看到直方图大致均匀 。我的意思是，一切都有可能
我们可以制作更多条带，例如，我们 可以有条带，等于 100 个。我们可以
看到几乎所有的事件他们是我的意思只是 看起来像制服。如果我们做的越来越多
数据集，那么它们看起来都是统一 的。我们可以拥有的另一件事，例如
这个。假设 B 等于 NP 点随机点 Rand n，这会生成正常随机点
数字，或高斯随机数， 让我们说哪个数字的分布
例如，是钟形曲线，所以让我们 只是 PLT 点急速 B。然后让我们
说等于 200。我们可以看到一个钟形曲线 ，因为这个数据的分布
是高斯分布看起来像这样。所以 这个这个随机包，这个NP点
随机是非常重要的包。它有不同 的，它可以创造不同种类的
来自不同分布的随机数 并在机器学习中进行
或者在统计学中，有时我们需要为 有时生成这些类型的随机数
用于测试目的，有时用于添加特定 类型的噪声来测试我们的模型
和这样的东西。所以掌握好 NP点随机包就好了。好的。
接下来我们看到reshape函数。还有一 件事。例如，如果您想创建，例如，
一个仅包含随机数的二维数组，假设 您可以将 NP NP 点称为随机点
兰德。你可以只调用a，你可以只传递 两个参数，例如，两个乘三个，
而 C 将是一个二乘三的矩阵。如果 您看到 C，它将是一个二乘三矩阵
四个随机值。如果你看到 c 点，那么它的尺寸是
二。它是一个二维数组。此外，我们 可以创建，例如，一个四维
数组 c 等于 NP 点随机点 Rand，可能 是二乘三乘四乘二。这是一个
具有此特定顺序的四维数组。所以 如果你看到这个 C 点 m，那么
将是B级，这个。是的， 让我让我给你解释一下
那件事是。有两个三维数 组。其中有两个。
好的？现在，每个三维数组都 有三个二维数组。哇。
所以每个
二维数组有四个一维数 组，每个一维数组有
其中的两个元素。所以这就是结构。是的， 获得良好的外观和感觉。那么让我们
请参阅重塑功能。例如，假设我们 有 d 等于 NP 点范围。让我们说
我们有 100 个值。然后我们说重塑这 100 个值，让我们说，让我们说四个
乘以 25。所以这个 D 将是一个四乘 25 的矩阵。 所以如果我们只是得到 D 的形状，那么
将是一个四乘 25 的矩阵或一个四 行 25 列的二维数组。是的，
所以有时我们想要处理矩阵，我们 只是，我们可以插入这些数组
函数生成一堆数字。然后我们 可以重塑它们并构建一个矩阵
很快，然后测试我们算法的性能 或类似的东西。所以，不
只有 reship 不仅返回，我的意思 是，你可以重塑一个矩阵，
如果您愿意，您可以将数组重塑 为二维以上的数组，例如
例如，排列 100，让我们说点重塑， 也许或作为四乘五乘五，这是一个三
维数组。现在，这个 D 将是一 个包含不同值的三维数组。
是的，所以现在您可以访问它并做任何 您想做的事情。所以不仅重塑，安排
并允许随机，还有其他功能以及 NP 点零。例如，如果你
按z，你只看到零，然后你 只要按问号，你就会
知道那个函数是什么，我们如何 使用它等等。同样，你可以有几个
其他函数有一个重要的函数， 例如，你可以调用那个函数，
这将生成一个包含所有 1 的数组，您 可以在此处查看如何调用该函数。
有 NP 点空，有 NP 点空，就像 有这么多功能只是为了创造
一些矩阵很快。并且您想基于 这些来测试您的核心算法。
所以是的，所以有很多我们想要的 功能我们可以处理。那么接下来
有很多函数可以快速创建 NP数组和n维数组。
我们可以快速创建数组测试或算法 或在任何我们想要的地方使用数组
喜欢我们每个人都可以使用。我们 可以继续进行一些功能，例如排列
一个零，它们有随机点Rand随机 点Rand n，以及其他函数
他们是可用的。在下一个视频 中，我们将看到我们将看到索引
或在 NumPy 数组中切片，我们 还将看到该索引的差异
with or slicing from the array 在列表 中还是普通数据结构？什么
区别在于？ NumPy中切片的 区别是什么？例如，与
列表，我们将在下一个视频中看到， 希望在下一个视频中见到您。
好的？
这是我在 NumPy 切片中最喜欢的主题。 实际上，在 NumPy 中索引或切片是
访问子数组的方式与访问子 字符串的方式相同，或者
子列表。你已经看到了， 我们如何使用切片或索引
在列表和字符串中，NumPy 中的区别 在于列表，例如，如果您切片
你得到，例如，假设 B 等于一个冒号 5，如果你把那个东西切片，从
NumPy，那么 B 不是副本，它实际上是 访问与 A 相同的内存视图。 现在，
如果你改变了 B 中的任何一个元素，a 中对应 的元素就会改变，只要是一个 NumPy
大批。但是，如果 A 是一个列表或任何 其他数据结构，普通数据结构，那么
切片这个，这种切片给出了一个副本 而不是一个视图。所以这是一个重要的
不同之处，我们需要知道其余 的索引技术几乎相同。你
做这种索引，这就是你如何扭转 这一开始并逐步完成所有
事情是一样的，除了如何玩我们 如何玩二维数组。让我们
让我们看看。来看看在 Jupyter Notebook 中一一索引的一些例子
并查看切片实际上如何创建视图而 不是副本。所以让我们去我们的
Jupyter Notebook 看看我们如何玩不同 的索引，假设 a 是 NP 点排列，
和 B 点排列，比方说 100。让我们把它们 洗牌。让我们照原样说，让我们说
那是现在，比方说，让我们带来 一些东西。让我们 A B 等于全部
从索引三开始到索引九结束的元素 ，苏丹不包括在内。那是
B，那是空白 v。让我们看看 B 是什么。所以 b 就是这个数组。好的？现在我要做什么
要做的是我只是改变b的内容，这个 NumPy数组是可变的，你可以改变
里面的元素，没问题。所以我要 改变元素，让我们说一个元素
在 B 中，比方说，我要更改元素编号 为零，而 B，也就是三，我要
只需将该元素放置为负 100 减 1200。就 是这样。就是这样。好的，现在
B 的内容已更改。我们是， 但现在让我们看看内容的内容
的一个也变了。这与切片普通的 Lester adini 数据有很大的不同
构造或切片列表，当你切片一个列表时 ，你得到我们，你得到另一个标签，
但是那个标签或那个变量正在访问 相同的内存，内存实际上不是
复制的。有一种内存视图。这两 个不同的名字，无论你访问那些
使用 B 的元素，或者您使用正在访问 的相同内存访问这些元素
如果您使用 B 或 A 更改内存， 您将在两个变量中看到效果。
所以这是一个区别。现在，在了解 了这种差异之后，如果我们真的
希望这种行为不会发生，我们可以称之为 的一件事是我们可以说好的，a，因为
例如，a，比方说 3 到 10。然后我们 可以调用我们著名的函数，记住
那个副本，你可以复制那个，现在 B 是一个完全不同的数组。它是一个
不同的内存视图，如果现在更改 B，在so copy函数中将看不到效果
需要复印的时候就在那里。如果 你不打算改变元素的一件事
number 是通过不更改内存视图 来非常快速地实现切片
如果你知道，你的算法 不会改变元素切片
为您提供对元素或子块 或子数组的高效访问
无需在内存中实际制作副本 ，这可能需要时间和空间。
所以这是 NumPy 的一个优势，而不 是我们已经看到的其他数据结构
到目前为止，在 Python 中，好吧，让我们使用索引，
让我们说你怎么看？那个东西是什么 ？冒号，冒号是什么？或结肠结肠，
让我们说五个，它会做什么，它会 从第一个索引开始，它是零，
它将转到最后一个索引，但它会选择每 五个元素。所以让我们看看。所以，
它选择零，然后是 5，然后是 10，然后 是 15，因为跳跃是五个中断，你怎么办
想想这会做什么？让我就让我通过 例子来教你，这会是什么
做。是的，它会做什么记住，如果 你在这里应用减号，结束和开始
和结束他们只是被横扫，这成为距离 结束的一步。那么，会发生什么
是同一种冲击，你从最后 开始，然后你一步减
从最后一个，你只是基于每个 元素，所以这是一种反转数组
以一种从最终速率开始的步骤。 所以，另一种反转数组的方法
是如果你想将数组作为一个整体 显示减去一，这意味着从
结束并选择从结尾到开头和 结尾的每个元素，以及数组
将被逆转。这个元素在那里，记住这个 就在那里，让我们链接那个元素。
让我们链接那个元素。所以，所以增加了 位置。所以，我想找出索引，这里
负1200位于。所以Id x 等于一个 点索引我猜有一个函数索引
是的，他有一个没有索引哦，那里没有 索引。是否有 MP 点索引和 P 点
指数？我想找出在 DAX 中 没有索引函数索引的索引
或者什么，我想要一个索引函 数有没有我想找出的索引函数
指数？负 200 在哪里？有几种方法 ，但我想找到一种。所以
比如我看看有没有 索引功能不可用
在 NumPy 中与否。不，它已经不在 了。但我猜在 CS 功能中有。
所以在 CS 中，它的作用是什么，我想它也 能完成同样的工作。让我看看 MPR 指数
返回一个表示网格索引的数组， 好吧。所以我必须给一个网格
然后它返回例如所有网格的索引 ，我该如何使用它？好，
变得很困难，可能有查找 功能，或者如何定位
负200的指数在哪里？是，位于？我 怎么办 我怎么办？
嗯？
是的，非常困难。好像非常困难 。哦，我为什么不找一个
功能？为什么我不玩玩 NumPy？为什么 不？所以让我们说一个相等的
等于负 1200。这给了我一个 布尔数组，将每个元素与
减去 1200。所以，数组返回数组， 让我调用索引数组或布尔值
数组，让我们将该数组是真或假数组 或零或一个数组，无论在哪里
为负 1200，该索引为 1，该值 为 1，否则为零，完全为零。
然后我要做的是，我只是将其 乘以 NP 点排列 NP 点排列与
说一个点 A 点 A 点的大小，所以 不管 A 的大小，所以因为这些
是指数 好的，那么点乘法等级 是什么。所以，我什么时候
将它们相乘，我将得到的是 我将从乘法中得到的，我
会得到，我怎么能我怎么才能发现，一列火车 真的在这里迷路了，我怎么能找到
out 我怎样才能找到我在哪里的索引？ 那会给我什么？让我们来看看，
什么是B。现在，B is B 只是一个数组 。 B 只是一个数组，有这三个。
那就是看着它。那我怎样才能知道呢？ 这三个在哪里？我怎样才能再次
问题是找出索引。好吧，那就是，这真的 是一件坏事。我可以叫这个吗
援助点指数？只需给一个负 1200。 一切都解决了吗？不在这里
是错误，有错误。哦，我在这里迷路了 。从字面上看，我迷路了，我需要
知道如何找出这个特定元素减去 1200 所在的索引。所以
那是一个
也问你。我也迷路了。那么让我们 在下一个视频中再见。而我们首先
将解决这个问题以找出特定 元素的索引，或者可能是
很多元素。然后我们将继续从 那里开始查看更多索引。好的，
伟大的。所以希望在下一个视频中 看到你首先解决问题，如何找到
找出 NumPy 数组中特定元素的索引 ，或者可能不止一个元素
在 NumPy 数组中。然后我们将更多地 练习这些切片示例。好的，希望
下个视频见。好的，假设这个 元素在那里。假设我们
想要，我们想要在数组中定位 那个元素，我们只想知道这个
元素在数组中。所以数组有这个 元素。让我按原样绘制数组，
这个数组有这个特定的元素， 我们想知道它的索引在哪里
数组中的 this 元素，有几种方法可以 做到这一点。一种方法是找出
他们的索引只是你调用函数 arc where arc where 例如，org, where
A 等于负 1200。这将返回一个二维数 组。如果你只想要任何一个索引，
然后你返回那种东西。所以如果 你写这个东西，你会得到索引
正是那里的元素。所以索引 是三，如果你想改变它
值，例如这里的值应该是3，如果 你想改变那个值，怎么办
你可以做的是你可以对，好吧， 即 x 等于 3，并且与它的位置相反
无论它在哪里创建，好吧，太好了 。现在，让我们使用二维索引。
让我们做多维数组，假设我们有一 个等于 NP 点的随机点，Rand，让我们
比方说，假设我们有一个五乘四的矩阵 ，假设一个二维数组，让我们四舍五入
所有的值都乘以 10。它 的作用是因为所有的值
RAND函数，它生成的所有值 都是0到1之间的值，什么
这乘以 10，它的作用是，它实际上 将所有值放大到 10。并且
然后 round 函数，实际上，舍入 实际上是将值四舍五入为整数。
现在，第三轮方法不再存在 的问题将变得更糟。好的，
也许有 NP 零圆，也许那个 NP 圆点圆 ，也许 NP 圆点圆是他们的
是的，还有 B 点圆。所以 NP 的圆函数 。所以这个 a is a is this 数组，例如，
那是五乘四，四，五行和 四列。所以假设我想访问
第二行。首先，假设我想 访问此特定条目。这个
特定条目是第二行第三列，这意味 着索引是一个逗号二，因为
第二行表示第一行的索引为零 。第二行有索引一。同样，列
一有索引零，第二列有索引二 ，一和第三列有索引二。以便
就是这个特定的条目。如果我们 想访问整个第二行怎么办，对于
例如，我们想要第二行。所以这就 是你所说的切片方式。一个正常的
这意味着你的角色应该是一 列，所有的列，所以那就是
您如何访问整个第二行。例如 ，如果您想访问整个第三个
例如，行，或者整个第二列，假设 这意味着你说这个，好吧，
列号秒和所有行，这意味 着访问的整个第二列。
如果你看到了，那就是整个第二列第六 、四到十。还有一，这就是
第二列是。此外，一旦你有一个， 你可以，例如，你可以访问一个子
矩阵，假设你想要，你想要第一 行来规则第三，不包括三。
然后在这些行中，您希望第二 列到列号
四，说吧。如果你这样做，你就可以访问 整个子矩阵。首先，它实际上选择
第二行和第三行，因为第二 行从一开始。然后是
那些行，它选择这些列， 你可以选择里面的子矩阵
更多，你可以，你可以对这些矩阵 做很多处理。例如，这是矩阵
A、如果只打一个点转置， 那这四个转置，矩阵刚好取
转置它。此外，NumPy 中有一个 完整的库，线性代数库。
例如，如果您只是导入 NumPy NumPy 点线性代数，例如，那么
NumPy 中的这个线性代数库，有 很多函数，特征值，chelski
分解，计算矩阵的行列式 ，找出矩阵的逆和
什么不是。例如，假设我们有 la dot inverse，这里是 NP dot random dot
兰德，比方说，一些三乘三矩阵 。所以它返回的是，它返回逆
这个矩阵，这个线性代数库 ，还有其他库。但
这是一个科学图书馆，实际上 可能是大多数数据科学专家
想做研究，他们可能会想 ，这个线性代数库，它指定
很多与这些矩阵或二维数组 相关的函数。以便
在那儿。好的，这就是索引。如果 我们可以经常使用这些指数
想。还有一件事，只是一件事。最后一 件事，让我们说这是我们的 a.而我们
想要做的是假设我们要根据列对这个 A 进行排序，我们希望每个
要单独排序的列，我们可以做的 是我们可以调用排序函数，我们
可以暂停 X 等于零，访问等于零， 这意味着单独对所有列进行排序
结果将是如果您看到结果，结果 将是每一列都已排序
个别。例如，如果我们想对每一行 单独排序，我们会说好的，
sort x 等于1，每一行都将单独 排序。如果这是一个多
多维数组多于三个多于二维， 那么x是可以是两个x的可以
是自由的。因此，对于您想要的任何 轴，您的排序都可以发生。它
可以做到这一点，如果 A 是一维的， 那么点排序功能无需访问，只需
sorts 只是从头到尾对一维数 组进行排序。如果你愿意
以降序排列剑只是先将它们排序 ，然后使用索引将其反转。
太好了，我的意思是，有很多要讨论 的，有很多要讨论的，我要结束了
在这里切片。在下一个视频中， 我将向您展示某种掩蔽或有时称为
在许多不同的上下文中更强大 和有用的花哨索引。
所以希望在下一个视频中看到更 多 NumPy 索引。好吧，还有一个
索引 NumPy 数组的方法。在我们看到的 最后一个视频中，我们可以做切片符号，
例如，从这里和这里开始， 诸如此类。还有一种访问方式
一个 NumPy 数组，因为我们有一个数组 ，我们可以在里面给出一个索引数组
例子。假设 a 是一维数组，然后 我们只给出 146，这意味着大元素
在索引 1 处，选择索引 4 处的元素， 选择索引 6 处的元素。所以这种
里面的数组可以是列表或数组 。这称为索引数组。你可以
只需选择您要选择的元素， 例如，您要选择所有元素，
你想选择第一个元素、第五个元素和 第 17 个元素，你可以创建一个索引
数组并传递它。并在索引中使用 该索引数组访问您的元素
这在 NumPy 数组中是可能的。此外， 您可以使用布尔值访问不同的元素
面膜也是如此。所以布尔数组，比如 true、true、false false，只要有
一个真正的选择那个元素，只要有一 个错误，不要选择那个元素并返回
选取的元素。例如，假设 这里有一个数组，它
是一维数组，假设有八个 元素，12345678 个元素。
现在你在里面传递一个布尔掩码， 其中显然有八个元素，一个真正的
或假值，只要有真值。所以选择 第一个值，选择第二个
值，选择不选择第三个值，不 选择第四个值，选择第五个值
值，选择第六个值，选择第七个 值，不要选择最后一个值。以便
在 NumPy 中也是可能的。重要的 一件事是如果你做这种索引，
这有时被称为掩蔽，如果你这样 做，如果你提供一个数组
索引或布尔形式的索引，与切片 相比，默认情况下您会获得一个副本
在切片中，您会得到一个单独副本 的视图，您无需调用点复制函数，
默认情况下，它是一个不同的副本 。而这就是普通切片的区别
例如，你这样做，从一次开始到 50 次 ，跳一跳，比如说两次，如果
那是您的索引样式，称为 切片，返回值不同
视图具有相同的内存。但是，如果你这样 做，如果你使用数组索引，或者
布尔数组称为掩码，那么您将获得一 个而不是这样的副本，这意味着如果
如果你得到一个新数组，你可以 使用数组更改新数组中的元素
指数。你不会让原始数组发生 这种变化。所以这就是区别
在切片和遮罩之间。好的，这 种布尔索引变得非常方便。
例如，如果您想退出怎么办？如果 你想获得所有较小的元素怎么办
比八，一种方法就是写一个 然后应用一个条件小于
八，好吧，a 小于八，我们将创建一 个布尔数组。而且到处都是
元素小于八，则为真 ，否则为假。现在，
内部数组是一个布尔数组，您可以 访问与该数组相关的所有元素
健康）状况。所以它会返回所有 小于八的元素。多么花哨
就是它？此外，您可以组合 使用这些条件。有一个
不同之处在于有一个 AND 运算符 A 和 D and，并且没有一个不同的操作
道路。所以我将讨论这个和 这个以及这个和这个的区别
整个视频中。所以让我们去我们的 粉丝 Jupyter Notebook 看看我们如何玩
这个面具。
因此，让我们再次说 a 和 B 点排列，排列 ，让我们说 100。就是这样。那是
我们的而我们现在所做的就是 访问A，B访问的元素，例如，
第三个元素和第五个元素和第六 个元素。假设我们想要这样做。
那就是我们的 B。所以发生了，让我们 说，所以 B 是什么 B 是这个，你
需要知道的是，如果你现在改变 B 的 元素，因为那是一个副本，让我们说
减去四，这种变化不会发生 在 B 中的 8 中。但那
不会发生在 a 中，a 不包含任何 负四的值。因为使用这些
索引种类，数组索引 默认情况下 ，结果是副本而不是视图。更远，
假设你有这个 a 并且 你想访问所有小于
假设小于 40， 访问所有小于
40. 所以现在甚至可以只包含 小于 40 的元素。所有
如果您想访问所有较小的 元素，则进一步访问元素
小于 40 小于 40。它们 大于小于 40。
它们大于 30。假设您想访问 介于两者之间的所有元素
30 和 40。你可以像这样访问那些元素 ，所以有问题。一个点任何一个点
这里有什么问题吗？具有多 个元素的数组的真值是
歧义使用 a.ne 或点 all。好的，这个 a 小于 40 是一个布尔数组更大
比 40. 那是一个布尔数组。所以有什么问题 ？什么，为什么我们不能使用这个？
有什么问题？我们应该使用它。所以使用 和，而且，是的，我想我们失踪了
这些，我们遗漏了这些括号，因为 它可能会混淆这个 40 和这个 a
和这样的东西。所以使用 括号率。现在，B 只包含
在 30 到 40 之间。现在，有 一件事，这个特殊的和
而这个符号和区别就是这个和AMD 的一个操作符 当两者都用的时候
这一端的两侧有一个对象， 它有一个真值，真或假。
当左侧和右侧可以是数组 时使用这个特殊符号，
并且该数组的每个元素都可以为真或 为假。所以，所以，你可以想到这个
并且正在使用数组，但是，当双方 都是单个对象时使用。所以
这就是区别。的其他变种，我的 意思是，结局是这样的，这些是
这些是相同的东西，但请记住 this 用于数组，this 用于
对于单个对象。同样，还有其他符号 ，如
或者
以这种方式使用或以这种方式使用 。同样，对于数组也有一个 not not
像这样使用而不是其他方式， 像那样使用。所以记住这些
左侧，我有符号，它们用于数 组，正确的符号，它们是
用于具有真值或假值的单个对象 。所以这些，这种掩蔽是
真的，真的很强大。稍后，我们将在 Pandas 中看到访问不同类型的数据
有了特殊的条件，如果我们 感到舒服，这会变得非常方便
使用这些类型的索引。这是非常强大的 索引。好的。所以，我告诉过你
Aaron 和我之间的区别我已经告诉 过你这是复制而不是视图。
因此，请在 NumPy 上多花些时间 。我会告诉你更多的真相
NumPy。然后我们将转向另一个名为 pandas 的包。所以在熊猫之前更多
NumPy 来了，我希望在下一个视频中见到 你。好的，在上一个视频中，我们看到
掩码，有时也称为花式 索引。我们将在这里
讨论 NumPy 的另一个功能，这是一 个非常强大的功能，称为广播。
我想，例如，你有一个数组，比方 说二，三，一个矩阵，那是一个二维
数组 235 和 9，你想添加，在每个元素 中，你想添加一个数字，让我们
说五个。所以一种方法是用 5555 创建另一个数组。然后应用这个
添加运算符，您就完成了。伟大的。 但是这个 NumPy 允许你只写让我们
说这是数组，NumPy 允许你做这个 特定的事情。而这五个是
自动广播以匹配其另一个 操作数的维度。和加法
碰巧你不需要明确地这样做。而且 这种广播不仅仅是一个标量
价值。例如，如果您有一个变量，假设 a 是这个，并且您想添加，例如
例如，这个特定的列，比方说 一三，你想添加这个特定的
第一列和第二列中的列 ，但是你需要这个
三个要再次复制并制作一个更大 的数组然后你做得很好，广播
允许你如果你只是把它写成 加一三，它会被自动广播
为了匹配另一个操作数的大小， 只要有可能播放书籍，就有
要知道何时可以进行广播的 某些规则并非每次都可能
时间。例如，如果你有这个矩阵 239 和 Jeff 421 让我们在这个矩阵和
你想要例如，二一和六二， 例如，如果你想这样做，广播
可能不会发生，因为这样，如果 我想广播这个结构，结构
应该是如果结构以水平 方式广播到，两列
将被排列并且添加不会发生。如果 它扩展到垂直方式仍然
加法不可能发生。所以，在这里 你会得到一个错误，因为广播是
不可能发生，但在某些情况下， 当您想要添加例如标量乘法时
在任何可能的情况下，通过特定 的事情进行这种广播是可能的
只是一个我的意思是它只是 NumPy 的 一个特性，它允许你不重复匹配
另一个操作数的维度来应用一个 特定的运算符，它本身就很好。
接下来，我们看到一些更重要的 函数是水平堆栈。这意味着，
如果你想连接两个不同的数 组两个可以连接的数组
水平在一起，你可以出去你 可以调用堆栈函数，这将连接
将两个数组放在一起并返回另一 个数组。同样，V栈是如果你想
垂直连接两个数组，如果它们 可以垂直连接，垂直连接，
同样，还有另一个强大的功能 排序，还有很多其他的
函数，这些类型的函数，它们 被称为通用函数。他们是
非常、非常、非常强大、非常、非常 快 他们的实现是矢量化的，其中
基督的意思是在编译时延迟 所有循环类型的实现
当您执行矢量化代码时，时间和事情 都会变得更快。所以，话虽如此
即，始终建议不要显式使用 for 循环来实现这些类型
的，
为了实现这些结果，只要有 通用功能可用，就使用它
因为那个通用功能的效率将是方式 ，方式比任何方式都多
loop 循环或您将要编写的任何 函数，而不是通用函数。
因此，顺便说一下，还有另一个函数 concatenate ，您可以在其中指定
轴。它将充当水平堆栈或 充当垂直堆栈，具体取决于
无论 x 值是零还是一，无论如何。 所以，让我们适应这些，
这三个函数，刚刚快速神经 Jupyter Notebook 和看一个例子，让我们
说，广播也是如此。所以假设我们 有一个函数，假设你有一个
数组是比方说，np dot random dot Rand， 比方说是二乘三。然后我
只需将其与它们相乘即可。记住最后 一件事，然后我们只是 NP 点，
我们只是围绕一切。以这种特殊 的方式，它变得完整。
好的，那是一个，比方说，那是我们的 a，那就是现在，如果我们说加三，三
将在 a 中的任何地方添加，这通过广播 发生。好吧，如果我们这样做，
例如，一个加号，例如，np dot range， 我们说只是做值，然后我们就
重塑它，重塑它，重塑它，让我们说， 一个二一矩阵。如果你这样做，
那么仍然会发生什么只是 应用括号只是为了表明这
应该发生。首先，将会发生 什么，将会有一个列
将被添加到每一列 A 中，这将再次通过
广播。所以广播就是那么强大。接下来， 让我们看看统计数据。就是这样，这个
是一个，假设我们有另一种方式 ，假设 NP 点随机点 Rand。让我们
说新数组是两个两个。再一 次，假设它乘以 Dan 和 NP doc
舍入只是为了避免小数点。就是这样 ，这是 B。 现在 a 是二乘三阵列
D 是一个二乘二的数组，如果我只是水平 连接它们，我会得到另一个数组
这将是二乘五。所以 C 等于 np.at stack 水平堆栈，在堆栈，我会
调用这些 A 和 B。你需要知道的 一件事是，如果你想调用它
x 堆栈，水平堆栈或垂直堆栈 ，B 中要连接的这些参数
您必须将它们倒置，或者您 可能想要提供多个值来连接
在一起也许你有也许你有 10 个矩阵可以水平连接在一起。
你必须把所有这些都作为一个元组放在一个好 的里面。现在类似地，我们可以做一个垂直的
如果我们愿意，可以堆叠。我的意思是，一个 在另一个之上。我们可以调用它并让它发挥作用
同样，如果您愿意。三是排序功能。例如 ，如果我们想要。如果你想使用
NP点，假设a是NP点随机点排列， 假设NP点范围，假设10个值。
假设我们的 a，比方说，这是 a，我们 想对这个数组进行排序。哦，这是
已经排序。为什么要排序？不，它不是按 1/4 排序的。是不是排序了？是的。让我们
说我们想对它进行点排序。一 种方法是调用点排序，然后
你完成了。这就是另一种方式的 价值，它有时更具可读性，尽管
一模一样的是用一个通用函数 ，用NP点那个东西也一样
事物。现在默认按升序排序 。如果要按降序排序，
那么你可以做的是你可以对援助或寻求 进行排序，例如，在升序中这样做
顺序，然后你要做的就是把它倒过来 ，减去一个，然后再复制一次，
现在他将被排序。虽然按降序排序 。很好。嗯，再来一张
只是为了给你更多的味道，如果 你创建一个数组，例如， np dot array
字符串，例如 ABC，另一个字符串 是，你和 vai 怎么样，也许我们有
另一个字符串？哇，785。也许我们还有另一 个字符串，一个，三个 e r，就是这样。
那是一个字符串。那是可能的。只要 所有对象的类型相同，就可以
创建一个空数组。现在，您可能想知道，我们 将在 a 上执行此排序功能，因为
这些都是字符串吗？嗯，答案是它 会根据字符串对字符串进行排序
字母顺序，无论字母顺序 是什么，无论字符串根据
字母顺序应该成为第一个将成为 第一个和其他字符串，他们
他们会不会加入。是的。所以是的 ，所以这是关于不是那样的事情
不是数值。好的，太好了。关于 NumPy 数组还有一些事情要做，
然后我们将转向建立在 NumPy 数组之上的熊猫库
为了更好地处理数据，我希望在下一个视频 中见到你。好的，在上一个视频中，
我们看到了水平串联、垂直串联排序 功能，我们还看到了一些
广播之类的。通用功能， 这里应该是速度，抱歉，
应该是速度，速度。通用函数 真的非常快，我一直在说
关于 NumPy。每当我启动 NumPy 时，我说 ，它很快，它一样快，我从不显示
你这是多快。所以让我给你举个 例子。让我让我创建一个 NumPy
有很多数字的数组，然后只需应用 一个普通函数，比如说想要
要将数组 B 中的所有数字相加，让我们 应用一个不在数组中的普通函数
NumPy。然后让我们使用通用函数点 和，看看那里的速度差异如何。
例如，如果我们应用应用通用 函数来完成特定任务如何
快速通用功能是，因为矢量化 实现，正如我告诉你的
快得多，让我们在新的 Jupyter Notebook 中检查一下。这是一个魔法
命令时间 ID 将告诉我们这个 特定任务花费了多少时间。
如果你运行这个命令，它会一次 又一次地调用这个函数几次
次。然后我们将报告一个平均值， 该平均值将比仅仅调用稳定得多
一次。之后，我们还将使用循环 编写我们自己的 sum 函数。和
我们将看看这是否更接近于 通用函数速度。让我们
只需检查通用函数的速度 ，这将使您了解如何
许多 NumPy 实现速度更快。所以假设 我们有一个数组，假设 B 和 B 点
随机点兰特。假设数组很大 ，真的很大。让我们说这是
案件。现在我们要做的是假设我们调用一 个函数 sum。所以让我们说我们打电话
一个函数总和。这是一个内置函数 。在孟买，这是一个内置的功能
Python 中的内置函数，而不是 NumPy 函数。然后假设我们也这样做
任务使用 NumPy 通用函数和 P 点和，这与 NP 点和相同是
就像我们写的一样，例如，b dot sum。
所以无论你写b dot sum，还是你使用 NP dot sum 并被传递和传递，作为
争论，这两个东西大致相同。所以 让我们运行它，它需要一段时间
这需要一些时间，因为，好的，sum 函数需要 307 毫秒，这不是
NumPy 中的通用函数。这是一个 Python 函数。那不是用 NumPy 写的。那
不是矢量化代码，什么都没有 。执行取总和需要 307 毫秒
这个数组的元素。它通过在圣诞 老人中应用七轮来做到这一点
循环。然而，通用函数只 需要大约三毫秒，我假设
2.7 毫秒，你将如何比较这个 307？带三个？多少
你在附近更快吗？ 100左右？倍你更快？我的 意思是，是的，我的意思是，这个 NumPy 是
从字面上看 NumPy 更快，通用函数 会更快，也许你想知道，
好吧， sum 函数可能太慢了。让我写 我自己的函数。要做到这一点，
让我定义我的儿子，我的儿子只是 争论，让我们说点什么，让我们说
G. 它的作用是，假设 s 等于 0， 它的作用是对 x in g, s 加等于
2x X plus 等于 x，然后作为空返回 。那是你的功能。让我们说
你认为这真是一个很棒的功能。让我们这样 做。好的，让我们计算一下时间
这次是我的儿子。让我们暂停 rabee，看看它有多快。这是
与您调用 sum 函数大致相同，但是 这个 NP 点 sum 还是通用函数
非常快，相当快。所以，使用通用函数 ，避免 for 循环，避免你自己的
函数，如果相同的任务已经可以 通过通用函数来实现，无论何时
可能，在使用 NumPy 时避免循环 。那个严肃的建议，请遵循
那，因为用 NumPy 编写的通用函数 ，它们遵循矢量化代码，
延迟到编译层的所有 解释缓慢。 NumPy 变成
当您使用
通用功能。所以我可以更多地谈论 NumPy。 但我已经告诉过你一些基础知识
NumPy。我们在这里结束 NumPy，从 下一个视频开始，我们将朝着
一种非常非常漂亮和漂亮的包，称为 pandas 来处理数据。顺便说一下，
pandas 库 pandas 包完全建立 在 NumPy 之上。一切
Pandas 中是否有内部构建在 NumPy 之上作为所​​有索引和所有
各种东西，切片和速度。由于 NumPy，pandas 中的一切都在那里。
所以我们会在 pandas 之后看到另一个 包，它是 matplotlib 用于之后的绘图。
最后我们也将使用 scikit learn 做一 个项目，只是为了总结所有这些
一起。但是现在我要在这里结束 NumPy， 在下一个视频中，我们将开始 Pandas
希望在下一个视频中见到你。好的，欢迎 来到熊猫数据科学包，非常，
非常强大的处理数据，操纵数据并且 在数据处理和数据中大量使用
清理和数据预处理等等。这个 Pandas 基本上是建立在 NumPy 之上的。
所以 NumPy 的大部分功能在 Pandas 中也是可 用的。
让我们深入了解。我的意思是，这个 pandas 是 一个非常非常漂亮的图书馆，非常非常漂亮
包，您可以处理 CSV 文件或 Excel 文件 中的大量数据。无论在哪里
数据位于。丢失的条目在那里。您 可以处理所有可以处理的数据
操作所有数据，只需几行 Using this 就可以准备所有数据
pandas 包，所以让我们开始 pandas 包。有两个最重要的对象
熊猫。一个是系列，另一个是我们 稍后会看到的数据框，有
又一个索引。但最重要的是， 或者说有用的是系列和数据
帧。所以让我们定义一下，首先， 你需要 import pandas 包 import pandas。
您可以将其重命名为 PD，这是最 流行的重命名，尽管您可以
重命名任何。然后你就说好吧，PD 点系列，然后就像一个NumPy
数组，你传递你想要的数据。您 可以创建自己的索引，例如，
就像，就像字典一样，这个 a 是一 个键值。这是这一点的键或索引，
二、五，这个B是指数4.5，C是指数4.75。 而这些索引四合一，所以你可以
你可以，你也可以提供你的显式 索引。如果您不提供索引，
默认索引为 012 和三个，但您 可以在其中定义自己的索引
你想要的方式。现在，一旦创建了此 数据对象，您就可以调用数据值并
你会发现你可以称之为美元 指数的值，你会发现
让我们在 Jupyter Notebook 中查看索引 只是为了熟悉 Pandas。第一的
最重要的是，将熊猫导入为 PD，也许或其他什么 。那么好吧，让我们导入它，也许我们可以
检查我们将要揭示在 PD 点担心中 工作的内容。我们是熊猫的版本
现在工作是 0.2 4.25。读。所以让 我们创建数据或任何变量让我们
说一个作为 PD 点系列 buzy 点系列， 我们只是给出了一些值的列表 2345
假设这些是值。然后我们可以将索引 作为另一个列表。让我们说
索引是 a 也许索引不再需要 是字符串，任何 AB、C 和
让我们说战士的指数。让我们来看看 。所以现在系列对象或熊猫对象
系列已创建。 Series 基本上处理 一维数组，后面我们会
参见 DataFrame 处理多维数组，我 的意思是不止一维。一般
通常是二维数组，但可以，点值 。所以让我们调用值，值，
您将获得系列中的所有值。 顺便说一下，这个值数组
你得到了，让我们检查一下那个阵列 的类型是什么类型的电池？一个点值？
那个东西是什么？那是一个 NumPy 数 组。哇。而 a 本身的类型是什么
将是一个熊猫对象。伟大的。所以 熊猫里面的一切，NumPy 都在玩
熊猫内部的角色。伟大的。所以现在，让我们 检查索引一个点索引。这也是一个 NumPy。
那也是一个索引类型的数组，那是一 个不同的实际上索引也是一个对象
在熊猫。这是一个具有这些索引的 索引类型对象，我们可以访问例如，
this a，就像我们使用字典一样，例如， 一个 dat 返回一个值，我们可以
更改值，我们可以添加不同的，我们 可以添加更多的键值对。所以只是想
像这些。
想想这个数据我会喜欢我们看到 的字典对象，这些是键
这些就是价值观。这是 一种非常好的记忆方式
series 可以，并以我们想要的方式操作 series。 好的，一，我们可以访问一个 z like
这个，我们也可以做切片。假设我们 想从 A 访问让我们说 C 让我们
说我们要访问所有这些一个区别是当 你像这样访问时，在正常情况下
使用隐式索引进行切片，例如 123 或零，不包括最终索引，
但是如果你像这样访问，使用那里 的显式索引，最终的索引是
也包括在内。所以这是在这个熊猫中使用的 一种更奇特的索引方式。好的。伟大的，
顺便说一下，这是一个严肃的对象，我们 可以通过首先创建一个严肃的对象
例如字典。让我们回到我们的幻灯片 ，看看这个例子，让我们
创建字典。比如盘子，我们 有很多A级的同学
A级减B级，红色B减，让我们创建 那个字典，然后我们就可以创建
一个系列对象或者熊猫的对象，只要把 这个字典传入里面，我们就可以制作
例如另一个字典，我们可以制作 另一个系列对象。所以一种方式
定义系列对象只是为了传递 数据以及其他索引
方法是先创建字典，然后 在里面传递字典变量，
并且将创建系列对象。好的， 这只是对系列的介绍，我们
随着我们 在
即将上映的视频。希望在下一个视频中 见到你。好吧，假设我们有两个不同的
字典，假设我们有很多学生， 并且 a 等级定义为四和
a 负等级定义为 3.5。 b 级 A 的数字为 3，B 减级为
2.5 的数值。同样，b 级 具有美国价值，让我们
做然后我们使用这本字典创建一 个系列对象，让我们说而不是
只是数值作为 GPS 或类似的东西 ，让我们说等级也被定义
总分 85 分，负评分者定义为 总分 80 分，类似地这些
然后我们创建另一个系列对象， 假设使用这些标记以标记命名
PD点系列。因此，让我们转到 Jupyter Notebook 并稍微玩一下这些词典。
并构建系列对象，比如说分数， 或者说成绩。字典等于，让我们
说，一个等级，有一个八级有 数字值，RGB值，让我们说，
假设我们有一个带有 GPA 值的 B 级， 假设 B 是假设它是 3.5。让我们说
我们有 GPA 值的 C 级，比方说三 个。让我们说最后，我们有 d 级
GPA 值，比方说 2.5。假设这是一本字典 。好的？我们现在所做的是我们创造
一个成绩系列对象，假设使用 PD 点系列，然后通过这个成绩下划线
技术。现在这个资本A资本B，资本 C和资本D，它们将作为指数
这是 3.53。在 2.5 中，它们的行为类似于值 。例如，如果我们打电话给她并且
刚才称为成绩点 v 点值，所以我们 将得到，例如，那是什么？那
只是价值，让我们说，产生这个等级的 股票价值，我们得到所有的价值
可用的。同样，如果我们找到等级或指数 ，我们会找到 A、B、C 和 D。让我们
定义另一个字典，例如标记字典 dict。让我们再说一遍，
有一段时间总分是85分。对于 a级，比方说，对于b级，总分
比方说，75。比方说C级 ，总分是
比方说 65。对于 D 级，比方说总分 是 55，比方说。所以让我们说
那是另一本字典。现在，让我们创建 一系列对象，一个系列对象 PD 点
系列，系列，让我们说标记字典。所以 现在再一次，如果你写这个，我们有
分数，就像这样，你会看到分数是 85，b 75，c 65，D 是 55。所有的值
它们是整数 64。加纳值，现在我们可以 访问。现在我们可以玩这个标记，
例如，如果我们只想访问，例如 ，标记是什么？什么是
标记之间，例如，我们 可以访问的标记是什么
我们可以改变，我们可以像字典 一样玩。如果我们而不是使用
index 在a中，我们使用例如切片 ，我们想从头开始。和
假设我们要去两个会发生什么？让我们来 看看。是的，所以，切片就在那里
例如，如果您希望这些是显式索引 A B、C、D，则这些是显式索引
他们就在那里。例如，如果您可以切片 ，则可以使用显式切片对数据进行切片
给定的索引或默认 索引的隐式索引，
第一个值索引为零，第二个值 是索引二，依此类推。那么你
也可以这样做，例如这里的一个捕获， 我们稍后会看到，可能有一个
问题是您的显式索引它们也 是数字，然后您进行切片
像这样，那么系列对象可能会混淆 是否必须使用显式索引
或者里面的隐式索引，我们将看到如何 解决这个问题，但是通过这个熊猫
允许使用显式索引和隐式索引 。好的，我们到了。
所以，他就是这样，是的，所以，我们在这里 。因此，我们将这些成绩创建为一个系列对象
这标记为系列对象，这些系列 对象适用于一维数组
或只有一维列表或字典的 数据，有点只有一维，
稍后，我们将看到实际上是 curl 的扩展的数据框可以是
看起来它可以看作是一个 多维系列的延伸，
例如，我们可能有二维数组 或二维数据结构，
像这样的东西。我们将看到 这个数据框更强大，特别是
用于从文件中读取数据并操作 它等等。我们会看到，在
next video data frame 下一个视频中数据 帧的运行形式，希望能看到
你在下一个视频中。好的，在上一个视频中 ，我们正在讨论系列，我告诉过你
该数据框基本上是如果数据 是否具有不同列形式的数据，
例如，一个记录作为一个数组，然后 你有另一个记录，然后你有另一个
记录。该记录中的每个元素都是 不同的属性。所以这个特别
使用熊猫内部的数据框而不是二维 数据的方式可以很好地处理
系列。因此，您可以使用不同的系列 对象制作这些数据框对象。为了
例如，您有一个很棒的对象，可以对我们 上次创建的对象进行评分，您知道，
标记我们上次创建的对象，让我们使用 这两个构建一个数据框，看看
它在 Jupyter 中的样子。笔记本。让我们 看看。所以请记住，我们有一个标记
series 对象，我们有一个成绩系列对象 。现在让我们打分。也许，也许
名字是rates，好吗？这个名字就像成绩 一样。好的，所以评分对象，这个，
让我们制作一个数据框。
让我们说 D，或者你想用那个 数据框做数据框的任何名字
也可以使用字典来定义。再一次， 现在我们可以说，分数是关键
数据标记。而成绩是数据成绩的 关键。假设我们定义了一个数据
像这样的框架。现在如果你看看你是否只显示 这个 D，我们会得到一个非常漂亮的外观
并且感觉我的意思是因为索引是 索引 a 处的显式索引、标记、
分数是85。分数是在索引B， 分数是75，分数是33.5。和
不仅如此，您还可以 像转置一样转置它
到 NumPy 数组，如果需要，您将 获得翻转版本或转置变体。
伟大的。所以这就是你可以 有更多的字典来连接
在一起，更多的列将在这里添加 。这就是真实数据的样子。
我的意思是，它有很多列，通常是 属性。而且每一行基本上都是
您要处理的数据的一个记录或 一个样本。所以这个数据框是
真的，非常适合处理文件的数据 结构，有很多记录，你
想要操作数据之类的东西。所以 ，是的，还有一件事，让我们
访问 D，例如，那是品牌 D， 那是，那是 D，让我们访问
D里面的值，除了No之外，那是 什么值，所以，D里面的值完全是
又是一个完全像这样的二维数组 。例如，如果我们想访问
这个特定的元素 65，即第三 行和第一列，不包括
第三行和第一列的索引。所以 我们可以访问那个特定的值
T个点值，只假设NumPy数 组，第三行是索引
使用 do 和第一列是索引， 我们将能够访问 65。哇，
伟大的。所以就在那里。还有 更多可用的 d 点，例如列，
d 点列，列，它会给我们 什么是列，列是标记和
成绩。还有其他属性。 还有其他几个属性
我们需要知道Rs，例如，this there，我们 将其定义为di d dot index之类的东西
像这样。好的。你需要知道的另一 件事是我们现在可以重复我们有
那个子D，就是这个。那是 D。假设 我们想在这里添加另一列，
只是我们想在这里添加另一列 。这就是该列的名称被缩放
分数。如果我们计算了分数，而不是 从 100 开始，那么刻度标记会怎样？
如果我们计算了 90 分的分数怎么办？ 90 的缩放比例是多少？所以一种方式
这样做，而且非常快速的方法 就像一本字典，再次，像一本字典，
您只需添加一个新键，比方说，缩放 标记，这是一个新键。价值是
只是所有的标记列除以 90。那是真的 吗？不？除以 90，如果我们
刚考完90分，那怎么办 ？我们如何计算分数
从90？它不是 100。它来自 90， 我猜？我们如何计算分数
从90？如果你想从 90 开始计算 分数，我猜他们会看起来像
乘以 90。也许这里乘以 100。 我想也许是公式。我猜那
就是这样，我想让我们看看。所以现在 如果你看到 D，就会有另一列
就在那里。哦，它还有别的作用。无论如何 ，它做了一些事情 是的，所以一些事情
无论如何，所以我们看到我们刚刚，我的意思是，我们 刚刚计算了这个，我们只是
我们刚刚发现我们刚刚在我所在的 列中插入了该列，有一个过程
这些值中的每一种。也许我们以非常 错误的方式添加了此列。和
稍后，我们建议好吧，我们应该 删除该列。嗯，这很简单。
再次，再次使用概念，就像 字典一样，删除这个，这个列
从数据中删除。你又得到了你拥有 的数据。所以你可以添加列，
你可以删除列，索引真的很好。我的 意思是，索引就像屏蔽一样，
比如说，你想烘焙，或者你 想烘焙 DataFrame，这样你
想要选择所有记录，以便 标记是标记。标记更大
比比，比比，比比，比方说 70。你想挑选所有记录
大部分分数都大于 70。就这么 简单。所有数据都将
在这个条件下被复制到 g 中 。这个条件可以任意复杂
使用 ands 和 ORS 以及组合和所有 这些东西。你见过这种
NumPy 中的东西也是如此。我的意思是，这叫 做好的，太好了。所以这在熊猫中可用
以及。好的，这就是您可以在下一个索引 的方式。在下一个视频中，我要去
基本上向您展示一种通常发生 在真实数据中的问题，即
缺失值问题。有时您读取 数据和一些属性或一些
在行列 p 值中，它们只是丢失了。我的意思 是，由于某些原因，它们不可用
原因。你如何处理这些值？以及 熊猫实际上如何建议您
处理这些类型的缺失值，有时 称为 Nan 值或非类型
值。此外，它们主要在熊猫中互换使用 。所以在下一个视频中，我们将
处理或查看如何处理 pandas 中丢失的 数据，希望在下一个视频中见到您。
好的，在上一个视频中，我们看到了数据 框对象。我们实际上看到了如何添加和
删除列如何处理数据，如何索引 如何实际屏蔽或如何应用
正如我们非常简要地看到的那样，债券 中的条件和选择，但在这个特殊的
视频，我们将看到一种缺失值， 有时称为名称或不称为数字，
或者可能什么都没有，或者有时这个 修女输入无，这是默认的返回类型
的任何功能。在 Python 中。这种 非类型有时在熊猫中也被视为
Nan 或 Nan 被视为无或可互换。任何 东西。让我告诉你我们的意思
通过那个，假设我们有两个字典 ，假设一个字典是具有键值的
a 和值是 1，然后 B 和值是 2。 好的？另一本字典是 B 和 C。
例如，这是一个包含 A 列和 B 列的 记录。所以 a 和 b 是列。在
第一条记录，a的值为1，b的值 为2。现在让我们说我们想要
在同一数据框中插入另一条记录 。现在 b 的值在第二个可用
时间，好吧，如果b可用，也就 是3，c的值可用，这意味着
现在添加了一个 C 列。但是对于 值 c，第一行值不可用。所以
我们会说这里缺少这个值。但在 第二行，我们有四个类似的，
第二行缺少 a 的值，这 是一个缺失值，即
有时称为南。所以这些是缺 失值。他们是典型的。当你
处理数据。并且您正在读取 数据，从中获取数据
某处或大文件之类的东西。所以大熊猫 给出了一些处理这些的方法
的种类
这些我的意思是，这种情况，让 我们说一个等于 PD 点数据框，
数据框，又是一个字典，假设我们有 一个，
一个和 B，比方说四个，这是第一行 或记录。第二个记录，让我们说
是另一本字典，假设 B 是负 三，而 C 是九。就是这样。
就是这样。那是我们的数据框a。所以现在 如果你带上这个如果你看到里面的数据
a、你会看到哦，有什么问题吗 ？这个重吗？你玩过东西吗
以错误的方式？让我们来看看。哦，我们 必须创建一个列表。没关系，我们必须创建
它的列表，您必须创建字典列表，这是 调用它的正确方法。所以我们
只是错过了这个索引列表。好吧，对了。 所以现在我们有了这个 A，B，只需调用
a 和此值缺失且该值缺失 。在大型数据文件中，
这是典型的，我的意思是，有很多 值可能会丢失。熊猫的一种方式
把这些缺失值补给地狱只是用 一些东西来填充这些缺失值
例如，固定数字，有一个填充功能 ，填充任何功能，让我们说
你提供零意味着哪里有不 可用或不是数字值，
用零填充它，或者你想用任何 值填充它。所以这是一
这样做的方法，现在如果您看到 a 的值是所有非值都填充了
那，在 Pandas 中可用的另一 种函数有时会被使用
drop na 那个函数 drop na，它的 作用是删除所有包含的记录
一个缺失值。有时，如果这是可见的 ，我的意思是删除所有包含的记录
缺失值，如果这是可见的，那就 去做吧。但是如果如果缺失值
很多，它们分布在很多行上， 然后删除所有这些类型的记录，
他们会造成很多我的意思是数据 丢失，然后它变得非常非常重要
如何处理这些缺失值。但是， 您可以修复您可以填补缺失的
值使用固定值，或者您可以删除它们 ，稍后我们将在 scikit 中看到
还有其他处理缺失值的方法 ，您可以填写每一列
使用平均值或使用例如回归 的每列中的缺失值有
处理这些缺失值的方法。但是 在pandas中，这两个函数是马上
例如，您可以使用固定值填充所有 它们，或者您可以删除它们并
你准备好了。好的，太好了。接下来 ，正如我之前提到的，我们将看到哦，
如果隐式之间存在混淆， 那么什么之间的混淆是什么
和显式索引。我将在下一个视频 中讨论基本上，只是为了给
如果您提供的显式索引是一三 和五，您会感觉如何。和
如果你将此特定命令称为冒号 三，它会调用隐式命令吗？
索引或显式索引，这是一个问题。所以 我们会看到因为 1.1 冒号三，一
并且三个它们也是显式索引 。这个冒号三是否指的是
到默认索引的隐式索引，或者它们 指的是这些索引。所以
这种混乱是存在的，我们将看到如何 处理这种混乱。使用这个锁，
LLC 函数和索引锁 ilsc 函数，我们 将在下一个视频中看到，希望
下期见
视频。好的，在上一个视频中，我提到 了可能存在的混淆，如果您有
提供可能与隐式索引冲突的显式 索引。特别是，对于
例如，如果这是系列对象，或者 如果您想要，可以是数据框对象
对于索引，让我们考虑一下系列对象 ，它具有这些值 ABC 和索引
一三和五，例如，如果您访问特定 元素，让我们说带有索引的数据
一个肯定意味着显式索引 ，但例如，我们将值切片
例如，一个冒号三个，如果你给一 个美国疾病切片的默认行为，
那就是使用隐式索引，而隐式索引 是指我们的意思是什么是在
索引一处的索引一这是 b，因此 B 将 被打印，例如，或 B 将被提取，
然后你开始做 C 然后 C 将被获取，这些是值
这将被打印，但行为可能会有所 不同，您可能希望使用
显式索引，这意味着访问一个 冒号三，当使用显式索引时，
最后一个索引也包括在内。在这种 情况下，您可能会期待索引一
是 a 所以应该打印，索引三 是 B 和 B 应该打印。和
如果存在，则此配置可能 存在。所以要处理有
两个函数一个叫做l OC。而另一种方法 称为 i l OC，无论何时您调用
LLC，这意味着您正在使用显式索引。我 的意思是，您强制使用显式索引。
每当你打电话时，我 LSE 这意味着 你正在使用隐式索引访问元素
不管什么。所以，让我们练习 一下，看看混乱。查看详情
在这里 Jupyter Notebook 中的这种混乱 。假设我们有一个系列对象，
假设等于 PD 点系列。假设它 的值为 a、b 和 c，NASA 值。
这些是值和索引，比如一、 三和五，让我们添加这些是
指数让我们说这是八 好吧，假设 我们访问一个 using one 这意味着
表示显式索引，也就是说 B 访问并使用切片运算符。
现在，这将使用隐式索引，它将 访问我的意思是它将访问这些 B
和 C 因为一个冒号三使用索引隐式 索引结果，我们可能
可能会期待使用这种东西。 所以，如果我们真的对
使用显式索引，我们应该做的 是我们应该将 lat 函数称为锁
然后一个冒号三意味着，使用 显式索引来消除混淆
现在，它将使用显式索引一和三 ，例如，​​如果我们感兴趣
在使用隐式索引时，最好使用 ilok 函数 是的，现在，一列
三是使用隐式索引，隐式索引就 是这样。所以，就像系列一样
对象你可以你可以你可以在数据框对象 中做同样的事情。一旦你使用
lock 和 ilok 然后这些方括号内 的进一步索引完全相同
像 NumPy。因此，无论您使用 log 还是 ILOG，索引机制正是
切片机制与您在 NumPy 中使用 的完全相同。一世
意味着保持相同日志的所有索引意味 着您正在使用显式索引 ILOG 意味着
您正在使用显式隐式索引。比方说， 例如，我们有我们的数据框，我
猜 D，这是我们可用的数据框 。假设我想访问 d dot ilok。
假设我想完全访问第二行 的第二条记录，哦，记录
索引为 2 处的索引，完全 是第三行，比方说
我想要
访问那个。现在这两个正在作为这 两个作为，例如，如果你看到
第二行或第二个索引处 的或行，即第三行
完全此编辑返回，例如，一旦您 使用了锁，并且大多数情况下
人们使用ilok。有时也需要锁。但 我登录只是为了明确提及
我将使用隐式索引方案。 再次，您可以考虑持有
那个东西作为矩阵。一旦你应用了 这个眼锁，那么你就可以自由地
例如，使用索引，就像使用 二维数组一样。我想要
例如，我想反转，例如，所有 的行，我想反转所有的
例如，所有所有结构，假设 我想这样做。你可以看到一切
被逆转。我的意思是所有索引 都像九一样的索引都在，在
熊猫。我的意思是，一旦你在里面使用 了 il​​ok 只需要记住 NumPy 索引和
一切都是这样。好的，这就是日志和我 的日志功能。在下一个视频中，我们
实际上只是要练习 熊猫来实际工作
我们保存为 CSV 文件的数据文件。所以 我们会，我们将向您展示如何
实际添加如何实际操作读取 和写入数据并使用数据，
数据，某些 CSV 文件中的真实数据 ，以及 pandas 将如何帮助您
以非常有效和非常快速地 处理数据。所以希望能在
下一个视频。好的，在这个特定的视频 中，我将谈论真实的数据集。这
我选择的数据集只是为了向您 展示一些 Pandas 中可用的功能
处理真实数据集我选择作为可 用的 COVID-19 数据集的数据集
在 kaggle 上。这是一个超现实的数据 集，其中包含恢复的受害者信息
每个国家每个省的康复 总人数，总人数
死亡人数和每个日期 报告的总人数
该数据可用。让我们看看文件 中数据的外观。只是为了
看看我们在谈论什么样的数据。假设 这是我们的数据。这是连续剧
仅包含记录编号的数字列 。那是一个叫做观察的专栏
日期。那是一个日期，那是一个省 或州。这是最后一个国家或地区
更新记录更新时间 和有多少确诊病例
在那个日期，以及在那个日期有多少人 死亡以及在那个日期有多少人康复，
随着日期的推移，您将 看到确诊病例的数量
并且康复病例的数量将会 增加，也许死亡人数
它们也会增加。那么让我们看看这个数据。 让我们使用 Pandas 读取数据并执行一些操作
操作此数据并查看该数据的外观 。在 Jupyter 中，笔记本。
我们去 Jupyter Notebook 看看。所以首先 ，我需要这个熊猫库并倾倒
也许在某个地方我也需要这个 NumPy 库。我也在学通灵
学习SK学习库因为我想，我想 使用impute函数，只是为了处理
缺失值，使用我在 SK 学习库 中的功能更强大
也是一个数据科学库包 ，特别是机器学习库，
或者我们的包实际上提供了更好 的支持或更大的处理丢失的支持
数据。虽然在这里我使用这个 SK 学习功能 只是作为一个例子。而且但是但是
我可以使用这个数据框填充任何 函数或类似的东西，但我只是
使用那个。好的，在导入所有这些 之后，我所做的就是调用 PD dot read
CSV 函数，然后我加载该数据，然后我 一一执行这些操作。我们，我们
让我们花点时间一一研究所有这些命令 。让我们在 Jupyter Notebook 中看到，
发生了什么，让我们转到 Jupyter Notebook 并 实际阅读该文件并执行任何操作
我们在这里做。所以首先，导入 已经导入的 NumPy。进口。
比如已经导入的pandas，那么从 SK学习dot impute import simple
不纯。所以让我们使用它，或者让我们 好吧，让我们这样做。从SK学习点插补
SK learn dot impute import simple in pewter, 好 吧，import that 因为那是新东西，
我们需要导入现在读取的数据， 例如df中的数据框。所以 df 等于
PD 点读取 CSV。有一个 CSV 文件读取 CSV。它包含文件的路径。
路径位于我的目录中，它 位于这个特定位置 COVID。
它的名称是 COVID，下划线 19 ESCO 数据。所以 COVID 下划线 19 下划线
data dot c s v. 所以让我们读取那个文件， 文件将被读取，如果你只是看到一些
有一个函数，让我们说 head 给出最高记录或记录
出现在最顶部，这就是我在 Excel 中向您展示的数据文件，
它只显示前 5 条记录，我可以 显示前 10 条记录，例如，
只需以这种特殊方式调用 head 函数 。好的，太好了。假设我只是
想删除这个实数，因为我认为 这不是必需的。让我们说
我想删除这个特定的列。因为 这也不是必需的。有多个
这样做的方法。我可以为此调用 t l 函数。我可以调用 L 函数
那。但是还有另一种方法可以 通过 df dot drop df dot drop
只给你想要删除的列，其中一 列是序列号，我猜，是什么
列名？那是 s 和 No。 所以你 想要你想要删除那列然后你
想要删除带有鲱鱼上次更新的特定列 。所以这是最后一次更新。以便
我猜那里有什么
Xs 一个就地德鲁。所以Xs 一是正义 。提到，用列做那些事
就位，等于真。这实际上是，告诉 你无论你在做什么这个操作
将反映此 df 框架中的变化 。如果我们不写到位，
我们将做所有事情并返回一个临时变量 或下划线变量或其他任何东西
我们是说，但数据帧的 DF 将保持 不变。所以到位真正意味着做
df 变量本身的变化。所以现在如果我们 看到 df dot 有 flat 说，它不会
不再向我们展示序列号列和最后更新 的列。我们接下来怎么办
可以吗，我们可能想重命名这个 ，这个名字只是日期。例如，这
也许是另一个，让我们重命名所有这些 列，使用重命名函数，df dot rename
列等于二，然后我们再次将该字典放置 在等于二的位置。所以让我们使用
使用这个读入函数，TF 点重命名。 让我们这样做。在这里我们有列，列，
如果我拼写正确的列，然后 那是字典您要更改的列，
我想改变观察日期，我想把 它改成简单的日期，比方说
我也想把省斜线状态改为 简单的状态，我们省省
简单地说，我也想把这个国家 斜线区域改为简单的国家。
所以，也许我想将这个国家斜线区域 更改为仅仅由于国家 cru 并尝试
国家和我希望所有应该发生的事情都 到位。所以就地等于真。所以之后
那，如果你运行它，在这个特定的步骤 ，现在如果你看到 df 的状态，
你会像
所以。好吧，这么多，所以他们省国家， 确认债务，等等。所以这是很多
比以前更好的形式。而且，我们可能 有很多缺失值，哦，一种方式，
这个日期格式，日期格式不是 pandas内部日期格式的格式。
所以让我们将日期格式转换 为内部pandas日期格式，使用
到 PD 到日期时间功能。所以让我们说 df 日期等于 PD 到日期时间，然后转换
此特定格式的 df 日期。现在如果 你运行这个 TF 点可能是
以不同的方式查看日期 格式。看那是日期
大熊猫期望的格式。现在 ，我们只是展示了一些
记录 如果你想看到更多的记录，我们可以 看到那些让我们说我想要只是我想要
只是计数或让我们说让我们只描述 TF 点处的所有数据描述有一个
描述数据的所有大部分统计信息 的函数，我的意思是，总数
确诊病例数是这些死亡人数 是这些康复者是这些许多列
有这么多值吗？平均值 是，标准差是
最少 25 个。这些是统计数据。 假设还有另一个函数信息 df
dot d 一条狗的信息。如果您调用该函数 信息，它将为我们提供更多信息
关于零增长和名义增长等。 例如，如果您看到总计
数据列数为6，总记录 数为6162。日期增加
始终可用。全省条目仅 3700个可用，其余增加
我们的零增长，所以省增加了大部分 的增长或零增长，他们
在那里，也许我们想放弃那些， 或者我们想把这些增加归咎于
像这样的东西，但它们没有 增加，在省列中可用，
某些省，某些省的值不再 可用。让我们来看看
就是这里。例如，这个不可用， 这个不可用，这个不可用。
这就是数据的真实状态这 是不可用的，这是不可用的
等等。所以这可能发生。好的，接下来 ，我们要做的是，我们实际上是在使用
简单的计算机只是为了估算缺失值。使用 简单的 mburo 做到这一点的一种方法
向SK学习。另一种方法是，正如我们已经知道 的，只是 df dot fill na fill na with，让我们
说一点 假设不可用 假设一个字符串 ，某些字符串不可用，那就是
它是那个字符串，然后用那个，如果你 现在用那个填充任何填充，在那之后，
我们将拥有所有数据，缺 失值将根据让我们看看
一些缺失值，因为在该省存在 一些缺失值。现在你可以
看例如，让我继续离开 是的，所以 不可用 不可用，我们可以
可以使用它，或者我们可以使用 通灵者可以获得的奇特的东西
等等。好的，之后，如果你现在 看到信息信息，现在，你不会
看到任何空值，所有列都在那里 ，哦，这没有到位。所以不要
填充 na 那是让我们用它来改变 DF。 所以这不会发生，df只是改变了
DF。好的，df改变了。现在，如果我们 现在调用信息，则不再有空值。
是的。
所以我在这里有这个视频。在下一个 视频中，我将通过命令向您展示这组
以更详细的方式看待这些东西 。因为这个特别的视频是
让这里的灯更亮。我我要停 在这个特定的位置。下次，
我将在熊猫的数据框中按命令 向您展示分组。我会展示
你这是做什么。因此，我们将探索 这里编写的所有代码。我们会
在即将到来的视频中，我们 将看到绘图和 matplotlib
使用相同的数据文件进行更多工作 。并更深入地了解这只大熊猫如何
和 matplotlib 和 NumPy 结合起来 ，他们实际上可以如何玩
在分析非常非常大的真实数据文件中起 着非常重要的作用。好的，所以我结束
这个视频在这里。我将从这个命令 开始下一个视频。我会告诉你
正在发生的事情 范围 baikman 所以希望 在下一个视频中见到你。好的，
在上一个视频中，我们讨论了这个 COVID-19 文件，我们到达了这里，但我们
没有使用这个 SK 在锡中学习，我们只是 使用数据框的填充 na 功能。现在
让我们通过命令或熊猫中更明显 的居里来讨论这个组。让我们
说我们现在的目标是，例如，如果 你回到木星，如果你看到你亲爱的
df 点头，或全部，在 D f 点头， 让我们参加记录。如果你想看那个
这么多记录，我们只看10条。让 我们看看，你想做的就是你
只想看看每个国家有多少 ，总共有多少确诊病例，
不管他们的日期。而且，例如， 您只想查看所有所有所有所有
每个国家的所有确诊病例、所有 死亡病例和所有康复病例
日期和所有省份合并在一起。 一种方法是写一个组
命令例如。这是一个 df two 等于 df dot group by 和 in group by 你所看到的
是针对您想要对所有这些数据 进行分组的列类型。所以
例如，您想按国家/地区分组。国家 。这就是你的分组。现在之后
gopeng你想看什么样什么样 什么样什么样的，比如
你想看到的值，因为现在你正在放弃 ？好吧，分组后我真的很想要
看看因为一旦我删除数据就消失了， 所有的日期，它们都被分组在一起
防止组合在一起。所以，我 真正想看到的只是国家和
我想看看确诊病例。所以，选择所有 这些确认的记录，然后我想要
看到死亡和康复。所以，举例来说， 如果我想死，让我们说那么我
想看到恢复的病例是 E 只是我 想要一个所有国家的大集团
一起将所有这些东西组合在一起并添加 每个国家/地区下的所有记录。所以
将所有这些相加，也许我们想重置 任何索引（如果存在）。例如，
预设，我们设置索引。所以，所以，在这个 居里之后，例如，这个group by query，什么
将会发生的是，这个 df 2 将 包含每个国家/地区的数据摘要
和总数例如，在这个特定国家 ，确诊病例总数是这些
到目前为止，所有确诊病例，以及这些 病例的死亡人数和为这个国家康复的人数
对于每个国家，现在，每个国家都在描述澳大利亚 ，例如，在我们的直到现在，
澳大利亚总共有这些确诊病例， 这些总死亡人数，这些都已康复
案件等。所以，也就是说，如果我们想 根据国家/地区对所有这些进行分组，
例如，如果我们想根据国家和日期 对所有这些进行分组。所以，
首先我们想按国家对它们进行分组， 所以国家然后对于每个国家，显示
所有日期，然后做同样的事情 ，居里将几乎保持不变。一种
group by command 会说几乎相同 的一种
有一种假设我们要先按国家 /地区分组，一旦分组
按国家/地区，然后我想按日期对它们 进行分组。现在我想看看所有的结果
以我也想查看数据的形式。现在 将要发生的是每个国家，
它相对于将在此处显示的所有日期 的趋势。所以让我们看看 df 二
现在，df 两个。所以如果你现在看到 df 2， 你可以看到，例如，这个特定的国家，
它在这个国家只有一项记录，它 有一项记录，那么这个国家为此
日期在同一个国家有这个记录， 其他日期有相同的记录，所有的
数据也是排序的。我的意思是，现在您可以 以非常增量的方式查看所有记录。
因此，这可能会让您对正在发生的事情有 一个非常好的外观和感觉，或者，例如。
另一件事如果你想要什么 ，例如，找出所有
记录，所有的记录，你只是想找出 所有的记录？让我们做三个，
四、确诊病例，比如确诊 病例超过100例。
让我们找出所有的记录。让我们， 让我们让我们让我们选择所有的
确诊病例大于 100 的记录 。让我们复制所有这些
仅记录此中的那些记录。所以如果 我们这样做，我们有 d3 可用，我们有
d3.这，我的意思是，这些只是 确诊病例肯定的记录
大于 100。就是那些。是的，所以我们可以这样 做。我的意思是很多很多的数据分析，
真正的数据分析，还有很多很多，我 只是给你展示了一个很小的快照
我们可以在真实数据集上用熊猫 做什么。我的意思是，还有很多
我们可以使用这个 Pandas 库，在多个 数据文件的真实数据集上，结合
它们在一起，将它们连接在一起，看到 它们的相关性，很多东西。和这个
pandas 真的是一个非常非常 高级的库，非常高级的包
处理数据。所以由于时间限制，我只是 在这里结束这个熊猫，虽然
还有更多要解释的，但在下 一个视频中，我们将跳到
matplotlib 只是我们将看到一些 matplotlib 的功能。我们将非常简短地看到
我们如何绘制我们如何使用可视化图表 或类似的东西来分析数据。所以，那个
有时，这种数据不同属性的 可视化提供了很好的洞察力
尽可能地访问数据。如果可视化 是可能的，如果数据
维度在某种程度上是可视化 技术的方式，您可以可视化
数据的趋势，比数字 给你更好的洞察力
或统计结果，但这完全取决于 您可以可视化的情况
数据在某些情况下，例如高维 数据并不总是可视化的。
因此，在这些情况下，数字的统计 结果可能会发挥更重要的作用。
但在更多情况下，可视化可以 很好地初步了解数据
如果你对数据有所了解，设计 过程会变得非常非常快，
无论您是通过可视化还是其他统计数据或 其他方式获取该信息。所以，在
下一个视频，我将只解释 matplotlib 的一些极少数功能。和
然后我们会，然后我们将探索同 一个文件，我们将做一些事情。
使用绘图和 matplotlib 做一些事情。并且 这样做，看到死亡率的趋势，
看到我的意思是，我们将更多地 使用 matplotlib 来处理这个文件
以及。所以希望在下一个视频中见到你 。好的，在这个视频中，我将讨论
matplotlib 一个非常强大的包，用于 绘制图形和散点图、线图和 3d
地球上的情节和情节等等，我的意思 是，非常非常强大的工具。最多
这个matplotlib中的重要模块，或者最 流行的模块，或者最常用的模块
是双线图。所以我们可以将 matplotlib.pi 图导入为 PLT。另一种写法
我们可以像 Matt matplotlib 那样 写一些东西
从 matplotlib 按图导入为 PLT。所以 无论我们把它写成哪种方式都可以
一份文档或像 MP 一样适用于 NumPy 的 文档。所以让我们创建一些点，
只是制作我们的第一个情节。 让我们从零开始做一些点，
假设所有点从零开始到 10。让 我们在两者之间创建 1000 个点。
一种方法是使用内置函数或 NumPy 中的方法，即 linspace 或
从零到 10 的线性间隔点 。 其中有 1000 个
点。假设这是我们的 x，这是我们 的假设 y，它是 NP 点正弦，
正弦函数实际上会在这个 NumPy 数 组上逐个元素地应用。然后这个
PLT 将实际绘制 x 逗号 y 前面 的所有点。所以我们走吧
到 Jupyter Notebook 并实际看到这个 matplotlib 以运行形式第一次出现
时间，哦，我们已经看到了这个matplotlib。当我们 看到 NP dot random 时，我们只绘制了一个直方图。
虽然这不是我们第一次真正看到 过一次，一次，一次。所以
将 mat plot lib.pi plot 导入为 PLT。那 是您的导入命令。例如。现在PLT
可用。假设 x 是 NP 点 Lin。空间。让 我们从零开始。转到 10 并生成
比方说1000分。就是这样。那是你的 x，y 可能是你的 MP 点正弦 x。就是这样。
那是你的y然后你做的是你说 好的，PLT点图，x逗号y点
点，然后按Shift，回车。就是这样 。哦，这个情节就在你面前。
就那么简单。我的意思是，就这么简单。你 可以想象？这个？这么简单吗？是的，这个
就是这么简单。所以我在策划。这是一 个线图。例如，如果我们想要一个散点图，
我们可以说好的，PLT dot scatter，有 一个散点函数可以让我们绘制
所有这些端点形成而不是这 种线形式。这些都是这些
很多点。这就是为什么你没有看到 这些散点。所以让我让我让我拿
这个 n x s 查看器。让我们来看看。让我们 把 x 当作让我们只取几点，让我们说
只有30分而已。让我们看看对应的30 个点，看，他们记得索引
NumPy 数组并使用它。所以现在 使用散点图，你有这个，
哦，那是散点。也许我们想使用 ，比方说，从一开始就开始，
由于结束和大每个，比方说，尝试点 。对为什么做同样的事情，只是为了
要以更好的方式查看绘图，只需对一些 点进行采样。这就是散点图。它
就像我在积分等等。这不是一 个它不是一个连续的情节，就像
线图，它是一个散点图，我们要注释 这个散点图，我们可以改变
这些颜色到我们想要的任何颜色。例如 ，我们可以拥有一个 prop 属性，例如，
颜色等于红色，一切都会变成 红色。是的，没错，我们
我的意思是，我们可以给它贴上标签，我们可以 给它贴上标签，我们可以通过标签，有很多
的属性。但是，但主要的一 点是绘图是简单的绘图是
快速，使用 matplotlib。所以是的，这个 matplotlib 真的非常强大，我们刚刚看到
一个快照，只有一个绘图函数和 一个散点函数，有很多属性
要说，有很多事情要考虑 。我们会看到我们会看到
对这个 COVID-19 文件的一个很 好的使用。我们将实际分析
数据趋势和确认的趋势以及一些 趋势，我们将绘制它们和
真正使用 matplotlib 查看趋势。所以 在此之前，让我让我告诉你。
如果你多次调用这个图，例如 ，可能用不同的颜色，
例如，那么您将在同一个图 上有很多相同的曲线。所以
例如，让我们看看 PLT 点图 x 逗号 y， 让我们说与颜色，让我们说颜色
等于蓝色。
你可以写蓝色，整个，或者你可以 写只是很好的PLT点图，x，
让我们说 NP 点导致 x 和您感兴趣 的颜色，让我们说颜色
是，让我们说绿色。这完全 没问题。这会给你两个情节
同样的数字，有点，你可以很好地 去。嗯，是的，这样你就可以更多，
例如，您可以使用绿色、绿色进行 绘图，并且您想要实线，或者您
例如，想要虚线中的 Seon 颜色， 或者您想要一条虚线和点黑线
或者，或者您可能想要完全 红色的虚线。所以有几件事
在 matplotlib 中可用。这只是 极少数非常简单的快照。和
我已经给了你一个非常快速的 开始，实际上整个重点是使用
Matlab 就是那么快，我的意思是，你可以 拥有你的数据，你只需插入他们的数据，
您只需调用 plot 函数，就可以 进行分析。好的。下一个
视频，我们是我们将真正走过 的地方 我们将真正走过
COVID-19 数据集。我们将实际 分析趋势并添加死亡率
单独转移每个国家，然后 我们将看到深度确认和恢复
直到 3 月 16 日，直到数据可 用的那一天为止的全球趋势。
所以下一个视频实际上是观众 将看到pandas和matplotlib的运行形式。
在一起，所以希望在下一个视频中见到你 。好的，我已经向您展示了 COVID-19
文件。在这里我有一个笔记本，它 使用 matplotlib 和 pandas 来找出
使用不同的绘图深度构造和恢复 趋势。所以让我导入所有
我需要的包。我需要来自 matplotlib 的绘图函数绘图。我需要熊猫
我需要 NumPy 的地方。我在这里使用一个简单 的 mburo 来处理缺失值。所以让我们跑
这个。让我们运行这个命令。是的，一切 都是进口的。现在让我们加载数据
我之前已经给你看过了。数据现在 可用。让我们运行这个东西
前 50 条记录。是的，记得吗？是 的，这就是可用的数据，如果
你只想要另一个视图 另一个数据 视图 那是数据文件，它是 COVID-19
文件。它有观察天省国家，最后 更新，确认，迄今为止，死亡
为每个国家和每个省单独 恢复到日期。好的，
伟大的。这就是我们所拥有的。现在我们 能做的是，现在让我们去掉序列号
和上次更新就地使用，并重命名 我们在之前已经做过的列
视频也是如此。让我们将日期转换为 内置日期框架的熊猫。好的，让我们
使用锡制的通灵学习，锡制的 sk 学习，使用恒定策略，有
那里有很多策略，让我们使用一个 恒定的策略。而这个时期或数据
框架，在纯点拟合变换中，这 将有助于将所有缺失值与
不纯的恒常策略。所以就在那里。好的 ，接下来，让我们通过命令应用这个组
并使用每个国家/地区的 country 对所有记录 进行分组。对于所有日期，让我们
对所有记录死亡的所有值求和的所有记录求 和，并使用此方法进行确认，
但是现在让我们先说国家，然后说所有国家 ，然后说第二个国家，然后说所有国家
状态等。我们已经看到，在我们 之前的一个视频中再次运行它，
只是为了仔细检查。这就是数据 状态。所以国家一所有它说的
国家对所有国家。所以这个国家 有很多约会，然后是另一个国家和
很快。接下来，让我们看看有多少 个国家。总共有多少个独特的国家
在那里。所以我，我所做的是我找到了 这个专栏，我实际上选择了这个专栏
country 并调用一个独特的函数 。这给了我所有没有的国家
重复。我只是计算国家的长度 长度告诉我有多少独特的
这个数据文件中有国家吗？
有171个国家。所以现在我的目标 是针对每个国家，我想看看
随着数据从第 1 天移动到第 16 天，相对于日期的趋势
行进？死亡趋势如何？耐心 ？康复患者趋势如何？
随着数据的发展，确诊患者的趋势 是什么？因为我们有 171 个国家，
所以让我们再循环一遍每个国家，再 循环一遍，再循环一遍我们所做的
ID x 在此范围内，这就是您记住 的循环。我要做的是让我们
找出这个国家的指数， 让我们找出所有的指数
国家就是这样的指数。那你怎么 做我做一个散点图。那，
从这个开始，我只挑确诊 病例和所有确诊病例
对于这个国家的情况，我只选择那些。我 看，我使用这个散点图来做到这一点，
然后我使用另一个散点图，只是为了得到 所有恢复的案例，然后我再做一个
散点图以获取所有深度案例。然后 我的人物标题的标题就变成了
国家名称，x 标记天数，自第一个 嫌疑人起的天数，电线标签是
案例总数，图例命令实际上 将在那里显示什么
吃掉里面的东西。所以这些在这里 重写的标签，它们会出现
图，然后我们强迫他们展示，在 每次迭代中展示第四个。所以
这将一一显示所有171个国家的确诊人数 趋势，以涵盖部分死亡人数。
所以如果我们运行这个命令，我们面前 会有 171 个图。让我们看看所有
那些一一。所以是的，所以这是为了 国家。它只有一件这样的事情。这个
是因为这是为阿富汗。随着这些 对确诊病例的影响，甚至
蓝色，他们正在向上移动。这些是案件 的数量。这些是自此以来的天数
第一天。绿色是阿尔巴尼亚 的康复病例数。那就是
阿尔及利亚的趋势。这就是趋势。我的 意思是，这些是每一个都是独立的
那是给阿根廷的。那是给美国的。这 是针对美国的，直到 3 月 16 日，由
方式，今天。新的说，无论如何，美国 真的处于危险的境地，那是为了
澳大利亚直到我们必须这样做的日期 是为奥地利。是的，所以这些都是
所有国家的趋势。你看我在 matplotlib 中有多么强大。
虽然我非常快速地浏览了这段代码，但是你 可以一次又一次地看到这个视频。
然后检查这是如何发生的。是的 。这就是芬兰的情况。哦，芬兰
也有麻烦。所以法国。好的。这 就是德国。是的，所以所有国家
在数据集中可用，他们有 这些图。这是给香港的。
这是针对印度的。这是给意大利的或意大利 的。是的。就是这样了。所以那是
对于每个国家，如果我们想要 整体趋势或整体确认怎么办
以及全世界的死亡和复苏趋势 ，所以我所做的就是我大
我长大了所有的数据与日期。所以我选择 第一个日期，并添加所有记录，然后
所有国家的所有记录的第二个 日期，依此类推。然后我绘制
使用散点图的趋势再次确认了 记录。这适用于全世界
并看到趋势，世界正在移动。所以 这就是世界的趋势。随着日子
正在进行中，这些是深度盛大，这是 一个复苏趋势。这是一个确认
正在发展的趋势。虽然我走过 的还是这本笔记本，笔记本会
可供您使用。我很快地走过这本笔记本 。但真正的目的是为了展示
你我的意思是，如果你在 Excel 中看到 ，那是一个文件可能没有那么丰富，
但现在它更有意义了。当您看到这些 斑点时，您就知道发生了什么
你对数据有洞察力。稍后，我们 可能想要预测我们可能想要的
做出预测。下一个日期会发生 什么，我们可能想要预测
使用此图或使用一些机器学习库 ，如通灵学习或 TensorFlow 或
类似的东西。好的，就是这样。 我可以更多地谈论熊猫 NumPy matplotlib
有很多其他数据科学包，非常 重要的包，其中之一是 SK
学习，我们可以那是机器学习的 基础机器学习。然后还有其他
用于深度学习的 TensorFlow 等软件包， 由用于深度学习的 Torch 提供。有很多
有很多专业的包是在数据科学 和东西。我刚刚讨论了一个
很少有最重要的人会操纵 数据以进行预测
进行分类或回归。一方面， 一种方法是去SK学习或通灵
学习。如果数据量很大，而且你 有很多大量的数据，而且你有
良好的专业知识或深度学习，那么 你应该去 TensorFlow 或 pytorch
这些是可用于预测、分类 、回归的 Python 包
还有更多，但不管怎样，你是否 打算使用 scikit 学习你是否
无论哪种方式都要使用 TensorFlow 或 pytorch，你必须使用 Pandas NumPy，有时
matplotlib 预处理数据并使数据 为这些类型做好准备
用于执行预测的库，可以 是分类形式，也可以是
以回归的形式。所以所以这整个 课程是为想要的初学者准备的
对于想学习Python的人，具体来说 ，我讨论了很多关于在很多关于
Python一般，然后我有时会花 一些时间而不是很多时间
关于探索数据科学包。但是， 我的意思是，我们没有尽头
探索更多，我们可以谈论包更多 我们可以谈论Python的其他功能
更多，很多我的意思是，输入格式 ，输出格式，模块，包，标准模板
图书馆，文件处理 Internet Access 数据库，
我的意思是，
这是一个完整的宇宙，我已经为初 学者讨论了一些事情。但是这些
很少有东西是为数据科学家精心 挑选的。如果你有这门课
在您完成所有课程后，您 现在有一个非常非常好的
理解，现在您可以进一步 编辑高级课程
数据科学，您将准备好使用这些 包在 Python 中实现这些概念
到目前为止我已经讨论过了。所以我感谢大家 ，祝你好运。