python 两点曲线_Python自学教程| 3万字详解每个重要知识点（内附视频）

本文目录：

1. 什么是Python？

2. Python的用途是什么？

3. 如何安装Python？

4. 为什么选择Python？

5. R与Python

6. 学习Python的最佳方法

7. 什么是顶级Python IDE

8. 哪个是最适合Python的IDE？

9. 如何为Jupyter Notebook供电？

10. Python Notebook(Jupyter)中的功能

11. 注释

12. 变数

13. 经营者

14. 算术运算符

15. 赋值运算符

16. 比较运算符

17. 逻辑运算符

18. 身份运算符

19. 会员运营商

20. 按位运算符

21. 拉姆达

22. 数组

23. 班级

24. 遗产

25. 迭代器

26. 范围

27. 模组

28. 日期

29. JSON格式

30. 正则表达式

31. 画中画

32. 尝试，除了

33. 用户输入

34. 字符串格式

35. Python数据类型

36. 流程控制声明

37. 文件处理

38. 用Python创建函数

39. 通过使用Python作为计算器来学习简单命令

1.什么是Python？

Python是一种高级的，面向对象的编程语言。开发领域的大多数初学者都喜欢Python，因为它的简单性和多功能性使其成为最先学习的语言之一。它也得到了社区的大力支持，并与日俱增。

在这个面向初学者的Python教程中，我们将学习Python作为编程语言的基础知识，并了解如何开始使用它。我们将看到如何下载和安装Python以及如何使用流行的IDE开始编码。我们还将详细讨论jupyter功能。

2.Python的用途是什么？

当您使用浏览，每天在视频网站上观看视频或在收听自己喜欢的音乐时，请记住，他们所有人都使用Python来满足编程需求。Python在应用程序，平台和服务中有多种用途。让我们在这里谈论一些。

2.1-Web开发

大量的预构建Python库使Web开发变得更加简单。由于其简洁明了的语法，因此编写Python代码的时间更少。这有助于快速建立原型，从而加快商业产品的投资回报率。内置的测试框架有助于交付无错误的代码。大量支持良好的框架有助于在不影响解决方案性能的情况下加快实施速度。

2.2-物联网

为了简单起见，让我们将物联网视为“将嵌入式系统连接到互联网的物理对象”。它在涉及大数据，机器学习，数据分析，无线数据网络和网络物理系统的项目中起着至关重要的作用。物联网项目还涉及实时分析。

考虑到上述应用领域，编程语言应该是一个大胆的选择。这是Python选中所有复选框的地方。此外，Python还具有可伸缩性，可扩展性，可移植性和可嵌入性。这使得Python独立于系统，并使其可以容纳多台单板计算机，而与操作系统或体系结构无关。

而且，Python是管理和组织复杂数据的绝佳选择。对于大量数据的物联网系统而言，它特别有用。Python成为IoT应用程序理想编程语言的另一个原因是它与科学计算的紧密联系。

2.3-机器学习

机器学习为解决问题提供了一种全新的方法。由于以下原因，Python处于机器学习和数据科学的最前沿：

• 广泛的开源库支持

• 高效而精确的语法

• 易于与其他编程语言集成

• Python的入门点很低

• 可扩展到不同的操作系统和体系结构

3.如何安装Python？

如果您是Windows用户，并且已使用Anaconda.org上可用的Anaconda发行包安装了Python，则需要转到“ Download Anaconda ”，然后下载适用于Python 3.6的最新版本。
下载此文件后，这是一个非常简单明了的过程，并且将为您安装Python。下一步是启动IDE，以开始使用Python进行编码。

因此，一旦安装了Python，您就可以在Python安装的顶部拥有多个IDE或文本编辑器。

对于文本编辑器，可以使用Sublime或Notepad ++之类的东西。如果您喜欢使用集成开发环境，则可以使用Jupyter。此外，还有其他选项，例如Wingware，Komodo，Pycharm和Spyder。

Python中有多个可用的软件包。一些工具库是numpy，pandas，seaborn以进行可视化，并通过scipy进行计算和统计。其他是xlrb，openpyxl，matplotlib和io。

(配套视频见文末)

4.为什么选择Python？

因为Python已成为支持数据科学和机器学习应用程序的首选编程语言。当然，Python有其优势。与其他编程语言相比，它是快速的，甚至R也是如此。 我们可以很容易地说Python是一个快速的编译器。由于它是一种基于Java的编程语言，因此您可以将其应用程序扩展到分析研究，分析建模和统计建模之外。您将能够使用Python创建Web应用程序，并将这些Web应用程序直接集成到后台的分析模型中。 Python也很容易与其他平台和其他编程语言集成。它具有通用的面向对象的编程体系结构，其中现有的IT开发人员，IT分析师和IT程序员发现很容易过渡到分析领域。
由于Python中的编码结构是面向对象的编程体系结构，因此它具有出色的文档支持。

使用Python的7个理由

1. 可读且可维护的代码

2. 多种编程范例

3. 与主要平台和系统兼容

4. 强大的标准库

5. 开源框架和工具

6. 简化软件开发

7. 测试驱动开发

5.R vs Python？

R是为统计分析应用开发的；另一方面; Python是作为通用编程语言开发的。对于使用大型数据集，解决机器学习问题并创建复杂的数据可视化的人来说，这两者都是必不可少的。

让我们看一下R和Python之间的区别。

开发Python是为了提供一种编写脚本的方法，以使每天遇到的一些例行任务自动化。但是，随着时间的流逝，Python已经发展并在许多其他领域变得非常有用，尤其是数据分析。

R是一种编程语言，同时也是用于图形和数据分析的开源软件。它具有可以在任何计算机系统上运行的优势，并且被数据挖掘者和统计人员用于对其数据进行表示和分析。

Python与R进行数据分析编程对于
数据科学家来说，决定使用Python还是R进行数据分析是一个普遍的挑战。尽管R是纯粹为统计人员开发的，使它能够将分析描述为可视化数据的特定优势，但Python凭借其通用特性和语法非常规则而脱颖而出。基于这些差异，有必要将两种语言进行比较，以确定哪种语言最适合它们。

Python程式设计语言

