第二章（1）：Python入门：语法基础、面向对象编程和常用库介绍

第二章（1）：Python入门：语法基础、面向对象编程和常用库介绍
1. Python 简介
- 1.1 Python 是什么？
- 1.2 Python 解释器及其应用场景
- - 1.2.1 学习和开发
  - 1.2.2 科学计算和数据分析
  - 1.2.3 Web 开发
  - 1.2.4 自动化
  - 1.2.5 网络编程
- 1.3 Python 主要优点
2. Python 基础语法和数据类型
- 2.1 变量、数据类型和表达式
- - 2.1.1 变量
  - 2.1.2 数据类型
  - 2.1.3 表达式
- 2.2 Python 基本控制结构：顺序结构、分支结构和循环结构
- - 2.2.1 顺序结构
  - 2.2.2 分支结构
  - 2.2.3 循环结构
  - - （1）While循环
    - （2）for循环
- 2.3 Python 函数和模块
- - 2.3.1 函数
  - - （1）函数定义
    - （2）函数调用
    - （3）函数参数
    - （4）匿名函数
    - （5）递归函数
  - 2.3.2 模块
  - - （1）模块导入
    - （2）模块创建
    - （3）python标准模块
  - 2.3.4 总结
3. Python 面向对象编程
- 3.1 类、对象和方法
- - 3.1.1 类
  - 3.1.2 对象
  - 3.1.3 方法
- 3.2 封装、继承和多态
- - 3.2.1 封装
  - 3.2.2 继承
  - - （1）继承的语法格式
    - （2）单继承与多层继承
    - （3）重写父类方法
    - （4）多继承
    - （6）调用父类同名方法
    - （7）私有和继承
  - 3.2.3 多态
4. Python 库
- 4.1 常见 Python 库的介绍
- - 4.1.1 Numpy
  - - （1）安装
    - （2）数组创建
    - （3）基本操作
    - （4）更多应用
  - 4.1.2 Matplotlib
  - - （1）安装
    - （2）初级绘制
    - （3）多个子图绘制
    - （4）自定义图形
    - （5）其他类型的图形
    - （6）高级图像设计
  - 4.1.3 Pandas
  - - （1）安装
    - （2）数据结构
    - （3）数据读取与写入
    - （4）数据的选择和操作
    - （5）绘图
5. 总结

1. Python 简介

Python由荷兰数学和计算机科学研究学会的吉多·范罗苏姆于1990年代初设计，作为一门叫做ABC语言的替代品。 Python提供了高效的高级数据结构，还能简单有效地面向对象编程。Python语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的编程语言，随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发。

1.1 Python 是什么？

自20世纪90年代初Python语言诞生至今，它已被逐渐广泛应用于系统管理任务的处理和Web编程。

1995年，Guido van Rossum在弗吉尼亚州的国家创新研究公司（CNRI）继续他在Python上的工作，并在那里发布了该软件的多个版本。

2000年五月，Guido van Rossum和Python核心开发团队转到BeOpen.com并组建了BeOpen PythonLabs团队。同年十月，BeOpen PythonLabs团队转到Digital Creations（现为Zope Corporation）。

2001年，Python软件基金会（PSF）成立，这是一个专为拥有Python相关知识产权而创建的非营利组织。Zope Corporation是PSF的赞助成员。 [1]

Python的创始人为荷兰人吉多·范罗苏姆（Guido van Rossum）。1989年圣诞节期间，在阿姆斯特丹，Guido为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，作为ABC语言的一种继承。之所以选中单词Python（意为大蟒蛇）作为该编程语言的名字，是因为英国20世纪70年代首播的电视喜剧《蒙提·派森的飞行马戏团》（Monty Python’s Flying Circus）。

ABC是由Guido参加设计的一种教学语言。就Guido本人看来，ABC这种语言非常优美和强大，是专门为非专业程序员设计的。但是ABC语言并没有成功，究其原因，Guido认为是其非开放造成的。Guido决心在Python中避免这一错误。同时，他还想实现在ABC中闪现过但未曾实现的东西。

就这样，Python在Guido手中诞生了。可以说，Python是从ABC发展起来，主要受到了Modula-3（另一种相当优美且强大的语言，为小型团体所设计的）的影响。并且结合了Unix shell和C的习惯。

由于Python语言的简洁性、易读性以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python来教授程序设计课程。例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用Python语言讲授。众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。2018年3月，该语言作者在邮件列表上宣布Python 2.7将于2020年1月1日终止支持。用户如果想要在这个日期之后继续得到与Python 2.7有关的支持，则需要付费给商业供应商。

1.2 Python 解释器及其应用场景

Python 解释器是一个用于执行 Python 代码的软件程序。它将 Python 代码转换为计算机可以理解并执行的计算机代码。Python 解释器的应用场景非常广泛，下面是一些典型的应用场景：

1.2.1 学习和开发

Python 是一种易于学习且具有高级编程功能的编程语言。由于它的语法简单易懂，因此它成为了很多人学习编程的首选语言。 Python 解释器是学习和开发 Python 编程语言的必备工具。Python 编程语言的易读性和简洁性使得它成为了非常适合新手学习编程的语言，同时也被广泛使用于大型公司和组织中。

1.2.2 科学计算和数据分析

Python 解释器加上一些常用的科学计算库（如 Numpy、SciPy 和 Pandas 等），可以实现强大的数学计算和数据分析功能。因此，在数据科学领域中，Python 解释器也被广泛应用。 Python 是一种强大的编程语言，它支持高效的数组处理技术，这使得 Python 成为一种非常流行的科学计算语言。

1.2.3 Web 开发

Python 解释器可以与各种 Web 开发框架（如 Django 和 Flask 等）配合使用，开发复杂的 Web 应用程序。这些框架提供了一套工具和库，使得开发者能够快速地构建 Web 应用程序。 Django 是一个功能强大的 Web 框架，它支持快速而轻松的 Web 开发。 Flask 是一个轻量级的 Web 框架，它非常适合小型应用程序的开发。

1.2.4 自动化

Python 解释器可以通过脚本编写实现一系列自动化任务，例如文件操作、批量重命名、发送电子邮件、自动化测试等。 Python 在自动化方面非常强大，它可以帮助开发人员节省时间和精力，从而更专注于他们的核心业务。

1.2.5 网络编程

