1.导言
编程是一种人与计算机进行交流的方式，让计算机按照一系列指令来执行任务。通过编程，我们可以创造各种各样的应用程序、网站、游戏和工具，为解决现实生活中的问题提供智能化的解决方案。
计算机程序是由一系列的指令组成，这些指令按照特定的顺序被计算机执行。编程语言是用来编写这些指令的工具，它们提供了一组规则和语法，让程序员能够以人类可读的形式来描述计算机的操作。
编程的核心思想是问题解决。通过编程，我们可以将复杂的问题分解为简单的步骤，并用计算机来自动执行这些步骤，从而得到问题的解决方案。因此，编程能够提高我们的效率，让我们能够更快速地完成重复性任务，或者处理大量的数据。
举个例子，想象一下你的老板给了你一个任务：从一个包含大量数据的Excel文件中提取特定信息并进行统计（求最大值、最小值、均值等等）。
其实你找最大值、最小值的过程就是一个程序，只不过这个操作Excel给你封装好了，所以你每次鼠标点一点就能求出来各种值。以求均值为例，Excel中封装好的均值功能一定是满足 y=\frac{(x_1+x_2,…,x_n)}{n} 这个函数关系，你只需要拉取想要求均值的一行或者一列元素，再点击一下就可以实现了。其他的操作也是如此，Excel建立了一个函数关系给用户，用户想要的相应的功能就可以实现。
但是，如果这种表格有1000个，你是不是需要点特别多次，这里假装你没有其他骚操作可以批量处理。
为了解决上述问题，是不是可以建立这些操作的数学意义上的函数关系呢？即建立输入数据（Excel）和输出数据的函数关系（例如 y=ax+b 、 f(x)=wx+b 等），也就是建立计算最大值、最小值、均值等的函数。只需将数据输入到各个函数中，不就可以计算出我们想要的数据了吗？这个操作你用Excel的内置公式可以是实现，只不过你要点很多次。我们学习编程的过程实际上就是将这个函数映射到计算机上，然计算机去处理，和Excel处理的过程一样，只不过Excel的计算最大值、最小值、均值等的函数关系已经被官方写好了。
对于上面的问题，可以写一个程序依次将每一个Excel文件扔给程序中的各个函数去处理（依次处理Excel文件的过程也可以用程序实现，不需要手动点n次），然后将得出的结果进行处理。
得出结论：写程序就是把函数通过计算机去实现，只要能写出 f(x)=ax+b 的函数关系，输入变量x就可以得出对应的结果。
那么，考虑一下自己从事的行业，化学？物理？生物？地理？或者文科类的？等专业，是否在某些场景下可以建立函数关系呢？如果有，那么强烈建议你去学习。因为当今社会是数据驱动的（在计算机眼里只要能够输入进去处理的都是数据，如化学反应的过程、生物中分子的作用过程等），有了数据就有了资源。当你是一个非计算机科班的学生，但是在求职的过程中，简历中有相关的编程经验（很多新兴的交叉学科工作基本上都是用编程，如计算化学、计算生物等等），将会锦上添花。最最重要的是老板喜欢这样的人才，当你把把一些交叉学科的任务进行代码化了，老板一看有点东西，牛皮，拿着PPT带着你就出去吹牛了。所以，学会编程语言一定会是你升职加薪迎娶白富美（高富帅）的重要一环（本身就是白富美、高富帅的除外，如有此类人群，请自觉退出，这里不是你们该来的地方，好好的回家继承家产）。
对于零基础来说，难肯定是难的，我也是非科班自学的，当时学的时候，还没有视频教程，只能各种百度看书本，现在也在从事程序相关的工作，所以，不要慌，干就完了。
以我个人自学多年的经验来说，不需要买任何资料（我当时买了巨多，现在来看，没啥大的作用）、不需要看太多视频，要多打开电脑编写程序。利用好百度，做好笔记（避免重复百度）。
编程语言重要的是函数关系的映射、是解决问题的逻辑，不是你看多少课程和书本，很多书本和课程的内容，都是你用不到的，学了浪费时间。
程序是一个哪里不会百度哪里的学习过程，不是一下全都学会，要多交流、勤记笔记。
2.使用Python编程的前置知识
2.1.什么是Python？
Python是一种高级编程语言，具有简单易读的语法和强大的功能。以下是Python的一些关键特点：
- 易学易用：Python被广泛认为是一种容易学习和使用的编程语言。它的语法清晰、简单，类似于人类语言，使初学者能够快速入门。
- 多用途：Python可用于多种应用，包括Web开发、数据分析、人工智能、科学计算、自动化脚本、游戏开发等。它是一种通用编程语言，适用于各种领域。
- 开源：Python是开源的，这意味着它的源代码可公开查看和修改。这使得Python社区可以不断改进和扩展语言的功能。
- 跨平台：Python可以在不同的操作系统上运行，包括Windows、macOS和各种Linux发行版，因此具有良好的跨平台性。
- 丰富的库和框架：Python拥有丰富的标准库，以及许多第三方库和框架，可以加速开发过程。例如，NumPy和Pandas用于数据分析，Django和Flask用于Web开发，TensorFlow和PyTorch用于机器学习等。
- 动态类型：Python是一种动态类型语言，不需要显式声明变量的类型，可以根据变量的值自动确定类型。
- 面向对象：Python是一种面向对象的语言，支持面向对象编程（OOP）范例，使得代码可以更容易地组织和重用。
- 社区支持：Python拥有庞大的全球社区，提供了大量的文档、教程和支持，这对学习和解决问题非常有帮助。
2.2.什么是高级编程语言？
高级编程语言是为了让人类程序员更容易理解和编写代码而设计的。这些语言提供了更高层次的抽象，使程序员能够更专注于解决问题而不必深入研究计算机底层的硬件细节。高级编程语言通常使用人类可读的语法，与自然语言更接近，使得编写代码变得相对容易。
与之相反，低级编程语言（例如汇编语言和机器语言）更接近计算机的硬件层面。在这些语言中，程序员需要直接控制计算机的内存、寄存器和指令，这需要深入了解计算机的底层结构。低级编程语言在某些情况下非常有用，例如嵌入式系统或需要极高性能和精确控制的应用程序。
高级编程语言通常需要一个"中介"，即编译器或解释器，将人类可读的代码翻译成计算机能够理解的0和1，或者反过来将计算机生成的结果翻译回人类可读的形式。这种中介使得高级编程语言成为了实际应用开发的首选，因为它们提供了更大的可读性、开发效率和跨平台性。
因此，高级编程语言和低级编程语言之间的主要区别在于抽象级别和人类可读性。高级编程语言旨在提供更大的抽象，以便更容易理解和编写代码，而低级编程语言更接近计算机硬件，需要更多的细节了解和精确控制。
以下是高级编程语言的一些特点和优势：
- 人类友好：高级编程语言的语法和结构通常与自然语言更接近，使得编写代码更容易理解和学习。这使得程序员可以更快地开发应用程序，并降低了编程中的错误几率。
- 抽象程度高：高级编程语言提供了高度的抽象，允许程序员通过更高级别的概念来表达想法，而不需要关心底层的计算机硬件细节。
- 跨平台性：许多高级编程语言具有跨平台性，这意味着您可以编写一次代码，并在多个不同操作系统和计算机体系结构上运行。
- 丰富的库和框架：高级编程语言通常有庞大的标准库和第三方库和框架，可以加速开发过程。
- 可维护性：高级编程语言的代码通常更易于维护，因为它们更容易阅读和理解。
- 广泛应用：高级编程语言可以用于各种应用领域，包括Web开发、移动应用开发、数据分析、人工智能、游戏开发等。
2.3.什么是解释器和编译器？
解释器（Interpreter）和编译器（Compiler）都是用于执行计算机程序的工具，但它们在程序执行方式和原理上有重要区别。
2.3.1.解释器 (Interpreter)
执行过程：解释器逐行读取源代码，并将每行代码翻译成计算机能够理解的中间代码或直接执行，一边翻译一边执行。这意味着解释器会逐行解释源代码，并即时执行，不生成独立的可执行文件。
速度：由于解释器在运行时逐行解释代码，因此通常比编译器慢。每次运行程序时，都需要重新解释一次源代码。
调试：解释器通常提供更好的交互式调试支持。您可以在程序执行时逐行查看变量的值和程序状态，以更容易地找到问题。
示例语言：Python、JavaScript和Ruby等脚本语言通常使用解释器。
2.3.2.编译器 (Compiler)
执行过程：编译器在运行程序之前将整个源代码文件编译成机器代码或中间代码。编译过程生成一个可执行文件，该文件可以独立运行，而无需源代码。
速度：由于编译器在运行之前完成了翻译和优化过程，因此通常比解释器执行得更快。编译后的程序运行时无需再次翻译源代码。
调试：在编译过程中进行了大部分错误检查和优化，这意味着在运行时很难进行逐行调试，通常需要使用特殊的调试工具。
示例语言：C、C++、Java等语言通常使用编译器。
3.Pycharm是什么？
3.1.工欲善其事必先利其器
使用Python编写程序通常涉及到两个主要工具：代码编辑器（例如Pycharm）和Python环境管理工具（例如Anaconda）。下面将具体介绍这两个工具是什么？
Pycharm是一款由JetBrains开发的集成开发环境（IDE），专门用于Python编程。它提供了一套强大的工具和功能，旨在帮助Python开发人员更高效地编写、调试和管理Python代码。以下是为什么要使用Pycharm的一些理由：
智能代码编辑：Pycharm提供了智能代码编辑功能，包括自动补全、语法高亮、代码检查和自动修复等。这有助于减少编码错误，提高代码的质量和可读性。
社区版和专业版：Pycharm有两个版本，社区版（免费）和专业版（付费）。社区版适用于一般的Python开发，而专业版则提供了更多高级功能，其中最重要的是链接服务器中的解释器。
强大的调试器：Pycharm内置了强大的调试器，可以帮助您轻松地调试Python代码。可以设置断点、逐行执行代码、查看变量的值，以及监视程序的状态。
集成版本控制：Pycharm集成了版本控制系统，如Git，使得团队协作和代码管理变得更加容易。可以在IDE中执行版本控制操作，轻松提交、拉取和合并代码。
丰富的插件生态系统：Pycharm支持丰富的插件，可以扩展其功能。可以根据需要安装插件，以满足特定项目或工作流程的要求。
个人认为，开发Python程序，使用一个Pycharm就完全够了，最多再下载一个VSCode。
4.Anaconda是什么？
Anaconda是一个用于数据科学和机器学习的开源工具套件，它包含了许多常用的Python库和工具，以及一个强大的环境管理系统。Anaconda的主要目标是简化Python开发和数据科学工作流程，使其更容易管理依赖关系、构建环境和部署项目。以下是Anaconda的一些关键特点和用途：
虚拟环境管理：Anaconda允许用户创建和管理多个Python环境，每个环境可以具有不同的Python版本和依赖项。这有助于隔离不同项目或工作流程的依赖关系，以避免冲突（这才是重点，相当于是一个管理各个版本Python的仓库或者说文件管理器）。
包管理：Anaconda提供了一个称为conda的包管理器，用于安装、更新和删除Python包。它可以轻松地处理数千个Python库和工具，包括用于数据分析、机器学习、科学计算和可视化的库。
Anaconda是一个强大的工具套件，开发Python程序必备，需要使用它管理不同的Python环境（不同的项目可能需要不同的Python版本，有的项目可能需要3.8版本，有的需要3.10）。通过使用Anaconda可以提供一站式解决方案，管理多个Python版本。
5.怎么安装Pycharm和Anaconda
这里的重点是讨论Anaconda和PyCharm在Python开发中的重要性，而不是具体的安装和配置过程。这是因为篇幅有限，而且安装和配置过程可能相对繁琐，不适合在此展开详细说明。
详细的安装和配置图文指南（可关注微信公众“自然语言处理CS”，回复“240106”获取教程和详细的操作指南）。
6.Anaconda关联到Pycharm
将 Anaconda 关联到 PyCharm 可以让你更方便地管理 Python 环境和包。具体的操作也同样需要关注微信公众“自然语言处理CS”，回复“240106”获取）
7.第一个Python程序
7.1.给计算机打招呼
创建程序文件夹：在桌面上创建一个文件夹，命名为the_path_to_python_learning，这个文件夹就是后面保存Python的所有代码和笔记。
Note：在学习编写第一个程序时，可能会遇到各种困难，很难通过纯文字来充分解释。因此，对于初学者来说，非常建议观看视频教程，第一个程序的编写见视频：04-Python的第一个程序_哔哩哔哩_bilibili
本教程中所有的程序可见：JakeSenior/the_path_to_python_learning - 码云 - 开源中国 (gitee.com)
关注Bilibili进行全部课程学习，BiliBili账号：SeniorJake的个人空间-SeniorJake个人主页-哔哩哔哩视频 (bilibili.com)
8.注释
在编程中，注释是用来解释代码的文字，它不会被计算机执行。注释可以帮助程序员理解代码的功能和逻辑，也可以帮助其他人更容易地理解和修改代码。具体的注释方法如下图所示。
单行注释：单行注释是用#开头的一行文字。它只影响紧跟在其后的一行代码，这一行代码被称为“注释行”。在执行程序时，计算机会忽略注释行。
多行注释：多行注释是用三个单引号（‘’‘…’‘’）或三个双引号（“”“…”“”）包围的一段文字。它可以跨越多行，即解释一行代码的时候，一行写不完，需要多行才能写完，就用多行注释（其实一般情况是用单行注释就可以搞定，只是没有多行注释美观）。
9.变量和数据类型
9.1变量的概念
对于函数 f(x)=ax+b 来说， x 很显然是一个变量，前面提到过，我们编程的目的其实就是将这些函数关系用计算机表示。在数学上，变量实际上是一个可以变化的量，可以是整数、小数、复数、同样也可以是一个字符串（一堆英文单词或者中文词之类的自然语言，一般称为字符串）吧！
为了将我们提到的函数在计算机处理，就需要将这些变量表示出来，而计算机执行程序时要把一些值加载到内存中（电脑中8G、16G的那个内存条，所以电脑的内存条太小了，就运行不了太多程序。对于电脑比较老的同学可以加装更大的内存条给升级一下，一般会提升电脑的性能），因此，执行函数时这些变量就存储在内存上了，这就意味着在创建变量时会在内存中开辟一个空间进行存储。
对于函数来说，只要我们给变量赋值一个确定值就可以输出函数的结果，如 f(x)=\pi r^2 这个函数，很显然这是求一个圆的面积的函数。如果要计算圆的面积，那么就要给变量 r 赋值，一旦变量赋值以后该变量就会被创建（保存到了内容中），再将这个变量传入到函数中就可以求出面积。
那么在Python中怎么定义一个变量呢？
首先，定义一个变量 r ，并给他赋值为2，因为赋值了之后变量才会有实际意义。然后，假设一个函数 f® = \pi * r + 5 是圆的面积的求解（为什么假装呢？因为现在我们不知道 \pi 怎么在程序中表示。）。最后，调用print函数显示f的值。结果显示为9，即2*2+5的结果。
Python 中的变量赋值不需要类型声明。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号 = 用来给变量赋值。
等号 = 运算符左边是一个变量名，等号 = 运算符右边是存储在变量中的值。
多个变量赋值可以使用如下方式：
9.2.数字类型和字符串类型
上面的例子中的变量 r 就是一个数字类型，即变量 r 之后跟的是一个数字，由于后面是一个整数，所以也叫整数变量，或者叫整型变量。也可以定义一个浮点数变量（带有小数点的变量，即 r=1.5555 ）。
1. 整型变量的操作
# 加法和减法
result1 = 2 + 3 # 结果是整数 5
result2 = 10 - 5 # 结果是整数 5
# 乘法和除法
result3 = 4 * 3 # 结果是整数 12
result4 = 20 / 4 # 结果是浮点数 5.0
# 整除和取余
result5 = 10 // 3 # 结果是整数 3
result6 = 10 % 3 # 结果是整数 1
# 幂运算
result7 = 2 ** 3 # 结果是整数 8
# 整数转换
num_str = "42"
result8 = int(num_str) # 将字符串 "42" 转换为整数 42
2. 浮点数操作
# 浮点数运算
result1 = 3.14 + 2.0 # 结果是浮点数 5.14
result2 = 10.5 / 2.5 # 结果是浮点数 4.2
# 浮点数转换
num_int = 5
result3 = float(num_int) # 将整数 5 转换为浮点数 5.0
3. 字符类型的操作
# 字符串连接
string1 = "Hello"
string2 = "World"
result = string1 + ", " + string2 # 结果是 "Hello, World!"
# 字符串长度
length = len("Python") # 结果是 6
# 字符串索引
text = "Python"
first_char = text[0] # 获取第一个字符 "P"
last_char = text[-1] # 获取最后一个字符 "n"
# 字符串切片
text = "Python Programming"
substring1 = text[0:6] # 获取索引 0 到 5 的子字符串 "Python"
substring2 = text[7:] # 获取索引 7 到末尾的子字符串 "Programming"
# 字符串方法
text = "Python is easy to learn."
uppercase_text = text.upper() # 将字符串转换为大写 "PYTHON IS EASY TO LEARN."
lowercase_text = text.lower() # 将字符串转换为小写 "python is easy to learn."
# 字符串格式化
name = "Alice"
age = 30
formatted_text = "My name is {} and I am {} years old.".format(name, age)
# 结果是 "My name is Alice and I am 30 years old."
# 字符串格式化
name = "Alice"
age = 30
formatted_text = f"My name is {name} and I am {age} years old."
# 结果是 "My name is Alice and I am 30 years old."
"""
字符串按照一定的规则分割成多个子字符串（重点）
字符串的split方法是用于将一个字符串按照指定的分隔符拆分成多个子字符串，并返回一个包含这些子字符串的列表。
以下是字符串的split方法的基本用法以及一些示例：
"""
text = "apple,banana,cherry"
fruits = text.split(",") # 使用逗号作为分隔符
print(fruits)
# 输出: ['apple', 'banana', 'cherry']
# 可以根据需要指定不同的分隔符，例如空格、制表符、换行符等。默认情况下，split方法使用空格作为分隔符。
text = "apple banana cherry"
fruits = text.split() # 使用空格作为分隔符（默认）
print(fruits)
# 输出: ['apple', 'banana', 'cherry']
text = "apple\tbanana\tcherry"
fruits = text.split("\t") # 使用制表符作为分隔符
print(fruits)
# 输出: ['apple', 'banana', 'cherry']
text = "apple\nbanana\ncherry"
fruits = text.split("\n") # 使用换行符作为分隔符
print(fruits)
# 输出: ['apple', 'banana', 'cherry']
# 还可以通过指定最大分割次数来限制拆分的次数。默认情况下，会拆分所有匹配的分隔符。
text = "apple,banana,cherry"
text = "apple,banana,cherry,dates"
fruits = text.split(",", 2) # 最多拆分2次
print(fruits)
# 输出: ['apple', 'banana', 'cherry,dates']
10.列表
10.1.列表的定义
Python 中的列表（List）是一种有序的数据结构，用于存储一组值或元素。以下是列表的特点：
有序性：列表中的元素是有序排列的，每个元素都有一个特定的位置（索引），索引从0开始，依次递增。
可变性：列表是可变的，这意味着你可以在列表中添加、删除或修改元素。这使得列表非常灵活，适用于存储和管理多个元素。
元素类型：列表可以包含各种数据类型的元素，包括整数、浮点数、字符串、布尔值、甚至其他列表等。在Python中，列表可以混合不同类型的元素。
方括号表示：在Python中，列表使用方括号 [] 表示。元素之间使用逗号 , 分隔。
10.2.列表的基本操作
# 1.定义一个列表，列表名为my_list，里面含有5个元素，前三个为整数类型，第四个为字符类型，第五个为布尔类型。
my_list = [1, 2, 3, 'apple', True]
# 2.对列表进行增删改
my_list = [1, 2, 3, 'apple', True] # 创建一个包含不同类型元素的列表
my_list.append(4) # 在末尾添加元素，将整数4添加到列表中，现在列表是 [1, 2, 3, 'apple', True, 4]
my_list.remove('apple') # 删除指定元素，删除值为'apple'的元素，现在列表是 [1, 2, 3, True, 4]
my_list[2] = 'orange' # 修改元素的值，将索引为2的元素从3修改为'orange'，现在列表是 [1, 2, 'orange', True, 4]
# 列表中可以包含不同类型的元素，但通常建议保持列表中的元素类型一致以提高代码的可读性和可维护性。
# 3.访问列表的元素
# 可以通过索引来访问列表中的元素。索引从0开始，负数索引表示从列表末尾开始反向计数。
my_list = [1, 2, 3, 'apple', True] # 创建一个包含不同类型元素的列表
first_element = my_list[0] # 获取第一个元素，使用索引0来访问列表中的第一个元素，这里是整数1
last_element = my_list[-1] # 获取最后一个元素，使用索引-1来访问列表中的最后一个元素，这里是布尔值True
# 4.对列表进行切片
# 切片是一种获取列表中子集的方法，可以使用 : 来指定范围。
my_list = [1, 2, 3, 'apple', True] # 创建一个包含不同类型元素的列表
subset = my_list[1:3] # 获取索引1到2的元素，即包括索引1的元素2和索引2的元素3
# 5.求列表的长度
# 列表的长度是指列表中包含的元素数量。可以使用 len()函数来获取列表的长度。
my_list = [1, 2, 3, 'apple', True] # 创建一个包含不同类型元素的列表
length = len(my_list) # 获取 my_list 的长度，即列表中元素的数量
# 上述代码中的length变量将包含列表my_list的长度，也就是5，因为它包含了5个元素。
11.字典
11.1.字典的定义
字典提供了一种将值与相关key关联起来的方式，使可以根据键来检索value，而不必知道value在字典中的位置。字典是一种非常有用的数据结构，通常用于存储和管理具有关联性的信息，例如配置设置、数据库记录、JSON 数据等。它们提供了一种高效的方式来检索和操作数据，尤其在需要根据特定标识符（key）查找相关信息（value）时非常有用。以下是关于字典的概念：
key-value对：字典是由一组key和与每个key关联的value组成的。每个key-value对之间使用冒号 : 分隔，不同的key-value对之间使用逗号 , 分隔。
无序性：与列表不同，字典中的key-value对是无序的，它们没有固定的顺序。你无法通过索引来访问字典中的元素，而是通过key来检索相关的value。
唯一key：字典中的key必须是唯一的，每个key只能出现一次。如果你尝试使用相同的key添加新的value，它将覆盖之前的value。
可变性：字典是可变的，这意味着可以添加、删除或修改key-value对。
元素类型：字典可以包含各种数据类型的value，包括整数、浮点数、字符串、布尔值、列表、甚至其他字典。
花括号表示：在Python中，字典使用花括号 {} 表示，key和value之间使用冒号 : 分隔，key-value对之间使用逗号 , 分隔。
11.2.字典的基本操作
# 1.创建字典
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
# 2.访问Value
# 可以使用key来访问字典中的value。
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
name = my_dict['name'] # 获取key为'name'的value，结果为'John'
# 3.添加和修改Value
# 可以使用key来添加新的key-value对或修改现有key的value。
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
my_dict['job'] = 'Engineer' # 添加新的key-value对
my_dict['age'] = 31 # 修改key'age'的value
# 4.删除key-value对
# 可以使用 del 语句来删除字典中的key-value对。
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'} # 创建一个字典
del my_dict['city'] # 删除键'city'及其关联的值
# 在这个示例中，有一个名为my_dict的字典，其中包含了三对键-值对。
# 通过使用del关键字，我们删除了键为'city'的项，这也同时删除了与之关联的值。
# 在操作后，my_dict将不再包含'city'这个键，它的内容变成了{'name': 'John', 'age': 30}。
# 5.检查key是否存在
# 可以使用 in 运算符来检查key是否存在于字典中。
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'} # 创建一个字典
if 'name' in my_dict:
print('Name is in the dictionary.')
# 在这个示例中，我们首先创建了一个名为my_dict的字典，其中包含了三对键-值对。
# 然后，使用条件语句if 'name' in my_dict来检查字典中是否存在键'name'。
# 如果存在，条件表达式将为真，然后打印出"Name is in the dictionary."。
# 6.求字典的长度
my_dict = {"apple": 2, "banana": 3, "cherry": 1, "date": 4}
# 获取字典的长度
length = len(my_dict)
print("字典的长度是:", length)
# 上面的代码会输出：4。
# 这里的字典my_dict包含了4个键值对，因此它的长度是4
12.元组
12.1.元组的定义
元组（Tuple）是 Python 编程语言中的一种有序、不可变的数据结构。它与列表（List）相似，但有一个主要的区别：元组一旦创建，就不能再进行修改，即它是不可变的。元组使用圆括号 () 来表示，并且可以包含零个或多个元素，各元素之间使用逗号 , 分隔。
以下是有关元组的主要特点和用途：
不可变性：元组的不可变性意味着一旦创建了元组，就不能修改其中的元素。这使得元组在需要保护数据免受意外更改的情况下很有用。例如表示日期时间、坐标或配置设置时。由于元组是不可变的，可以用作字典的键，而列表不能。
有序性：元组中的元素是有序排列的，每个元素都有一个唯一的位置，可以通过索引来访问元组中的元素。
多类型支持：元组可以包含不同数据类型的元素，包括整数、浮点数、字符串、布尔值等。
12.2.元组的基本操作
# 1.创建元组
# 可以使用圆括号()来创建一个元组。元素之间用逗号 , 分隔。
my_tuple = (1, 2, 'apple', 3.14)
# 2.访问元素
# 使用索引来访问元组中的元素，索引从0开始。
my_tuple = (1, 2, 'apple', 3.14)
print(my_tuple[0])
# 3.长度
# 使用len()函数可以获取元组中元素的数量。
my_tuple = (1, 2, 'apple', 3.14)
length = len(my_tuple) # 获取元组的长度
# 4.元素检查
# 使用 in 关键字来检查元素是否存在于元组中。
my_tuple = (1, 2, 'apple', 3.14)
if 'apple' in my_tuple:
print('Found apple in the tuple.')
13.循环
13.1.循环的定义
循环（Loop）是编程中的一种控制结构，它允许你多次执行一组指定的代码块，直到满足特定条件为止。循环是一种重复性的行为，通常用于处理需要重复执行的任务，例如遍历数据集、执行相同的操作多次、等待条件满足等情况。
循环的基本定义包括以下要素：
循环体：循环体是一组要重复执行的代码块。这些代码块通常包括了你希望循环执行的任务或操作。
循环条件：循环条件是一个表达式，它确定是否继续执行循环体内的代码。只要循环条件为真，循环就会继续执行；一旦循环条件为假，循环就会终止。
控制变量（在某些循环中）：控制变量是一个变量，用于追踪循环的状态。在每次迭代中，控制变量的值可能会发生变化，以便最终使循环条件变为假。
13.2.for循环
for 循环是编程中常见的一种循环结构，用于遍历数据集合或执行一组操作多次。它通常有两种形式：迭代循环和计数循环。
迭代循环
for 循环用于遍历（迭代）可迭代对象中的元素，例如列表、元组、字符串等。
# 1. 列表循环
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
print(fruit)
"""
代码分析：
1. fruits = ['apple', 'banana', 'cherry']：这一行创建了一个包含三个水果名称的列表，并将其赋值给变量 fruits。
2. for fruit in fruits:：这是一个 for 循环的开头，它会迭代遍历 fruits 列表中的每个元素，并将当前元素赋值给变量 fruit。这意味着在每次循环迭代中，fruit 将依次取得列表中的 'apple'、'banana' 和 'cherry'。
3. print(fruit)：在循环中，这一行代码使用 print 函数打印当前 fruit 变量的值，即当前水果的名称。
因此，这段代码的执行将会输出以下内容：
apple
banana
cherry
"""
# 2. 遍历元组
# 元组是一种不可变序列，通常用于存储一组相关的数据。可以使用 for 循环来遍历元组中的元素。
fruits = ("apple", "banana", "cherry")
for fruit in fruits:
print(fruit)
# 3. 遍历字符串
# 字符串是一个字符序列，可以使用 for 循环逐个访问字符串中的字符。
text = "Hello, Python"
for char in text:
print(char)
# 4. 遍历字典}
# 字典是一种键-值对数据结构，可以使用 for 循环来遍历字典的键、值或键值对。
# 4.1 遍历key}
person = {"name": "Alice", "age": 30, "city": "New York"}
for key in person:
print(key)
# 4.2 遍历value
person = {"name": "Alice", "age": 30, "city": "New York"}
for value in person.values():
print(value)
# 4.3 遍历key-value对}
person = {"name": "Alice", "age": 30, "city": "New York"}
for key, value in person.items():
print(key, value)
计数循环
计数循环是通过指定循环的次数来执行的。在大多数编程语言中，通常使用一个计数器变量（例如 i）来控制循环的次数，直到计数器达到特定的值。
range() 是一个内置函数，用于生成一个整数序列(生成的序列是一个不可变的序列)，通常用于循环结构，尤其是在 for 循环中。range() 的基本语法如下：
range(start, stop, step)
"""
start（可选）：序列起始值，默认为 0。
stop（必选）：序列结束值（不包含在序列中）。
step（可选）：步长，即序列中相邻两个元素之间的差，默认为 1。
"""
# 1. range()具体的用法
for i in range(5):
print(i)
# 这个例子将会输出从 0 到 4 的数字，因为 range(5) 生成了一个从 0 到 4 的序列。
for i in range(2, 8, 2):
print(i)
# 生成一个从 2 到 8（不包括 8）的整数序列，步长为 2，输出的值为 2、4 和 6。
for i in range(10, 1, -1):
print(i)
# 生成一个从 10 到 1（不包括 1）的整数序列，步长为 -1，这个示例将逆序输出从 10 到 2 的整数。
# range() 函数的主要用途是在循环中生成一系列整数，以便遍历数据或执行重复操作。
# 虽然 range() 返回的是一个序列对象，但通常在 for 循环中直接使用它，而不需要将其转换为列表或其他数据结构。
13.3.while循环
while 循环在指定条件为真时重复执行代码块，直到条件变为假。
count = 0
while count < 5:
print(count)
count += 1
# 这个示例中，while 循环在 count 小于 5 的条件下执行，每次循环增加 count 的值，并打印出当前的 count 值。
14.迭代器和可迭代对象
Python 中的迭代循环是基于迭代器（iterator）和可迭代对象（iterable）的概念实现的。迭代器是一个具有__iter__()和__next()__方法的对象，它可以逐个地返回序列中的元素。可迭代对象是包含多个元素的对象，可以通过迭代器遍历。
fruits = ["apple", "banana", "cherry"]
fruit_iterator = iter(fruits) # 创建一个迭代器
print(next(fruit_iterator)) # 输出 "apple"
print(next(fruit_iterator)) # 输出 "banana"
在 for 循环中，Python 会自动处理迭代器和可迭代对象的细节，使迭代循环更加简洁。
14.1.可迭代对象（Iterable）
可迭代对象是一种包含多个元素的数据集合，可以遍历它们，访问其中的每个元素，例如列表、元组、字符串、字典等等。可迭代对象具有__iter__()方法，这个方法返回一个迭代器对象。
my_list = [1, 2, 3, 4, 5] # 列表是可迭代对象
14.2.迭代器（Iterator）
迭代器是一种可以逐个访问可迭代对象中元素的对象。迭代器使用 __iter__()方法返回自身，并且有一个__next()__方法，用于获取下一个元素。当没有更多元素可供访问时，__next__方法会引发 StopIteration 异常。
my_iterator = iter(my_list) # 创建一个迭代器
迭代器的特点是它在遍历时只记录当前位置，因此对于非常大的数据集合，迭代器在内存上的开销较小。
使用 for 循环时，Python 会自动创建一个迭代器，并在循环过程中逐个获取元素，直到没有更多元素可获取。
15.条件语句
15.1.条件语句定义
条件语句是编程中的基本控制结构之一，它允许根据条件的真假来执行不同的代码块。在 Python 中，条件语句通常由 if、elif（可选）和 else（可选）关键字组成。以下是 Python 中条件语句的基本语法和概念：
if 条件:
# 如果条件为真，执行这里的代码块
elif 另一个条件: # 可选的elif部分，可以有多个
# 如果上面的条件为假且这个条件为真，执行这里的代码块
else: # 可选的else部分，最多只有一个
# 如果以上条件都为假，执行这里的代码块
if 后面的条件是一个布尔表达式，它会被求值为 True 或 False。
elif（else if的缩写）用于在第一个条件为假的情况下测试另一个条件。
else 用于指定当所有上面的条件都为假时要执行的代码块。
# 给出一个具体的实例：
age = 18 # 设置年龄变量为 18
if age < 18:
print("未成年人") # 如果年龄小于 18，则打印 "未成年人"
elif age >= 18 and age < 65:
print("成年人") # 如果年龄大于等于 18 且小于 65，则打印 "成年人"
else:
print("老年人") # 如果年龄不符合上述条件，则打印 "老年人"
"""
代码的执行过程如下：
1. 定义一个名为 age 的变量，并将其设置为 18。
2. 使用 if 语句来检查年龄：如果年龄小于 18，则执行 if 语句块中的代码，打印 "未成年人"。
3. 如果年龄不满足第一个条件，会继续检查 elif 条件：如果年龄大于等于 18 且小于 65，则执行 elif 语句块中的代码，打印 "成年人"。
4. 如果年龄不满足前两个条件，将执行 else 语句块中的代码，打印 "老年人"。
5. 在这种情况下，由于 age 的值为 18，它不满足第一个条件（小于 18），但满足第二个条件（大于等于 18 且小于 65），因此代码会打印 "成年人"。
这就是条件语句如何根据不同条件执行不同的代码块。
"""
15.2.嵌套条件语句
条件嵌套语句是指在一个条件语句内部包含另一个条件语句。这允许你在某个条件满足时进一步测试其他条件，以实现更复杂的控制逻辑。条件嵌套的距离通常用来描述内部条件语句相对于外部条件语句的缩进级别。
在 Python 中，缩进是非常重要的，它用于表示代码块的开始和结束。条件嵌套的距离是指内部条件语句的缩进相对于外部条件语句的缩进的级别。
x = 10
y = 5
if x > y: # 外部条件语句
print("x 大于 y")
if x > 15: # 内部条件语句，相对于外部条件的缩进
print("x 大于 15")
else: # 内部条件语句的另一部分，与上面的部分相同级别的缩进
print("x 不大于 15")
else: # 外部条件语句的另一部分，与if语句相同级别的缩进
print("x 不大于 y")
"""
在上述示例中：
外部条件语句是 if x > y:，其下方的代码块（缩进部分）是外部条件的一部分。
内部条件语句是 if x > 15: 和 else:，它们相对于外部条件语句的缩进级别不同。
缩进用于表示代码块的开始和结束，它决定了哪些代码属于内部条件语句，哪些属于外部条件语句。
要注意，Python 非常严格地要求正确的缩进，因此必须保持相同级别的代码块有相同的缩进距离。
条件嵌套语句的距离通常用来指导你在代码中创建清晰的层次结构，以便易于阅读和维护。
"""
15.3.break和continue
break 和 continue 是用于控制循环的两个关键字，在编程中经常用于改变循环的执行流程。
break 用于终止当前循环，无论循环条件是否满足。一旦 break 被执行，循环立即结束，程序流程将跳出循环，执行循环后的下一条语句。
for i in range(5):
if i == 3:
break # 当 i 等于 3 时终止循环
print(i)
"""
代码分析：
1. for i in range(5):：这是一个for循环的开头，它迭代变量i从0到4（包括0，不包括5）。循环将执行5次，每次i的值会递增。
2. if i == 3:：在每次循环迭代中，这个条件语句检查i是否等于3。
3. break：如果条件 i == 3 为真，break语句将被执行。break语句的作用是终止当前所在的循环。在这里，如果 i 等于 3，循环将被立即终止。
4. print(i)：如果条件 i == 3 为假（即 i 不等于 3），则会执行这行代码，将当前的 i 的值打印到标准输出。这将在 i 不等于 3 时发生。
因此，这段代码的行为如下：
当 i 为0、1、2时，它们不等于3，因此print(i)会执行，打印出0、1、2。
当 i 为3时，条件 i == 3 为真，break 语句执行，循环立即终止，因此不会打印出3。
当 i 为4时，循环已经终止，因此不会执行任何操作。
因此，最终的输出为：
0
1
2
"""
continue 用于跳过当前迭代中的剩余代码，并继续下一次迭代。它不会终止整个循环，而是跳过当前循环迭代的剩余部分，进入下一次迭代。
for i in range(5):
if i == 2:
continue # 当 i 等于 2 时跳过这次循环迭代
print(i)
"""
代码分析：
1. for i in range(5):：这是一个 for 循环的开头，它迭代变量 i 从0到4（包括0，不包括5）。循环将执行5次，每次 i 的值会递增。
2. if i == 2:：在每次循环迭代中，这个条件语句检查 i 是否等于2。
3. continue：如果条件 i == 2 为真，continue 语句将被执行。continue 的作用是跳过当前迭代的剩余部分，直接进入下一次迭代。
4. print(i)：如果条件 i == 2 为假（即 i 不等于2），则会执行这行代码，将当前的 i 的值打印到标准输出。这将在 i 不等于2 时发生。
因此，这段代码的行为如下：
当 i 为0、1时，它们不等于2，因此 print(i) 会执行，分别打印出0、1。
当 i 为2时，条件 i == 2 为真，continue 语句执行，跳过了当前迭代的剩余部分，因此不会执行 print(i)，直接进入下一次迭代。
当 i 为3、4时，它们不等于2，因此 print(i) 会执行，分别打印出3、4。
最终的输出是：
0
1
3
4
"""
16.函数
16.1.函数的定义
在Python中，可以使用 def 关键字来定义函数。函数的定义通常包括以下几个部分：
函数名称：函数的名称是标识符，用于唯一标识函数。它通常是由字母、数字和下划线组成的，但必须以字母或下划线开头。函数名称后面跟着一对小括号 ()。
参数列表：小括号内包含函数的参数列表，参数是函数接受的输入值。参数可以是零个或多个，多个参数之间用逗号 , 分隔。例如，def my_function(x, y): 中的 x 和 y 就是参数。
冒号 :：冒号表示函数定义的开始。
函数体：函数体是由缩进的代码块组成，包含了函数的具体实现。函数体中的代码定义了函数的行为和操作。函数体必须相对于 def 关键字有一致的缩进。
返回值（可选）：函数可以包含一个 return 语句，用于指定函数的返回值。如果函数没有 return 语句，或者 return 后面没有表达式，函数将默认返回 None。
在Python中，函数或方法名前面加上一个下划线通常是一种命名约定，用于指示该函数或方法是"私有的"或"内部的"，意味着它不应该被外部代码直接访问或调用。这并不是Python语言本身的强制性规定，而是一种约定，旨在提醒其他程序员不要在外部访问这些函数或方法。如下代码所示：
def _internal_function():
# 干一些事情
"""
表示这个_internal_function函数是内部使用的，不应该被外部代码直接调用。
这只是一种建议，Python不会强制阻止你调用这些函数。
"""
16.2.函数的具体用法
下面给出一个用于计算给定数字列表的平均值的函数，并在示例用法中演示了如何使用它。
def calculate_average(numbers):
"""
计算一组数字的平均值。
参数：
numbers (list): 包含数字的列表。
返回值：
float: 平均值。
"""
if len(numbers) == 0:
return 0 # 避免除以0错误
total = sum(numbers)
average = total / len(numbers)
return average
# 示例用法
data = [10, 20, 30, 40, 50]
result = calculate_average(data)
print("平均值:", result)
# 代码分析：
"""
1. 函数定义的部分：
def calculate _average(numbers)：这是一个函数的定义，函数名为calculate_average，它接受一个参数 numbers，该参数应该是包含数字的列表。
if len(numbers) == 0}:：这一行检查输入的列表 numbers 是否为空。如果列表为空（长度为0），则函数返回0，以避免除以0错误。
total = sum(numbers)}：这一行使用内置函数 sum 计算输入列表 numbers 中所有数字的总和，并将结果存储在 total 变量中。
average = total / len(numbers)：这一行计算平均值，将总和 total 除以列表的长度，得到平均值，并将结果存储在 average 变量中。
return average：最后一行返回计算得到的平均值作为函数的结果。
"""
"""
2. 示例的解析
创建了一个名为 data 的列表，其中包含了一组数字 [10, 20, 30, 40, 50]。
调用calculate_average(data)函数，传递 data 列表作为参数，以计算这组数字的平均值，并将结果存储在 result 变量中。
使用 print 函数将平均值打印到控制台，输出了 "平均值: 30.0"（这个示例数据的平均值为30.0）。
"""
16.3.return的用法
return 是一个关键字，用于在Python中定义函数的返回值。当函数执行到 return 语句时，它会立即结束函数的执行，并将指定的值或表达式结果返回给函数的调用者。以下是关于 return 语句的重点强调：
定义返回值：return 语句用于在函数内部定义函数的返回值。
结束函数执行：当执行到 return 语句时，函数的执行将立即停止，并且函数将返回 return 语句指定的值。这意味着函数中的后续代码将被跳过。
返回类型：return 语句可以返回任何Python对象，包括数字、字符串、列表、字典、布尔值等
返回多个值：尽管 return 通常用于返回单个值，但它也可以用于返回多个值。多个值可以作为元组、列表或其他数据结构的形式一起返回。
def return_multiple_values():
a = 10
b = 20
return a, b
返回 None：如果函数没有明确的 return 语句或者 return 后面没有跟随任何表达式，函数将隐式返回 None。这在没有明确返回值的函数中很常见。
def do_something():
# 没有明确的return语句，函数隐式返回None
result = 42
函数的返回值可选：并不是所有函数都需要返回值。有些函数只是执行某些操作，而不返回值。在这种情况下，可以省略 return 语句或使用 return 单独返回 None。
函数调用中的接收：调用函数时，通常将函数的返回值分配给变量，以便进一步使用或处理。例如：result = my_function()。
17.内置函数
17.1.内置函数的定义
内置函数是编程语言中已经预先定义好的函数，它们无需额外导入模块或库，可以直接在编程中使用。这些函数执行常见的任务，如数学运算、数据类型转换、文件操作等。
17.2.常见的内置函数
Python 内置函数是 Python 编程中的基本工具。这些函数包括数学函数，
如 **abs()**用于返回绝对值，**max()和 min()用于找出最大和最小值；
类转换函数，如 int()、float() 和str() 用于转换不同类型的数据；
序列操作函数，如len()**用于获取序列的长度，**sorted()用于排序列表；
输入输出函数，如print()**用于打印文本，**input()用于接收用户输入；
逻辑函数，如bool()**用于转换为布尔值，**all()和any()**用于检查可迭代对象中的元素；
文件操作函数，如 **open()**用于打开文件，**read()**用于读取文件内容；
其他常见函数，如 **type()**用于返回对象的类型。
18.文件操作
在学习使用Python打开本地文件进行文件操作时，可能会遇到各种困难，很难通过纯文字来充分解释。因此，对于初学者来说，这一节也是非常建议观看视频教程，文件操作见如下视频：
12-1文件操作之使用open读取文件_哔哩哔哩_bilibili
12-2文件操作之使用open读取并写入数据_哔哩哔哩_bilibili
18.1.文件操作的定义
文件操作是指在计算机中对文件进行读取、写入、创建、删除、移动和修改等操作的过程。文件操作是计算机编程和数据处理中的常见任务之一，允许程序访问和处理文件中的数据。
以下是文件操作的一些关键概念：
打开文件：要执行文件操作，首先需要打开文件。打开文件时，通常需要提供文件名和打开模式。模式可以指定文件是用于读取、写入、追加或其他操作。文件打开后，程序可以访问其内容。
读取文件：一旦文件被打开，程序可以使用不同的方法来读取文件的内容。常见的方法包括一次性读取整个文件、逐行读取文件和将文件内容读取为行的列表。
写入文件：程序可以将数据写入文件，将数据存储在文件中。写入文件时，通常需要指定写入模式。写入文件会覆盖文件的内容，除非使用追加模式。
关闭文件：在完成文件操作后，应该显式关闭文件。关闭文件有助于释放系统资源并确保对文件的更改得以保存。
处理二进制文件：除了文本文件外，程序还可以处理二进制文件，如图像、音频和视频文件。读取和写入二进制文件需要使用适当的二进制模式。
异常处理：文件操作可能会引发异常，如文件不存在或无法访问。因此，异常处理在文件操作中非常重要，以确保程序具有健壮性。
文件路径：文件路径指定文件在计算机文件系统中的位置。在文件操作中，你需要指定要打开或处理的文件的路径。
文件操作模块：Python提供了多个模块，如 os 和 shutil，用于执行文件和目录操作。这些模块提供了丰富的功能，如文件复制、删除、移动等。
18.2.打开和读取文件
要打开一个文件，可以使用 open() 函数。该函数需要文件名和模式作为参数。模式可以是 “r”（读取），“w”（写入），“a”（追加），“x”（创建），等等。例如：
# 打开文件
file = open("example.txt", "r")
# 打开一个文本文件以供写入（如果不存在则创建）
file = open("output.txt", "w")
# 读取文件
# 一旦文件被打开，可以使用不同的方法来读取文件的内容：
# read(): 一次性读取整个文件内容。
# readline(): 逐行读取文件内容。
# readlines(): 将文件内容读取为行的列表。
# 读取整个文件内容
content = file.read()
# 逐行读取文件内容
line = file.readline()
while line:
print(line)
line = file.readline()
# 将文件内容读取为行的列表
lines = file.readlines()
18.3.写入和关闭文件
向文件写入数据，可以使用 write() 方法。如果文件以写入模式 “w” 打开，则写入将覆盖文件的内容。如果文件以追加模式 “a” 打开，则写入将追加到文件的末尾。
# 写入文本到文件
file.write("Hello, World!\n")
# 追加文本到文件
file = open("output.txt", "a")
file.write("This is a new line.")
# 关闭文件：在完成文件操作后，应该关闭文件以释放资源。
# 可以使用 close() 方法来关闭文件：
file.close()
18.4.with的神奇用法
更安全的文件操作方法是使用 with 语句，它会自动关闭文件，即使发生异常也能正常工作：
with open("example.txt", "r") as file:
content = file.read()
# 在这里文件会自动关闭
# 文件已自动关闭
18.5.处理二进制文件
上述示例是用于处理文本文件的，如果要处理二进制文件（例如图像、音频等），可以使用二进制模式 “rb”（读取二进制）和 “wb”（写入二进制）：
# 读取二进制文件
with open("image.jpg", "rb") as file:
image_data = file.read()
# 写入二进制文件
with open("output.jpg", "wb") as file:
file.write(image_data)
19.异常处理
大部分的同学可能看得懂异常的处理，但是不知道为什么要学习这个，或者不知道什么时候用。因此，对于初学者来说，这一节也是非常建议观看视频教程，异常处理见如视频：13-异常_哔哩哔哩_bilibili
19.1.异常的概念
异常是在程序执行过程中发生的错误或不正常情况的表示。它们可能是由于无效输入、文件不存在、内存不足、网络问题等引起的。Python 中有许多内置的异常类型，如 ZeroDivisionError、FileNotFoundError、TypeError 等。
19.2.try-except语句
在 Python 中，可以使用 try 和 except 语句块来处理异常。try 块包含可能引发异常的代码，而 except 块包含处理异常的代码。如果在 try 块中发生异常，程序将跳转到匹配的 except 块。
try:
# 可能引发异常的代码
except SomeException:
# 处理异常的代码
except AnotherException:
# 处理 AnotherException 的代码
19.3.else和finally
else：else 块包含在 try 块中没有引发异常时执行的代码。
finally：finally 块包含在 try 块执行后始终执行的代码，无论是否引发异常。通常用于释放资源，如文件或网络连接。
try:
# 可能引发异常的代码
except SomeException:
# 处理异常的代码
else:
# 如果没有异常，执行的代码
finally:
# 始终执行的代码
20.模块和包
20.1.模块
模块是一个包含Python代码的文件。这些文件可以包含变量、函数、类和可执行的代码。每个Python程序都可以被看作是一个模块。模块使代码更加模块化，提高了代码的可读性和可维护性。
创建模块：创建模块非常简单，只需将Python代码保存在以.py为扩展名的文件中。例如，如果你创建一个名为 my_module.py的文件，它就成为了一个名为my_module 的模块。
导入模块：要在另一个Python文件中使用模块，可以使用import语句。例如，import my_module将导入名为my_module.py的模块。
使用模块中的内容：使用点符号. 来访问模块中的变量、函数或类。例如，my_module.my_function()。
20.2.包
包是一个包含模块的目录。包允许将多个模块组织在一起，以便更好地管理和分组相关的代码。包是一个包含一个特殊的__init__.py文件的目录，这个文件可以为空。
创建包：要创建一个包，只需创建一个带有__init__.py文件的目录，并在该目录中放置模块文件。例如，可以创建一个名为my_package的目录，其中包含__init__.py文件和其他模块文件。
导入包和模块：要导入包中的模块，可以使用import语句，例如，import my_package.my_module。
使用包中的内容：与模块一样，可以使用点符号. 来访问包中模块的内容，例如，my_package.my_module.my_function()。
包的嵌套：包可以嵌套，即包中可以包含子包。子包也必须包含含__init__.py文件。这允许创建更复杂的代码组织结构。
20.3.为什么使用模块和包？
代码组织：模块和包帮助将代码组织成可管理的单元，使代码更清晰和易于维护。
代码重用：可以在多个项目中重用模块和包，避免编写重复的代码。
命名空间管理：模块和包提供了命名空间，防止不同模块中的变量名冲突。
可维护性：通过将功能分解为模块和包，可以更轻松地进行测试、修复和更新代码。
21.实践项目——二手车市场分析
21.1.二手车市场分析的背景及意义
二手车市场分析在今天的社会中具有重要的背景和意义，这是因为它涉及到广泛的经济、社会和个人层面。
背景
汽车保有量的增加： 随着时间的推移，汽车保有量在世界各地都在增加。这导致了更多的二手车在市场上流通，因此二手车市场变得更加重要。
经济因素： 由于新车价格的上涨，许多人更愿意购买二手车，这使得二手车市场成为了一个经济重要的领域。
环保考虑： 在一些地区，人们更加关注环保，选择购买二手车可以减少新车生产的环境影响。
意义
经济贡献： 二手车市场为经济做出了巨大贡献。它创造了工作岗位，促进了汽车相关产业的增长，如维修和保养服务。
购车选择： 对于许多人来说，购买二手车是出行的实际选择。通过市场分析，人们可以找到价格合适、性能良好的二手车。
资源节约： 通过购买二手车，人们可以减少新车生产对资源的需求，有助于资源的可持续利用。
环保： 善用二手车可以降低废弃车辆数量，减少废旧汽车对环境的污染。
21.2.数据介绍
数据集包含多个数据点，每个数据点表示一辆二手车的信息，数据集见：Part3-Python实战 · JakeSenior/the_path_to_python_learning - 码云 - 开源中国 (gitee.com)
原始数据为：data.csv
运行：00-转化为txt数据格式.py 获取后面我们要真正使用的数据（一定要运行这个程序）。
其中每个数据点包括以下字段：
汽车品牌（Brand）：表示二手车的制造商或品牌，例如斯柯达、奥迪、宝马等。
价格（Price）：表示二手车的售价，以货币单位（可能是人民币或其他货币）为单位。
标签（Tag）：描述二手车的状态或特点的标签，例如急售、0过户、里程少等。
21.3.二手车基本信息统计
# 读取数据的函数
def obtain_data(filepath):
"""
从文件中读取数据并将其解析为列表
:param filepath: 文件路径
:return: 二手车信息的列表
"""
data = []
with open(filepath, 'r', encoding='utf-8') as file:
for line in file:
item = str2lst(line)
data.append(item)
return data
def str2lst(data_str):
"""
将二手车的一行字符串信息转化为列表信息
:param data_str: 字符串元素
:return: 列表元素
"""
# 去掉字符串两端的方括号，并分割成子字符串
data_str = data_str[1:-2]
data_items = data_str.split(', ')
data_list = []
# 遍历子字符串，将其解析为元组并添加到列表中
i = 0
for item in data_items:
if i % 2 == 0:
item = item[2:-1]
else:
if "'" in item:
item = item[1:-2]
else:
item = float(item[:-1])
i = i + 1
data_list.append(item)
result_lst = []
for i in range(0, len(data_list), 2):
result_lst.append((data_list[i], data_list[i + 1]))
return result_lst
# 计算价格的平均值的函数
def calculate_average_price(data):
"""
计算价格的平均值
:param data: 二手车数据的列表数据
:return: 平均价格
"""
total_price = 0
count = 0
for item in data:
for key, value in item:
if key == 'price':
total_price += value
count += 1
if count > 0:
return total_price / count
else:
return 0
# 计算价格的中位数的函数
def calculate_median_price(data):
"""
计算价格的中位数
:param data: 二手车数据的列表数据
:return: 价格的中位数
"""
prices = []
for item in data:
for key, value in item:
if key == 'price':
prices.append(value)
sorted_prices = sorted(prices)
middle_index = len(sorted_prices) // 2
if len(sorted_prices) % 2 == 0:
return (sorted_prices[middle_index] + sorted_prices[middle_index - 1]) / 2
else:
return sorted_prices[middle_index]
# 计算价格的中位数的函数
def count_brand_distribution(data):
"""
统计品牌分布
:param data: 二手车数据的列表数据
:return: 品牌分布：字典类型，key为品牌名，value为出现的品牌次数
"""
brand_counts = {}
for item in data:
for key, value in item:
if key == 'brand':
brand = value
if brand in brand_counts:
brand_counts[brand] += 1
else:
brand_counts[brand] = 1
return brand_counts
# 统计标签分布的函数
def count_tag_distribution(data):
"""
统计标签分布
:param data: 二手车数据的列表数据
:return: 标签分布：字典类型，key为一款二手车是否急售、过了几次户、里程少等信息，value为次数
"""
tag_counts = {}
for item in data:
for key, value in item:
if key == 'tag':
tag = value
if type(tag) == float:
tag = str(["没有备注"])
else:
tag = str(tag.split("_"))
if tag in tag_counts:
tag_counts[tag] += 1
else:
tag_counts[tag] = 1
return tag_counts
# 二手车基本信息统计的执行
if __name__ == '__main__':
filepath = "data.txt"
data = obtain_data(filepath)
# 调用示例函数并打印结果
average_price = calculate_average_price(data)
median_price = calculate_median_price(data)
brand_distribution = count_brand_distribution(data)
tag_distribution = count_tag_distribution(data)
print(f"------------------平均价格: {average_price}----------------")
print(f"------------------中位数价格: {median_price}--------------")
print("--------------------------品牌分布:------------------------")
for brand, count in brand_distribution.items():
print(f"{brand}: {count} 个")
print("------------------------------标签分布:-----------------------")
for tag, count in tag_distribution.items():
print(f"{tag}: {count} 个")
21.4.二手车可视化分析
数据分析的可视化
进行数据分析后，可视化是将分析结果以图形方式呈现的重要步骤，它可以帮助你更清晰地理解数据并传达分析的结论。Python中有许多库可用于数据可视化，其中最常用的是matplotlib和seaborn。以下是一些常见的数据可视化类型和如何使用这些库进行可视化的示例。
# 直方图
# 直方图用于表示数据的分布情况，特别适用于显示数值型数据的分布。直方图的示例代码如下所示：
import matplotlib.pyplot as plt
# 示例数据
data = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6]
# 创建直方图
plt.hist(data, bins=5, edgecolor='k') # 指定分箱数量和边界颜色
plt.xlabel('Value') # x轴标签
plt.ylabel('Frequency') # y轴标签
plt.title('Histogram of Data') # 图表标题
plt.show()
# 散点图
# 散点图用于显示两个数值型变量之间的关系。散点图的示例代码如下所示：
import matplotlib.pyplot as plt
# 示例数据
x = [1, 2, 3, 4, 5]
y = [10, 12, 8, 15, 11]
# 创建散点图
plt.scatter(x, y, label='Data Points', color='blue', marker='o') # 指定标签、颜色和标记样式
plt.xlabel('X-axis') # x轴标签
plt.ylabel('Y-axis') # y轴标签
plt.title('Scatter Plot') # 图表标题
plt.legend() # 添加图例
plt.show()
# 条形图
# 条形图用于比较不同类别或组之间的数值。条形图的示例代码如下所示：
import matplotlib.pyplot as plt
# 示例数据
categories = ['A', 'B', 'C', 'D']
values = [10, 20, 15, 25]
# 创建条形图
plt.bar(categories, values, color='green') # 指定类别和对应的值
plt.xlabel('Categories') # x轴标签
plt.ylabel('Values') # y轴标签
plt.title('Bar Chart') # 图表标题
plt.show()
22.类
类是Python中最难理解的，初学者必须要对应视频进行学习，视频见：15-1-类的初步了解_哔哩哔哩_bilibili
22.1.什么是类？
Python 中的类（Class）是一种用于创建对象的蓝图或模板。它们允许你定义对象的属性（数据）和方法（函数），以便在程序中创建多个具有相似特征的对象。类是面向对象编程（OOP）的核心概念之一，它允许你将数据和操作封装在一个单独的单元中。
22.2.如何定义一个类
在Python中，可以使用关键字 class 来定义一个类。以下是一个简单的类的定义示例：
class Dog:
# 类的构造函数
def __init__(self, name, breed):
self.name = name
self.breed = breed
# 类的方法
def bark(self):
return "Woof!"
# 创建一个类的实例
my_dog = Dog("Buddy", "Golden Retriever")
# 访问类的属性和调用方法
print(my_dog.name) # 输出：Buddy
print(my_dog.bark()) # 输出：Woof!
类的构造函数
类的构造函数是__init__方法，构造函数是一种特殊的方法，用于初始化类的属性或状态。
它通常在创建类的实例时自动调用，以确保对象的合理初始化。
类的属性
类的属性是与类相关联的数据。
可以使用点操作符（.）来访问类的属性。
类的方法
类的方法是定义在类内部的函数，用于执行操作或提供功能。
方法的第一个参数通常是 self，它表示调用方法的类的实例。
22.3.二手车分析——类版本
class UsedCarDataAnalyzer:
def __init__(self, filepath):
self.filepath = filepath
self.data = self.obtain_data(self.filepath)
def obtain_data(self, filepath):
"""
从文件中读取数据并将其解析为列表
:param filepath: 文件路径
:return: 二手车信息的列表
"""
data = []
with open(filepath, 'r', encoding='utf-8') as file:
for line in file:
item = self.str2lst(line)
data.append(item)
return data
def str2lst(self, data_str):
"""
将二手车的一行字符串信息转化为列表信息
:param data_str: 字符串元素
:return: 列表元素
"""
# 去掉字符串两端的方括号，并分割成子字符串
data_str = data_str[1:-2]
data_items = data_str.split(', ')
data_list = []
# 遍历子字符串，将其解析为元组并添加到列表中
i = 0
for item in data_items:
if i % 2 == 0:
item = item[2:-1]
else:
if "'" in item:
item = item[1:-2]
else:
item = float(item[:-1])
i = i + 1
data_list.append(item)
result_lst = []
for i in range(0, len(data_list), 2):
result_lst.append((data_list[i], data_list[i + 1]))
return result_lst
def calculate_average_price(self):
"""
计算价格的平均值
:return: 平均价格
"""
total_price = 0
count = 0
for item in self.data:
for key, value in item:
if key == 'price':
total_price += value
count += 1
if count > 0:
return total_price / count
else:
return 0
def calculate_median_price(self):
"""
计算价格的中位数
:return: 价格的中位数
"""
prices = []
for item in self.data:
for key, value in item:
if key == 'price':
prices.append(value)
sorted_prices = sorted(prices)
middle_index = len(sorted_prices) // 2
if len(sorted_prices) % 2 == 0:
return (sorted_prices[middle_index] + sorted_prices[middle_index - 1]) / 2
else:
return sorted_prices[middle_index]
def count_brand_distribution(self):
"""
统计品牌分布
:return: 品牌分布：字典类型，key为品牌名，value为出现的品牌次数
"""
brand_counts = {}
for item in self.data:
for key, value in item:
if key == 'brand':
brand = value
if brand in brand_counts:
brand_counts[brand] += 1
else:
brand_counts[brand] = 1
return brand_counts
def count_tag_distribution(self):
"""
统计标签分布
:return: 标签分布：字典类型，key为一款二手车是否急售、过了几次户、里程少等信息，value为次数
"""
tag_counts = {}
for item in self.data:
for key, value in item:
if key == 'tag':
tag = value
if type(tag) == float:
tag = str(["没有备注"])
else:
tag = str(tag.split("_"))
if tag in tag_counts:
tag_counts[tag] += 1
else:
tag_counts[tag] = 1
return tag_counts
if __name__ == '__main__':
filepath = "../Part3-Python实战/data.txt"
analyzer = UsedCarDataAnalyzer(filepath)
# 调用示例函数并打印结果
average_price = analyzer.calculate_average_price()
median_price = analyzer.calculate_median_price()
brand_distribution = analyzer.count_brand_distribution()
tag_distribution = analyzer.count_tag_distribution()
print(f"------------------平均价格: {average_price}----------------")
print(f"------------------中位数价格: {median_price}--------------")
print("--------------------------品牌分布:------------------------")
for brand, count in brand_distribution.items():
print(f"{brand}: {count} 个")
print("------------------------------标签分布:-----------------------")
for tag, count in tag_distribution.items():
print(f"{tag}: {count} 个")
以上就是“零基础最快学会Python”的全部内容，希望对你有所帮助。
关于Python技术储备
学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
一、Python所有方向的学习路线
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
二、Python必备开发工具
三、Python视频合集
观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
四、实战案例
光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
五、Python练习题
检查学习结果。
六、面试资料
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
最后祝大家天天进步！！
上面这份完整版的Python全套学习资料已经上传至CSDN官方，朋友如果需要可以直接微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】。
535
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