• – Python编程语言受到Modula-3，ABC和C语言的启发
• – Python专注于代码的可读性和生产力
• –由于其易于使用和简单的语法，因此更易于开发代码和调试
• –代码缩进会影响其含义
• –所有功能通常都以相同的样式编写
• – Python非常灵活，也可以用于Web脚本。
• –它具有相对渐进和较低的学习曲线，因为它注重简单性和可读性
• –适合开始编程的人
• –其Package索引称为PyPi。其带有库的Python软件仓库。尽管用户可以选择为Pypi做贡献。在实践中很难。
• – RPy2可在Python中用于运行R代码的库。用于从Python向R提供较低的级别。
• – 2014年，Dice Tech薪酬调查显示，经验丰富的专家的平均工资为$ 94139
• –主要用于需要将分析的数据与Web应用程序集成或将统计信息用于数据库生产时
• –尽管数据处理能力有所提高，但过去处理数据的能力仍然是一项挑战，这是由于其数据处理程序包尚处于初期阶段
• –您必须使用pandas和NumPy之类的工具才能将其用于数据分析
• –可用的IDE包括Spyder，IPython Notebook。

R编程

• – S编程语言激发R。
• –强调用户友好的数据分析方法，图形模型和统计信息。
• –由于统计模型只用很少的几行编写，因此使用起来有点困难。
• –存在R样式表，尽管很少使用
• –表示或编写相同功能块的方法有很多。
• –使使用复杂的R公式变得容易。对于它的许多统计模型和检验。
• –在学习基础知识时，学习曲线开始就很陡。但是以后学习高级主题变得非常容易
• –对于专业程序员来说并不难。
• –全面的R存档网络(CRAN)。CRAN是R存储库软件包，很容易由用户提供。
• – R中的rpython包用于运行Python代码。调用Python方法或函数并获取数据。
• – 2014年，Dice Tech薪酬调查显示，经验丰富的专家的平均工资为$ 115 531
• –主要用于需要独立计算或独立服务器的分析。
• –用于初学者的关键任务时更容易。使用很少的代码行来编写统计方法。
• –非常适合处理大包装中的数据。可用的测试和公式的使用。
• – R不需要其他程序包即可进行基本分析。对于大型数据集，只需要像dplyr这样的软件包即可。
• –使用R studio IDE

Python –优点

1. IPython Notebook促进并简化了Python和数据的使用。这是因为您可以与其他人共享笔记本而不必告诉他们安装任何东西。这减少了代码组织的开销，因此使人们可以专注于完成其他有用的工作。

2. 鉴于它是一种通用语言，因此它既直观又简单。它使数据科学家的学习曲线平坦，从而使他能够提高自己的程序编写技能。Python还有一个内置的测试框架，可以鼓励改善测试范围，这反过来又保证了代码的可靠性和可重用性。

3. 它是一种多用途的编程语言，它将具有不同背景的人们(统计学家和程序员)聚集在一起。

R –优点

1. R提供清晰的数据可视化，使数据得到有效的设计和理解。ggvis，ggplot2，rChart和googleVis是其可视化软件包的示例。

2. R具有活跃社区和理想软件包的广阔生态系统。该软件包可从Github，BioConductor和CRAN获得。

3. 它是由统计学家为统计学家开发的。因此，他们可以通过R包和代码交流概念和想法。

两种语言各有优势，您可根据个人喜好选择一种可以解决您问题的语言。

6.学习Python的最佳方法？

易于学习是Python受欢迎的主要原因。它是一种简单且无类型的编程语言，因此易于学习。学习语言所需的时间取决于您要使用Python达到的水平。同样，学习曲线可以根据个人能力而变短或变长。

一个人需要6到8周的时间来学习Python的基础知识。这将包括学习语法，关键字，函数和类，数据类型，基本编码和异常处理

并非所有Python专业人士都需要高级Python技能。根据您的工作性质，您可以学习诸如数据库编程，套接字编程，多线程，同步技术等技能。

高度复杂的Python技能包括数据分析的概念，所需库的动手经验，图像处理等。每个专业技能都需要大约一周的时间才能掌握。

7.什么是最受欢迎的Python IDE？

有7个适用于Python的顶级IDE

1. 斯派德

2. 药香

3. 托尼

4. 原子

5. 朱皮特

6. 科莫多

7. 翼件

8.哪个是最适合Python的IDE？

Jupyter是Python最好的IDE，也是Python使用最广泛的IDE之一。让我们看看如何设置Jupyter Notebook。另外，让我们看看Jupyter Notebook的功能是什么。

9.如何为Jupyter Notebook供电

以下是启动Jupyter笔记本电脑的指导步骤：

1. 打开Anaconda提示符。如果您通过Anaconda安装程序完成了安装，则可以使用该选项。 

2. 打开Anaconda命令提示符后，您将看到分配给您的默认路径。这是您使用的计算机的用户名。

3. 将文件夹路径添加到您要在其中打开笔记本的默认路径(例如cd Desktop→cd Python)

4. 设置路径后，使用命令jupyter notebook 添加Jupyter笔记本

   

5. 按回车。这将在本地主机(即系统)中打开笔记本

6. Anaconda提示中描述的路径现在将出现在jupyter笔记本主页上

7. 下一步是打开一个新的Python Notebook。这是您执行所有编码的环境。您可以将新笔记本(无标题)重命名为您想要的名称，然后单击“重命名”。

在本地使用Jupyter时，请保持anaconda提示符处于活动状态，这是您用来为Jupyter笔记本电脑加电的电源。如果关闭了anaconda提示符，则说明系统上不再运行python，并且内核已断开连接。

10.Python Notebook(Jupyter)中的功能

工具栏上有多个选项，即文件，编辑，视图，插入，单元格，内核，小部件和帮助。让我们一一看一下其中的一些特征和功能。

文件选项

保存和检查点– 设置检查点是一个有趣的概念。该文件会定期进行自动保存，通过设置检查点，您可以跳过一些自动保存到设置的检查点的操作。如果您在过去的几分钟或几小时内犯了一个错误，这将有所帮助。您始终可以还原到更稳定的检查点，然后从那里继续执行代码，而不是从头开始。 