Python 解释器可以轻松地进行网络编程，如通过 socket 模块编写客户端和服务端程序等。Python 提供了一些内置的模块（如 socket 和 urllib）来执行网络编程任务。它也有一些第三方模块，如 requests 模块，可以更方便地完成网络编程任务。

总之，Python 解释器可用于多个应用场景，并得到了广泛的应用。 Python 语言具有易读性、简洁性和高效性等优点，因此，Python 解释器适用于不同行业的人们，例如开发人员、数据科学家、研究人员等。作为一种开源的编程语言，Python 生态系统在不断发展壮大，其相关应用场景也将随之不断扩展，未来它将继续成为一个受欢迎的编程语言。

1.3 Python 主要优点

Python 作为一种开源的、高级的、解释性的、面向对象的编程语言，具有以下主要优点：

简单易学： Python 的语法非常简单，易于理解和上手。它的代码可读性强，代码风格简洁明了，使得其成为了很多新手学习编程的首选语言。
库丰富： Python 拥有大量的第三方库，这些库各具特色，可以完成多种任务，包括 Web 开发、数据科学、机器学习等等。这些库的存在，减少了很多编写代码的时间。
可移植性强：Python 编写的代码可以在许多操作系统平台上运行，如 Windows、Linux、Mac 等，这使得 Python 成为一种非常流行的跨平台语言。
大型社区： Python 有一个庞大的社区，很多人都使用 Python 并参与到 Python 开发和维护中。这个社区提供了丰富的资源和支持，包括教程、文档和各种工具和库等。
面向对象编程：Python 具有强大的面向对象编程能力，利用 Python 的类和对象，可以轻松地构建复杂的应用程序。
高效性：Python 代码通常比其他编程语言的代码更简单，这意味着 Python 编程可以节省时间和精力。同时，Python 也具有非常高的性能，它可以处理大量的数据并迅速地执行复杂的任务。

综上所述，Python 作为一种简单易学、具有丰富的库、可移植性强、社区庞大、面向对象编程和高效性的编程语言，拥有广泛的应用场景，并成为了很多人喜欢的编程语言之一。

2. Python 基础语法和数据类型

2.1 变量、数据类型和表达式

2.1.1 变量

在 Python 中，变量是一个可以存储数据值的标识符。Python 是一种动态类型语言，因此不需要预先声明变量的类型，变量的类型由其所引用的值决定。例如，下面的代码定义了一个名为 x 的变量，并将其赋值为 5：

x = 5

在上述代码中，我们使用等号（=）将值 5 赋给变量 x。在后续的代码中，我们可以使用变量 x 来引用该值。

2.1.2 数据类型

Python 提供了多种数据类型，包括数字、字符串、列表、元组、字典等。下面是一些常见的 Python 数据类型：

整型：整型（int）是表示整数的数据类型。例如，下面的代码定义了一个名为 x 的整型变量，并将其赋值为 5：

x = 5

浮点型：浮点型（float）是一种表示带有小数点的数字的数据类型。例如，下面的代码定义了一个名为 x 的浮点型变量，并将其赋值为 3.14：

x = 3.14

字符串：字符串（str）是表示文本的数据类型，在 Python 中可以用单引号或双引号来表示。例如，下面的代码定义了一个名为 x 的字符串变量，并将其赋值为 “hello world”：

x = "hello world"

列表：列表（list）是一种有序的可变序列，可以包含任意类型的元素。例如，下面的代码定义了一个名为 x 的列表变量，并将其赋值为 [1, 2, 3]：

x = [1, 2, 3]

元组：元组（tuple）是一种有序的不可变序列，也可以包含任意类型的元素。例如，下面的代码定义了一个名为 x 的元组变量，并将其赋值为 (1, 2, 3)：

x = (1, 2, 3)

字典：字典（dict）是一种无序的键值对集合，可以用来存储任意类型的值。例如，下面的代码定义了一个名为 x 的字典变量，并将其赋值为 {“name”: “jack”, “age”: 30}：

x = {"name": "jack", "age": 30}

2.1.3 表达式

表达式是 Python 中的一种计算方法，可以由变量、操作符和函数等组成。例如，下面的代码定义了一个名为 x 的变量，并将其赋值为两个数字相加的和：

x = 2 + 3

在上述代码中，表达式 2 + 3 计算得到的结果为 5，然后将其赋给了变量 x。

Python 支持各种操作符，包括算术操作符（+、-、*、/、%等）、比较操作符（>、<、==、!=等）、逻辑操作符（and、or、not等）、位操作符（~、&、|、^等）等。

除了基本操作符之外，Python 还提供了许多内置函数，例如 abs()、len()、sum() 等。这些函数可以用来对变量进行操作并计算出结果。

2.2 Python 基本控制结构：顺序结构、分支结构和循环结构

2.2.1 顺序结构

顺序结构是程序设计中最基础、最单一的控制结构之一，是所有程序的基础。在Python中，通过编写代码的书写顺序，即可实现程序的顺序结构。

举例说明，我们可以通过一个非常简单的例子来解释Python中的顺序结构。比如，我们想要实现一个Python程序，对两个数进行相加并输出结果。首先，我们需要利用Python定义两个变量x和y，用于存储我们要相加的数字。然后，将它们相加并将结果存储到一个新的变量z中，最后将z输出即可。代码如下所示：

x = 5
y = 3
z = x + y
print(z)

实验结果：

2.2.2 分支结构

分支结构是一种基本的控制结构，它会根据某种条件判断来决定程序的执行路径。在Python中，我们可以使用if-else语句来实现分支结构，通常的语法格式如下：

if condition:# 如果condition为True，则执行这里的语句块
else:# 如果condition为False，则执行这里的语句块

在实际应用中，我们可能还需要添加更多条件来进行判断，此时可以使用elif关键字，它表示在前面的所有条件都不满足时，进一步判断是否满足elif后给定的条件。通常的语法格式如下：

if condition1:# 如果condition1为True，则执行这里的语句块
elif condition2:# 如果condition1为False，而condition2为True，则执行这里的语句块
else:# 如果condition1和condition2都为False，则执行这里的语句块

tips：需要注意的是，在使用if-elif-else结构时，只有第一个满足条件的分支会被执行，其他分支则会被忽略。

2.2.3 循环结构

