Python
Python是用来编写应用程序的高级编程语言。Python为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、
数据库、文本等大量内容，被形象地称作“内置电池（batteries included）”。用Python开发，许多功能不必从零
编写，直接使用现成的即可。
除了内置的库外，Python还有大量的第三方库，也就是别人开发的，供你直接使用的东西。当然，如果你
开发的代码通过很好的封装，也可以作为第三方库给别人使用。
Python适合开发哪些类型的应用呢？
首选是网络应用，包括网站、后台服务等等；
其次是许多日常需要的小工具，包括系统管理员需要的脚本任务等等；
另外就是把其他语言开发的程序再包装起来，方便使用。
优点:
跨平台
Python是跨平台的，它可以运行在Windows、Mac和各种Linux/Unix系统上。在Windows上写Python程
序，放到Linux上也是能够运行的。
缺点:
第一个缺点就是运行速度慢，和C程序相比非常慢，因为Python是解释型语言，你的代码在执行时会一
行一行地翻译成CPU能理解的机器码，这个翻译过程非常耗时，所以很慢。而C程序是运行前直接编译成
CPU能执行的机器码，所以非常快。
第二个缺点就是代码不能加密。如果要发布你的Python程序，实际上就是发布源代码，这一点跟C语言
不同，C语言不用发布源代码，只需要把编译后的机器码（也就是你在Windows上常见的xxx.exe文件）
发布出去。要从机器码反推出C代码是不可能的，所以，凡是编译型的语言，都没有这个问题，而解释型
的语言，则必须把源码发布出去。
编程语言
编程语言：编程语言是人与计算机沟通的工具，用于编写计算机程序，作用类似“翻译官”，将人类逻辑转换为
计算机可识别的二进制指令
机器语言：直接使用二进制代码（0和1）表达指令，是计算机硬件可直接识别和执行的语言，特点是执行效率极高，
但编写难度大、可读性差。
汇编语言：使用助记符（如`MOV`、`ADD`）与机器语言指令一一对应，降低了编写难度，但仍依赖硬件架构，可移
植性较差，需通过汇编器转换为机器语言后执行。
高级语言：接近自然语言和数学逻辑的编程语言（如Python、Java、C++等），无需关注硬件细节，可读性强、开发
效率高，但需通过编译器（如C++编译为机器码）或解释器（如Python逐行解释执行）转换为机器语言才能运行。
下载安装
目前，Python有两个版本，一个是2.x版，一个是3.x版，这两个版本是不兼容的。由于3.x版越来越普及，
所以采用3.8版本，下载链接如下:
https:
下载和安装完成后，打卡CMD窗口输入python，会进入Python交互式环境中，可以输入任何Python代码，
回车后会立刻得到执行结果。
如果窗口显示：'python' is not recognized as an internal or external co│
│mmand, operable program or batch file.
则需要在环境变量中配置python.exe的位置(参考Java JDK的配置 指定一下path即可)
Python解释器
当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，
就需要Python解释器去执行.py文件。
目前python的解释器有如下几种:
1.CPython
CPython是使用最广的Python解释器。当我们从Python官方网站下载并安装好Python 3.x后，我们就直接获
得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行
python就是启动CPython解释器。
2.IPython
IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执
行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。
3.PyPy
PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译，
所以可以显著提高Python代码的执行速度。绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython
有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要
放到PyPy下执行，就需要了解PyPy和CPython的不同点。
4.Jython
Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。
5.IronPython
IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把
Python代码编译成.Net的字节码。
运行Python
Python交互模式的代码是输入一行，执行一行,Python交互模式主要是为了调试Python代码用的，也便于
初学者学习，它不是正式运行Python代码的环境！
命令行模式下直接运行.py文件是一次性执行该文件内的所有代码.
编写一个.py文件,内容如下:print('你好，Python')
Python输出print函数
print('张三','李四')
print('--------------')
print('张三','李四',sep='|')
print('--------------')
print('张三','李四',sep='|',end='!')
print('--------------')
输出:
张三 李四
--------------
张三|李四
--------------
张三|李四!--------------
进程已结束，退出代码为 0
`sep`参数：自定义分隔符，默认为空格。
示例：`print("Hello", "World", sep="-")`，输出结果为`Hello-World`。
`end`参数：控制输出结尾字符，默认为换行符`\n`。
示例：
`print("Hello", end="!")`；
`print("World")`，输出结果为`Hello!World`（两行内容合并为一行）。
print写入文件
a=open('1.txt','w',encoding='utf-8')
print('我想变强',file=a)
a.close();
Python输入input函数
input函数无论用户输入数字、文本还是符号，`input()`函数均返回字符串类型（str）。
示例：`age = input("请输入年龄：")`，即使输入“18”，`age`的数据类型仍为`str`。
#input()输入函数
name = input("请输入您的姓名:");
#print()输出函数
print("~~~~~~~~~~~~~~~~~~~~~\n");
print("键盘输出姓名:"+name);
address = input('请输入您的家庭地址:')
idno = input('请输入您的身份证号:')
print(f'我的家庭地址{address},我的身份证号{idno}') #f格式化占位符输出
age=int(input('请输入您的年龄'))
phone=input('请输入您的手机号')
print(f'我的年龄{age}',f'我的手机号{phone}')
Python关键字
Python内置`keyword`模块可查看当前版本关键字列表及相关信息。
***关键字严格区分大小写，例如`True`是关键字，而`true`是普通变量名；
`None`是关键字，`none`不是。
变量
`变量`是存储数据的空间
`变量名 = 变量值`
1.由字母、数字、下划线组成。
2.不能以数字开头。
3.不能使用Python内置函数名。
4.不推荐使用中文命名。
5.严格区分大小写
6.特殊字符不能命名
数据类型-整数
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，
例如：1，100，-8080，0，等等。
计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f
表示，例如：0xff00，0xa5b4c3d2，等等。
对于很大的数，例如10000000000，很难数清楚0的个数。Python允许在数字中间以_分隔，因此，写
成10_000_000_000和10000000000是完全一样的。十六进制数也可以写成0xa1b2_c3d4。
#代码展示
print(100);
print("-------");
print(-100);
print("-------");
#Python允许在数字中间以_分隔 增强可读性
print(100_00_00_00);
print("-------");
print(100000000);
输出结果:
100
-------
-100
-------
100000000
-------
100000000
注意:
Python的整数没有大小限制，而某些语言的整数根据其存储长度是有大小限制的，
例如Java对32位整数的范围限制在-2147483648-2147483647。
数据类型-浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变
的，比如，1.23x10^9和12.3x10^8是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但
是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10^9就是1.23e9，或者
12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），
而浮点数运算则可能会有四舍五入的误差。
#代码展示
print(10.5 / 2);
print(22.0 / 2);
print(6.3 / 2.0);
输出结果
5.25
11.0
3.15
注意：
Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）。
数据类型-字符型
字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种
表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，
那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。
#代码展示
print('abc');
print("张三上山打老虎");
输出结果
abc
张三上山打老虎
`字符串切片`
# 0 1 2 3 4 5 6 7 正索引
# H e l l o d l
#-8-7-6-5-4-3-2-1 负索引
s1='Hello dl'
print(s1)
#从字符串s1截取出Hello
print(s1[0:5]) #正索引 从0开始（最左边） [n:m]包含n不包含m索引值
print(s1[-8:-3]) #负索引 从-1开始(最右边) [n:m]包含n不包含m索引值
数据类型-字符型（常用方法）
| 函数 | 作用 |
|---|
| replace() | 返回替换后的字符串，可将字符串中指定的子串替换成新的内容 |
| split() | 返回切割后的列表序列，能把字符串按照指定分隔符拆分，转换为列表形式 |
| join() | 用一个字符或子串合并字符串，可将多个字符串通过指定的连接符拼接成新的字符串 |
| index() | 查找给定字符的第一个匹配项的下标，能快速定位字符在字符串中的首次出现位置 |
| strip() | 移除首尾的空格和换行符或指定字符串，用于清理字符串首尾的冗余内容 |
| count() | 统计字符串内某字符串的出现次数，可统计指定子串在原字符串中出现的频次 |
| len() | 统计字符串的字符个数，注意这是内置函数，不是字符串方法，用于获取字符串长度 |
| lower() | 将字符串转换为小写，可把字符串中的大写字母全部转为小写 |
| upper() | 将字符串转换为大写，可把字符串中的小写字母全部转为大写 |
字符串格式化
# %() %s输出字符串 %d十进制整数 %f浮点数类型
name='张三'
age=18
weight=175.5
print('%s今年%d岁，体重%f斤' %(name,age,weight))
# f格式化输出
print(f'{name}今年{age}岁，体重{weight}斤')
# format()格式
print('{}今年{}岁，体重{}斤'.format(name,age,weight))
数据类型-布尔类型
布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False。
在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来。
布尔值可以用and、or和not运算。
#代码展示
print(True)
print(False)
print(True and True)
print(True or False)
print(not True)
输出结果
True
False
True
True
False
整数对应：
True 等价于整数 1，
False 等价于整数 0，
支持基础数值运算（如 `True + 1 = 2`，`False * 5 = 0`）。
### 自动转换规则
非0值/非空值：非零数值（如 `10`）、非空字符串（如 `hello`）、非空列表/字典等转换为 True。
0值/空值：整数 `0`、空字符串 `""`、空列表 `[]`、空字典 `{}` 等转换为 False。
数据类型相互转换
s1=10.8
s2=int(s1) #int 向下取整
print(s2,type(s2))
print('---------------')
s3=10
s4=float(s3)
print(s4,type(s4))
print('---------------')
s5=188
s6=str(s5)
print(s6,type(s6))
print('---------------')
s7=99
print(float(s7),type(s7))
print(type(s7))
eval函数
eval函数是Python的内置函数，其核心功能是去掉字符串最外侧的引号，并将其内容当做Python语
句执行。
运算符
| 运算符 | 描述 | 实例 |
|---|
| + | 加 | 1 + 1 输出结果为 2 |
| - | 减 | 1 - 1 输出结果为 0 |
| * | 乘 | 2 * 2 输出结果为 4 |
| / | 除（浮点数结果） | 10 / 2 输出结果为 5.0 |
| // | 整除（取整结果） | 9 // 4 输出结果为 2 |
| % | 取余（取模） | 9 % 4 输出结果为 1 |
| ** | 幂指数 | 2 ** 4 输出结果为 16 |
| () | 小括号（运算优先级） | (1 + 2) * 3 输出结果为 9 |
赋值运算符
| 运算符 | 描述 | 实例 |
|---|
| = | 赋值 | 将右侧结果赋值给左侧变量 |
| += | 加法赋值运算符 | c += a 等价于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等价于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等价于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等价于 c = c / a |
| //= | 整除赋值运算符 | c //= a 等价于 c = c // a |
| %= | 取余赋值运算符 | c %= a 等价于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等价于 c = c ** a |
比较运算符
| 运算符 | 名称及规则 | 示例 |
|---|
| == | 等于：判断两个操作数是否相等，相等则条件为True，否则为False | 如 a=3, b=3，则 (a == b) 为 True |
| != | 不等于：判断两个操作数是否不相等，不相等则条件为True，否则为False | 如 a=1, b=3，则 (a != b) 为 True |
| > | 大于：左侧操作数大于右侧则条件为True，否则为False | 如 a=7, b=3，则 (a > b) 为 True |
| < | 小于：左侧操作数小于右侧则条件为True，否则为False | 如 a=7, b=3，则 (a < b) 为 False |
| >= | 大于等于：左侧操作数大于或等于右侧则条件为True，否则为False | 如 a=7, b=3，则 (a >= b) 为 True；如 a=3, b=3，则 (a >= b) 为 True |
| <= | 小于等于：左侧操作数小于或等于右侧则条件为True，否则为False | 如 a=3, b=3，则 (a <= b) 为 True |
逻辑运算符
| 运算符 | 表达式 | 规则说明 | 示例 |
|---|
| and | x and y | 布尔“与”：若x为False，返回False；否则返回y的值。 | True and False 返回 False |
| or | x or y | 布尔“或”：若x为True，返回True；否则返回y的值。 | False or True 返回 True |
| not | not x | 布尔“非”：若x为True，返回False；若x为False，返回True。 | not True 返回 False，not False 返回 True |
IF判断语句
'''
if 条件:
执行True条件成立语句
'''
num = int(input('请输入一个正整数:'))
if num % 2 == 0:
print("您输入的是偶数")
print('-------------------------')
'''
if 条件:
执行True条件成立语句
else:
指定False条件不成立
'''
num = int(input('请输入一个正整数:'))
if num % 2 == 0:
print("您输入的是偶数")
else:
print("您输入的是奇数")
'''
if 条件1:
elif 条件2:
elif 条件3:
elif ...:
elif ...:
else:
'''
age =int(input("请输入您的年龄:"))
if age <18:
print("您还未成年")
elif age >=18 and age <30:
print("您已成年")
elif age >=30 and age <50:
print("您正值壮年")
elif age >=50 and age <60:
print("您正在老去")
else:
print("黄土马上盖过头顶")
#代码展示
age = 10;
if age > 5:
print("你的年龄超过5岁");
print("现在通知您,");
print("赶紧买票");
----------------------------
#代码展示
age = 1;
if age > 5:
print("你的年龄超过5岁");
print("现在通知您,");
print("赶紧买票");
else:
print("您的年龄没有超过5岁");
print("可以不用买票");
----------------------------
#代码展示
age = 6;
if age > 5:
print("你的年龄超过5岁");
elif age > 6:
print("您的年龄超过6岁");
elif age > 7:
print("您的年龄超过7岁");
else:
print("未知年龄");
输出结果:
你的年龄超过5岁
注意:
if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略
掉剩下的elif和else。
if判断条件还可以简写，只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。
#代码展示
x = 1;
if x:
print("摇摇晃晃");
三目运算符
num1=10
num2=20
max = num1 if num1>num2 else num2
print(f'最大值为:{max}')
Pass
`pass`是Python中的关键字，作为空语句占位符，用于语法结构中确保代码完整且不报错，本身无实际功能。
序列
序列是用于存储多个值的连续空间，每个值对应一个唯一整数(索引)。
s='Hello World'
print(s[0:5:2]) #索引从0开始，到5结束（不包含5），步长2
print(s[:5:2]) #省略开始位置，start默认从0开始
print(s[0::1]) #省略结束位置，默认到最后一个元素
print(s[5::]) #省略结束位置和步长
print(s[::2]) #省略开始和结束位置，步长2
| 操作符/函数 | 描述说明 |
|---|
| x in s | 若x是s的元素，返回True，否则False |
| x not in s | 若x不是s的元素，返回True，否则False |
| len(s) | 返回序列s的长度（元素个数） |
| max(s) | 返回序列s中的最大元素 |
| min(s) | 返回序列s中的最小元素 |
| s.index(x) | 返回序列s中第一次出现x的位置（索引） |
| s.count(x) | 返回序列s中元素x出现的次数 |
数据类型-空值
空值是Python里一个特殊的值，用None表示。
None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
#代码展示
print(None)
输出结果
None
转义字符
| 转义字符 | 作用 |
|---|
| \n | 代表换行符（键盘的Enter键） |
| \t | 代表制表符（键盘的Tab键） |
| \ | 代表反斜杠（\） |
| \r | 代表返回后面的字符串 |
| \b | 代表退格 |
转义字符\可以转义很多字符。
print('hello\nworld')#\n 代表换行符（键盘的Enter键）
print('------------')
print('hello\tworld')#\t 代表制表符（键盘的Tab键）
print('------------')
print('hello\world')#\ 代表反斜杠（\）
print('------------')
print('hello\rworld')#\r 代表返回后面的字符串 只返回world
print('------------')
print('hello\bworld')#\b 代表退格 相当于删除前面一个字符
print('------------')
print(r'hello\bworld')#r或R 表示关闭转移字符
print(R'hello\bworld')#
强制不转义
Python还允许用r''|r""表示''|""内部的字符串默认不转义
#代码展示
print(r'\'\'\'\'\'\'\'\'\'');
print(r"\"\"\"\"\"\"");
print(r"\n")
print(r"制表符")
print(r"\t")
#输出结果
\'\'\'\'\'\'\'\'\'
\"\"\"\"\"\"
\n
制表符
\t
格式化多行内容
如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''XXX'''的格式表示多
行内容。
#代码展示
print('''
你好，Python
大数据学习
未来可期
~~~~~~
''');
输入结果：
你好，Python
大数据学习
未来可期
~~~~~~
变量
变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可
以是任意数据类型。
变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头
，比如：
#代码展示
a = 123;
print("整数变量:");
print(a);
a = "张三";
print("字符串变量:");
print(a);
a = True;
print("布尔值变量");
print(a);
输出结果
整数变量:
123
字符串变量:
张三
布尔值变量
True
注意：
这种变量本身类型不固定的语言称之为动态语言。
常量
所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名
表示常量：
PI = 3.14159265359
但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表
示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。
#代码展示
PI = 3.14159265359;
print("PI的值:");
print(PI);
PI = 9999;
print("PI的值发生变化:")
print(PI)
输出结果
PI的值:
3.14159265359
PI的值发生变化:
9999
除法运算
在Python中，有两种除法，一种除法是：/
/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：
#代码展示
print(10 / 2);
输出结果
5.0
-------------------------------------------------------------
还有一种除法是：
称为地板除，两个整数的除法仍然是整数：
#代码展示
print(10
print(10
输出结果
5
3
注意：整数的地板除永远是整数,因为地板除只取结果的整数部分。
Python字符串
在最新的Python 3版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言。
对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：
#代码展示
v1 = ord('张');
print(v1);
print('\n');
print(chr(65));
输出结果
24352
A
bytes类型
Python对bytes类型的数据用带b前缀的单引号或双引号表示:
x = b'ABC'
以Unicode表示的str通过encode()方法可以编码为指定的bytes
v1 = '中文'.encode('UTF-8');
print(v1);
v2 = 'bca'.encode('ASCII');
print(v2);
输出结果
b'\xe4\xb8\xad\xe6\x96\x87'
b'bca'
注意:
纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。
含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。
如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，
就需要用decode()方法：
#代码展示
v1 = b'\xe4\xb8\xad\xe6\x96\x87';
print(v1.decode('UTF-8'));
v2 = b'bca';
print(v2.decode('ASCII'));
输出结果
中文
bca
注意：
如果bytes中包含无法解码的字节，decode()方法会报错
Traceback (most recent call last):
File "E:\2021-11-12-python\project01\com\ldd\main\main.py", line 3, in <module>
print(v1.decode('UTF-8'));
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x88 in position 6: invalid start byte
如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节
#代码展示
v1 = b'\xe4\xb8\xad\xe6\x96\x87\x88';
print(v1.decode('UTF-8',errors='ignore'));
中文
len()函数
要计算str包含多少个字符，可以用len()函数：
#代码展示
v1 = "张三坐错车";
print(len(v1));
输出结果
5
-------------------------------------------------------
len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：
v1 = "张三坐错车".encode('UTF-8');
print(len(v1));
输出结果
15
格式化占位符
最后一个常见的问题是如何输出格式化的字符串。我们经常会输出类似'亲爱的xxx你好！你xx月的话费是
xx，余额是xx'之类的字符串，而xxx的内容都是根据变量变化的，所以，需要一种简便的格式化字符串的
方式。
#代码展示
v1 = 'Hello %s' % 'World';
print(v1);
v2 = '%s同学,在%s，打卡出校门' % ('张三','2021-10-10 12:12:12');
print(v2);
输出结果：
Hello World
张三同学,在2021-10-10 12:12:12，打卡出校门
----------------------------------------------
#代码展示
v1 = 'Age: %s. Gender: %s' % (25,True);
print(v1);
输出结果：
Age: 25. Gender: True
注意：%s它会把任何数据类型转换为字符串
----------------------------------------------
#代码展示
v1 = '%%' % ();
print(v1);
输出结果：
%
注意: 格式化字符串 用%%来表示一个%
format函数使用
格式化字符串的方法是使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……
#代码展示
v1 = '{0}同学，最近在{1}口吐狂言'.format("张三","东营路");
print(v1);
输出结果：
张三同学，最近在东营路口吐狂言
List操作
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
#代码展示
nameList = ['张三','李四','王五'];
print(nameList);
print(len(nameList));
print("-----------");
print(nameList[0]);
print(nameList[1]);
print(nameList[2]);
print("-----------");
print(len(nameList)-1);
输出结果:
['张三', '李四', '王五']
3
-----------
张三
李四
王五
-----------
2
#list创建 list里面的元素可以是任意类型
list1=['a','b','c']
print(list1)
print('-----------')
#使用内置函数list()创建
list2=list('qwer')
print(list2)
print('-----------')
list3=[1,'张三',2.5]
print(list3)
print('-----------')
del list3
print(list3) #报错 因为list3已经被删除
1.list是一个可变的有序表，所以，可以往list中追加元素到末尾。
#代码展示
nameList = ['张三','李四','王五'];
nameList.append("马六");
nameList.append("牛七")
print(nameList);
输出结果：
['张三', '李四', '王五', '马六', '牛七']
2.insert把元素插入到指定的位置
#代码展示
nameList = ['张三','李四','王五'];
nameList.insert(0,"爸一");
nameList.insert(1,"爸二");
print(nameList);
输出结果：
['爸一', '爸二', '张三', '李四', '王五']
3.remove操作
3.要删除list末尾的元素，用pop()方法,要删除指定位置的元素，用pop(i)方法，其中i是索引位置
#代码展示
nameList = ['张三','李四','王五'];
nameList.pop();
print(nameList);
print("-----------");
nameList.pop(0);
print(nameList);
输出结果:
['张三', '李四']
-----------
['李四']
4.list其他操作
#代码展示
nameList = ['张三','李四','王五'];
#要把某个元素替换成别的元素，可以直接赋值给对应的索引位置
nameList[0] = "张子墨";
print(nameList);
print("----------");
#list里面的元素的数据类型也可以不同
varList = ["Hello",100,True,False,200.20];
print(varList);
print("----------");
#list元素也可以是另一个list
allList = ["Hello",["张三",100,True,["张思",200,False]],"World"];
print(allList);
#获取allList
#allList[1]里面第一个数组,allList[1][3]第一个数组里面的数组,allList[1][3][0]张思
print(allList[1][3][0]);
输出结果:
['张子墨', '李四', '王五']
----------
['Hello', 100, True, False, 200.2]
----------
['Hello', ['张三', 100, True, ['张思', 200, False]], 'World']
张思
#代码展示
nullList = [];
#如果一个list中一个元素也没有，就是一个空的list，它的长度为0
print(nullList);
print(len(nullList));
输出结果:
[]
0
5.list其他操作
list1=['a','b','c','a']
list1.remove('a')#移除第一个匹配到的元素
print(list1)
print("--------------")
list1=['a','b','c','a']
del list1[1] #del删除list1索引为1的元素
print(list1)
print("--------------")
list1=['a','b','c','a']
n=list1.index('c') #返回第一个匹配元素的索引值
print(n)
print("--------------")
list1=['a','b','c','a']
count=list1.count('a') #统计元素a出现的次数
print(count)
print("--------------")
list1=[1,3,8,3,6,5,6,7,7]
list1.sort()#升序排序
print(list1)
print("--------------")
list1.sort(reverse=True)#倒序排序
print(list1)
tuple
tuple有序列表叫元组,tuple和list非常类似，但是tuple一旦初始化就不能修改。
它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的。
#代码展示
nameTuple = ("张三","李四","王五");
print(nameTuple);
print(nameTuple[0]);
print(nameTuple[1]);
print("-----------");
输出结果:
('张三', '李四', '王五')
张三
李四
-----------
#定义一个空的tuple，可以写成()
varTuple = ();
print(varTuple);
print("-----------");
输出结果:
()
-----------
#定义只有一个元素的tuple
#定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产
生了歧义。
#oneTuple = (1);#因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
#定义一个元素的元组，必须加上`,`
oneTuple = (1,);
print(oneTuple);
print(len(oneTuple));
print(oneTuple[0]);
输出结果:
(1,)
1
1
注意：tuple的不可变表示tuple内部元素指向不可变。比如说tuple里面存入的是一个list，你不能把这个
list变成字符串或者数据，但是list内部中的元素可以发生改变(懒的写案例了)
int()函数
#代码展示
x = "123";
print(x);
#int()函数，将字符串转成int
print(int(x));
for in循环遍历
#代码展示
nameList = ["张三","李四","王五"];
for name in nameList:
print("name:"+name);
#range(10) 产生从0开始 小于10的整数序列 0~9
#list()函数将整数序列，转换成list
numberList = list(range(10));
numSum = 0;
for num in numberList:
numSum +=num;
print("0~9数值总和是:"+str(numSum));
输出结果:
name:张三
name:李四
name:王五
0~9数值总和是:45
str1 = 'Python'
for s in str1:
print(s)
print('----------')
输出:
P
y
t
h
o
n
----------
range函数
#range(10) 生成0-5的数字（不包含5）
num = range(5)
print(num)
for n in num:
print(n)
print('---------------------')
#range(1,5) 生成1-5的数字（不包含5）
num2 = range(1,5)
print(num2)
for n in num2:
print(n)
print('---------------------')
#range(0,5,2) 生成0-5的数字,每次递增+2（不包含5）
num3 = range(0,5,2)
print(num3)
for n in num3:
print(n)
print('---------------------')
while循环遍历
#代码展示
num = 99;
sum = 0;
while num >0:
sum +=num;
num -=2;
print(sum);
输出结果:
2500
-----------------------------------------------
#代码展示
num = 99;
sum = 0;
while num >0:
if num == 97:
break
sum +=num;
num -=2;
print(sum)
输出结果：
99
-----------------------------------------------
#代码展示
num = 99;
sum = 0;
while num >0:
if num % 2 ==0:
continue
sum +=num;
num -=2;
print(sum)
输出结果：
2500
dict数据结构
1.Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值
（key-value）存储，具有极快的查找速度。
2.dict在内部可以直接计算出key对应存放value的“页码”，所以速度非常快。这种key-value存储方式，
在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。
dict有以下几个特点：
1.查找和插入的速度极快，不会随着key的增加而变慢。
2.需要占用大量的内存，内存浪费多。
3.dict的key必须是不可变对象。
4.这个通过key计算位置的算法称为哈希算法（Hash）。
5.在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。
#代码展示
dictMap = {"name":"张三","age":18,"hobby":["篮球","游戏","吉他"]};
print(dictMap);
print(dictMap.get("name"));
print(dictMap.get("hobby"));
输出结果:
{'name': '张三', 'age': 18, 'hobby': ['篮球', '游戏', '吉他']}
张三
['篮球', '游戏', '吉他']
#把数据放入dict的方法，除了初始化时，还可以通过key放入
dictMap["name"] = "李四";
print(dictMap["name"]);
输出结果:
李四
#由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉
dictMap["name"] = "王五";
dictMap["name"] = "马六";
print(dictMap.get("name"));
输出结果:
马六
#通过dict()函数来创建
dict1=dict(name='张三',age=18,city='中国')
print(dict1)
输出结果:
{'name': '张三', 'age': 18, 'city': '中国'}
#通用两个列表来创建dict字典
keys=['name','age','address']
values=['汤米',18,'麻吉岛长春大道19号']
dict1=dict(zip(keys,values))
print(dict1)
输出结果:
{'name': '汤米', 'age': 18, 'address': '麻吉岛长春大道19号'}
#代码展示
dictMap = {"name":"张三","age":18,"hobby":["篮球","游戏","吉他"]};
#通过in判断key是否存在
print("name" in dictMap);
输出结果:
True
#通过dict提供的get()方法，如果key不存在，可以返回None或者自己指定的value
dictMap = {"name":"张三","age":18,"hobby":["篮球","游戏","吉他"]};
print(dictMap.get("hello"));
print(dictMap.get("hello","key不存在"));
dictMap.pop("name");#要删除一个key，用pop(key)方法，对应的value也会从dict中删除
print(dictMap.get("name"));
输出结果:
None
key不存在
None
#通过key给dict数据结构存入元素
dict1=dict()
dict1['name']='张三'
dict1['age']=18
print(dict1)
输出结果:
{'name': '张三', 'age': 18}
#del 删除元素
dict1=dict(name='张三',age=18,city='中国')
print(dict1)
print('---------')
del dict1['city']
print(dict1)
输出结果:
{'name': '张三', 'age': 18, 'city': '中国'}
---------
{'name': '张三', 'age': 18}
#update 更新字典元素
dict1=dict(name='张三',age=18,city='中国')
print(dict1)
print('---------')
dict1.update({'name':'李四'})
print(dict1)
输出结果:
{'name': '张三', 'age': 18, 'city': '中国'}
---------
{'name': '李四', 'age': 18, 'city': '中国'}
Set
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
#代码展示
#重复元素在set中自动被过滤
#显示的顺序也不表示set是有序的
nameSet = set(["张三","李四","张三"]);
print(nameSet);
print("--------------");
nameSet.add("王五");
nameSet.add("赵六");
nameSet.add("赵六");
print(nameSet);
print("--------------");
nameSet.remove("张三");
print(nameSet);
输出结果:
{'张三', '李四'}
--------------
{'王五', '张三', '李四', '赵六'}
--------------
{'王五', '李四', '赵六'}
#代码展示
nameOneSet = set(["张三","李四","张三"]);
nameTwoSet = set(["赵六","李四","马飞飞"]);
#set做交集
print(nameOneSet & nameTwoSet);
print("---------------------");
#set做并集
print(nameOneSet | nameTwoSet);
输出结果:
{'李四'}
---------------------
{'赵六', '马飞飞', '张三', '李四'}
内置函数
#代码展示
#常用内置函数
#绝对值
print(abs(100));
print(abs(-30));
#最大值
print(max(100,200,300,400,500));
#数据类型转换
print(int("123"));
print(float("12.34"));
print(str("1.34"));
print(bool(1));
print(bool(0));
print(bool(''));
输出结果:
100
30
500
123
12.34
1.34
True
False
False
自定义函数
| 要素名称 | 作用描述 |
|---|
| 函数声明：def关键字 | 使用def关键字创建函数，是函数定义的起始标识，用于告知Python解释器此处为函数定义。 |
| 函数名 | 紧跟def关键字的名称，需符合Python命名规范，用于后续通过函数名调用函数，是函数的唯一标识。 |
| 参数列表 | 函数名后括号内可定义零个或多个参数，用于接收外部传递给函数的值，实现数据输入，是传递数据的入口。 |
| 函数体 | 由冒号后缩进的代码组成，包含执行特定任务的语句，是函数功能实现的核心部分。 |
| 返回值 | 通过return语句返回值给调用者，若无return语句，函数隐式返回None，用于传递函数执行结果。 |
#定义自定义函数
def showModd(name):
return name+"心情贼差劲";
print(showModd("大马猴"));
print("---------");
#如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return;
def noneReturn():
return;
print(noneReturn());
print("---------");
#定义一个空函数，实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个
pass，让代码能运行起来。
def nop():
pass;
print(nop());
输出结果:
大马猴心情贼差劲
---------
None
---------
None
def cut(name,age):
print(f'我的名字叫{name},年龄{age}')
#关键字传参
cut(name='张三',age=18)
cut(age=28,name='李四')
isinstance类型判断函数
num = "123";
if not isinstance(num,(int,float)):
print("num类型不属于int或float");
else:
print("num类型属于int或float");
输出结果：
num类型不属于int或float
自定义函数-返回多个值
def mostParam():
return "张三",123,["李四","王五"];
x,y,z = mostParam();
print(x);
print(y);
print(z);
print("----------");
print(mostParam());
print(mostParam()[0]);
print(mostParam()[1]);
输出结果:
张三
123
['李四', '王五']
----------
('张三', 123, ['李四', '王五'])
张三
123
注意:Python函数返回的仍然是单一值，这种多参数的返回，其实是返回一个tuple类型，按位置赋给对应的值。
定义函数-默认参数
#定义函数 y默认值为3
def defaultParam(x,y=3):
return x * y;
#defaultParam(2),未传入参数y,将会使用默认值。
print(defaultParam(2));
print("--------------");
print(defaultParam(2,3));
#指定参数名称传递默认参数
def defaultMoreParam(name,age=18,city="北京",sex="男"):
print("姓名:"+name+",年龄:"+str(age)+",城市:"+city+",性别:"+sex);
#city使用传递的值，age,sex使用默认值 (这种通过参数名指定的方式，不用考虑默认参数的位置)
defaultMoreParam("张三",city='西安');
输出结果:
6
--------------
6
姓名:张三,年龄:18,城市:西安,性别:男
def defaultParam(list = []):
list.append("end");
return list;
print(defaultParam([1,2,3]));
print("-------------------");
#注意：因为默认参数list也是一个变量，它指向对象[]，每次调用该函数，如果改变了list的内容，则下次
调用时，默认参数的内容就变了，不再是函数定义时的[]了。
print(defaultParam());
print(defaultParam());
print(defaultParam());
输出结果:
[1, 2, 3, 'end']
-------------------
['end']
['end', 'end']
['end', 'end', 'end']
Process finished with exit code 0
修正-----------------------------------------
用None这个不变对象来实现
#定义函数 y默认值为3
def defaultParam(list = None):
if list is None:
list = [];
list.append("end");
return list;
print(defaultParam([1,2,3]));
print("-------------------");
print(defaultParam());
print(defaultParam());
print(defaultParam());
输出结果:
[1, 2, 3, 'end']
-------------------
['end']
['end']
['end']
Process finished with exit code 0
定义函数-可变参数
def dynamicVariable(*numbers):
for num in numbers:
print("num的值:"+str(num));
return;
#调用
dynamicVariable(1,2,3,4,"张三","李四");
print("--------------");
#如果已经有一个list或者tuple，要调用一个可变参数,在list或tuple前面加一个*号，把list或tuple的元
素变成可变参数传进去。
numList = [100,200,300];
dynamicVariable(*numList);
print("--------------");
#没有加*相当于单个参数
dynamicVariable(numList);
输出结果:
num的值:1
num的值:2
num的值:3
num的值:4
num的值:张三
num的值:李四
--------------
num的值:100
num的值:200
num的值:300
--------------
num的值:[100, 200, 300]
`**kwargs`可变字典参数
def print_key_value(**kwargs):
for key, value in kwargs.items():
print(key, value)
print_key_value(name="张三",age=20,city="纽约")
print("-------------------------------------")
def print_kv(**kv):
for key, value in kv.items():
print(key, value)
print_kv(name="李四", age=18, city="北京")
定义函数-关键字参数
1.关键字参数允许你传入0个或任意个参数名的参数，这些关键字参数在函数内部会自动组装为一个dict。
def dictParam(name,age,**key):
print("name:",name,"age:",str(age),"key",key);
return ;
dictParam("张三",18);
print("----------");
dictParam("李四",28,city="西安");
print("----------");
dictParam("李四",28,city="北京",hobby="篮球,跑步");
print("----------");
dictMap = {"city":"上海"};
dictParam("李四",28,city=dictMap.get("city"));
print("----------");
dictMapTwo = {"city":"成都","drinks":"小酒"};
dictParam("李四",28,**dictMapTwo);
输出结果:
name: 张三 age: 18 key {}
----------
name: 李四 age: 28 key {'city': '西安'}
----------
name: 李四 age: 28 key {'city': '北京', 'hobby': '篮球,跑步'}
----------
name: 李四 age: 28 key {'city': '上海'}
----------
name: 李四 age: 28 key {'city': '成都', 'drinks': '小酒'}
注意:最后一个案例，**dictMapTwo表示把dictMapTwo这个dict的所有key-value用关键字参数传入到函数
的**key参数，key将获得一个dict，注意key获得的dict是dictMapTwo的一份拷贝，对key的改动不会影响
到函数外的dictMapTwo。
函数作用域
1. 作用域核心概念
作用域指的是变量、函数等标识符在代码里的可访问范围，是代码维护和操作的基础，直接决定了标识符在程序里的可见区域。
1. Python作用域的主要类型
Python的作用域分为两类，二者变量可见性界限清晰：
- 全局作用域：在整个.py文件内都可访问
- 局部作用域：仅在函数内部可访问。
函数三种特殊使用方式
global关键字
1.在函数内部声明变量为全局变量，突破局部作用域限制。
def func():
global name
name='张三'
func()
print(f'我的名字是{name}')
2.允许在函数内部修改全局变量的值
number=0
def func():
global number
number=number+1
func()
print(number)
lambda匿名函数
#语法 lambda 参数列表：表达式
add = lambda x, y: x + y
result = add(1, 2)
print(result)
print('----------------')
#使用匿名函数作为参数传递
def apply(f,a, b):
return f(a,b)
result = apply(lambda x,y: x*y,4,5)
print(result)
Map函数
基础语法：`map(函数, 序列)`
功能：将指定的函数依次作用于序列（如列表、元组、字符串等）中的每个元素，返回一个包含所有元素处理结果的迭代器。
使用注意：`map()`直接返回迭代器，若要获取列表形式的结果，需要通过`list()`将其转换，示例代码：
filter函数
reduce()函数
文件操作
#read读文件 read()一次性读取 readline()按行读取 readlines() 一次性读取，返回的数据类型是列表
file = open('1.txt','r',encoding='utf-8')
print(file.read())
file.close()
print('-------------------------------')
#升级语法 自动关闭文件
with open('1.txt','r',encoding='utf-8') as f:
print(f.read())
print('-------------------------------')
#注意: w模式 文件不存在会新建文件。文件存在写入内容会覆盖原有内容
with open('2.txt','w',encoding='utf-8') as f:
f.write('你好')
with open('2.txt','r',encoding='utf-8') as f:
print(f.read())
print('-------------------------------')
#注意 a模式 文件不存在会新建文件。文件存在新内容追加
with open('2.txt','a',encoding='utf-8') as f:
f.write('世界')
with open('2.txt','r',encoding='utf-8') as f:
print(f.read())
#读取二进制文件内容 rb wb ab
with open('2.txt','rb') as f:
print(f.read())
模块使用
Python四个常用内置模块
- os模块：操作系统交互工具
用于实现Python程序与系统环境的便捷交互，核心功能为文件与目录操作：
- `os.listdir(".")`：可列出当前目录下所有文件和文件夹
- `os.mkdir('new_folder')`：用于创建新的文件夹
- math模块：数学计算核心库
涵盖各类基础数学运算工具，满足日常数学计算需求：
- `math.sqrt(16)`：计算平方根，结果为4.0
- `math.pow(2,3)`：完成幂运算，结果为8.0
此外还包含三角函数、对数函数等更多数学工具
- random模块：随机数生成器
具备随机数生成与序列元素选择功能，适用于抽奖、随机抽样等场景：
- `random.randint(1, 10)`：可生成1到10之间的随机整数
- time模块：时间控制工具
提供时间相关函数，助力程序的时间管理与延时操作：
- `time.sleep(3)`：使程序暂停3秒
- `time.time()`：输出当前时间戳。
Python的4种模块导入方式，具体说明如下：
整体导入
- 语法：`import 模块名`
- 用法：导入整个模块，需通过`模块名.功能名`调用，比如`import os`后，用`os.listdir(".")`调用函数
- 优点：模块功能完整保留，避免命名冲突
精准导入
- 语法：`from 模块名 import 功能名`
- 用法：仅导入指定函数或变量，可直接使用功能名，比如`from math import sqrt`后，直接调用`sqrt(16)`
- 优点：简化代码书写，提高执行效率
全部导入（不推荐）
- 语法：`from 模块名 import *`
- 用法：导入模块所有内容，可直接使用所有函数/变量
- 缺点：易引发命名冲突，不同模块同名函数会被覆盖，通常不建议采用
别名简化调用
- 语法：`import 模块名 as 别名`
- 用法：为模块指定简短别名，比如`import random as rd`后，用`rd.randint(1,10)`调用
- 优点：减少重复输入，提升代码简洁度。
导入自定义模块
Python第三方模块的安装指南：
一、安装前提：调出命令行窗口
通过快捷键`Win+R`调出运行窗口，输入`cmd`并回车，即可打开命令行界面，用于执行后续安装命令。
二、基础安装命令
使用`pip install 第三方模块名`命令即可安装模块，例如安装NumPy模块的命令为：
pip install numpy
三、换源安装方法
通过`pip install 第三方模块名 -i 镜像地址`的方式可以提升安装速度，推荐使用清华源，示例命令（以安装pandas为例）：
pip install pandas -i https:
包
Python包的三部分核心内容整理：
1. 包的核心概念
Python包（Package）是通过文件夹形式整合相关模块的代码管理方式，能实现代码的模块化
与结构化管理，让代码更清晰易维护。
2. 包的关键标识
包本质是包含`__init__.py`文件的文件夹，这个文件可以为空，但它是判定一个文件夹为
Python包的必要条件。
3. 包的组成内容
包可以包含多个`.py`格式的模块文件，还能嵌套包含子包（即同样带有`__init__.py`的子
文件夹），以此形成层级化的代码组织体系。
导入包里面模块
使用_init_.py导入
面向对象
- 类的本质：是创建对象的模板，包含对象的共同特征与行为，能直接复用，就像思维导图模板的固定样式。
- 属性：是类的共同特征，属于类中的变量，用来描述对象的静态特征，比如物品的名称、颜色等。
- 方法：是类的共同行为，属于类中的函数，用来定义对象的动态操作，比如动物的奔跑、叫唤等行为。
- 封装特性：属性和方法被整合封装在类内部，对象创建后可直接调用，实现了数据与操作的有机结合，能提升代码的易用性。
1. 类的定义
使用`class`关键字来定义类，类是对象的模板，内部可以包含类属性（类变量，比如`class_variable`）和
方法（函数，比如`method_name`）。
2. 对象的创建
通过`类名+括号`的方式创建对象，格式为`object_name = ClassName()`，括号里可以传入构造函数需要的
参数。
3. 对象属性与方法的访问
使用点操作符来访问，比如`print(object_name.instance_variable)`可以获取对象属性，
`object_name.method_name()`可以调用对象方法。
1. 方法的定义
方法是类里定义的特殊函数，用来描述对象的行为，第一个参数必须是`self`，它代表调用该方法的对象本身。
3. self参数的核心作用
`self`会自动传入调用方法的对象，相当于“房子的钥匙”，能让方法访问该对象的属性和其他方法，确保对象
只操作自身的数据。
3. 方法的调用方式
通过`对象名.方法名()`来调用，不需要手动传递`self`参数，Python解释器会自动把调用方法的对象作为
`self`传入。
`__init__`方法的作用解析
- 属性初始化：它是Python内置的特殊方法，在创建类的实例对象时自动执行，用来给对象的属性设置初始值，
确保实例化后对象就具备预设的属性，无需后续再单独初始化。
- 封装属性：通过`__init__`在类内部统一定义属性，能避免在类外部零散设置属性，让类的结构更完整，实现
数据与逻辑的统一，提升代码的可维护性和整体性。
继承
- 继承的定义：在Python面向对象编程里，继承是允许一个类（子类）继承另一个类（父类）的属性和方法的机
制，子类可自动获取父类特性，并能按需扩展或修改。
- 继承的本质：实现代码的层级化组织与复用，通过建立类之间的父子关系，让子类在父类基础上构建，避免重
复编码，体现面向对象编程的核心思想。
- 继承的核心地位：作为面向对象编程的核心概念，继承是实现代码重用、增强可维护性和可扩展性的基础，也
是构建复杂类体系结构的关键手段。
多层继承
多层继承是单继承的延伸，指子类继承自父类，而父类本身又继承自更高层级的祖父类，形成超过两个类的链式继承
关系，本质仍属于`单继承范畴`。
多继承
1.多继承是面向对象编程里的一种继承方式，允许一个子类同时继承多个父类，以此获取所有父类的属性和方法，实现
代码的多重复用。
2.多继承中父类的书写顺序会影响方法调用优先级，当多个父类存在同名方法时，子类对象会优先调用排在前面的父类中的方法。
方法重写是面向对象编程里的核心机制：
- 概念：指子类中定义与父类同名的方法，以此覆盖父类原有方法实现的机制。
- 核心作用：为子类提供专属的方法实现，满足个性化需求，同时增强代码的灵活性与扩展性。
- 调用优先级：当子类与父类存在同名方法时，创建子类对象调用该方法，会优先执行子类中的重写方法。
正则表达式
正则表达式是一种文本处理工具，依靠预定义的字符和语法规则，能精准完成字符串的匹配、查找
和提取操作。在文本处理场景中，它可以高效解决复杂匹配问题，比如数据提取、格式验证、内容
替换等，是编程、数据分析、爬虫开发等领域的基础技能。
Python内置的`re`模块是处理正则表达式的标准库，核心功能、应用场景及学习价值如下：
- 核心功能
提供正则表达式的完整支持，涵盖模式编译、匹配、搜索、替换等核心操作，能高效完成文本
的模式匹配与处理。
- 在爬虫中的应用
是爬虫数据解析的关键工具，可从网页源代码中精准匹配提取结构化数据，比如数字、链接、
特定标签内的内容等。
1.`re.match()`函数
尝试从字符串的起始位置匹配正则表达式，仅当起始位置匹配成功时返回匹配对象，否则返回
`None`。
2.`search()`函数
它会扫描整个字符串，返回第一个成功匹配的匹配对象；如果没有匹配内容，就返回`None`。
3.`findall()`函数
会扫描整个字符串，返回所有匹配正则表达式的字符串组成的列表；如果没有匹配项，返回空列表
`[]`，不会引发错误。
装饰器
1. 外部装饰器函数
以被装饰的函数作为参数，比如`def decorator(fn)`里的`fn`，它保存着需要被扩展功能的原函数对象，构
成了装饰器的外层结构，负责接收要装饰的目标函数。
2. 内部函数
负责实现额外的功能，在执行原函数的前后可以插入自定义代码，比如在原函数执行前打印"hello"、执行后打
印"world"，以此来扩展原函数的行为，同时内部函数会调用原函数，保证原功能不被覆盖。
3. 外部函数返回内部函数
外部函数返回内部函数的名称（注意不是调用内部函数），这样被装饰的函数就会指向内部函数，当调用被装
饰函数时，就会自动触发装饰逻辑，完成对原函数的功能封装。
简单来说，装饰器就是通过这种嵌套函数的结构，在不修改原函数代码的前提下，给原函数添加新的功能，是
Python里实现代码复用和功能扩展的常用技巧。
异常机制
1. try模块
- 作用：包裹可能引发错误的代码，比如文件读写、网络请求、数值计算等存在风险的操作
2. except模块
- 作用：当try模块里的代码抛出指定类型的异常时，会执行这里的代码，用于捕获并处理错误
3. else模块
- 作用：可选模块，只有当try模块的代码**没有发生任何异常**时，才会执行这里的代码
4. finally模块
- 作用：无论try模块是否发生异常，这段代码都会被执行，常用于释放资源、关闭连接等收尾操作
### 抛出异常的基本语法
抛出异常的核心语句是`raise`，完整语法为：
`raise ExceptionType(message)`
- ExceptionType：指定异常类型，既可以是Python内置异常（如`ValueError`、`TypeError`），也可以是自
定义异常类
- message：可选参数，为字符串类型，用于清晰描述异常发生的原因，方便排查问题
