欢迎大家参加这门课程
在Python编程中。
我的名字是Saurabh，在本教程中我们要去
专注于Python的每一个重要概念。
所以不要浪费任何时间，
让我们继续前进，看看今天的议程。
所以这就是我们要讨论的内容。
今天，我们首先要了解什么是Python，
它是如何工作的，我们如何安装Python。
然后我们将了解序列是什么
和Python中的文件操作。
接下来，我们将专注于功能
和哎呀的概念。
之后，我们将使用模块
以及我们如何处理Python中的异常。
然后你会被介绍几个非常重要的
图书馆叫做NumPy和Pandas。
之后，您将了解自己的表现
使用Matlab进行数据可视化。
然后你就会明白你的表现
使用所有三个库进行数据操作
我刚刚提到过。
在那之后，你将要发展
非常酷的应用，
一个是使用Folium的Web地图的web地图，
另一种是使用OpenCV的运动检测器。
我希望你们发现议程非常有趣。
瓦伦先生将担任讲师
对于这个特定的会议。
他在使用Python方面拥有丰富的经验。
瓦伦，给你。
嗨，大家好。
我将成为这门课程的导师。
我叫瓦伦。
Python简介。
所以问题是
你应该从哪种编程语言开始？
我的意思是，当然，你已经开始了一个
作为本课程的一部分，但戴夫认为
我认为，它必须是Python。
仅仅因为它非常非常简单易学。
在我们开始查看Python代码的一些时刻，
你会注意到它看起来像英语。
它甚至看起来不像代码。
很多人听到字码，
他们开始考虑零和零
或者他们开始​​考虑哦它会是什么样子
你必须解决的难题。
没有那种，真的。
这只是一套详细的说明。
就像你可以写关于如何发送电子邮件的说明一样
还有关于如何发送邮件，如果你可以写得非常，
关于如何发送邮件的非常详细的说明，
你可以编码。
就像那样。
接下来是它是免费和开源的。
所以从某种意义上说，你不需要向任何人支付钱
用于使用Python。
现在，有一个问题可能是，嘿，这有什么新意？
我不需要付钱给任何人说英语，
和英语是一种语言。
但问题是英语，西班牙语，法语，
这些语言，没有这些语言的创造者。
它们通常被开发出来。
所以没有人真正拥有英语作为一种语言。
没有人有权使用英语。
然而，如果你看一下编程语言，
它们是由一小群人创造的。
10,15,50,100人。
100人不是一大群人，
与人相比，它相对较小
谁发展了英语。
开发英语单词的人将是作者，
作家和普通人也是如此。
这个数字将是数百万人
谁开发了这门语言。
所以开源是软件编程的一个概念。
我强烈建议你去YouTube
并搜索开源。
我们会看到一些非常整洁的纪录片，
我建议你看看他们。
但是将这与所支付的费用进行比较，
Matlab有一个付费的版本，
它有一些额外的功能
你需要付钱。
但Python完全免费。
许多Python库都是免费提供的。
有一种名为Wolfram，WOLF的语言，
像狼，RAM，这是非常昂贵的。
你需要购买许可证，你不能只使用它，
这不被允许。
就像Windows一样，您需要支付许可费才能使用它。
现在它是一种高级语言，所以信不信由你，
但实际上这里的前三行是
有效的Python代码。
忘了第四个。
你们中的一些人可能能够理解，
但前三行是有效的，有效的Python代码。
这就是Python的原因。
你没有必要处理正确的方面。
不要想这个，这是你永远不会，
几乎从来没有去看过这个并且应该被认为
弄清楚哦，这是什么意思。
你应该只看这样的东西
并说好，这是什么意思。
然后它便携，便携，你可以使用它
在多个设备上，无论这是一个Window的设备，
或Linux设备。
Python非常兼容。
它将学习不同的设备。
它支持不同的编程范例。
所以范式只是风格的一个奇特的词。
如果你是编程的开始，
除非你有，否则不要打扰它，
你知道600到1000小时的编程。
根本不用担心。
这与您无关。
但是，如果您有一些编程经验
而且你知道编程范式是什么，
只知道Python支持多个，对于那些人
不知道，不要担心。
你最终会到达那里。
我不是说这不重要，重要的是，
它就是现在就像跑步一样。
就像现在一样，如果写一行代码是
起点，就像绊脚石或爬行，
思考范式和编程风格
有点像跑步。
所以我不建议考虑太多。
接下来是Python在可以的意义上是可扩展的
从Python调用C和C ++库。
所以你可以调用其他语言的代码
使用Python。
这样它是非常可扩展的，
增加它的可用性。
使其与其他系统一起使用。
所以Python也被许多公司广泛使用。
让我们看看几个巨头。
所以这包括YouTube，Google，Dropbox，
RaspberryPi，BitTorrent，
美国国家航空航天局，Netflix，NSA，
我的意思是，它就像是惊人的，对吧。
我的意思是，你看看各种各样的差异
这些公司是。
他们是互联网公司，你知道，
国家空间机构，国家安全机构。
真的虽然广度和深度。
所有人都以某种方式使用它。
所以不是你不应该说嘿谷歌
是基于Python构建的。
不，Google使用10种语言。
对，这是一家大公司。
Dropbox也是如此。
哦顺便说一句，Python的创建者适用于Dropbox。
他确实为Dropbox工作，而且他有
他的合同是他将投入一定的比例
他的时间，大概是他30％或40％的时间，
用于开发Python。
这就是他得到的东西
作为他的工作合同的一部分。
当然，他是一个非常着名的人。
不是普通人，或者我猜你也是，
能真正谈判这样的事情。
但是，是的，因为他是Python的创造者。
但是，关键是最好的地方
在硅谷和政府机构，
他们正在使用Python。
现在最好的部分，是的，这是我最喜欢的部分，
因为Python真的适用于那里的大部分事情
就像你想开发一个网站一样，你可以使用Python。
你想做数据分析，你想做数据科学，
你可以使用Python。
你想做自动化测试，你可以使用Python。
你想从互联网收集数据，
这是网页抓取，即提取数据
从网站上，您可以使用Python。
现在一个谨慎的事情，你不需要做所有
可以说你是一个Python，
一个初学Python开发人员。
比如说，我从来没有做过这个测试。
我从来没有真正做过刮刮。
我知道它是如何完成的，但需要注意的是
这些之间存在很小的差异。
那时你必须学习一个全新的东西
那你就是这样做的。
你必须学习与之相关的概念，
但这更像是商业逻辑
而不是编程逻辑完全改变。
对，很多人心中的黄金问题，
这个行业有Python工作吗？
所以这是Indeed.com的工作趋势。
不要专注于小百分比，我知道它们很小，
但他们是工作总数，好吧。
他们不仅仅是，它说.85％，但可能是
招聘1000万或1500万个职位。
所以你可以注意到这个趋势对Python的好处。
它有点横向，但随后它继续这样做，
但如果将它与PHP或C ++进行比较，
绝对是巨大的差异。
当然，人气。
这更相关，
社区发展了多少？
这表明Google趋势会指示两种搜索
通过经验或新人使用Python这个词，
一切按行业划分。
即使我必须聘请Python开发人员
我可能会去Google并说雇用Python开发人员
然后它会出现在这里。
所以这是一个整体积累。
这是对Python比较流行程度的总结
到其他语言。
像这些索引一样，99,66，等等，
这些都是指示性的。
那么让我们来看看如何安装Python。
到目前为止，我们有点理解什么是Python，
为什么使用它，什么是编程，为什么使用它。
我们来看看如何开始。
现在，开始吧，第一件事当然是，
买卡，或者获取Python。
你去Python.org，你去了下载标签
并下载最新版本的Python。
3.6,3.x是最新版本。
2.X也在那里。
它被很多项目使用，甚至是我的项目
这些天使用2.X，因为他们有一个，
现在12到15个月，那种项目
我正在努力，所以我的意思是，并不是你做2.X.
对于Python中的一个大的（语言不清楚）来说，这不是那个
具体来说，你会发现大量的差异
介于2.X和3.X之间。
我的意思是，就像你知道的那样，拥有一辆汽车然后就是这样
该车的运动版或加号版
或豪华版的汽车。
普通用户的差异很小，
但如果您是Python用户，那么您当然可以找到
显着差异。
但不要被它混淆。
这并不是公司告诉开发人员你知道的，
知道Python 2.7并且不知道最新版本。
就业市场并不像那样。
他们会选择Python。
他们会问你是否了解Python，然后是版本
差异并没有真正造成太大差异。
您打开链接并单击运行。
点击立即安装。
这个非常重要。
如果您已经安装了Python而忘记了
或者你出于某种原因取消选中此项，
请返回，卸载Python，然后重新安装，
并确保您选择了此框。
如果你不这样做，什么都行不通。
请拜托，请按照步骤操作。
就是这样，你已经完成了。
就像您现在在系统上使用Python一样简单。
有一个Python GUI开发人员。
接下来是Python IDE。
一个问题是什么是IDE？
IDE是一个集成开发环境。
它用作代码编辑器，包括一系列并行
其中的组件和附件。
抛开那些花哨的话，如果你能问我，
嘿，我可以编写代码还是可以在记事本中编写Python
还是Word文档？
我对这个问题的回答是肯定的。
现在，如果你问我应该在记事本中编写代码吗？
我的答案是否定的，请不要，永远不要。
所以你得到了不同，你可以做到，但你应该做到
绝对不会这样做。
所以这不是你的代码不能运行或者什么的
那种，只是IDE是有意义的工具
这样做。
它们是专门的开发环境
为你编码。
它以某种方式帮助你。
这是有道理的，对，因为编程可以非常
没有他们很难。
所以一定要选择一个IDE并坚持下去。
有一点你注意到，有行号。
顺便说一句，这些非常非常有用。
正如您将体验的那样，如果您正在与另一个人交谈
开发者，与他们交谈的最佳方式是第三行
然后在这个特定的行上编辑。
你能开始从这一行读到这行吗？
这就是我如何处理许多情况。
我会谈谈某个行号。
好吧，让我们打开一个叫做终端的东西。
所以在Mac和Linux上，这将被称为终端。
在Windows上，这称为CMD。
参见第二单元，搜索CMD。
一旦安装了Python，你可以简单地输入
在命令行上输入Python，然后按Enter键。
它打开了Python解释器。
我可以在这里编写Python代码，它可以工作。
这是有效的Python代码。
它配备了帮助功能。
如果我输入帮助后跟括号，
它会为我提供帮助。
如果我输入关键字，对，那么有一些事情
在编程中称为关键字。
让我放大一下，是的。
所以我可以退出Python。
看看定义。
让我们开始吧。
我将向您展示这是如何打开Python的
翻译，你只需要去特定的页面
并键入Python，它将打开它。
我们来Pycharm一会儿。
在Pycharm中，它的工作方式当然是
我已经有了这个，但万一你没有这个。
所以，让我们一起删除它们。
您需要做的是创建一个新项目
然后你需要给它一个名字。
这个名字可能是测试的
你做了一个创造。
我们在当前窗口中打开它。
一旦进入当前窗口，我能做的就是这样
我可以去新的，然后我可以选择Python文件。
我可以给它起个名字。
自动创建测试作为pv扩展
它存储它。
即使你进入一个系统，你会发现它有
已创建，您可以开始编写Python代码
在这里。
现在编程有一些叫做评论。
很多时候会发生什么，你会写一篇文章
代码，但你会忘记它的作用。
这不仅仅是你经历过的事情。
这是标准的事情。
即使我写代码，我也可以打赌我的生活
那三天后我会忘记它的80％左右。
我会知道它的作用，但如果它不止于此
100行，我将不得不通读它。
现在开发人员为这种情况做了什么
他们添加评论。
评论只不过是简单的英文解释
因为你做了什么，所以你不需要提醒
你自己一次又一次地做着这个特殊的事情。
它只是有助于跟踪，就像笔记一样。
它就像小笔记和编程语言
基本上忽略它们。
现在有两种方式来撰写评论。
这是该类的新Python文件。
就是这样。
这不是有效的Python代码。
这不是代码，这是英文。
这是编写它的一种方法。
编写它的其他方法是使用三个单引号
你这样写的。
这是该类的新Python文件。
这是你可以做到的两种方式。
目的基本上就是提醒自己
或者其他开发者。
所以这是很多人的一件事
首先，您的代码将被其他开发人员查看
在某一点。
您将开始在公司内共享您的代码
或者其他。
因此，当他们查看您的代码时，他们应该能够
从你的评论中了解它的作用。
不只是整个文件，而不是像这样的描述
文件向数据库说了些什么，但是每个都有
每一步都是沿途。
就像每10道，每行20行代码一样，
应该有一条评论。
这就像是一种最佳实践。
接下来是缩进。
你需要以Python的方式来思考这个问题
像注释系统一样遵循缩进
在社交网络网站上。
所以如果你见过Reddit，
让我实际打开它，好吧。
所以，如果你看一下Reddit，如果你去评论部分，
你会看到有一个嵌套。
你可以知道，Ahah正在回应
由RetardedClownFace或这个家伙回复
通过这个，但这个家伙正在回答这个问题。
这家伙正在接受这个家伙的回复，依此类推。
这是一个嵌套。
你可以看到有一个分裂。
您可以看到此评论是对此评论的回复。
这是我们到处看到的东西。
我们在Facebook上看到这个，
我们在Instagram上看到这个，无处不在。
现在，这就是Python类声明代码块的方式。
所以如果你不熟悉什么块
或关闭，没关系。
当我们进一步使用Python时，你会遇到它
但请记住，缩进是非常重要的
Python中的概念，这就是闭包
或定义了代码块。
那么Python代码执行是如何发生的呢？
您编写代码并以.py扩展名保存，
就像我刚给你看的一样。
代码转换为机器的字节代码
了解。
这是由Python编译器或解释器完成的。
您无需担心此步骤。
它会在您运行文件时自动发生。
它被执行了。
只需要关心第一步，第二步和第三步
自动照顾。
这不是你必须要做的很多事情。
让我们用Python创建第一个“Hello World”程序。
那么你如何写你好世界，我们如何迎接世界？
嗯，这就是我们这样做的方式，就像这一样简单。
打印，打开括号，然后是一个字符串。
这是一个字符串。
你不能写这个，这不行，好吧。
如果你看到，这已经显示错误
当然，这是Python聪明的地方。
Python很聪明。
如果您注意到，则会在此文件下划线。
它已下划线包含它的文件夹。
这告诉你，在你运行之前，
这不会起作用。
因此，无论何时打印字符串，任何字符串都可以
这就像一条消息，对，它需要在字符串中。
使用print语句，使用支撑开口
和支架这样关闭。
如果你错过了支架它将无法工作，你必须包括它。
然后让我们运行它。
所以运行它的方法是右键单击
然后你点击运行你好，
它在哪里引用文件名。
这是它将运行的地方。
这个终端已经存在。
Hello world打印两次。
您好欢迎来到Edureka打印
然后出现奇怪的事情。
欢迎学习Edureka。
这将打印在两个不同的行上。
这是为什么？
我们刚写了一行。
所以这就是它的用武之地，\ n。
这就是它所说的断线字符。
它会打破界限。
如果您正在输入Word文档并按Enter键
它进入下一行。
这是一个新的线条角色。
如果我输入两次，我们应该期待两个空格。
如果你发现它已经消失了两个空间。
如果你再做一次，
让我们假设你做了四次而且你保存并且我们跑了。
它甚至更进一步。
之所以没有分成同一个目的
是因为这里有空间特征。
如果我像那样做，那么它将从同一行开始。
现在看，它调整了。
所以你就是这样做的。
因此，双码可能是单一代码，无关紧要，
但我建议关注其中一个。
这是运行文件后将获得的输出。
接下来是变量，变量非常相似
数学变量在这里。
你拿一个你想要的特定名字。
所以你想将A设置为10，你想将B设置为edureka。
这是Python中的整数。
这是一个字符串。
请注意，现在我们使用单个字符串进行比较
双引号。
您可以打印AB，A，B并注意逗号。
所以，例如，我可以做到这一点
这会有效。
因此，print可以分隔多个字符串或事物
您想通过逗号打印。
所以你看到它们都被打印出来了。
现在让我们来这里，让我们打印出来。
10和edureka都打印出来。
当然他们会带着这些牙套。
所以如果你想打印它，
单独打印，这是一个单独的事情。
我的意思是，你必须把它分开。
但是如果您只想查看终端上的值
这是做到这一点的方法。
现在，另一个例子就是这个。
那么它将做的是它将按顺序移动。
它将X指定为10，y指定为20，z指定为30。
我们来试试吧。
好的，现在当然这是非常方便的做法。
现在是另一种方式，
当然，你也可以这样做。
它会增加文件的垂直长度。
我觉得它不整齐，你会看到方便
这样做的水平。
它更方便。
它只是一条线，就是这样。
这只是一个方便的问题。
否则，这也是正确的，这也是正确的。
正确性就在那里，它只是九号线
比三行更好。
这更简洁。
现在，关于标识符的一个词。
这是行标识符。
当您听到单词标识符时，A和B是标识符。
他们正在为您识别特定的变量名称。
现在围绕它有一些规则。
它用于识别变量函数，类，
或任何其他对象权利。
它以字母A到Z或A到Z大写或小字母开头
或者一个下划线，后跟数字，从零到九。
因此，您无法使用这样的数字启动变量。
它显示错误。
你可以做到这一点，你可以做到这一点。
或者你可以做到这一点。
这有效，但这样做是行不通的。
所以这个，这个，_B，__，
而且所有这些，它们都是有效的标识符。
但你不能用别的东西开始它
字母A到Z，大写或小写，下划线。
你不能从数字开始。
Python不允许使用特殊符号，例如add，
美元，百分比，明星，大括号，
带标识符的感叹号。
现在Python中有一些命名约定。
Python中有一个叫做类的东西，它是一个概念。
也许你们中的一些人对其他程序语言很熟悉。
它以大写字母开头
所有其他标识符以小写开头。
所以只有类名以大写字母开头。
现在还有一些其他规则。
他们与班级有关。
我认为如果我们覆盖它们会更好。
所有这些都喜欢将其识别为私有，
强烈的私人，两个尾随的下划线。
现在所有这些都是我们稍后会学到的一些概念。
让我们留下他们。
但是现在你只需知道那个没关系，
这就是你在Python中命名变量的方式
或标识符。
现在如何存储变量？
有保留的内存位置。
在计算机的内存中会发生什么
这是RAM权利，它创造了一个空间并存储
内存中的那个变量
它保留了一些字节，就是这样。
这就是发生的一切。
它只是记住它们，存储它们。
所以在我写作的时候并不是这样，
它是在我运行文件的时候。
所以现在不会这样做
一旦我创建它。
因此，如果您创建了太多变量，请不要认为
你的打字速度会减慢或你的笔记本电脑
将开始挂断。
不，我的意思是它可能会那样做，
但是当你运行文件时它可能适用于
你知道的不同原因，
只是有太多的变数。
所以，但请注意，这只是一个指令。
这只是说明而已。
当你运行它时，它真的做了什么
在计算机上的。
现在你只是像记事本文档那样输入它
而你正在按控制S.
但是，当我运行它并且通过运行我的意思是我继续这样做，
那就是它进入记忆的时候
它完成了所有这些事情。
是的，所以我们已经涵盖了这个权利，
我们在哪里运行它并打印出值。
现在让我们看一些标准数据类型
可在Python中使用。
甚至在此之前，让我们试着理解它的含义
按数据类型。
现在，数据类型基本上是一种表达某种东西的方式
是一个整数，是一个字符串，
类似于什么样的数据，
无论是数字还是字符串
或者它是一个布尔或其他东西或其他东西。
所以Python有两种不同的数据类型，
或任何程序语言。
一个是不可变的，另一个是可变的。
所以可变和不可变这个词来自，
你需要考虑变异。
你可能在生物学方面学过的那个。
突变从根本上意味着变化。
所以可变数据类型会说它可以改变，
数据可以改变。
不可改变的是它无法改变。
所以列表，词典或集合，
这些都是你要学习的东西。
它们可以更改，但是不可变的数据类型，
数字，字符串或元组，它们无法更改。
现在你可能有一个混乱的来源
如果我像这样做= 121，你可能会这样想
然后我做= 121，或者假设是对的，
我这样做然后我做了= 3，
那不应该发生这种情况。
因为a是一个整数而你正在改变它。
我首先将它设置为随机值121，
然后我将它设置为三。
但这并不意味着什么。
这意味着，看到这只是一个标识符。
这不是数据。
数据位于此右侧。
因此，当它说它是不可变的时，它意味着什么
无论你做什么，你都不能把121变成三个。
如果你认为它有意义，对吧？
所以这是深度的方式，
在编程中发生的事情。
显而易见的是，一个不等于两个
或121不等于三，不能三。
就是这样。
但这是世界上不同的事情
这是世界上不同的事情。
它无法将此转换为此。
就像你不能将黄金转化为白银。
黄金是不可改变的。
黄金是不可改变的，你不能把它变成白银。
你不能把它变成任何其他元素。
但是世界上有某些东西
哪些是可变的，你可以把它们转过来
从一件事到另一件事。
例如，您可以将种子转化为树。
那是突变。
但如果你想把金变成一棵树
或金成银，它不会发生。
它会保持金色，即使你混入其中的杂质。
这将是不纯的黄金，但它仍然是黄金。
所以你需要这样想。
这是一个非常基本的概念，但它是存在的东西
跨编程，实体无法改变。
现在让我们谈谈不可变数据类型，
数字，字符串和元组。
没有Python支持三种不同的数值，
整数，这是标志。
所以你可以在前面添加加号或减号。
有浮点数，它们是实数，小数。
然后有复杂的数字。
在表示数字时，您可以表示
它们有三种不同的方式，二进制，八进制或十六进制。
但请注意，您通常不会使用
这些陈述。
通常，您将使用数字
就像你正常使用它们一样。
所以要定义一个你设置为10的整数，
定义一个10.65的浮点数和复数。
万一你记得这个，或者你对此很熟悉，
这是10 + 6j。
这是虚构的值，将像这样运作。
我们快点看看吧。
我们在这里有相同的文件，让我们运行它，
它输出像10 + 6j。
如果我做10 = 5 + 4j
我打印DC，
让我们看看我能得到什么。
所以，如果你看到，它确实做了减法，
5-10是负五，4-X是负二，得到一个结果。
接下来是字符串，一组连续的字符
任何引用中表示的都称为字符串。
所以无论是单引号还是双引号。
现在，Python不支持字符类型。
这基本上来自其他语言
称为char的东西，作为一个角色。
Python没有那个。
Python只有连续的字符串。
如果你不熟悉角色，那也没关系。
但是字符数据类型与字符没有区别
以字母表的通用方式。
它在编程环境中引用它，
哪里有一个叫做角色的东西，
它是char，datatype，Java，C ++等等。
Python没有它。
Python只有字符串。
它无法区分单引号和双引号
或者不区分单引号和双引号。
正如您已经尝试过的那样，这对我们有用。
我们已经使用字符串完成了print语句。
接下来是元组，所以元组是一个固定的列表。
它在括号内。
例如，即便如此，它的打印方式，
这是一个元组。
如果你看这个，这是一个元组。
我能做到这一点，现在注意到这一点。
我可以打印这个，这将运行。
现在我也可以使用元组执行以下操作，
我可以打印和个别元素。
我可以打印零指数。
这些是零索引，意思是让我改变它，
所以我们假设这些是四肢，对吧。
开始说这是第一个和第二个
第三个。
它适用于零索引。
它说这是零，
这是第一次，这是第二次。
现在我也可以这样做。
所以这是我阅读元组的一个单独元素，
四，五，六。
但是，请注意我是否尝试这样做。
Python已经强调了这一点。
它有问题。
你把它悬停在它上面，它只是说那个元组
不支持项目分配，这基本上是有意义的
嘿，你不能这样做，你不能改变它。
我无法改变这一点，让我来运行吧。
这是一个错误。
它抛出一个错误元组对象不支持
项目分配。
所以我正在尝试更改此数据类型。
这就像我试图将黄金变成白银
并且说抱歉，不能这样做，那是不可能的。
你不能修改它。
现在让我们看看可变数据类型。
第一个是列表。
所以我们只看到一个元组，它看起来就像一个项目列表
但它被称为元组。
但Python也有一个叫做列表的东西。
现在，列表可以包含各种元素
和元素数量，如果你想创建一个空列表，
这是你创建一个。
方括号，打开和关闭，这是一个空列表
没有任何东西。
这是一个包含一个，两个，三个的列表，
还有四件事。
现在，如果你注意到，所有这些都是不同的类型
数据的。
这是一个小数，这是一个整数
这是一个字符串。
你可以打印列表，几乎可以创建一个元组
你可以评估其中的任何元素。
我们来试试吧。
你还可以做的是你可以更新它。
所以我们可以说A等于改变第一，第二元素。
所以，因为这又是零索引，
顺便说说。
就像元组是零索引一样，这也是零索引。
零指数是这被称为零。
它不算是一个。
所以这通常是编程中的工作方式。
几乎所有的编程语言都有这种方式。
所以，如果你看到，我改变了第二个元素。
所以同样的事情是在元组中抛出一个错误，
但是在列表中，它正以这种方式进行。
它允许我修改它。
现在，列表也可以包含其他列表。
所以你知道，你也可以这样做。
而且你也可以做四个，然后是第三个元素
它也可以包含元组。
它里面还可以包含一个元组。
这是一个特别复杂的例子，
不复杂，但通常你会这样
遭遇，但我只是想展示它
说明一点。
列表可以是任何东西。
所以想想英文单词列表，它可以是任何东西。
我在这里做的是我说过零元素，
这就是这个，这是一个清单，给我第二个。
所以它给了我四个。
如果我说一个然后我运行它，它会给我两个。
我也可以在第一个上运行它。
是的，它会给我四个。
如果我需要访问元组，请考虑哪个元素
它是，零，一，二，三，正确。
我想要打印五个，然后我会这样做。
B3来了，我只算数。
我算零，一，二，三。
好的，我得到了元组，直到这一点。
在那之后，我想要访问五个。
它是零，一，二，我去两个。
现在略有不同，列表放方括号，
元组在括号内。
列表是可变的，元组是不可变的。
元组比列表更快，因为这样
它的不变性，但这不是真正的原因
为什么你会使用元组。
如果要获得固定值，则将使用元组。
所以，如果我们假设，你正在制作一个简单的计算器，
你知道哪些可以进行科学计算。
让我们假设使用pi的值
和可以计算面积的科学常数
圆形，圆形或圆锥形等等。
它需要使用3.14，pi的值，
和其他常数，你需要保持这一点
并且需要确保它不会被意外修改
由您或您的编程。
那是你将使用元组的时候。
或者，如果必须维护列表，则可以使用元组
国家/地区因为您不想要国家/地区列表
改变。
在编码时，你不小心想要，
你最终改变了该列表中的元素
因为你知道，它会引起很多问题。
所以基本上，要理解为什么你也需要
思考并理解为什么不可变数据类型
是必要的，因为如果你看一下列表和元组，
这里唯一的区别是 -
顺便说一下，我也可以用元组来做这件事。
我可以做同样的事情。
我可以简单地这样做，看看，我可以运行它。
它会按原样工作。
它只是做了，我只是打印了元素，对吗？
现在，唯一的区别是列表更慢，
但更重要的是，列表是可变的。
所以大多数情况下你会发现自己相信这一点
（演讲不清楚）处理列表而不是元组。
非常具体的场景需要元组。
所以不要为什么我有两个，
我可以使用其中任何一个。
暂时关注列表。
当你出现时，元组自然会来找你
有一个场景。
元组更多的是在利基中，它们是一部分
一个特例。
接下来是字典。
所以字典，顾名思义，就像你想的那样
通过一本字典吧。
naive这个词是什么意思，
岌岌可危的词是什么意思，
苹果这个词是什么意思，等等。
反对每一个字你都会有意义。
所以这个词就像一把钥匙
而且解释就像一个价值。
这是关键，年龄是关键，这是价值。
这是关键，这是一个价值。
如果你看一下，这是非常易读的。
它们被冒号分开，好吧，
并且需要使用它是它使您的数据
很可读。
关键值对是自然而然的事物。
因此，如果您查看填写表单，请填写任何表格
你满满的，
它要求提供电子邮件和密码。
想象一下，存储在这里。
所以在这个意义上，让我们打开它，
所以这就是这样处理的。
现在，假设你也可以争辩说，嘿，
你知道我也可以这样存储它，
为什么我不应该像这样存放？
我会像这样存储它，而不是，你知道，
顺便说一句，哦，你在这里做了什么
是你会使用方括号然后你会
键入了键。
让我们运行一次。
对，相同的输出。
所以你可以争辩，嘿，为什么我不会使用列表
或者一个元组，我为什么要使用它？
所以你不会这样做的一个主要原因
是因为这更具可读性。
想象一下其他代码行，想象一下这是如何声明的
在第一行，你在第100行使用这个，
你不知道什么是零。
你必须不断地参考存储的内容
在零。
但如果你看一下，马上哦，好的，
你正试图印刷这个时代。
因此，对于开发人员的可读性，字典更好。
你会发现你也会使用这些。
再次，所以键必须是字符串。
键必须是字符串，但值可以是任何值。
从某种意义上说，价值观可以是任何东西
它也可以是一个补充，或者它可能是你知道的，
一本字典。
字典中的字典并在其中添加A.
一本字典，所有这些都可以混合搭配。
最后一个是集合，它是一个无序的项目集合。
每个元素都是独一无二的，你使用花括号
用逗号分隔。
如果你注意到，如果你试试看，
一旦你最后尝试过，你可以分配它
但它会自动打印或考虑
独特的。
就是这样，它不会打扰非独特的。
接下来是Python运算符，运算符可以是任何类型
对您的数据类型的操作。
所以两加三等于五，
两个和三个是操作性的，而且被称为
作为运营商。
算术，赋值，比较，
逻辑，按位，身份和成员资格。
这些是不同类型的运营商。
我们来看看吧。
第一个是算术，我们已经完成了很简单
在数学中，a + b，ab，
a * b，a / b，这给你剩下的。
所以这被称为模数运算符，
让我快速向你展示。
让零四模数五给我们四。
然后当然有4 + 5然后4-5，对。
指数是2 ** 3
或2 ** 2，对不起，我误打了那个。
是的，两个，四个，然后有浮动分裂，
这是浮动师。
这将返回浮动。
现在从右到左分配值。
所以首先要计算一下
然后这将被分配。
所以，如果这对你来说很困惑，那就是从右边开始。
它不会从左侧开始。
所以它不会与更多的事情相混淆
它将执行a + b然后将其重新分配给a。
Ab然后重新分配给。
A * b和a / b。
这里写的是简写符号。
所以在Python中你可以，假设我有一个= 2，
b = 3，现在我可以做+ b，然后a是5。
或者我也可以做+ = b
然后a是8。
所以这是因为我再次添加。
我可以再次这样做，对不起，
a，b = 2,3，我可以做+ = b。
这些是提供相同的简写符号
效果，它说a，取左边的，
并应用此操作并使用第二个操作符
然后将其分配给值。
接下来是比较运算符，因此这些给出了结果
这是真是假。
这些给出了布尔值。
所以，如果你做a = b则表示错误。
你说1 = 1它说的是真的。
如果我这样做，那就不等于它会给我一个真正的价值。
我做的比b大，给我一个真正的价值。
如果我做的比b少，它会给我一个虚假的价值。
因为a是2，b是3。
a是5，b是耶，如果你得到那个
困惑，所以少于b，五是少于三假。
五是大于三是真的。
这自然是正确的，我也可以做得更好
等于b，小于等于b。
这些是关键字，顺便说一下，这些不是字符串。
所以这些不是字符串，这些是Python关键字。
在这里向你展示，我也可以像这样分配它们。
如果您注意到颜色，则颜色会有所不同。
这不仅仅是另一个价值。
它在Python中被视为特殊值。
是的，那么也有逻辑运算符，
a和b，a或b，而不是a。
它们几乎是a和b会给我三个。
它会给我更低的价值。
A或b会给我更大的价值
而不是一个会给我假的。
因为一个是真理，没有人会给我错误。
不是零会给我真实的。
所以任何大于零但不是假的东西都会给我
真实而不真实会给我假。
任何不是零而不是假的东西
会给我一个错误并应用not运算符。
回到这是做什么，为什么给予
较低的价值以及它为什么给予高价值。
这是Python与这个特殊事物一起使用的方式
如果我们比较它们，在哪两个特定的东西上，
它会将它们转换成二进制
然后它会自动执行操作
那是（说得不清楚）。
这与二进制逻辑更相关
而不是Python逻辑。
所以这就是你在数学中得到的结果。
你有一个像三和五的数学问题，对吧
三五个
这不是关于Python的，
这更多是关于数学，关于运营商的原因
三和五应该是五和操作
五个中的两个应该是三个。
工作逻辑。
所以我只想把它留给你
重新发现，但这确实是学校的数学。
它与Python无关。
这就是你在Python中的方式。
你只需像英语一样使用它。
所以，如果你注意到这一点，这可能看起来不像英语
对你来说，这可能看起来不像你的代码
现在，但所有这些都是有效的代码。
我也可以做到这一点，对吧。
我可以运行这个。
看到？
我得到的结果是假的。
这是所有有效的Python代码和A或false返回
这个价值。
所以或基本上总是这会返回一个很高的值
并始终返回一个低值。
如果我有一个，但如果我有五个和五个，
并将返回最低值，
在这种情况下，这是五。
但如果我有五个和四个，
它将返回最低值。
或者始终返回最高值。
接下来是按位运算符，这些是在位上完成的，
基本上是二进制AND，二进制OR，
二进制XOR，二进制NOT，
二进制左移，二进制右移。
很高兴知道他们，但正如我之前所说，
你很少会在Python中处理二元运算符。
二进制数，非常非常非常。
否则，当你处理它时，就会发生这种情况
非常像数学。
这与Python几乎没有关系，
它更多地与数学有关。
然后Python也有身份。
再一次，非常非常可读。
所以五是四，
当然你会得到一个假的。
同样，五个不是四个。
我也可以使用变量。
我可以做同样的事情说......
我们当然会，所以你可能会问，
嘿这是什么用途，为什么打印真实
假真假？
当然，这些都是有用的比较。
您可以稍后设置逻辑，如果C是D
然后这样做，否则做其他事情。
所以如果C你知道，假设今天等于星期三。
这是瑜伽日，现在是星期四。
当然，现在你可以建立一个逻辑，如果今天是瑜伽日
我可以运行它。
这是假的。
所以现在注意这是多么可读。
对，就像英语一样。
这就是我喜欢Python的原因，这就是很多人的原因
爱Python，因为它非常非常冗长。
这个词很冗长，更容易阅读
代码并理解没问题，这是什么意思。
它读起来像英语。
接下来是，因此会员运营商所做的就是这样
他们检查某件事物中是否存在某种东西。
所以这适用于词典，这适用于列表，
它适用于元组。
所以我可以做这样的事情，让我运行这个。
四个不在列表中，错误，正确。
在这里我可以做的是，评论所有这些，
是的，所以这是会员资格检查。
它正在检查是否识别出此成员，
这个清单与否。
这适用于列表，它也适用于字典。
在字典中，它将像这样工作。
在A打印年龄
我们只是想检查是否存在密钥。
它说错了。
所以等它在这里说真的。
让我评论一下。
让我评论所有这些。
现在，如果我错误地做了这件事，那就是在这种情况下
它会说错。
再次，为了比较，
如果我这样做的话，当然这一点，
如果我这样做，不要在字典的情况下，
我使用的键不是它的一部分
我运行它我会得到一个错误，关键错误，年龄。
它不承认它。
因此，如果我需要在使用之前检查密钥，
我可以使用这种东西。
现在让我们看一下条件语句
和条件语句用于，
所以这就是我们在这一点上所建立的，
他们是if if else if if。
如果满足条件，则执行某些操作。
如果不做别的事情。
我们每天都这样做。
如果今天是你的星期三，去参加瑜伽课，
否则，没有瑜伽课在家里冷却。
这对我们来说非常自然
作为人类现在，我们自然需要它
在编程语言中也是如此。
当然，它的工作方式是你启动一个程序
这有点称为控制流程。
如果X小于Y，那就做一堆东西吧。
如果不是，则再次检查某个条件。
如果这是真的那么做一堆其他的东西，
否则这样做。
这就是编程如何运作的方式。
所以你想要的很多业务逻辑或逻辑
你的应用程序工作在这里建立。
好的，现在让我再谈谈缩进，好吧。
让我先评论一下这个文件的操作。
所以问题是当你输入指令时
在Python中，你怎么告诉Python嘿，
需要遵循这些指令
并且如果和这些指令在这之下
否则，对吧？
所以基本上这是一段代码。
这绝对是指令所在的代码块
这不仅仅是一条线，对吧。
当然，你在这里写下更复杂的东西。
你可能需要两个，你可能需要写一百行
如果满足这个条件。
你可能需要做一百件事。
现在Python如何知道这是在这个内部？
比如，做到这一点的一种方法当然是，我的意思是为什么我不能
这样写吗？
我可以，为什么不呢？
但是，elif是否会受到疲惫的指导
我一直在写作？
或者它映射到这个？
因为并非所有人都在同一条线上。
我的发言应该在这里还是在这里？
没有围栏。
没有明确的路径定义。
Python通过缩进实现它的方式
我们之前谈过的，
这需要在四个空间的距离。
所以IDE尽快完成它
你有点打字。
如果我正在打字，我们假设X> Y.
我按下冒号，它后面跟着一个冒号，
顺便说一句，所以注意结肠，然后按回车键。
它将自动转到四个空格。
它甚至没有问我。
Pycharm中的Tab总是使用四个空格。
否则你可以自己给四个空格。
所以有一个，两个，三个，四个。
但是如果你不这样做，你的代码将无法运行。
你的代码不起作用。
这不仅仅是，有一个非常强大的原因
为什么会这样。
之所以在Python中这样，是因为
Python的开发人员想要做的
Python阅读精美。
虽然这似乎是一个奇怪的原因，
但是如果你看一下代码生产级代码，
所以我的意思是，如果你看看伟大的代码
软件开发人员，优秀开发者
甚至不够好，甚至不够好，
被认为是好的，他们会编写代码
非常可读，非常干净。
Guido van Rossum，Python的创造者，
想要执行它。
他说这不是一个选择。
我告诉你它通常会有多少
用其他语言完成。
所以在其他语言中，你会有这样的东西。
好的，然后你就会有类似的东西
然后你会有花括号，对吧。
那么你可以假设有一堆线
让我们假设打印X，对吧。
那么这将有很多次打印Y.
现在看起来很脏，因为我的意思是，
我可以缩进它，它会变得更多
可读，像这样。
忽略下划线，因为这不是
有效的Python代码，我只是想在这里展示一个例子
其他程序语言如何做到这一点。
所以他们用花括号做。
它们表明关闭的一部分
或者使用花括号的代码块。
但Python没有那个。
Python没有花括号括起来
一堆指令。
Python有缩进，这个。
基于此，它需要做出决定。
所以如果它是真的那么它就进去了。
如果这是真的，那就进去吧。
否则，最后不检查任何东西，只是执行。
让我们来运行吧。
X <Y和第六行。
如果你只是想做一个if else声明，
你也可以这样做。
您可以在此处添加条件并简单地运行它。
大于25，a小于10，
介于10到25之间
大于等于10。
非常像你在数学中如何写它。
如果这是真的，那么这样做，否则这样做。
请注意，这些和这些都没有关系。
它们都将永远执行。
所以，如果我这样做，我做了10，对，
我们将看到这两个陈述。
所以不到10，在10到25之间。
但如果这是在这之下，现在这是一个if else块，
然后如果阻止。
因为标签。
因此，要确定内部是什么，你需要真正看
在父语句的缩进级别。
所以要打印这条和这条线
需要是真的。
要执行此行，只需要这样。
要执行此操作，此行必须为false，
但这条线必须是真的。
所以控制不会进入这个，但是如果不这样的话
是为了这个外部块。
所以在评论方面，这是一个家长评论
这个人正在回复父母的评论。
它本身不是个人评论，
这是一个嵌套的评论。
如果是这样的话，
那么这两个都是家长评论。
接下来是循环，Python中有三种循环。
循环的目的是一次又一次地做同样的事情
再一次，就像重复一样。
如果满足条件，那么它将检查条件
并且它将根据该条件继续重复
好几次。
因此，值将在到期为止之前执行。
它检查，进入循环体，
否则就会消失。
请注意while循环，再次，缩进块
然后是冒号。
现在，在这种情况下，你正在做的是
我们正在打印告诉折叠。
我们将逐个递增值。
我们要算到四点。
我们来试试吧。
一，二，三，四，然后再见。
一旦计数变为五，就不再是真的了。
它会走出循环。
让我们静音，而不是运行它。
因此，如果排名不等于12，它将打印出来
五点到十一点。
很简单。
所以这是一个你可以尝试的小猜谜游戏。
输入数字10，数字太小。
输入数字15，数字太大。
如果输入数字是12，退出，我的意思是你将结束循环。
恭喜你成功了。
现在for for循环，这是迄今为止最重要的
一个你将要使用的。
它迭代一个单词排列。
现在安排可以是一个列表。
所以如果你想打印一个列表或一个元组
甚至是字典项目，任何集合，
是的，它接管并将增加，
它将继续迭代或踩过
每个项目。
那么让我们来看看这里的陈述。
所以我们有一个项目清单，水果，我们可以做的是
忽略这个。
这不相关。
水果和水果，印水果。
再一次，只需运行它。
所以按顺序运行香蕉，苹果，橘子。
这是列表，然后它将再次做同样的事情。
整个列表，一，二，三，Python。
是的，因此您可以使用列表来单击阶乘
一个数字。
您需要做的就是将数字再现一个
并继续倍增并继续使用它
一次又一次。
所以你只需减去它，乘以它，
乘以它，乘以它然后你会得到一个结果。
当然你可以有嵌套循环。
所以你可以在循环中有一个循环。
同样，同样适用缩进原则。
您可以使用while循环而不是for循环，
或者是for循环而不是循环。
纯粹取决于你正在建设什么，
在你想要做什么。
所以这取决于逻辑，对吧。
让我们假设逻辑就像你写作一样简单
周四的机器人和谚语为零
一百万人继续左脚
而且右脚向前。
左脚向前，右脚向前。
它将继续这样做，直到星期四。
所以它需要花费数百万步，或者让我们假设
这是关于这样的指令。
而白天等于星期四
对于三，四对。
所以你基本上是在告诉全世界
这是周四，只是一直这样做。
这真的取决于你想要做什么
满足您的应用需求。
所以，这是你可以尝试的东西
你可以用Python编写代码，
只需模拟自动柜员机，您需要四位数的密码。
然后你会显示一个菜单，说明平衡
同时提取，支付和退回卡。
然后用户选择一个值，或者您知道，
它不断重复它
或者你可以设置一个限制。
虽然尝试次数不是五次，但请不断询问用户
做出选择。
现在，循环中有一些控制语句。
如果你想摆脱循环，
让我们假设你试图循环一个
（乱码）或某事，
或者你试图循环一些东西和你，
一定的条件是让你想要摆脱它。
你想在那时完成循环。
然后你会使用break语句。
如果满足某个条件，我真的不想这样做
然后它会使用continue语句，
它会跳过循环。
它将跳过它在循环中的位置并转到下一个
然后当然有一个传递声明。
这不仅用在循环中，这在类中使用，
功能，以及其他多个地方。
这用于定义一个空体。
所以，我想假设一，二，三，
我会说通过。
仅仅因为我还没有返回任何代码，
我稍后会担心，但就是这样
我想，因为如果我不这样做那么这就是
不完全正确。
如果你注意到，我不能在此之后写任何代码，
即使它是，你知道合法的真实，
因为缩进，
Python不知道我已经关闭了它。
我会用一张传球。
再次通过是缩进。
告诉Python嘿，这是一种默认的方式，
结束了，然后转到下一行，即24，
并且不考虑尝试在for循环中。
正如我说得对，如果你打印数字
在10到50之间，但是一旦遇到30
你想摆脱循环。
它会停止循环。
如果你真的想要11并且你说j = 5
之后你想继续下一个，
它将跳过这五个。
它将跳过它并直接转到七。
我们来试试吧。
我们假设范围是1到11。
让我们来运行吧。
等等，我需要将所有这一切都静音。
是的，所以如果你注意到这次五次没有
打印，因为我们刚刚跳过了五个。
我把这两个地方放在这里并运行它。
然后它将打印所有内容，因为您正在打印
无论如何，我的意思是，基本上是继续的用例
如果你不这样做，出于某种原因，想要按
您将要遇到的某个值。
如果满足某个条件，则不需要循环
继续之后。
你想要它去下一个。
但是，如果你想要一起打破所有，
你没想到会发生这种情况
它会停止
继续将转到下一个项目。
接下来是命令行参数。
当你执行项目文件时，对，
你可能想要传递某些参数。
争论是它的特定价值。
这发生在Python命令行参数中。
所以Python是一个模块，并且构建的是直的
开箱即用，你不必安装任何东西。
它就像一个库，本质上就是那种模块。
您有一个Python sys模块以及sys模块的功能
是它代表系统。
它首先是您的操作系统，它允许您
访问您传递的参数。
它是命令行参数列表和len（sys.argv）
是命令行参数的长度。
那么让我们看看其中一个文件。
我们实际创建一个文件。
您需要在文件中执行的第一件事是import sys
然后你想说len（system.argv）
然后你想说sys.argv。
现在，我们直到现在还没有涉及的一件事是如何
将运行Python文件。
我正在做的是现在我要去文件夹
其中包含此文件夹DS mod one，好的。
它包含一些字母。
好的，那么所有文件包括test.py.
要执行Python文件，
我需要做的就是运行Python test.py.
然后我需要提供参数。
现在注意参数的长度是六。
它不仅仅是一，二，三，四，五。
文件名本身就是一个参数。
所以这一开始可能令人困惑。
它作为一个论点的第一件事
是文件本身，然后接下来是什么
你给它。
这是一，二，三，四，五。
好的，有.ABD，BCD。
这就是（语音切断）。
（轻乐器）
在我们做任何一件事之前，让我们假设一个问题
或者你想用Python文件做的一件事
你想问用户输入吗？
我们假设我们想写一个简单的脚本
询问用户两个数字并添加或乘以它们
或者用它们做某种操作。
那我们怎么做呢？
答案是Python为您提供输入
功能和输入功能的工作方式是
它是Python中的内置函数。
你调用输入函数，传递一个字符串。
字符串是您想要的消息或问题
问用户。
所以我们假设你想问用户，
给一个数乘以或给一个数加。
这将在字符串之间。
现在无论输入的用途类型如何，
它被存储到左侧的变量中。
该功能基本上归还了你的功能
是它提示用户有一条线，
这是以用户的语言理解的
将能够理解。
用户键入某些内容然后获取该值
并在变量中给你。
让我们看一个简单的例子。
让我对此文件进行评论。
所以它要求我的意见。
让我输入三个，它表示收到的输入是三个
这意味着输入存储在str中。
让我们看另一个例子。
假设您想询问用户的姓名和年龄。
一样。
您提供要使用的字符串。
它存储在此变量中
然后你可以打印它。
当然，如果你想执行这个操作
你可以继续这样做。
让我们快速运行它。
所以我只是遇到了一个错误。
现在发生的是输入预期，所以如果我不是
给它一个数字，如果我给它一个像我的名字一样的字符串，
我必须在报价中提供。
所以如果我这样做会有效。
对于数字，我不需要提供任何字符串。
我们再来一次吧。
假设我将我的名字命名为Varun，那将无效。
如果你输入一个字符串，那么它必须是
在单引号内。
它不能没有单引号。
如果它是一个整数，那么它不需要任何报价。
接下来，让我们看看Python中的文件。
所以，如果你还记得我们讨论过，那就假设你有
构建一个可以为您管理文件的软件，
将它们放在文件夹中，对它们进行排序，依此类推。
Python使用非常简洁和漂亮的材料来成为好文件。
那么让我们来看看。
谈到文件，有几个典型的东西
你需要做的。
您需要打开和关闭文件，即使它是记事本
文件，或者您刚刚创建的Python文件
在第一个之后。
你用任何文件做的事情就是打开它
或者你关闭它。
接下来你需要写一个文件
或者从文件中读取。
然后进行一些维护操作，例如重命名
文件和移动文件或删除文件，
像那样的东西。
所以在我们做任何事之前，你需要了解这一点
打开和关闭文件是怎么回事
在Python工作。
问题是打开和关闭文件是有效的
与模式。
它并不像打开物理文件那么简单
从某种意义上说，有不同的模式
你可以打开Python文件。
有一个只读模式，有一个写模式，
有一个写加模式，用于创建文件
如果它不存在，所有这些都是为了这个
如果一个文件总是打开的意义上的保护
在只写模式下，如果是你可以写的
并一直读到它。
您最终可能会对文件执行某些操作，
某些操作，最终可能会弄乱数据
在文件里面。
打开文件基本上是最佳做法
根据你的目标使用正确的模式
用它来做。
如果你不打算写，是的，
不要在写入模式下打开它，在读取模式下打开它。
当然，关闭文件。
所以假设你正在打开一个巨大的文件。
这是一个500 MB大小的文件。
它包含1000万个地址或名称。
如果你不关闭文件，会发生什么
当你打开一个文件时，它会被加载到RAM中。
如果没有正确关闭文件，则不要这样做
文件的管理位正确，
然后它将保留在内存中并且可能存在
导致内存泄漏。
所以就像要记住的一个预防措施一样
无论你怎么做，都要关闭
该文件需要牢记。
所以打开文件，你将使用open函数
Python
它将文件名作为第一个参数
然后访问模式是第二个参数。
文件名实际上是文件的名称
和访问模式是我刚才所说的。
有读，写或追加。
所以这里是不同的访问模式。
R，这是默认模式，
打开文件以供阅读。
还有一种叫做rb的模式。
顺便说一句，你把它们作为字符串传递到这里。
再次，这将是引号，
string r和string rb。
它打开一个文件，只能以二进制格式读取。
您很少使用它，但它只是一些东西
这是很好的了解。
对于那些体面维护的典型文件，
甚至没有很好的维护，你真的不需要去
对于rb和差异，除非你正在处理
某种格式错误的文件，并不是那么多。
或者你正在做的具体事情
你需要二进制格式的地方。
然后就是r +模式。
它为阅读和写作打开了它。
然后是rb +模式，它会打开文件
用于读写，以二进制格式。
有w模式，它打开文件只写。
如果文件存在，它会覆盖文件。
所以这是w和r +之间的显着差异。
w基本上会覆盖文件，
就像创建一个新文件一样，无论事实如何
它已经存在了。
而r +不会覆盖该文件。
Wb，它打开文件只能以二进制格式写入
和w一样，它也会覆盖文件。
另一种模式是a，它打开要追加的文件，
这意味着它只允许你添加到底部
的文件。
它不允许你部分已经存在。
所以，如果你这样做，这是有道理的
更新或附加到您不想要的系统
防止代码以任何方式被操纵。
Ab它以二进制格式附加。
A +打开文件以进行追加和阅读。
Ab +打开文件以进行追加和阅读
以二进制格式。
W +和wb +是我们已经涵盖的内容。
现在谈到写文件，
你获取文件对象，这是在这里获得的。
你打开文件，你得到一个文件对象。
这基本上是在代码中显示您的文件
然后你说.write并传递字符串
你想写。
当然，写法是我的意思，因为你是
之前和二进制位一起讨论，
您可以以二进制格式打开文件。
所以写只是不带字符串，
它也可以采用二进制数据，而不仅仅是文本。
read方法从打开的文件中读取文件字符串。
而且，它也可以读取二进制数据。
注意计数。
所以，如果你给它一个计数，那就是字符数
它会一次读。
它不提供参数，我们不计算
它会准备好一切。
我们来看看重命名文件。
因此，要重命名文件，您需要提供当前文件
名称，然后是新文件名。
如果你想知道它需要两个参数并重命名
什么是操作系统，它是Python提供的模块
这将处理操作系统。
我们将在以后深入介绍它，
但只知道操作系统代表您的操作系统。
因为在重命名时，通常是这样
在操作系统的帮助下完成。
并不是说您需要了解操作系统
就他们如何建造或书写而言，
但这只是Python中一个非常棒的实用工具。
为了删除文件，我们将再次使用os.remove
和文件名作为它的参数。
让我们快速看一下几个例子。
所以让我们从这开始吧。
我们打开文件，注意模式是w +。
所以文件现在不存在写
但是我们会创建文件。
现在我要循环数字1到10
写下这10行。
让我们看看我是否成功。
完了，我有一个打招呼的文件，欢迎使用Python。
维持，因为这从一开始。
如果我只做零，我们就这样做。
所以让我再次运行它。
现在已经完成了11次。
它每次都会简单地覆盖文件
因为它处于w +模式。
现在，让我们假设我们必须阅读该文件
我们将运行它。
我们做错了什么？
我们在这里做错了的是它处于w +模式
所以它已经清空了文件。
但是让我们再次运行这个并重新运行。
现在我们有一个填充文件，让我们把它静音
现在以r模式打开文件，现在运行它。
现在我们出现了10次。
我们有一个newfile.read。
正如我所说，你也可以把它传递给一个柜台，
所以我可以通过它五，它只会读
一次五个字符。
你得到一个非常奇怪的输出。
不要被它弄糊涂，但这只是它的阅读
一次只有五个字符，这就是原因
它就是这样的。
如果一次读取500个字符，
然后输出会有所不同。
500个作品类似于我们只读50个字符
一次。
所以我认为它第一次阅读所有这些
然后它会读到这个。
现在我们来试试OS功能，
如果你想删除该文件。
我们先重命名该文件
到new.txt。
我们真的不需要打开文件，所以我们可以
删除它，我们可以运行它。
如果您注意到，则已重命名。
那个文件消失了，我们现在有了new.txt。
现在我们可以简单地继续删除。
我们运行它并将其删除。
你注意到它从这里被删除了吗？
所以file.close方法关闭打开的文件。
当然，关闭文件无法读取，万一我是
重新分配新文件。
让我们假设我这样做然后我接受这个变量
我给它分配了一些其他的价值，
Python将做的是告诉它自动关闭
每当我重新分配时该文件。
因此，如果我重新分配，它将自动关闭文件
这个变量。
这就是Python当然非常有用的地方，
因为这是你记得的事情之一，
Python应该是一种非常友好的语言
学习。
现在让我们尝试另一个关闭文件的地方
然后我们尝试写入文件。
让我们看看发生了什么。
它给了我们一个错误。
是的，我正试图从阅读模式打开它
并且该文件不存在。
让我再试一次。
现在它就是，I / O在关闭文件上运行。
它说该文件已关闭。
现在有各种可用的方法属性
在一个文件上。
一个是file.close，我们刚刚看到了。
还有file.mode。
让我们看看我们得到了什么。
所以我们得到了w +。
如果您需要，这用于检查。
您可以将它用于任何类型的检查。
如果你对它感到困惑，就像写一个大的
一块程序，在某些时候有多个文件
你不记得了，或者你想要严格检查
在你对文件做某事之前，也许你不想要
要写入文件或要添加约束，
那就是这会帮助你。
现在file.name当然会，
返回文件的名称。
我们也这样做。
我们也做另一个，我们已经完成了模式
然后还有file.softspace。
让我们运行所有这三个。
所以我们也得到了文件的名称。
Softspace只是返回布尔值，
无论空间角色是否需要，它都是零或一
在另一个值之前打印
使用print语句时
然后有一个模式，有名字
然后是newfile.softspace。
其他一些可用的方法是寻求。
它可以让你通过文件搜索。
它正在寻找特定的东西。
它占用行读取的字符数
创建了许多字符。
同样，seek也需要占用字符数
你可以告诉它嘿，开始阅读40个字符后
已通过。
Tell为您提供文件的当前位置。
这些东西都在文件中，
这是一个职位。
这是文件中的某一行。
所以让我们尝试一下，看看我们得到了什么。
让我们以读取模式打开文件，立即运行。
是的，所以它寻求两个零。
现在让我们把它变成100并看看它是否会改变任何东西
在输出中。
我们看到第二个输出正在发生变化
根据我们寻求多少。
所以，如果我做到1000，如果你去1000线
此时我们也可以做第三次阅读。
这就是说我要找到前五个字符
我要读一读，然后我会去做一个告诉。
这当然是基本的，
newfile.read将读取整个文件，好的。
这不仅仅是读一行，
但它开始在五个字符之后阅读。
所以前五个字符是HEL，对，
然后是空格的两个字符。
它也算作一个角色。
你好，第一，空间，一，二，三，四
然后有新的线条字符。
有一个输入字符，
这使它走到了下一行。
那么，五个字。
我们已经经历了这个，
对文件执行的不同操作。
现在，大部分时间，编程时间很多
你会听到数据这个词。
从本质上讲，编程的内容很多，
关于逻辑，关于数据和处理数据。
如果你的数据类型不同，你如何安排，
你怎么组织他们？
这在编程中非常非常非常重要
并且在Python和Python中提供了一些很好的方法
去做这个。
所以Python有一些叫做序列的东西。
序列只不过是连续的集合
的数据类型。
允许对它们进行不同操作的数据。
无论是索引还是切片，还是别的，
你会看。
想想序列就像你会想到一个序列
在现实生活中，就像一系列自行车，
就像一排自行车站在办公室旁边
或者一排自行车站在红绿灯处。
你需要在展示厅里想到这一点
作为一个序列。
那么让我们来看看序列操作。
最常见的序列操作是串联，
重复，会员资格测试，
切片和索引。
我们来看看连接。
连接只不过是将两件事粘在一起。
所以你在这里有四辆自行车，然后你有四辆
其他自行车在这里。
连接将序列连接在一起，
创建一个新序列。
序列重复基本上是一个序列
并将它乘以一个数字。
因此，创建，复制，对其进行两次排序
项目或它可能是三个或四个，它可以只是
创建这样的项目。
接下来是会员测试。
这意味着你要检查是否确定
自行车的类型是这个自行车系列的成员与否，
从某种意义上说，这不是这项权利的成员。
您无法找到此特定图像或自行车样式
在这里，但这个是成员，
喜欢在这里和这里。
所以这个成员有两次出现
这一系列的自行车。
然后是序列索引的概念，
项目为零索引的位置，在此处引用
作为索引零到零的项目。
这是第一，第二，第三，
第四，第五，依此类推。
它没有索引像一，二，三，四。
很少，我不认为，我知道一种编程语言
这是一个指数。
大多数编程语言都以零索引为基础。
切片基本上是一部分，
这就是说嘿，我想索引一到四，
这是一，二，三和四。
所以我想从这个开始切片
并进入这一个，但不包括最后一个。
所以这不包括四个，这是一个，两个，三个。
所以四减一，三，从一开始。
一个是包括在内，四个不是。
最后一个不包括在最后一个之前，这一个，
当你切片时包括在内。
切片基本上是少量的子部分。
把它想象成从水果中切出一片
或者是苹果。
你正在从这件事中拿出一片，就像这样。
我们来看几个代码示例。
第一个很简单。
你有一个包含课程列表的列表，我们假设，
是编程语言，
Hadoop，Python，Android。
您可以打印列表中的第一个项目。
你可以从零到两个切片，
只包括Hadoop和Python而不是Android。
或者你可以做减号列表。
所以，让我们试一试。
所以它花了Hadoop和Python。
一个打印Python不是Hadoop然后是负面打印
基本上采用列表中的最后一个元素。
负面的是逆转，我也可以做负面的两个
我也可以做三个负面的。
我们来看看。
我们总能做到这一点，加上角度数据科学的反应
我们可以在这里查看输出。
看，所以我们有一个连锁列表，
列出反应，角度，数据科学，对。
这加入了它。
我们也可以做一个列表或分区。
让我评论一下，而不是像打印（列表）。
所以我会在我想要的地方使用不同的例子
乘以三而不是两。
如果你看到，现在同样出现了三次。
这出现过一次，Hadoop，Python和Android，
现在它出现了Hadoop，Python，Android，
再次Hadoop，Python，Android。
会员资格测试，这给出了真实或错误的答案。
所以我可以做Hadoop列表并在列表中做角度。
有些人可能还记得我们已经做到了
最后一堂课。
答案是真是假。
你已经完成了索引和切片。
那么让我们看看Python中的序列类型。
有列表，元组，字符串，集合
和Python中的词典。
让我们逐一介绍这些。
列表，它是Python中最通用的数据类型。
它基本上是逗号分隔的值
在方括号内。
您可以在列表中执行的一些操作是
你可以更新列表元素，你可以得到长度
列表，您可以连接它，正如我刚才所示，
你可以切片，你可以删除列表中的限制，
你可以在列表中重复限制。
那就是乘以它。
那么你什么时候想使用列表？
如果您有一组不需要的数据
随机访问。
所以随机访问的意思是你想要访问
它顺序。
从某种意义上讲，如果你谈论随机访问。
如果你谈论列表四，像这样，或三个列表，
你真的不知道这意味着什么，除非
你知道这个清单吧。
你不知道这代表什么。
当你编写代码时，除非你知道
列表中的第二个元素是什么，
你真的不知道它到底会是什么。
你可能知道这将是其中一门课程，
但是哪个课程，或者它是否是课程名称
或者课程价格，你不知道。
如果您想要按顺序访问它，列表很有用
并处理它。
当然，当你必须处理可能的值时
改变了，所以你可能还记得，元组是不可变的
列表是可变的。
因此，当您想要更改项目时，那就是列表
也会有所帮助。
这是我刚给你看的东西。
您可以索引列表，您可以对其进行切片
然后你可以访问它并反转。
我们来谈谈更新列表。
假设我想安装Java而不是Python
作为第一要素。
我就是这样做的。
就像把它拿出来一样简单
并为其分配一个新值。
我们来试试吧。
现在我们有了一个更新的列表。
它说Hadoop，Java和Android相比
Hadoop，Python，Android。
要删除该元素，您所做的就是简单地说
Python中的关键字是del，它是一个反转函数。
你调用del并将它传递给列表中的项目
你想读的。
但请注意，我们没有通过索引，
我们正在传递整个项目。
删除方式可能在内部工作，它会看起来
对于该项目，然后它将进入并删除它。
看，所以我们删除了这个。
让我们来看看pop，pop会做什么？
如果你有这种类型的列表，它给我们四个。
流行音乐的作用是它只是访问那个特定的
元素并将其返回给您。
如果您注意到该列表，它基本上会删除该元素。
不要认为pop与这样做是一样的。
它可能看起来像那样，因为你可以说嘿，
这是四个权利，
那我为什么不能这样做呢？
但最终pop正在删除该元素
从列表中一起来看。
把它弹出序列。
删除只是完全删除元素，不返回它。
这也是一个名为list.remove的东西
如果我做list.remove三而不是让我们假设
我这样做然后让我们看看这个输出。
这不会返回任何内容，只是删除它。
pop和remove之间有区别。
请不要对此感到困惑。
Pop实际上会为你提供它删除的项目
这样你就可以使用它了。
完成该项目后，或多或少会使用删除
当你不想在列表中。
流行音乐更像是去展厅和骑自行车
从自行车的集合中，而删除基本上
把箱子放在一系列自行车上
并且只是摧毁它。
有区别。
您还可以使用列表中的类型函数。
它只会返回它是一个列表类型。
那么我们这里有什么非常有趣的东西，
它被称为列表理解。
让我们看一下这里给出的例子。
这是Python非常着名或众所周知的一个
Python用户之间的功能。
你基本上可以通过这样做来创建一个列表。
暂时忘记打印语句，我可以这样做。
这样做是你需要从这里开始阅读它。
对于[1,2,3,4,5]中的x。
我知道语法看起来有点奇怪。
首先，它需要在方括号内，
所以让我们删除它一秒钟。
方括号。
它已经是一个列表，但它没有任何东西。
我们看到了什么，我将如何开始写这篇文章
表达式是我在[1,2,3,4,5]中对x说的。
这是有效的，对。
我的意思是，这就像在[1,2,3,4,5]中为x写作一样。
有点像那样。
我只是在这里结束了冒号。
然后我说为每个X做这个，
这是权力二的指数。
现在我也可以做同样的事情。
所以，让我们列出。也可以这样做。
但是，这相当于此。
对于第29行和第31行至第33行，将给出相同的期望。
只是这个写得有点整洁
和调用列表这个理解和Python开发人员
喜欢用它。
仅仅因为它比较单一
三行代码。
好的，我们已经添加了，
所以它将一个项目添加到列表的末尾。
Extend与另一个列表一起使用，所以你可以在这里看到
通过添加所有这些项目来扩展此列表
在列表的末尾。
那么让我给你举个例子。
如果我有这个，我在这里有这个列表
然后我用一，二，三，g，h运行它。
追加是针对单个元素的。
扩展是指有两个列表
你想把他们加在一起
这是串联。
插入，顾名思义，它将插入一个项目
在列表中的特定位置，对。
所以插入了。
如果你必须自己做，你可以想象，
它是可行的，但它会非常麻烦。
所以这将采取指数，它会说没关系，
在这个索引你想要这个值。
在此索引处，即1，您需要此值。
那么让我为你做那件事。
因为你这样做了，
它会在这里覆盖两个，而不是一个。
但插入将插入它而不是删除任何
覆盖任何现有元素。
你已经看过删除了，
它将从列表中删除该元素。
所以还有另一个内置功能
这被称为排序。
它将采用一个列表，并将为您排序。
我们来试试吧。
虽然它会自动排序
这里按字母顺序排列。
好的，所以如果你查看原始列表，你看
在这一个，这个现在排序。
另一件事是，如果你想反转列表，
因此，我们假设您想要打印它
以相反的顺序。
你对它进行了排序，你希望它按大多数原因排序，
但只是通过打印名称，或者让我们假设
您的应用程序中有一个用户功能
可以到A到Z，Z到A.
列表四中的课程和语法是冒号冒号
然后消极的。
打印课程。
所以如果你看一下这个，就打印出了这个列表
从这里到这里的顺序相反。
但原始列表仍然是相同的。
这是一个巧妙的小技巧，您可以使用相反的方法
列表的顺序没有实际反转列表，
这很有意义。
我的意思是，为什么要在同一件事的副本之后创建副本。
所以你可以反转列表并像这样使用它。
现在，另一个有趣的事情是，你可以有一个，
列表本身可以包含字典，
元组，其他列表。
它可以继续下去和任何操作
你可以继续链接它。
所以如果你在这看一下，它就是选择元组
首先，然后在元组上进行切片。
无论你想做什么，
你可以把它连在一起。
元组可以包含更多元组。
金额没有任何限制
你可以做的筑巢。
这完全取决于您的需求。
如果你认为没关系，这个元组将包含更多
元组，你可以继续添加方括号，
一个接一个，它会工作。
所以这是一个更直观的表现形式。
零元素，第一个元素，这个零，一，二，
这个零，一个。
现在你可以在它下面进一步添加越来越多
它可以继续反复做这件事。
现在的问题是即使它是一个正确的元组，
我的意思是你可以修改元组
即使它在列表中。
所以不是任何可变项目都会
如果它在一个可变的序列中突然变得可变。
我们来看看元组。
所以元组是一系列不可变的Python对象。
元组就像列表一样，除了它们之外
从常规括号开始，类似地
它们用逗号分隔。
所以元组有切片，更新，元组的长度
重复，删除，连接。
所有这些都可以作为操作
甚至是一个元组。
元组比列表快一些
在您可能想要使用元组的区域之一
你可能还想在使用时使用元组
你必须处理无法改变的价值观。
所以你上次谈到的时候，
不可改变的科学内容，你没有的东西
想要改变，pi的价值，
只是刷新你的记忆。
如果您的应用程序中有一组国家/地区
你不想被修改，
那时候你会使用一个元组。
所以基本上如果你有一组恒定的值
你想迭代它们，
那就是你要使用元组的时候。
让我们打开我准备好的文件。
让我们运行它，让我们看看输出。
现在长度为3，理智正确。
最大的是Python。
因此，它选择最大值的方式是启动
这封信。
它是升序，然后是最小的
这是Hadoop。
现在如果它里面还有另外一个值，那就是三
或者里面有两个，会发生什么？
让我们来看看。
什么是最小值和最大值？
敏将成为两个。
如果这是一个像这样的大数字会怎么样？
所以连锁总是会赢。
所以它正在观察我们的天空值，这就是它的样子
确定最大值。
所以再次排序和反转的工作方式与字符串完全相同
再次进行乘法和成员资格检查
正如你所见到的那样。
你可以做一个重复，你可以做一个会员测试，
完全相同。
当然，你无法更新元组。
那会抛出错误说出来。
所以这根本不起作用。
如果已经定义了元组三，但当然是元组
三个没有定义你可以将两个东西加在一起。
当然，这会因为元组而引发错误
这里没有定义。
您无法删除尚未定义的变量。
这也是我们在上一章中介绍的内容
我们经历了一些列表的例子
是可变的，元组不是。
现在，正如您所看到的那样，列表可以包含元组，
元组也可以包含列表。
削减两种方式然后当然可以将它链接在一起。
因此excel中的列表可以包含多个列表。
同样的可视化，零，一，二，
那么零，你有零，一，二。
在一个你拥有所有这些元素。
该列表可以进一步扩展，可以继续下去
就这样。
所以不要对此感到困惑。
你实际上是在这里更新列表。
你没有更新元组。
元组更新意味着你在零上做。
所以让我通过一个例子告诉你。
我们假设你有一个元组，零，一，二，
一二三
和四，五，六。
如果我尝试这样做，让我运行这个。
这不行。
但是，如果我尝试这样做，这将有效。
不要为此感到困惑，因为我做了什么，
这件事已经在这个特定元素上完成了，
这是可变的。
这不可变。
这是可变的。
这基本上是一个元组元素，
我现在选择的是什么。
现在这是一个元组元素。
元组元素本身不能改变，
但是元组元素内部是多么可变
它本身就可以改变。
所以你也可以将你的元组转换成一个列表
通过使用list关键字或元组关键字。
你只是传递它，元组或列表，
它只会转换它并将它还给你。
所以我可以这样做，我可以在元组中说，打印元组项目
和打印项目。
请注意区别？
只是括号，但当然，这个不是，
一个是不可改变的，一个是另一种方式。
我当然可以这样做。
我可以做到这一点，然后我可以运行它
现在整个事情就是一个清单。
因此，了解这些转换会很有帮助
是可能的，而不是你需要使用这些。
接下来，让我们看看字符串。
当您查看字符串时，您可以创建它们
将它们用单引号，双引号括起来，
甚至三重报价。
字符串上的可用操作是，
切片，更新，连接，
重复，成员资格然后倒转一个字符串。
我知道一个字符串，这有点难以想象
像序列一样的字符串，但你真的需要考虑它
非常像一个元组，它们是个体元素
无法更新。
开始考虑像元组一样的字符串，其中，
但当然这里的不同之处在于会员
字符串不能是列表。
所以它不能包含另一个列表或它不能包含
另一个元组，自然，
但它可以包含任何字母数字字符。
你需要把它想象成一个元组，
其中每个单独的元素都不可变。
当然，字符串是Python中最流行的类型。
单引号，双引号或三引号。
让我们尝试对字符串进行一些操作。
所以你有一个字符串，你在字符串上有一个长度，
你有第一，第二，第三，
这是会员资格检查。
我们来试试吧。
好的，所以字符串1被打印，字符串2，字符串3，
很标准的东西。
这里的字符串长度是6。
字符串一，二，三是y，t，它是从
一，二，没有达到第三个。
字符串中的T是真的。
如果它是字符串中的Z，那么它就是假的。
我们可以检查更多的个人角色。
现在，如果你注意到，这种行为是的，我的意思当然
现在它看起来像一个序列。
这似乎是一个元组。
我可以做这个。
所以，如果我要给你，让我们假设我这样做
我用这个替换字符串。
让我们看看会有什么结果。
当然这个没有代表
像一个字符串。
长度将是相同的。
是的，但这里的代表，
切片表示将是
有点不同。
原则上，就像它类似，你可以使用它
作为一个衣服类比，它是相似但不一样的。
因为当它切成正确时，它会给你y，t，
在那里，你又得到了什么，一个元组
作为回报，即使是切片。
接下来是Python中的占位符。
现在这些非常非常强大。
他们允许你做的是，
想到他们就像填空。
这就像一个空白，你正在填补它
外面有一根绳子。
现在这是一个更好的方法，这样做，
你有变量的地方。
现在有什么替代方案？
欢迎加上课程名称。
现在这很乱，我会告诉你原因。
如果我必须写这个，你就是这样的
就在它的中间。
这里有一个空间，我必须照顾这个时期
要结束这句话，必须给出另一个空间。
它不是很易读。
如果我在这里做同样的事情，我会这样做，
哪个更具可读性。
比较一下你自己。
现在你知道你要打印什么了。
在这里，它更有帮助的地方
是你有不同的数据类型。
因为如果你不使用它，
完成任务的唯一方法，
你必须使用字符串来转换它
因为否则这不会添加。
Python不会添加字符串和数字。
它不能连接字符串和数字。
它可以添加两个数字，可以连接两个字符串。
这又是非常混乱的。
比较这个和这个。
作为开发人员，您有什么可读性？
重要的是，这很重要。
输出是相同的，但有区别。
这更具可读性。
想想这些就像填空
这些是价值观。
现在这种方式你有很多选择，％s，％i，
而且它们非常详尽。
所以％c是任何角色。
％i是带符号的十进制整数，列表只是继续。
当然还有小数，％f。
我建议你去探索，
但大部分时间你都会使用％s，％d或％f。
现在有一些内置的字符串方法。
一个是大写，它当然会听起来像，
它将大写字符串的第一个字母，
不是其他的。
然后是string.count，它会考虑序列
你给它的字母或单个字母，
开始计算它在字符串中出现的次数。
接下来是编码。
编码基本上是放置它的过程
以某种格式使不同的计算机
可以支持它。
目前最受欢迎的编码是utf-8。
万一你不知道，
继续，请探索它。
这不完全在课程范围内，
但只知道它是不同计算机的方式
世界各地代表人物。
因为如果你看外面的英语，
你看看欧洲语言，你有口音
看看各种各样的印度语言
对于角色是对的，不同的计算机是怎么回事
坐在世界各地都能传播
这是正确的，能够代表
在屏幕上正确吗？
还是汉字？
那是通过utf-8。
所以每当你打字的时候，我的意思是，
当你通过互联网传输时，
它被编码和解码。
这就是编码的全部内容。
Max和min基本上按照ASCII值工作。
所以这里max会给你U的值，
这是最高的ASCII值，min会给你
A的值，这是edureka中最低的。
那么替换做什么呢？
替换将搜索特定字母并替换
所有出现的都是替换的
作为第二个参数。
这是第一个，这是第二个。
这是它应该替换的次数。
如果您注意到输出，它没有替换第二个e，
它只是取代了第一个。
Str.upper将把所有字母大写。
所以资本化只是第一个资本化，
但鞋帮将把所有这些都资本化。
接下来是索引，现在与find相同，但是有一个例外
如果找不到索引。
所以它会找到你的字母k的索引
在整个序列中。
这有点像列表或元组中的搜索操作
在哪里你试图找到哪个位置
特定元素或特定项目
顺序。
所以，如果你看看k，零，一，二，三，四，五，k。
这就是在edureka发生k的地方。
对于更多的字符串方法，当然是逆转，
切片，你已经完成了这个。
现在找到类似于字符串，但是如果它没有找到
什么都不会给你一个错误。
所以，让我们看看，它给你一个消极的，
它没找到任何东西。
而另一个人会做什么，哪个是索引，
它会抛出一个未找到的错误。
所以索引基本上是在假设你的情况下工作的，
开发人员或其在逻辑中的任何人，
已经检查过它是否存在。
它不会帮助你检查。
所以find正在帮助您确定它是否存在
如果存在，在哪里。
索引只是告诉你在哪里。
它不会，它会抛出一个错误
如果它不存在。
字符串连接，这是你有的东西
已经看到了，字符串一开始两个，
那只会倍增它。
快乐学习，快乐学习。
如果你看，请注意这一点，对。
它会成倍增加并打印字符串。
它只给你两次字符串。
接下来是套装。
Set基本上是一组无序的独特物品。
请注意，这些项目必须是唯一的
和set由分隔的值定义
用括号内的逗号。
您也可以通过调用内置函数来创建一个集合，
设置，非常像我们看到列表和元组。
快速运行这个，看看我们会得到什么。
如果你看到我们在这里有一套，
包含各种价值观。
他们已经自动订购了。
所以问题是你什么时候使用套装？
答案是，如果你想收集独特的字符串
或序列中的整数值，
那是你的意思，因为它不重复它们。
如果你注意到这里它没有重复任何
这些元素，即使e多次出现，
我们只看到一个小e和一个资本e。
所以，如果有多个重复，
它会给你一些独特的东西。
一个例子是让我们假设大学管理
在信息感受期间遇到问题
学生输入相同的密码和ID。
现在，set支持独特的元素，我们可以转换
ID和密码列表集合和获取
独特的，因为它只会收集
独特的，并确保重复的
未输入数据库。
现在，集合中有各种可用的操作。
其中一个是工会运作。
这是使用这个管道操作员的一种方式，
所以它可以在你的键盘上使用。
它可以在不同键盘上的不同位置使用
但通常它在反斜杠键上可用
你需要在筛选中使用它。
现在，如果你有这样一套，一，二，
三，四，然后是另一套
三，四，五，六，
并且你打印了一个联盟B，你将获得两者的联盟。
但同样，没有重复。
它将两者结合在一起，没有任何重复。
看看这个例子。
所以它将它们结合在一起。
同样，你有A和B.
这是十字路口。
它会给你两者之间的共同点。
这两者之间的共同点是三和四。
这就是它给你的东西，常见的，
三和四。
这是交集，所以你也可以想象
它像维恩图一样，是一个共同的交叉点
两者之间。
然后也有差异，即A减B.
A中的所有值，
它不应该是B里面的值。
所以我们也试一试。
试着想一下答案可能是什么
让我跑吧。
所以A减B是一，二，三，
四，五，六，七，八。
这是B，交叉点是B.
您也可以将A视为这样。
减号B也是如此，这两者都是相同的。
A和B之间的常见内容将被删除。
与已经看到的非常相似的东西
按顺序，成员资格测试。
您还可以在可以检查的位置进行子集检查
如果一个集合在另一个集合中。
在那里你需要想象B包含A.
所以A是B的子集。
当然，通过会员资格检查，您也可以
做相反的事情，而不是。
你可以做超级套装。
所以对于set和super set，让我们尝试使用它。
让我们看看set one是否是S的子集。
答案是肯定的，它是一个子集。
但是如果你添加一个C值，那么它不是一个子集。
子集是它基本上所有的元素
在集合S的所有元素中找到集合1的集合。
接下来的检查是，如果S是一组超集，
它包含集合1的所有元素，
这是真的。
现在，如果我们将它标记为C，现在我们运行它，
那么它是假的，因为S不包含所有元素
第一集。
但是，如果我们将它设置为C，现在我们运行它，
那么它又是真的，因为现在，S集包含了
集合1中包含的所有元素。
现在，类似于追加，set有一个叫做add的东西，
你可以在哪里添加一个元素。
那么，我们来试试吧。
您添加了一个元素，它会自动对其进行排序。
如果要删除元素某个索引
你也可以这样做。
这是我们将尝试从集合S中删除一个。
然后你也丢弃了，你又提供了一个索引。
删除和丢弃之间的区别在于
remove将从集合中删除元素。
丢弃只有在存在时才会将其删除，
这意味着它不会抛出错误
如果元素不存在或将删除错误。
Pop的工作方式与list.pop类似，它将删除
元素并将它还给你。
S.clear将删除集合中的所有元素。
这可以创建一个空集。
所以我们也试试s.pop。
你现在所做的是.pop。
所以它基本上会删除其中一个元素，
在这种情况下，这是第一个在这里。
所以你也可以打印。
是的，它将删除一天，然后设置是
一，二，三，B
接下来是字典，让我们深入介绍它。
Dictionary是键值对的无序集合。
如果您有大量数据，通常会使用它，
如果它不是连续的值，它基本上是混合的
您想要存储在数组中。
如果它像是一个人的细节，那里的数据
关于一个人可以采取各种形式。
所以只要想想你的面部轮廓，或想想你的面部轮廓
任何社交媒体资料。
你可以得到你的姓名，姓氏，地址，
你可以有兴趣。
所以你知道的时候和各种各样的数据，非常有点。
你可以有你的年龄，你可以让你出生一年，
你可以找到你的工作，你所在的工作岗位数量，
就像你现在的工作一样。
所以所有这些东西，所以你将使用的字典
在这里，含氢数据呈现真实的生活情况
或现实生活中的实体。
你什么时候使用字典？
所以一个例子是，如果你想创造，我们假设，
任何你知道的，你想要的数据安排
存储名称，Aadhar卡号，
社会安全号码。
您创建过的任何Excel工作表，都是这样的
每个标题的字典示例
是键，每行都是一个值。
名称将具有多个值，键是名称。
所以，当你问的问题是什么名字
这个特殊的人排在第10排，
第10行的名字是什么
或第10行的社会安全号码。
然后答案就是，社会安全号码
是其中一个输入，这是关键
因为你可以一行一行地进行检查
哪些数据对应于什么序列
字符代表。
这取决于标题。
所以它可能充满了数据和语境化
通过标题发生。
非常简单，这就是你创建字典的方式。
给你一个和两个所以它可以有整数值
同样，但通常它会有字符串值
因为整数值是使用的东西
在列表中也是如此。
所以它并没有真正帮助那么多。
字典的要点是它立即制作
可读的感觉。
从某种意义上说，如果我要创建一个人字典，
我会说名字，说姓，年龄。
我会说像城市，然后是什么字典
允许我这样做是通过键访问元素
在方括号内，
这比你知道的更可读，整数。
所以，如果它是一个数组，我可以做这样的事情
排序，让我们假设你知道同样的事情，
但我们假设它是这样的。
让我们比较两者，是第56行更具可读性
作为开发人员，与第58,59行相比。
你不会知道两个人究竟是什么意思，
是否作为年龄。
它会导致各种各样的问题。
因此，了解哪些数据非常非常重要
结构使用这个元组，集合，你可以有自己的方式
在某种程度上与它。
就像在某种意义上一样，想想如果你
必须在墙上钉一个钉子，你可以用一块石头
但是，或者你可以使用很多其他东西。
你可以使用锤子，但是你可以使用螺丝刀。
但如果你使用的是锤子，那么基本上就是锤子
不能做螺丝刀的事。
螺丝刀不能像锤子那样做。
使用合适的工具来完成正确的工作，
这就是存在不同类型序列的地方。
因为他们根据不同的工作做
你在哪里使用它们以及你正在使用它们。
更新非常相似，你只需要索引，
你拿钥匙。
因此，如果我是，例如，更新年龄。
让我们假设我这样做然后我就这样做了
你会发现这会起作用。
是的，现在年龄更新了。
所以这是一个可变的数据结构。
我可以再次删除del关键字。
这是del关键字，我告诉它哪个特定
要删除的密钥。
所以我会说嘿，删除城市密钥，我不再需要它了。
打印人，我们将运行它。
就是这样，城市消失了，我已经删除了它。
一些内置函数，字典的长度，
这是键的数量，基本上它会经过
键的数量不是与值相对的。
String基本上会给你一个字符串表示
字典。
这对于进行Web开发尤其有用
而且你正在处理JSON数据结构。
Type只是Python中的word方法，
这会给你任何变量的类型，
如果那是一个字符串或元组或列表
或者一套或字典，在这种情况下，
或整数或小数或其他。
给定一个类对象，它只会给你它的类型。
如果我尝试打印一些东西，有一件事
这不存在，所以让我假设我删除了人的城市
现在我正试图访问它。
说它会抛出一个错误。
你会在Python密钥错误中非常常见。
字符串特别在这里这个键
不存在。
你想要访问什么？
就像，我不知道你在谈论什么。
现在，万一你不想要错误进来
在这种情况下，它不是避免错误的方法
但这是一种更安全的方法。
那么当你得到的时候会发生什么
它将返回null或none。
你仍然可以对此进行检查。
你可以说，如果是person.get city，你住在哪里
只是用这个，人得到了城市。
但问题是，你不能这样做
这件事是因为它检查这条线的那一刻
它会抛出错误。
但这只是忽略它。
它可以做别的，打印，找不到的城市。
找不到这个人的城市。
现在，有一些非常有用的方法，一个是.items。
它将返回字典中的所有项目。
所以如果我想获得person.items然后另一种方法，
这是键，它将返回所有键
在字典里。
让我们来运行吧。
所以person.items基本上会返回一个元组列表
用里面的键和值。
钥匙只会返回钥匙。
这是名字，姓氏和年龄。
这将出现在元组内部。
当然，还有dict.copy可以创建的地方
字典和dict.clear的副本，
这将清空所有元素。
复制基本上只是你总是可以创建一个变量
但是复制就像一种更安全的方式，
除了分配给另一个变量
因为它做了很深的复制。
所以这里需要注意的是发生了什么
有时候是字典，因为字典
在Python中，好吧，他们没有订购。
所以你无法确定我是否创造了单词，
它会以某种顺序出现。
所以，让我们看看我们会在这里得到什么。
所以当然，它遍历键，
它不会迭代值。
但如果你看一下，这里没有订单。
这是城市，名字，姓氏，年龄。
没有明显的顺序，它已经做到了这一点。
但如果你想按顺序做，
你想按照那里的键的顺序迭代它，
你希望它遵循一定的顺序。
这就是你要做的。
你会得到钥匙，你会对它进行排序
然后你会迭代它。
所以这就是你想去词典的时候
以有条理的方式。
您的词典可以包含词典作为值。
它可以包含元组。
它可以包含列表。
它可以像这样继续下去。
您访问它的方式当然是，
用方括号表示并继续访问
直到你得到你想要的东西。
（愉快的器乐）
为什么我们需要功能？
我们假设您需要编写一个计算程序
数字的阶乘。
也就是说，如果给你一个四号，
然后它只计算四个阶乘权利。
只有四到三成二合一。
所以你要保持乘以相同的数字
除非数字是一个。
四减一是三，三减一是两，
两减一是一。
你把四到三分成两分为一。
这是一个四因素。
现在这里给出了阶乘的逻辑实现。
您只需从用户输入一个数字。
您可以设置要计算的因子
如果数字是正数，你会不断重复
阶乘，你继续在这里乘以，
如此特定行所示。
所以你从范围L到逗号和数字加L
并且你一次又一次地继续计算
然后再次。
现在，以这种方式思考它。
我们假设您需要多个因子
在你的程序中。
你想要计算一，二，三的阶乘，
四，五，喜欢不同的数字。
它不是固定的数字。
你必须在多个地方做，
不只是在一个文件中，你有10个文件。
你该怎么办？
您是否应该复制，一次又一次地粘贴代码？
你可以这样做，但问题是它不会
最佳方法。
作为开发人员，您的工作就是编写代码或逻辑。
你的工作不是一次又一次地复制粘贴相同的东西。
我的意思是，这是职员的工作。
所以记住这一点。
这样，如果你开始考虑这种方式，
为什么我会写类似的东西或句子
或一次又一次地到我的电脑，
看看你是否可以将它们组合在一起。
什么是功能？
函数是有组织的可重用代码块。
正如我所说，你必须一次又一次地使用这个功能。
这就是这个定义的来源。
该函数是一个块或有组织的可重用代码。
通常，当您创建一个函数时，
意图应该只做一件事而且只做一件事。
所以你可以在这里看到，如果你只是那样
把逻辑放在一个盒子里实现析因
然后使用此框输入，然后输出，
就像我们在数学方面做的
所以y = x + 2，其中y是x中的函数。
所以以类似的方式，你给输入你得到一个输出。
现在这是一个非常强大的想法。
正如我所说，无论你认为自己在写什么
相同类型的代码，多次，
你正在重复自己，把它放在一个功能中。
你如何定义调用函数？
让我们深入研究一些代码。
因此定义函数的方法是def键
写在函数的名称。
这里我们要创建一个名为add的函数。
接下来发生的事情是它可以传递参数
通过这个函数，这是输入值。
所以A是输入值，B是输入值。
在这个函数中，它计算总和是做什么的。
所以当然你也可以这样做。
A等于1，B等于2，
你可以说像A + B这样的东西。
就是这样，你有钱。
但为什么要把它包含在一个函数中呢？
因为如果你这样做，下次你有
计算A的值或B的值，
计算B的新值
你必须再写一遍。
所以把它放在像这样的函数中会更好。
然后你可以调用它来获取不同的值
你需要它。
现在这是函数定义。
最后一个陈述是书面陈述
返回任何输出。
你必须明确要求它返回一些东西
或者你需要的任何东西。
它不会自己承担。
原因是，让我们假设你有另一个
变量在这里。
现在，如果我们自己不知道它们是相同的
总和或差。
因为指令在函数中可以很多。
所以你不知道你想说哪一个。
所以你必须明确你想要它
返还总和。
现在要调用一个函数，我们需要做的就是它
你需要写出函数的名称，
按照括号，然后输入输入的值。
所以你看，我正在重复使用这个逻辑
一次又一次。
我们来试试吧。
如您所见，我只需输入print add（1,3）
然后打印添加（4,5）。
我刚要求打印输出。
我们来试试吧。
看看是否没有参数。
让我试试一个不同的数字。
我们再次获得输出。
所以这就是你调用函数的方式。
现在为什么需要使用return语句？
所以当我在谈论它时，
终止函数的执行。
它还返回一个输出。
所以当你看控件的时候还有另一件事
函数，代码在哪里，
口译员在哪里？
你需要以你打电话的方式来思考它
打印添加，这一个。
控件传递给add函数。
使用add函数然后逐个执行，
逐一。
然后它将控件返回到第七行
然后程序进入下一行。
然后再次进入，然后又出来了。
但是使用return语句。
回归真的有点像，想一想，
你在哪里归还某人？
它不仅仅是返回一个值，它还会返回
控制功能的主要部分，
即使在第七行之后它还需要执行的地方。
它需要上线八。
所以这就是主要的概念。
我们假设您有两个文件。
其中一个是one.py，另一个是two.py.
让我们假设有一个人有这个功能，你正在打印
out.py中的函数顶级。
它有这种情况，
正在检查一些非常奇怪的东西。
但下划线强调名称下划线，
它就像文件中存在的隐形变量。
好的，隐形变量排序在文件中，
这是检查该变量的值
是主要的，那么这需要打印，
否则这需要打印。
让我们来看看这个。
所以你可以看到，one.py中的顶级。
当然，这会被打印出来。
当我们执行one.py时，One.py正在直接运行。
所以这个名字并不是主要的。
现在让我们看看两个。
在你所做的两件事中，你正在进口一件
作为模块。
你在这里做的事情就是打印
将直接运行two.py和one.py中的顶级。
所以使用two.py让我们看看能得到什么。
最高级别为two.py.
因此，当我们执行两个时，而不是这个第四行，
我们首先在one.py执行中获得最高级别。
现在怎么样？
这是因为只要将文件导入另一个文件即可
Python文件，无论代码是什么
在里面被执行。
如果有一个文件写在里面，
一旦你导入它就会被执行。
这并不意味着它必然表明它会
引起任何问题。
发生这种情况的原因是因为某些变量
需要定义。
某些变量和功能，它们需要来
进入该文件的计算机内存
某种礼物。
然后我可以加载那些东西和程序
包含此功能将用于Python
是人们会宣布某些默认值。
他们会希望某些事情发生
如果导入文件。
因此，选择设计是存在的。
如果您导入文件，这不是一个缺陷
它会被执行，因此导入文件是一个不好的功能。
所以文件被执行了。
现在这个被执行然后如果你看到了
这次正在导入one.py
另一个模块被调用。
嗯，一旦你跑步，它并不意味着模块，
可能是主模块，它正在调用它。
但是因为你从two.py导入了它
不是主要模块。
这是两个模块呈现的两个模块，它正在调用它。
现在，最后我们在two.py打印顶级，
然后我们调用函数，one.function，
函数在py中然后最后，为了two.py得到
那个two.py直接运行。
与此相同的行为
我们进口了一些东西。
无论是执行还是其他文件
得到印刷。
如上所述，如果one.py文件返回语句
从此只被执行。
然后运行two.py文件，首先是one.py中的语句
从two.py执行then语句。
而不是以这种方式思考它，
来自one.py的陈述，你还有其他陈述
来自two.py.
想一想，输入的顺序是什么
声明？
然后把它放在最顶层，然后抓住文件，
然后是它先导入的其余行，
一些在中间，然后在two.py中的一些初始结束
然后是另一个文件中的行。
所以每当导入发生时都会有类似的感觉。
这是关于代码中的哪个位置
导入是否发生在。
接下来让我们看一些内置函数。
所以内置函数是给你的函数
通过Python开箱即用。
这些只是一些常见的实用程序或功能
无论什么样的编程，你都会使用它
你在的语言。
几乎所有的编程语言都为此提供了支持
Python也是如此。
所以内置函数是内置的函数
已经可用的Python，可以访问
任何用户。
现在，这些功能很快就可以使用了
当你第一次加载Python时。
例如，您看到了print语句。
实际上，打印也是内置功能。
您不必编码打印或启动其他内容。
它很快就可以使用了
因为你安装了Python。
这里给出了一些常见的内置函数。
排序，绝对，全部。
我们现在逐一看一下这些。
因此，在谈论已排序时，它会返回一个新的排序列表
来自可迭代的项目，
也就是说任何数组，元组或列表，
任何元组，列表或序列。
这就是它将回归的东西。
我来这里给你举个例子。
所以你看，它给了我们一个排序列表。
所以它检查是否可迭代，这又是
序列，列表或其他任何东西，
如果所有元素都是真的。
所以它检查它们是否真实。
所以这并不意味着我们都喜欢，真正的逗号，
真正的逗号，真的。
它可以是真正的逗号，一个逗号，两个逗号，三个。
即使一，二，三是真正的价值观，它们也是真的。
所以它只是Python标记它们的真实模式。
什么被认为是真理价值。
这可能是另一种数据类型。
它可能是字符串，任何非虚假的东西
或者没有或为零。
这些是真正的价值观。
假设我将此更改为none，没有为true值。
只有当一切都是真的时，它才会发出两个
Python存储它。
这是真正的t值，它不是真值
但它有点像积极的价值。
所以从积极到消极的角度考虑它。
让我们假设我将其更改为零，再次为假。
我把它改成假，当然是假的。
另一方面，任何功能都是相反的。
也就是说，它会给你所有相反的真实情况。
因此，即使其中一个是真的，它也会返回真正的价值。
如果你去第一个例子，
即便如此，它至少会回归真正的价值
其中一个是真的。
但是如果我们把它当作假而没有，
那么它会给出一个错误的价值。
接下来是布尔函数。
它使用Python将值转换为布尔值
真相测试程序。
真相测试程序在哪种情况下都是一样的
适用于任何这些迭代中的所有迭代。
想想它内部调用bool为零或无。
我们的一个人是积极的。
布尔尔布尔也是积极的。
在某种意义上它是一个字符串。
正如您所看到的，这就像任何或所有。
他们肯定会使用像bool这样的东西来确定
如果传递给它们的值为true或false。
所以这真的是任何或所有的原子版本。
接下来是chr。
所以它返回一个表示字符的字符串
其Unicode点是整数。
让我们看看它的作用。
所以它基本上采用整数值并返回
ACII中的ACII字符或其中的Unicode字符。
它到255。
现在它做的是它打开一个文件并返回
相应的文件对象。
这是我们将在文件处理方面做的。
然后有一个abs函数，它返回绝对值
整数，浮点或复数的值。
所以它取整数的负值
或浮点数或复数。
顺便说一句，Python确实有复杂的数字，
它将返回它的绝对值。
Enumerate返回带有项的枚举对象
和索引值。
我们将在一段时间内检查枚举。
它在幻灯片中更进一步，我们将回到它。
然后有一个int函数，它返回一个整数
从数字或字符串x构造的对象。
那么int将会做的是它将采取字符串
一，二，三，把它变成这个。
ABC，它不会做任何事情。
所以只有当数字作为字符串返回时。
然后它对他们做了一些事情，否则它将无法工作
在任何特殊字符或任何。
它只适用于这种事情。
所以有时你可能需要转换
一个字符串变成整数。
然后len返回一个对象的长度。
对象的长度表示数组中的长度
或枚举。
长度，ABCD的长度或元组的长度。
所有这些。
Globals是我们将要在一段时间内完成的事情
所以，让我们暂时留下它。
Bin将数字转换为前缀为二进制字符串
用0b。
如果你拿这个，你得到一个二进制字符串，
其前缀为零和B，仍然为零和B.
现在eval是一件非常有趣的事情。
它执行你在字符串中返回的任何内容
并将其作为参数传递给它
或像Python代码一样执行它。
所以在某种意义上说如果我输入eval print四加五，
它像Python代码一样纠正。
所以它抛出了无效的语法
因为这是一个安全漏洞，安全问题。
所以现在在我的翻译中，证券开启了
它不会让我执行任何东西
比算术多一点。
这就是通常你会发现Python的设置，
那种（嘟））。
现在的问题是eval用于执行Python代码
原因可能是危险的
让我们假设eval的东西，它删除所有文件
从你的机器，因为你只是允许一个用户
输入一个输入到eval的输入。
该用户是恶意用户。
他们最终会在服务器上执行代码。
无论他们想从你的Python代码做什么。
接下来是总和。
基本上可以迭代你给它，
这是一个数组或列表，它总结了所有数字。
所以，如果我做一，二，三，四，五的总和。
另一方面，反过来，顾名思义，
只是扭转它。
所以你必须用循环来做这件事。
没有循环就不能这样做。
它确实使用了一个可迭代的对象。
它没有在这里给你一个实际的列表。
我们来看看枚举函数。
枚举函数的作用是返回
反对价值，一旦你通过它，
应该再次迭代。
所以你在iterable中传递它然后它返回一个列表
元组和元组包含索引值
和列表中的项目。
如果你注意到这里，你在那做了什么
我们已经通过了杂货，面包，牛奶和黄油。
列举的是它将打印
这里列举了对象。
如果您将其转换为列表为零逗号面包
一个逗号牛奶两个逗号黄油。
让我们来看看吧。
首先，他们列举了一下。
这个东西返回并反对，枚举杂货，
其类型是枚举。
这基本上是一个枚举函数，它正在返回
枚举类型的对象。
然后，您可以使用list函数将其转换为列表。
list函数采用枚举对象
然后它会给你一个元组列表。
每个都包含索引和索引的值。
让我们看几个函数的例子。
因此，当涉及到函数定义时，您可以定义它
按书面名称，你做一些操作，
接受输入，做一些操作，
然后你返回一个输出。
调用一个函数，你只需要调用它，
只需使用学生的姓名，然后使用括号。
最后，结果是你想要的任何形式。
我们来看看lambda函数。
Lambda基本上是非常小的功能
用于您不想要的快速或小型操作
定义整个函数。
所以这是一个简写符号。
它是编写特定函数的简写方式
它们不超过一个表达式。
所以它们不能包含命令，也不能包含
不止一个表达。
所以一看到语法，
事情会变得更加清晰。
它们可以接受任意数量的参数并返回值
一个表达式。
所以语法是这样的，lambda是一个关键字
然后是输入。
我知道这附近没有括号。
因此，您需要查看此表达式的方式是这样的
它是lambda然后zed。
这不是正确的语法，
但我只是想向你展示它。
然后，它必须做什么来zed并同时返回。
这部分或这部分是将要返回的部分
通过这个lambda函数。
这是输入然后输出，我们在说
对于此输入，请输出此输出。
现在请注意你是如何在一行中写的。
你也可以像这样返回它。
所以即使这样也行。
您仍然可以拨打第七行，没有任何变化。
但这里的区别在于这种方式只是简洁
写它的方式。
然后是lambda分配给的变量。
基本上我们正在做的就是我们正在采取的行动
一个函数，我们将它分配给一个变量，
就像我们会做的一样。
如果你要定义一个函数答案，那么它会
后来基本上都是从这里开始使用的。
所以，如果你不得不调用这个函数，
你会以这种特殊方式打电话给答案。
即使打电话给一个lambda，我也会做的
lambda的表达式和我将它分配给变量。
现在让我们假设您需要打印答案
这就是我们执行它的方法。
因此，它再次称之为功能。
我们得到答案28。
我们可以再做一次，答案是8，
两乘以四。
现在这仍然是一个名为lambda的函数，
但后来lambda的最大用途之一，
它之所以存在，除了它简洁之外，
是它允许你传递其他功能，
作为参数的函数。
所以如果你有，我们假设，这些典型的功能
存在于任何编程语言中，
地图供替代使用。
那么它需要一个项目列表的地图
它将它们映射到某些东西。
例如，要向您展示，
首先让我们看一下这个结果，然后再开始工作
地图正在做。
地图，它做了什么，是它采取了每个价值
在一，二，三，四，五。
如果你可以进行比较。
它似乎已经成倍增加了它们。
一乘以一。
两乘以二。
三乘三乘四乘五乘五。
所以它是平方的。
好吧，这是映射到这个，你可以看到
这些产出，来自每个人
此特定项目列表中的元素。
然后你可以使用相同的索引。
所以因为它们在两个列表中都在同一个索引中，
你可以对它们进行排序。
现在这就是map函数本质上所做的。
现在，我们能做的就是在地图功能中第一个
参数是你想要的当前列表
要映射到？
从某种意义上说，你如何定义映射？
每次都必须是一个正方形吗？
如果你想要一个立方体怎么办？
所以lambda允许你做的是它允许的
你做这些非常整洁的事情。
如果你注意到，与写作相比，这是非常简洁的
函数def平方，x，它将采取项目。
在项目中写项目。
所以一个是你写下这一切
或者你这样写。
这里有一个明确的整洁，
但是它需要一个函数的原因是一个对象。
现在通过lambda实现它比写作更好
每次这样的功能。
下一类功能是过滤器。
过滤器将检查特定列表中的每个项目
并对其应用过滤器。
它会从列表中删除一些没有的项目
符合一定的条件。
所以我们采取了负五到五的范围，
这是从负数到正五的数字，
十个数字。
我们将它传递给过滤器。
现在过滤器的作用就是列表，
将此应用于每个人。
应用每个单独的元素进行处理
这个lambda函数。
现在这个lambda将返回两个或四个。
过滤器的作用是保持真实值。
所以对于这个列表中的任何项目，
这个表达结果证明是真的。
此过滤器功能仅采用这些元素。
如果x小于零，则仅为负5，
负四，负三，负二，
和负一，其中x是这些值。
这就是它将要回归的东西。
决赛减少了。
所以减少的是它需要一个列表，
对它应用一些操作，它基本上给你
最终的单一输出。
因此，如果您继续一次又一次地应用相同的输出
这就像减量运算符。
把它想象成一个减量运算符，它需要，
让我们假设我做了四个负减号而且我保持
一次又一次地呼唤它。
所以你做了什么，它会减少数量
从四到三到二对一？
所以它将以前的输出作为输入
并继续应用它到达列表的时间
列表的结尾。
那么让我们看看这将会发生什么。
24，那怎么会发生这种情况？
花了一个，最初这是一个。
所以一个逗号。
一个逗号就是一个。
然后一个逗号二进来了。
一个乘以2。
现在y的值是2。
三个进来，三个的价值变成了六个。
现在六个输入，四个作为输入。
所以基本上他们自己都成倍增加了。
现在我们可以做一件有趣的事情。
让我们看看这是什么结果。
我们将对第一个数字进行调整，我们将会这样做
乘以y。
因此，让我们看看y的值是什么，因为我们的输出
将取决于那。
它告诉我什么是平方。
因此，当我们对此进行平衡时，您将获得此值
但是如果你看一下这个，价值会有所不同。
所以你可以看到你也可以接受两个输入
对于一个lambda。
因此任何数量的输入都是可能的，但只有一个到期
并且只有一个输出。
我们来看看Python中的变量范围。
所以Python有两个变量范围，全局变量和局部变量。
全局变量定义为文件层。
一旦文件运行，它们就会被分配
首次。
另一方面，局部变量在其中定义
功能范围是（语音切断）。
所以，如果你看这个例子，
a代码中到处都有。
因此，即使通过此功能也可以使用它并将其转换为
全局，因为它在功能之外。
但是，如果我也在功能之外使用b
它会抛出一个错误。
如幻灯片所示，本地变量存在于此处
是b，它位于函数内部，只能使用
在给定的函数内。
这是另一个例子，所以当你打印一个时，它就在外面。
但如果你试图打印c，这是内部添加，
它不适用于你，因为它不是
一个全局变量，它是一个局部变量。
所以add中的所有内容都是本地添加的。
接下来是内存地址。
如果你有两个变量a和b，你就可以知道内存
通过这种方式中的任何一个的地址。
所以如果你想知道变量的内存地址
在Python中，您需要做的就是调用内置函数
id函数，它会告诉你内存位置
该特定变量。
所以让我们在终端试一试。
假设我有一个= 1，b = 23，
然后我做id（a）和id（b）。
如您所见，数字不同。
就你在哪里使用它而言，它真的取决于它
关于你正在做什么或你正在建设什么。
通常它不是你需要处理的东西
在日常的基础上，因为这些东西，
比如id（a）和id（b），我的意思是，这在更多时候是相关的
你正在处理Python中的低级事物，
但如果你正在做数据科学或类似的东西，那就不行了。
这不是你最终会得到的东西
处理除非你做的事情
特别是对内存管理，
这已经为你完成了。
接下来是函数参数。
所以函数中的参数个数
应完全匹配。
这些是必需的参数。
所以，如果你在这里看看这个功能，
必须将字符串传递给函数才能运行它。
否则，它将抛出一个打印名称的错误
缺少一个必需的位置参数str。
它期望的参数的名称和
中间的电话，它失踪了。
这基本上是说它需要输入
你没有提供相同的，所以它不能运作
就像那样。
接下来我们有一个叫关键字参数的东西。
在函数中使用关键字参数时
调用者通过参数名称标识参数。
所以关键字参数就像这样，我可以传递这个
特别是我说安妮的说法
是字符串的值。
现在，它并没有真正击中你，
但是，让我再举一个例子说明为什么这是有用的。
假设你有一个函数add，
这需要完整的参数。
现在，假设它不仅仅是一个简单的功能。
有一些东西就是总和。
相反，定义一个称为随机函数的新函数。
A，B，C和D.
它总和A ** B，A ** D，
加上C ** B，它返回总和。
当你调用随机函数时，
你可能需要记住嘿，好吧，我该怎么办？
我需要删除五条路径吗？
所以你要映射它，
看看在哪里使用的是什么。
相反，如果我们只是标记它，你会看到d =这个。
将c视为三，将a视为两，
将b视为五。
现在你告诉Python这是需要映射它的东西。
所以它不会依赖
仅在原始序列上。
你已经过去了。
这非常有用，因为你可以看到，
现在我可以用任何方式调用该函数，
只要我清楚地使用了功能参数。
订单无关紧要，事实上，
我会向你推荐这个，而不是打电话
我想，这种特殊的方式，
我们可以这样称呼它，五。
但我不建议打电话给这个。
我想每个人都应该严格遵循这个
特别的方法。
更清洁，更多的好处。
让您作为开发人员的生活变得更加轻松。
现在，默认参数。
我只想要d值为3，
即使没有提供。
所以我可以这样做，我可以删除该值
总之。
所以我可以像这样传递d的值。
这也是正确的，但我现在在签名中做了什么
是我给它一个默认值为3。
d应始终具有值3，
即使没有通过，
共谋应该具有三个值。
这里是另一个例子，其中年龄已被预定义。
除非他们明确提供数据，
特别是价值50，
在创建函数时提供的。
所以你要设置一个特定的默认值
函数，当你定义函数时自然而然。
另一个例子是薪水。
所以，如果有基本工资，我们假设，
以任何方式发出10,000卢比，
不管这个人是谁。
如果工资没有定义怎么办？
这些默认参数存在的原因是
因为有特定的参数会有
默认值，或在大多数情况下，
它将具有一种设定值。
您需要做的只是在某些情况下
你会改变价值。
所以真的出于各种原因，人们可以使用
这种东西。
所以有时你可能不知道有多少参数
是必需的，需要多少参数
你可能需要可变长度的参数，
你可以在多少个参数中传递它
因为你只是不知道有多少论点
将需要。
所以让我们假设你正在构建一个非常通用的
Python中的数学计算器。
如果你考虑乘法，你不知道是否
用户将乘以三个数字或四个数字
或一次五个数字。
他们可能只输入七个十字交叉
四个十字三或像阶乘的例子，
我们不得不反复繁殖的地方。
通常重复进行的任何操作
或者有重复输出，接收数据的功能
以这种方式可能无法定义它需要
它需要什么样的论据。
因此，为了处理这些情况，我们有这个启动运算符。
所以只要你把它放在一个变量前面，
在这里的参数前面，你可以传递一个数字
这个函数的值。
看看会发生什么，你可能认为没关系，
第二个是一种奇怪的方式来称呼它。
但不，即使第一个是正确的。
这可以是零或参数，
有这个选项的信息Annie Dave。
它也可能有第三个参数，第二个参数
这里将接受第三个参数
作为一个列表，您可以迭代。
那么，让我给你一个真实的快速例子。
所以我定义了一个功能打印用户，
但它类似于一个就在这里。
让我们假设edureka定义了其中一个。
那么其他用户，我们假设，管理员，首席执行官，
cto，经理。
我们称之为。
一旦你运行它，回到这一点，你可以看到，
第一个用户参数是edureka然后你有点看
变长参数是ceo，cto，admin，
等等等等。
它与此处的订单顺序相同。
现在另一种方法是传递关键字参数。
这些是星形参数，然后有关键字参数
你可以传递同样的东西
但具有关键价值的地方。
在这个arg1，arg2，arg3上看一下这个。
一，二，三，四，五，六七个ar args
然后你有这些kwargs，
它们被命名为类似名称参数，
但是因为它们是在args之后收到的，
他们将在这里作为字典提供。
如果你看非关键词参数，
它们可以作为元组使用。
现在Python不在内部。
同样，这样做的目的是制作功能
灵活地接收不同类型的输入
在这种机制中有更多的灵活性
与修复功能可以是什么相比。
所以这也是OOPS多态性的概念，
您可以通过多种方式调用函数。
这就是你输出的方式
将被操纵。
现在让我们来看看差异是程序导向的
编程和面向对象编程。
所以在面向过程的编程中，
该计划分为功能。
这就是功能是核心概念
当涉及面向过程的编程时
或函数式编程。
在面向对象编程中，
程序分为对象。
现在，POP遵循自上而下的方法
从最顶端的整个问题，它向下建立。
如果说没关系，我需要一些可以的东西
给我一个这样的输出，然后可以进一步
分为好吧，这件事需要做这五件事
事情，所以让我们的功能。
你从最顶端开始，然后继续添加
块越来越小，尺寸越来越小。
OOP遵循自下而上的方法，在它看来
所需的不同构建块，
将它们定义为对象，定义它们之间的关系
不同的实体，然后开始构建一个系统。
现在在程序编程中，数据需要自由移动
从功能到系统功能，
绝对是这样的。
在OOPS中，对象需要移动和通信
通过会员功能相互结合。
POP的一些例子是C，Visual Basic，
FORTRAN和Pascal。
OOP的例子是C ++，Java和Python。
但要注意的是，即使是Python，
例如，通过它的lambda函数
通过其他方式和机制，
允许程序编程。
它不是不允许程序编程，
它更适合风格。
所以最终，这些是你编程的风格。
没有语言强制执行这些，但它提供了功能
用它做那些事情。
因此，以这种方式考虑汽车具有许多功能
是的，但您可能不会使用所有功能。
所以汽车可以快速行驶，它可以行驶缓慢，
它可以反向驱动，但你可能会也可能不会
使用所有功能。
因此驾驶速度快，所以有些人不喜欢
一点开车。
它们永远不会达到最高速度，
但汽车实际上可以做到这一点。
以类似的方式，编程语言具有特征
内置的。
如果他们允许你做更多的事情
更容易的方式或他们更倾向于它。
但这并不意味着，
你不能让它做别的事情。
当然，你需要有足够的经验来制作
它就像那样工作。
让我们看一些面向对象的概念。
所以Python又是面向对象的。
它支持它，它有一个广泛的类机制
和我们要看的结构
在短短几分钟内。
面向对象的是那个
它使您的代码可重用，并使您可以
编写越来越少的代码。
它也非常适合现实世界的场景，
在你想到的时候你可以说那些图像
对象一词，脑海中浮现出一些想法。
所以一切都是对象。
就像汽车是一个物体一样，
喷气机是物体，物体是物体。
现在假设一切都是对象，
这让你很容易想象
或在您的应用程序中模拟现实世界。
当然，如果代码是可重用的，你知道，
所有这些不错的功能都在那里，
程序员，他们会产生更快，更准确，
和更好的书面申请。
但是，Python OOPS与其他语言不同。
当然，我的意思是，这就是为什么它是一种不同的语言
首先。
例如，在Java中，您无法创建文件
没有定义一个类。
所以就像存在差异一样，Python也是一种解释
我们知道的语言。
它逐行执行代码。
Java的情况并非如此。
所以Java是一种编译语言，
Python是一种解释语言。
所以Python OOP与其他OOP不同。
我们来看一个用例。
SRT是一家跨国公司。
该公司希望创建员工信息表。
它应包括名称，员工ID和进度。
现在让我们看一下每周一次的员工，
和他的进度专栏。
但要创建单独的表格将很困难
为每个员工。
所以不是那样，他们决定创建一个类
员工的信息，创造每个员工的对象，
为新员工打电话。
所以这基本上是原型，其中定义了，
嘿，这是一个班级的蓝图。
这就是员工所拥有的。
他有一个名字，他有一个名字，他有一个姓氏，
他有工资，他有年龄，他有性别，
这是他的角色，这是部门。
所以，所有这些都被称为他的属性。
如果你看对了，那通常是每个员工
在现实世界中也会有这些属性。
所以课程只不过是现实世界的蓝图
对象，我们尝试使用类来模拟该对象。
所以，当我说模型时，我的意思是我们试图在代码中描述它。
当模型出现时，男人实际上会尝试成为
对事物有点正式，特别是在上下文中
科学和编程。
在为某个场景建模时
或某种情况或个人或个人
或者一个对象，就英语而言，它被称为
作为描述。
所以当你谈论语言时，就像描述一样
给我一个球，但是你谈到编程，
他们是花哨的人，所以我们说让我们模仿球。
所以对球的建模确实涉及描述它，
在它的高度，它的重量，它的直径，对不起，
颜色，形状，材料。
同样的事情在这里，
当你试图为员工建模时
关于相关员工的一切是什么
我们作为一个组织？
所以同样正确，另一件事就是员工
可以是一个特别的东西，但它们是定义的
通过某些参数但属性会发生变化
从一个人到另一个人。
因为在一天结束时，每个人都是独一无二的。
同样，课程只是一个蓝图。
所以，如果你看一个循环，对，或自行车
或两轮车。
两轮车基本上是蓝图
有两个轮子和制动器。
这是基本的蓝图，对吧。
从中它可以是各种物体，
是否像其中一个这样的自动驾驶汽车，
或者它不是这样的自动车辆。
它是红色或绿色或粉红色或红色，
喜欢它可以不断变化，但不会改变事实
这仍然是一个特定的实现
循环对象的特定实例的。
所以就像人类一样，
所有人的解剖学都是一样的
世界上有70亿人。
他们不是我，它是相同的，这是一个蓝图
你将拥有一定数量的肌肉
和你体内一定数量的骨头。
但是，然后，每个人都是不同的。
所以这就是人类的解剖学。
这是一种来自这种解剖学的变异。
现在让我们谈谈类和对象之间的关系。
类是对象的模板。
它包含对象方法的所有代码。
一个类描述了抽象的特征
现实生活中的事物。
所以他们说它创造了一些东西，
我们在现实世界中看到的，但在编程方面。
实例是在运行时创建的类的对象。
所以当你创建或使用那个蓝图时，
所以只是创建蓝图什么都不做。
所以你需要声明一个函数，
你需要调用函数来执行任何操作，
同样只是宣布一个班级的蓝图
在Python中什么都不做。
您需要使用该蓝图实际创建对象。
你需要说好的，让我把它变为现实。
这是蓝图，让我实际构建它，
让我实际在内存中设置它。
我现在就有了蓝图。
没有那个实际价值。
当然，它们可以是同一类的多个实例。
所以要清除课程，你所做的就是你使用的
一个类关键字。
类关键字后跟类的名称
和括号。
当然是一堂课，在创作时，
可以在其中加入某些论据，我们会看到
它对这些论点做了什么
但只是一个非常基本的定义。
你声明一个类，数字和数字
类的名称，然后是该类中的语句。
要创建类的实例，您需要做的是
你需要拿一个变量，你需要打电话
类的名称，并按照模式，
这将为您创建课程
或者为你创建一个类的实例。
如果你看这个他们有印刷品（x），
这说它是一个对象。
在某某记忆位置。
那么它就像一个变量。
这只不过是一个变量，
在一天结束时。
现在，定义一个方法。
所以self指向类对象。
我们写ob.hello而不是self.hello。
现在正确，这里发生的事情是
一个方法里面的第一个参数，所以一个类
可以在其中包含方法。
首先，参数是类自动提供的
本身就是你好。
所以当你调用这个ob.hello时，内部Python会调用
这个hello方法，它会将self对象传递给它。
什么是自我？
自我是你定义的对象，ob。
接下来让我们谈谈变量的范围
上课。
变量未在类中声明
在班级范围内。
它们是全局变量，很可能解决它的功能，
某些变量所在的某些东西
在函数内部定义。
它们是功能或机箱的本地
由函数创建。
同样，对于类，同样的概念也适用。
在函数内定义的变量
是它的本地和外部定义的变量
是全球的。
像往常一样，全局变量可以在任何地方使用。
现在，如果变量是在类中定义的
他们是本地人，他们无法访问
不使用该课程。
B = 60，如果你试图打印b，理论上，
不起作用。
让我告诉你怎么做。
我只是评论一下。
假设我声明了一个类演示并且它有一个变量
变量b里面的变量。
外面我有变量b，即45。
我可以在任何地方这样做。
所以即使是这个类，我也可以在函数内部打印b
管他呢。
但是，如果我尝试这样做，它将无法正常工作。
即使你注意到这里，我们也试着运行它。
它说名称是未定义的，即使变量
已在这里定义。
但是，如果我们这样做，让我们看看我们是否可以这样做。
这有效。
所以表.a已经定义了这个变量
在课堂上。
除非并且直到你，否则它不可用
以这种方式提及它。
所以你真的需要看到很多变量都被定义了
并且您得到任何未定义变量的错误
但你实际上可以看到它存在于代码中
与自我不拼写状态。
您需要检查范围是否正确。
请小心点
这些是一些最初的错误。
因此，每当你看到这个时，不要失去动力。
它有时会非常混乱，但只要看看你是否可以
从该特定位置访问变量。
我们来谈谈属性。
所以我们说课程只不过是蓝图
现实世界的对象。
现在来到现实世界的对象，
它会有一定的财产。
因此，对于员工权利，员工就是财产
作为名称，员工ID。
让我们假设他们在某个项目中的进度百分比
或者是其他东西。
这就是真正定义蓝图的原因。
当我们从现实世界模拟对象时
进入编程世界，你将定义它
属性或其属性，因为这是如何
我们代表它。
现在，你可能会说嘿，这不是一个完整的
代表员工。
从某种意义上说，我对这个人有所了解
现在，但我不知道所有的事情。
哪个好，对。
嘿，你知道关于某个人的那些事情
与你相关的。
就像有同事一样，你可能知道很多
他们的职业生涯，但你可能知之甚少
关于他们的个人生活。
或者你也可能知道他们的个人生活
因为他们是你的朋友或其他东西。
所以以类似的方式，取决于你想要做什么
在您的软件中，在您的代码中使用该对象
你定义了你需要的属性，
不是所有的都存在。
有两种类型的属性，内置属性
和用户定义的属性。
内置属性，如内置函数，
在Python类对象上可用
由Python本身。
所以有某些属性，
你需要考虑这些。
所以一个问题可能是嘿，如果蓝图
该课程是根据我个人的定义，
根据我作为软件开发人员的需求，
为什么存在内置属性？
就像Python如何知道任何事情一样？
因此，如果我宣布一份员工名单，那怎么可能呢？
Python的开发人员会知道任何事情
关于我的员工班？
他们怎么能想象内置属性？
答案是通常这些内置属性
用于命名类并包含元信息
关于那个类或那个对象。
他们并不是你所看到的那种真正的东西。
所以这些更多的东西与更多的工具有关
是Python需要的信息，而不是Python
需要运行该类或执行该类
或代码，而不是你想要描述的。
然后自然会有用户定义的属性。
所以用户是你，作为开发人员。
所以你可以在这里替换用户这个词
用开发者这个词。
您知道的开发人员定义的属性，
你是用来模拟这个班级的。
首先，让我们看一下内置的类属性。
所以我什么都没做，但我已经定义了edureka课程
并且有一些可用的内置属性。
现在，不要与此混淆。
为什么它强调下划线？
这并不意味着什么特别的。
我们将稍微介绍一下这个问题。
这只是Python编写某些特殊属性的一种方式。
从某种意义上讲它是一种特殊的视觉识别。
所以这不是一个真正的字符串或数字
在其中，价值将在这些线上
或一个物体。
只是作为Python开发人员，你看到的那一刻
这个，你会知道嘿，
这不是你通常的属性，它要么是内置的
或者它是别的东西。
所以它只是创建一个你可以看的上下文
在此并将其视为不同的东西
来自用户定义的属性。
让我们运行它，看看输出将是什么。
所以edureka .__ dict__。
这是做什么的？
它包含类的名称空间。
所以名称空间是非常重要的Python概念。
在Python文件方面，当涉及到查找文件时，
和代码执行，你需要知道这个，如果你真的
用Python构建一大段代码。
目前，我们不需要深入了解细节
名称空间是什么，名称空间是如何工作的，
但只是知道我们可以做的事情
得到当前类的名称空间。
下一个是.__ doc。
现在每个Python类都可以包含一个doc字符串，
就像解释课程的常见字符串一样。
如果你想出于某种原因打印，
好的，你想打印文档，
你需要使用这个方法调用。
所以它实际上需要特定的。
doc字符串需要在单引号内。
所以，如果你注意到这里，
它打印了这个特定的文档字符串。
现在请注意，如果您放置此文档字符串
在其他任何地方，如果你把它放在外面，这将无法正常工作。
让我告诉你。
没有文档字符串，但是我把它放在里面的那一刻
在这里，我运行它，文件字符串存在。
接下来很简单。
它为您提供了班级的名称。
所以__name和edureka类名是edureka。
所以我想要的是这里的班级名称。
所以edureka的名字，我可以做同样的事情。
我也需要在这里改变它。
是的，所以如果你想知道你可以在哪里使用它，
如果你真的在构建某种类型，这将被使用
使用Python的框架或库。
所以从某种意义上说，这是大型的
正在构建的系统，因为那时
这些东西比他们需要的更多
如果你只是想建立一个网站
或者如果你只是想做数据预测
或数据可视化或分析。
这并不完全是你将使用所有这些，
但如果你是这样，尤其是建筑师，这是必需的
使用Python的大解决方案。
接下来是我们所在的模块，它是主要模块。
所以主要是我们之前介绍的内容，
如果你可能记得
如果name等于main这个类的开头
我们从两个不同的文件调用该函数。
它只是调用特定文件的模块
我们知道主模块总是调用文件。
我们来看看基数。
什么是基地？
因此，如果该类派生自另一个类，
然后碱有一个价值。
如果一个类可以从本质上推导出来，那就是它
从另一个类，它被称为继承的概念，
就像我们其中一个人从父母那里继承的那样。
所以以类似的方式，如果类继承自
另一个类，这是你用来获取列表的地方
在这些类中，您可以继承并且可以继承
多个班级。
这就是你在这段代码中得到这个edureka的地方
这个代码，base__。
好的，让我们找到用户的属性。
属性在类定义中创建。
很明显吧？
我们可以为现有动态创建新属性
一个班级的实例。
所以你也可以创建动态属性
对于现有的课程。
对此没有限制。
你可以随时随地附上它。
有三种属性。
有一个私有属性可以访问
只在类定义中。
然后是一个可以而且应该是的公共属性
自由使用。
然后是受保护的属性，可以访问
来自类或其子类。
子类，什么是子类？
同样，它与继承有关
或者基本上是派生位。
现在，我们将尽快介绍。
但只知道有私人，公共和受保护
类中可用的属性。
这种方式的工作方式是，如果你想申报
作为公共变量，您不需要做任何事情。
它只会在self上声明一个正常变量。
self.pub，这是这个类的属性。
如果要将其定义为受保护，则需要启动
带下划线，如果必须是私人的，
然后它必须以双下划线开头。
现在，如果你想访问它，这就是问题所在
你可以尝试像这样访问它。
现在这里的东西是ob.pub和ob._pro，
让我告诉你。
让我们看看这将是什么输出。
所以我公开竞选。
我受保护跑，但这个我私下没跑。
即使它被声明，这个也没有运行。
Python向我们抛出错误，就是这样。
这就是使它成为私有变量所需要做的一切。
现在，它受到了强调保护，但是如何解决这个问题呢？
因为你告诉我受保护的属性可以
只能从子类访问，只能访问
在课堂上。
这就是事情，Python有点流畅或轻松
有这些规则。
这更符合惯例。
所以作为Python开发人员，这就是变量的事实
只能通过派生类或类内访问
对于惯例而言，它不仅仅是一个非常严格的规则
这是强制执行的。
你会发现即使对于私人也是如此，
因为我会告诉你，有一种方法可以访问
一个类的私有变量。
所以有些人发现它为什么会非常奇怪和奇怪
你基本上可以访问这三个，
但为什么会有区别呢？
它更多的是彼此的荣誉系统，
Python开发人员试图指出的地方
对于其他人，嘿，不要触摸这个东西，
但如果你想要你本质上，
但如果你这样做，那么人们会注意到它。
经验丰富的Python开发人员立即注意
嘿，这个人被抓到这个特别的
打电话，他们会问你。
因此，如果您正在与团队开发人员合作，
他们会问你嘿，你为什么这样做呢。
所以你最好有充分的理由然后使用它。
是的，正如您所看到的，Python使用了两个下划线
隐藏方法，也可以使用两个下划线
隐藏变量。
所以我们看到了变量和相同的目的
也适用于某种方法。
所以我可以在这里声明一个方法。
如果我尝试这样做，我会尝试，ob .__ private方法。
看，Python已经强调了这一点。
这有问题。
它试图告诉我嘿，你可以尝试运行它，
但这不行。
这很可能不起作用。
所以让我们尝试一下。
看到它没用。
所以，是的，现在是大揭示。
您可以在哪里访问私有方法。
您可以访问私有方法，但您需要执行此操作。
你需要使用这个非常非常奇怪的语法
将edureka作为该类的名称。
所以这部分你需要将它附加到名称
变量或方法的属性
然后打电话给它。
所以我们试着这样称呼它。
看到这个运行。
因此，即使是私有方法或属性，也可以访问它们。
如果我现在尝试这样做，ob._Edureka和套管
必须准确。
所以_Edureka，实际上你应该复制粘贴
因为如果你刚刚开始这个。
然后pri然后你运行它。
我是私人的，我是私人私人方法。
两者都被执行了。
现在是类变量和实例变量。
所以我们已经在定义一个类的地方完成了这个。
我们为班级设定了蓝图。
我们在这里定义了一个类的实例，Edureka。
您可以设置课程，然后打印。
类变量由两个实例共享，
对象一和对象二。
所以从某种意义上讲，这里有两件事
如果有一个像这个域的变量，
这是在班级本身定义的。
它将在不同的实例中保持相同。
如果你看一下这个，ob1.domain和ob2.domain。
它们都是数据科学，但名称为ob1和ob2
可以是不同的。
将此视为共同的共同财产，
一个特定类的不同实例的类
或者类的对象的特定实例。
人类，如果属性是五号。
如果类变量是数字5，则为默认值
将永远像两个，对。
所以没有人出生，
这在基因上是一个单眼的人。
是的，有些人是盲人。
有些人天生没有双眼
工作，但在遗传上，所有人都应该是
有两只眼睛，不是三只眼睛，不是一只眼睛。
这将是固定的。
所以以这种方式思考它。
这是正在共享的特定类变量
作为跨不同实例的属性
不管是什么例子。
好的，接下来谈谈构造函数和析构函数。
构造函数使用___init__函数实现。
您可以定义将遵循自身对象的参数。
析构函数使用__del__，第三个名称定义。
删除对象时调用它。
所以想到构建为构建构造函数，
这会构建你的对象。
你标记了一个基本上是蓝图的类
你的对象
现在要创建该对象的实例，
构造函数需要实际行动
制作那个对象。
同样，析构函数基本上会发挥作用
删除该对象时。
所以想象一下正在建造的摩天大楼
哪个是建筑需要某些东西
发生，对。
析构函数需要某些东西
要清理和删除。
现在，在它基本上是样本初始化。
这是初始化，这是删除。
那么让我们看一个例子。
我们这里有什么例子，这是构造函数，
这是私人保护和公共方法。
正在设置公共属性。
同样，我可以定义一个析构函数，
我可以说，我想，我可以把它设置为无。
我们打印一下。
现在让我们谈谈多个构造函数。
基本上使用多个构造函数以备不时之需
同一物体的相同蓝图
以不同的方式上课。
您只能以不同的方式初始化它。
你这样做的方法是使用装饰器，例如添加它
特定对象的类方法。
这个装饰器做的是通过CLS
也反对这个特殊事物的自我对象。
例如，假设我想创建
另一个构造函数。
我会声明一个类方法。
这基本上采取CLS，这非常像自我，
让我们假设这次我想......
所以，如果你注意到这里正确，已经做了什么
是你需要调用特定的方法
在创建实例时。
我要做的是我会创建一个对象
ob = Edureka.myCustomConstructor并将其传递给值400。
通常我会创建一个对象，如果你谈论
一个默认对象，以这种方式创建它。
如果您需要自定义对象，
它将以这种方式创建。
现在，面向对象编程中的某些关键概念
是抽象，封装，
继承，压倒和多态。
让我们逐一研究这些问题。
抽象，抽象简化了复杂的现实
通过建模类。
那么这意味着，如果你看一个粉丝，对，
你不知道它是如何在内部工作的。
你们大多数人都不知道汽车内部如何运作
或者发动机如何工作或喇叭如何工作，
但你只知道如何与它互动，利用它。
如果我谈论像这句话一样简单的事情
打印你好世界。
它有用吗？
它是如何工作的？
它是如何在控制台上打印的？
我很确定大多数人都无法回答
甚至我也无法回答。
从某种意义上说，我需要看看如何
这已经执行了。
所以有关这种情况的细节有点像
抽象了我。
我需要真正打开Python库
以及Python代码库，以了解它是如何
在这里打印一些东西。
所以说到正确学习Python，
如果我们开始为每件事做这件事
我们永远不会最终完成学习Python。
我们永远无法从中学到任何东西
或者能够学会使用任何东西。
所以抽象需要发生，它发生在每一个
某些事情正在发挥作用的编程语言
以某种方式，但你不知道。
直到你需要做某事为止，你才知道
与特定方法或对象不同寻常
或者你所呈现的任何东西。
因此，如果您想要修理风扇，因为没有
修理周围的人，你知道，
或者修理风扇或汽车太贵了，
那时你最终会了解它。
不是你只需要打开风扇。
封装是指将代码组合到接口中。
这包括编写方法，创建变量，
使用类，任何类型的枚举，创建列表。
我们是封装。
我们以更易转移的方式收集它
它可以在多种情况下重复使用
它以这种方式灵活。
继承是指存在关系，
大多数人之间存在父子关系
你在那里看到的东西
如果你看右边的车辆，就会有一个父母的孩子
自行车属于类别车辆的关系
汽车属于类别车辆，
公共汽车属于类别车辆。
可能还有汽车，公共汽车和卡车
车辆后的子类别，可能是
四轮车。
下面的子类别。
自行车也是如此。
继承是非常自然的事情
我们可以在编程中使用相同的内容
模拟现实世界，因为那是什么软件
毕竟，这就是全部。
现在有多种类型的继承。
一个是单个继承，因为有一个父
上课，有一个孩子，可能有多个
类继承自A和B的继承。
然后可能有多级继承。
这就像父母，父亲和母亲。
这就像祖父，父亲，孙子。
所以B是C的父亲，C是B的儿子，
或B是A的儿子，A是B的父亲。
我们来谈谈单继承。
基本上，继承的作用是它允许我们这样做
扩展一个类的属性和方法
去另一个班级。
如果一个蓝图具有某些属性
某些具有某种造型的东西，
它模仿了我们周围的世界。
对象的位置，例如让我们假设和对象
绝对有现实世界的重量。
不存在您将调用对象的对象
在没有重量的现实世界中，
或者没有宽度。
这些是常见的属性，但有属性
对某个对象来说是唯一的。
比如，让我们假设颜色，物体的颜色
对于不同的对象可能有所不同
并且可能存在或可能不存在某些对象。
例如，如果我们甚至考虑水，就像一团水
作为一个对象，那么水将没有任何颜色，
因为水基本上是无色的。
颜色属性不会（语音被删除）。
此特定对象仍存在其他属性。
这种方式的工作方式是您可以定义基类
你可以定义它的属性和方法。
然后你可以定义另一个类，
它继承自基类。
继承的方式是你只需要提供
子类的类名
现在，当您创建子类的实例时
你调用函数很有趣，即使它没有定义
在这里，但它在这里定义，这将被执行。
所以让我们试一试，看看这是否有效。
所以在班级基地。
现在，我总能在这里开设另一个有趣的课程
它可以运行这个。
现在我上课了。
所以它的工作方式是首先看
对于类图像中的类名
然后它会发现它的链条
对于父类。
我们来谈谈多重继承，你有一个继承
从两个类继承的类。
那么我们先来看看这个。
有第一个对象，还有第二个对象。
然后有第三个继承的对象
从第一个，第二个，第一个。
调用inherit方法时
让我们知道什么被执行。
是的，所以当我们这样做时，我们也在呼唤
超级方法，即调用此方法。
所以这基本上就是说我的上级。
调用我正在继承的类。
因为它继承了第二和第一，
这两种方法都被调用了。
首先调用然后调用第二个调用。
当然，即使是第三个也是印刷的。
然后当然有多级继承。
多级继承，它的工作方式，
就像祖父一样，是一个单一的班级，
父亲和孩子。
所以你有一个明显可以吃的动物类。
你有一个狗类，它会吠叫。
然后你有一只会发出哔哔声的小狗
它有一个beepclass。
所以你可以创建一个幼犬类的实例。
你可以在它上面调用d.eat，d.bark或d.beep。
如果你看到我们写了更少的代码，否则我们就可以了
一次又一次地定义这些代码片段。
这是一个非常非常强大的概念
在编程中你可以重用代码片段
一次又一次地通过创意编辑，
从而通过将它们包装在类中来创建假设
并在它们之间创建这种关系。
好的，所以方法覆盖。
现在这是我们甚至做过的事情
在前面的例子中，当我向你展示课程时，对。
我已经向你展示了我可以覆盖方法的地方
但让我们看另一个例子。
所以，如果你看一下，这是一个参数
myMethod然后有一个孩子，
还有另一个myMethod。
现在我可以创建一个子变量的实例
我可以在上面打电话给myMethod。
现在即使myMethod存在于父级中，
孩子一会被召唤。
让我为你运行这个。
所以调用了子方法。
看看我们是怎么做到的？
这是另一个有限的例子。
你有一个类矩形，你有一个类方块，
这是继承自矩形。
现在当你打电话到get区域时，回想起那个区域
因为我们想打印它所以出现在广场内
以某种方式。
A是正方形的区域，所以这不会自然而然
回想一下矩形的获取区域。
它将打印一个矩形，这是不正确的，
因为每个方格也是一个矩形。
但是，我们不想这样做，对吧。
我们想要调用广场的区域，那就是哪里
一点超载或覆盖将帮助我们。
我们让子类重写父类方法。
多态性是利用相同接口的能力
对于不同的底层形式，例如数据类型或类。
现在在百万富翁和学生的意义上
两者都要支付账单，但也许是他们支付的方式
该法案将与众不同并支付账单
根据被调用的内容进行更改。
所以多态性基本上说同样的事情
或者相同的对象可以表现不同
在不同的场景中。
如果您是学生，您可以通过以下方式支付账单
父母，但如果你是百万富翁并且你付钱
您的账单，您可以通过信用卡支付
或者您可以通过借记卡付款，你知道，
以两种不同的方式。
因此，支付账单是常见的
对一个人，对，但它的方式可能
根据谁付账单而改变。
看看这一个吧。
正在派生班级猫和班级犬
也来自动物类。
如果你发现它们都是顶级方法。
C.talk和d.talk表现不同。
所以多态性我的意思当然是，现在你做了什么
是你使用了音乐会方法重写
早期，但动物.talk存在于所有动物。
然而，猫基本上也是一个例子
动物的对象。
这是多态性，因为基本上是猫和狗
是动物，但在通话时，
他们两个都表现不同。
所以同样的属性被调用，
但行为是不同的，这是多态性，
你有多个形式的同一个对象。
所以也有称为getter和setter方法。
这些或多或少都在编程惯例中。
所以你可以直接访问属性所以（喃喃自语）
一个类，但你也可以使用getter和setter，
在哪里设置值并获得值。
这基本上更像传统方式
如果使用这些方法，这些方法是普遍使用的
是因为很多时候你可能需要修改你的数据
在你使用它之前。
您可能需要知道，添加符号，
或者在设置之前进行一些修改
你只是不希望任何人能够做到这一点。
您希望以安全可靠的方式完成它。
也许这个对象是由数据库设置的
并且您不希望任何人访问数据库
就像那样。
您希望通过适当的定义进行访问
因为它很复杂。
这是你将使用setter和getter的地方。
那么让我们来看一个例子。
类edureka，我们正在设置课程名称。
我们正在创建一个edureka的对象。
我们打印，得到课程名称，
然后我们要设置课程名称。
顺便说一下，我们也可以做到这一点。
替补可能是这个权利，
但是我们假设你必须使用大写，
你不得不大写它。
每次只需要打印大写的一个。
这是您必须对数据进行的转换。
当你更新它时，如果每次都要这样做
单次，写上.upper会很麻烦
每一次都成功（说话乱码）。
或者同样的事情适用于此，
当你返回课程名称时，你总是如此
将其设置为大写。
这就是为什么你会使用getter和setter。
看看我们是如何做到的。
（愉快的器乐）
现在我们完成了循环。
我们已经对循环进行了基本的介绍。
让我们转到标准库
Python中提供的。
标准库是一组工具
Python附带的。
它包括以下内容，它包括内置功能
功能，模块，包。
所以其中一些我们已经在使用了。
我们来看看其他一些。
Python中使用的模块。
所以模块基本上允许你逻辑上
整理代码。
它可以包含类，函数。
一个简单的事情是我有一个实用程序模块。
或者你可以有一个DV模块，它可以完成所有DV
与您或其他人的互动。
所以任何类型的逻辑包装代码，
逻辑不是零和零，但对你来说是合乎逻辑的。
好的，这段代码应该放在这个文件中。
此文件处理数据库，此文件涉及，
我们假设PDF和此文件处理文件处理
这个文件处理这个。
我们甚至将代码划分为逻辑中断
然后你称之为模块。
最后，它们只不过是Python文件
扩展名为.py。
所以并不是说它们与其他任何一个都不同
Python，只是它们被称为模块
因为他们以某种方式组织起来。
正如我所说，模块是一个包含Python的文件
定义和陈述。
因此，当我们使用import时，无论何时使用import，
你告诉Python加载一个模块。
当Python解释器遇到import语句时
如果模块存在，它会导入模块
在第一部分。
因此它可以将模块定位在相同的位置
数据树和路径已经给出。
相同的数据树，与当前文件相同的文件夹。
它最终会导入该模块。
现在看，有两件事，一件是你有的
您自己的文件或您自己编写的模块，
你要导入的。
或者你是从Python导入的东西
标准库，永远可用
在搜索路径中。
第三个是内置函数，它返回一个列表
包含模块定义的名称的字符串。
它给出了变量函数列表
在该模块中定义。
所以这种方式的每个文件都是一个模块而且它有
什么目录它给你所有的变量，
该模块中可用的所有内容。
所以某些隐藏的东西，比如下划线下划线文档，
下划线加载，所有这些也是
默认可用。
我们来看看这个。
你可以关闭所有这些。
所以我想我会导入数学。
一，b等于列表。
C等于，我称之为dir。
让我们看看结果会是什么。
请参阅，a，b，c和数学。
如果你想特别检查所有可用的东西
在数学里面，你可以这样。
这种类型为您提供了许多可用的功能
在数学模块中。
很多功能，可能是很多变量
这些可能有点令人困惑。
这些下划线是什么强调了变量？
但是你只需要知道它们是Python内部的
Python使用它们来组织和运行代码。
它是关于Python使用的代码的元数据。
import语句允许您导入
特定模块的特定属性
进入当前的名称空间。
它像导入一样工作，但它允许您导入
特定的事情。
如果你看这个权利，我们进口了这么多
这些功能。
如果您不需要所有功能怎么办？
如果你只需要余弦或10或平方根怎么办？
为什么不，我们可以这样做吗？
所以你可以做的是你可以从数学导入，
导入，假设我们导入平方根
或者让我们导入余弦。
现在让我们这样做。
这个特殊级别的导演。
让我们看看结果是什么。
所以，如果你现在看一下，它就不会被导入
整个数学模块。
它只是导入了平方根。
如果您想使用任何其他可用的功能
在数学模块中，你将无法做到。
如果要使用数学模块中的所有函数
我们需要使用导入数学，这将导入整个
模块，但在这里我们是具体的。
我们说嘿，去图书馆拿这本书。
或者我们从这本书中说，
得到这个特定的页面。
导入数学就像导入整本数学书，
这是非常的，让我们假设，又大又胖。
所以你不想导入所有东西。
但是这更有效，您想要导入
特定的事情。
所以建议，这实际上是一种更好的做法
你导入特定的东西，
只有你需要的那些。
因为发生了什么，他们被加载
计算机的内存，如果你有很多不必要的
功能位于那里，可能会导致问题
处理它们的麻烦。
还有进口*。
所以你也可以这样做。
从math import *，这与导入数学几乎相同。
但是，不建议这样做。
这不推荐，因为我的意思是，
它几乎是一样的但是你要导入一切。
考虑让我们假设一个变量的场景
已经在数学模块中定义，
与您正在使用的变量同名。
现在我知道机会少了，但随后的数字越多
对于文件，您正在阅读的图书馆数量越多，
数学模块碰撞的几率，
这是另一个文件，有一个同名的变量
因为你正在使用。
所以你真的要小心你要导入的东西
因为它可能会导致意外错误。
现在，这些不是您将立即看到的错误。
这些是您在运行时会发现的错误
因为输出不正确。
所以请注意如何使用import语句。
最负责任的使用方式是通过
这种特殊的方式。
重载功能基本上是一个非常漂亮的工具。
它的作用是重新加载一个特定的模块。
所以我们假设您正在处理两个文件
并且您已对某个文件进行了修改
而另一个文件已在运行。
您只想重新加载它运行的模块
新鲜的代码。
它只会重新导入它的特定模块
被要求重装。
现在，这些是一些非常非常重要的模块
可在Python中使用。
sys模块，Os模块，数学模块，
datetime，random或dual enter，JSON模块。
让我们现在了解Python中的一些重要模块。
Sys模块，所以Sys模块基本上是它的功能
是它避免访问某些变量
过去由翻译和功能维护
与解释器强烈互动。
强烈地认为他们是密切相关的
到Python解释器。
现在，它的工作方式是导入系统
以及一些你可以用它做的非常常见的事情
是sys.argv。
它存储传递的任何命令行参数
当你启动Python时。
那么让我给你举个例子。
现在让我们假设我去了航站楼
然后我执行这个文件。
我通过了一个论点。
如果你注意到这个sys.argv，它会接收文件名
已被执行。
一，二和三是字符串。
所以传递的任何参数都有字符串
所以它也可以这样做。
所以这就是你执行Python文件的时候
通过命令行，你想传递一些
它的论据。
sys.exit做的是它基本上关闭了
终点站。
它关闭了执行。
所以没什么不同，我的意思是发生在任何地方
但syst.exit可能是你使用的东西
当你想要退出执行时。
假设您正在运行Python文件
命令行，你想结束执行
在基于某些错误条件的某一点之后
已经发生了。
这就是告诉口译员退出的地方。
我可以告诉你的另一件事是，如果我这样做，
当我说import.sys和syst.exit。
看，它关闭了终端。
它关闭了Python解释器。
现在在Sys中有一些重要的东西，这就是.winver。
所以这对我的机器不起作用，因为我在MacBook中
但如果你不在MacBook中，如果你在Windows中
系统，这将为您提供Windows的版本。
让我们跑一下，看看我会得到什么输出。
是的，它会给我一个错误，因为我不是
在Windows系统中。
所以这不起作用，但你可以尝试另一个。
让我们看看sys.flags是什么。
它给了我们一些旗帜。
这些标志是什么样的，这些标志是设置的
零或一。
它公开了命令行标志的状态
可用的。
现在这些标志本质上是如何命令行的
一些作品，它基本上给你这些价值观
命令行。
我们来看看sys.prefix。
好的，syst.prefix基本上可以告诉你它在哪里
工作环境或Python路径所在。
如果您已设置了哪个环境或是否已设置
安装Python，它基本上会告诉你
Python安装在系统中的位置
用于当前运行此程序。
好的，现在的问题是sys模块更有用
再次，当您与操作系统交互时
或者您正在与命令行进行交互。
如果你正在使用它，你将不会使用它
用于数据科学目的，或者如果您正在使用它
网站开发目的。
如果你正在处理，这更有用
您正在处理的操作系统。
我们去os模块，所以os也是相关的
到操作系统。
它让你做某些事情，比如目录
文件操作。
因此它允许您创建目录。
它允许您创建目录。
它允许您删除目录。
所以让我们试试这些。
好的，那么你要做的就是你将开始
我们可以使用一些东西。
首先是os.name。
我在posix系统中，
这基本上就是MacBook的用途。
操作系统的名称不是MacBook，
我的意思是这是营销名称，但它是posix。
然后是os environ，它的作用就是
存储的某些环境变量
在任何计算机上。
即使在某些环境中的Windows也是如此
变量，环境是整个操作系统，
它有一定的变量集。
这给出了整个键映射或字典
环境变量。
然后有一个叫做登录的东西，然后有
获取ppid函数，它提供进程ID
目前的功能。
如果你看一下，它会告诉我操作的名称
系统，依赖模块导入，
返回表示字符串的对象的映射
环境，返回登录用户的名称
在过程的控制终端上。
登录此终端的用户是_mysql
与DVS无关，只是名字
在我的系统上的用户。
它返回父进程的ID。
使用os.getppid，它返回测试开关的ID
运行这个特定的Python文件。
现在您在上一张幻灯片中看到的其他内容，
所以我们也可以说获取当前的工作目录。
我们这样做。
你可以看到我在这个特定的目录
现在，Python Edureka，DS mod三，DS mod三。
我也可以使用它创建一个目录。
我不需要完全打印它，所以我知道这是显示的
作为打印，但让我在不使用打印的情况下创建目录。
我将在这里使用名称test的目录。
如果您注意到，则已创建测试目录。
我现在可以更改目录进行测试。
我只是评论它，以便我们不创建
它在目录上。
我们更改了目录。
我可以打印os.getcwd。
Cwd是当前的工作目录。
Python知道它在哪个目录中
在任何给定的点上。
现在您看到了当前的工作目录
就是这个。
现在，如果我尝试，我们假设，导入任何这些文件
在这里，它不起作用，因为我在
一个不同的目录。
最后，我也可以删除目录。
为此，我要做的就是我会给它
测试的名称。
如果你注意到，这个特定的目录就消失了。
是的，所以os路径模块非常非常有用。
它允许我们对当前路径做一些事情
我们在哪里。
为什么Python需要这个？
Python使用os模块或路径模块的一件事
内部是找到文件。
每当你进行任何类型的模块导入时
你知道，你正在尝试导入函数，
内置函数或任何类似的东西。
Python在内部依赖于这些方法。
有一个想法肯定是一件好事
Python如何在内部处理这些事情，
这不仅仅是魔术。
只是由其他开发人员编写的代码
在内部它发现了
并逐一完成所有这些事情。
那么让我们来看看os.path.join。
它需要一条或多条路径才能做到
通过使用当前的操作系统加入它们
路径分隔符，无论它是什么，路径分隔符
是，它基本上给你回报它。
所以让我们试一试。
我只是将其更改为用户apple和用户apple共享。
让我们再次运行它。
是的，所以它将两条路径连接在一起。
让我们假设他们完全不同。
让我们看看输出将是什么。
好的，我希望每个人都清楚这一点。
让我们来看看绝对路径的作用。
它采用相对路径名并返回相应的路径名
绝对路径。
我们可以做什么，我们可以给它DS_mod。
那么我们所处的位置是DS_mod3。
让我们看看我们通过跑步获得了什么。
如果你注意到它采用了DS mod三，它就存在了
在其领域内，它发现嘿，
这是它的落后部分。
这是它的绝对路径。
您也可以在文件名上尝试它。
我们假设我们在这个文件condr.py上试一试。
我们运行它。
它自动找到这个文件的位置，
这个文件的完整部分。
让我们写出一些不在其中的东西。
我们来试试这里的东西，
我们在哪里使用info.py.
绝对路径的作用是它需要一个电流
工作目录。
所以，如果我们采取当前的工作目录
并在此处添加您传递的字符串。
就是这样。
它会像我们一样得到当前的工作目录
在这里，只是走这条路，
并且它将与任何东西连接起来
你要传递给它。
现在，normpath，它转换非标准的路径名称
格式为标准格式。
那么标准格式是什么？
我们来看一下。
让我们再次引用os模块py。
好的，这是规范化的路径。
现在让我们来看看吧。
这是规范化的路径。
现在让我们假设我们这样做，
让我们看看输出。
好的，这是输出。
这是为了这个。
Os.path.split，它采取的是路径名称
并将其分为两部分，即目录部分
和文件名路径。
这非常有用。
我们来试试吧。
让我们走完整个路径，把它交给os.path.split。
您可以看到第一部分是目录
第二部分是实际的文件名。
第一部分是整个目录
第二个是文件名。
因此，使用os.path.exists，非常简单地告诉您路径是否正确
是否存在，特定文件夹或路径是否存在。
我们可以尝试这个，价值将是假的
因为我没有这种文件夹。
但如果我试试这件事，
确实存在。
所以让我试试这个，类演示，对吧。
这应该存在，价值是真的，是的，
它确实存在于这个系统上。
接下来是检查是否确定
确实存在与否的事物。
所以，如果我传递一个文件名，
它应该说它不是一个目录。
它不是目录，因为它是一个Python文件。
现在，如果我说这个，我跑了，是的，
那么这是一个目录，在这里。
现在操作系统将不起作用，它走的是什么呢
或遍历提供给它的路径。
它给了你，让我们看看它给予的回报。
所以它给你生成器或它给你一个迭代器。
所以让我们以更好的方式使用它
并看看它实际给了我们什么。
是的，所以它给了我们一堆东西。
它实际上给了我们一堆文件。
它列出了存在的整个目录集
在课程demos / python / edureka中。
所以可能有点太多了所以让我们回过头来
并尝试一下，看看我们可以从这个中得到什么。
只是在DSmod3中，此目录中提供了什么。
它应该只是文件，因为只会发生什么
为什么你在这里获得如此多的输出
是因为Python edureka下有很多东西。
这个文件夹很大。
所以相反，让我们试试吧。
现在，这好一点。
有.idea，它只是一个系统文件，忽略它。
有一种叫做pycache的东西。
这与Python缓存有关。
但是，如果你看一下，这就是所有的清单
这里代表的文件。
所以os.walk允许你做的是它允许你
进入文件夹并导航或导航
到你的不同文件夹
系统Python文件。
我们来谈谈数学函数。
它提供对数学函数的访问。
让我们看看几个重要的数学函数。
好的，所以数学点上限，让我们运行这个。
是的，所以天花板是圆的
尽可能最高的数字，在这种情况下为11。
这就是天花板的作用。
复制它所做的是它复制一个标志或其他什么
在变量内部左侧内侧。
这仍然是更好的方式，而不是
只是将它乘以负数。
当然需要复杂的案例，
例如复数或任何其他类型的系统。
复制标志非常重要。
这将以负数的正值结束
已经给出了。
如果数字是正数，那么让我们看看输出是什么。
输出不会改变，如果是这个，整数，
那么这是绝对的，这是绝对的浮动。
这不是，这甚至可以转换为19到19.0，
如你看到的。
然后我们有math.exp，它基本上是e的权力
给你的结果是对任何事物的力量
你传递给它。
然后我们有expml，它返回e到幂x减1
其中x在此示例中为2。
这是日志，因此math.log 10 of 10返回对数
基数10到10。
现在万一你不知道e或log，
它就像你需要划分的数学类型，
但这些并不复杂。
你可以输入输入并获得电源
和你想要的对数值。
同样，我们有正弦和余弦。
你可以获得角度的度数。
然后你得到asin，atan，cos。
您可以在此处获取所有可用值。
所以你说Python有各种各样的用例
其中包括科学用例。
这就是为什么这是用Python内置的，
你知道吗，与我们假设的C ++相比，
你需要在哪里导入它，你需要它
或其他一些语言，你知道，
你可能需要一个特殊的模块。
所有这些都是用Python内置的。
由于Python，所有这些内置支持
用于科学等领域，特别是。
很多科学家都使用它，这就是为什么这些东西
在Python中开箱即用。
同样，有Python数学，有角度，
双曲函数，你可以把数学转换成程度，
math.radians，你可以得到pi的值，
pi的常数值，
你也可以获得e的价值。
好的，我们来谈谈随机模块。
随机模块，有时您可能需要一个随机值
在某个范围内，或者您可能需要一个随机数
无论出于何种原因
这是随机模块的用武之地。
那么让我给你举个例子。
您导入模块和randrange。
什么randrange它给你一个数字
在0到100的范围内。
让我们来运行吧。
好的，它给你的值为52。
每次运行它我们都会得到一个不同的数字。
randrange做的是它给你一个数字
在0到100之间，但在那里有20步。
所以开始，停止和步骤。
它将从零开始，并以正确的步骤开始。
因此，如果我需要获得更好的结果，我应该增加
这个上限。
现在所有这些都将是20的倍数。
这不是它会给我们20的倍数，
但每次都是20步。
然后是randint，介于0到30之间。
所以我们也试一试。
使用哪一个取决于用例。
您可以继续使用其中任何一个。
那么random.getstate做什么呢？
这是我们可以使用的另一种方法。
它返回捕获当前内部的对象
发电机的状态。
所以会发生什么是Python以某种方式维护
这个概念的发电机，保持随机的
价值已经产生，实际上可以真实
随机化下一个值。
它获得当前发电机的状态
当前形式，这只是一个对象。
接下来是random.uniform，它返回一个浮点数
这样N在A和B之间。
A和B是您传递给它的值。
所以这个数字将介于三到六之间。
所以再一次，就像说任何小数值
在三到六之间产生并将它还给我们。
什么是真实生活应用
生成随机数？
它可以用于生成随机密码短语
对于互联网上的银行系统。
它可能适用于您使用Python开发的视频游戏
也就是说，怪物应该随机出现
或者该人员应该出现太空飞船
射击他们。
或者它可以用于模拟任何随机事件
或看似随机的事件，如降雨。
这就是它的目标。
类似的其他几个类似的现实生活
您可能需要随机的应用程序。
但我的意思是，如果你正在建立一个赌场网站，
让我们假设，并且有一个随机数被抛出，
有一个骰子被抛出。
你正在建造一个轮盘赌。
轮盘赌基本上就是你看到的那些东西之一
在赌场，你可以扔球
它将落在一个特定的数字上。
现在，如果你正在构建任何类型的机会游戏
使用Python，您将需要一个随机变量。
或者即使你正在构建另一个概率定理。
所以我们假设您正在构建机器学习
你正在实现一个算法。
机器学习通常依赖于随机数
就某种语言而言，就其而言（喃喃自语）
这就是你可能需要随机模块的地方。
接下来是日期时间模块。
对于日期时间模块包括工作工具
与日期，时间和组合。
那么让我们来看看一些可用的方法。
Datetime.maxyear，它做什么？
让我们运行它，看看。
它为我们提供了可供我们使用的最大年份，
我们在系统上可用的最小年份。
Datetime.time基本上给了我们时间对象。
最多一年是双九九双
而最小年就是一年。
它以r分钟返回时间对象，
第二，微秒。
这个返回一个时区对象。
但这可能不适用于所有系统，
正如你刚才所见，它没有用
在我的特定系统上。
该模块没有属性时区。
小心你在哪里使用它。
它适用于某些系统。
它不适用于某些其他系统。
接下来是Json模块。
Jason模块提供了一种简单的编码和解码方式
Json格式的数据。
我们来看看这个。
所以Json基本上就像是Python中的字典
但基本上它代表Java脚本对象表示法。
这是互联网上经常使用的东西
这些天通过传输数据，存储数据。
这些日子非常非常流行。
在使用它之前，您不需要了解Java脚本，
它只是一种数据格式。
像MP3是一种存储音乐的格式。
同样，Json是一种用于存储数据的格式。
是的，让我找到该文件。
好的，就在这里写吧。
首先，您需要为Json导入模块。
然后让我们假设我们创建数据，
这是一本字典，然后我可以创建一个Json字符串，
这是json.dumps是可用的方法。
我需要将数据传递给它。
然后我可以打印Json字符串。
我们来试试吧。
所以你可能会说，嘿，这看起来没什么不同
比我在这里打印的还要多。
但相信我，这实际上是不同的。
这是不同的，因为如果我按照Python的方式行事
在它将是非常不同的。
抱歉。
是的，所以如果你看一下这个，那就是字符串。
这不是字典。
它看起来像字典，但它不是字典。
如果我试着这样做，是的，这不会运行
因为字符串对象不支持项目分配。
好的，所以它是一个强大的对象。
我们接下来谈谈正则表达式。
假设您想要查找特定数据
在大量的数据文本中。
因此，您想要找到所有电子邮件ID
存在于整个数据文本中。
您想要找到某些颜色的名称。
你想找到某些单词。
您想要查找单词标志出现的次数
在这里，并用单词标志替换它。
所以这些东西，对，你需要匹配的地方
对于某些模式或单词，要么替换它们
或者找到可以处理的事件数量
很容易用正则表达式。
或者假设您要验证电子邮件地址。
所以这是你非常普遍看到的，对，
在注册网站时，它告诉你
自动是否提供您的电子邮件ID
看起来像是电子邮件ID。
所以事情是有这么多的模式，
存在电子邮件ID的方式很多
因为有类似的网站以.in结尾，
.co.in，依此类推。
那么如何确保电子邮件ID实际上看起来如此
像电子邮件？
该公司是如何解决这个问题的？
这就是正则表达式帮助我们的地方。
什么是正则表达式？
正则表达式是一种特殊的文本字符串
用于描述搜索模式。
因此它将描述一种搜索模式，即模式
我们将在给定的字符串中查找匹配项。
你可以很好地做到这一点，
但我们怎么告诉电脑呢？
我们告诉计算机这样做的方式是
告诉它某些表达并要求它
将它与给定的字符串相匹配。
所以你在字符串中找到一个单词，你生成一个迭代器，
匹配一个或几个字母。
这是在内部完成的，从而生成一个迭代器，
然后它匹配几个字母中的一个或任何一个
根据您提供的输入。
或者它匹配一系列或一系列字符。
然后你可以替换字符串或者你可以匹配
单个字符。
所以Python有re模块可用于此。
它有几种方法可供选择。
其中一个是sub。
我们来看看这个。
好的，所以这里发生的是read或sub
现在这就是所谓的常规，
这就是所谓的正则表达式。
这就是我们描述搜索模式的意思。
这是一种搜索模式，它说的是什么
匹配A或D.
因此无论何时编写它的方式都是你写的
a，只要是方括号之间的东西，
让我们假设你给它匹配的字符。
在方括号内，任何东西都是可选的。
所以，如果你要匹配A或D.
在给定的字符串中。
所以它会找到A或D.
它将由明星取代它们。
所以让我们运行它，看看我们是否得到了正确的输出。
好的，所以如果你看一下这个，
所有的A都被明星和所有的D所取代
也被一个明星所取代。
我们再来一个。
现在你想匹配模式abc。
所以这不是a或b或c，这就是说，这就是说
它必须是那个序列中的abc并替换所有的abc。
所以它在这里和这里取代了abc。
让我们将它与第一个进行比较。
你看到了区别？
如果你这样做，让我们假设A和D，让我们看看。
没有任何变化，因为AD不在序列中。
但如果我们放入方括号，那么我们就得到了
几乎相同的输出，对吧。
现在这是另一个。
这表示A或B或C然后是一个或两个或三个。
所以让我们试一试，看看我们得到了什么输出。
一个匹配，B两个匹配，
B四没有匹配，因为D附近都没有
事情是四个。
我们假设我们有D.
即便如此，它也不会匹配，因为没有四个。
但是如果你在这里添加四个，那么你得到一个匹配。
首先，它说第一个角色应该是
A或B或C或D.
字符串中的第二个字符应该是
一，一，二，三或四。
我们再来一个。
问题是，这又是
像一个更简单的，但后来有
也很复杂。
有这个点，正则表达式，
有符号。
有关于如何描述模式的符号。
让我们看看我们用AB获得了什么
好的，AB在做什么？
它说基本上匹配任何序列。
A，以A开头，大写A，然后添加任何字符。
所以dot代表键盘上的任何字符
然后是B.
所以A到B匹配。
AXB匹配并被一颗星代替。
AXXB无法匹配。
一美元B匹配。
如果我要添加另一个点，那会发生什么？
然后前三场比赛都没有比赛，只有这场比赛。
这可能是任何角色。
它本身也可以是AB。
但这可能是美元，它仍然会匹配。
方括号，圆点，所有这些都是符号
现在什么是AB +？
所以它多次说A和B。
我们来试试吧。
它匹配A然后匹配B.
所以它被一个明星所取代。
然后A和所有这些B被一颗星代替。
然后A，看，这没有动过
因为它不匹配。
得到它，所以这说嘿，找到一个字符串
在这一个内的子串内。
Sub是找到任何匹配的模式
第一个字符是A，第二个字符是B +。
这是做什么的？
这说AB但B在三到六次之间。
所以当它是花括号时，那就是说B
必须是三到六次。
如果少于三次，则不会替换。
因此ABB不会被取代。
如果超过六次，则不会替换。
它只会替换到这一点，直到前六个
然后将最后三个B字符排除在外。
它匹配这个，它自然匹配。
这是非常重要的一个。
这是为了匹配任何与ABC的开头。
字符串的起始部分开始
与ABC相匹配。
请注意，这不匹配。
每当你有这个上限时，这个上限操作员
在这里，它将寻找字符串的开头
它将开始从那里取代它。
它不会查看字符串的结尾。
如果要匹配字符串的末尾
你需要做ABC美元。
当然，如果你想要匹配任何一种方式，
然后你只需将它保持为ABC然后它将取代
开始和结束。
但只有在最后你需要投入一美元，
从字符串后面开始查看的位置。
上盖，它将从字符串的前面开始。
同样，还有更多此类。
就像在这一点上有一些复杂的东西。
就所有存在的方式而言，这有点大。
更好的方法是找到它
越来越多的正则表达式
并且越来越多地练习它。
然后我们只做了一个替代品，但也有
搜索和匹配，告诉您是否可以找到
某件事与否。
它只是给你一个匹配对象。
如果是这样的话，让我们假设abc，你这样做了，
它会给你没有，因为它找不到abc
在字符串中。
所以你只需确认搜索对象即可找到匹配项，
但什么也不做。
你只是确认没问题，
此字符串存在于此字符串中。
然后有一个匹配对象。
好的，匹配对象的作用是什么？
比赛开始寻找比赛
在字符串的开头。
搜索看起来在任何地方，但匹配看起初。
所以这实际上类似于
我会证明它类似于这样说。
这取决于你如何写它，
是否要使用re.search或re.match编写它。
当您期望多重时，通常会使用Re.search
一个词多次出现。
Re.match更多地出现在字符串的开头。
因此，如果您要匹配电子邮件ID，则可以使用re.match
但如果你正在寻找特定的蓝色这个词
文本文档，那么你将使用re.search。
因此，您可以使用它来匹配电子邮件ID或手机号码。
这就像一个非常非常典型的应用程序
正则表达式。
我们来谈谈Python中的包。
所以包是Python模块的集合。
我们学习了模块，这只是Python文件。
但是包基本上是一堆模块
逻辑上结合在一起。
Python包允许您分解大型系统
并以与您一致的方式组织他们的模块
和其他人可以有效地使用和重用。
再说一次，如果你看一下编程，就会有很多压力
关于事物的可重用性。
无论是功能还是类或模块
或者包，很多东西都是关于构建块的
并将它们组合在一起并使它们协同工作。
所以我们做到了，对。
我们有背包，进口，笔，纸，计算器。
我们已经涵盖了这一点
我们在哪里了解了导入功能
并找到了一个。
我们来谈谈异常处理。
异常是出现错误或异常时发出的信号
条件已经发生。
一个非常典型的异常例子是
你试着除以零。
现在，在数学上，方案是以编程方式
你没有写任何不正确的，
但数学上无法做到这一点。
那么Python做什么或任何其他编程语言做什么
是它抛出错误说零分裂
是错误，不允许，
这是一个特例。
这不是不正确的事情，
但这是一个例外
因为在一个非常基本的层面上失败了。
基本水平是不可能的
或意外情况。
地震意义上的意外情景
是一个特例，对吧。
在考虑时考虑特殊情况
异常处理。
现在，你需要保持谨慎
这些特殊情况。
您需要将它们视为程序员并确保它们
您正在代码库中处理它们。
这对于优雅降级非常重要
的软件。
这对于显示当前类型非常重要
错误的用户，这是一个整体，
一个非常非常需要的代码编程实践。
所以语法和Python是尝试。
试着说，尝试块会发生什么
你写下你想要做的任何事情。
让我们假设你正试图分裂。
所以它将在这里定义的try块下，
当然还有缩进。
然后你将处理某些例外。
让我们假设当你试图划分两个数字时，
你期待三种例外。
一个例外可能是用户可能试图划分
零或让我们假设用户可能试图划分
非常大的数字或分母可能是如此之小
这个数字是如此之大，以至于它无法适应
在你的电脑的记忆中。
这是可能的。
就像，计算机有其局限性。
就像我们的计算机可能写入数百个
数千万亿，但它将达到极限
它不能存储大于给定数字的数字。
现在，所有这些都是不同的例外。
它比你处理不同的例外更好
以不同的方式。
例如，处理非常大的数字将是
与处理用户非常不同
关于零输入。
所以如果数字太大，它可能仍然可以，
你知道试着找出如何表现它
以不同的方式，仍然给用户一个解决方案。
但除以零，你可能只是告诉用户
嘿，你给了一个糟糕的输入。
所以不要把它与if if混淆
因为在某种意义上我见过人们使用它
事情本可以做的时候，而不是其他
通过if else声明，
但是这些东西，这个用的时候会更多
你期待一些意想不到的事情。
是的，所以我知道这是一个头部旋转器，但你期待，
你期待着。
因此，我认为我应该使用而不是期待
这个词期待。
我们期待嘿，这件事可能会出错。
我可能得到一个糟糕的输入，所以让我只是制作我的程序
可塑性足以处理那种情况。
因此try子句可以包含任意数量的except子句
处理它们的方式不同，但只会执行一个
如果发生异常。
所以我们会提高价值误差，只有一个会
被执行，它找到的第一个。
您也可以使用此类操作
你必须找到已处理的多个错误
与此同时。
正在处理typeError和zerodivisionerror
以同样的方式。
假设用户输入了一个你想要的字符串
在这两种情况下，用户被告知嘿，
与值错误相比，您输入的输入错误，
哪里出了别的东西，对。
正如我们所讨论的那样，让我们​​假设这更多的是
大数错误，这是类型错误
零分错误。
然后是除了，这是为了处理任何意外
或者意料之外的例外。
这甚至是你无法做到的
期待，但你仍然知道这可能会破裂
因为这是一个背景，你正在这样做
用于关键任务应用。
让我们快速看一个例子吧。
所以我们试图从一个数字中获取输入。
现在Python为我们提供了raise关键字，
我们可以用来引发异常。
我们人为地提出例外。
这不是通常的方式，但我们是人为的
提出异常只是为了让它可以进入这个区块。
我想我们应该看一下这个例子。
让我们假设进入和随机性，
我们正试图分裂。
正如我所说，你可以获得预期的输入。
那么让我们看看当我们运行它时会发生什么。
是的，所以如果你看一下这个，它第一次执行
一分为A.
条目A和异常发生。
糟糕，这会为您提供下一个条目的信息
它会进入下一个条目。
它做零，没有什么可以做。
如果是真的，那么你会得到一些结果。
然后你会得到一些结果
但如果你注意到现在发生了什么
是你没有，你的程序会停止
在第一步，但执行到最后
因为你正在处理例外
因为它们正在发生，所以某种方式或其他方式。
想象一下，你得到了随机输入
而你正在迭代它，这就是你的样子
排序去处理它。
try语句中还有finally块。
它可以有一个选项finally子句。
无论什么和通常使用，都执行该子句
释放外部资源。
这是以防万一，我们假设您正在阅读文件，
并发生一些异常，你无法处理
例外，但仍然，你想要的无论如何
在处理完文件后的任何内容，
它应该被关闭，因为它是一个非常非常大的文件。
你只是不想留下机会，留下它
记忆因为那会引起很多问题。
这就是你要进行任何清理的地方。
最后主要用于任何类型的清理
是否需要切断DV连接
或者文件需要关闭。
这就是你将使用finally块的原因。
所以这是一个例子。
我们正在尝试写入文件。
我们假设发生错误
你不能写入文件。