在Python编程中，循环结构用于重复执行一段程序，直到满足某个条件才停止。Python提供了两种循环语句：while和for。本文将主要介绍这两种循环语句及其使用方法，以及它们在实际开发中的应用。

（1）While循环

while循环会在给定条件成立的情况下重复执行语句块的内容。语法如下：

while 条件:重复执行的语句块

while循环通常用于需要反复进行某种操作的情况，直到满足某个条件为止。假设我们要猜年龄游戏，我们先定义一个年龄变量age为18，然后让用户输入猜测的年龄，如果用户猜测正确，打印“恭喜你猜对了”，并结束循环，否则提示用户重新输入。这个任务就适合使用while循环来完成，代码如下：

age = 18
count = 0
while True:  guess_age = int(input("请输入您猜测的年龄："))  if guess_age == age:  print("恭喜你猜对了！")  break  else:  count += 1  if count >= 3:  print("猜测次数已用完，正确答案是", age)  break  elif guess_age < age:  print("猜小了，请重新输入！")  else:  print("猜大了，请重新输入！")

实验结果：

恭喜你猜对了！

在上面的代码中，使用了一个无限循环while True，在循环体中每次让用户输入猜测的年龄，并使用if条件语句判断用户是否猜测正确。如果猜测正确，使用break退出循环；如果猜错了，则提示用户继续猜测，并统计猜测次数。如果猜测次数达到3次，则使用break退出循环并显示正确答案。同时，需要注意使用break及时结束循环，防止出现死循环的情况。

（2）for循环

for循环用于遍历序列、列表、字符串等数据类型中的每个元素，并对每个元素执行相同的操作。语法如下：

for 变量 in 序列/列表/字符串:重复执行的语句块

for循环通常用于遍历序列、列表、字符串等类型中的元素，对每个元素进行相同的操作。例如，我们可以编写一个程序输出一个列表中所有偶数的值：

arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for i in arr:  if i % 2 == 0:  print(i)

实验结果：

在上述代码中，使用for循环遍历了列表arr中的每个元素，并在每次循环中使用if条件语句判断元素是否为偶数，最终输出所有偶数的值。

tips：Python中的for语句实际上并不是传统意义上的“for循环”，而是一种“for each”语法。即每次循环都会自动取出序列中的下一个元素赋值给循环变量，并在执行完语句块后再去取下一个元素。

2.3 Python 函数和模块

首先我们需要说明为什么Python中引入函数的概念，函数其实就是一部分代码模块，将这部分写好的代码模块封装成一个函数，这个函数具有你所编写的特定功能，并且以后使用时还可以调用。而模块是一个包含 Python 定义和语句的文件，可以在其他文件中重复使用。

2.3.1 函数

（1）函数定义

在 Python 中函数的定义格式如下所示：

def function_name(parameters):"""函数功能描述"""# 函数主体return [expression]

其中，

def 关键字用于定义函数。
function_name 是函数的名称，我们需要遵循程序的命名规则。
parameters 是传递给函数的参数列表。它们可以是位置参数、关键字参数或默认参数。
return 语句用于从函数中返回某个值（可选）。

下面的函数 sum_two_numbers() 接受两个数字作为参数，并返回它们的和：

def sum_two_numbers(a, b):"""此函数返回两个a和b数字的和"""return a + b

（2）函数调用

在 Python 中调用函数，使用以下语法：

result = function_name(arguments)

其中，

function_name 是要调用的函数的名称。
arguments 是传递给函数的实际参数值。
result 是函数返回的结果。

sum_two_numbers() 函数的调用如下所示：

result = sum_two_numbers(3, 4)
print(result)  # 输出 7

实验结果

（3）函数参数

函数可以接受多个参数，并且这些参数可以是位置参数、关键字参数或默认参数。位置参数是指按照定义顺序传递给函数的参数。关键字参数是指传递给函数的参数名称和值成对出现。默认参数是指在函数定义中指定的参数默认值。

以下是一个描述一个人基本信息的函数，可以接受多个位置参数和一个默认参数的函数的示例：

def print_info(name, age=18, gender='男'):  """这个函数的描述了一个人的基本信息"""  print('姓名：', name)  print('年龄：', age)  print('性别：', gender)

可以通过以下方式调用定义的函数print_info()：

# 位置参数
print_info('安徒生', 33, '男')  # 关键字参数
print_info(age=33, name='安徒生', gender='男')  # 默认参数
print_info('安徒生')

实验结果：

姓名： 安徒生
年龄： 33
性别： 男
姓名： 安徒生
年龄： 33
性别： 男
姓名： 安徒生
年龄： 18
性别： 男

（4）匿名函数

在 Python 中，我们可以使用 lambda 来创建匿名函数，也就是没有名称的小函数。lambda 函数可以在需要函数的任何地方使用，通常用于定义简单的单行函数。

以下是两个使用 lambda 声明的函数的示例：

示例一：

addition = lambda a, b: a + b
result = addition(1, 2)
print(result)

实验结果

示例二：

f=lambda a,b,c,d:a*b*c*d
print(f(1,2,3,4))

实验结果：

（5）递归函数

在 Python 中，可以编写递归函数。递归函数是一种可以调用自身的函数，它通常用于解决问题的分治算法。

假设需要计算 100 的阶乘，可以使用以下递归函数：

def factorial(n):"""这个函数计算给定数字的阶乘"""if n == 1:return 1else:return n * factorial(n - 1)print(factorial(7))  #计算7的阶乘

实验结果：

2.3.2 模块

每个 Python 程序都是由一个或多个模块组成的。模块是一个包含 Python 定义和语句的文件，可以在其他文件中重复使用。使用模块可以提高代码的可维护性和复用性。

（1）模块导入

要在 Python 中使用模块，必须先导入它。可以使用 import 语句导入模块：

import module_name

我们也可以导入类，函数，指定变量等。如果要导入模块中的所有内容，可以使用以下语句：

from module_name import *

（2）模块创建

要创建自己的模块，在Python中只需编写包含Python定义和语句的文件。举个例子，假设我们要创建一个名为 calculator 的模块，它包含加、减、乘和除四个函数。

首先，我们需要创建一个名为 calculator.py 的文件，并在其中定义每个函数：

# calculator.py
def add(a, b):"""两个数字的加法"""return a + bdef subtract(a, b):"""两个数字的减法"""return a - bdef multiply(a, b):"""两个数字的乘法"""return a * bdef divide(a, b):"""两个数字的除法"""return a / b