下载为– 有多种下载Jupyter Notebook的方式。首先是Classic Notebook，它是ipynb 扩展名。在被称为jupyter笔记本之前，它是一个Ipython笔记本。这就是为什么扩展名。
然后，您有了.py 扩展名。保存带有.py 扩展名的文件，您可以将其导入到其他IDE中以方便使用。 关闭并暂停–此命令关闭在此特定时间点运行的所有内核，并暂停所有进程。

编辑选项

它包括剪切单元格，复制单元格，粘贴，删除，拆分单元格，上移，下移等。

那么，什么是细胞？

单元格不过是您在窗口中出现的对话框中键入的代码。这是一个单元格，您可以在其中键入代码-运行时，每个单元格都会为您提供输出。

要运行这段特定的代码，您可以单击特定的选项，即运行单元格或快捷键是Shift + Enter 。 

如果要浏览其他可用的快捷方式选项，可以在“ 键盘快捷方式”中的“ 帮助” 下获得。您可以剪切这些单元格，以后再粘贴。您可以合并，拆分等等。这些是简单的项目。 

查看选项

您也可以切换标题，工具栏和行号。 

插入选项

这些是基本的插入操作。您可以根据代码要求在上方或下方插入一个单元格。

单元选项

如果您单击全部运行，它将运行整个工作簿中存在的所有单元格。当您单击“ 全部运行”时，它将运行所选单元格上方的所有单元格。同样，如果您单击“ 在下方运行所有文件” ，它将运行所选单元格下面的所有单元格。

不同类型的单元格，即 代码，降价和原始转换文件。我们将在代码文件中大量使用的一项令人兴奋的功能是Markdown文件。降价仅是将您在单元格中键入的内容转换为文本消息。

您转换为Markdown的单元格将不会运行或视为一行代码。当您运行此单元格时，它将被视为一个文本字段，并且输出也是文本。在此单元格上不执行任何计算。

帮助选项

在这里，您可以看到可用的常用库和软件包。您可以单击这些选项，这将打开指南或参考书，您可以在其中查看所选软件包中可用的各种方法。使用Jupyter时，您可以尝试其他各种选项。

11.注释

注释对于描述程序逻辑和各个模块的用途很有用。除编码人员外，其他人员也可以通过查看有意义的注释来理解代码。 在测试程序时，注释可用于禁用部分代码，并从执行中排除。 Python注释以＃符号开头。注释可以是自己的，也可以在同一行中的代码之后开始注释。下面说明了这两种情况。

# comment in separate line  x = x * 5x = x * 5   # multiply by 5; comment in same line# this function is going to divide two variables  # the second value should not be zero  # if it is zero, error is thrown  def divide(first, second):

提及多行注释没有其他方法。＃可以添加到不同的行。 当＃放在引号内时，则它是字符串的一部分，而不是注释。 例如，

str = "# hello world"

12.变数

Python变量是保存数据的容器。这些分配给变量的数据值可以在以后的阶段进行更改。 对变量的第一次值分配将创建变量。没有明确的变量声明。

numOfBoxes = 7  ownerName = "Karthik"  print("numOfBoxes= ", numOfBoxes)  print("ownerName= ", ownerName)

上面示例中，创建了两个带有数字和字符串数据的变量。打印语句用于显示这些变量。 变量名称遵循以下约定。

• 变量名称以字母或下划线字符开头
• 其余名称中允许使用字母数字和下划线
• 变量名称区分大小写

# valid names  numOfBoxes = 7  _num_of_boxes = 10           # this is a different variable than numOfBoxes  _NUM_OF_BOXES = 15   # a different variable as names are case sensitiveownerName = "Karthik"  ownerName2 = "Charan" # different, valid variable# invalid names  2ownerName = "David"    # cannot start with number.                                              # Only letter or underscore in the beginning  owner-name = "Ram"       # no hypen  owner name = "Krish"      # no space allowed                                            # only alpha numeric and underscore

在这里，我们列出了一些可能的变量名称和一些无效的名称。 在python中，您可以为多个变量分配多个值。同时将相同的值分配给多个变量。请看这个例子。

# different values assigned to many variables  length, width, depth = 5, 8, 7  print(length)  print(width)  print(depth)# same value assigned to many variables  length = width = depth = 5  print(length)  print(width)  print(depth)

13.经营者

运算符可帮助处理变量和值。例如，如果我们可以使用两个数字变量，则可以将它们相加或相减，相乘或相除。这些操作会更改值并给出新值。 Python支持以下类别的运算符。

• 算术运算符
• 赋值运算符
• 比较运算符
• 逻辑运算符
• 身份运算符
• 会员经营者
• 按位运算符

14.算术运算符

使用算术运算符执行诸如加法，减法之类的数学运算。让我们通过它们。

a = 10  b = 6  print (a + b)    # addition  print (a - b)     # subtraction  print (a * b)     # multiplication  print (a / b)      # division  print (a % b)    # modulus  print (a ** b)   # exponentiation  print (a // b)    # floor division

