嘿，我叫Mush，我将作为您的Python课程老师。
在本课程中，您将学习开始使用Python进行编程所需的一切。
Python是最流行的编程语言之一，人们每天都在使用它来做
自动化之类的很酷的东西，他们也使用AI
建立应用程序和网站，如Instagram和Dropbox。因此，如果您正在寻找
要找到一份工作，Python非常适合您。在这门课程中，我将教你一切
您需要从Python开始。我们将讨论所有基本概念
在Python中，我们将一起构建三个Python项目。
这是我们将要建设的第一个项目。我们将学习如何创建这个美丽的网站
对于假杂货店。在主页上，我们可以看到所有内容
对于商店中的产品，我们还有一个管理区域来管理
库存我们将使用一个流行的Python框架Django构建它。
现在，如果您以前没有创建过网站，请不用担心，我将从头开始教您一切。
您还将学习如何在机器学习或人工智能中使用Python。
因此，您将学习如何编写可以预测的Python编程
人们根据个人资料喜欢的音乐。就像YouTube一样
根据您之前看过的视频推荐视频。我也会告诉你
Snake可以自动执行无聊的重复性任务，从而浪费您的时间。
您将编写一个Python程序，该程序将处理数千个电子表格
在不到一秒钟的时间内。本Python课程专为想要学习的人而设计
Python。如果您是初学者，请不要担心，我将在整个课程中全程为您服务。
您年龄不大或太小，Python很容易学习。你可以先写
每秒字面上的Python程序。再加上我会给你很多
练习可帮助您建立对编写出色的Python程序的信心。
我叫Mush，我是一位拥有两年经验的软件工程师
我已经教了超过300万人如何调音。我真的很高兴教您
本课程中的Python。所以我希望你坚持学习这个美丽
强大的编程语言。
在本教程中，我将向您展示如何下载
并在您的计算机上安装Python。所以我要你做的第一件事
它会打开您的浏览器并转到Python
咖啡厅在此页面上，单击下载。
在录制此视频时，您可以在此处看到当前最新版本的Python
最新版本是Python 3,7.2。
将来有可能，当观看本教程时，会有更新的
可以使用Python的副本，不用担心，您将在本课程中学习的所有材料
它也将适用于最新版本的Python。所以我们继续吧
立即下载Python 3，
查看您的下载文件夹，在这里，我们必须具有Python 3安装程序
如果您使用的是Windows，只需双击即可
您将在此处看到一个复选框，将Python添加到
Snake，这真的很重要，请务必选中此框，否则您将无法
遵循本教程。如果您使用的是Mac，
您会看到这样的安装程序，使用此安装向导，我们将安装Python 3
在我们的计算机上。因此，只需单击“继续”，然后再次
再次同意许可协议，并
安装它，这将需要几秒钟，所以我要
停止录音。
好了，我们已经在计算机上成功安装了Python 3。
让我们关闭这个。好，那我们需要安装
代码编辑器，我们将放置一个代码编辑器来编写我们的代码，就像
我们如何使用Microsoft Word编写文档？我们使用代码编辑器进行编写
代码。现在有很多脚本编辑器，我将在此向您展示
本教程是PyCharm。这是最受欢迎的编辑器之一
编写Python代码。您可以从jetbrains.com获得它
/ pycharm。现在更准确的pycharm
IDE是集成开发的首字母缩写
环境。这基本上是类固醇的代码编辑器，
它具有一些其他功能，可以轻松编写代码。因此
让我们继续下载PyCharm。现在在这里
在下载页面上，您可以看到两个版本的PyCharm，一个是专业的附件
那还有其他功能，您必须为此付费。另一个是
论坛版本，它是完全免费的，这就是我们将在本教程中使用的版本。
因此，也下载并下载它。
现在，再次查看您的下载文件夹，再次必须具有pycharm
双击它，如果您现在
在Windows中，您将看到安装向导，只需单击“下一步”，“下一步”，“下一步”
直到您安装pycharm。如果您使用的是Mac，请拖放此图标
在“应用程序”文件夹中，将其拖放，
好吧，我们双击它打开它，
第一次运行pycharm时，我们会收到此警告，因为这是一个应用程序
我们从互联网上下载。因此，让我们继续打开它，
之后，您将看到此对话框以导入一些设置，将其保留在此对话框上
不导入设置，真的没关系。好吧
在此页面上，选择“从不使用PyCharm”。您可以看到一些关键字
将来可能会有用的捷径，只要接受即可，下面，
单击下一步按钮。再说一次
再次，然后终于开始使用pycharm。
所以这是您每次打开PyCharm的主页
单击创建新项目。
这是我们项目的地方，我们称它为Hello
全球。现在，在单击并创建之前，展开
此处，请确保为Python设置了主要翻译器
3. Python编译器基本上是一个程序
他知道如何实现Python代码，然后就知道如何解释
或将Python指令翻译成计算机可以理解的指令。
现在，默认情况下，Mac电脑随附老年人
安装Python，即Python 2，被认为是传统
这意味着不再维护或支持它。在此之前，我们下载了它
Python 3，请务必将其设置为Python 3
从此列表中，选择Python 3,7。
好吧，现在让我们继续创建这个项目，
现在在这里右键单击
您好全局文件夹，然后转到新
Python文件，称为app.py。
因此，根据协议，所有这些Python文件必须
红色扩展名。好吧，让我们继续吧，
现在，让我们通过单击此处并编写来折叠此项目板
第一个Python程序。只需键入打印，PR
int，全部用小括号括起来，
在这些括号内，加上引号
现在可以使用单引号或双引号
在符号之间，键入您的名字。我也是Mush Hamdani
在这里，这是您的第一个Python程序。有了这段代码
您可以在屏幕上打印您的姓名。现在打开它，去
在播放列表下方的顶部，单击播放，
还请注意，当
我是一个始终使用首字母缩写词的程序，因为这可以提高我的工作效率。
即使在Mac计算机上，快捷方式也为Control，Option和
在Windows上是不同的。所以现在就开始做
询问您要在何处运行此程序，单击该应用程序，
在下面，您应该看到这个小的终端窗口，这个
我们程序中的一个小窗口，因此您可以在这里看到我们的结果
输出到我们的程序。将来，当您从Python中学习更多信息时，您将
能够构建具有图形用户界面或粘性的应用程序。
这有点复杂，所以我们现在要使用这一点
一个终端窗口，可查看我们程序的结果。这样就可以看到我的名字
打印在这里，现在在打印图标时，可能会出现此窗口
始终更改其大小或将其最小化
图标在这里，所以这是第一个蛇程序。现在
如果您没有在此视频中看到我给您显示的结果，请使用下面的评论框，然后
告诉我出了什么问题，我会尽力帮助您前进。
在此Python教程中，我们将把该程序带入一个新的水平，并使之更加令人兴奋。
因此，我将向您展示如何绘制狗毛。现在作为
本教程将学习如何实现Python指令，并且您还将学习
关于一些编程术语。因此，按Enter和
在第二行上，编写另一个要打印的语句，以便打印，打开和关闭
括号，加上引号，现在您要画一条狗。
因此，加上x，这是我们狗的头，然后
4个连接器。这就是身体。
好吧，现在再次使用print语句
报价，现在我们需要画腿。因此，添加一个空间。
跟随4条竖线。像这样
所以这是一个小假点。让我们现在得到它
运行该程序，看看我们得到了什么。因此，在右上角，您将看到此播放按钮，
单击该按钮，您就可以到达了，所以我们有我们的名字和
在下面，我们有我们富有想象力的狗。现在您需要了解的内容
在这里，我们的蛇刃被逐行执行
从顶部开始。之前，我告诉过您有关Python解释器的信息
这是一个知道如何翻译或解释的程序
我们的Python代码是您的计算机可以理解的说明。
因此，当我们通过单击此处的程序运行该程序时，
蛇翻译器开始执行或运行我们的程序
从顶部一行一行。最初它运行1号线
然后转到第2行，依此类推。所以这就是蛇
程序已实施。现在，让我向您展示一些很棒的东西。让我们添加
另一个声明，现在带引号
在引号中添加一个星号或星号，例如
这个现在在引号之后和弧线之前，
再次添加一个空格，添加一个星号，
太空，10。这是怎么回事？好吧
我们在这里或这里引用的任何地方
我们定义一个字符串，因为字符串是一个编程术语，表示
一串字符，所以这里有一个字符串，我们也有
第3行加上第2行和第1行的字符串。
现在在这里，我们将字符串乘以
第10条。这就是乘法因子，就像乘法一样
我们的因素是数学。因此，使用此代码，我们可以
在设备上画10个星号，让我告诉你。所以让我们运行
还有一个时间程序，您可以开始。所以我们有10
星号。现在我们在这里，这里的代码，
被称为表达式。表达式是的一部分
该代码产生一个值。所以当Python编译器
尝试执行第4行，首先它将评估
我们放在方括号中的代码，以便我们可以评估表达式
然后我们的表达式将产生10个星号
这些星号将被打印在工作站上。现在作为练习
您可以使用这些打印短语来绘制其他形状，也可以绘制心形，
球，你会的。我将在下一个教程中见。
我在频道上遇到的很多问题之一是
学习Python并准备工作需要多长时间？好吧，没有人
一个答案。这取决于您以及您要付出的努力和承诺的数量
在此。但是我想说如果您每天花费两个小时
大约三个月后，您应该可以连续写
基本的Python程序，但是坦率地说，这并不能使您找到工作。
为了找到工作，您需要专注于一个领域，
您想使用python什么？您要构建Web应用程序还是
桌面应用程序？还是要在机器学习和人工智能中使用它？
因此，无论您想做什么，都需要参加其他课程。
例如，如果您除了学习还想成为一名Web开发人员，
Python，您还应该了解HTML，一些CSS，一些
JavaScript和Django是流行的Python框架
生成Web应用程序。学习所有这些东西会带你另一个
6个月，因此总共需要9-12个月
准备工作。此时，您可以与年轻的开发人员一起工作
年薪约50-60 000美元。现在，当您工作更多时
随着您执行更多的Python项目，您的简历和构建开始
您可以每年订购100,000美元，或120,000美元
年份，取决于您所在的位置，公司，地理区域，
真的要看，没有一个答案。所以你很高兴
学习Python并开始这一职业道路？如果你是，我会鼓励你
做出承诺，每天花两个小时锻炼身体
蛇。使用下面的评论框，让我知道您为什么学习
Python，您想使用它做什么？您梦dream以求的工作是什么？我很想听听你的故事。
在此Python教程中，您将学习变量，变量是基本要素之一
编程中的概念，它们不特定于Python，它们存在
几乎所有的编程语言都在那里。我们使用变量
暂时将数据存储在计算机的内存中。这是一个例子。
让我们在Python上编写价格= 10
翻译器执行此代码，它将分配一些内存，并将其存储
该内存中的10号，最后将被暂停
在此存储位置中命名价格。作为metahor
想象一下我们的盒子。在这个方块中，我们有10
价格是我们贴在盒子上的标签。现在我们可以使用这种分类
在程序中的任何位置均可访问此框中具有的值。
这是一个非常简化的解释。现在，让我们
在终端上打印价格。打印，现在这一次我们不会去
添加引号，因为如果将引号放在此处，我们将看到文本
价格在车站上。现在，价格变量的值。
因此，将其放在报价中并写下价格，
现在，让我们再次在该位置运行该程序。所以我们看到10
在车站上。这就是我们定义变量的方式，我们
从ID（即我们的变量的名称）开始，然后，
等号，最后是值。现在更确切地说，何时
这个数字10将要存储在内存中，首先它将
转换为该双重视图。这个数字10
在包含所有数字0到9的十进制系统中。
计算机不理解所有这些数字，它们只是
0和1。因此，当我们将数字10存储在计算机的内存中时
第一次将其转换为二进制表示形式，
一堆0和1，例如001、001，无论
我不知道，我也不知道然后它将被存储在计算机的内存中。因此，
将此程序提升到一个新的水平。在第二行，我们可以
更新此价格变量的值，以便我们可以对其进行重置
现在，当我们运行程序时，新的值变为20
我们应该看到20，因为正如我在Python解释器用完之前告诉您的那样
从顶部开始逐行代码。所以首先我们把它
价格为10，然后重置为20，最后我们是
在工作站上打印它，让我们运行该工作站，然后就可以了，所以，
在这里看到20，好吗？现在这个
我们这里的数字是没有小数点的整数。
在编程中，我们将这些数字称为整数。
但是整数是不带小数点的数字。我们也可以使用
例如第2行带小数点的数字，我们可以定义
另一个名为分类的变量分配给一个数字
4,9。现在在编程中，我们指的是这种类型的数字
浮点数从短浮点数开始。所以我们有整数
并漂浮。我们还可以定义一个变量并设置
以一个字符串为例，其名称等于
糊糊，我们还有另一种类型的值，称为逻辑值，
那可能是对还是错。它们是肯定的，没有英文字体。
这是一个示例，我将定义一个变量，下面划线
所以我们用下划线来分开
以我们的变量名称命名的多个单词。我们把这个
是非题。他们在这里
布尔值。现在注意，Python是一种情况
敏感语言，这意味着它对小写和大写字母敏感。
因此，在定义变量时，我们应始终使用它们
小写字母，但此处的false和诚实是的特殊关键字
语言，因此如果我们将其拼写为小写，Python不会这么做
知道了您可以看到我们的红色下划线表示错误。
请确保使用大写字母F拼写此代码，或者如果您要将其设置为true，
确保T是大写字母，因此在此
该程序将简单值存储在计算机内存中。很简单
值可以是数字，可以是整数或浮点数
也可能是连锁或逻辑的。但是在Python中
我们还可以存储列表和值之类的复杂值。这就是我要告诉你的
将来。所以在我进一步之前，我想要你
做一点运动。想象我们将编写一个医院程序。
因此，我们正在检查一名名为John Smith的患者。是
20年了，他是个新病人。我想在这里定义3个变量，
关于他的名字，年龄等变量
因为这是新患者还是现有患者。因此视频停止并消除了一个
在此练习中准确。完成后，请返回并继续并继续执行我的解决方案。
好吧，我们需要
三个变量，第一个是患者的姓名，
我们把它交给了约翰·史密斯。我们也可以
我们称其为全名，因为这两个名称对我们的变量有效。
第二个变量是针对我们患者的年龄。所以年龄
是20，最后我们需要一个变量来知道这是否是新的
还是现有的病人。在这里，我们可以使用布尔值。
因此，我们定义了变量，它是新的，
我们说对了。
所以，我学会了如何打印
终端窗口上的消息。在本教程中，我将向您展示
接收来自用户的输入。所以我们写一个小程序问
用户名，然后键入自定义问候语
对于此用户。因此，我们将使用打印而不是打印
回车现在所有这些都已输入并打印
它们是Python中的内置函数。她也认为隐喻
从遥控器到电视。在这个遥控器上，我们有一堆
这些是电视附带的功能，您可以操作它们，
将其关闭，更改音量等等。在我们的Python中
常见任务的功能，例如打印消息，接收输入，
等等。所以我们现在要使用输入功能
我们有这些括号，可以说我们称之为或实施
此功能，例如按遥控器上的按钮。原来是
转到方括号之间调用输入函数
我们想要添加一个字符串以在设备上打印内容，
你叫什么名字跟着问号
空间。一秒钟您会明白为什么。所以这是一个输入功能
您将打印此消息到设备，然后等待用户
输入一个值。无论用户输入此功能是什么，输入都会
退货。因此，现在我们可以获取此值，并使用变量将其存储在内存中。
所以我们得到结果并将其放在一个名为
名字好吗现在在第二行
我们想打印一条消息，例如Hi John或Hi Mosh或其他任何内容，
打印，带空格的报价，
现在在报价之后，我们要动态打印
我们在name变量中拥有什么。所以我们有
加号，然后命名。所以我们有
嗨，这是一条链子，我们是一个系列
将链与另一个链结合起来，这就是我们所拥有的
在名称变量中。所以这是另一个例子
表达。记住表达是什么吗？这是一段代码
使用一个值。因此，此短语已序列化或分组
2条链。让我们运行该程序，看看会发生什么。甚至跑步
好吧，这是问题，你叫什么名字？不可以
现在请注意，之前我们在问号后面添加了一个空格，
这样做，因此在终端窗口中，光标
与问号分开，否则将非常接近。所以我们写
无论这里有什么，再加上一个条目，现在我们都收到此消息，你好，（Mush）
现在，这里有个小练习。我要你扩展这个程序
并问两个问题。首先每个人的名字，然后
他们最喜欢的颜色。然后打印像摩西爱的信
蓝色因此，暂停视频，然后进行此练习，然后再返回并继续观看。
好吧，这是之后的第一个问题，
再次使用所有输入功能，这一次我们将提出不同的问题。
你最喜欢什么颜色？
现在，我们获得新值并将其存储在变量中
它称为颜色，或者您可以在颜色下将其命名为“收藏夹”。
颜色。无论哪种。最后，我们将改变
我们传递给打印功能的内容，因此我们首先打印出名称
然后我们用一个字符串序列化它，在这里我们将
输入喜欢的字样，我们还要在前面加上一个空格
在喜欢之后，我们再次攀登。
具有喜欢的颜色。所以，我最喜欢的颜色
现在让我们运行这个程序，你叫什么名字
输入机器，喜欢的颜色，蓝色，输入，
我们收到此消息，Moshe喜欢蓝色。
嘿，马什，在这里，我只是想让你知道
您在本课程中确实不需要记住任何内容，因为我将备忘单放在一起
带有摘要注释。因此，您可以快速查看本课程中的材料。
链接在此视频下方。所以我尽力创造
YouTube上最好的Python课程。我真的很感激
如果您喜欢这部影片并与他人分享，以支持我的辛勤工作
其他人，因此他们也可以学习。并且一定要订阅我的频道以获取更多
这样的教育计划。好了，现在，让我们继续下一个教程。
在此Python教程中，我们将编写一个程序来询问我们出生的年份
进入时，我们的时间将被计算并打印在工作站上。
因此，让我们从输入功能开始
让我们在此处打印出生，再加上两点，
和空间。现在，让我们获取返回值并将其存储在变量中，
称为birth_year。
如我之前所说，我们使用下划线分隔多个单词
之后，我们需要计算年龄，因此我们定义了另一个
一个名为age的变量，在这里我们做一些基本的数学运算，
目前我们在2019年，所以让我们写一个表达式
像这样2019年-出生
年。现在让我们最后打印
车站上的年龄。让我们运行我们的程序，看看会发生什么。
所以，我在1982年生日那天，
糟糕，发生错误，这是怎么回事？因此
当您看到此消息时，表明程序有问题。有信息
在这里，我们可以准确找到错误发生的位置。因此，
在文件旁边，您可以看到生成此错误的文件，在这种情况下
这是app.py。因此
目前我们只有一个程序，但是真正复杂的程序通常
您有数百甚至数千个文件。所以在这个档案中
在第2行，这是我们收到此错误的地方，对
在下面我们可以看到一段生成此错误的代码。
这是我们计算年龄的地方
您可以看到错误的类型。在这种情况下，我们遇到类型错误，这里
讯息。不支持的交易类型
减法。整数和强度
所以int是integer的缩写，代表一个整数
str是字符串的缩写，因此我们减去
一个整数字符串，Python不知道如何处理它。
让我解释一下。所以我要关闭终端窗口。然后
我们实施的第一行在今年设置了变量
变成一个字符串，所以我们在终端上写的所有内容总是
即使您键入数字，换句话说，也应将其视为字符串，
运行该程序时，将设置该出生年份变量
变成一个字符串，带有四个字母。
1982年。此系列与实际数字不同
1982。一个是整数，另一个是字符串。
对不对所以，回到第二行
发生错误。在运行时，这意味着我们在运行程序时
此表达式在作业启动器的右侧
它看起来像这样。 2019-
字符串1982。Python不知道如何
解释或如何评估此表达式。解决这个问题
我们需要将此1982转换为整数
然后我们就可以从2019年开始
很简单到目前为止，您已经了解了两个合并的工作
一种是打印，另一种是输入。我们还有其他工作
将值转换为不同的类型。所以我们有
Finder将字符串转换为整数，我们还有
浮点数可将字符串转换为浮点数或数字
带小数点。我们也有布尔值来转换字符串
具有逻辑价值。因此，要解决此问题，
我们需要回到第2行
将此可变的圣诞节年份传递给这样的帖子。
放在括号中，像这样
在我们将此字符串传递给int函数之前，int会将其转换为itneger
然后，Python解释器将能够评估此表达式。
现在让我们再次运行该程序
那是我进入的1982年
37岁。在Python中，我们有一篇有用的文章
例如，对于变量类型，让我们输入类型
从出生年份开始，因此在第1行之后
让我们打印，现在在这里我们将调用另一个内置函数，
该类型被称为，现在让我们继续生育
一般，很好，现在下线之后
3，我们还要打印年龄类型
旧类型的打印。
好吗因此，让我们运行我们的程序，再出生一年
时间，1982年，好吧，这是结果
所以你看到的出生年份是一个学期
从str或字符串，我们将在将来研究类
暂时不用担心它们，在它们下面也可以打扰他们
年龄变量为int或true。因此
这是您需要带走的东西。每当您使用输入功能时，
您总是会得到一个字符串，所以如果您期望一个数字值
您应该始终将该字符串转换为整数或
飘因此，这里有一些练习适合您。我要你写一个程序
向用户询问他或她的体重，将其转换为千克，然后打印出来
在车站上。因此，暂停视频，然后进行练习，当您准备好后，请返回
要查看它。
好吧，让我们使用输入功能并询问
重量（磅）
在这里，我们得到的磅数或磅数
现在我们需要将其转换为千克，这很容易
我们定义了另一个变量的权重
我们把这个放在weight_lbs上
0,45倍。
最后，让我们确定重量
公斤让我们运行这个Python程序，看看会发生什么。因此
我的体重是160，再次出现错误，
无法将非int int序列加倍
飘因此，正如我之前告诉您的那样，此输入功能又回来了
系列，因此我们不能将系列乘以浮点数。
Python不知道该怎么办。因此，在这种情况下，我们必须转换此数字
取整数或浮点数然后乘以0,45。
因此，我们将其称为int函数。
传递下划线的重量。
然后再次运行我们的程序，160
好吧，我72公斤。
在本教程中，您将了解有关Python链的更多信息。
因此，我定义了此课程变量并将其放在Python上供初学者使用
之前，我告诉过您可以同时使用单引号和双引号
要定义一个字符串，但是有时您必须使用特定的模板，
否则，您将面临问题。这是一个例子。想象一下你想
将此字符串更改为初学者的Python课程。
所以我们想要添加一个单引号
初学者课程。你可以马上说
疯狂，因为连锁店从这里开始，然后在这里结束，
在第二个撇号之后，我们在这里拥有的所有这些字符
Python翻译器不知道它是什么。所以要解决这个问题
我们需要使用双引号定义我们的字符串，以便我们可以获取它
系列中间的一个引号。所以我们改变一下
要加双引号，现在您可以看到它添加了另一个双引号以将其关闭，
您必须再次手动删除
在本系列的开始，我们需要添加另一个双引号。现在
您会看到一个金色错误，因此，如果您打印，当然
请参阅Python初学者课程。
好漂亮现在，我们不想在这里使用此分隔符，所以我们有
适用于初学者的Python，但我们想让初学者加入
双引号。同样，如果您在此处添加双引号，则Python编译器会
困惑，因为第二个双引号应该表明这一点
本系列的结尾，所以不知道这些字符是什么，为了解决这个问题
我们需要将双引号更改为单引号
像这样然后我们可以在中间添加双引号
该系列。现在，让我们运行此程序，就可以了。
直到我们为初学者准备了Python。就是这种情况
使用单引号或双引号。现在在所有示例中
到目前为止，我已经向您展示了我们仅处理短字符串，但是如果您想定义
多长度系列？例如，如果您想指定一个字符串怎么办
对于邮件，我们发送电子邮件。在这种情况下，我们需要使用它
三重引号。因此。我们正在删除它。
现在我们添加三个引号，所以1、2、3就行了，
因此，我们有三个引号来开始我们的系列，另外三个
结束它。同样，这些引用可以是单引号也可以是双引号。
好吗现在，我们可以定义一个拉伸字符串
多行。例如，我们可以说你好约翰
这是您的第一封电子邮件。谢谢啦
支持团队。像这样
现在，让我们运行此程序
结果。所以，我们得到了一条美丽的折线
线程。现在让我们将其更改为简单的内容
因此，我们可以看看字符串和Python的其他属性。
因此，我将使用单引号并将会话名称设置为Python
对于初学者。现在我们将使用一个正方形
本系列中特定个性和指标的括号。
让我告诉你。在得到第一个字符之前，我们使用方括号
并输入0。因此索引是第一个字母
在字符串中它是0。换句话说，这就是Python的样子
字符串被索引。 0、1、2、3、4等。
所以第一个字母的索引是0，第二个字母的索引是
1，依此类推。所以让我删除它并运行该程序
我们得到p。我们也可以使用负数
在这里索引。这是我们在其他编程语言中所没有的功能之一
据我所知。所以我们有一个负指标，我们可以得到字符
从头开始。因此，如果您将负1移到此处，
假设0是第一个字母索引
负1是最后一个字符索引。所以当我们跑步
该程序必须参见s。让我们运行它，到那里，
我们得到s，如果传递负数2，则将返回
从结尾的第二个字母。让我们再次运行它，
现在我们得到一个R，因为那是结尾的第二个字母。
好吗因此，请密切注意这些方括号的语法
因为它经常是在线Python测试的主题
或大学考试，因此，如果您正在准备蛇测试，
确保再次观看本教程，并了解其具体内容
这些方括号的语法，我们也可以使用类似的
提取一些字符而不是1个字母的语法。
例如，如果我们写0，
第3点，Python翻译器将返回所有字符
从这个指标一直到这个
第二个指针，但它不返回该指针中的字母。
换句话说，返回这些索引
因此，您有0、1、2、3，依此类推。运行该程序时。
Python转换器将从以下字符开始返回字符
从索引0一直到索引3，
但是它不包括字母和光标3，
因此，当我们运行此Python程序时，我们将看到一品脱（？）。我告诉你，我们去吧
删除此行，运行该程序，就可以了。
我们得到一品脱。现在我们也有默认值
开始和结束指示器。所以如果我们不供应
端点指示符，Python将所有字符返回到字符串的末尾。
让我们来看看。因此，运行此程序，就可以了，
适用于初学者的Python。但是，如果您将开始指示器更改为1，
即使我们是
运行该程序，我们看到ython，因此p被删除。
好吗现在类似地，我们为
起始索引，所以如果我们不提供起始索引
但要添加结束索引，例如5。Python解释器将假定
0作为开始索引，让我们开始
这个程序，你去了，我们得到了pytho。
现在，如果我们离开起点和终点
索引？好吧，我告诉过你？现在，在这种情况下，将假定为0
作为起始索引，字符串的长度将采用
作为结束索引。因此，使用这种语法，您基本上可以复制
或克隆一个字符串。换句话说，如果我定义
这里有另一个变量，让我们称之为另一个并将其设置为课程
方括号只有一个冒号，现在此表达式将
返回课程变量中的所有字符，因此
变量将是我们第一个变量的副本。让我们来看看，
让我们打印另一个，然后加载我们的
程序，您可以使用Python，适合初学者。所以再说一次
如果您要在线准备，方括号语法非常重要
python测试或大学考试，请确保再次观看本教程。
现在，这里有个小练习。我将删除所有这些代码
定义一个名为name的变量，并将其设置为Jennifer。
现在当我们打印名称时
之1：负数1
您认为我们将在终端上看到什么？我要你用你的知识
为了告诉我们要在终端上看到的内容，我们现在正在运行此程序。因此
暂停视频，考虑几秒钟，然后再返回并继续观看。
因此，此表达式将返回从
索引1，它是第二个字符
从头到尾一直到第一个字符，但不包括
该索引处的字符。在这种情况下，
in是r，因此r将被排除，换句话说，我们将看到
所有从e开始的字符
到第二个e。让我们来看看。所以我要运行这个程序
你去。这就是我们得到的，
我希望你猜对了。
在本教程中，我们将研究
用Python编程语言格式化的字符串。格式化的字符串是
在您动态生成一些内容的情况下特别有用
文本与您的变量。让我告诉你。假设我们有两个变量
名和姓。所以首先我们将其设置为
约翰，最后我们将其设置为史密斯。现在更好了
称这些变量的名字和姓氏，因为它们更多
描述性的。但是这里我使用的是较短的名称，因为我希望您看到显示的整个代码
屏幕。因此，假设我们要使用这两个变量来生成
一些这样的文字。乔恩，放在方括号中
史密斯是一位编码员。假设我们要在上面打印
终端。我们该怎么做？好吧，我们定义另一个变量
像消息一样，现在我们在这里添加名字，
现在我们需要用一个包含空格的字符串将其连接起来
接下来是方括号，我们需要添加一个姓氏，
那么我们需要添加一个包含
右方括号后面是编码器
好吗那么，
如果您打印消息并运行此程序
看约翰·史密斯是编码员，对吗？现在，
尽管此方法可以完美工作，但并不理想
因为随着我们的文字变得越来越复杂，它变得越来越难
可视化输出。所以其他人在阅读这段代码时，他们必须
可视化其头部中的所有字符串连接。这是我们使用的地方
格式化的字符串，它们使我们更容易可视化输出。因此，
我要定义另一个变量，假设
msg消息的简称，并将其设置为格式化的字符串。格式化的
字符串是一个以f开头的字符串。所以，
行情。现在在引号之间，首先我们要添加
名字变量的值，所以，
我们添加花括号，然后在这里首先键入。
接下来，我们在正方形之间添加一个空格，并添加方括号
方括号，我们要显示姓氏，所以我们再次添加大写
花括号，最后键入，最后在这里键入
是一个编码器。这就是我们所说的格式化
线程。通过这些花括号，我们可以定义占位符
或字符串中的孔，当我们运行程序时，这些孔
将充满我们的变量的值。所以这里有两个占位符
或我们弦上的两个孔。一个是为了我们名字的价值
变量，另一个用于姓氏变量的值。
但是将此格式化的字符串与字符串进行比较
串联。使用此格式化的字符串，我们可以轻松地可视化
输出是什么样的，对不对？现在让我们打印其他
终端以确保我们获得相同的准确输出。所以，让我们打印消息
你去。所以乔恩
史密斯是一位编码员。因此，要定义格式化的字符串，
给字符串加上F前缀，然后使用花括号
在字符串中动态插入值。
在此Python教程中，我将向您展示可以使用Python进行的一些非常酷的操作
字符串。因此，让我们开始定义一个变量，
当然，我们将其设置为Python
初学者。现在计算数字
对于此字符串中的字符，您可以使用称为len的内置函数。
所以len我们给这个课程变量，然后
我们可以打印结果。让我们运行这个程序，
如您所见，该字符串中有20个字符，这是
当您从用户那里收到输入时特别有用。例如你有
注意到当您在线填写表格时，每个输入字段
通常有一个限制。例如，您的名字可能有50个字符，
因此，使用此len函数，我们可以限制字符数
在输入字段中。如果用户输入的字符超出了我们的允许范围，
我们现在可以显示一个错误，
len函数是Python内置的另一个函数，它是
通用函数，因此它不限于计算字符中的字符数
字符串，将来我们查看列表时，我想向您展示我们可以使用此字符串
函数计算列表中的项目数。所以这是通用的
功能。现在我们还有专门针对字符串的函数
例如，我们具有将所有这些字符转换为大写字母的功能
或小写。要访问这些功能，我们使用点运算符。
让我告诉你。所以首先我们输入课程
然后点一下，这些都是功能
特定于字符串。现在更准确地说，
您将这些功能称为方法，这是一个术语
在将来我们要研究的面向对象编程中，但就目前而言，我希望您能从中受益，
是当一个函数属于别的东西或者是特定的
对于某种对象，我们将该函数称为方法。
例如，这里我们有上面的函数，用于转换字符串
变成大写字母，现在更准确了，因为此功能
是特定于字符串的，我们将此称为方法。相反
len和print是通用函数，它们不属于
字符串，数字或其他类型的对象。
这就是函数和方法之间的区别。现在让我们来看一下
上层方法。所以，让我们打印结果
然后我们运行我们的程序，就可以了，
您将所有这些字符显示为大写。现在注意这种方法
实际上不会更改或修改我们的原始字符串
它创建一个新字符串并返回它。因此，
如果我们在之后打印我们的课程变量
调用上方方法，我们可以看到我们的课程变量仍然
它具有原始形式，因此让我们再运行一​​次该程序，在那里
快走看，这是我们原来的课程变量，它没有被修改。
现在类似于上层方法，我们有另一种方法
用于将字符串转换为小写。所以让我告诉你。
印刷，当然。
现在，让我们运行程序，在第二行，
所有字符均小写。现在有些时候
您想要在字符串中查找一个字符或一系列字符。
在这种情况下，您可以使用find方法。所以让我删除
这几行。通话过程。
在这里找到一个字符，让我们说
p，这将返回第一个匹配项的索引
那个角色，让我告诉你。所以我们打印结果
我们得到0，因为
字符串中第一个大写字母p的索引为0。
再举一个例子，如果我们在此处传递小写字母o，
让我们看看我们得到什么，我们得到4，因为
这个o的索引是4。现在请注意
find方法区分大小写，因此对
小写和大写字符。例如，如果您通过大写
在这里运行该程序，我们得到负1，因为
我们在此字符串的任何地方都没有大写字母o，好吗？
我们还可以传递一系列字符，例如，我们可以传递
初学者用大写字母B
让我们运行该程序，我们得到11，因为
初学者从索引11开始，现在我们
也有替换字符或字符序列的方法
这就是所谓的替换。所以我们换找
代替，假设我们要用
绝对的初学者，所以我们添加逗号以传递第二个值
此功能，或更准确地说是此方法。我们添加一个字符串，
在这里，我将通过绝对的初学者。
好的，现在让我们运行该程序，
因此，我们为绝对初学者准备了python。
同样，此方法（如find方法）区分大小写，因此
如果您以小写形式通过初学者，则此方法为
不会在我们的字符串中找到这个确切的词，所以它不会
与绝对的初学者放在一起。让我们来看看。所以我要运行程序
再看一次，我们仍然为初学者提供python。
我们也可以替换一个字符，例如我们可以替换
大写p与假设大写
j。现在，当我们运行此程序时，我们得到
jython，适合初学者。这些是查找和替换方法
最后，我想在本教程中向您展示。有
您想检查字符中是否存在字符或字符序列的时间
线程。在这种情况下，您可以使用in运算符，
因此，假设您想知道此字符串是否包含单词python。
我们可以这样写一个表达式。弦乐
太空课程中的python space。
所以我们正在检查python是否在
课程变量。这是一个产生布尔值的表达式
值，我会得到对或错，因此我们引用此表达式
作为布尔表达式，现在，如果我们在终端上打印它，
我们应该做到正确，顺便说一句
我将删除第二行，我们不再需要它，因此运行程序
我们是正确的，但是如果我将国会大厦p更改为小写
p并运行该程序，因为我们没有
是我们字符串中字符的确切顺序。
现在注意in运算符和find方法之间的区别
是我们的find方法返回的索引
字符或字符序列，但使用in运算符
产生一个布尔值。我们有没有？
这就是区别。现在，让我们回顾一下您学到的所有有趣的东西
与本教程中的字符串有关。我们可以使用len函数
计算字符串中的字符数，这是常规的
python中内置的用途函数，我们还具有特定的功能
对于我们称为方法的字符串，包括
上部，用于将字符串转换为大写
您也有较低的和标题方法，
您将了解返回索引的find方法
一个字符或字符序列，我们有
最后替换字符串中的字符和单词的替换方法
您了解了in运算符。所以有些字符
在一个字符串中。
因此，您已经了解到，在Python编程语言中，您有2
数字类型，整数是整数，例如10，它们没有
小数点和浮点数或浮点数。
是带小数点的数字。现在，在本教程中，您将了解
在python语言支持的算术运算中，这些是
和数学上一样的算术运算我们可以加数字
乘以此类推。因此，让我们看几个例子，
我们可以打印10加3，所以
这是加法运算符，我们也有减法，我们
有乘法，我们有两种除法，
这是一个带有正斜杠的斜杠，让我们运行此程序，看看能得到什么。
我们得到一个浮点数。但是我们也有
另一个除法运算符，用于获取整数。因此
如果我们在此处添加另一个斜杠并运行该程序
我们得到一个整数。我们有
另一个叫做modulis（？）的运算符，它是一个百分号。
这将返回除法的其余部分。所以当我们运行这个程序
我们应该得到1，你去。和
我们在这里拥有的最后一个运算符是幂。
因此，用2个星号表示，它将返回
10乘以3的幂。因此，让我们运行该程序
我们得到1000，所以这些是算术运算符
用python编程语言编写。现在，对于您了解的所有这些运算符
我们有一个增强的赋值运算符。这是
非常有用，让我告诉你。假设我们有一个变量
叫做x，我们将其设置为10，现在我们想将其增加
3，我们必须编写这样的代码。 X我们将其设置为
x plus3。因此Python解释器将添加
10到3，结果是13，然后将其存储
再次变成x。所以当我们打印x时，我们应该看到
13，你去。所以这就是你可以增加的方式
一个数字，对不对？现在，扩展赋值运算符是
一种写相同代码但形式更短的方法。这个
它是如何工作的。我们输入x加号
等于3。第3行上的内容恰好是
就像我们第2行上的内容一样。这就是我们所说的
我们已经扩充的扩充任务运算符，或者
增强了赋值运算符。现在特别
如果我们使用扩展赋值运算符将数字递增，
但我们也可以将数字减去或乘以给定值
例如，让我们删除第2行上的内容
我们可以键入减等于3。所以在这里我们
从x减去3。当我们运行该程序时，我们应该看到7，
你去。
现在让我问一个问题，我将在此处清除所有代码
定义x并将其设置为10加3
时代2.你认为这个表达的结果是什么？
不幸的是，这是一个非常基本的数学问题，很多人未能回答。
答案是16。因为在数学中我们有这个
称为运算符优先级的概念，它表示
操作。所以乘法运算符有
更高的优先级，这意味着它首先被应用，这意味着3 x
首先执行2，结果为6，然后执行
它加到10，这就是为什么x在之后显示为16的原因
我们运行这段代码，让我们验证一下。因此，打印x
运行该程序，x为16。这就是我们所说的
运算符优先级，这只是一个基本的数学概念。
它与python编程语言无关。所以所有其他编程语言
行为相同，所以这是顺序，首先
幂，即2乘以3的幂
然后我们有乘法或除法
最后我们有加法或减法。
这是操作顺序。让我向您展示另一个示例。
在这里，我要添加指数运算符，因此，
2乘以2的幂。
认为这是表达的结果吗？暂停视频，然后考虑几分钟。
答案是22。
因为幂运算符优先，所以首先
2以2的幂执行，结果为4，
然后4乘以3，即12
最后将12加到10。因此x应该是22。
因此，让我们运行该程序并进行验证。所以我要
在此处删除这些行。运行程序，就可以了。 X
22.现在，让我在这里回顾这些规则。
我们还可以使用括号来更改操作顺序
所以如果我们有括号，我们总是
优先。在这种情况下，我们可以添加括号
大约10 + 3，所以这3个
首先执行，结果为13，然后取幂
运算符将被执行，因此2的2的幂等于4，
最后4乘以13
现在，这里为您做一些练习。我要设置x为
括号2 + 3 x 10减
3.结果是什么？暂停视频，然后考虑几分钟。
所以你知道括号总是
覆盖顺序，因此首先执行这段代码。结果
在这5个中
减法，您知道乘法优先。
接下来，将5乘以10，结果是
50，最后我们减去。所以50减
3将是47。让我们验证一下，打印
x，在那里运行程序，希望您猜对了。
这就是所有回合运算符的优先级，这是一个非常重要的主题
我在Python测试中经常看到它。因此，如果您正在准备进行Python测试
确保再看一次他的教程。
在本教程中，我们将介绍一些用于处理数字的有用函数
让我们开始定义一个变量，如x并将其设置为2
.9。现在要舍入这个数字，我们可以使用内置的
圆形函数，因此我们将圆形函数命名为x，
然后打印结果。让我们运行这个程序
因此，我们得到3，还有另一个有用的内置函数称为
abs代表绝对值，这是绝对函数
我们有数学，我们给它一个值，它总是返回
即使该值为负，该值的正表示。
这是一个例子。我们叫abs函数
并给它负数2,9当我们运行该程序时
我们很高兴在终端上看到2,9。所以我们继续吧
你去。因此，绝对值始终会返回一个正数。
但是从技术上讲，在Python中，我们有一些内置函数可以执行
数学运算，如果要编写涉及复杂的程序
数学计算，您需要导入数学模块。
Python中的模块是一个单独的文件，具有一些可重用的
代码。我们使用这些模块将代码组织成不同的
文件。作为一个比喻，可以考虑一个超级市场。当你去超级市场时
您会看到水果和蔬菜，清洁产品的不同部分，
垃圾食品等。超级市场的​​每个部分都像一个模块
在Python中。因此在Python中，我们有一个数学模块，其中包含一堆
用于执行数学计算的生锈函数。
因此，让我向您展示如何使用此模块。在顶部
我们以小写形式输入import，math
这样我们可以导入数学模块。现在数学是
像字符串这样的对象，因此我们可以访问它的功能或更精确
它是使用点运算符的方法。所以如果你输入
数学看起来这些都是数学上的
该模块中可用的功能。例如，您可以致电
密封方法可以得到一个密封数。因此，如果您在此处通过2,9
然后打印结果，我们应该看到3。
让我在这里删除所有其他代码。好吧，让我们运行这个程序
你去。这样我们得到3。另一种有用的方法是
下限方法，让我们尝试一下，下限为2。
9.您认为我们会得到什么？我们得到
2.现在，此模块中内置了许多功能，我们真的没有时间
去经历所有这些。但是，让我向您展示如何独自学习它们。
打开浏览器并搜索Python 3
数学模块。确保添加版本python 3。
因为python 2中的math模块与python 2中的math模块略有不同
python3。因此python 3 math模块，
现在，您可以在这里看到这种模块的文档
我们去看看，如果您向下滚动，
我们可以看到所有功能的列表及其解释。
因此，作为一项练习，我鼓励您快速浏览一下
文档。看看有什么功能可以满足您的需要。
在本教程中，我将与您讨论Python中的if语句
if语句在编程中非常重要，并且它们
使我们能够构建可以根据某些条件做出决策的程序。
因此，如果某些条件成立，我们将做某些事情，否则我们将做其他事情
东西这是一个例子。在这里，我有这个文本文件
我们程序的一堆规则。如果天气炎热，也许我们想
告诉用户天气炎热，因此请确保喝大量水。
否则，如果很冷，那么这是另一种情况
如果此条件为真，我们将告诉用户这是一个寒冷的日子
所以在哪里保暖的衣服。否则，如果
无论是冷还是热，我们都想告诉用户这是美好的一天。
因此，让我向您展示如何编写模拟这些规则的程序。因此，
回到我们的程序，我们首先定义一个布尔变量
下划线很热。我们将此设置为true。
接下来，我们添加一个if语句，所以在这里
我们需要添加一个条件，在这种情况下，我们将使用我们的布尔变量。因此，
下划线很热。因此，如果此值为true。
然后，我们将做某些事情。在这种情况下，我们想告诉用户
嘿，天气热，多喝水。所以，回到我们的程序
在我们的条件之后，我们添加一个冒号，现在，
请注意，当我按Enter键时，pycharm会自动缩进
我们的光标。现在，我们在此处编写的任何代码都将执行
如果此条件为真，否则将被忽略。在这里
是一个例子。让我们写一个打印语句，在这里我要使用
双引号，因为我想在字符串中使用撇号。因此，
天很热。现在让我们按Enter
您可以看到光标仍在缩进，这意味着我们可以编写更多代码
如果此条件为真，则执行该命令，在这种情况下，我们不想
编写任何额外的代码，以便终止此块
我们需要按Shift和Tab，现在光标在该行的开头
因此，让我们编写一条打印声明，并附上如下信息：
祝您愉快。现在，当我们运行该程序时，因为
此条件为真，您要说的是此消息，然后是
第二条消息，看一看，所以运行，去吧，今天很热
祝您愉快。但是如果我去这里
将此布尔值更改为false并再次运行程序，我们的
第一条消息消失了，我们只看到第二条消息，享受
你的一天。所以这就是if语句如何工作。现在回来
在这里我们可以添加另一个打印语句，假设
多喝水。
现在，因为这个精妙的陈述也被缩进了
如果此条件为真，则执行。所以我要还原为真
并再次运行该程序。你去那里，所以
天气炎热，喝大量的水，并享受您的
天好吧，现在让我们在这里添加第二条规则
很热，我们要执行这两行，否则，如果不热
我们要打印其他信息。所以这里
我们正在移动缩进并输入els
冒号。现在，当我们再次按回车键时
缩进，这样我们将在此处编写的代码被执行
条件不正确。所以我们可以在这里打印
今天很冷，打印，
那里暖和的衣服。
现在，让我们再运行一​​次程序。这样我们得到消息
大约炎热的一天，然后享受您的一天。您没有看到任何讯息
大约很冷的一天。现在，如果我们回到顶部。
并将此布尔值更改为false并运行我们的程序
我们会看到不同的消息集。天很冷
穿暖和的衣服，享受美好的一天。但是有一个问题
我们的程序。如果不热，则不一定意味着它很冷，这意味着
这是美好的一天。因此，没有热量并不意味着它冷。
回到我们的条件，在第4行，我们有一条规则说
如果天气冷，则打印这些消息
否则，无论天气冷还是热，都说这是美好的一天。
因此，要实施此规则，我们需要回过头来
py并定义另一个变量。所以说
下划线是冷的，我们将此设置为
没错现在，我们需要添加第二个条件。所以之后
我们的第一个if语句，我们可以使用el if语句
定义第二个条件。这就是它的工作原理。因此，
el如果是els的缩写，则为
否则，如果现在在这里添加另一个条件，那么，
很冷所以如果你很冷你想
执行这几行。所以我们剪下来
从这里，并在第二个条件下移动它们
最后，如果这些条件都不成立，
您要打印其他信息。真可爱
天所以，现在，
热是假，冷是真，
因此，当我们运行该程序时，python解释器将执行第一个
if语句，在这种情况下因为我们的条件为假，所以这两个
行将被忽略，然后Python解释器将查看
第7行，它将评估这种情况，在这种情况下是
Cold是真的，因此我们将在终端上看到这两个消息。
现在，在这种情况下，因为这些条件之一成立，所以此els语句
将被忽略，因此我们将不会看到此消息，最后
和以前一样，我们总是会看到此消息。因此，让我们运行
程序，您去了。天气很冷，
那里暖和的衣服，并享受您的一天。现在，
回到顶部，如果我们改变是冷的
不管是冷还是热，这都是美好的一天。
让我们运行程序，然后开始，这是美好的一天
祝您愉快。这些是使用if的基础
陈述。如您所见，它们在编程以及这些方面非常有用
我们可以在程序中建立各种规则。好的，这是一个
运动还是你。想象一所房子的价格是一百万美元。
现在，如果买家信誉良好，则需要放下10％
的价格，否则他们需要放下20％
使用这些规则编写程序并显示预付款
信誉良好的买家的信用卡。您会看到我的解决方案
下一个
好吧，让我们为这所房子的价格定义一个变量
我们将其设置为100万，所以1与6 0对应。
接下来，我们需要一个变量来判断该买家是否信誉良好
所以信誉很好
并将其设置为true，现在我们需要一个if语句
所以如果有良好的信誉就可以
冒号，这里我们需要计算预付款，所以
首付应等于
价格的0,1倍。那是这个价格的百分之十
财产。否则冒号
首付应为0,2
乘以价格。现在终于我们删除了
缩进和打印在这里我们可以使用表格
的有效字符串，首先我们添加标签，预付款
冒号，然后我们添加一个占位符
或预付定金变量的漏洞。大括号
首付。让我们运行这个
计划，因此对于信誉良好的买家而言，首付款
是100,000美元。现在，通过添加一个
该数字前的美元符号。回到我们的格式化字符串，
在花括号之前，我要添加一个美元符号，让我们
再运行一次，那更好。
在本教程中，我将与您讨论Python中的逻辑运算符。
我们在有多个操作员的情况下使用这些运算符
条件。这是一个例子。假设我们正在为
处理贷款。如果申请人的收入很高
和良好的信誉，那么他们就有资格
贷款。所以在这个例子中我们有两个条件，一个是
高收入，另一个信誉良好。所以如果两者
这些条件成立，那么申请人就有资格获得贷款。
这就是我们使用逻辑和运算符的地方。
顺便说一下，我们使用此运算符组合两个条件
这并非特定于python编程语言，几乎是任何编程语言
支持if语句也支持逻辑运算符。
所以，回到我们的程序，让我们定义两个变量，
有高收入，我们将其设置为true。
还有一个很好
信用，我们也将其设置为true，现在我们的if语句
如果高收入是真的，
拥有良好的信誉也是如此
然后我们将打印符合条件的
为空。所以这是
我们正在使用and运算符。所以如果这两个条件都成立
然后将打印此消息。如果其中之一是假的，我们将不会看到
此消息。让我们尝试一下。所以我要运行这个程序
因此我们认为它有资格获得贷款，但是如果我们改变
这些条件之一为false，然后再次运行程序
看，消息消失了。
所以这是逻辑和运算符。我们也有
逻辑或，我们想在需要做某些事情的情况下使用它
至少有一个条件为真，例如让我们更改
该计划的规则，例如，如果申请人的收入很高，
或信誉良好，那么他们就有资格获得贷款，
因此，如果这些条件中的一个或两个都成立，则候选人为
合格的。现在回到我们的程序，我们可以
通过使用逻辑或运算符来实现此规则。所以我们只需替换
或，现在，当我们运行该程序时，我们将
看到此消息是因为我们至少有一个条件为真，
让我们来看看。因此，申请人有资格获得贷款
借钱，因为他们有良好的信誉。如果您将其更改为false
但将其他条件设为true，我们仍然
看到相同的结果，但是如果这两个条件都为假
那么我们就不会再看到此消息了。所以这是区别
这些运营商之间。与逻辑和运算符
两个条件都应为真，符合逻辑
或操作员至少有一个条件为真
我们还有另一个逻辑运算符not
基本上就颠倒了我们给它的任何布尔值，如果我们给它，
我们给它一个真实的布尔值，它将其转换为false。举个例子
如果有申请人，我们就来一个新房间
信誉良好，没有
然后是犯罪记录
他们有资格获得贷款。让我向您展示如何实现这一点。因此，
我们回到程序，在此示例中，我们不需要
我们删除第一个变量。让我们将此变量设置为true
我们还定义了另一个变量，例如具有刑事犯罪
记录。我们将此设置为false。
现在，我们要检查此申请人是否信誉良好，
犯罪记录。这是我们使用not运算符的地方。
因此，如果他们有良好的信誉，
而不是犯罪
记录。因此，在此示例中，
当我们使用not运算符this时，记录设置为false
基本上更改为true，所以我们有两个条件为true。
这是一个，这是另一个。所以我们的申请人是
有资格获得贷款。当我们运行该程序时，我们看到
这个熟悉的消息。可是
如果申请人有犯罪记录，那么我们将其更改为
是的，现在运行此程序时，我们可以看到我们的申请人是
不符合条件，因为当我们在此应用操作符时
变量，我们将得到假。因此，将真实更改为错误。
最后我们有两个条件，一个是正确的
另一个是假的。这就是为什么这个消息是
不打印。这就是关于逻辑运算符
python。
在本教程中，我将与大家讨论
Python中的比较运算符。我们使用比较运算符
在我们想要将变量与值进行比较的情况下，
例如，如果温度大于30，则
我们要打印这是一个炎热的日子。否则，如果少于
然后十，这是一个寒冷的日子，否则它既不热
也不冷。顺便说一句，我要摄氏，而不是摄氏。
因此，要将这些规则构建到我们的程序中，我们需要使用比较
操作员。回到app.py，我定义了这个
温度值，让我们写一个if语句，如果温度
现在我们要检查它是否大于30，所以我们使用
大于运算符。如果大于30，
我们想打印今天很热
否则，我们只打印
那天不热。现在，
当我们运行该程序时，我们将看到第二条消息，因为30
不大于30。所以我们的第一个条件是一个值
是假的。让我们验证一下。快跑
那天不热。现在，如果你改变
温度升至35，然后再次运行
我们将看到不同的消息，这是一个炎热的日子，所以我们在这里使用
比较运算符。现在我们所知道的是一种表达
因为这是一段产生价值的代码。所以更准确的是
布尔表达式。所以这大于运算符
我们也有大于或等于
小于，小于或等于
这是相等运算符，所以如果温度等于30，
那么您可以说天气很热。请注意，这与赋值运算符不同
只有一个等号。您可以看到如果我们仅使用一个等号
在这里，我们立即得到红色下划线，因为这仅仅是
作业说明。我们正在更改温度值。
您正在设置的值
另一件事。因此，我们没有布尔表达式，您没有生成
布尔值。好吗所以，我们的平等算子
有两个相等的符号，最后我们没有
等于，是感叹号后跟等号。
现在这里是一个练习。您可能已经看到，当您填写
在线表单，有时输入字段中包含验证消息，
例如，假设我们有一个输入字段供用户输入其名称。
现在，如果名称少于3个字符，我们要显示一个验证
错误，例如名称必须至少包含三个字符，
否则，如果名称长度超过50个字符，则我们需要
显示一个不同的验证错误，例如name可以是最大的
50个字符。否则，如果名称介于3到50个字符之间
那么我们只想告诉用户该名称看起来不错。
因此，继续并编写实施这些规则的计划。
好吧，让我们定义一个名为name的变量并将其设置为
假设j。因此，我们假设这是用户在输入字段中键入的内容。
现在，我们要获取此字符串中的字符数。
所以我们使用len函数吧？伦的名字。
当我们打印时，我们得到1，对
你以前看过现在在这里我们要使用if语句
如果名字len小于
3，那我们要打印
名称必须至少3个字符
现在这里我们需要第二个条件
检查上限。所以，如果
名称len大于50，
那么我们要打印不同的消息，名称，
必须为最大值
50个字符。
好吗否则的话
这些条件都不成立，这意味着名称看起来不错。因此，
打印，名字看起来不错。让我们
运行我们的程序。所以在这种情况下，我们收到此消息
因为我们的名字太短了。现在，如果您回到这里，
键入非常长的内容。然后
我们运行程序，我们将看到另一个消息名称必须是
最多50个字符，最后是
我们在这里输入一个合适的名字，例如约翰·史密斯
并运行我们的程序，我们得到名称
看起来不错
这是另一个结合了好的练习
到目前为止，您已经学到了许多材料，所以早些时候您建立了一个程序来
将某人的体重从磅转换为公斤。现在我们要扩展这个程序
并允许用户以千克或
磅，然后将其转换为其他单位。这是我们的程序
要上班了。所以我以磅为单位输入体重
现在是100和60告诉我是磅还是磅
公斤。所以在这里，我将l加至lbs或k表示千克。
顺便说一句，该程序不区分大小写，因此
当我输入大写字母l或小写字母l时
以磅为单位。现在它告诉我您将其设置为
公斤。让我们再运行一​​次该程序，
这次我要输入以公斤为单位的体重，所以将其发送到
是重量，单位是千克，所以k，
它说你160磅。
因此，继续并花几分钟进行此练习，接下来您将看到我的解决方案。
好吧，首先让我们问一下使用者的体重。所以我们使用输入
函数，权重冒号我们得到返回值
并将其存储在名为weight的变量中。
现在是第二个问题，所以又一次使用输入函数
埃尔英镑。
或k表示千克。因此，
我们也将其存储在名为unit的变量中
现在我们需要一个if语句。所以如果单位
等于l，那么我们需要转换这个权重
公斤但是，通过此实现，我们仅允许
用户输入国会大厦l，如果他们输入小写字母l
此代码将无法正常工作。所以这是我们使用鞋帮的地方
字符串对象的方法，所以这个单位是一个字符串，因为正如我告诉你的
之前，输入函数总是返回一个字符串。
因此，我们可以使用点运算符来访问其所有方法，或者
函数，这里我们调用上层方法
会将用户输入的内容全部转换为大写，然后将其转换为大写
到首都现在，如果这个条件成立，
那么我们需要获得权重并将其乘以0，
.45但是，正如您所知
weight是一个字符串对象，我们不能将一个字符串相乘
通过一个浮点数，我们在本课程的前面讨论了这一点。
因此，首先我们需要将此权重转换为数值。因此
就在这里，当我们调用输入函数时，我们可以获得返回值
值并将其传递给int函数。因此，
我们调用int函数并给它
输入函数的返回值。现在，
in函数将返回一个整数，因此我们可以将其存储在此权重中
变量。这是转换后的重量，我们将其存储在
称为转换的变量，
然后我们在这里打印，我们可以使用格式化的字符串，所以
我们用f ur前缀这个字符串
我们添加花括号以动态插入
转换后的变量。最后我们加公斤。
否则，如果单位是千克。
我们需要将权重除以0,45。 q
因此，重量除以0,45
只是为了刷新您的内存，该除法运算符返回一个浮点数
但是如果我们使用双斜杠，我们将得到一个整数。
在这种情况下，我们想要一个浮点数，
最后，让我们打印一个格式化的字符串ur
花括号，转换
磅。好吗现在
让我们运行该程序，看看会发生什么。所以重量是
160和lbs
等于72公斤，很完美，如果我们再跑一次，
然后输入72公斤
我们得到160磅。
在本教程中，我将向您展示如何在python中使用y循环。我们是
使用y循环多次执行代码块，通常
在构建交互式程序和游戏时很有用。在以后的教程中
我将向您展示如何使用ay循环构建简单的游戏。
所以，让我们开始基础，我们写一个y语句
然后紧接着，我们输入一个条件，后跟一个冒号
只要这个条件成立，我们写的引号
在此块中将被重复执行。这是一个例子。
我们可以定义一个像i这样的变量，简而言之
索引并将其设置为1。现在我们将条件设置为
我小于或等于5，只要我
小于或等于5，我们可以打印i，
在终端上。然后我们需要增加i
乘以1。所以我们将i设置为i加1。原因
我们这样做是，如果我们不这样做，我将永远是1
所以我们最终会陷入无限循环。因为这种情况会
永远是真实的。一个总是小于5，因此在每次迭代中
循环，我们将i加1，所以在某个时候，我会
六，然后当此条件为假，然后
我们会跳出这个循环，好吗？现在演示一切如何
在此循环之后，我将添加一个打印语句
说完成。因此请注意这两行
缩进，因此它们是y块的一部分。
好的，现在让我们继续运行该程序，看看会发生什么。因此，
看一下，我们得到数字1-5，然后是
完成。所以这是如何执行该程序的
首先我们将i设置为1现在python解释器执行行
2，此条件成立，因为我小于5，
所以我印在终端上，然后增加
1.然后，控件移回y循环的开头。
因此，它不会转到下一条语句。因此，
我们回到这里，现在是第二次迭代。在第二次迭代中
我是2，并且因为2小于5，所以我们的条件仍然是
是的，所以我将被打印在终端上，再一次
加1，所以在某个时候我会变成6
那时这种情况将是假的，所以我们的外观会
终止，此完成的消息将打印在终端上。
因此，这是y循环的基础。现在让我们将该程序做一点
更有意思。在这里，我们可以编写这样的表达式。我们是
添加一个字符串，并在此字符串中添加一个星号
然后我们将此字符串乘以i。因此
使用此表达式，当我们将一个字符串乘以一个字符串时，我们可以重复一个字符串
用一个数字，该字符串将重复。例如，如果
我是两个，这个表达式会产生一个
带有两个星号的字符串。现在让我们运行程序
看看我们得到什么。所以我们看到这个小三角形
在这里塑造。因为在第一次迭代中，我是1，所以，
星号1次产生1个星号。
在第二次迭代中，我是2，所以当我们乘以2
按1个星号，我们将得到2个星号。
在本教程中，我将向您展示如何使用y循环进行构建
像这样的猜谜游戏。所以我们有这个秘密号码，目前设定为
9.现在，计算机要我猜测。因此，
假设1不正确，因为密码是9，好吧，
再试一次，2，不对，我们再试一次，所以我
只有三个机会来猜测。如果我猜不到程序的编号
告诉我我失败了。这次我们再运行一​​次程序
我猜数字是9，你去了，说你进去了。
因此，让我们继续使用ay循环构建该程序。
好吧，让我们开始定义一个变量来存储我们的秘密号码
因此，我们称其为秘密下划线，并将其设置为9。
现在我们需要一个while循环来反复要求用户
猜一猜。所以当条件结肠
我们这里的状况如何？好吧，我们想给我们的用户一个
最多三个猜测。与上一教程类似，我们可以定义
像我这样的变量，将其设置为0，并假设它代表
用户做出的猜测数量。然后我们写条件
因为我不到3。请注意，这里我不是
使用小于或等于运算符，因为在这种情况下
我们的循环将执行4次，而我为0时，
一，二和三，所以在这里我们应该使用
少则运算符。现在，如果我们将此代码提供给其他人，目前尚不清楚
我在这里代表什么，只是在我们脑海中
我代表用户的猜测次数。喜欢
最佳做法是，始终对变量使用有意义的描述性名称。
因此，最好重命名此变量以进行猜测和计数。
让我告诉您如何重命名。因此，右键单击i变量，
然后去重构
重命名。查看快捷方式。在Mac电脑上，它正在转移，
f 6.现在，在此对话框中，我们可以轻松地
重命名您的变量，pycharm将更新对该变量的所有引用
变量，因此我们不必手动更新每个实例，好吗？让我们
更改为guess_count
进入，你去那里，现在更好了，
另外最好将3存储在一个单独的变量中以使我们的代码
更具可读性，因为目前尚不清楚3代表什么。
因此，让我们定义一个称为猜测极限的变量
说3，然后我们可以改变3来猜测
下划线限制，现在我们的代码更具可读性
虽然猜测数少于猜测极限，但阅读起来就像一个故事
这就是您应该编写代码的方式。好吧
当此条件成立时，我们希望敬酒用户做出猜测。所以这里
我们使用输入函数，猜
现在，用户输入的任何内容都以字符串形式出现，因此我们需要将其转换为整数。
所以在这里，我们将结果传递给end函数
然后将其存储在一个单独的变量guess中。
因此，此时用户做出了猜测，现在我们需要
增加猜测数，所以猜测数
我们将其设置为正等于1或
好的，现在我们需要检查用户是否会做出正确的猜测。
因此，在这里我们需要一个if语句。如果用户猜到了
等于我们的秘密号码，
再次看到我们的代码是如此可读。这就像一个故事，您可以像平常一样阅读它
英文所以如果这个条件成立，我们想
告诉用户他们赢了。所以打印你赢了
现在让我们继续运行程序。
好吧，这是要我猜测，我要做出
猜错了，于是又问了我一次2次，
3，好的，此实现中缺少的是
消息告诉我我失败了。我们将暂时解决它，但是
让我们再运行一​​次程序并做出正确的猜测。所以9
好的，它说您赢了，但它仍在要求我
一个猜测，因为我们的while循环将被执行3次。看
1和2。所以我们需要更改程序
这样，如果用户做出正确的猜测，我们需要终止我们的
while循环，我们需要跳出循环。我们该怎么做？
因此，在此之后，如果用户做出正确的猜测，
我们打印此消息，我们可以使用砖语句终止
终止循环，当python解释器看到这一点时，它将
立即终止我们的循环，不会再评估这种情况。
现在让我们运行程序，看看会发生什么。所以，我会去
猜对了数字，你赢了，看看，你是
现在要求再做两个猜测，很漂亮。现在我们需要的最后一件事
要在此处添加的消息是告诉用户，如果他们无法猜到他们失败了
正确的号码。我们该怎么做？在Python中很好
我们的while循环可以选择包含else部分。
类似于if语句。所以之前您了解了我们的if语句
可以选择发生其他部分。在这里
如果满足此条件，请执行此操作，
否则做其他事情。在这种情况下，我们的if语句没有
另一个部分。现在，类似于if语句
我们的while循环，我们的while语句也可以包含else部分。
因此，在这个级别上，我们可以添加
一个else块，另一个冒号。
如果执行while循环，我们在此处编写的代码将被执行
无需立即完成即可成功完成
休息。换句话说。如果用户猜测
正确的数字，您打破了这个循环，您跳出了循环，所以代码
我们在else块中写入将不会执行。
但是，如果用户无法猜到这个数字，那么您将永远不会崩溃
这个循环，所以这个循环将执行到完成为止
这种情况变为假。在这种情况下，我们编写的代码
在else块中将被执行，这对我们来说是绝佳的机会
告诉用户嘿，您做出了三个猜测，但没有一个是正确的。
所以，打印，对不起
失败了现在，让我们再测试一次该程序。
所以，猜一二三
抱歉，您失败了，让我们再运行一​​次。这次我要做
一个错误的猜测，然后是正确的猜测，
我们赢了，我们的循环立即终止。
好了，现在该练习您到目前为止所学的知识了。
因此，我们再次要构建一个游戏，该游戏是模拟游戏
纸牌游戏。现在我们的游戏没有图形用户界面或粘性
目前，这并不重要，我们的重点完全放在构建
游戏的引擎。因此，让我们看看它是如何工作的。
当我们运行它时，我们在这里得到这个小符号，然后我们的程序
正在等待我们输入命令。如果您输入帮助
小写或大写我们都会得到命令列表
我们的程序或游戏当前支持的功能。所以我们可以输入
启动命令来启动我们的车，我们可以输入
停止命令以停止我们的汽车，并退出以终止游戏。
我们键入程序的任何其他命令都会告诉我们，嘿，我不明白。
例如，如果我在此处输入asd，则表示我听不懂
如果您键入开始，我们会收到此消息，
汽车启动，准备出发，如果您键入停止
说车停了，最后如果我们撞了
我们的程序终止，这是您练习的绝妙练习
学到了什么，所以暂停视频并花费5-10分钟
建立这个程序。
好了，我们将从有条件的while循环开始
我们这里的状况如何？我们要运行此循环
直到用户键入退出。所以我们可以定义一个变量
或一个故事来命令用户输入什么，然后我们可以运行它
只要命令不等于退出就循环。所以就在
在循环中，我们定义一个变量，命令，并首先设置它
到一个空字符串。空字符串是没有字符的字符串
在里面。我们只有报价。所以呢
我们输入条件为while命令
不等于退出然后做点什么。
现在我们在这里遇到了一个问题，因为我们假设用户
以小写形式键入命令，因此如果以大写形式键入命令
我们的程序无法正常运行，因此要解决此问题，您需要
调用字符串对象的下部方法，然后比较结果。
退出。你也可以称这上衣
然后以大写形式键入quit。这是关于我们的个人喜好
在此演示中，我将使用小写字符。
好吧，现在在这个循环中，我们需要让用户输入
命令。因此，我们将再次使用输入函数，我们将添加
更大的符号后跟一个空格，
无论用户输入什么，我们都将其存储在我们的
命令变量。现在除了
quit命令，我们还需要支持其他三个命令。开始
停下来，帮忙。所以在这里我们需要一个if语句进行比较
用户使用受支持的命令之一输入的内容。
因此，如果command.lower
等于开始，然后您要打印消息
就像汽车起步一样。于是打印车开始了。
准备出发，没关系，
现在第二个条件。如果它没有开始，也许它停止了怎么办？因此，
el if command.lower
等于停，你去那里，然后我们打印一个
不同的消息车停了下来。现在看一下我们的代码。
我们已经多次重复了这个更低的更低的更低的价格。
这很不好，在编程中我们有一个叫做dry的术语，它是
不要重复自己。所以只要你有重复
您的代码意味着您做错了什么。那么我们如何解决这个问题。
好吧，与其在每种情况下都调用lower方法，
当我们从用户那里获得输入时，我们可以在这里调用它，因此
如您所知，此输入函数返回一个字符串，我们可以
立即使用此命令在该字符串上调用下层方法
总是小写，所以我们不需要
在每种情况下都调用此方法。你看
我们删除重复项以及我们的条件
更短，更容易阅读。还有一个地方
我们需要进行修改，就在这里。那更好。
现在，第三个命令。如果还需要另外一位。
如果命令等于帮助，那么，
我们想显示我们支持的命令。因此，
在这里，我们将打印多行字符串。所以我们
使用这样的三引号，并且
给用户这样的指导。所以开始
开始停车
停下来的车
戒烟戒烟。现在最后我们需要
其他部分，因此，如果用户输入的不是这些命令，
我们要告诉他们，嘿，我们不了解这些，
否则，冒号打印
对不起，我不明白。
顺便说一下，这里变成了我在使用double
引号，我可以轻松地将单引号用作撇号，好吗？
现在让我们运行程序，看看会发生什么。
好吧，让我们键入启动车是
开始，美丽，停止，汽车停止，帮助，
我们得到了这个指南，但是缩进太多了
在执行命令之前，我们将在一秒钟内解决此问题。最后
让我们测试quit命令，哎呀，我们的程序
不能正常工作。这是原因。使用这些if语句，
我们正在将命令与开始停止进行比较，并且
帮忙其他一切都将在这里结束，所以这就是为什么我们
程序说不明白。这就是为什么我们的程序
说它不理解该命令。但是，在此el声明之后
控件将被移至循环的开头。
此时，我们的命令已退出，因此我们的循环将完成，并且
程序终止。换句话说，当我们运行该程序时
并键入quit，我们的程序实际上退出了
我们仍然看到此消息，该消息不应出现在此处。我们如何解决这个问题？
好吧，我们可以回到这里和之前
else块，如果再添​​加另一个el，例如
这个如果命令等于，则为el
退出，您可以立即休息。
这将解决我们的问题，但请注意，我们已经反复
这个表达在两个地方。现实情况是
我们实际上不需要最上面的条件，因为有了这些if语句
如果我们可以跳出此循环并终止，则使用此el会更准确
我们的程序。因此，我们可以简化条件
像这样没错因此，虽然真实意味着
该代码块将反复执行，
直到我们明确打破它，
好吗现在让我们再测试一次我们的程序。因此，
现在退出，我们的程序终止，我们看不到该消息
漂亮因此，让我们解决最后一个问题。你看到了，当我们
键入帮助，这些准则在
缩进，这就是原因，在我们的代码中，
他们已经缩进了。因此，当我们使用三引号时，我们在此处键入
将完全照原样打印。所以，因为我们
在此处有一个压痕，该压痕也将被打印在终端上。
所以，我们删除这些
好的，再运行一次程序，输入帮助，
压痕消失了。好漂亮现在这对您来说是一个挑战。我要你
将此程序带入新的高度。所以现在如果我们输入
启动，我们得到此消息汽车启动。如果我们再次键入开始
我们收到相同的消息。如果会更好
我们收到一条消息，例如汽车已经启动，因此
开车两次。同样地，如果我们输入stop
它说汽车停了下来，如果我们再次键入它，我们得到的完全一样
消息，两次停车都没有意义。所以这就是我需要你做的
如果汽车停了下来，而用户又试图停下来，
程序应该说嘿，汽车已经停了，你在做什么？同样
如果汽车已经启动并且用户尝试再次启动它，
该程序应该对用户大吼大叫。因此，继续进行必要的更改
实施此方案。
好的，将其添加到我们的程序中，我们需要
知道汽车是否启动。因此，还有更多信息
我们需要存储在内存中。我们需要在这里存储什么类型的数据？
一个布尔值。汽车是否启动，是的
还是没有是非题。所以在最上面
我们可以定义另一个变量，例如begin，最初我们对其进行设置
虚假。所以汽车没有启动，对吧？现在
当用户键入启动命令时，这里我们需要检查
看看汽车是否已经启动。如果没有，我们将开始
否则我们会大吼大叫。因此，在此块中，我们将编写
另一个if语句（如果已启动）
我们已经打印好车了
开始。否则，如果您添加一个
el声明在这里。在这一点上，
您将开始设置为true。所以我们开始
汽车，我们打印此消息，好吗？现在我们需要做一个类似的
更改停止命令。所以如果汽车是
已经停止，我们需要打印其他信息。所以
没有开始，所以这里我们使用not运算符
如果汽车停了。因此，如果未开始，则意味着
停止了，好吗？所以如果它停止了，我们打印
车已经停了
双p，否则
我们需要停车，我们该怎么做？我们是
设置为false。然后我们将打印此消息。
就这么简单。让我们继续运行我们的程序。
因此，最初我们的汽车停了下来。所以我要输入
停止，它说汽车已经停止了，所以让
启动它，好吧，现在我们的车启动了，让我们
再开始一次。该程序对我们大吼大叫。这样我们可以
不要两次启动汽车。好漂亮现在停止
它说汽车停了，让我们再停一次，我们会收到此消息
再来一次
在本教程中，我将与大家讨论
for循环在python中。在上一教程中，您了解了while循环
您了解到，我们使用while循环多次执行代码块。
在python中，我们还有另一种循环，即for循环，我们使用
我们使用它来遍历集合的项目，例如字符串。
因为字符串是字符序列，所以它看起来像一个集合
因此我们可以使用for循环遍历a中的每个字符
字符串，然后对其进行处理。这是一个例子。我们输入
然后我们定义一个变量，这就是所谓的循环
变量。在每次迭代中，此变量将保持
一个项目。所以，我们称它为
在这里，我们输入类似Python的字符串，然后
冒号。因此，有了这个for循环，我们可以遍历一个字符串，并且在每个字符串中
迭代此项目变量一次将容纳一个字符
在第一次迭代中，它将被设置为p
在第二次迭代中，它将设置为y，在第三次迭代中，它将设置为
t等。所以这是我们的for块
由于此处的缩进，因此我们在此处键入的任何内容都将在
每次迭代，现在我们只需打印此项目
现在，让我们运行该程序，看看会发生什么。
这样您就可以看到此字符串中的每个字符都印在
新线。让我们看另一个例子。在Python中，我们可以
使用方括号定义列表，所以让我从
在这里，并使用方括号定义一个列表，
列表只是项目列表，数字列表，
客户，电子邮件，产品，博客文章列表等等。
因此，我们可以在此处定义名称列表，例如Mosh，
乔恩，莎拉，然后继续
并运行我们的程序，以便我们可以看到在每次迭代中我们都有一个名称
并在新行上打印。我们也可以
循环显示数字列表，例如，
1，2，3，4，让我们再次运行它
我们会在新行上看到每个数字，但是如果需要
数字列表？我们不会明确输入列表
假设有100或1000个数字，我们不想输入5、6
7一直到100。也就是当我们使用范围功能时。
所以，让我删除它，
在Python中，我们有一个名为range的内置函数，用于创建
数字范围。因此，我们给它一个数字，例如10，
让我们运行该程序，现在我们可以看到
在终端上，我们一路为0
至9。因此不包括10。
因此，基本上，当我们调用范围函数时，该范围会创建
一个对象，不是列表，是一种特殊的对象，我们可以
迭代，此对象将在每次迭代中吐出一个新数字。
我们也可以在此处处理一系列数字，假设您要开始
从5开始，一直到10。
所以，让我们运行我们的程序，现在我们有了数字
5、6、7和9。此外，此范围
函数可以选择采取步骤，因此我们可以通过
作为此功能的两个步骤，
当我们运行程序时，我们可以看到第一个数字
是5，现在我们向前走两步得到7，
再一次，我们向前走两步，我们得到9，即
我们范围的尽头。因此，这是在python中使用for循环的基础。
现在这里是一个练习。我要你写一个程序
计算购物车中所有物品的总费用。
假设我们有一个价格清单，例如10，
20和30，我希望您使用for循环，
计算我们假想的购物车中所有物品的总费用，
所以计算一下，然后在终端上打印出来。好漂亮
容易而且您应该在几分钟内完成。
因此，如您所知，我们用于
循环访问集合中的所有项目，
集合可以是字符串，可以是列表，可以是范围对象
从范围函数返回。任何事物，任何具有多个物体的物体
项目。因此，在此示例中，我们将使用for循环进行迭代
价格清单。所以对于项目
价格，冒号以及顺便说一下，此循环变量
我们不必叫这个项目，可以叫任何东西。例如，在这种情况下
我们可以将其重命名为价格。因此，为了价格，
价格。现在在每次迭代中
价格将保持一个值。在第一个迭代中，它将保持10，然后是
变成20，然后变成30。所以我们需要定义
另一个变量来计算总数
我们在for循环之外定义它，我们称其为total
最初我们将其设置为0。现在每个
迭代，我们得到当前价格并将其添加到总计中
我们写的总数等于总数加价格
或者如您先前所了解，我们可以使用增强型
赋值运算符以简化此代码。
因此，在我们的for循环之后。该总变量具有
所有价格的总和，我们可以在这里简单地打印出来，
或者我们可以使用格式化的字符串，所以字符串
带f的前缀，另一个标签，如total，
大括号以动态地在字符串中包含一些值，
在这种情况下，我们的总变量。所以我们继续吧
并运行该程序，然后就可以了，因此，
我们想象中的购物车中的所有物品都是60。
在本教程中，我将与大家讨论嵌套循环
在python中。使用嵌套循环基本上意味着添加一个循环
在另一个循环中，并且通过这种技术，我们可以做一些令人惊奇的事情
例如，我们可以轻松生成坐标列表。所以，一个
如您所知，获得的（？）是x和y的组合
价值。假设0和0。现在假设您要生成
这样的坐标列表。所以我们有0和0，
那么我们将有0和1，然后是0和2，接下来
我们将要更改x，所以我们将x用于1，
再一次，我们将使用这3个值作为y坐标
所以1和0然后1和1
1和2，你明白了。我们可以
使用嵌套循环轻松生成这些坐标。让我告诉你。
因此，我们从一个循环开始，比如说x in
范围4。通过此循环，我们可以生成值
x坐标。让我们在终端上打印它，
好了，我们得到的值是0
到3。现在对于每个x，像0，我们
应该生成一些y值。这就是我们使用的地方
嵌套循环。因此，在此循环中，我们将添加
另一个循环，所以我们不想添加仅先打印x
另一个循环，范围为y
假设3，现在我们可以一起打印x和y
因此，在这里打印，我们使用格式化的字符串。
显示这样的坐标。所以我们加上括号
首先在此括号内，我们需要添加x这样的花括号
x然后是逗号，然后是逗号
另一组花括号，y，
让我们运行该程序，看看会得到什么。
你去。所以，我们有这些坐标
0和0、0和1、0和2，那么
1和0 1和1 1和2等等。所以让我确切地解释一下
该程序如何执行。所以在第一次迭代中
我们的外循环的x是0。
在第2行，这里有一个新的循环，我们称之为
内循环。在这个内部循环中，在第一次迭代中
将会是0，所以我们在
终端。现在，控件返回到第2行或
内循环。在第二次迭代中，y将设置为1，但是
我们仍处于外循环的第一次迭代中。因此
x仍为0，但现在y增至1。
这就是为什么我们在终端上看到0和1的原因。
控件再次回到第二行，我们在第三行
内循环的迭代，因此将一直持续到内循环为止
完成。那是当y达到2时
此范围函数生成数字0到3，但不包括
3.因此我们将得到0 1和2。
然后控件返回到第1行，这时我们将转到
在外循环的第二次迭代中。所以x将是
1，则控件将移至第2行，即我们内部的
循环，此时，此范围函数将生成数字0
到3再多一次。因此，此内部循环将执行3次。
然后我们回到外循环。所以这就是
嵌套循环被执行。
好的，这是适合您的一种锻炼，但是这个锻炼有点
比到目前为止的练习更具挑战性。所以我真的不
希望你能做到，但是如果你做到了，哇，我会为你感到骄傲，
所以看看我在这里做了什么？使用嵌套循环
我已经编写了一些代码来绘制此f形，您能看到吗？所以我
让我给你一个提示，首先我们有这个
列表，称为数字，在此列表中，我们具有这些值，
5、2、5、2、5、2。这些值确定
每行中x的数量。因此，
例如，此列表中的第一项，它告诉我们应该有
第一行有5 x。你去了，所以1，2，3，
4，5，在第二行，我们将有2 x，
在第三行，我们将有5 x这样的。
所以我写了代码来转换一个简单的数字列表
变成这样的形状现在给您一个提示。
使用for循环，您需要遍历此列表。在
每次迭代都得到一个数字，这决定了x的数量
显示在该特定行上。所以如果你想作弊，
您可以获取该数字并乘以包含x的字符串，
因此，如果您将x乘以5，我们将得到5 x，那不是
我要你做。我希望您在这里使用内循环
生成包含5个x的字符串。所以想像
在Python中，我们不能将字符串乘以数字
因此，要解决此问题，我们需要一个嵌套循环。所以继续花钱
五分钟的练习时间。顺便说一下，尽力解决这个问题。是
有点挑战，但这并不是很难。只需要
一点重点。接下来，您将看到我的解决方案。
好吧，首先我们需要迭代
此列表中的所有项目。所以对于项目
以数字表示，或者，您可以重命名此变量
到x_count。那是x的数量
在每一行上。好吗现在我告诉你，如果你想作弊就可以编写代码
像这样打印x次
x下划线计数。如果您运行此程序，我们将得到相同的结果
输出。这就是Python的魅力所在
我们可以这样写表达式，我们可以将一个字符串乘以一个数字
重复一遍。许多其他编程语言不支持此功能。可是
对于本练习，我想让您想象一下，我们在Python中没有此功能
因此您将必须使用内部循环来解决此问题。这就是
它有效。在第一次迭代中，x计数将为5。
因此，我们需要生成5个x。我们该怎么做？
好吧，假设我们定义了一个名为output的变量，并将其初始设置为
一个空字符串。现在我们需要在该字符串中添加5 x。因此，
我们可以使用另一个循环来计算范围
x下划线计数。所以我们使用范围函数
生成从0到最大的数字序列
x数。因此，在我们的第一次迭代中，x计数将为5，因此
5的范围将生成数字1、2、3、4。
因此，此内部循环将执行5次。
这正是这个数字所代表的意义。
所以现在在每次迭代中，我们只需要
将x附加到我们的输出变量中。所以我们设定
输出，加等于x，
然后在这个内循环之后，我们只需打印
输出。有了他，我们将打印5 x
第一行。然后我们转到外循环的第二次迭代。
此时，x计数将为2，现在
在第3行，我们将把输出变量重置为
空字符串。因此，我们重新开始。然后我们进入内在循环，
此循环将执行2次，因此我们将附加到x的后面
到输出变量，然后打印出来，就这么简单。
如此看来，这并不是真的那么困难，但是要比
以前的练习。因此，让我们运行此程序，就可以了。
现在，如果您喜欢冒险，我希望您修改我们拥有的值
在我们的号码列表中
打印，我在这里。
现在，在本教程中，我们将仔细研究列表。
所以，我将定义一个名称列表，让我们发送它们
致约翰·鲍勃·莫什（John Bob Mosh）
莎拉和玛丽。因此，
如果您在此处打印此列表，我们将看到
终端看起来完全像我们定义列表的方式
方括号，在这些方括号之间，我们有我们的商品
我们的商品，因此此列表中有5个字符串。
因此我们也可以使用索引访问单个元素，就像
我们如何使用索引访问字符串中的单个字符。
因此，在这里我们键入方括号，
并指定一个索引。此列表中第一项的索引
是0。那么，让我们运行该程序，就可以了，
如果您要打印此列表中的第三个元素，我们现在得到Jon
它的索引是2，所以名称是2
返回莫什，现在我们也可以通过
此处为负索引，因此负1表示最后一项
在这个列表中，那就是玛丽，让我们运行该程序，
你去了，我们看到玛丽，如果你通过负2，这个
返回列表末尾的第二项。所以让我们运行程序
到那里，我们得到了萨拉，所以这就像访问
字符串中的单个字符。我们也可以
使用冒号选择项目范围，例如
您通过2个冒号。这将获得所有物品
从索引2开始，这就是Mosh
到字符串结尾的方式。所以让我们运行这个程序
你去。我们得到这个清单3
项，莫什，莎拉和玛丽。我们也可以指定
结束索引，比方说4，那么它将返回所有
直到此索引的项目，但不包括此索引的项目。
因此，当我们运行该程序时，我们只会看到Mosh和
莎拉（Sarah），我索引为4的项目是第5个元素，或者
不返回此列表中的第5个项目。所以玛丽
不返回。而且这里我们有默认值，所以如果您
省略该表达式将要返回的结束索引
从索引2开始到列表末尾的所有项目
或者，如果省略起始索引，则此表达式假定
0作为默认索引，因此它将返回
从列表的开头到结尾。顺便说一句
就像字符串一样，这里的方括号不要修改我们的
原始列表，他们只是返回一个新列表。例如，如果我们通过
2在这里，您可以看到它返回一个包含3个项目的新列表。
因此，如果您返回此处并打印我们的原件
在您看到名称不受影响后立即列出名称。
所以在这里我们要使用带有冒号的方括号来选择
项目范围，我们会得到一个新列表，顺便说一句，
修改此列表中的任何元素。例如，假设我们犯了一个错误，
第一项不应该是带h的john，
所以我们要删除h，这很简单，因此我们可以访问它，
使用名称为0的索引，并将其设置为新值
像这样现在，让我们打印列表
因此，您可以看到此列表中的第一项
现在是数据。因此，这是列表的基础。这是一个
为你运动。我希望您编写一个程序以查找最大数量
在您的列表中。对于初学者来说，这是一个很棒的练习，所以继续
花几分钟时间，然后再回来继续观看。
好吧，让我们
定义数字列表，数字和一堆随机数字
3、6、2、8、4和10。
现在在此列表中找到最大的数字。我们需要定义另一个
变量我们称之为max，该变量将保持
最大的数字，现在您最初要假设
此列表中的第一项是最大的数字。因此我们将max设置为
数字0。我们仅假设第一项
是最大的数字。我们的假设很可能是错误的。所以我们需要
要遍历此列表，我们需要遍历它，获取
每个项目，并将其与最高如果大于Max，则
我们需要将max重置为该数字。所以在第一次迭代中我们得到
3，最大值也为3。大于3
3.不，我们继续，我们得到第二个数字，是
6，大于3？是的，所以我们需要重置最大
到6。再一次，我们继续得到2，这两个更大
大于6，不，不是，所以我们继续，然后得到8
8大于6？是的，所以我们应该将max重置为8。
那很容易。所以在这里我们需要一个for循环
数字冒号
现在我们太想知道这个数字是否大于最大值，
因此，如果number大于max，
最大冒号，那么我们需要重置最大，所以最大
到这个新数字，这就是我们要做的。
因此，让我们打印max，然后运行
程序，我们可以看到此列表中最大的数字是10。
这个数字是列表的末尾还是开头都没有关系。
所以如果我移动10并把它放在开头
我们仍然应该看到相同的结果。让我们运行程序，
我们仍然看到10，如果我把它放在中间，
程序仍然可以正常工作。让我们把它放在2之后。
运行程序，我们仍然得到10。
在本教程中，我将与大家讨论二维
在python中列出。二维列表功能非常强大，并且有很多功能
在数据科学和机器学习中的应用。这是
例如，在数学中，我们有一个叫做矩阵的概念，就像
一个矩形的数字数组，让我告诉你。因此
我们有1、2、3、4、5、6、7、8、9。
因此，我们有一个矩形的数字数组。你有排
和列。所以这是一个3 x 3的矩阵
在数学上。现在我们可以使用
二维列表。二维列表是一个列表，其中
该列表中的每个项目都是另一个列表。因此，
您想定义一个矩阵。我们将其设置为列表，每个
此列表中的项目将是另一个列表，该列表表示
每行中的项目。所以，第一个
我们列表中的项目将是另一个列表，而在另一个列表中，我们将拥有
值1、2和3。现在是第二个
矩阵列表中的项目，我们又有一个列表，
此列表表示第二行中的项目。因此，
4、5和6，最后是7、8
9.因此，您可以看到我们有一个二维列表
我们外部列表中的每个项目都是另一个列表。
好吗因此，这就是我们如何在
python，现在可以访问矩阵中的单个项目，
再次使用方括号，让我删除这些内容，
好了，那么我们如何在这里访问1
好吧，您从我们的列表开始，然后我们添加正方形
首先要放在方括号中，然后获得此列表中的第一项。
对不对所以我们传递0，现在这个表达式
返回另一个列表。那是内部列表。在这个清单中
假设您要访问第二个项目，
再次添加方括号，然后传递1，
是此列表中2的索引，好的。
所以如果我们在终端上打印
我们得到2。好吗？因此，使用2个方括号
我们可以访问矩阵中的各个项目，并且
我们也可以使用这种语法修改这些值，因此，
在打印之前，让我们将其更改为20，这样矩阵
0和1，我们将其更改为20，
然后将其打印出来，然后进行修改，现在在这里
也可以使用嵌套循环遍历所有项目
在这个矩阵中。让我告诉你。因此，
我们从矩阵中的行开始，
所以通过这个循环，我们迭代了矩阵
列表，在每个迭代行中将包含1
清单，1件，好吗？现在，在这里我们需要
使用内部循环。所以我们需要遍历这一行
这是项目列表。我们可以输入4
行冒号并打印项目
项目。好吗因此，让我们运行该程序，
到那里，我们得到所有物品
在我们的清单中。嘿，我只是
想要快速宣布。如果您还没有看到我的网站，请访问codewithmosh.com
这是我的编码学校，在那里您可以找到很多课程
网络和移动应用程序开发。事实上，最近我发布了
全面的python课程，超越了这些初学者
youtube。如果您认真学习python和找到工作，我强烈建议您
您可以参加本课程。就像本教程一样，您可以随时观看，
您可以随时随地进行多次，而且还会收到证书
完成后，您可以将其添加到简历中，该课程为期30天
退款保证，因此，如果您不满意，我们将退还您所有的钱，
没问题问。这门课程的价格是149美元，但是
前200名学生只需15美元就可以得到它。因此，如果您有兴趣，
该链接位于该视频下方，请单击该链接，然后开始使用。
在本教程中，我是
将与大家讨论list方法或list函数。这些是
我们可以在列表中执行的操作。所以我们来定义
数字列表，在这里我们传递了一堆随机数，例如
5、2、1、7和
4.现在，我们可以使用此列表做很多事情，我们可以
向其中添加新项目，我们可以删除现有项目，我们可以检查项目是否存在
这些是我们可以对列表执行的操作。因此，
我们键入数字，我们可以看到所有这些功能或更准确
列表对象中可用的方法。
因此，我们可以调用append方法将一个新项目添加到此列表中。比方说
13.实际上，不是一个好数字。
我在开玩笑我不是迷信，所以我们加20
没关系，然后打印我们的列表
当我们运行该程序时，我们可以看到此列表的末尾添加了20
但是如果您想在中间或开头添加数字
我们名单上的？为此，我们使用了另一种方法，即
插入。所以，现在插入此方法
取两个值，让我告诉你。所以当我们打开括号
看看insert方法上方的这个小技巧。
您会看到我们需要在此处传递的第一个值是索引，因此
这是我们要插入此新项目的索引。让我们
说我们想在列表的开头添加一个项目，因此我们通过了索引位置
的0，然后第二个值是实际
我们要添加到此列表的对象。假设我们要加10
现在，当我们打印此列表时，您可以看到
数字10放在列表的开头，
所有其他项目都被推到右边。我们也可以删除一个项目
我们称之为删除并传递
我们要删除5.现在
打印我们的列表，所以我们看到5消失了，我们有
2、1、7、4。如果要删除列表中的所有项目，可以致电
清除方法，所以清除
该方法没有任何值，因此，我们只需
调用它会清空我们的列表，所有项目都将被删除。
我们还有另一种有用的方法，称为“跃点”
这样我们就可以删除列表中的最后一项。
让我告诉你。这样，我们运行我们的程序，您可以看到数字4
已从我们列表的末尾删除。现在，如果你想
检查列表中是否存在某个项目，可以调用index方法。
因此，我们调用index并在此处传递一个值，例如5
这将返回第一个的索引
该项目的出现。因此，让我们在终端上打印它。
我们不再需要此行。所以
5的索引是0。如果传递不存在的数字怎么办
在这个清单中？比方说50？运行程序，
我们得到一个错误。我们收到一个值错误。 50不是
在列表中。还有另一种检查项目是否存在的方法，
我们可以使用in运算符。所以，让我告诉你
我们输入15个数字
前面我们使用in操作符和一个字符串，我们
检查字符串中是否存在字符或字符序列，
现在在这里，我们要检查数字列表中是否存在50，所以
让我们打印出来，我们得到一个布尔值，
错误，因此与索引方法不同，此表达式
不会产生错误，因此使用此方法更安全。我们还有另一个
计算项目出现次数的方法，假设我们有
这里还有另外5个。
现在我们可以拨打number.count并传递5
这应该返回2，因为此列表中有2个5。
看一下你去。那很有用
现在，如果您想对列表进行排序，则可以调用sort方法。因此，
我们在这里称为sort方法，该方法没有任何值，
看他的返回值，就是没有，没有
是python中的一个对象，表示不存在值。
所以这种排序方法实际上并没有返回任何值，它只是对它进行排序
列表，所以不用打印返回值
通常使用他的方法，我们只需调用它即可对列表进行排序
然后打印我们的列表。看一下
现在，所有项目都按升序分类。我们也可以
按降序对项目进行排序，因此在对列表进行排序之后
我们可以调用反向方法。我们可以简单地反转
我们的清单。现在，让我们继续运行我们的程序，看一看。
我们的数字按降序排列。
我想在这里向您展示非常有用的最后一种方法是复制
方法。因此，使用此方法可以复制
我们的清单中。因此，让我们定义另一个称为数字2的变量
现在数字2是我们原始列表的副本。即使
您对我们的原始列表进行了任何更改，如果您添加了新项目，如果您删除了
现有项目，这些操作不会影响我们的第二个列表。
让我告诉你。因此，在向您显示我们的号码清单副本之后
让我们向此列表中添加一个新项目，即numbers.apphend
十。因此，第一个列表已更新，所以现在我们有一个
列表中的新项目，然后打印第二个列表。
看一下，我们这里没有数字10，因为这些是
2个独立列表。这些都是操作
我们可以在列表上执行。我们可以将新项目添加到列表中，我们可以
删除exxisitn项目，我们可以检查项目是否存在，可以进行排序
我们的列表，然后复制它们。现在是本教程的练习，
我希望您编写一个程序，以删除列表中的重复项。
同样，这是一个很棒的练习。所以花一些时间，然后
回来继续观看。
好吧，假设我们有一个数字列表
一堆重复。所以2 2 4 6
6，3，4，6，1.我们要删除
重复项。所以我们需要定义另一个列表
让我们称之为新列表。最初我们
将其设置为空列表。然后我们需要迭代
我们的第一个列表，获取每个项目，如果我们没有那个数字
在此Unix列表中，然后将其添加到第二个列表中。
就这么简单。所以，对于数字
在数量上，现在我们需要检查是否
在第二个列表中有此号码。所以我们用
操作员。如果没有
单位
因此，如果我们在此单位列表中没有运算符，
那么我们需要添加它，所以添加单位。
知道数字，这就是我们要做的。
所以，让我们继续打印单元列表
你去。所以你有2、4
6、3和1。将删除重复项。
在本教程中，我将与大家讨论另一个重要的结构。
在Python中称为tuple。元组类似于列表
因此我们可以使用它们来存储项目列表。但是与列表不同，我们可以
不修改它们，我们不能添加新项目，我们不能删除现有项目，我们
元组是不可变的。我们无法对其进行突变或更改。因此
让我告诉你。因此，我将从定义数字列表开始，
1、2、3、4，因此我们使用方括号来定义列表和
用圆括号定义元组，因此如果将其更改为
括号1、2、3。现在我们有一个
元组。因此，如果我们键入数字。
看这里，我们没有append或insert方法，因此我们无法向该元组添加新项目。
我们也没有删除清除和弹出按钮，我们不能
在此处删除其中任何一项。我们只有两种方法，计数，
和索引。我们使用count来计数一个项目中的出现次数，
和索引，以找到第一个出现的索引，
一个项目。因此，我们只能获取有关元组的信息，而不能进行更改。
顺便说一下，您在这里看到的其他方法
有两个下划线，我们将其称为魔术方法，它们更像是一种高级方法
因此，它们超出了本教程的范围。如果你有兴趣
学习回合他们。您可以获取我的python课程，我已经详细介绍了它们。
与清单类似，您可以使用
方括号，所以我们可以得到这样的第一项，然后
打印另一个终端，然后走，第一个项目是1，
但是，如果您尝试更改第一项，则会收到错误消息，因此，
数字0，我们将其设置为10并运行程序
你去。我们收到此类型错误，因为元组对象
不支持项目分配。所以我们不能
更改或更改元组，它们是不可变的。现在实际上
讲，大多数时候您将使用列表，但是元组也
有用的。如果要创建项目列表并确保
没有程序中您不小心修改该列表的位置，那么最好是
使用元组，
在本教程中，我将向您展示功能强大的
我们在python中拥有的功能称为拆包。
因此，让我们找到一个称为坐标的元组
我们在这里传递3个值1、2、3
xy和z的坐标。现在说
我们想要获取这些值并在一些表达式中使用它们
程序中的表达式。也许我们想将它们作为大项目的一部分
复杂的公式。因此，我们必须一起编写这样的代码，
坐标为0，那么我们要乘以
乘以1的坐标，然后乘以坐标
/ 2，我们的代码变得有点太长了，这仅仅是
一个非常简单的例子。但是，假设我们要在很多地方使用这些值
在我们的程序中，更好的方法是获取这些值
并将它们存储在单独的变量中，如我们可以
坐标为0，并将其存储在x中，则可以
获得1的坐标并将其存储在y中。
同样，我们得到2的坐标
然后将其存储在z中。现在我们开始重复
2或0的坐标多次，我们可以简单地使用这些
变量，x y y z。
对不对到目前为止，没有什么新鲜事物。但是在Python中，我们拥有强大的功能
称为拆包的功能，通过该功能我们可以实现
具有更少代码的相同结果。所以我们可以定义我们的变量
x，y和z。并将它们设置为我们的
元组。我们在第6行上拥有的正是
等同于第2-4行的内容。
因此，这是获得相同结果的简写。
因此，让我删除它并解释该代码如何工作。
当Python解释器看到此语句时，它将获得
该元组的第一项并将其分配给
变量。然后它将获得该元组中的第二项，然后
同样，我们获得该元组中的第三项并将其分配给
我们在这里拥有的第三个变量，所以我们要拆包
该元组分为3个变量。现在，如果我们
打印x您可以看到x
是1，类似地y是2，那么你去了。
所以这是开箱。顺便说一句，这不是
仅限于元组，我们也可以将此功能用于列表。因此，
如果我将括号改为方括号，现在
坐标是一个列表，因此我们可以将列表拆成3个变量
现在我们运行程序，我们可以看到y为2。
在本教程中，我将与您讨论字典
在python中。我们在需要的情况下使用字典
存储作为键值对提供的信息。这是
一个例子。想一想客户。客户有很多属性
如姓名，电子邮件，电话号码，地址
等等。现在，每个属性都有一个值。
例如，名称可以是乔恩·史密斯，电子邮件可以是
jon @ gmail.com电话可以是whatevr
所以我们这里是一堆关键值对。所以在这个
例如，我们的密钥是姓名，电子邮件和电话，
每个键都有一个值这就是我们使用的地方
一本字典。使用字典，我们可以存储一堆键值对。
因此，让我向您展示如何在python中定义字典。
回到我们的程序，我将定义一个变量，客户，
在这里，我们将其设置为花括号。有了这些花括号，我们可以
定义字典。在此示例中，我们有一个空字典，其中没有
任何键值对。现在我们可以添加一个或多个密钥
花括号之间的值对。所以我们
在此处添加一个键值对，我将把键设置为一个名称，然后
值给约翰·史密斯（John Smith），然后添加一个逗号，
添加另一个键值对。因此，我们将年龄设置为
30让我们添加另一个键值对是
下划线已验证，我们将其设置为布尔值。
现在重要的是这些键应该是
独特的因此，如果我在此处添加另一个键值对，
将年龄设置为40，现在看起来pycharm
突出显示了年龄密钥，因为我们已经复制了该密钥，并且
那是不允许的。因此，每个键在字典中应该是唯一的，就像
在现实世界中的字典，在真正的字典中，我们有一堆单词
并且它们定义了每个单词在词典中只列出一次。
我们没有两次单词本。所以我们删除第二个
重复的键值对，因此键应该是唯一的，
在这个例子中，我使用的是字符串，但是它们也可以是
数字，我们稍后再讨论，但是值可以是任何值，可以是
字符串，数字，布尔值，列表等等。
现在我们可以访问该词典中的每个项目
使用方括号。因此，我们键入客户，
方括号，然后指定名称之类的键
这将返回与
名称键。让我们在终端上打印一下，看看
你去了，所以，名字叫约翰·史密斯，现在
如果我们传递了一个不存在的密钥，该怎么办，比如说第一次约会。
您运行该程序，会遇到一个关键错误，因为我们没有
一个称为出生日期的密钥。另外，如果我们拼写
用一个大写的N作为名字，我们得到相同的
错误，因为我们没有键的序列完全相同
这本词典中的字符。现在解决这个问题，我们可以
使用get方法，而不是使用方括号
我们调用get方法并指定密钥
现在，如果您使用此处不存在的钥匙，它不会对我们大喊大叫。例如
如果您通过生日
它只是返回非值。之前我告诉你，没有东西是物体
表示没有值。因此
除了得到关键错误，我们什么也没有，我们还可以选择
提供默认值，例如，如果此词典没有此值
键，我们可以提供默认值，例如
1980年1月1日。运行程序
现在我们得到这个默认值，而不是一无所获。
因此，这就是我们可以访问与键关联的值的方法
在字典中。例如，我们也可以更新这些值
在打印声明之前，我们可以编写如下代码，
名称，让我们将名称更新为jack
史密斯，现在这个小警告告诉我们在这里我们可以放江淮
史密斯在这里，而不是一次定义，然后更新
那个不用担心它们，这并不重要。现在，如果这条线
我们会打印此客户的姓名，我们应该看到杰克·史密斯，让我告诉你。
所以，我将再次使用方括号符号，让我们打印
您可以看到的客户名称已在此处更新，
我们还可以在此处添加新密钥，让我们设置
生日，如一月初
1980。然后我们可以在这里打印
如您所见，我们可以轻松添加新的键值对
到字典。这是使用字典的基础
在python中。它们非常重要，并且在实际应用中有很多应用
全球。好的，这是一个练习。所以我们有
这个程序询问我们的电话号码。让我们输入1
234.我们用数字键入它，然后它将翻译
用言语来看一下。输入，它会打印1、2、3，
4.这是一个很酷的程序，所以继续
花几分钟时间做这个练习，很简单，我会见到你
下一个
好了，所以首先我们需要获取用户的电话号码，我们调用输入功能
使用标有phone的电话，我们得到结果并将其存储
在这个变量中，假设用户输入123
4.因此，我们需要浏览该字符串，获取每个字符并
将其转换为一个世界，因此我们需要实现此方案。
是字典，因为字典是一种结构，可以让我们
值的关键。所以我们可以有一个带钥匙的字典
像1234。并且我们映射每个键
一句话。所以我们不能将数字1放在
我们可以映射的单词1
到两个，您就明白了。所以我们来定义
一本字典，您可以称其为数字，下划线映射
现在，我将在字典中添加一些键值对。
一，我们将其映射到1，2，我们
到2、3、3
最后是4到4。现在从技术上讲，我们应该
将0到9之间的所有数字相加，但我不想浪费所有时间
在这里输入重复的内容，您就明白了。因此，让我们继续前进，
现在我们需要查看电话字符串。因此
电话中有4个字符，每个字符
字符，然后使用它来访问一个键值对
字典。因此，数字下划线映射
我们可以使用方括号或调用get方法，
我更喜欢使用get方法，以便在用户输入某些字符的情况下
那不是我们字典的一部分，我们的程序不会对他们大喊大叫。
因此，我们调用gt方法并传递此字符
一个钥匙，如果我们没有这个钥匙，我们可以提供
默认值，例如感叹号，因此我们得到一个字
现在我们需要将此单词添加到输出字符串中，以便我们可以定义
输出字符串，最初我们将其设置为空字符串，
在每次迭代中，我们都将其添加到输出字符串中。
因此，我们输入输出，加上等于。
这，我们还应该添加一个
获得的空间。所以这两个词彼此不接近，好吗？
这就是我们要做的。现在终于让我们打印
此输出，运行我们的程序，所以我想
类型1、3、4、5，
看看我们得到什么。我们得到1、3、4的称赞
马克
在本教程中，我将向您展示一些非常酷的东西
您可以使用字典来完成，因此在此程序中，您可以输入
像早安的信息，然后是笑脸，
当我们按Enter键时，我们会得到一张美丽的笑脸，或者
我们可以输入我很悲伤，带有悲伤的笑脸
它被翻译成这个美丽的表情符号。
所以这是另一个应用程序，如果使用字典，我们有一个字典
将这些角色映射成笑脸。
因此，让我们一起构建该程序，我们首先
调用输入函数，这里我们传递一个大于号
作为用户输入消息的指示，我们给该消息存储
如您所知，它是一个字符串，现在我们需要
用空格分隔此字符串，因此如果用户键入
早上好，笑脸，我们想把它分解成
3个字，早上好，笑脸。
为此，我们可以调用split方法。所以我们打电话
message.split和通过
一个以一个空格作为分隔符的字符串。这个方法什么
基本上是通过该字符串以及任何找到此字符串的地方
字符，在这种情况下是空格，它将其用作边界
将此字符串分成多个单词。然后它将返回
清单。让我告诉你。因此，让我们将其存储在这里，然后再说
然后在终端上打印
让我们继续运行我们的程序。所以如果你早上好
阳光，输入，我们得到包含三个项目的列表
每个项目都是一个字符串，好吗？现在，
回到我们的程序，我们需要定义一个字典来映射特殊字符
像这两个变成笑脸，所以，
我们可以称之为表情符号
将其设置为花括号，这里我们添加一个键值对，
一张笑脸，我们将其映射到字符串，
在此字符串中，我们要添加表情符号，如果您使用的是Mac键盘，则可以按
控制命令和空间，这应该引起
这个表情符号框，如果您确实是在Windows上，我
真的不知道如何做到这一点，但是必须有一些应用程序为您做到这一点。所以放手
向前挑一张幸福的笑脸，好，
现在让我们添加另一个键值对或悲伤的面孔
我们将此映射到
这张脸在这里，很好。所以，我们
现在有一个单词列表，我们需要浏览这个列表，获取
每个单词，并可能将其映射到表情符号。
因此我们可以为单词中的单词编写一个for循环，
现在我们要去字典，看看您是否有与此相关的物品
单词作为关键。如果您有带有该钥匙的物品，我们会得到
它的价值，否则我们想使用相同的词。因此，如果用户输入
早上好，我们不想翻译这些单词，我们只想返回那些单词。这样的话
我们使用get方法提供默认值
价值，所以我们希望得到一个带有关键词的物品，并且
如果我们没有带有该钥匙的物品，我们只需将该词用作
默认值。现在类似于我们在上一个教程中所做的练习
我们需要一个输出变量。所以我们在这里定义
输出将其设置为空字符串，现在返回到行
9，我们得到get方法的返回值，
并将其添加到我们的输出变量中。所以输出
加等于我们从get方法得到的结果，最后
我们需要在末尾添加一个空格。
就是这样，我们完成了。所以我们打印输出
并运行我们的程序，我要输入早上好
阳光带着笑脸，我们明白了
美丽，让我们也尝试悲伤的脸，我很悲伤。
太可惜了好漂亮如您所见
字典在实际应用中有很多用例。
这是上一个教程中创建表情符号的解决方案
转换器。到目前为止，我们已经在这里编写了所有代码，
在app中，py，但是随着程序的发展，我们需要一种更好的方式来组织代码。
我们需要将代码分解为更小，更易管理的代码
还有更多可维护的块，我们称之为函数。所以功能
是执行特定代码的几行代码的容器
例如，您已经了解了以下任务中的一些内置函数
python就像print和input一样，其中每个函数
有目标，他们知道如何执行特定任务。所以当我们
构建大型复杂程序，我们应该将代码分解为更小的代码
可重用的块，我们称之为函数，以更好地组织代码。
这就是我将在本教程中向您展示的内容。所以让我们写这个简单
程序，用于打印问候消息。因此，我们将进行打印，
您好，让我们添加另一条消息
欢迎登船。所以这里有一个简单的
程序只有两行代码。现在说这两行
具体来说，我们将在其他程序中需要它们，因此我们可以将它们放在一个函数中，
我们可以重复使用。让我告诉你如何做，所以，
我们开始输入死亡，这是
Python，它是定义的缩写。当Python解释器看到它时
知道我们正在定义一个函数，接下来我们需要提供函数
一个名字，比如说greet_user。
因此，您了解的有关命名变量的所有最佳做法也适用于此，
这意味着我们应该用小写字母命名函数
如果有多个单词，我们需要使用下划线将它们分开
而且你应该永远，永远，永远使用有意义的
功能的描述性名称。所以，在这里我们定义一个函数
称为“问候用户”，之后我们需要添加括号
其次是冒号。现在您知道，只要我们在行尾添加冒号
我们告诉python我们正在定义代码块。所以当我们
按Enter，下一行缩进。现在我们在这里写的任何代码
将属于此功能。所以我要移动这两行
函数中的这两个print语句。你可以简单地
按Tab使其缩进，美观，也可以删除
这个额外的换行符，更好，所以这两行
现在是我们问候用户功能的一部分，所以无论何时我们
调用此函数，将执行这两行。好吗现在，
让我们删除缩进，以便我们不在功能范围内，
让我们做一个打印语句并开始打印
之后，让我们调用函数，向用户打招呼。
最后，让我们做另一个create语句并打印
完成。现在我们在这里有这个小警告
下划线，如果您将鼠标悬停在此行上，则此工具会告诉您
我们应该在函数定义之后添加两个空行。这是来自
pep8，它是定义最佳实践的文档
格式化我们的代码。以后我们会讨论。所以现在做pycharm
高兴，让我们为此功能添加一个额外的换行符
因此，每当定义函数时，都需要在其后添加两个换行符。
好吗因此，现在让我们运行我们的程序，看看会发生什么。
好了，所以我们在终端上有4条消息
首先我们得到开始消息，然后我们得到消息
来自我们的create函数，因此欢迎加入，最后我们看到
完成的消息。所以让我解释一下我们程序的流程
当python运行此代码时，它实际上不会打印这些
终端上的两条消息，因为这两行代码都在里面
这个函数，所以只有在我们调用时，它们才会被执行
此功能。如果我们不调用此函数，则不会执行这些行。
好吗因此，我们的程序实际上是从这里开始执行的
我们在终端上看到的第一条消息是开始消息。之后
Python看到我们正在调用greet函数，所以
它将跳过这里，然后执行这两行。
然后，它将跳出此功能并继续正常
执行我们的程序，以便它将在终端上显示完成消息。
这就是函数的工作方式。另请注意，此顺序
代码很重要，因此我们在此之后调用greet函数
在定义好之后。如果在定义前尝试调用它，将会看到错误。
例如，如果我们打招呼
用户功能在这里，看到我们立即得到这个红色下划线
说未解决的参考，基本上向用户打招呼
意味着python不知道这个问候用户是什么，它在任何地方都没有定义。
因此，我们总是先定义函数，然后定义
给他们打电话。
这是我们在上一个教程中创建的函数
现在我有一个问题要问您，
调用此功能和python的打印功能？区别
在这种情况下，打印功能需要一些信息
我们要打印的消息，但是我们的问候功能没有
任何信息。如果您可以在此处传递用户名，那会不会更好
不用在那打招呼，您可以打印用户名。因此，
在本教程中，我将向您展示如何将信息传递给函数，以及
这很容易，所以回到我们的定义
用户功能，在这些括号内，我们可以添加参数
这些参数是用于接收信息的空白。
例如，您可以添加名称参数，然后我们可以传递
调用此函数时的用户名。让我们通过乔恩
在这里，现在当我们调用此函数并传递此值时
此名称参数将设置为Jon。所以呢
将像我们在此函数内部定义的局部变量一样起作用。
试想一下，我们没有此参数，而是
像name这样的变量被设置为跳转。现在在这里我们可以简单地
打印此用户的名称，因此我们可以使用格式化的字符串，
并打印name变量的值，对吗？现在，
我们实际上没有在此函数中定义此局部变量
我们有一个参数，这是完全一样的。因此
使用这些参数，我们可以在函数中接收信息。现在开始吧
运行此程序，所以看看。
嗨，约翰受到欢迎，我们可以将它带到下一个
水平。现在我们可以再调用一次此函数。因此
向用户打招呼，这次提供了另一个名称。假设玛丽。
因此，我们正在重用greet函数并将其传递给其他函数
价值。想象一下，如果我们没有此功能，您将不得不
重复此行两次，一次用于嗨乔恩，另一次用于嗨玛丽。
这就是定义函数的好处，我们可以采取一些措施
具有特定目的的代码行，并将其放入
功能，所以现在让我们再运行一​​次程序
你去。这样您就可以找到工作，欢迎您上车，然后您就可以好玛丽
欢迎登船。现在请注意，当函数具有参数时
我们有义务传递该参数的值。
因此，如果您从此处删除jon并运行
我们的程序中，出现此类型错误，欢迎用户，
缺少一个必需的位置参数。
编程中的参数是我们提供给函数的值，因此
回到这个例子，嫁给这种情况是
我们传递给name参数的参数。还有很多
程序员不知道参数和参数之间的区别，并认为它们是相同的。
但是它们不是，参数是孔或占位符
我们在接收信息的功能中定义的
参数是我们提供给这些函数的实际信息。
好吗所以，让我们带回来
这个乔恩字符串，现在我们也可以定义多个
参数，例如，让我将这个参数重命名为名字
您之前，可以右键单击此处，进行重构，然后
重命名，或者最好使用快捷方式。所以捷径
在Mac上，这是shift和f6。
这会弹出重命名的拨号框，在这里我们可以将其更改为first
下划线名称。现在我们可以添加第二个参数
因此逗号后跟最后一个下划线名称
回到我们格式化的字符串，让我们也打印
姓氏，漂亮，所以在这里调用此函数时，
那么我们可以提供另一个论点，所以乔恩
史密斯，让我们删除此行，我们不再需要它了
运行我们的程序，看看吧，乔恩·史密斯，
因此，在上一教程中，您了解到
我们为我们的功能定义参数，我们应该始终提供
值，否则我们将得到一个错误。让我们再来看一次该错误。
因此，在删除第二个参数时仅传递了jon。
运行我们的程序，我们收到此消息，
问候用户缺少一个必需的位置
论点。所以你在这里像乔恩这样的论点
和史密斯，您将这些称为位置参数。
这意味着他们的立场或论点很重要。在其他
字，我们在这里添加的第一个参数是值或第一个参数
第二个参数是第二个参数的值。
因此，如果您更改其仓位或订单，我们将获得不同的结果。
让我们来看看。让我们先通过史密斯，然后再通过
乔恩好吧，好，删除，现在让我们
这样做，而不是让Hi Jon Smith，
我们打招呼史密斯·乔恩。这就是我们提到的原因
这些参数作为位置参数，它们的位置或
顺序很重要。但是在python中，我们也有关键字参数，并且
与那些位置无关紧要。让我告诉你它们是如何工作的。因此，
假设在这里您要传递Jon作为第一个的值
名称参数。我们可以在这里简单地指定。所以名字
等于乔恩。现在，我们这里有了一个关键字参数。
关键字参数。因此，具有参数名称的组合
紧随其后的是我们称为关键字参数的值，以及此关键字得到的值
论据立场并不重要。所以我们在这里提供
乔恩作为第一个参数的论点。现在类似
我们可以为史密斯使用关键字参数，所以最后
名字等于史密斯，所以我们有2
关键字参数。因此，有了这些关键字参数，我们不必担心
参数的顺序。现在，这并不意味着我们应该始终使用关键字参数。
不完全是大多数时候，我们使用位置参数，但是
在某些情况下，这些促使我们前进的关键字参数会有所改善
我们代码的可读性。所以在第7行上很清楚
我们提供史密斯作为姓氏和乔恩
作为名字。现在，在这个特定示例中，即使我们没有
关键字参数，只传递两个位置参数，例如jon
和史密斯就足够了，因为很容易猜到
这些论点的目的是什么。但是有时候你在处理函数
在这种情况下，您将数值传递给它们
这些值代表什么可能还不清楚。让我给你看一个例子。
假设我们有一个用于计算订单总成本的函数，
所以我们仍然称其为计算成本，强调成本，
因此，在调用此函数时，您需要提供三条信息。
一是所有订单商品的总成本，例如50
美元。另一个是运输成本，比方说
5美元，最后一块是折扣，假设0，
.1。有人在阅读此代码，可能不确定
这三个值代表什么，在这种情况下，我们可以改善
通过使用关键字参数，此代码的可读性。这样我们可以
在每个值前面加上它们所针对的参数名称，例如，
我们可以将总数设置为50，然后
运费至5，然后折扣至0,1。
现在，如果您将此代码提供给其他人，他们
可以立即知道这些值代表什么。这就是力量
关键字参数。所以这就是我要你带走的东西。
在大多数情况下，请使用位置参数，但如果要处理
带有数值的函数，看看是否可以改善
通过使用关键字参数来提高代码的可读性。你只是
给您传递的参数加上参数名称的前缀，这将
提高代码的可读性。现在，您还需要了解一件事
关键字参数。这些关键字参数应始终放在后面
位置参数。让我告诉你我的意思。因此，
回到简单的问候用户函数，让我们使用关键字参数
首先。所以，让我们开始
给乔恩一个名字，看看会发生什么。因此，我们立即收到此错误，
关键字参数之后的位置参数。
因此，在调用此函数时，我们将提供一个关键字参数
和一个位置参数，而python不喜欢这样。因此，
如果您要混合使用位置参数和关键字参数，则应始终使用
然后是关键字参数。
换句话说，让我们在此处删除此关键字参数，
所以乔恩现在是一个位置论点，针对第一个
参数。现在，在这个位置论点之后，我们可以
提供任意数量的关键字参数，因此，如果您将姓氏设置为史密斯
看起来，python对此没有任何问题，因为我们正在添加
位置参数后的关键字参数。
因此，让我们快速回顾一下，大部分情况下使用位置参数
如果您要处理带有多个数值的函数
还不清楚这些值代表什么，请使用关键字参数
以提高代码的可读性，最后
您同时传递位置参数和关键字参数，请使用
在位置参数之后的关键字参数。
到目前为止，您已经了解了如何创建函数并使用以下方法发送信息
它们的参数在本教程中，我将向您展示如何创建返回的函数
值，如果您正在做某种
计算您的函数，并且您想将结果返回给使用您的函数的任何人
功能。让我告诉你。因此，我们先定义一个
函数，称为平方，该函数仅计算
数字的平方。因此，我们需要在此处添加一个参数，
那是我们的数字，现在我们要计算数字
乘以数字，即数字的平方。
现在，要在此函数之外返回此颜色，我们只需
使用return语句。所以回来。现在，
我们的平方函数非常简单，它只有一行代码。
但是在实际程序中，您可能有一个包含十行代码的函数来计算
有事因此，此return语句非常
有价值的。现在，我们可以将值返回给函数的调用者。
因此，当我们调用平方函数时，
假设我们给它3，现在此函数返回一个值，
就像python的输入函数一样，这个输入函数
等待用户键入内容并按Enter，然后它将
以字符串形式返回用户的输入，以便我们获取它
并将其存储在这样的变量中，对吗？我们有同样的故事
故事，具有我们的平方功能。所以我们的平方函数返回值
我们可以简单地获取它并将其存储在变量中。叫那个
结果。现在，我们可以打印
结果在终端上，你去了，所以结果是9
我们也可以传递这个函数
直接在打印功能内部，而无需定义单独的变量。
有时，这对于编写较短的代码很有用，因此在这种情况下。
因此，在这种情况下，我们实际上不需要此结果变量。我们只想打印
3的平方。因此，我们可以简单地传递此函数
在这里打电话，作为打印的参数
功能。现在让我们删除此变量
更短，因此我们调用平方函数，这将返回一个
值，我们会将其作为参数传递给打印功能。
好吗当我们运行该程序时，我们得到的结果完全相同
结果。你去。现在，如果我们不这样做会发生什么
在我们的函数中使用return语句。所以在上一个示例中，我们只是使用了
打印声明。让我们暂时删除
此return语句并打印结果
在终端上。像这样所以让我们运行程序
再有一段时间，看看我们得到了什么。我们看到两件事，数字
9，没有。这是怎么回事好吧
当Python解释器执行此代码时，首先它将调用
平方函数。所以控制移到平方函数
在这里，我们计算给定数字的平方，然后打印出来
在终端上。这就是我们在这里看到9的原因，
现在，默认情况下，所有函数均返回该值
没有所以如果我们没有退货声明
在这里，默认情况下python不返回任何内容。无
是一个代表缺少值的对象，就像什么都没有
或null ic，c ++ java和Javascript。
因此，在此示例中，我们没有return语句，并且
默认情况下，python从此函数不返回任何内容。
因此，执行此平方函数后，值none
返回并作为打印函数的参数传递，这就是原因
我们在第二行上看不到任何内容。所以这是两件事
您需要阅读本教程。默认情况下，Python中的所有功能
不返回。您可以更改它，所以如果您有一个功能可以
计算某些东西，您可以使用return语句返回结果。
这是我们先前编写的表情符号转换器程序的代码。
如果您错过了该教程，请确保返回并观看它，因为
我之前曾告诉过您，该视频下方的内容表
说明。因此，我们只需单击emoji转换器教程即可观看。
现在，您的练习是使用一个函数重新组织此代码。
所以我希望您在这段代码中提取一个函数，因为这种算法
可以将这些笑脸转换为表情符号
我们可能想在几个不同的应用程序中使用。我们可以在聊天中使用它
电子邮件应用程序中的应用程序等。我们不想每次都写所有这些代码
我们希望将这些字符转换为笑脸。
因此，在从第1行到第3行的所有这些代码行中
第10行，第10-2行属于我们
算法，所有这些行一起实现此功能。
因此，您应该将这些行放在单独的函数中，
现在，为什么我们没有此功能的输入？因为
输入将以不同的形式出现，当前我们正在使用导入功能
从终端接收输入，但在其他应用程序中
我们可能会从图形用户界面接收输入，因此输入可以输入
不同的形式。我们不想将其放在函数中，因为该行将不可重用。
您想给我们的功能实际的信息，
作为字符串。我们不在乎我们如何收到该消息。合而为一
程序，您可能会从终端获得它，在另一个程序中，您可能会从终端获得它
图形用户界面。因此，这就是此排队代码不应
在那个功能。通过相同的功能，您不应包含
该函数的最后一行，因为我们对输出所做的与
一个程序到另一个。在此程序中，我们正在打印输出
在另一个程序中，您可以将输出作为电子邮件或作为响应发送给
聊天应用程序，因此一般而言，您应该发挥作用
不用担心收到输入
打印它。这些代码行不应属于您的功能。所以去
并通过提取函数来重新组织此代码。
好的，首先，我们需要定义函数。首先我们输入
def，给我们的函数起一个名字emoji_
转换器，所以此函数的名称清楚地告诉我什么
是的，是的。每个功能应仅负责一项任务，
并且应该在函数名称中清楚地说明该任务。
因此，我们的表情符号转换器功能应该
一个参数，我们称该消息为字符串，对吧？冒号
现在我们需要移动线
5一直到for代码块的结尾
进入函数，因此让我们选择所有这些行，您可以
在Mac上按Command和x，从此处剪切它们，或者
Windows上的控件和x，然后将其粘贴到此处，
如您所见，这些行自动缩进
因此，它们是表情符号转换器功能的一部分，如果您没有发生这种情况
计算机，请确保选择这些行并使用
标签以使其缩进。好了，这就是我们的表情符号转换器功能
漂亮现在之后
在程序的主要流程中，首先我们从用户那里获得输入
我们将其存储在此可变消息中，然后调用
表情符号转换器并传递此消息，
这个函数应该返回一个值，这就是我们用来计算的
该函数的结尾，因此在此for块之后，我们需要添加
返回语句，返回输出，
现在我们的函数返回一个值，我们可以获取并存储它
在一个单独的变量中，我们将该结果称为
然后我们可以在这里简单地打印出来，或者
我们可以使这段代码更短，我们在这里实际上不需要此代码，因此我们可以简单地
调用表情符号转换器，然后打印结果。
像这样现在这里有一个下划线，因为
正如我之前告诉您的，之后我们需要空白行
我们的功能定义。所以目前我们只有一个空白行
我们需要添加另一条黑线，好的，让我们继续，
并运行该程序，并确保一切正常
所以我要像笑脸一样打个早上好
好，让我们再运行一​​次，
为了增加好看的美丽，所以，这是
最终结果，我们定义了这个函数
表情符号转换器，此函数采用一个称为message的参数。
最后返回输出。
在本教程中，我将教你如何处理自己的错误
python程序，所以让我们从编写一个小程序开始
从终端获取用户年龄。所以我们称输入变量
输入和此处的标签，
像age一样，它返回一个字符串，因此我们需要将其传递给
结束函数并将结果存储在
一个称为年龄的变量，现在让我们打印年龄以确保您拥有
正确执行我们运行程序的所有内容，然后键入
20，这里印有20，很美，现在来看
该程序的退出代码，退出代码0表示
我们的程序成功终止，没有错误，但是如果
我们再运行一​​次该程序，而不是输入
一个数值，我们输入类似asd的值。
我们收到他的消息无效文字的值错误
用于以10为底的int。基本上，此消息告诉您
我们是这个字符串asd不包含
可以转换为整数的有效家庭电话号码。现在看看出口
该程序的代码，退出代码1表示我们的退出代码崩溃了，
所以0总是表示成功，而0之外则表示崩溃
现在，作为一名优秀的python程序员，您应该预料到这种情况。
您不想仅仅因为用户输入而让整个程序崩溃
无效的值。所以不要让程序
崩溃时，您应该处理这种情况并打印正确的错误消息，并且
这就是我将在本教程中向您展示的内容，现在我们将继续进行介绍。
看看我们得到的错误类型，值错误，
所以请记住这一点，我们将在不久后回到这一点
现在我们如何处理这些错误，在python中，我们有一个名为
尝试接受我们使用它来处理错误。
让我告诉你它是如何工作的。所以在顶部
我们输入try：现在如您所知，我们正在定义
一个代码块，所以，我将移动这两行，
在我们的try块中，因此在此处按Tab。
删除这条黑线，现在这两行是我们的一部分
尝试阻止，对不对？所以尝试后，我们键入
接受，然后我们添加错误的类型
我们的程序可能会遇到的，那就是值错误
好吗然后，我们添加一个冒号，并且在此块中，我们可以
定义如果我们的程序遇到该怎么办
类型值错误的错误。在这种情况下，我们要打印
正确的错误消息，请打印，
无效值。因此，通过尝试并接受，我们正在告诉python
嘿，继续尝试运行其中一两行代码，
如果遇到，则为类型错误。值错误
然后不要崩溃程序，请在终端上尝试此错误消息
所以这是这样的现在更加精确的编程
我们将这种错误视为例外。所以一个例外
是一种导致我们程序崩溃的错误。所以我们
用户输入无效值，此行代码
第2行将引发异常，第4行将捕获异常
并打印此错误消息，因此我们的程序将不再
崩溃。让我告诉你。所以让我们继续运行
20岁，一切
就像以前一样工作，退出代码为0，让我们
重新运行该程序，然后输入asd，
因此，我们得到此正确的错误消息无效的错误菜单，然后再次
退出代码为0，这意味着我们的程序已成功完成。
没有崩溃，现在，我们还可以处理各种
错误或例外情况，例如在我们达到年龄时
让我们定义一个可变收入并将其设置为20,000。
然后定义另一个称为风险的变量并进行设置
收入除以年龄。
让我们运行该程序并输入0作为游戏，看看发生了什么。
所以0显然是一个数值
因此，当我们输入此值时，从技术上讲，我们不应获得任何例外。
看一下我们的程序崩溃了，我们
发生了0除法错误，因为我们无法将数字除以0。
再次查看退出代码，因此我们无法捕获此类错误或
这种带有接受块的异常。
接受块仅是类型值的兑现例外
错误。当我们尝试转换非数值时，就会发生这种情况，
到一个整数。所以在这样的情况下。我们应该处理
不同种类的异常，我们可以添加另一个
除了0类型异常的语句
除法错误。现在，在此块中，我们可以打印
不同的讯息，例如年龄
0.让我们再运行一​​次程序。现在，
我要输入0作为年龄，所以我们得到这个
错误消息的年龄不能为0，并查看退出代码。
它是0，所以我们的程序确实崩溃了，因此回顾一下，
使用尝试接受块来处理以下异常
在我们的程序中提出来的，作为一名优秀的程序员，您应该始终期待
这些异常，并正确处理它们。
在本教程中，我将与大家讨论python中的注释。
我们使用注释为程序添加注释或注释。
例如，在这里我要做一个打印声明，
天空是蓝色的。现在，在那之前，我
可以使用hi符号添加注释，然后在此处输入任何内容
将被忽略，将不会被执行。让我给你看
让我们运行这个程序，看起来我们只会看到这个
讯息。天空是蓝色的。因此，通过此评论，我们可以解释
关于我们的代码的某些内容，我们可以将其用作提醒以修复问题或
清除问题，或者我们可以使用它与其他开发人员进行交流
阅读我们的代码，为什么我们以某种方式编写此代码。
这些是使用注释的好用例，我们也可以
对多行有评论，因此我们可以简单地添加更多
注释，每行应以新的hi符号开头。现在
使用注释时需要避免的一件事是解释
代码。因此，这是一个不好评论的例子。
让我只删除这两行，并在此注释中
说打印天空是蓝色的。为什么一个
这是一个不好的评论，因为它告诉了我显而易见的事情，它告诉了我
这张幻灯片要打印的天空是蓝色的。现在，此评论的问题是
除了冗长和重复之外，如果您来到这里，
并改变天空为海洋，现在此评论得到
过时的。所以加班，我们更改此代码，然后我们必须返回
修改相应的注释。所以我看过一些开发人员
在功能之前添加注释，例如，他们定义
一个函数，假设一个带数字的正方形
并简单地返回数字乘以数字。
但是很明显，此函数会计算并返回
给定数字的平方。因此，实际上没有必要添加评论并
解释一下。计算并返回
一个数字的平方。这是非常重复的，它创造了
干扰代码。其他人阅读您的代码后，他们会全神贯注
这些不必要的评论，因此请使用评论解释原因和方式。
不可以，如果您做出了某些假设，我们可以使用
评论以解释这些假设。或者我们可以使用它们添加注释以提醒自己
或其他开发人员在代码中做某事。
因此，评论是好的，但过多的好事却是坏事。
在本教程中，我将与大家讨论python中的类。
类在编程中非常重要，但不是
特定于python，实际上，还有许多其他编程语言
支持类的概念。我们使用类来定义新类型。
例如，到目前为止，您已经了解了Python中的基本类型
像数字，字符串和布尔值，
这些是python中的基本或简单类型，您还可以学习
关于一些复杂的类型，例如列表和
字典。尽管这些类型非常有用，但它们不能
总是用于建模复杂的概念，例如，考虑
点或购物车的概念。购物车不是
布尔值，不是列表，不是字典，是另一种
有事因此我们可以使用类来定义新类型
模型真实的概念。现在，在这个新模型中，我将向您展示如何
定义一个称为point的新类型，该新类型将具有方法
用于积分。例如，回到我们的主程序。让我们
创建一个列表，数字，1,2,3，
您知道在这里，当我们键入该点时，
列表对象中可用的函数或方法，现在与此类似，
我们将创建一个称为point的新类型，这一点是
将具有诸如移动，绘制，获取，
到另一点的距离，这些是我们可以进行的操作
在点上执行。因此，让我向您展示如何执行此操作。
我们首先使用class关键字定义一个类，
然后，我们给班级起一个名字。现在看看
我在这里使用的命名约定。我在这里大写了第一封信，这就是我们所说的
Pascal命名约定。所以我们的命名约定
用于命名我们的类的方法不同于我们用于命名的约定
我们的变量和函数。对于变量和函数，我们始终
使用小写字母，我们使用
下划线。但是在命名类时，我们不使用下划线
分隔多个单词，而是大写
每个单词的第一个字母。所以在这种情况下，我们班只有一个
单词，如果您有多个单词，假设是电子邮件客户端
看起来我大写了第一个字母
每个字。再次，这称为Pascal命名约定
它来自您可能听说过的古老的Pascal语言。
因此，回到我们的重点课。在这里我们添加
一个冒号，这意味着我们现在要定义一个块
在此块中，我们可以定义所有属于的函数或方法
例如，我们可以定义一个名为
移动端口，现在请注意，只要我们
输入开括号，pycharm自动在此处添加自身，
这是一个特殊的关键字，我们将在不久之后再讲。
所以，现在，用这种方法，让我们打印
在终端上移动，现在让我们定义另一个
像draw这样的方法，所以定义draw
然后使用这种方法，现在在终端上打印绘图
让我们删除缩进，我们完成了
与我们的点类的定义，所以我们需要添加两个换行符
好的，所以在这个课程中，我们定义了一个新的
使用这种新类型键入我们可以创建新对象，因此
一个对象是一个类的实例，一个类只是定义
用于创建对象的蓝图或模板，以及
对象是基于该蓝图的实际实例。
因此，我们可以在屏幕上拥有数以百计的点，这些是
对象或实例。所以要创建一个对象
我们输入类的名称，然后像函数一样调用它
这将创建一个新对象，然后将其返回。这样我们就可以存储
该对象在变量中，让我们称其为1，
现在，当我们使用点运算符时，就可以了。
看，我们有这两种方法
定义，绘制和移动，我们还有很多其他方法
从两个下划线开始，这些被称为魔术方法
我们将在本课程的稍后部分讨论它们。现在，让我们调用draw方法
点对象，然后运行我们的程序
这样您就可以看到在终端上打印了抽奖。现在
除了方法之外，这些对象还可以具有属性，并且这些属性
就像属于特定对象的变量一样。例如
在我们定义好之后1。
我们可以将.1.x设置为
10.和1,1至20。
现在我们可以轻松打印出这些属性，让我们打印
.1.x并再次运行我们的程序
看一下，所以.1的x坐标是10。
现在我们可以创建另一个对象，我们称之为2。
所以。2我们再次输入名称
类，然后像函数一样调用它。现在这个物体已经完全
与第一个对象不同。所以如果你打印
2.x
看起来我们得到这个属性错误，因为这个点对象没有
属性被调用，所以每个对象都是不同的
点类的实例。现在在这里
我们可以为.2.x分配一个值。让我们
将其发送到1，然后运行我们的程序，以便我们可以看到
.2的x坐标为1。
我们使用类来定义新类型，这些类型可以具有
我们在类主体中定义的方法，它们也可以
具有可以在程序中的任何位置设置的属性。
您已经了解了如何使用类创建新类型
现在，在此实现中存在一个小问题。
我们可以创建一个没有x或y坐标的点对象
让我告诉你。所以点，我们创建这个
在这里设置对象，然后设置point.x
打印点.x运行我们的程序
我们得到这个属性错误，你
在上一教程中看到了，所以point对象没有名为x的属性
这是我们这里的问题，有可能，
具有没有x或y坐标的点对象。
这真的没有意义，因为每当我们谈论一个要点时，
我们需要知道该点的位置。为了解决这个问题，我们
使用构造函数。构造函数是一个被调用的函数
在创建对象时。所以在第9行，当创建这个
点对象，我们要传递x或y的值
坐标，比如说10和20，然后
我们到达这里的这一点对象将具有
x和y坐标已初始化。那么我们该怎么做呢？
我们需要在此类中添加一个特殊的方法，称为构造函数。
因此，在顶部，我定义了一个新函数，
看一下这个函数的名字，双下划线init，双下
得分。所以init是初始化的简称，这就是
创建新的点对象时调用的函数或方法。
现在，按Enter，这样会自动添加，
自我用括号括起来，我们将在不久后回到这个问题。
现在，在self之后，我们要添加2个额外的参数，
x和y，所以我们输入x和y
然后在此方法的主体中，我们应该读取过去的值
在这里，并使用它们来初始化我们的对象，所以当我们通过
10和20，这些参数将用于
x和y参数。现在初始化
我们的对象，我们这样输入代码。 Self.x等于
x。然后self.y等于y。
这里发生了什么，您在这里看到的这个自我是对当前事物的引用
对象。因此，回到第13行
当我们创建一个新的点对象时，自我引用该对象
内存，就是我们使用此cariable引用的对象。
所以我们之前输入point.x等于10，
通过此代码，我们设置了该点对象的x属性。
现在我们在构造函数中拥有的是完全相同的，我们使用self
引用当前对象，然后设置x属性
传递给此函数的x参数。因此，
使用此init方法，我们可以初始化对象并
我们将此方法称为构造函数，该方法用于构造
或创建一个对象，好吗？因此，
现在，我们删除第14行，因此我们创建了
点具有这些值的对象，然后打印point.x让我们运行程序
你去，x是10，我们也可以改变
这些值稍后，因此在打印point.x之前，我们可以进行设置
将point.x设置为11，然后运行我们的程序
所以x已更新，很漂亮，好的，这是一个
为你运动。我要你定义一个新的类型叫做person
这些人对象应该具有名称属性以及对话
方法。这是一个非常容易的练习，
您可能会在几分钟内解决它。
好啦
首先我们从一个类键盘开始，我们定义这个人类
再次看看我在这里使用的命名约定，第一个字母
在这种情况下，第一个单词的唯一单词是大写。
现在，在这个类中，我们定义了我们需要的所有方法，目前我们只有
方法是通话方法，因此定义通话，
pycharm自动添加自我，我们很快就会回到这个话题，
现在，让我们来谈谈。
这就是我们这个人类的主体。我们删除缩进
并在定义我们的代码后添加两个换行符
类。现在我们可以创建个人对象，我们称其为乔恩，
我们将其设置为person，我们可以调用jon。
谈谈，让我们运行程序，以便我们得到
信息，很美，但是我们的人对象也应该有
名称属性，没有名字的人是没有意义的。
这就是我们使用构造函数的时候。所以在最上面
我们添加了一个新方法，该方法的名称为double
下划线，init双下划线。所以我们
将此方法称为构造函数。现在，在这种方法中，我们需要
添加另一个名为name的参数，所以我们
只需将self.name设置为name。一次
再次，self引用当前对象，我们设置名称
当前对象的属性，传递给此方法的name参数。
有了这个，我们可以回到第9行，
在创建人员对象时，我们传递名称，让我们看看乔恩·史密斯
现在让我们打印jon.name并运行我们的程序
你去。所以乔恩·史密斯印在终端上
因此，这是您在本练习中要做的全部工作。可是
让我们使该程序更有趣。代替打印
这条无聊的消息，让我们打个招呼，我是乔恩·史密斯。
因此，我们可以在消息中使用格式化的字符串
像嗨，我是，现在我们要动态地
添加此人的名字。我们该怎么做？好吧，看看
此对话方法的参数。就像我之前告诉你的
我们类中的每个方法都应具有此参数self。
而且它们应该是每种方法的第一个参数，好吗？因此，
通过这个自我，我们可以获得对当前对象的引用，因此
我们可以添加花括号并输入self
.name。此返回当前属性的名称属性
人对象。有了这个我们可以删除
第10行，我们打印jon.name并简单地调用
乔恩·托克让我们运行我们的程序。
嗨，我是乔恩·史密斯。我们去了，美丽。
现在我们可以建立另一个人对象，比如鲍勃，是一个新人
我们说鲍勃·史密斯
Bob.talk。并运行我们的程序
我们收到不同的消息，嗨，我是鲍勃·史密斯，所以
每个对象都是一个人员类的不同实例。
在本教程中，我将与您讨论Python的继承，
继承是一种使用代码的机制，
不仅限于python，大多数支持类的语言
也支持继承。因此，让我们了解您的工作方式。比方说
我们通过简单的走动方法为狗类提供了这种方法
我们只是在终端上打印步行消息，现在让我们说
在实际程序中，我们将只剩下10行，而不仅仅是这里的一行代码
代码。现在，如果将来我们要定义一个
另一个类，比如说猫，我们想添加
还有这种步行方法。播种，必须重复所有代码，
在这门新课上，走路。
不好因为您重复或重复了我们的
代码。在编程中，我们有一个叫做干的原理
简而言之，就是不要重复自己。
假设在将来的某个时候，我们发现步行方法存在问题。如果你
已经在许多其他地方重复或重复了此方法，那么我们将
必须回来并在我们拥有的每个地方修复该问题
复制了此代码。这就是为什么在编程中我们不应该定义一些东西
两次那么我们如何解决这个问题。
有不同的方法，对于初学者来说更容易理解的一种方法是固有
现在，它是如何工作的。我们定义了一个新类
maml，然后将walk方法移到那里。那我们有
狗和猫类继承了该方法
就像人类如何继承某些
属性或行为是他们的父母。完全一样，所以
在顶部，我们定义一个新类，我们称之为
哺乳动物，那么我们需要将步行方法移到那里。因此，
我们选择它，在Mac上使用Command和x剪切它，或者
在Windows上控制x，然后将其粘贴到此处，很漂亮，
现在我们要让我们的狗类从哺乳动物类继承下来
所以在类名之后，我们加上括号和
然后输入父类的名称。在这种情况下，是哺乳动物。
这就是我们要做的。所以和他的狗班
将继承哺乳动物类别中定义的所有方法。
现在这里有一个小问题，如果您看一下第9行，
红色下划线在这里。发生这种情况的原因是
python不喜欢空类，所以现在我们的狗
类为空，它没有任何东西，我们要么需要添加方法
特定于狗或只是为了让Python开心，
我们可以使用path语句，这基本上没有任何意义。
我们正在告诉python解释器，嘿，通过这一行，不用担心。但是有了这个，我们
没有空课，好吗？现在就像我之前告诉你的
每次上课后我应该有两个换行符，所以现在我们
只有一个换行符，这就是我们在这里有这个小警告的原因，所以让我们添加
另一条黑线很漂亮，所以我们的狗类是
从哺乳动物继承步行方法，您需要应用相同的更改
去猫课。所以我们要猫
从哺乳动物继承，然后
在这里使用path语句。有了这些变化，
现在我们可以创建狗或猫的对象，比如说狗，
首先，我们将其设置为狗对象，然后
当我们键入点外观时，我们具有定义的walk方法
在mamall类中。我们可以轻松地调用它，让我们运行程序
去那里，您会看到步行信息，
所以狗和猫类都继承了所有类
在其父类中定义的方法。现在在这里我们可以添加方法
例如，特定于狗，我们可以定义一个方法
树皮，然后打印树皮。
现在，我们不需要path语句，因为我们已经定义了
我们狗类中的一种方法。所以现在当我们输入
狗1。看我们有两种方法
一个是我们继承的walk方法，而我们只是树皮方法
在狗类中定义。同样，我们可以添加一个方法
例如，我们可以定义一种特定于猫的方法
烦人，我讨厌猫，所以让我们打印
烦人的，现在当我们创建猫
对象，让我们删除它，cat1
并输入cat1。你有这两种方法
狗，烦人。所以这些是python中继承的基础
现在，还有更多的功能超出了本教程的范围。
如果您有兴趣了解有关继承和其他机制的更多信息
为了重用代码，我鼓励您获得完整的Python课程。
在本教程中，我将与您讨论python中的模块。
python中的模块基本上是带有一些python代码的文件。
我们使用模块将代码组织到文件中。
就像超级市场中的部分一样。当您去超级市场时，会有不同的部分
用于水果，蔬菜，清洁产品等。我们没有
超级市场中所有产品的一个部分。我们有相同的概念
在编程中。因此，与其编写所有代码，不如编写
app.py中的所有函数和类，我们想分拆我们的代码
成多个文件。我们将每个文件称为模块。
这样，我们的代码不仅可以更好地组织和结构化，
但是我们也可以重用我们的代码。例如
在app.py的此处，我定义了两个用于转换的函数
重量从磅到千克，反之亦然。
现在我们可以将这两个功能放在一个单独的模块中
称为转换器，然后我们可以将该模块导入任何
需要这些转换器功能的程序。让我告诉你如何做。
因此，让我们打开项目面板，然后
单击项目，转到“新建”，然后添加新文件，
我们将其命名为converters.py。
然后，我们回到app.py
选择所有这些代码，将其剪切，然后
将其粘贴到我们的新模块中。 converters.py。
有了这个，我们清理了我们的应用程序模块
函数，所以当我们用类编写更多函数时，我们将它们放在它们的
对应的模块，一个模块应包含所有相关的
函数和类，好吗？现在你想
将converters模块导入到我们的app模块中，这很简单，在
顶部我们编写导入转换器
没有扩展名，因此我们不添加.py，我们只输入名称
文件。让我关闭该项目面板。现在，
这个转换器是一个对象，所以我们可以使用点运算符
访问它的成员。所以目前我们已经定义
这两个功能在我们模块的内部，从千克到磅，
和磅到千克。因此我们可以轻松地调用以下功能之一
让我们传递70公斤来得到结果并打印出来。
运行我们的程序，所以，
不到55磅。现在还有另一个
导入模块的语法，让我告诉你，所以
无需导入整个模块，我们可以从中导入特定功能
模块。运作方式如下。我们从
然后我们添加模块的名称，因此转换器
导入，如果您按Control和Space，现在在这里
我们可以看到此模块中定义的所有功能的列表。
所以在这里我们可以抓取其中一个功能，比如说千克到磅，
有了这个，我们可以像这样直接调用此函数
该文件中定义的功能。 App.py。比较一下
我们在第4行到第6行的内容在第6行
我们必须在此函数之前加上对象名称
转换器。因此，我们必须键入转换器。然后我们就可以
访问此功能。相反。当我们导入
某个模块中的特定功能，那么我们可以轻松地调用该功能
而不用模块名作为前缀。所以这是什么
你需要带走。我们使用模块来更好地组织我们的代码。代替
编写所有代码，而不是将所有功能写在一个文件中，而是分手了
我们跨多个文件的代码。每个文件被称为
一个模块，它应该包含所有相关的函数和类
然后我们可以将一个模块导入另一个模块，在这种情况下，我们正在导入
将converters模块转换为我们的app模块。如你所见
有两种导入该模块的方法，我们可以导入整个模块，然后
我们将获得与模块同名的对象，因此我们可以
类型转换器。然后我们就可以访问所有
本模块中定义的函数和类。另一个方法
是使用以下命令从模块中导入特定功能或类
从导入语句。现在在这里
是你的运动。在课程的早期，您练习了如何找到
列表中最大的数字。所以在最上面
数字列表，最初我们将max设置为此列表中的第一个数字
然后，我们浏览此列表，获取每个数字，
如果当前数字大于最大值，则重置最大值。
最后，当我们完成循环时，将在终端上打印max。
现在，这就是我要你做的。该代码目前
没有组织。我们没有任何功能，我们没有任何模块，我们编写了所有
app.py中的代码，对于小型程序来说还可以，
但是随着程序的增长，您需要将代码正确组织到
类和模块。因此，作为本练习的一部分，我想
您编写一个函数，调用它查找最大值。
此函数应获取一个列表，并返回该列表中最大的数字。
现在执行此操作之后，继续执行此功能
在一个单独的模块中。因此，从这里提取它，并将其放入模块中，
称为工具。因此，在本模块中，我们将有一堆
实用功能，是吗？然后导入实用程序
模块插入当前模块并调用此函数。
最后，获取结果并将其打印在终端上，这是一个
出色的练习，教您如何正确组织代码。因此，
继续并花几分钟进行此练习。
所以第一个
步骤是定义一个名为find max的函数。所以在
顶部，我要定义函数，找到最大值
这个函数应该有一个数字列表，所以我们
添加一个称为数字的参数。现在在此功能内
想要有这几行，这是寻找
列表中最大的数字，我们不想带第一行，因为这
是我们创建列表的地方。因此，在程序的某个位置，我们将创建此列表，
并把它作为参数传递给max
功能。好吗所以，让我们继续前进
这几行，剪下来，放进去
查找最大功能。好了，所以我们找到了
该列表中最大的数字，最后我们需要将其返回，因此，
返回最大值这就是我们的功能。现在我们
需要将此移到一个单独的模块中。所以我们去面板
右键单击该项目并添加一个新的
文件，我们还可以添加一个相同的新python文件，我们称其为
utils，因此，如果您添加新的python文件
pycharm自动添加.py扩展名，但是如果您转到
新文件，我们将必须明确输入
.py。因此，请确保正确使用扩展名。
现在，回到app.py，让我们削减这段代码，
粘贴到这个新模块中，好漂亮。
现在，我要返回到app.py并导入我们的新模块。
我们可以导入整个模块，所以导入utils
然后访问各个函数，以便我们可以调用utils
.find max或我们可以显式
从utils模块导入此函数。它并没有真正的改变。
因此，我们可以从utils中键入
导入查找最大值然后我们
不需要在其前面加上对象的名称，因此我们只需调用
找到最大现在我们需要在初始化列表后调用它。
因此，首先我们需要定义数字列表。
然后，我们将该列表作为参数传递给max
我们得到最大的结果，最后我们打印出来
在终端上。让我们继续运行我们的程序，
最大的数字是10，很漂亮，
现在，在完成本教程之前的最后一件事，在这里，我们有一点警告
在max下，工具提示显示阴影内置名称
最高看到这是因为我们实际上有一个名为
最高它做的完全一样
作为我们的max函数。因此，这实际上是内置在python中的。
但我请您将其作为练习，因为对于初学者来说，这是一个很好的练习。
现在，回到警告，该警告基本上告诉我们
覆盖python中内置的max函数
因此我们正在更改此函数的含义，这被认为是不正确的做法，
让我告诉你我的意思。因此，让我们注释掉第4行的内容
通过在此处加一个井号，我们还可以使用
在Mac上的快捷命令和斜杠，或在斜杠上进行控制
在Windows上。因此，现在此行已被注释掉。看看
max的颜色，紫色，与打印颜色相同。这就是颜色
用于识别内置功能。现在我们可以打电话
此功能并给它一个数字列表
运行我们的程序，我们得到的结果完全相同，
如果我们把这条线带回来，我们可以再次使用相同的
在Mac上是命令和斜线的快捷方式，在Windows上是控制斜线的快捷方式。
现在，我们正在重新定义max，因此
该行，max曾经是一个函数，但是在执行第4行之后
max设置为整数，即此列表中的最大数字。
因此，我们将无法在第5行上调用它
让我们运行我们的程序，看看会发生什么。所以你去了
我们得到这个类型错误，int对象不是
可以调用，因为max现在是整数，所以它不是函数，
所以我们不能称之为。所以要解决这个问题，我们可以重命名
这个变量给别的东西。因此，右键单击此处。
去重构并重命名，
并将其重命名为最大。
这样您就可以看到警告已消失。如您所见，我们有相同的警告
在我们的utils模块中。所以我们在这里重新定义max
就像我之前告诉你的那样，这是不好的做法。我们正在改变
python中内置函数的含义。因此，
我们也将其重命名，我将使用shift和
f6到那里，在这里我们可以将其更改为
最大。输入，完成。
在本教程中，我们将讨论python中的软件包，
软件包基本上是组织代码的另一种方式，因此目前
我们的项目中只有3个模块文件，但是一个真实的项目
可以包含数百甚至数千个模块。
我们不想在这里添加所有这些模块，因为随着时间的流逝，此目录将
files肿的文件太多了，所以更好的方法是整理相关文件
模块，位于包装内部，因此包装就是容器
用于多个模块用文件系统术语来说，一个软件包是
目录或文件夹。因此，在我们的项目中，我们可以添加一个新目录
隐喻认为，在该目录中，我们可以添加所有定向模块
购物中心当您去购物中心或购物中心时，会有所不同
男士女士和儿童服装的部分，因此
打包，现在当您去男士专区时，会有不同的区域
提供不同种类的产品，我们有专门的鞋，T恤，
夹克等等，所以每一个就像一个模块，所以，
在本教程中，我将向您展示如何在Python中创建和使用包，
在我们的项目面板中，右键单击面板，然后
添加一个新目录。
我们将此目录称为电子商务。所以我们要创建
一个叫做电子商务的软件包，在这个软件包中，我们将拥有
与电子商务应用程序相关的所有模块。例如
我们可以有用于销售，运输，客户服务的模块
等等。所以我们继续吧
现在这里有一个空目录，以便将其转换为包
我们需要在其中添加一个特殊文件。所以吧
点击此目录并添加一个新的python文件，
将该文件称为双下划线，双下划线
这是Python中的特殊约定。
当Python解释器看到具有该名称的文件时，
目录中的名称，它将此目录视为一个包，我们也有一个
pycharm中的快捷方式，让我删除此目录
然后重新开始。所以删除，再次右键单击
项目，然后转到new，而不是创建新目录
我们可以创建一个新的python包，让我们称之为
您可以看到我们的包裹电子商务
pycharm会自动为我们创建此文件，因此我们无需手动创建
那个好吗现在，在这个包中，让我们添加一个新模块，
所以一个新的python文件，我们称它为
运送好吗？现在在这个模块中我们想要
用于计算运输成本的功能。所以定义
计算，强调，运输。
现在不用担心参数或实现，我们只需打印
计算下划线的运费。
现在假设您要导入此运输模块
进入我们的应用程序模块，并采用这种新结构
模块现在是电子商务软件包的一部分，因此我们无法直接导入
您必须从电子商务软件包开始。因此，
bak到应用程序，py再次有两种方法可以导入此模块。
我们可以导入整个模块，也可以
导入它的功能或类之一。因此，让我向您展示两种方法。
首先，我们将导入整个模块。现在我们的名字是
包？是电子商务吧？电子商务。
运输。所以不要输入import
我们输入进口电子商务的运输
运送。我们必须给它加上包名称的前缀。
现在访问该模块中的任何函数或类
我们必须输入ecommerce.shipping。
然后你去。现在我们可以访问计算运费
功能。因此，让我们继续运行我们的程序，
我们看到此消息印在终端上，很漂亮。可是
使用这种方法，每次您要调用其中一个功能时
对于此模块，我们必须在其前面加上电子商务。
运输。这很冗长。因此，在使用软件包时
我们经常使用第二种方法
从声明。这样我们就可以从电子商务中键入
.shipping导入
计算运费。现在我们不必为此功能添加前缀
通过ecommerce.shipping，我们可以多次调用它
在此模块中，因此我们的代码要短一些。但是如果
您想在此运输模块中使用多种功能。我们可以在这里导入它们，
所以计算运费，逗号，例如，compute_
税。或者我们可以导入整个模块，然后
访问该模块中的所有他的函数或类。因此，
让我还原一下。导入整个模块
我们从电子商务中键入内容，因此我们将其删除。
所以从这个包中导入
运输模块。现在运输模块，
是一个对象，所以我们可以访问
这里使用点运算符定义的所有函数和类，因此
运输。到那儿，计算运费。所以
回顾一下，使用from语句时，我们可以从
打包并导入特定模块，或者我们可以
从package.module开始
然后导入特定功能。像计算运费。
因此，这是在
python。正如我之前告诉您的，软件包非常重要，尤其是
当您想使用django之类的框架时，我们使用django进行构建
Web应用程序和python，我将在本课程的后面向您展示。
因此，在Django中，我们有很多软件包和
每个程序包包含几个模块。因此，请务必观看教程，
再一次讨论模块和软件包，否则以后您会感到困惑
当我们到达Django时。
在本教程中，我将与您交谈
关于python中内置模块的人，所以python
带有一个标准库，其中包含一些通用模块
诸如发送电子邮件，处理日期和时间，
生成随机值和密码等。模块太多了
已经内置在Python中，这意味着已经有很多功能
我们可以重用。让我告诉你在哪里可以找到
这个标准库。所以打开这个浏览器
并搜索python 3，模块索引，
确保添加版本号，因为python 2中的模块是
与python3中的模块不同。所以在这里我们搜索python 3
模块索引，这里的第一页是
python模块索引或python 3，让我们继续吧，
这些都是python内置的所有模块，
例如，我们有用于处理日期和时间的模块，
我们有用于发送电子邮件以编码值的模块，
这里有很多模块。现在所有这些的解释是
超出了本课程的范围，这确实需要它自己的课程。
因为这里有很多模块，但不要让此列表吓到您。
在学习python时，这不是您现在需要学习的东西
随着构建更多应用程序，逐渐您将熟悉更多模块
在这里，实际上没有人知道python中的所有模块
标准库。每个人都基于他们构建的应用程序了解一些模块。
因此，在本教程中，我将向您展示如何使用内置模块之一，
用于生成随机值。所以在最上面
我们导入随机模块，因为
random是一个内置模块，我们不需要在这里有文件
称为random.py。所以python解释器知道random是一个内置的
在模块中，只要它知道在哪里可以找到它。
现在，如果您想知道此随机模块在磁盘上的存储位置，请让我告诉您，
在项目面板中，展开外部
库，然后展开python 3，
然后再来一次python 3,7库
路线。这是您计算机上某个位置的文件夹，在该文件夹中，
python中的所有内置模块。因此，
如果向下滚动，则应该可以找到。
随机模块。你去。就在这里如此随机。
py您可以打开它，这将向您显示源
该模块的代码。你去。现在在本教程中
我们不想担心帽子，所以让我们回到我们的app.py，
并使用此模块生成随机值。所以当我们导入
这个模块，现在我们有了这个对象，随机的，所以我们可以使用点
操作员访问它的方法。一种有用的方法
这是随机方法，每次调用它都会生成
一个介于0和1之间的随机值。因此，在这里我们可以进行for循环，
比方说我
范围3.因此，为了刷新您的记忆，我们正在使用
range函数创建一个范围对象。我们可以看一下这个范围对象
并且在每次迭代中，该对象都会吐出一个值。
因此，使用此for循环，我们可以执行此代码3次。现在，让我们
缩进这个。好的，最后，让我们打印结果，
你去。所以我们可以看到
在每次迭代中，我们都会得到一个介于0和1之间的新随机值。
现在，如果我们想要一个特定年龄的随机值怎么办？
假设介于10到20之间的随机值
这里有另一种方法rand int，我们在这里使用2个参数
要指定我们的范围，例如10和20。
再运行一次我们的程序。现在我们有数字20
13和18。如果我们再运行一​​次程序，
我们得到了不同的值，所以再增加20、19、11。
看，您还有另一种强大的方法
从列表中随机选择一个项目。假设我们有一个团队成员列表，而您想
随机选择某人作为领导者。让我告诉你如何做。
因此，我们定义了团队成员列表，将其设置为
乔恩，玛丽，鲍勃，
和mo。现在我们可以叫随机
.choice并通过我们的会员列表
此方法从此列表中随机选择一个方法并将其返回。所以
我们可以将结果存储在Leader中，然后
在终端上打印它。让我们运行我们的程序，
所以现在领导者是玛丽，如果您再运行一次我们的程序
这条线是现在，现在又是一次，
它真的很喜欢吃甜食，你明白了。因此
random模块功能非常强大，并且具有很多应用程序。
现在，这是一个非常酷的练习。我要你写这个程序到
掷骰子。因此，每次运行此程序时，我们都会获得不同的值。
现在我们有3合1，下次我们有3和6，还有一次
5和6、4和3，双重，这是一个非常酷的练习。
因此，在我们开始之前，我希望您注意一些事项。
我要你定义一个叫骰子的类
在本节课中，我们将有一个称为rope的方法，因此每次
调用此方法，我们得到一个元组，一个元组记住的是一个列表
值，但是值不能更改，您不能向其中添加新项目，我们
无法将其删除。因此，这就像一个只读列表。所以每次
我们调用row方法，我们应该获得两个随机值的元组。
因此，继续进行此练习，接下来您将看到我的解决方案。
好吧，我们首先从顶部导入random模块，
然后定义一个名为dice的类：
这个类我们要有一个叫做row的方法。所以定义行
括号，这会自动添加自我，现在使用此方法，
您想要生成1到6之间的两个随机值。
因此，我们将其称为random.randint。
并传递1和6。这样就生成了第一个数字，
我们可以在这里说，现在让我们再打电话一次，
所以我要复制第5行的内容，放在这里，然后
将此变量更改为秒。因此，我们有两个变量第一和第二。
有了两个随机值，最后我们需要返回它们，
在元组中，因此返回括号而不是方括号，
第一和第二，现在
在python中，当您想从函数返回python时，不必添加
这个括号，因此您可以简化代码，而python会自动
将此解释为元组。这样就完成了
使用我们的类的定义，我们删除缩进并添加
两个换行符。现在我们创建这种类型的对象
所以你把骰子设置成骰子
接下来我们掷骰子，所以dice.roll和
在终端上打印结果，这就是您要做的全部。
让我们运行该程序，现在我们得到2和5，
让我们再运行一​​次3、2、1和1，非常漂亮。
现在我们这里有个小警告，说
预期找到2条黑线1.再次是
来自pep 8，pep是python的缩写，
提案。我们有很多python增强建议或peps。
Pep 8是非常有名的1，在本文档中，
格式化代码的所有最佳做法。如此鼓舞人心
8说，在定义了类之后，我们应该有两个换行符，我们已经完成了
所以抱怨的原因是因为我们之前有1个换行符
该类，所以让我们再添加一个换行符，现在是pycharm
很高兴所以基本上pycharm一直在追随一切
pep8中定义的做法。现在你不必记住
这些最佳实践中的任何一种，当您在pycharm中进行编码时，pycharm都会为您提供更多
警告，然后您将逐渐了解如何正确设置代码格式，因此
被其他人阅读。
在本教程中，我将向您展示
如何在python中使用目录。所以在python3中
模块索引，您可以看到我们有一个名为path lib的模块，它提供了一个对象
面向文件系统协议。这基本上意味着它提供
我们可以用来创建与目录和目录一起使用的对象的类
文件。因此，如果您单击此处，则可以看到此模块
的作品，我们可以看到各种各样的例子。例如，在这里基本
使用情况，您可以看到这是我们导入路径的方式
path lib模块中的class。让我放大以便您可以看到
清楚地。好的，所以从路径库看，这就是
我们的模块，导入路径，请注意命名约定。
P是大写的，这意味着path是一个类，因此我们需要创建
您可以在此处看到该类的实例，
现在这里有很多文档，您可以自己阅读，但让我快速向您展示
一些帮助您入门的示例。所以在pycharm之后
在顶部，从路径引导模块开始
导入路径类。现在我们需要创建
引用文件或目录的路径对象
在我们的计算机上。因此，基本上有一些方法可以使用绝对值
路径，或者基本上是相对路径
表示从当前目录开始的路径。例如
如果您想在我们的项目中引用此电子商务目录，我们可以
使用相对路径。所以我们从当前目录开始，然后
去别的地方。使用绝对路径，我们从根开始
我们的硬盘。例如，如果您使用的是Windows，则可能
这样的绝对路径，C驱动器，反斜杠，
程序，文件，反斜杠Microsoft，
所以这些是c驱动器中的目录。
在Windows上，我们使用反斜杠来构建路径。如果你在
在Mac或Linux上，您的路径看起来会有所不同，因此
除了反斜杠，我们还有一个正斜杠，可以说用户/本地
/箱。 So these are examples of absolute paths.在
this tutorial we're going to work with he relative path to work with this ecommerce
directory that we have in our project. Now if you didn't create this directory
earlier, simply right click on the project and then go to new
directory. oaky? So, let's close this panel,
we create a path object, now,
if you don't pas an argument here, this will reference the current directory
alternatively, we can pass string, in this string we can
add a file or a directory. let's say the ecommerce
directory. Now this runs a path object, so we store it here,
now this path object has a few interesting methods
for example, we can check to see if a path exists by calling
the exist method. This simply returns a boolean so let's print it on the terminal,
there you go. So this path exists,
what if it changes to ecommerce 1, and
run our program and get false, we can also create a new directory
for example, let's change our path to email, now when we
run this program, obviously we don't have this directory but we can
create it by calling the mk dir method
so make directory. Let's run our program
alright, this method returns none which basically means
it doesn't return any values. Now if you look at the project panel you can see
here we have a new directory called emails, we can also delete this directory
so, instead of mk dir we call
rmdir which is short for remove directory, but
let's go ahead, now we can see that directory is gone. We can also see
all the files and directories in a given path, that is, very useful if you want to
write a little program to automate something.例如
you can iterate over all the spreadsheets in a directory one them and
process them. Let me show you. First we change the path
to the current directory and then we call the glob
طريقة. With his method we cans each for files and
directories in the current path. So as the first argument we need to pass a string
that defines a search pattern. We can type an asterisk
and that means everything, all files and all directories.
We can optionally add an extension, so to get all the files, you
need the files you use star.star. With this
pattern, we'll only get the files in the current directory. But not the directories.
We can also search for all the py files, or all the excel
spreadsheets. Anything. So let's search for all the py files
in the current directory, now when we run our program
we get this generator object. Generator object
are kind of an advanced topic, and they are beyond the scope of this beginners
python course. But for now all you need to know is we can iterate
or loop through these generator objects. So instead of
printing this generator object, let's just iterate over it using
a for loop, so, for, file in,
the generator object that is returned from the glob method. q
Let's print file.
We run our program, there you go. So these are all the
py files in my current directory, this could be different on your machine
if you didn't follow the exercises I gave you earlier. For example, this
utils.py, we created this as part of one of the exercises earlier in this course.
So don't worry if the files you see here are different on your machine.
So, you can use the glob method to search for files using
a pattern, we can also get all the files and directories in the current
path, so, we just use one asterisk, then
run our program, take a look, so we have this
ecommerce directory, we have notes.txt, this is a file I
added earlier just to write notes as part of my presentation so you're not going to have
this file. We also have a bunch of directories and files.
Even though python's standard library is comprehensive and has
so many modules for common tasks, it's not complete by any means.
That's why we have this directory called python package
index. Or pypi. And in this directory you can find hundreds
of packages for doing awesome things. These are packages that people like you
and I have built as part of our projects, and then they have published it as part of this directory.
For other people to use. So that's why we have a fantastic community in python,
there are so many python developers out there and there are so many packages
right in front of us to reuse in our programs, let's say
you want to send text messages in your programs, you don't have to build this functionality from scratch,
we can simply come to pypi.org and
search for sms aas you can see there are so many
projects or apckages that give you this functionality. Of course not every
package, not every project is complete or bug free, some of them are still
in development or they have bugs, but if you look around I'm pretty sure
for any kind of function you can imagine there is a good
reliable and well documented package for you. In my complete python course,
I will show you some of those most useful packages on pypi.举个例子
you will learn how to access the information on yelp.com in your
programs. So you can write a program and search for businesses
registered on Yelp. Let's say you want to search for the best barber
in New York City. I will show you how to do that. You will also learn how to use a technique called
web scraping, which means you can build an engine and have that engine
browse a website, and extract information from HDML files.
This is the same technique that Google does to index various
websites. So they have several engines, or web crawlers, these web crawlers
are continuously looking at various websites and extracting information
from their pages. When you publish a blog post Google's web crawler
finds the title of your post, its keywords and so on.因此，
I'm going to show you how to do that with Python, we'll also look at browser automation, and this is extremely
powerful, because you can automate testing of your web
applications. So you might get a job as a test engineer, and
your daily job is to browse a website, click here and there, fill out this form, that form, and
ensure that this website is functioning properly. You can automate all that
with a powerful python package called selenium, as I have shown in my complete, as I show in my complete
python course. Now in this tutorial, I'm going to show you how to install
packages, from pypi.org.因此，
here on pypi.org let's search for open py
xl. This is a package that we use for working with excel
spreadsheets. So let's search for this package, there you go, so currently
it's at version 2,5. On the top you can see,
this instruction pip install open pyexcel.
this is the command that we need to type in the terminal window to
install this package into our program, so back to pycharm,
here on the status bar. You can open up a terminal window for executing
various commands. So let's open it, now if you're on Windows
you're probably going to see something different instead of this dollar sign, don't worry about that
just execute this command I'm going to show you. So pip
install open py xl
Make sure to spell everything properly. So pip is the tool,
that comes with a python installation, and we use it to install or uninstall
packages registered on pypi.org. So here,
we're using pip to install this package. open py
xl. Enter, let's go ahead with that, it's going to take a few
seconds, oaky done, now we can import this package and it's
modules just like the built in modules in python, or the modules that we have
in our project. Now if you're curious where this package
is stored on disc let me show you. So open up the project panel,
and then expand external libraries, next
expand python 3, and then expand sight packages.
This is where all these packages that we installed with pip are stored.
So here we have open py xl, you can open this,
in this folder we have another folder called cell, now
Now, look what we have here you have this init
type, earlier I told you that whenever we add this file to a folder, python treats
that folder as a package, so sell is a package, and this
package we have is modules. Sell, interface, read only and text.
So as you can see, this package openpyxl has several
subpackages like cell, start, chart sheet and so on.
And in each package we have several modules, in the next tutorial
I will show you how to work with excel files.
So we have covered all the core concepts in Python, I hope you have learned a lot.
please support my hard work by liking this video and sharing it with others.
And be sure to subscribe to my channel for more tutorials like this. Next we're
going to work on our first python project that involves automation.
You're going to write a python program that can process thousands of spreadsheets
in under a second. Are you excited?让我们开始吧。
In this tutorial I'm going to show you something really awesome you can do with python. You're going to
learn how to process spreadsheets, and this is extremely valuable
in situation where you have hundreds or thousands of spreadsheets that need to
be updated. If you want to do this by hand it may take hours or days
weeks, or even months, you can simply build a python program in less then
half an hour. And have that python program, automatically process thousands of spreadsheets
in under one second. So, here we're going to work on this
excel spreadsheet. You can download this below this video.
In this spreadsheet we have three columns, transaction ID,
product ID, and press. Now don't worry about the fourth column yet.
So in this spreadsheet we're going to record all kinds of transactions, but let's say
due to an error, it could be a human error or a system error. The price that we have
here is wrong. Let's say we need to decrease this by 10 percent.
If you want to do this manually, we'll have to come back here and
add a formula, so we typed out equal sign, let's say you want to recalculate
say you want to recalculate the value of this cell.
have to get that and then multiply it by 0,9
and that is like 90% of the original price, we are reducing the original
reducing the price by 10%. Now when you hit enter you can see the updated price.
Next we'll have to come back here, select this cell and
apply the same formula to all the other rows. Now what if you have thousands of rows
在这里吗You'll have to scroll up and down, this is going to be very tedious.
So we're going to write a python program that will do this for us. It's going to
auotmate this process and not only that it will also
add this beautiful chart right here,
once again if you want to open up hundreds or thousands of spreadsheets
and add a chart to each one, this is going to take at least a week or two
Our python program is going to do all of this in a matter of seconds.
因此，让我们开始吧。 Alright the first thing I want you to do is
to download this transactions file and add it to your project.
I put the link below this video for you to download. So if you're wondering
how to put this in this project, you can simply right click the project,
and if you're on Mac you have this item where
reveal in finder, if you're on Windows you should see something like reveal
in explorer, or file explorer, or whatever it's called
when you click this, this opens up the direct
on your machine where this is stored. So simply copy paste
the transactions file right here.现在，
here on the top, first we need to import the open py excel package.
So import open py excel, we can give it a
an alias to make our code shorter. So asxl.
This is not required but it just makes our code a little bit cleaner.
Let me show you. So now instead of typing open pyxl.
we type xl. okay so that's an alias for
this package. Now in this package we have a function for loading an xl
workbook. So let's call load workbook,
and as the argument we pass transactions.
.xlsx. So this we load
our excel workbook and return a workbook object.
好吗Now if you open this workbook, you can see you add only 1
sheet, and that is called sheet 1, so to access that you use
square brackets, and specify the name of the sheet,
that is sheet one, make sure to spell this with a capital
S. Because this is case sensitive, if you don't spell it properly
you're going to get an error, so this returns a sheet,
now in this sheet, we have various cells.因此
next you need to learn how to access a particular cell, and that is very easy.
back to py charm, with this sheet object, you can use
square brackets and give the coordinate of a cell.
Coordinate is the combination of the column and the row.
For example, this cell it's coordinate is a1.
So back to pycharm, we can type a1, and this returns
our first cell. Also, there is another approach to getting
a cell, instead of using square brackets with a string, we can
use the cell method of the sheet object, so,
sheet.cell, you pass the row and the column, so row
and column 1 these return the exact same
cell. Now let's print the value of this cell, cell.value
and run our program so
the value is transaction id, beautiful,
so now we need to iterate over all these rows and for each row we need to get the value
in the third column. That is the price. We'll get that and then multiply
by 0,9. So first we need to know how many rows
we have in this spreadsheet. We can get that from the sheet object so sheet
has an attribute called mx_
صف. Let's print this, so in this sheet,
we have 4 row, and you can verify that here. So we have
a total of 4 rows. So we need to add a for loop.
that would generate the numbers 1-4.因此，
let's delete this print statement, nd add a for loop
for row in were going to use the range function unction to generate a range of numbers,
starting from 1, all the way to sheet
.max_grow. Plus 1. The reason we're
adding 1 to this, is because as I told you before this range function
will generate numbers, starting from this value all the way to this
value, but it will not include the second value. So currently
max row returns 4, if you use range of 1-4 this will generate
the numbers 1, 2, and 3, but not 4.
So to include 4, we need to add 1 to it. Let's go over here,
so we tied sheet.max underline row plus 1.
Now before going any further let's just print row and make
sure our program is working up to this point. So let's run
this, we get the numbers 1-4 beautiful.
So now we can easily get the cells in the third column.可是
we don't really want this first cell, that's the heading.
so technically you want to ignore the first row. Back here, you want to change
our range function, and start from 2. Now,
we're going to use sheet.cell to get access to the cell
at this row. And the column should be 3.
We get a cell object, let's print it's value
and make sure you're on the right track, so run the program
these are the values we get. 5,95
6,95 and 7,95 these are the
values of the third column. Next we need to multiply each
value by 0,9 so instead of printing
cell.value we multiplied by 0,9 and this is
the corrected underline price,
so this is the mistake we're going to make with our program, now
we need to add a new cell to our worksheet, so we want to add all the corrected
prices, ia new column, it could also overwrite the values in this column,
but in this tutorial I'm going to show you how to add a new column.
So using the same method, now we need to get a reference to the cell, to the given
row, but in the fourth column. So, we call sheet
.cell, and pass row and four as the arguments.
Once again, this returns a cell object, let's store that in a
separate variable and call it
price_cell. So note that my variable names are
very descriptive. There is no guess work. You have corrected price which holds
actual value and we have corrected price, which is a cell
object in this spreadsheet. Next we have to set the value in this
cell. So we set corrected price cell.
value to this corrected price. With these few lines
we can easily update our spreadsheet, but first we need to save it.因此，
after our for loop, we call workbook.
save. Now let's save this in a new file because we don't want to
accidentally overwrite the original file in case our program has a bug
so, I'm going to call that transactions 2.sms
ex. And finally let's run our program,
so, you can see that happened in a split of a second, now here we have a new file
tranactions 2. When we open this we get something like this.
So you can see we have this 4th column with the updated prices.好漂亮
So half of the problem is solved, now we need to add a chart here.
To add a chart, we need to add a couple classes on the top, so,
after this import statement let's type out from
open py excel.chart, import, bar chart,
comma, reference.
So lets see what's going on here. In this package you have a module
chart, and from this module we're importing two classes, bar chart,
and reference. Again, look at the naming convention used
在这里The first letter of e very word is capitalized. Also it's better
to add a line break after our import statements to make our
code cleaner. So, before we save our workbook, we need to
add achart to the current sheet. First we need to select a range
of values. For this exercise, I'm going to select the values in the fourth column/.
So all the values in rows 2-4 these are
the values I'm going to use in our chart. Now in this part 2 example it doesn't really
make sense to add a chart per transaction, but that doesn't really matter
we just want a bunch of numbers to create a chart, so after our
for loop, we're going to use the reference class to select a range of
values. Now the first argument in the constructor is the
sheet. So we pass our sheet here, then we add
4 keyword arguments, the first one is min_row, we set this to
2. The second one is max_row we set
this to the maximum row in this sheet. That is sheet,
.max_row, so we want to select the cells in row
2-4. kay? Now to make this code a little bit cleaner
I'm going to put this on a new line, so we
can see clearly, now this is going to select all the cells
in all the columns in these rows. That's not what we want.
we only want the values in the fourth column, so back here
we need to set a couple more key word arguments men_call
or column, we set that to for, and also
max underline call, we set that to 4 as well. So we are limiting the range
of cells we're selecting to the fourth column.
Now, we're creating an instance of the reference class, let's store the
result in a variable called values, so this values object
will have all these values in the fourth column, now we are ready to create
a chart, so we create an instance of the bar chart class
and store it in this object.
Next, we call chart.add_date and
pass our values. That is pretty straight forward finally we need to add this chart
to our sheet. So, we call sheet,
.add_chart and pass this chart object
We should also specify where we want to add this chart.
let's say we want to add it here, on row 2, after the fourth column.
So the coordinate of this cell is e2, and this is going to be,
the top left corner of our chart. So as the coordinate I'm going to
pass e2 that's all we had to do, done. Let's run our
program one more time, beautiful, let's open up the update
workbook. And here's the end result, so
right after the fourth column, we have this beautiful chart. Now we could take this to the next level,
we could add a legend here, we could change the color of these bars, we could even use a different
kind of chart, it doesn't have to be a bar chart. So to learn more about this we can
read the documentation for openpyxl.因此
our program is complete, for our code is dirty, it's not clean, it's not
organized. We don't have any functions here. We have written all the code in app.py.
So let's goo ahead and organize this code like a professional software developer.
So, on line 4, we are loading our workbook
then we're getting a reference to the first sheet, but we don't really need these two lines here
this is purely for demonstration to show you how to access a cell.因此，
let's delete these unnecessary lines, this is a very important practice
as you're coding always look at your code, always review it, see if you have some code that is
not used. Always delete those. Okay, next we are iterating over
all the rows, fixing the prices, and then
we select the values to add a chart, and finally we save the workbook.
Now, if you were going to use this to automate the process of updating
thousands of spreadsheets, this program wouldn't work, because it's only
relying on this file. So we want o reorganize this code, and
move it inside of a function. This function should take the name of a function
So let's define a function.让我们
call it process_workbook.
It gets a file name. Now, we move all the code inside
of this function, so let's select everything, and press
tab, beautiful, now back
to our function, instead of loading this transactions file we're going to load
this file name, that's better,
Also, now that our program is working properly, there is really no need to store the
result in a separate file. So here we can
simply overwrite the same file. So let's pass
file name, that is the end of our function, so,
now, we have this reusable function, we can simply reuse this
to process thousands of spreadsheets. Earlier in this python course you learned
how to find all the files in a directory, so we can get each file in a directory
and pass the name of the file to this function, this function will go
ahead and update this spreadsheet in just a second or less.
So, that was just one example of using python to automate
repetitive boring task that waste your time. But automation is not
just about processing excel spreadsheets, there are so many things we can automate.
Here's a question for you, what do you want to automate, how do you want to use python to make your
life easier? Use the comment box below and let me know. I love to
hear about your ideas. Next we're going to work on project which involves machine learning, which is a
subset of artificial intelligence. Are you excited?
让我们开始吧。
In this section, you're going to learn about machine learning, which is a subset of
AI or artificial intelligence. It's one of the trending topics in the world,
these days, and it's going to have a lot of applications in the future. Here's an example.
Imagine I ask you to write a program to scan an image, and
tell if it's a cat or a dog. If you want to build this program using
traditional programming techniques, your program is going to get overly complex
You will have to come up with lots of rules to come up with specific curves
edges and colors in an image to tell if it's a cat or a dog.
But if I give you a black and white photo, your rules may not work, they may break.
Then you would have to rewrite them. Or I may give you a picture of a cat or a dog from a different
angle that we did not predict before. So solving this problem
using traditional programming techniques is going to get overly complex or
sometimes impossible. Now to make the matter worse. What if I ask you to extend
this program such that it supports 3 kinds of animals.
Cats, dogs, and horses, once again you will have to rewrite
all those rules. That's not going to work. So machine learning is a technique
to solve these kinds of problems, and this is how it works. We build
a model or an engine and give it lots and lots of data.
For example, we give it thousands or tens of thousands of pictures of
cats and dogs. Our model will then find and learn patterns and the input
data, so we can give it a new picture of a cat that we haven't seen before.
And ask it, is it a cat or a dog or a horse
and it will tell us with a certain level of accuracy, the more input data we give it, the more accurate
our model is going to be. So that was a very basic example,
but machine learning has other applications in self driving cars,
robotics, language processing, vision processing,
forecasting things like stock market trends and the weather, games and so on.
So that's the basic idea about machine learning. Next we'll look at machine
learning in action.
A machine learning project involves
a number of steps, the first step is to import our data which
often comes in the form of a csv file. You might have a database with lots of data,
we can simply export that data and store it in a csv file for the
purpose of our machine learning project. So we import our data, next,
we need to clean it. And this involves tasks such as duplicated data.
If you have duplicates in the data, we don't want to feed this to the model, because
otherwise our model will learn bad patterns in our data and will produce the wrong result,
so we should make sure that our input data is in a good, and clean shape.
If there is data that is irrelevant we should remove them, if there are duplicates
or incomplete we can remove or modify them, if our data is
text based, like the name of countries, or genres of music,
or cats and dogs, we need to convert them to numerical values.
So this step really depends on the kinds of data we're working with, every project
is different. Now that we have a clean data set, we need to split it
into two segments. One for training our model, and the other for
testing it, to make sure our model produces the right result.
For example, if you have 1,000 pictures of cats and dogs, we can reserve
80% for training, and another 20% for testing.
The next step is to create a model, and this involves selecting
an algorithm to analyze the data. There are so many machine learning algorithms
out there, such as decision trees, neural networks and so on.
Each algorithm have pros and cons in terms of accuracy and performance
so the algorithm you use, depends on the kind of problem
you're trying to solve and your input data. Now the good news isnthat we don't have to
explicitly program an algorithm, there are libraries out there that provide these
algorithms, one of the most popular ones, which we are going to look at
in this tutorial, is side kick learn. So we build a model using an algorithm ,
next we need to train our model. So we feed it our training data.
Our model will then look for the patterns in the data, so enxt
we can ask it to make predictions. Back to our examples of cats and dogs,
we can ask our model is this a cat or is this a dog and our model
will make a prediction, now the prediction is not always accurate
in fact when you start out, it's very likely your predictions are inaccurate.
So we need to envalue the predictions and measure their accuracy.
Then we need to get back to our model and either select a different algorithm
that is going to produce a more accurate result for the kind of problem
we're trying to solve. Or fine tune the parameters of our model.
So each algorithm has parameters that we can modify to optimize the
accuracy. So these are the high level steps that you follow in a machine learning
project. Next we'll look at the libraries and tools for machine learning.
In this lecture we're going too look at the popular python library
that we use in machine learning projects. The first one is numpy which
provides a multidimensional array. A very, very, popular library.
The seconnd one is pandas, which is a data analysis library that
provides a concept called data frame. Data frame is a two dimensional
data structure similar to an excel spreadsheet. So we have rows and columns
we can select columns in a row or a column or a range of rows and
columns, again, very very popular in machine learning
and data science projects. The third library is mad plot lib which
is a two dimensional plotting library for creating graphs on plots.
The next library is sidekick learn, which is one of the most popular machine learning
libraries that provides all these common algorithms like decision trees,
neural networks and so on. Now, when working with machine learning
projects, we use an environment called jupiter for writing our code, technically we can still
use vs code or any other code editor, but these editors
are not ideal for machine learning projects, because we need to frequently
inspect the data, and that is really hard in environments like vs code and
terminal. If you're working with a table of 10 or 20 columns
visualizing this data in a terminal window is really, really difficult and messy, so thats why we use jupiter.
So that's why we use jupiter, it makes it really easy to inspect our data.
Now to install jupiter, we are going to use platform called anaconda.
So, head over to Anaconda.com/download.
On this page you can download Anaconda distribution for your operating system,
so, we have distributions for Windows Mac and
Linux. So let's go ahead and install
Anaconda for python 3,7. Download,
Alright, so
here's Anaconda, download it on my machine, let's double click this.
Alright, first it's going to run a program to determine if the software can be installed.
So, let's continue and once again continue,
pretty easy, continue one more time,
I agree with the license agreement, we can use the default
you ca use the default installation location so don't worry about that, just click install,
give it a few second, now the beautiful thing about Anaconda is it will install
jupiter, as well as all those data popular science libraries
like numpy, Pandas and so on. So we don't have to manually install this
using pip. Alright now as part of
the next step Anaconda is suggesting to install Microsoft vs code.我们是
already have this on our machine so we don't have to install it we can go with continue
and close the installation, now finally we can move the
this to trash because we don't need this installer in the future.
Alright, now open upa terminal window and type
jupiter, with ay, space, notebook.
This will start the notebook server on your machine. So enter
there you go. This will start the notebook server
on your machine, we can see these default messages here, don't worry about them, now
it automatically opens a browser window, pointing to local host
port 888. This is what we call
jupiter dashboard. On this dashboard we have a few tabs, the first tab
is the files tab, and by default, this points to your home directory.
So every user on your machine has a home directory, this its my home directory
on Mac, you can see here we have a desktop folder as well as documents,
downloads and so on. On your machine you're going to see different folders, so somewhere
so somewhere on your machine you need to create a jupiter notebook. I'm going to go to desktop
here's my desktop I don't have anything here, and then
click new, I want to create a notebook for python
3. In this notebook we can write python code, and execute it line by line.
We can easily visualize our data as you can see over the next few videos.因此，
let's go ahead with this,
alright, here's our first notebook, you can see by default it's called
untitled, let's change that to Hello World so
this is going to be the hello world of our machine learning project.让我们
rename this now if you look at your desktop you can see this file
hello world.ipynb. This is a jupiter
notebook. It's kind of similar to our py files where we write our
python code, but it includes additional data that jupiter uses to execute our
code. So back to our notebook, let's
do a print hello world.
And then, click this run button here
and here's the result printed in jupiter, so we don't have to
navigate back and forth between the terminal window we can see all the result
在这里Next I'm going to show you how to load a data set from a
csv file in jupiter.
Alright, in this lecture we're going to download a data set from a very popular website called
caggle.com. Caggle is basically a place to do data science projects.
So the first thing you need to do is to create an account, you can sign up with Facebook,
Google, or using a custom email and password, once you sign up then come back
here, on caggle.com, Here one the search bar
search for video game sales.
This is the name of a very popular data set that we're going to use in this lecture.因此，
here in this list you can see the first item with this kind of reddish
icon, so, let's go with that, as you can see this data
set includes the sales data for more then 16,000 videos
games. On this page you can see the description of various
columns in this data set, we have rank, name, platform,
year, and so on, so here's our data source, it's a csv file
called vg sales.csv, as you can see there are over 16,000
rows, and 11 columns in this data set.
Right below that you can see the first few records of this data set.
So, here's our first record, the ranking for this game is 1, it's the wi sport
game for wii as the platform and it was released in the year 2006,
now, what I want you to do is go ahead and
download the data set, and as I told you before you need to sign in
before you can download this. So this will give you a zip file as you can see here,
here's our csv file, now I want you to
put this right next to your jupiter notebook, on my machine that is on my desktop
so I'm going to drag and drop this onto the desktop folder.
Now, if you look at the desktop you can see here's my
jupiter, hello world notebook, and right next to that we have
vgsales.csv. With that, we go back
to our jupiter notebook, let's remove the first line and instead
import pandas
as pd. With his we're importing pandas module
and renaming it to pd, so we don't have to type pandas. several times in
this code. Now let's type pd.
read_csv. And pass the
name of our csv file. That is vgsales.
csv. Now because this csv file, is in the current folder right next to our jupiter notebook,
we can easily load it, otherwise we have to supply the full path
to this file. So, this returns a
data frame object which is like an excel spreadsheet. Let me show you.
So we store it here, and then we can
simply type df to inspect it. So one more time let's run this program
here's our data frame with these rows and these columns so we have
frank name platform and so on. Now this data frame object
has lots of attributes and methods that we're not going to cover in this tutorial,
that's really beyond the scope of what we're going to do, so I'm going to leave it up to you to
read pandas documentation or follow other tutorials to find out about pandas data frames.
But in this lecture, I'm going to show you some of the most useful methods and attributes.
The first one is shape, so shape
let's run this one more time, so here's the shape of this data set, we have over
16,000 records and 11 columns.
Technically this is a 2 dimensional array of 16,000
and 11, okay? Now, we can see here we have another
segment for writing code. SO we don't have to write all the code in the first segment
so here in the second segment we can call one of the methods of the dataframe,
that is df.describe.
Now when we run this program, we can see the
output for each segment right next to it. So here's our first
segment, here we have these three lines, and this is the output of
the last line. Below that we have our second segment, here we're calling
the describe method, and right below that we have the output of
this segment So this is the beauty of jupiter, you can easily visualize
our datsa, doing this with vscode in windows is really tedious and
clunky. So what is the describe method returning? Basically it's
returning some basic information about each column in this data set, So,
as you saw earlier we have columns like rank, year and so
on. These are the columns with numerical values. Now for each column we have
the count which is the number of records in that column, you can se
our rank column has 16,5
-98 records whereas the year column has 16,3-
-27 records.. So this shows that some of our records don't
have the value for the year column. We have null values.
So in a real data science or machine learning project we'll have to use some
techniques to clean up our data set. One option is to remove the records
that don't have a value for the year column. Or we can assign them a default value.
That really depends on the project. Now another attribute for each column
is mean so this is the average of all the values, now
in the case of the rank column, this rank doesn't really matter, but look at the year.
So the average year year for all these video games in our dataset is
2006. And this might be important in the problem we're trying to solve.
We also have standard deviation, which is a
measure to quanitfy the amount of variation in our set of values, below that we have
min, as an example the minimum value for the year column
is 1980. So quite often when we work with a new data set,
we call the describe method to get some basic statistics about
our data. Let me show you another useful attribute.
So, in the next segment, let's type df.values.
Let's run this, as you can see this returns
a two dimensional array, this square bracket indicates the outer array
and a second one represents an inner array.
So the first element inn our outer array, is an
array itself, these are the values in this array, which basically
represent the first row in our data set. So the video game we ranking
1, which is called wii sports. So this was a basic
overview of pandas data frames, in the next lecture I'm going to show you
some of the useful shortcuts of jupiter.
In this lecture I'm going to show to you some of the most useful shortcuts in Jupiter,
Now the first thing I want you to pay attention to is this green bar on the left.
This indicates that this cell is currently in the edit mode, so we can
write code here. Now, if we press the
escape key, green turns to blue, and that means this cell is
currently in the command mode. So basically the activated cell can either
be in the edit mode or command mode. Depending
on the mode, we have different shortcuts, so here we're in the command mode.
If we press h, we can see the list of all the
keybord shortcuts, right above this list we can
see, Mac OS modifier keys, these are the
extra keys on a Mac keyboard. If you're a Windows
user you're not gong to see these. So as an example, here is the shape of the
command key, this is control, this is option,
and so on. With this guideline you can easily understand the shortcut associated with
each command. Let me show you. So here we have all
the commmands when a cell is in the command mode. For example, we have
this command, open the command palette. This is exactly like the
command palette that we have in vs code. Here is a short cut
to execute this command. That is command shift and F.
Okay, so here we have lots of shortcuts,
of course you're not going to use all of them all the time, but it's good to have a quick look here to see
what is available for you. Tis these shortcuts you can write code much faster.
So let me show you somme of the most useful ones. I'm going to close this,
now with our first cell in the command mode
I'm going to press b, and this inserts, a new
cell below this cell. We can also go
back to our first cell, press escape, now the cell is in the command
الوضع. We can insert an empty cell above this cell by pressing a.
So either a or b. A for above or
b for below. Now if you don't want this cell, you can press d
twice to delete it. مثله.
Now in the cell I'm going to print a hello world message. So print
hello world. Now, to
run the code in this cell, we can click on the run button here,
so, here's our print function, and
right below that you can see the output of this function. But note that when you run
a cell, this will only execute the code in that cell.
In other words, the code in other cells will not be executed.
Let me show you want I mean, so in the cell below the cell, I'm going to delete the call
to a describe method. Instead I'm going to print
محيط. Now, I'm going
to put the cursor back in this cell where we print this hello world message
and run this cell. So we can see hello world
is displayed here, but the cell below is still displaying
the describe table, so we don't see the changes here.现在，
to solve this problem, we can go to the cell menu on the top,
and run all cells together. This can work for a
small project, but sometimes you're working with a large data
set, so if you want to run all these cells together it's going to take a lot of time.这是
the reason jupiter saves the output of each cell, so we don't have to rerun that
code if it hasn't changed. So this notebook file that we have here,
includes our source code organized in cells as
well as the output for each cell. That is why it's different
from a regular py file where we only have the source code.
Here we also have autocompletion and intellisence, so in this cell,
let's call df data frame
。 now if you press tab you can see all the attributes
and methods in this object. So let's call
describe, now with the cursor on the name of the method we can
press shift and tab, to see this tool tip that describes
what this method does and what parameter it takes. So here in front of
so here in front of signature you can see the describe method, these are the paramter
and their default value, and right below that you can see
the description of what that method does. In this case, it describes
generates descriptive statistics, that summarize the central tendency and so on.
Similar to vs code, we can also convert a line to comment
by pressing command and slash on mac, or
control slash on windows. مثله. Now that line is a comment, we can
press the same shortcut one more time to remove the comment,
so these are some of the most useful shortcuts in jupiter.
Now over the next few lectures we're going to work on a real machine learning project, but before we get there,
let's delete all the cells here, so we start with only a single
empty cell, so here, in this cell, first I'm going to press the
escape button, now the cell is blue, so we're in the command mode, and
we can delete the cell by pressing d twice.你去。
Now, the next cell is activated and is in the command mode.
So, let's delete this as well, so we have two more cells to delete
there you go, and the last one, like this,
so now we have an empty notebook with a single cell.
Over the next few lectures, we're going to work on a real machine learning project,
imagine we have an online music store, when our users sign up,
we asked our age and gender, and based on their profile,
you recommend various music albums their likely to buy. So in this project,
you want to use machine learning to increase sales.
So, we want to build a model, we feed this model with some sample data,
based on the existing users. Our model will learn the patterns in our data,
so we can ask it to make predictions. When a new user signs up,
we tell our model, hey, we have a new user with this profile, what
is the kind of music, that this user is interested in, our model will say jazz, or hip hop,
or whatever, and baed on that we can make suggestions to the user
so, this is the problem we're going to solve, now back to the list of steps in the machine
learning projects, first we need to import our data, then, we should
prepare or clean it, next we select a machine learning algorithm
to build a model, we treat our model and ask it to make predictions.
And finally, we evaluate our algorithm to see it's
accuracy. if it's not accurate we either fine tune our model or
select a different algorithm. So let's focus on the first step.
Head over to bit.ly/music.csv
this is a very basic csv that I've created for this project, it's just some random
made up data it's not real. So we have a table with 3
columns, age, gender, and genre. جنس
can either be one which represents a male,
or a 0, which represents a female, here I'm making a few assumptions.
I'm assuming that men between 20 and 25 like hip hop men between
26 and 30 like jazz, and after the age of 30,
they like classical music. For women I'm assuming
that if they are between 20 and 25 they like dance music, if
they are between 26 and 30 they like acoustic music, and just like
men, after the age of 30 they like classical music. Once again this is
a made up pattern, it's not the representation of the reality, so,
let's go ahead and download this csv. Click on this ... icon here
and download this file.
In my downloads folder, here we have this music.csv.
I'm going to drag and drop this onto the desktop because that's where I've
stored this hello world notebook. So I want you to put this csv file
right next to your jupiter notebook.
Now, back to our notebook, you need to read the csv file, so just like before
first we need to import the pandas module, so import panda
as pd. And then we'll call pd,
.read_csv and
the name of our file is music.csv. As you saw earlier this
returns a data frame which is a two dimensional array similar to an xl spreadsheet,
so let's call that music_
data. Now let's inspect
this music_data to make sure we loaded everything properly so
run, so here's our data frame, beautiful, next we need
to prepare or clean the data. And that's the topic for the next lecture.
next lecture.
The second step in a machine learning project, is cleaning, or
preparing the data, and that involves tasks such as removing duplicate
null values and so on. Now on this particular data set we don't have to do anything
kind of cleaning, because we don't have any duplicates, and as you can see
As you can see, all rows have values for all columns, so we don't have null values.
But there is one thing we need to do,
we should split this data set into two separate data sets, one into the first
two columns, which we refer to as the input set, and the other
with the last column which we refer to as the output set. So when we train a model,
so when we train a model we give it two separate data sets. The input set and the output set.
The output set which is in this case
the genre column contains the predictions so we're telling our model that
if we have a user who's 20 years old and a male they like
hip hop. Once we train our model then we give it a new
input set. For example, we have a new user who is
21 years old and is a male, what is the genre of the music that this
user probably likes. As you can see in our input set, we don't have
a sample for a 21 year old male, so we're going to ask
our model to predict that. That is the reason we need to split this data
set into two separate sets. Input and output
So back to our code, this data frame object has a
method called drop.现在
if you put the cursor on the method name and press shift
and tab, you can see this tool tip, so this is the signature of
this drop method, these are the parameters you can pass here.
the parameter we're going to use in this lecture is set to none by default.
Witht his parter we can specify the columns we want to drop, so
in this case we set columns
to an array with one string, genre
now this method doesn't actually modify the original data set.
In fact it will create a new data set but without thisq
call. So by convention we use a capital X to
represent that data set, so capital x equals this
expression. Now, let's inspect x,
so as you can see our input set or x
includes these two columns, age and gender, it doesn't have the
output or predictions. Next we need to create our output set so,
once again we start with our data frame
using data, using square brackets we can get all the
values in a given column. In this case, genre. Once again this returns
a new data set. By convention we use a lower case y
to represent that. So that is our output
data. Let's inspect that as well.因此，
in this data set we only have the predictions or the answers.
So we have prepared our data, next we want to create a model using an
algorithm.
The next step is to build a
model using a machine learning algorithm. There are so many algorithms out there, each algorithm
has its pros and cons, in terms of the performance and accuracy.
In this lecture we're going to use a very simple algorithm called decision tree.
Now the good news is we don't have to explicitly
program these algorithms, they're already implemented in a library called side kick
learn. So, here on the top,
from sklearn.tree
let's import the decision tree
classifier. So sklearn is the package
that comes with sidekick learn library, this is the most popular machine learning library
in python. In this package, we have a module called tree.
And in this module we have a class called decision tree classifier.
This class implements the decision tree operator, okay?
So, now we need to create a new instance of this class.
So, at the end, let's create
an object called models nd set it to anew instance of decision,
tree classifier. مثله.
So now we have a model, next we need to train it so it learns
patterns in the data, and that is pretty easy. You call model,
.fit this method takes
2 data set. The input set and the output set.
So they are capital x, y.
Now finally, we need to ask our model to make a prediction, so we can
ask it, what is the kind of music a 24 year old male likes? Now before
we do that, let's temporarily inspect our initial data set.这是
music data. So, look what
we got here. As I told you earlier, I've assumed
that men between 20 and 25 like hip hop music but
here we only have 3 samples for men age
20, 23,and 25. We don't have a sample for
a 21 year old male. So if you ask our model to predict the kind of music
that a 21 year old male likes, we expect it to say hip hop. Similarly,
I've assumed that women between 20 and 25 like dance music,
but we don' have a sample for a 22 year old female. So once again if
you ask our model to predict the kind of music that a 22 year old woman
likes, we expect it to say dance.
So, with these assumptions let's go ahead and ask our model
to make predictions. So let's remove
the last line, and instead we're going to call model
.predict. This method takes a
2 dimensional array. So here's the outer array. In this array, each element
is an array. So I'm going to pass
another array here, and in this array I'm going to pass a new input set.
a 21 year old male. So 21, 1
that is like a new record in this table.好吗因此，
this is one input set, let's pass another input for a 22 year old
female. So here's another array, here,
we add 22 comma 0, so we're asking our model to make 2 predictions
at the same time. We get the result and store it
in a variable called predictions, and finally
let's inspect that in our notebook.
Run, look what we got, our
model is saying that a 21 year old male likes hip hop, and a 22 year
old female likes dance music. So our model successfully
will make predictions here. But wait a minute, building a model that makes
predictions accurately is not always that easy.
After we build a model we need to measure it's accuracy.
And if it's not accurate enough, we should either fine tune it or build a model using a different
algorithm. So next lecture I'm going to show you how to measure the accuracy of
a model.
In this lecture I'm going to show you
how to measure the accuracy of your models. Now in order to do so,
first we need to split our data set into two sets. One for training and the other
for testing, because right now, we are passing the entire data set,
for training the model and we're using 2 samples for
making predictions. That is not enough to calculate the
accuracy of a model. A general rule of thumb is to annotate
70-80% of our data to training, and another20-30%
for testing, then instead of passing only two samples for
making predictions, we can pass the data set for testing
we'll get the predictions and then compare the predictions with the actual values.
In the test set. Based on that, we can calculate the
accuracy. That's really easy, all we have to do is import a couple functions and
call them in this code. Let me show you. So first on this top
from sklearn.model
underline selection module we import a function called
train test split. With this function we can easily split our
data set into two sets. So training and testing,
now, right here, after we define x and y,
sets, we call this funciton, so train
test split. We give it 3
arguments, x, y, ad a keyword argument that specifies
the size of our test dataset. So test
_size we set it to 0,2 So we're allocating 20%
of our data for testing. Now this functions returns a
tuple, so we can unpack it into 4 variables
在这里x_train
x_test y_train and y
_test. so the first two variables
are the input sets for training and testing.
And the other are the output sets for training and testing,
now, when training our model,
instead of passing the entire data set we want to pass only the training data set.
So, x_train,
and y_train. Also, when making predictions
instead of passing these two samples, we pass
x_test. So thats the datas set.
That contains input values for testing. Now we get
the predictions. To calculate the accuracy we simply have to compare these predictions
with the actual values we have in the output set
for testing. That is very easy. First on the top,
we need to import a funciton, so, from sklearn.metric
.metrics import accuracy
_score. Now at the end.
We call this function, so accuracy score and
give it two arguments y_test.
Which contains the expected values and
predictions which contains the actual value.
Now this functions returns an accuracy score between 0
to 1. So we can store it here,
and simply display it on the console. لذلك دعونا نمضي قدما
and run this program. So, the accuracy score
is 1 or a 100% but if we run this one more time, we're going to see a different result
because every time we split our data set into
training a test sets. We'll have different data sets, because this function
randomly picks data for training and testing. Let me show you, so put the cursor
in the cell, now we can see this is activated
note that if you click this button here, it will run the cell and also insert a new
cell below this cell. Let me show you. So if I go to this second cell
press the skip button, now we are in the command mode,
press d twice, okay now it's deleted, if we
click the run button, we can see, this code was
executed, and now we have a new cell, so if you want to run our cell multiple times
every time you have to click this and then run
it, and then click again, and run it, it's a little bit tedious. So I'll show you a shortcut.
Activate the first cell, and press control and enter
this runs the current cell without
adding a new cell below it. So, back here, lets run it multiple times
okay, now look the accuracy dropped to 0,75, it's
still good, so the cuuracey scored here, is somewhere
between 75% to a hundred %. But let me show you something, if I
change the test size, from 0,2 to 0.
8, so essentially we're using only 20 percent of our data,
for training this model. And you're using the other 80%
for testing. Now let's see what happens when we run this cell multiple
مرات. SO, control and enter, look, the accuracy immediately
dropped to 0,4 One more time, now 46%
40%, 26%
it's really, really bad. The reason this is happening is because
you are using very little data for training this model. This is one of
the key concepts in machine learning, the more data we give to our model and the cleaner
the data is, we get the better result, so if you have duplicates,
irrelevant data, or incomplete values, our
model will learn back patterns in our data. That's why it's really important to clean
before training our model. Now let's change this back to 0.
2, run this one more time, okay, now
the accuracy is 1, 75%, now we drop to 50%
again, the reason this is happening, is because we don't have enough data.
Some machine learning problems, require, thousands or even millions
of samples, to train model, the more complex a problem is,
the more data we need. For example, here we're only dealing with a table of three
columns, but if you want to build a model to tell if a picture of a cat or a dog or a horse,
or a lion, we will need millions of pictures, the more animal
it will support the more pictures we need. In the next lecture, we're going to talk about
model persistence.
So this is a
very basic implementation of building a training a model to make a prediction.
Now to simplify things I have removed all the code that you wrote in the last lecture for
calculating the accuracy, because in this lecture, you're going to
focus on a different topic, So basically we import our data set.
Create a model, train it, and then
ask it to make predictions, now this piece of code that you see here, is not what we
want to run everytime we have a new user or
every time we want to make recommendations to an existing user
sometimes it's really time consuming. In this example, we're dealing with a
very small data set that only has 20 records. But in a real application,
you might have a data set with thousands or trillions of examples, training for that
might take seconds or minutes or even hours.
And that is wy model persistence is important, once in a while,
you build and train our model and then we save it to a file.
Now, next time we want to make predictions, we simply load the model from the file and
ask it to make predictions. That model is already trained
you don't need to retrain it, it's like an intelligent person. لذا دعني أريكم
how to do this. it's very very easy. On the top,
from sklearn.externals module
we import joblib. This
job lib object has methods for saving and loading modules.因此，
after we train our model we'll simply call
job lib .dump and give it
two arguments. Our model and the name of the file
in which we want to store this model. Let's call this music
-recommender.job lib
That's all we have to do. Now temporarily I'm going to comment
out this line, we don't want to make any predictions, we just want to store
train model in a file. So let's run this cell with control,
and slash, okay, look, in the output
we have an array that contains the name of our model file.
So this is the return value of the dump method. Now back to our
desktop, right next to my notebook we can see our job lib file, this is where our model is stored.
It's simply a binary file. Now back to our
jupiter notebook. As I told you before in a real application we don't want to
train model every time. So let's comment out
these few lines, on Mac, we can press
command and slash and on windows control slash.
Okay, these lines are commented out, now this time, instead of dumping
our model, we're going to load it, so we call the load method, we don't have the model, we simply
pass the name of our model file. This
returns our trained model. Now with this
two lines we can simply make predictions, so, earlier,
we assumed that men between 20-25 like hip hop music.
let's print predictions and see if our model is behaving
so control
so this is how we persist and load models.
Earlier in this section, I told you that decision trees are the easiest
to understand. And that's why we started machine learning with decision trees. In this lecture, we're going to
export our model in visual format, so you will see
how this model makes predictions, that is really, really cool.
Let me show you. So once again I've simplified this code
so we simply import our data set, create
input and output sets, create a model, and
train it, that's all we are doing, now I want you to
follow along with me, type everything exactly as I show you in this lecture.不行
worry about what everything means we'll come back to it shortly. So on the top,
from sklearnimport
tree, this object has a method for exporting
our decision tree in a graphical format. So after we
train our model, let's call tree
_graph vis. Now here are a few arguments we need
to pass. The first argument is our model,
the second is the name oft he output file. So here we're going to use keyword
arguments, because this method takes so many parameters, and we want to selectively pass
keyword arguments without worrying about their order.因此，
the parameter we're going to set it out_file
let's set this to music-recommend
.dot. This is the dot format, which is the
graph format, which is a graph description language, you will see that shortly.
Now the other parameter you want to set is feature
_names. We set this to an array of two strings,
age and gender. These are the features
or the columns of our data set. So they are properties or features of
our data.好吗The other parameter
is class names. So class_names
we should set this to the list of classes or labels we have
in our output data set, like hip hop, jazz, classical and so on.
So, this y data set includes all the genre
or all the classes of our data, but they are repeated a few times in this data set.
So, here we call y.unit this returns
the unique list of classes, now we should sort this alphabetically.
So, we call the sorted function, and pass the
result a y.unique.
The next parameter is labeled, we set
this to a string, all, once again don't worry,
about the details of these parameters, we're going to come back to these shortly.因此，
set label to all, then round it,
to true, and finally field to true.因此，
so this is the end result, now let's run this sound
using control and enter, okay,
here we have a nw file music recommender .. that's a little
bit funny. So we want to open this file with vs code.
So drag and drop this into a vs code window.
Okay, here's a dot format, it's
a textural language for describing graphs
Now to visualize this graph we need to install an extension in vs code.
So on the left side, click extensions panel and search
for dot, dot. Look at this second extension here.
graphvis or .language
by stephon vs. Go ahead and install this extension
and then reload vs code. Once you do that, you can visualize
this dot file. So let me close this tab.
Alright, look at this ... on the right side. Click this,
you should have a new menu, open preview to the side. So like that
alright, here's the visualization of our decision tree,
let's close the dot file, there you go. This is exactly
how our model makes predictions. So we have this
binary tree, which means every node can have a maximum of two children.
On top of each note we have a condition
if this condition is true we go to the child node on the left side. Otherwise we
go to the child node on the right side. So let's see what's happening here, the first condition
is age less then or equal to 30
.5. If this condition is false, that means that user is 30 years
or older, so the genre of the music that their interested in is classical.
So here we're classifying people based
on their profile. That is the reason we have the word class here,
so a user who is 30 years or older, belongs to the class of
classical. Or people who like classical music. Now what if this condition
is true. That means that user is younger then
30, so, now we check the gender, if it's less then 0,5,
which basically means it equals to 0, then
we're dealing with a female. So we go to the child node here,
now once again we have another condition, so we are dealing with a female
who is younger than 30. Once again we ned to check their age so
is the age less then 25,5? إذا كان هذا هو الحال
then that user likes dance music, otherwise they like acoustic music.
So this is a decision tree that our model uses to make predictions
Now if you're wondering why we have these floating point numbers
like 25,5 These are basically the rules
that our model generates, based on the patterns in our dataset.
As we give our model more data, these rules will change so they are not always the same.
So they are not always the same, also the more columns or the more features
we have, our decision tree is going to get more complex.
We only have two features, age, and gender. Now back to our code
let me quickly explain the meaning of all these parameters, we set field to true
so each box or each node is filled with a color. We set
rounded to true, so they have rounded corners. We set label to all
so every node has labels that we can read.
We set class names to the unique list of genres
and that's for displaying the class for each note, right here, and we set
feature names to age and gender, sow e can see the rules
in our notes. So that was a short and
sweet introduction to machien learning. Now you can use the materials that you learn in this section
and apply them to solve a different set of problems. Now here's a question for you:
What ideas do you have for machine learning? What kind of problems do you want to solve
with machine learning? Use the comments box below and let me know. I love to
hear about your ideas! Next we're going to use python and a popular framework called
django. To build a web application. Are you ready, let's get started
In this turorial, I'm going to show you how to create your first website with python, and A
and a very popular framework called django. So it's spelled with a silent D,
and is pronounced django. it's a web framework for
perfectionists with deadlines. So if you're a perfectionist and you want to quickly put together
a website that is fast, scaleable and secure,
django is your best friend. And here are the popular websites
built with Django. Like Instagram, Spotify
YouTube, Washington Post, and so on. Now you might say
what is a framework, and why do we need a framework to build a web application or a web site?
Well, the framework is essentially a library of reusable modules
these modules provide functionality for common tasks
for example, in the case of a web framework like django we have modules to work with http requests
url's, sessions, cookies and so on.
These are the concerns of pretty much every website or
application out there. So all this functionality is baked into django, we don't have to
code it from scratch, that is why we use a framework like django.现在，
django. Now technically a framework is more then a library,
apart from providing these modules it also provides a structure for each application
It tells us what folders or files we should have in our project. إذا هذا
provides a consistency among various django projects. So as you
move from one company to another and work on different projects, you can easily transition from one
project to another, because all these applications follow the same structure
now, with that interaction, let's create our first
django project. So back to pycharm, close the hello world
project, and create a new project, create a new project,
let's call this new project pyshop
go ahead, alright, now down at the bottom let's
open up a terminal window, in this window we're going to
install django. So we use pip to install
django. But be sure to add two equal signs here followed by
2,1 With this we are telling pip that we want to install django version
2,1. The reason I'm doing this, is because in the future when you're watching this video,
chances are there is a newer version django out there.我是
want to make sure that you can easily follow these tutorials, even though what I'm going to show you
in these tutorials will most likely work with the latest version of django. I just want to
be on the safe side. لذلك دعونا نمضي قدما
alright, django is installed,
next we need to create a django project, so here press control and L
this cleans up our terminal window, you don't have to do it, but it's just
easier to see. To create a django project, we need to execute this command, django,
-admin space
start project space, you're going to call this
project pyshop space period.
So when we install django, django brings a
command line utility called django admin so this is a utility or program
that we can execute form the command line or terminal, right here.
Now, this program takes various arguments, in this case
we want to use this argument start project, with this we're going to create
a project called pushup in the current folder.
So this period is imported here, that means the current folder, if
you don't add this period, this utility is going to create an extra folder and that
looks a little bit repetitive, so let's go ahead with this,
alright, now, back to the project panel, if you expand py
shop we can see that this is our project that we created in pycharm
and in this folder we have these files.
So, init.py, you have seen this before, that means
this folder is package, so we can import various modules,
of this package into other modules, and in this module,
we define various settings for our application, you're going to see this later in
this course. You also have this url's module, and with this module
we define what should the user see when they see slash
about/contact/products/shopping cart
again, we're going to work with this only. And finally we have this module,
that wsgi, that is short for web server gateway
جهة تعامل. The purpose of this module is to provide a standard interface
between applications built with django and web servers.这是
an advanced topic, so for now, don't worry about it. Now, outside of this folder,
of this folder you also have this new folder in our project
manage.py. As the name implies, we use this to manage
this django project. With this we can start our web server,
we can work with our data base, again, we're going to work with this soon,
let's open up the terminal window one more time, now,
type out this command, python if you're on windows or python
3 if you're on Mac, because as I told you at the beginning of the course, Mac by
default comes with an installation of python, that is python 2. But that is
this course is python 3. So python 3 space manage
.py space run
server. ما الذي يجري هنا؟ So with python interpreter
we are running this program manage.py and passing run server
as an argument. This manage.py is essentially the same program
that we worked with here, django admin.
But we use django admin before creating a django project, now we have a django project, so now
in this project we work with manage.py this
is a module that contains some python code, so we use this module to manage
our django project. So let's go ahead and