然后，我们可以在其他文件中导入 calculator 模块并使用其中定义的函数：

from calculator import add, subtract, multiply, divide  result = add(1, 2)
print(result)  # 输出 3
result = subtract(5, 2)
print(result)  # 输出 3
result = multiply(2, 3)
print(result)  # 输出 6
result = divide(6, 2)
print(result)  # 输出 3.0

实验结果：

（3）python标准模块

Python标准库是一组已安装在Python解释器中的模块和包，可以在任何Python程序中使用。它包含了丰富的功能，如文件操作、网络服务、正则表达式和日期和时间处理等。

以下是几个常用的标准库模块：

os：提供了与操作系统交互的功能。
sys：提供了对解释器的访问和控制。
math：提供了数学函数。
datetime：提供了处理日期和时间的函数。

我们以os和datetime为例说明使用的方法。

a. 输入相对路径可以返回绝对路径

import os
os.path.abspath(‘.’)

实验结果:

'/home/lihuanyu/code/06NLP/NLP_Pre-training model'

b. 返回当前路径下的文件名

import os
os.path.basename('.')

实验结果：

'.'

c. 返回在此path下最后一次修改的时间

import os
os.path.getmtime(‘.’)

实验结果：

1681188867.706238

d. 获取当前日期和时间

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

实验结果

2023-04-11 13:04:25.860961

2.3.4 总结

Python 函数和模块是组织代码的重要工具。函数是用于执行特定任务的代码块，模块是用于组织相关代码的文件。使用函数和模块可以提高代码的可维护性和复用性。在 Python 中，有许多内置函数和标准库模块，也可以自己创建函数和模块来满足特定需求。

3. Python 面向对象编程

3.1 类、对象和方法

类、对象和方法是Python编程语言中非常重要的三个概念。类和对象是面向对象编程范式中的基本概念，方法则是面向对象编程的具体实现。

3.1.1 类

类用来抽象、描述待求解问题所涉及的事物，具体包括两个方面的抽象：数据抽象和行为抽象。数据抽是指描述某类对象共有的属性或状态；行为抽象是指描述某类对象共有的行为或功能特征。
例如，我们可以定义一个类来表示手机，其中包括手机的品牌、型号、颜色、电池容量和使用时间等信息：

class Phone:  def __init__(self, brand, model, color, volume,time):  self.brand = brand  self.model = model  self.color = color  self.volume= volume  self.time = time

在这个示例中，Phone类表示一种手机，它有五个属性：品牌、型号、颜色、电池容量和使用时间。这个类还定义了一个特殊的方法__init__，它是类的构造函数，用于初始化新创建的对象。这个方法有四个参数：brand、model、color、volume和time，分别对应手机的品牌、型号、颜色、电池容量和使用时间。在这个方法中，我们使用self关键字来引用正在创建的对象，并将属性的值设置为传递给构造函数的参数。

3.1.2 对象

在Python中，对象是类的实例化。对象是类的一个具体实例，它包含了类定义中定义的所有数据和操作。例如，我们可以使用Car类创建多个对象，分别表示不同的手机及使用情况：

phone1 = Phone("Mi", "K40", "Black", 4520, 100)
phone2 = Phone("Huawei", "P60", "White", 4500, 500)

这个语句创建了两个不同的手机对象，前者名为phone1的对象，该对象属于phone类，具有品牌为“Mi”、型号为“K40”的手机，颜色为“黑色”，电池为4520mAh，已经使用时间为100分钟，后者的表述与前者类似。

3.1.3 方法

在Python中，方法是类定义中包含的函数，它们用于执行特定的任务或操作。方法通常与对象关联，因此也称为实例方法。例如，我们可以定义一个time_statistics方法来统计手机的使用时长：

class Phone:  def __init__(self, brand, model, color, volume,time):  self.brand = brand  self.model = model  self.color = color  self.volume= volume  self.time = time  def time_statistics(self, use_time):  self.time += use_time

在这个示例中，我们向Phone类中添加了一个名为time_statistics的方法，它有一个参数use_time，表示手机又使用的时长。这个方法用于更新手机使用总时长。例如，我们可以使用time_statistics方法来统计在定义对象的基础上，手机使用的总时长：

phone1 = Phone("Mi", "K40", "Black", 4520, 100)
phone1.time_statistics(50)
print(phone1.time)

实验结果：

该代码表达的意思是，在使用了100分钟基础上再使用50分钟后，phone1手机的使用总时长。

3.2 封装、继承和多态

在Python面向对象编程中，封装、继承和多态是三个非常重要的概念。它们可以使代码更加易于维护、扩展和重用。

3.2.1 封装

封装是面向对象编程非常重要的概念之一。封装意味着将数据和方法组合在一起，并限制外部访问这些数据和方法的方式。封装的目的是隐藏类的实现细节，使得类的使用者无需关心类的内部实现细节，从而提高了代码的可维护性、健壮性。

在Python中，使用__双下划线来创建私有变量和方法。私有变量和方法只能在类的内部使用，外部无法访问。例如：

class Person:def __init__(self, name, age):self.__name = nameself.__age = agedef get_name(self):return self.__namedef get_age(self):return self.__agedef set_age(self, age):self.__age = age

我们传入两个值，读取其状态：

people = Person('lihuanyu',26)
print(people.get_age())
print(people.name)

实验结果：

其中__name和__age是私有变量。外部代码无法直接访问这些变量，必须通过公共方法来获取和修改它们的值。

tip：在Python中，私有变量和方法并不是真正的私有。可以通过_类名__变量名的方式间接访问私有变量，这个技巧称之为“name mangling” ，如下所示：

people = Person('lihuanyu',26)
print(people.get_age())
print(people._Person__age)

实验结果：

26
26

3.2.2 继承

继承是一种面向对象编程的重要概念，它可以使代码更加灵活、可重用。继承允许我们创建一个新的类，从而继承另一个已有的类的属性和方法。子类可以重写或修改父类的方法，从而实现不同的行为。

在程序中，继承描述的是指的是类与类之间的关系，如下如所示：

（1）继承的语法格式

语法格式如下：

class 子类名(父类名)：pass

示例：

class Father(object):  def __init__(self):  self.money = 9999999  def print_info(self):  print(self.money)  class Son(Father):  pass  s = Son()
print(s.money)  # 子类私用继承过来的属性
s.print_info()  # 子类使用继承过来的方法