所有操作都很容易理解。模运算返回除以两个数的余数(在我们的示例中，4是提示)。同样，底数除法是整数除法，它返回除法结果为整数(10 // 6 = 1)。

15.赋值运算符

可以使用赋值运算符将值或变量内容分配给另一个变量。右侧也可以是表达式(在下面的示例中为c赋值)。这里有一些例子。

a = 7  # assign value to a  b = a  # assign value of a into b  c = a + b -2  # calculate an expression and place result into c  b += 2   # equivalent to b = b + 2  b -= 2    # equivalent to b = b - 2  b *= 2   # equivalent to b = b * 2  b /= 2    # equivalent to b = b / 2  b %= 2   # equivalent to b = b % 2  b //= 2   # equivalent to b = b // 2  b **= 2  # equivalent to b = b ** 2  b &= 2   # equivalent to b = b & 2  b |= 2    # equivalent to b = b | 2  b ^= 2    # equivalent to b = b ^ 2  b >>= 2  # equivalent to b = b >> 2  b <<= 2  # equivalent to b = b << 2

最后五个运算符将在下面的后面部分中说明。

16.比较运算符

比较两个值，结果是布尔值True或False。在if和loop语句中使用以进行决策。

a = 3  b = 7  print(a == b)  # true if a and b are equal  print(a != b)  # true if a and b are not equal  print(a > b)  # true if a is greater than b  print(a < b)  # true if a is less than b  print(a >= b)  # true if a is greater than or equal to b  print(a <= b)  # true if a is less than or equal to b

让我们看一个实际比较的例子。在这里，我们检查a是否小于b。如果此条件为真，则执行一条语句。否则，执行其他语句。

a = 3  b = 7  if(a < b):      print("first number is less than second one");  else:      print("first number is greater than or equal to second one")

17.逻辑运算符

可以使用逻辑运算符组合两个或多个比较操作。这些逻辑运算符返回布尔值。

a = 5  b = 8  # True if both conditions are true  print(a > 3 and a < 7)  # True if one condition is true  print(a > 6 or b < 7)  # True if given condition is false (inverse of given condition)  print(not(a > 3))

18.身份运算符

身份运算符比较两个对象是否相同。他们需要指向相同的位置。

a = ["hello", "world"]  b = ["hello", "world"]  c = a  # prints true as both are same element  print(a is c)  # prints false as they are two diffent values  # content may be same, but value locations are different  print(a is b)  # comparing the values gives true  print(a == b)  # not negates the comparison result  # if two variables are not same, then result is true  print(a is not c)  print(a is not b)

19.会员经营者

检查给定列表中是否存在元素。

a = ["hello", "world"]  # checks if given element is present in the a list  print("world" in a)  # checks if given element is not present in the a list  print("world" not in a)

20.按位运算符

在处理二进制数时，我们需要按位运算符来操作它们。二进制数是零和一，它们被称为位。

a = 1   # binary equivalent of 1 is  1  b = 2   # binary equivalent of 2 is 10  # In case of AND(&) operation, if both bits are 1, set result to one  # in our case, two corresponding bits are not 1  # so, corresponding result is 0  print(a & b)  # OR operation (|), gives 1 if either operands are 1  # The reult of 0 and 1 is 1, 1 and 0 is 1  # hence, a | b gives binary 11 or decimal equivalent of 3  print(a | b)  # XOR (^) returns 1 if only one of the operands is 1  # 1 ^ 1 = 0, 0 ^ 0 = 0, 1 ^ 0 = 1, 0 ^ 1 = 1  # considering a and b, they have only ones in each bit position  print(a ^ b)  # NOT operation negates the bit value  # NOT 0 = 1, NOT 1 = 0  # while negating b, all preceeding zeros are turned to one  # this leads to a negative number  print(~ b)  # zero fill left shift (<# zeros are filled from right, bits are shifted to left  # left most bits fall off  # in this example, we shift the bits of b twice  # 10 (b) shifted twice is 1000 (which is decimal 8)  print(b << 2)  # signed right shift (>>)  # shift the bits to the right, copy leftmost bits to the right  # right most bits fall off  # when we shift b (10) once to the right, it becomes 1  print(b >> 1)

21.拉姆达

前面我们看到了函数定义和函数调用。Lambda是匿名的小函数。Lambda的主体只能有一个表达式。Lambda可以接受任意数量的参数。

# a lambda function with the name growth is created  # it takes one argument and increase it by 2  growth = lambda givenLength : givenLength + 2  print(growth(25))  # prints 27  Let us take another example with many parameters:# lambda with the name area is created  # two parameters are passed, who area is calculated  area = lambda length, breadth: length * breadthprint(area(4, 7))  # prints 28

当嵌套在另一个函数中时，lambda很有用。函数成为创建函数的模板。

# the growth lambda we wrote earlier  def growth(n):      return lambda a : a + n  # create a function that would increase by 2  strechTwo = growth(2)  # create a function that would increase by 3  strechThree = growth(3)  print(strechTwo(7))  print(strechThree(7))

在上面的示例中，使用相同的函数增长，我们生成了不同的函数strechTwo和strechThree。这可以通过在growth函数中声明的lambda函数来实现。通过运行此代码，我们得到输出9和10。

22.数组

数组用于在变量中存储值列表。这是创建数组的语法。方括号用于定义列表。

fruits = ["mango", "apple", "grapes"]  print (fruits)

数组允许我们使用索引访问数组元素。索引从零开始，从零开始。

fruits = ["mango", "apple", "grapes"]  firstFruit = fruits[0]  print (firstFruit)

与访问元素类似，我们可以使用索引来修改元素。

fruits = ["mango", "apple", "grapes"]  fruits[0] = "melon"  print (fruits)

可以使用len()方法知道数组中元素的数量。

fruits = ["mango", "apple", "grapes"]  print (len(fruits))  # prints 3

for语句用于遍历数组元素。我们可以在循环内处理单个元素。

fruits = ["mango", "apple", "grapes"]  for fruit in fruits:      print(fruit)

append()方法将新元素添加到数组的末尾。

fruits = ["mango", "apple", "grapes"]  fruits.append("guava")  print(fruits)  

有两种方法可用于从数组中删除元素。pop()方法获取数组索引，并删除特定位置的元素(请记住元素是从零开始的)。remove()接受元素的值并将其删除。让我们看看这两种方法的作用。

fruits = ["mango", "apple", "grapes"]  fruits.pop(1)  print(fruits)  fruits.remove("grapes")  print(fruits)

23.班级

对象是具有属性和方法的实体。这些对象可以通过声明类来创建。类是对象的蓝图。 在此示例中，我们看到如何定义一个类，如何在该类之外创建对象以及访问该对象的属性。

# create a class with "class" keyword  class Fruit:      # a property, "name" is created      # the property is assigned with the value "mango"      name="mango"  # let us create an object, "oneFruit" using the above class  oneFruit = Fruit()  # the property of the object "oneFruit" is accessed like this  print(oneFruit.name)

所有类都有一个内置函数__init __()从该类创建新对象时将调用此函数。创建对象时会自动调用此函数。 我们可以在该函数中编写有用的初始化代码，以便在对象实例化时设置变量。 

# create a class with "class" keyword  class Fruit:      # define the init function      def __init__(self, name, color):          self.name = name          self.color = color  # let us create an object, "oneFruit" using the above class  # values are passed to the class  oneFruit = Fruit("mango", "yellow")  # the property of the object "oneFruit" is accessed like this  print(oneFruit.name)  print(oneFruit.color)

在上面的示例中，我们使用了参数“ self”。在init函数中定义了三个参数，但是我们在类调用中仅传递了两个参数。自参数会自动传递给类的方法。名称“ self”不是固定的，可以使用任何名称。它必须是第一个参数。  除了内置方法之外，该类还可以具有其他用户定义的方法。让我们在类内部创建一个makeJuice()方法。

# create a class with "class" keyword  class Fruit:      # define the init function      def __init__(self, name, color):          self.name = name          self.color = color      def makeJuice(self):          print("Made " + self.name + " juice. It will be in " +               self.color + " color.")  # let us create an object, "oneFruit" using the above class  # values are passed to the class  oneFruit = Fruit("mango", "yellow")  # invode object's method  oneFruit.makeJuice()  The property of the object can be modified like this:oneFruit.color = "red"

24.遗产

继承是一个概念，其中我们扩展类的功能以创建新的类。这样做有很多好处。首先是重用现有代码。 现有类具有可以重用的通用代码。该类称为父类或基类。 我们创建一个子类，该子类将从父类接收定义。 让我们考虑一个父类，车辆。它具有适合描述任何车辆的特性和方法。

lass Vehicle:      def __init__(self, make, color):          self.make = make          self.color = color      def display(self):          print("make= " + self.make + " color= " + self.color)  v = Vehicle("2015", "green")  v.display()

Vehicle属性中定义了两个属性，make和color。 让我们从Vehicle类扩展一个子类Car。

class Vehicle:      def __init__(self, make, color):          self.make = make          self.color = color      def display(self):          print("make= " + self.make + " color= " + self.color)  # v = Vehicle("2015", "green")  # v.display()  class Car(Vehicle):      def __init__(self, make, color, numOfSeats):          super().__init__(make, color)          self.numOfSeats = numOfSeats      def display(self):          super().display()          print("number of seats= " + str(self.numOfSeats))      def wipeWindshield(self):          print("turned on wiper")  newCar = Car("2019", "orange", 5)  newCar.display()  newCar.wipeWindshield()

在此代码中有许多要注意的地方。 第12行定义了一个类Car。这是一个扩展的载具(在括号中提到)。 第13行是Car的构造函数。接受三个参数。 第14行调用父类Vehicle类的构造函数。两个参数传递给父级的构造函数。 第15行初始化一个对象属性numOfSeats。此属性属于Car，并且在Vehicle类中不存在。 第17行重新定义方法display()。在方法的代码中，将调用父方法，并且那里的代码可以表达Car对象的功能。 第21行定义了一个属于Car类的方法。 第24至26行创建一个Car对象，处理Car属性并调用各种方法。

25.迭代器

迭代器是值的容器，我们可以使用它遍历所有值。 在Python中，迭代器是实现__iter __()和__next __()的对象。 列表，元组，字典和集合是可迭代的，并实现了迭代器协议。这些容器具有用于遍历值的iter()方法。 这是一个例子。

fruitTuple = ("mango", "apple", "grapes")  fruitIter = iter(fruitTuple)  print(next(fruitIter))  print(next(fruitIter))  print(next(fruitIter))  A string can be iterated using iter() method.fruitStr = "mango"  fruitIter = iter(fruitStr)  print(next(fruitIter))  print(next(fruitIter))  print(next(fruitIter))  print(next(fruitIter))  print(next(fruitIter))  print(next(fruitIter)) # last call throws error

请注意，前五个next()调用将打印“ mango”的每个字符。最后的next()引发错误，指示迭代已停止。 可迭代对象可以使用for in循环进行迭代。

fruitTuple = ("mango", "apple", "grapes")  fruitIter = iter(fruitTuple)  for fruit in fruitTuple:      print(fruit)

我们可以创建自己的迭代器类。我们需要实现__iter __()和__next __()方法。 还记得我们在类定义中看到的__init __()吗？迭代器的方法和协议类似于该类的init。 让我们考虑一个创建迭代器的示例。迭代器是从1、2开始的斐波那契数列。

class Fibonacci:      def __iter__(self):          # define first two numbers          self.first = 1          self.second = 2          return self      def __next__(self):          curr = self.first + self.second # find new number          self.first = self.second # shift the previous two numbers          self.second = curr          return curr  fibo = Fibonacci ()  fiboIter = iter(fibo)  print(next(fiboIter))  print(next(fiboIter))  print(next(fiboIter))  print(next(fiboIter))  print(next(fiboIter))

当第15行iter(fibo)被调用时，内部会调用__iter __()。调用next(iter)时，将调用__next __()方法来查找系列中的下一个元素。 该迭代器永无休止，因为没有终止控件。 为了防止无休止的系列，我们可以添加StopIteration语句。在__next__中，我们可以添加条件并使用StopIteration。

class Fibonacci:      def __iter__(self):          # define first two numbers          self.first = 1          self.second = 2          return self      def __next__(self):          curr = self.first + self.second # find new number          if (curr <= 50):              self.first = self.second # shift the previous two numbers              self.second = curr              return curr          else:              raise StopIteration  fibo = Fibonacci ()  fiboIter = iter(fibo)  for f in fiboIter:      print(f)

在此示例中，我们检查斐波那契数列是否已达到50。任何大于或等于50的值都会产生错误。那将停止for循环。

26.范围

该变量仅在声明的区域中可用。这种变量声明的局限性是范围。变量或方法的范围定义了这些元素的可访问位置。

def func1():      a = 5      print(a)  func1()  print(a)

最后一个打印语句将引发错误，因为在代码的主要部分无法访问a。 在所有位置都可以访问变量的一种方法是在全局范围内声明变量。在主级别创建的变量是全局变量，可以在函数定义中访问。

a = 5  def func1():      print(a)  func1()  print(a)

现在，两个打印语句都可以访问该变量。 当函数内部和外部的变量使用相同的名称时，python将它们视为两个单独的变量。

a = 5  def func1():      a = 7      print(a)  func1()  print(a)

如果我们更改函数内部的值，则该更改不会影响函数外部的变量。 当在函数内部定义变量时，可以使用“ global ”关键字将该变量声明为global 。

def func1():      global a      a = 10      print(a)  func1()  print(a)

27.模组

模块是关于使用库文件的。您将创建一个具有常规功能和变量声明的python库文件。这些定义可以由另一个python文件引用。 在清单.py中定义了以下函数和值

fruits = ["mango", "apple", "grapes"]  def countStock():      return len(fruits)

为了使用此函数和数组，我们将不得不将此库导入到主代码文件中。

import inventory  print(inventory.countStock())  print(inventory.fruits)

第1行导入库存库。第3和第4行是在库中声明的函数和变量。 可以将库名称更改为合适的名称。在下面的代码中，我们将库名称更改为inv。此更改是我们代码的本地更改。

import inventory as inv  print(inv.countStock())  print(inv.fruits)

我们不必从库中导入所有元素。我们可能会选择导入。在从子句用于模块的进口部分。

from  inventory import  countStock  print(countStock())  print(fruits)

在上面的代码中，函数countStock返回预期结果。但是，水果是未定义的并且会引发错误。 python中有许多内置模块，可以在上述导入样式中使用。

28.日期

通过导入模块datetime，我们可以在python中使用日期。

import datetime  today = datetime.datetime.now()  print(today)

我们可以打印当前日期和时间戳。 我们还可以创建具有特定日期值的日期对象。datetime对象的构造函数接受年，月和日来创建日期。

import datetime  pastDate = datetime.datetime(2020, 2, 29)  print(pastDate)

在上述构造函数调用中，小时，分钟，秒，毫秒是可选的。默认值为零。 Datetime有一种格式化日期值的方法。datetime对象公开了strftime()方法，该方法格式化对象的日期值。Strftime()接受格式字符串作为输入，并返回格式化的输出。

import datetime  pastDate = datetime.datetime(2020, 2, 29)  print(pastDate.strftime("%B"))

％B返回完整月份的名称。 其他格式的详细信息如表中所述。

指示	描述	例
％一个	平日，短版	周五
％一个	平日，完整版	星期五
％w	工作日为数字0-6，0为星期日	2
％d	每月的一天01-31	22
％b	月名称，简称	三月
％B	月名称，完整版	游行
％m	月份为数字01-12	10
％y	年，短版，无世纪	19
％Y	年，完整版	2020年
％H	时间00-23	15
％一世	00-12小时	5
％p	上午下午	下午
％M	分钟00-59	37
％S	秒00-59	23
％F	微秒000000-999999	42875
％z	UTC偏移	50
％Z	时区	科技委
％j	年份的天数001-366	365
％U	年的周数，星期日作为星期的第一天，00-53	52
％W	年的周数，星期一作为一周的第一天，00-53	52
％C	日期和时间的本地版本	星期六2020年2月29日18:23:00
％X	日期的本地版本	20/29/20
％X	当地时间	13:57:00
%%	一个人物	％

29.JSON格式

JSON代表Javascript对象表示法。它是一种文本格式，可用于交换数据和存储信息。   Python有一个称为json的内置模块来处理json数据。 可以使用json.loads()方法将json字符串解析为json数据。json.loads方法将json数据返回一个字典。

import json  jsonStr = '{ "name" : "mango", "price" : 100, "color" : "yellow" }'  jsonData = json.loads(jsonStr)  print(jsonData["color"])  print(jsonData)

json.dumps()用于将python对象转换为json字符串。

import json  fruitsDictionary = { "name" : "mango", "price" : 100, "color" : "yellow" }  jsonStr = json.dumps(fruitsDictionary)  print(jsonStr)

我们可以缩进以提高生成的输出字符串的可读性。

import json  fruitsDictionary = { "name" : "mango", "price" : 100, "color" : "yellow" }  jsonStr = json.dumps(fruitsDictionary, indent=5)  print(jsonStr)

我们可以在dumps方法中对键的顺序进行排序。

import json  fruitsDictionary = { "name" : "mango", "price" : 100, "color" : "yellow" }  jsonStr = json.dumps(fruitsDictionary, indent=5, sort_keys=True)  print(jsonStr)

30.正则表达式

正则表达式是一种强大的搜索机制，其中我们有一个字符串模式，并在给定的完整字符串中查找匹配的子字符串。 导入re模块以使用regEx库功能。

import re  givenStr = "Hello world, good morning"  outRegex = re.search("^Hello", givenStr)  print(outRegex)

outRegex是由搜索方法生成的对象。搜索在字符串的开头查找字符串Hello。

31.画中画

在模块部分，我们看到了如何将模块导入我们的代码并使用这些库中的元素。 PIP是程序包管理器，可帮助安装所需的模块。 pip install 这是安装软件包的语法。这需要在命令提示符窗口中运行。 如果您的计算机中未安装pip，请从https://pypi.org/project/pip/下载 示例安装是： 点安装HTMLParser pip卸载 此命令将卸载已安装的软件包 点列表 将显示本机中安装的所有软件包。

32.尝试，除了

尝试块监视是否有块中引发任何错误。 除了块处理任何抛出的错误。 当我们不使用try andexcept时，python将抛出错误并暂停程序。通过使用try，除外，我们处理了代码中的错误并避免了代码终止。

try:      print(a)  except:      print("error occured, please check if a is defined")

这里a是未定义的。引发错误，由except块处理。 最后是一个在try和except之后执行的块。无论是否发生错误，都可以得到控制。我们可以在finally块中编写清理操作，例如关闭文件句柄。

try:      print(a)  except:      print("error occured, please check if a is defined")  finally:      print("We are here after try and except")

我们可以编写代码来引发自定义错误。抛出的错误可以通过我们的尝试进行处理，除非python引擎可以接收到该错误。

a = 0  if a == 0:      raise Exception("cannot divide by zero")

33.用户输入

大多数程序需要从用户那里获取输入并生成输出。在python中，input()方法用于接受用户的输入。

city = input("Where do you live? ")  print("city you live is : " + city)

34.字符串格式

字符串变量可以使用format()方法进行格式化。首先创建模板字符串，并在格式化阶段附加值。

tStr = "The fruit {} is {} color."  print(tStr.format("mango", "yellow"))  print(tStr.format("apple", "red"))

您可以使用索引引用这些值。索引从零开始。

tStr = "The fruit {0} is {1} color. {0} is good for health"  print(tStr.format("mango", "yellow"))  print(tStr.format("apple", "red"))

类似于索引引用，我们可以使用参数名称。

tStr = "The fruit {name} is {color} color. {name} is good for health"  print(tStr.format(name = "mango", color = "yellow"))  print(tStr.format(name = "apple", color = "red"))

35.Python数据类型

Python支持五种标准数据类型，其中可能还包含子类型。用于定义对其可能进行的操作的数据类型以及每种数据的存储方法。 这是五种数据类型

1. 号码
2. 串
3. 清单
4. 元组
5. 字典

让我们看一下所有这些数据结构，并通过示例了解如何使用它们：

号码

此数据类型存储数字值，Python在其中创建数字对象并将数字分配给变量。 例：

a = 4b = 6

这里，a和b是数字对象。 Python支持四种类型的数字数据。他们是-

• int(有符号整数)
• long(长整数，也可以用八进制和十六进制表示)
• 浮点数(浮点实数值)
• 复数(虚数以'j'表示的复数)

在长整数的情况下可以使用小写字母L，但是，应始终使用大写字母L以避免混淆。

串

用引号表示的字符序列称为字符串。单引号，双引号或三引号可用于在Python中定义字符串。如果需要进行字符串处理，则提供内置的运算符。这使其简单易用。 示例：“ hello” +“ python”将返回“ hello python” 运算符*称为重复运算符。“ Python” * 2操作将返回“ Python Python” 让我们看看另一个例子-

str1 ='hello javatpoint'＃字符串str1   str2 ='你怎么样'#string str2   打印(str1 [0：2])＃使用切片运算符打印前两个字符     打印(str1 [4])＃打印字符串的第4个字符   print(str1 * 2)＃打印两次字符串  打印(str1 + str2)＃打印 str1和str2的串联

输出：

他  Ø 你好，javatpoint你好，javatpoint你好javatpoint你好吗

清单

列表可以包含不同类型的数据，类似于C中的数组。列表中存储的项目用逗号分隔，应放在方括号[]中。 要访问列表中的数据，应使用切片[：]运算符。重复运算符(*)和串联运算符(+)在字符串和列表中的工作方式相同。 看下面的例子-

l = [1，“ hi”，“ python”，2] 打印(l [3：]) 打印(l [0：2])  打印(l) 打印(l + l)   打印(l * 3)

输出：

[2]  [1，“嗨”] [1，'hi'，'python'，2][1，'hi'，'python'，2，1，'hi'，'python'，2][1，'hi'，'python'，2，1，'hi'，'python'，2，1，'hi'，'python'，2]

元组

元组和列表之间有许多相似之处。元组包含不同数据类型的项目的集合，这些项目用逗号(，)分隔，并且需要用括号()括起来。 元组中项目的大小和值无法修改，因为它是只读数据结构。 让我们看一个例子-

t =(“ hi”，“ python”，2)   打印(t [1：])   打印(t [0：1])   打印(t)   打印(t + t)   打印(t * 3)    打印(type( t))  t [2] =“ hi”

输出：

('python'，2)(“嗨”，)('hi'，'python'，2)(“ hi”，“ python”，2，“ hi”，“ python”，2)('hi'，'python'，2，'hi'，'python'，2，'hi'，'python'，2)追溯(最近一次通话)：中的文件“ main.py”，第8行t [2] =“ hi”;TypeError：“元组”对象不支持项目分配

字典

字典就像一个关联数组，其中每个键都存储一个特定值。它是一组有序的键值对项目。密钥能够保存任何原始数据类型。值是一个任意的Python对象。字典中的每个项目都用逗号分隔，并放在大括号{}中 让我们看下面的例子：

d = {1：'Jimmy'，2：'Alex'，3：'john'，4：'mike'} print(“第一个名称为” + d [1]) print(“第二个名称为” + d [ 4])   打印(d)   打印(d.keys())   打印(d.values())

输出：

第一个名字是吉米第二名叫麦克{1：“吉米”，2：“亚历克斯”，3：“约翰”，4：“麦克”}[1、2、3、4]['Jimmy'，'Alex'，'john'，'mike']

36.流控制语句

条件语句(if-else语句)

这些命令可帮助您根据条件(例如“如果”发生特定条件)进行决策，则您必须执行一组操作，而“否则”则必须执行另一组操作。 让我们看看它是如何工作的： 首先，我们将定义一些变量并为其分配值。接下来，我们将对这些变量执行一些基本的'if''else'操作。

a = 10b = 20

如果(b> a)：    打印(b大于a)

输出量

b大于a

在上面的计算中，如果条件为true，则得到输出。现在，让我们用一个错误的语句尝试'if'函数。

如果(a> b)：    打印(“ a大于b”)

对于此语句，由于if条件为false，因此不会获得输出。 现在，让我们包含else语句。

如果(a> b)：    打印(“ a大于b”)其他：    打印(“ b大于a”)

输出：

b大于a

接下来，让我们探索多种条件的“ elif”功能：

a = 10b = 20c = 30

如果(a> b)和(a> c)：    打印(“ a是最大的”)省略号(b> a)和(b> c)：    打印(“ b是最大的”)其他：    打印(“ c是最大的”)

输出：

c是最大的

您还可以在不同的数据结构(例如元组，列表，字符串等)上实现if和else函数。让我们来看一个带有列表的示例。

l1 = [10,20,30,40,50]

如果l1 [0] == 10：    l1 [0] = 10011

输出：

[100,20,30,40,50]

循环(while和for语句)

循环语句用于多次重复执行任务。让我们看看它是如何工作的。 首先，我们将定义一个变量并为其分配一个值。接下来，我们将对其执行“ while”功能。

i = 1而(i <= 5)：    打印(i)    i = i + 1

输出：

1个2345

那么，这里发生了什么？由于i = 1(小于或等于5)，因此while循环成立，并打印出“ i”的值，即“ 1”。根据下一条命令，“ i”的值将更新为“ 2”。 同样，由于“ 2”小于或等于“ 5”，我们将再次进入while循环并打印“ i”的值，该值现在为“ 2”。一直进行到“ i”的值变为“ 5”。之后，当'i = 6'的值，即不小于或等于'5'时，while语句为假，因此计算从此处停止。  让我们再举一个例子，我们必须将“ 2”表打印成十个值。让我们看看如何使用while循环进行相同的操作。

i = 1n = 2而(i <= 10)：    打印(n，“ *”，i，“ =”，n * i)    i = i + 1

输出：

2 * 1 = 22 * 2 = 42 * 3 = 62 * 4 = 82 * 5 = 102 * 6 = 122 * 7 = 142 * 8 = 162 * 9 = 182 * 10 = 20

与条件语句一样，您也可以在不同的数据结构(例如元组，列表，字符串等)上实现while函数。让我们来看一个带有列表的示例。

li = [1,2,3,4,5]i = 0当i     l1 [1] = l1 [i] +100    i = i + 111

输出：

[101,102,103,104,105]

接下来，让我们看看在哪里以及如何使用for循环。For循环用于遍历一个序列，让我们进入代码以了解for循环的功能。

l1 = [“蓝色”，“绿色”，“红色”]对于我在l1    打印(i)

输出：

蓝色 绿色 红

现在，让我们看看如何创建嵌套的for循环，即for循环内的for循环。

颜色= [“绿色”，“黄色”，“粉红色”]项目= [“椅子”，“书”，“电话”]对于我的颜色：    对于项目中的j：        打印(i，j)

输出：

绿色椅子绿皮书绿色电话黄色椅子黄皮书黄色电话粉色椅子粉红色的书粉色手机

因此，这全部与流控制语句有关。您可以根据要使用的数据类型和要解决的问题的类型，以多种方式应用这些功能和循环。

37.文件处理

Python支持许多创建，读取，写入和删除文件的功能。这些操作在大多数应用程序中至关重要。 open()函数打开该函数以进行进一步处理。open()有两个参数，一个是我们要操作的文件名，另一个是模式。 模式处理我们要执行的操作。可以读取(r)或附加(a)或写入(w)或创建(x) 此外，我们可以指定文件是二进制(b)还是文本(t)文件。 创建一个文本文件，该文件的名称为fruits.txt。将此文件放置在与我们正在编写的python代码相同的目录中。 考虑这个例子。

f = open("fruits.txt")

在此假设默认模式。默认情况下，文本文件以读取模式打开。上面的语句可以写成：

f = open("fruits.txt", "rt")

打开返回一个文件对象。该文件对象用于读取或写入文件。

f = open("fruits.txt")  print(f.read())

文件对象的read方法将加载文本文件的内容，并以字符串形式返回。 无需阅读整行，我们可以一次阅读几行。readline()方法返回一行文本。我们可以多次调用readline，直到文件包含文本内容为止。

f = open("fruits.txt")  print(f.readline())  print(f.readline())

此代码显示前两行。 可以在for循环中读取所有行。

f = open("fruits.txt")  for line in f:      print(line)

文件使用结束后，最好关闭文件。这将释放与文件和文件打开命令关联的句柄和其他资源。

f = open("fruits.txt")  for line in f:      print(line)  f.close()

绕过适当的模式可以写入文件。append(a)模式会将新字符串添加到文件末尾。write(w)模式将删除文件的现有内容，并将新的字符串单独写入文件。

f = open("fruits.txt", "a")  f.write("guava is green")  f.close()  f = open("fruits.txt")  for line in f:      print(line)  f.close()

通过运行此代码，我们将新字符串添加到现有文件中并显示整个内容。 如果我们将模式“ a”替换为“ w”，则将删除整个文本文件(现有内容)，并且文件中仅新字符串可用。 模式x用于创建新文件。如果文件已经存在，x会抛出一个错误，指出文件已经存在。 f =打开(“ fruits.txt”，“ x”)   此外，如果文件x和w不存在，它将创建新文件。 os库用于删除文件夹并检查文件是否存在。

import os  os.remove("fruits.txt")

在这里，我们已删除文件。如果文件不存在，则会引发错误。 您可以使用os.path对象的exist()方法检查文件是否存在。

import os  filename = "fruits.txt"  if os.path.exists(filename):      os.remove()  else:      print(filename + " does not exist")

可以使用os模块的rmdir()方法删除文件夹。

import os  os.rmdir("unwantedFolder")

38.用Python创建函数 

函数是可重用的代码块。它用于执行一项相关的动作，并且当他们需要执行该动作时，通常可以将其直接调用该函数，而这通常是更大代码的一部分。只需调用函数并将所需的值输入变量，即可避免每次需要执行相同操作时都编写冗长的代码。 要在Python中创建函数，我们将使用'def'方法。定义时，任何输入参数或参数都必须放在带有函数名称的括号内。每个函数中的代码块均以冒号(:)开头并缩进。最后，return [expression]退出函数。看下面的例子。

 def add_10(x)：     回报(10 + x)

让我们看看调用此函数时得到的输出。

add_10(5)

输出：

15

让我们看一下使用if和else定义函数的另一个示例。

39.通过使用Python作为计算器来学习简单命令

要在Python中插入注释，请以井号字符(即＃)开头。注释可能会出现在行的开头。它也可能遵循代码或空格。下面借助一些示例来解释注释。

 ＃这是一条评论counter = 100＃这是一个遵循代码的注释                  ＃这是空格后的注释text =“＃这不是注释，因为井号位于引号内。”

让我们运行一些简单的命令。启动解释器并等待主要提示，即>>>。现在让我们看一些简单的命令及其结果。这是基本的数学运算，例如求和，求差，乘法和除法。

>>> 2 + 24>>> 50-5 * 430>>>(50-5 * 4)/ 65>>> 8/51.6

除法始终提供浮点值作为输出。如果要分别显示整数结果和余数，该命令将包含“ //”以在除法后显示整数值，而％将显示余数。

>>> 16/35.333333333333334>>> 16 // 35>>> 16％31个

在Python中，您可以使用**来计算功效。

>>> 5 ** 225>>> 3 ** 481

接下来，使用符号(=)将值分配给变量。

>>>高度= 20>>>宽度= 9 * 5

在交互模式下工作时，最后打印的值分配给变量(_)，即下划线。因此，可以通过调用变量_来调用最后的打印值。让我们看下面的示例，在该示例中，我们计算对产品价格征收的税款。

>>>税= 12.5 / 100>>>价格= 110.50>>>价格*税13.8125＃这是最后打印的值，因此分配给_>>>价格+ _124.3125＃现在这成为最后的打印值，因此分配给_>>> round(_，2)＃这是将值四舍五入到小数点后两位的命令124.31

【 配套学习视频 识别关注下方二维码 】 回复 “python视频” 即可领取！

— 关注python头条 每日干货资料喂饱你 —

创作不易 记得点各赞鼓励一下