实验结果：

9999999
9999999

子类对象调用方法有一个就近原则

如果本类能找到方法，直接调用本类的方法
如果本类找不到，则调用父类继承过来的方法

（2）单继承与多层继承

Python支持单继承和多层继承。单继承指一个类只能继承自一个父类，而多层继承则指一个类可以继承自多个父类，并且这些父类之间可能存在继承关系。

单继承

子类只继承一个父类

Animalclass Animal(object):  def eat(self):  print('吃东西')  class Dog(Animal):  pass  dog1 = Dog()
dog1.eat()

实验结果：

吃东西

多层继承

继承关系为多层传递

Animalclass Animal(object):  def eat(self):  print('吃东西')  class Dog(Animal):  def drink(self):  print('喝东西')  class SuperDog(Dog):  pass  sd = SuperDog()
sd.eat()
sd.drink()

实验结果：

吃东西
喝东西

（3）重写父类方法

子类重写父类同名方法

子类重写父类同名方法是面向对象编程中的常见操作之一，可以在子类中对父类的方法进行改进或扩展。具体来说，就是在子类中定义一个和父类同名的方法，重新定义该方法的实现代码，从而覆盖父类中原有的方法。

举例：

class Animal:  def __init__(self, name):  self.name = name  def make_sound(self):  print("Animal is making a sound.")  class Cat(Animal):  def __init__(self, name):  super().__init__(name)  def make_sound(self):  print("Meow!")  cat = Cat("Tom")
cat.make_sound()

实验结果：

Meow!

在上述代码中，Animal是父类，Cat是子类。Animal中有一个名为make_sound的方法，用于输出动物发出声音的信息。在Cat中也定义了一个同名方法，并重新定义了该方法的实现代码，以便让猫发出自己的特定声音。

当我们创建一个Cat对象并调用make_sound方法时，将会输出"Meow!“，而不是Animal类中定义的默认信息"Animal is making a sound.”。这是因为在Cat类中定义的make_sound方法覆盖了父类中的同名方法。

子类调用父类同名方法

在Python中，子类可以通过调用super()函数来调用父类的同名方法。以下是一个示例代码：

class Vehicle:  def __init__(self, name, color):  self.name = name  self.color = color  def start(self):  print(f"{self.name} starts.")  def stop(self):  print(f"{self.name} stops.")  class Car(Vehicle):  def __init__(self, name, color, num_wheels):  super().__init__(name, color)  self.num_wheels = num_wheels  def start(self):  super().start()  print(f"{self.name} has {self.num_wheels} wheels.")  car = Car("Toyota", "red", 4)
car.start() # 输出 "Toyota starts." 和 "Toyota has 4 wheels."car.stop() # 输出 "Toyota stops."

实验结果：

Toyota starts.
Toyota has 4 wheels.
Toyota stops.

在上述代码中，Vehicle是父类，Car是子类。Vehicle中有一个名为start的方法，用于输出车辆启动的信息。在Car中也定义了一个同名方法，并使用super()函数调用了父类的start方法以输出相应信息。

当我们创建一个Car对象并调用start方法时，将会输出"Toyota starts.“和"Toyota has 4 wheels.”，而不仅仅是Vehicle类中定义的默认信息"Vehicle starts."。这是因为在Car类中定义的start方法先调用了父类的start方法，再输出自己的信息，从而实现了对父类同名方法的调用。

（4）多继承

所谓多继承，即子类有多个父类，并且具有它们的特征

多继承的调用格式：

class 子类名(父类1, 父类2, ……)：pass

示例代码：

class SmallDog(object):  def eat(self):  print('吃小东西')  class BigDog(object):  def drink(self):  print('大口喝水')  class SuperDog(SmallDog, BigDog):  pass  sd = SuperDog()
sd.eat()
sd.drink()

实验结果：

吃小东西
大口喝水

（6）调用父类同名方法

默认调用情况

如果继承过来的2个父类的方法同名，默认调用先继承父类的同名方法

class SmallDog(object):  def eat(self):  print('吃小东西')  class BigDog(object):  def eat(self):  print('啃大骨头')  class SuperDog(SmallDog, BigDog):  pass  sd = SuperDog()
sd.eat()

实验结果：

吃小东西

（7）私有和继承

父类中的私有方法、属性不能直接继承使用。但可以通过调用继承的父类的共有方法，间接的访问父类的私有方法、属性。

下面通过一个示例来演示 Python 中的私有和继承。

class Animal:  def __init__(self, name):  self.__name = name  def get_name(self):  return self.__name  def __sleep(self):  print(f"{self.__name} is sleeping")  class Cat(Animal):  def play(self):  print(f"{self.get_name()} is playing")  cat = Cat("Tom")
print(cat.get_name()) # 输出 "Tom"  cat.__sleep()

实验结果：

在上述代码中，我们定义了一个 Animal 类，其中包含一个私有属性 __name 和一个私有方法 __sleep()，以及一个公开的方法 get_name()。接着，我们定义了一个 Cat 类，继承于 Animal 类，同时新增了一个公开的方法 play()。

在使用时，我们先创建了一个 Cat 类的对象 cat，并调用其公开的方法 get_name()，输出了猫咪的名字 “Tom”。随后，我们尝试调用对象的私有方法 __sleep()，程序抛出了异常：AttributeError: ‘Cat’ object has no attribute ‘__sleep’。

这是因为，Python 中的私有属性或方法需要以双下划线开头，这表示它们是被 “隐藏” 起来的，只能在类内部访问，而从外部是无法直接访问的。但是，如果你愿意，还是可以通过特定的方式访问到它们。比如可以在类内部进行调用，或者通过 _类名__属性名 的方式访问。

另外，我们使用继承让 Cat 类继承了 Animal 类的属性和方法。这样，在 Cat 类中，就可以直接使用 Animal 类中定义的公开方法 get_name() 来得到猫咪的名字，而无需重新实现。

3.2.3 多态

多种形态，调用同一个函数，不同表现。因为Python是动态语言，站在用户的角度，本身就是多态，不存在非多态的情况。

实现多态的步骤:

实现继承关系
子类重写父类方法
通过对象调用该方法

示例如下：

# 定义一个父类， Animalclass Animal(object):  def eat(self):  print('吃东西')  # 定义一个子类Dog，继承于Animal
class Dog(Animal):  def eat(self):  """重写父类方法"""  print('啃骨头')  # 定义一个子类Cat，继承于Animal
class Cat(Animal):  def eat(self):  """重写父类方法"""  print('吃小鱼')  # 定义一个函数，用于测试多态
def func(temp):  temp.eat()  # 创建子类对象
d = Dog()
c = Cat()  # 调用同一个函数，不同表现
# 传递d参数，调用Dog的eat()
# 传递c参数，调用Cat的eat()
func(d)  # 啃骨头
func(c)  # 吃小鱼

实验结果：

啃骨头
吃小鱼

4. Python 库

4.1 常见 Python 库的介绍

Python是一门功能强大的编程语言，可以进行各种数据处理、科学计算和机器学习等操作。在Python中，有许多常用的库可以帮助程序员高效地处理数据。本文将介绍三个最常用的库：Numpy、Pandas和Matplotlib。

4.1.1 Numpy

Numpy是Python中用于数值计算和科学计算的基础库，它提供了一个容易使用的高性能多维数组对象和用于操作这些数组的各种工具。它被广泛应用于各种领域，如数据分析、机器学习、科学计算、图像处理等。Numpy的核心是ndarray，即多维数组，使用Numpy创建的数组是相当快速和有效的，因为它们允许您以简洁的方式处理数据。本节简单介绍了Numpy的基本使用方法，包括数组的创建、索引和切片、形状操作、数学运算以及一些高级应用，如线性回归和随机函数生成Numpy是Python中非常有用的数学工具库，可以帮助开发者高效地进行各种数据处理和科学计算。

（1）安装

如果您未安装Numpy，可以使用以下命令在命令行中安装Numpy：

pip install numpy

（2）数组创建

在使用NumPy之前，需要先导入Numpy库：

import numpy as np

使用以下几种方式创建

从Python list创建

在创建ndarray时，可以传入一个Python list作为参数：

a = np.array([1, 2, 3])
print(a)

实验结果：

[1 2 3]

使用arange函数创建

arange()函数类似于Python内置函数range()，它返回一个ndarray对象，其中包含一个数值范围内的数值。例如：

b = np.arange(0, 10, 2)  # 从 0 开始，以步长 2 生成小于 10 的所有整数
print(b)

实验结果：

[0 2 4 6 8]

使用linspace函数创建

linspace()函数用于在指定的范围内均匀间隔地生成一定数量的样本。例如：

c = np.linspace(0, 1, 5)  # 在 0 到 1 之间生成 5 个等距样本点
print(c)

实验结果：

[0.   0.25 0.5  0.75 1.  ]

zeros函数创建

zeros()函数用于创建一个指定形状的全0数组。例如：

d = np.zeros((2, 3))  # 创建一个形状为（2，3）的二维数组，所有元素初始化为0
print(d)

实验结果：

[[0. 0. 0.][0. 0. 0.]]

ones函数创建

ones()函数用于创建一个指定形状的全1数组。例如：

e = np.ones((3, 2))  # 创建一个形状为（3，2）的二维数组，所有元素初始化为1
print(e)

实验结果：

[[1. 1.][1. 1.][1. 1.]]

（3）基本操作

Numpy数组提供了许多基本操作，如索引、切片、形状操作、数学运算等。

索引和切片

可以使用索引和切片来访问数组中的元素。例如：

a = np.array([1, 2, 3])
print(a[0])   # 输出第一个元素
print(a[0:2])  # 输出前两个元素

实验结果：

1
[1 2]

同样地也可以对多维数组进行操作。例如：

b = np.array([[1, 2, 3], [4, 5, 6]])
print(b[0, 1])   # 输出第一行第二列的元素
print(b[1, :])   # 输出第二行的所有元素

实验结果：

2
[4 5 6]

形状操作

可以使用以下方法来操作数组的形状：

shape属性：返回一个元组，表示数组的形状。
reshape()函数：用于改变数组的形状。
resize()函数：用于改变数组的形状，并在必要时插入或删除元素。

例如：

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.shape)   # 输出数组的形状  b = a.reshape((3, 2))
print(b)   # 输出重塑后的数组  a.resize((3, 2))
print(a)   # 输出重新调整形状后的数组

实验结果：

(2, 3)
[[1 2][3 4][5 6]]
[[1 2][3 4][5 6]]

数学运算

Numpy数组支持各种数学运算，如加、减、乘、除、求幂等。如果两个数组的形状不一致，NumPy会尝试将它们广播（broadcast）到相同的形状，使得它们能够进行逐元素运算。

例如：

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])  print(a + b)   # 输出数组的元素求和
print(a * b)   # 输出数组的逐元素乘积

实验结果：

[[ 6  8][10 12]]
[[ 5 12][21 32]]

（4）更多应用

除了上述基本操作外，Numpy还提供了许多高级功能，如线性代数、傅里叶变换、随机数生成等。

Numpy进行线性回归

可以使用NumPy中的函数polyfit()来进行线性回归。

例如：

x = np.array([0, 1, 2, 3, 4])
y = np.array([1, 3, 5, 7, 9])  m, b = np.polyfit(x, y, 1)   # 进行线性回归，返回斜率和截距  print("斜率：", m)
print("截距：", b)

实验结果：

斜率： 1.9999999999999998
截距： 0.9999999999999998

随机数的生成

Numpy提供了许多随机数生成函数，可以用于模拟随机实验或生成随机数据。以下是一些常用的函数：

np.random.seed(seed)：指定随机种子。
np.random.rand(shape)：生成给定形状的均匀分布随机数数组。
np.random.randn(shape)：生成给定形状的标准正态分布随机数数组。
np.random.randint(low, high=None, size=None, dtype='l')：在给定范围内生成整数随机数。
np.random.random_sample(size=None)：生成给定大小的[0.0，1.0)之间的随机数数组。
np.random.choice(a, size=None, replace=True, p=None)：从给定序列中随机选择元素。

以下是一个简单的例子，展示如何使用np.random来生成均匀分布、正态分布和整数随机数数组：

import numpy as np  # 生成10个[0,1)之间的随机数
a = np.random.rand(10)
print("均匀分布随机数数组：", a)  # 生成5个标准正态分布随机数
b = np.random.randn(5)
print("标准正态分布随机数数组：", b)  # 在[0,10)之间生成5个整数随机数
c = np.random.randint(0, 10, size=5)
print("整数随机数数组：", c)

实验结果：

均匀分布随机数数组： [0.65518091 0.9387529  0.21900196 0.35529013 0.00351118 0.730294570.70398811 0.33075301 0.29883347 0.80463579]
标准正态分布随机数数组： [-1.74731483 -0.7176287   0.77848856  0.47767463  0.88092069]
整数随机数数组： [5 1 2 8 0]

4.1.2 Matplotlib

Matplotlib 可能是 Python 2D-绘图领域使用最广泛的套件。它能让使用者很轻松地制作各种类型的图表，如线图、散点图、条形图等，并且提供多样化的输出格式。本文介绍了Matplotlib的使用方法，包括绘制基础图形、绘制多个子图、自定义图形以及绘制其他类型的图形等。

（1）安装

如果您未安装Matplotlib，可以使用以下命令在命令行中安装Matplotlib：

pip install matplotlib

（2）初级绘制

以下是一个简单的绘制折线图的示例：

import matplotlib.pyplot as plt  x = [1, 2, 3, 4]
y = [10, 2, 7, 8]
plt.plot(x, y)
plt.show()

实验结果

可以看到，我们只需要调用plot()函数来绘制图形，然后使用show()函数来显示图形。

（3）多个子图绘制

Matplotlib支持绘制多个子图，可以使用subplot()函数来实现。以下是一个绘制多个子图的示例：

import matplotlib.pyplot as plt  x = [1, 2, 3, 4]
y1 = [10, 5, 7, 8]
y2 = [7, 9, 6, 11]  plt.subplot(2, 1, 1)
plt.plot(x, y1)  plt.subplot(2, 1, 2)
plt.plot(x, y2)  plt.show()

实验结果：

（4）自定义图形

Matplotlib提供了各种功能，可以自定义图形的外观、轴标签、图例等元素。以下是一些常用的示例：

import matplotlib.pyplot as plt  x = [1, 2, 3, 4]
y1 = [10, 5, 7, 8]
y2 = [7, 9, 6, 11]  plt.plot(x, y1, label='Line 1', linestyle='--', color='red')
plt.plot(x, y2, label='Line 2', marker='o', color='green')  plt.xlabel('X axis label')
plt.ylabel('Y axis label')
plt.title('Title of the plot')  plt.legend()
plt.show()

实验结果：

（5）其他类型的图形

除了折线图之外，Matplotlib还支持绘制多种类型的图形，如柱状图、散点图、饼图等。以下是一些常用的示例：

柱状图

import matplotlib.pyplot as plt  # 绘制柱状图
x = ['A', 'B', 'C', 'D']
y = [10, 5, 7, 8]
plt.bar(x, y)plt.show()

实验结果：

散点图

import matplotlib.pyplot as plt  # 绘制散点图
x = [1, 2, 3, 4]
y = [10, 5, 7, 8]
plt.scatter(x, y)plt.show()

实验结果：

饼状图

import matplotlib.pyplot as plt  # 绘制饼图
sizes = [15, 30, 45, 10]
labels = ['A', 'B', 'C', 'D']
plt.pie(sizes, labels=labels)  plt.show()

实验结果：

（6）高级图像设计

使用Matplotlib中的scatter()函数和plot()函数，绘制了一个随机创建的点集，并将点集分为两个区域。其中，点的大小由area数组控制，颜色由c数组控制。还绘制了一个以原点为圆心、半径为r0的圆。

import matplotlib.pyplot as plt
import numpy as np  np.random.seed(19680801)  N = 100
r0 = 0.6
x = 0.9 * np.random.rand(N)
y = 0.9 * np.random.rand(N)
area = (20 * np.random.rand(N))**2
c = np.sqrt(area)
r = np.sqrt(x ** 2 + y ** 2)
area1 = np.ma.masked_where(r < r0, area)
area2 = np.ma.masked_where(r >= r0, area)
plt.scatter(x, y, s=area1, marker='^', c=c)
plt.scatter(x, y, s=area2, marker='o', c=c)
theta = np.arange(0, np.pi / 2, 0.01)
plt.plot(r0 * np.cos(theta), r0 * np.sin(theta))  plt.show()

实验结果：

具体地：

np.random.seed(19680801)用于设置随机数的种子，以便能够复现相同的结果。
使用np.random.rand(N)创建随机数数组，用于控制点的位置，其中N为点的个数。
通过使用平方运算和根号运算，计算出每个点对应的半径大小。
area数组控制了每个点对应的大小，np.ma.masked_where()函数用于在数组中过滤掉一些元素。
marker参数指定了点的形状，'^'表示三角形，'o'表示圆形。
c数组用于指定每个点的颜色，np.sqrt()函数用于对area数组进行平方根运算，使得点的颜色更加分散。
使用plot()函数绘制一个以原点为圆心、半径为r0的圆。
最后，使用show()函数显示图形。

4.1.3 Pandas

Pandas是Python中使用最广泛的开源数据分析库之一，可以快速、轻松地处理各种类型的数据，如数值、时间序列和表格数据。本节介绍Pandas的一些基础概念、常用函数和应用实例。

（1）安装

如果您未安装pandas，可以使用以下命令在命令行中安装pandas：

pip install pandas

（2）数据结构

pandas中有两个主要的数据结构,分别是:Series和DataFrame。

Series

Series是一个类似一维数组的对象，它能够保存任何类型的数据，主要由一组数据（各种Numpy数据类型）和与之相关的数据标签（索引）两部分构成。仅由一组数据也可以产生简单的Series对象。注意：Series的索引位于左边，数据位于右边，且索引值可以重复。可以通过以下方式创建一个Series：

import pandas as pds = pd.Series([1, 3, 5, np.nan, 6, 8])
print(s)

实验结果：

0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

其中，索引默认为0到N-1，也可以自己指定索引。

DataFrame

DataFrame是一个类似于二维数组或表格（如excel）的对象，包含一组有序的列，它每列的数据可以是不同的数据类型（数值、字符串、布尔型等）。注意：DataFrame的索引不仅有行索引，还有列索引，数据可以有多列，因此可以看做是由Series组成的字典。可以通过以下方式创建一个DataFrame：

import pandas as pd  data = {'name': ['Alice', 'Bob', 'Charlie', 'David'],  'age': [25, 32, 18, 47],  'gender': ['F', 'M', 'M', 'M']}
df = pd.DataFrame(data)
print(df)

实验结果：

     name  age gender
0    Alice   25      F
1      Bob   32      M
2  Charlie   18      M
3    David   47      M

其中，每列的名称对应字典中的键，行索引默认为0到N-1，也可以自己指定行索引。

（3）数据读取与写入

Pandas支持多种数据格式的读取和写入，包括CSV、Excel、SQL、JSON等。以下是一些示例：

读取CSV文件

import pandas as pd  df = pd.read_csv('read_data.csv')
print(df)

实验结果：

    1   2   3   4   5
0   6   7   8   9  10
1  11  12  13  14  15
2  20  21  22  23  24

写入CSV文件：

import pandas as pd  df.to_csv('data.csv', index=False)

实验结果：

读取Excel文件

import pandas as pddf = pd.read_excel('read_data.xlsx')
print(df)

实验结果：

    1   2   3   4   5
0   6   7   8   9  10
1  11  12  13  14  15
2  20  21  22  23  24

写入Excel文件

import pandas as pd  df.to_excel('data.xlsx', index=False)

实验结果：

（4）数据的选择和操作

Pandas提供了各种功能，可以对数据进行选择、过滤、排序以及计算等操作。

数据选择
Pandas提供了多种方式来选择数据：

使用[]运算符或.loc[]和.iloc[]属性来选择行或列；
使用bool值或条件表达式来选择满足特定条件的数据。

以下是一些常用的示例：

import pandas as pd  df = pd.DataFrame({'name': ['Alice', 'Bob', 'Charlie', 'David'],  'age': [25, 32, 18, 47],  'gender': ['F', 'M', 'M', 'M']})  # 选择单列
print(df['name'])
print(df.loc[:, 'name'])  # 选择多列
print(df[['name', 'age']])
print(df.loc[:, ['name', 'age']])  # 选择单行
print(df.loc[0])  # 选择多行
print(df.loc[0:2])  # 按条件选择数据
print(df[df.age > 30])

实验结果：

0      Alice
1        Bob
2    Charlie
3      David
Name: name, dtype: object
0      Alice
1        Bob
2    Charlie
3      David
Name: name, dtype: objectname  age
0    Alice   25
1      Bob   32
2  Charlie   18
3    David   47name  age
0    Alice   25
1      Bob   32
2  Charlie   18
3    David   47
name      Alice
age          25
gender        F
Name: 0, dtype: objectname  age gender
0    Alice   25      F
1      Bob   32      M
2  Charlie   18      Mname  age gender
1    Bob   32      M
3  David   47      M

数据计算

Pandas提供了各种功能，可以对数据进行数学计算、统计分析以及聚合操作等。

以下是一些常用的示例：

import pandas as pd
import numpy as np  df = pd.DataFrame({'name': ['Alice', 'Bob', 'Charlie', 'David'],  'age': [25, 32, 18, 47]})  # 计算平均值、中位数、最小值和最大值
print(df.mean())
print(df.median())
print(df.min())
print(df.max())  # 计算标准差和方差
print(df.std())
print(df.var())

实验结果：

age    30.5
dtype: float64
age    28.5
dtype: float64
name    Alice
age        18
dtype: object
name    David
age        47
dtype: object
age    12.396236
dtype: float64
age    153.666667
dtype: float64

（5）绘图

Pandas集成了Matplotlib库，可以轻松地进行数据可视化操作。以下是一个简单的示例：

import pandas as pd
import matplotlib.pyplot as plt  df = pd.DataFrame({'name': ['Alice', 'Bob', 'Charlie', 'David'],  'score': [70, 80, 65, 90]})  plt.bar(df['name'], df['score'])
plt.show()

实验结果：

5. 总结

Python是一种高级编程语言，广泛应用于多个领域。Python编程语言的简介和解释器应用场景是本文的开头，接下来详细讲解了Python的基本语法、数据类型和控制结构，以及函数和模块的概念和使用方法。此外，本文还介绍了Python面向对象编程中的类、对象、方法、封装、继承和多态等内容。最后，介绍了常见的Python库：Numpy、Matplotlib和Pandas，从安装、基本操作到高级应用，为读者提供了全面、深入的学习指导。

在第一章中，我们了解到Python是一种高级编程语言，拥有多种应用场景。Python在学习和开发、科学计算和数据分析、Web开发、自动化和网络编程等领域都得到了广泛应用。同时，Python也被广泛应用于机器学习和人工智能等热门领域。

在第二章中，我们学习了Python的基本语法和数据类型。Variable变量类型和表达式是Python基础的一部分。Python基础的控制结构包括顺序结构、分支结构和循环结构，其中while和for循环分别被详细介绍。

在第三章中，我们学习了Python的函数和模块。函数和模块是Python代码复用的关键部分，函数可以被重复使用，模块可以将一些公共的变量、函数等整合在一起，并且可以方便的导入到其他代码中使用。

在第四章中，我们学习了Python面向对象编程的基础知识。Class类是Python面向对象编程的核心，对象和方法是Class类的实例。封装、继承和多态是Python面向对象编程的三大特征。

在第五章中，我们介绍了常见的Python库：Numpy、Matplotlib和Pandas。这些库不仅仅提供了高效的数据结构和算法，同时还包括了可视化、数据处理和分析等多种功能，为Python编程带来了便捷和高效性。

总之，本文从Python的基础知识、语法和数据类型开始，逐步深入地介绍了Python的进阶知识。读者可以通过本文全面的介绍学习到Python编程的基本思想和技能，更好地掌握Python编程的核心内容。

参考教程：
Python（计算机编程语言）_百度百科 (baidu.com)
Pandas数据结构分析_pandas的数据结构_叮咚吾响应的博客-CSDN博客
Python基础课程-函数_python函数_慕斯先生的博客-CSDN博客
Scatter Masked — Matplotlib 3.7.1 documentation
Matplotlib documentation — Matplotlib 3.7.1 documentation
numpy_百度百科 (baidu.com)
pandas_百度百科 (baidu.com)
面向对象：Python中的继承和多态，一文彻底搞懂！ - 知乎 (zhihu.com)

想要了解更多的技术干货及学习教程，欢迎关注微信公众号“安静到无声成长之路”或扫描二维码添加关注。