4 万字【Python 高级编程】保姆式教学，330 页 PDF10 万字的知识点总结
包名.模块名.功能
举例：创建 1 个包，在另一个.py 文件中使用，要求.py 文件不包含在创建的包内。
步骤 1，打开 Pycharm 新建一个项目，创建 1 个包，命名为 demo，包里面新建 1 个.py 文件，命名为 my_module，代码如下：
a = 100
def fun1():
print("这是 1 个包")
步骤 2，打开另 1 个.py 文件，导入已创建的包
import demo.my_module
print(demo.my_module.a)
demo.my_module.fun1()
执行结果：
100
这是 1 个包
使用形式 2：常规使用 2
from 包名 import 模块名
模块名.功能
模块名.变量
举例：我沿用上面已经创建好的 demo 包，直接在步骤 2 中修改代码，用这个新方式去导入包并使用。
from demo import my_module
print(my_module.a)
my_module.fun1()
执行结果是一样的：
100
这是 1 个包
使用形式 3：另起别名并使用
import 包名.模块名 as 别名
别名.功能
别名.变量
上面使用形式 1 中可能有人会发现，导入模块后的使用不太方便，又要包名又要模块名的，能不能简单点？当然可以，直接给包里的模块另起 1 个缩短的别名，后面直接用别名就可以了。
沿用上面的使用形式 1 的例子，这里我就不改动步骤 1 了，我直接在步骤 2 中进行另起别名。
import demo.my_module as n1 #另起别名为 n1
print(n1.a)
n1.fun1()
执行结果：
100
这是 1 个包
结果是一样的，但如果代码比较长的话，使用别名会方便很多。
当然了，这里也可以用使用形式 2 的方式导入包并另起别名，使用时用别名就可以了，这个方式我就不举例了，你们自己可以去试试。
使用方式 4：导入某个功能
from 包名.模块名 import 功能 1
功能 1
这里我也沿用已创建好的包，直接在另一个.py 文件中进行使用。
from demo.my_module import fun1
fun1()
执行结果：
这是 1 个包
使用方式 5：导入所有功能
在模块导入的时候我们介绍了 import * 这个方式去导入模块里面的所有功能，在这里也可以这么入导入包里面的模块的所有功能。
举例，名叫“demo”包里面有 1 个模块叫“hhhh”，模块的代码如下：
def fun1():
print("这是功能 1")
def fun2():
print("这是功能 2")
然后我们在另一个.py 文件中调用一下;
from demo.hhhh import *
fun1()
fun2()
执行结果:
这是功能 1
这是功能 2
6.关于 all 的使用
关于__all__的使用在模块的时候有介绍过，那是控制可以被导入的功能列表，但在包里面，__all__是控制可以被导入的模块列表，即声明哪些模块可以被导入。
包里面的__all__是在__init__文件中声明的，而不是在哪个模块中写的。
举例：一个包里面有多个模块，其中被 all 声明的模块可以被导入，不声明的不可以被导入。
步骤 1，在名为 demo 的包里面有 hhhh 和 my_module 两个模块，但在 int 文件中被 all 声明只有 hhhh 文件可以使用，int 文件的代码如下：
all = [
"hhhh" # hhhh 模块允许被导入
]
步骤 2，在新的.py 文件中导入 demo 包里面的 hhhh 和 my_module 两个模块：
from demo import * #导入包里面的所有模块
hhhh.fun1() #调用 hhhh 模块的 fun1 功能，输出“这是功能 1”
my_module.fun1() #调用 my_module 模块的 fun1 功能，输出“这是 1 个包”
执行结果：
很明显，虽然用 * 导入了所有模块，但被 all 声明可导入的 hhhh 模块是可以被使用的，没被 all 声明的 my_module 模块是不能使用的，系统无法识别。
1.提高代码的可重用性。好用的代码不止你 1 个人可以用，很多人都可以重复使用它。
2.提高代码的可读性。如果所有的代码都放在 1 个.py 文件中，那代码就太长了，增加了理解和维护难度，所以可以把一些常用的代码封装成包和模块，起 1 个望文生义的名字，需要的时候直接用就行，减少了代码的数量，提高了可读性。
3.减少代码的冗余。模块里面封装的一些方法，我们直接给参数去使用就可以了，不用把方法再写一遍，占用内存，也就减少了代码的冗余。
Python 虽然有很多自带的模块和包，简称内置模块，但只会使用内置模块还不够，毕竟内置模块有限，我们经常会用到第三方的库，这个时候学习怎么安装第三方的库（包）是很必要的。
今天来介绍 3 种第三方模块与包的安装方法。
1.通过 pip 安装
可以通过包管理命令 pip 去进行第三模块与包的下载和安装，前提是你安装的 Python 是照着我前面在【Python 基础入门】那篇文章所讲的方式去安装，所有的选项都勾选了，这样你就不用配置环境变量了，首先查看一下你的 pip 是否能用。
方法：WIN+R 调出运行窗口→输入 cmd→如果出现下面的 pip 信息则是可以使用 pip
如果出现红字提示“cmd 中 ’pip‘不是内部或外部命令，也不是可运行的程序或批处理文件”，那么你就手动配置一下环境变量吧，实在不行就回过头跟着我说的安装 Python 的步骤去重新装吧。
回到 pip 如何安装第三方模块与包的问题，首先我们得知道我们要安装的第三方模块与包是叫什么名字，比如 Pillow 这个第三方库，这是 Python 下非常强大的处理图像的工具库，安装方法是：
1.WIN+R 调出运行窗口
2.输入 cmd
3.输入 pip install Pillow
4.等待下载和安装的完成
有时候会出现很多红字提示下载失败，这个很正常，原因可能是：
（1）.pip 版本过低，升级一下 pip 版本，在黑窗口输入：python -m pip install -U pip
（2）网络不好，多下载几遍就可以了
2.通过 Pycharm 安装
通过 pip 安装是不需要打开软件的，但我们也可以通过 Pycharm 进行安装，方法如下：
点击左上角的 File → Settings → Project:项目名 → Python interpreter → 点击 + →
输入你想安装的包名，选择你看上的 → 点击 Install Package → 等待下载和安装
3.通过渠道下载.whl 文件安装
可以通过官网等渠道去搜索和下载你想要的包，官网：https://pypi.org/ ，搜索你要下载的第三方库，比如说 Pillow 这个库，直接搜就可以了：
然后选择你要下载的文件，比如 Pillow8.3.2 这个版本，进入下载页面，点击 Download files。
进去之后有很多的版本型号，建议选择与你符合的版本，否则可能装不了，这里要注意 Python 版本、系统和电脑的位数。
比如说我的 Python 装的是 3.9.6 的，所以我下的是 cp39 里面的，电脑是 64 位,用的是 Windows 系统，所以我下的版本是 Pillow-8.3.2-cp39-cp39-win_amd64.whl 这个文件。
下载好之后，WIN+R 打开命令行输入 CMD，在黑窗口中输入 pip install 文件路径下的文件名，比如我下载后存放的路径是 D:\谷歌浏览器，所以我在黑窗口输入的代码是：
pip install D:\谷歌浏览器\Pillow-8.3.2-cp39-cp39-win_amd64.whl
然后回车进行安装，等待安装完成。
================================================================
计算机中的文件通常是指计算机硬盘为载体的、存储在计算机中的信息集合，主要的表现形式为视频、音频、图片以及文档四类，比如执行性文件.exe、文档文件.txt、网页文件.html 等等。
在现实中，我们对文件进行操作可以大致总结为“打开→操作（阅读、删除、修改等）→保存→关闭”，在 Python 当中依然是如此，在用 Python 开始文件操作之前，我们先学几个方法。
1.open(name,mode) ----打开文件
这是 Python 打开文件的方法，用于打开一个文件，返回的是一个文件对象。
name 指的是文件名，一定要写全，何为写全？就是要写清楚 存储路径+文件名+后缀 。
为何要写这么全？因为就算是相同的存储路径下，文件名相同的文件也可能不止一个，只要后缀不一样，计算机是允许存在同名文件,所以不写全的话，计算机是不知道你指的是谁
mode 是打开文件的模式，默认是 r，也就是只读的方式。mode 的方式有很多，比如读、写等等，后面我们会讲到。
2.write(“内容") ------写
顾名思义，就是向文件对象中写入内容。
3.read() -------读
向文件中写入内容，括号里面可以写数字也可以不写，不写的话默认是读取全部内容，写数字则表示读取 X 个字符，比如说 read(6)则读取文件对象的 6 个字符。
4.close() ------关闭文件
关闭文件的方法，如果你在进行文件操作之后不进行关闭文件，则文件一直处于打开和操作的状态，会占用内存。
5.案例
在了解了这 4 个基本方法之后，我们来开始做 1 个小案例：新建一个项目，然后新建一个名为“文件”的 Python 文件用于写代码，然后我们用写的方式向 1 个叫“文件 1”的.txt 文件写入“hello world”，代码如下：
f = open("文件一.txt",'w') #以写入的方式，打开文件
f.write("hello world") #向文件一中写入内容
f.close() #关闭文件
前面讲过 open() 这个方法返回的是一个文件对象，所以我们用 f 进行接收一下，这是没有运行前的界面：
运行后：
运行后生成了一个新的名为“文件一.txt”文件，打开它之后就能看到我们输入的内容。进行写操作时，如果文件不存在，则默认会创建一个。
同样的，我们也可以对这个文件进行读的操作：
f = open("文件一.txt",'r') #以写入的方式，打开文件
print(f.read()) #读文件
f.close() #关闭文件
运行结果：
hello world
这就是一个最基本的文件操作流程。
在这里要注意一点，open(name,mode)在一开始写的时候，mode 就已经决定了你能做什么操作，也就是说如果你在开始写代码的时候写的是：
f = open("文件一.txt",'r') #只读的方式打开文件
那么后面你想进行 write()的写操作是会报错的，因为 mode 里面声明了 r 只读模式，所以你没有写的权限，这一点要注意一下。
6.mode 的其他操作模式
mode 中有很多的操作模式，我们以表格的方式来看看：
| 模式 | 描述 |
| --- | --- |
| r | 以只读的形式打开文件，文件的指针在开头 |
| r+ | 读写，文件指针在开头 |
| rb | 以二进制的形式，只读文件指针在开头 |
| w | 只写，文件不存在，则创建新的，存在则覆盖，指针在开头 |
| w+ | 读写，文件不存在，则创建新的，存在则覆盖，指针在开头 |
| wb | 只写，以二进制的形式 |
| a | 追加模式，文件指针在结尾 |
| a+ | 读写，不存在则创建，存在直接追加 |
| ab | 以二进制形式追加 |
指针在这里可以理解为光标，它在哪里，你的操作就从哪里开始。
举例：新建 1 个名为 “test” 的.txt 文件，第一次向里面写入 aaa，第二次向里面写入 bbb。
f = open("test.txt", 'a+')
f.write("aaa")
f.close()
f = open("test.txt") # 默认只读模式
print(f.read()) # 打印内容
f = open("test.txt", 'a+')
f.write("bbb")
f.close()
f = open("test.txt") # 默认只读模式
print(f.read()) # 再次打印内容
运行结果：
aaa
aaabbb
1.file 的对象属性
有三个常用的方法可用于查看文件对象的属性：
closed
如果文件对象已关闭，返回 True，否则返回 False
mode
返回文件对象的访问模式
name
返回文件的名称
案例：对文件进行操作（随意），查看被操作的文件名、操作模式和是否关闭。
f = open("test.txt", 'a+')
f.write("aaa")
f.close()
print(f.closed) #查看是否关闭
print(f.name) #查看文件名字
print(f.mode) #查看操作模式
运行结果：
True
test.txt
a+
2.file 的对象方法
文件的方法有很多，前面我们已经讲过一点，比如 read()和 write()，但还有一些常用的方法需要掌握的，比如下面的：
close()
关闭文件---非常重要
read([count])
读取文件中的内容
count：字节数量
readlines()
读取所有内容，打包成列表
readline()
读取一行数据，追加读取，读取过的不能再次读取
seek（offset，[from]）
修改指针的位置：从 from 位置移动了 offset 个字节
from：0 则表示从起始位置，1 则表示从当前位置开始，2 则表示从末尾开始
oofset：要移动的字节数
write()
向文件中写入内容
举例：向 test.txt 文件中写入 aaabbbccc，将文件中的内容输出为列表。
f = open("test.txt", 'a+')
f.write("aaabbbccc")
f.close()
f = open("test.txt")
print(f.readlines())
f.close()
运行结果：
['aaabbbcccaaabbbccc']
os 模块是一个用于访问操作系统的模块，在进行文件操作的时候常会用到它。模块在使用之前要进行导入。
import os
1.关于文件的功能
1.os.rename(原文件名，新的文件名) ——文件重命名
2.os.remove(文件名) ——删除文件
如果不说明路径，则在源代码所在文件夹下寻找，寻找不到会报错。
若想删除指定文件夹下的文件，文件名则需要具体路径，例如 os.remove(r"D:\test_1\文件名"),r 防止斜杠发生转义
举例：已有文件 test1.txt，将其修改成 test20.txt。
import os
os.rename("test1.txt","test20.txt")
运行结果：
2.文件夹的功能
1.os.mkdir(文件夹名) ——创建文件夹
2.os.rmdir(文件夹名) ——删除文件夹
3.os.getced() ——获取当前目录
4.os.chdir(目录) ——切换目录
5.os.listdir(目录) ——获取当前文件夹下所有的文件或者文件夹，返回一个列表
os.listdir("aa") #获取 aa 文件夹下的所有文件或文件夹，返回一个列表
举例：在现有文件夹 venv 里面新建一个新建文件夹。
import os
os.chdir(r"D:\文件\venv") #切换到 venv 文件夹下,r 是防止转义
os.mkdir("新建文件夹") #在 venv 文件夹下创建一个新建文件夹
print(os.getcwd()) #输出当前目录位置
运行结果：
==============================================================
异常是一个事件，该事件在程序执行过程中发生，影响程序的正常执行。一般情况下，Python 无法正常处理程序时就会发生一个异常。
例如我在代码中只写了一个变量 a，运行程序，pycharm 无法识别这个变量，所以报错，便是出现了异常。
所以我们需要掌握处理异常的方法，处理异常的方法有很多种，接下来我们一个个来看。
1.try-except
它能够将可能出错的代码进行处理，处理后报错的红色字体将会转换成简短的、正常的字体，用法如下：
try:
有可能出现异常的代码
except 异常类型 as 变量
处理后的代码
举例：直接打印变量 a 会报错。
经过 tyr-except 处理过一下：
try:
print(a)
except NameError as s:
print(s)
再次运行看效果：
飘红的报错信息变得简短且颜色正常，看起来这个异常是不是显得舒服多了？
这里的 tyr-except 并不影响代码的运行，如果你的代码没有报错，你就算是写了 tyr-except，它也只会执行 try 那行代码，那行代码没有错误，那就不会执行 except 里面的代码。
例如我们来一个正常的：
2.try-except-except
这种方法和前面的 try-except 写法是差不多的，只是后面再增加了一个 except，可用于判断多种可能报错的情况。
例如：有两行代码可能会报错，两种不同类型的异常，但不想让它飘红。
try:
1 / 0
print(a)
except NameError as s: # 第一种写法，用 as+变量
print(s)
except ZeroDivisionError: # 第二种写法，自定义输出内容
print("除数不能为 0") # 自定义输出的内容
运行结果：
虽然报错，但没有飘红，这里注意一下 except 的两种写法。
try-except 的写法很灵活的，我们同样可以用元组把可能报错的异常类型囊括进去，避免写多行 except，例如：
3.try-except-else
如果没有异常，则执行 else 里面的代码，例如：
4.try-except-finally
不管代码是否有异常，最后都会执行 finally 里面的代码。例如：
5.顶层类 Exception
except 后面其实可以不加错误类型，因为系统会默认认为后面的错误是类型是 Exception，这是 1 个顶层类，包含了所有的出错类型。
有没有发现，前面我们去做基本的异常捕获时，每次可能出错的地方就得写一个 try-except，如果有多个地方可能会出错呢？是否我们需要写多个 try-except？又或者理论上代码可以运行，但我想定一下规矩，凡是不符合我规矩的行为，我都让它出现异常，比如密码长度超出我规定的长度，我想让程序出现异常。
自定义异常可用于引发一个异常（抛出一个异常），由关键字 raise 引发。
举例：模拟用户输入密码的情景，用户输入的密码不能低于 6 位数，自定义一个异常，用于检测用户输入的密码是否符合规定，不符合则引发异常，提示当前输入的密码长度和最小密码长度不能低于 6 位数。
class MyError(Exception): # 异常捕获的类
def init(self, length, min_len): # length 为用户输入的密码长度，min_len 为规定的最小长度
self.length = length
self.min_len = min_len
设置抛出异常的描述信息
def str(self):
return "你输入的长度是 %s,不能少于 %s" % (self.length, self.min_len)
def main():
try:
con = input("请输入密码：") # 获取用户输入的密码
l = len(con) # 获取用户输入的密码长度
if l < 6:
raise MyError(l, 6) # 长度低于设定的 6 位数则引发异常
except Exception as ss: # 有错误则提示
print(ss)
else:
print("您的密码输入完毕") # 没有错误则执行
main()
运行结果：
从上面的代码中我们又用到了之前面向对象板块里面的类和实例对象的知识，忘记的赶紧去复习吧，除此之外，这里还结合了前面的 try-except，还有我们的关键字 raise 引起异常捕获。
=================================================================
在讲正则表达式之前，我们首先得知道哪里用得到正则表达式。正则表达式是用在 findall()方法当中，大多数的字符串检索都可以通过 findall()来完成。
1.导入 re 模块
在使用正则表达式之前，需要导入 re 模块。
import re
2.findall（）的语法：
导入了 re 模块之后就可以使用 findall（）方法了，那么我们必须要清楚 findall（）的语法是怎么规定的。
findall(正则表达式，目标字符串)
不难看出 findall（）的是由正则表达式和目标字符串组成，目标字符串就是你要检索的东西，那么如何检索则是通过正则表达式来进行操作，也就是我们今天的重点。
使用 findall（）之后返回的结果是一个列表，列表中是符合正则要求的字符串
1.字符串的匹配
（1）普通字符
大多数的字母和字符都可以进行自身匹配。
import re
a = "abc123+-*"
b = re.findall('abc',a)
print(b)
输出结果：
['abc']
（2）元字符
元字符指的是. ^ $ ? + {} \ []之类的特殊字符，通过它们我们可以对目标字符串进行个性化检索，返回我们要的结果。
这里我给大家介绍 10 个常用的元字符以及它们的用法，这里我先给大家做 1 个简单的汇总，便于记忆，下面会挨个讲解每一个元字符的使用。
** 1?? []**
[] 的使用方式主要有以下三种：
常用来指定一个字符集。
s = "a123456b"
rule = "a[0-9][1-6][1-6][1-6][1-6][1-6]b" #这里暂时先用这种麻烦点的方法，后面有更容易的，不用敲这么多[1-6]
l = re.findall(rule,s)
print(l)
输出结果为：
['a123456b']
可以表示一个范围。
例如要在字符串"abcabcaccaac"中选出 abc 元素：
s = "abcabcaccaac"
rule = "a[a,b,c]c" # rule = "a[a-z0-9][a-z0-9][a-z0-9][a-z0-9]c"
l = re.findall(rule, s)
print(l)
输出结果为：
['abc', 'abc', 'acc', 'aac']
[] 内的元字符不起作用，只表示普通字符。
例如要在字符串“caabcabcaabc”中选出“caa”：
print(re.findall("caa[a，^]", "caa^bcabcaabc"))
输出结果为：
['caa^']
注意点：当在[]的第一个位置时，表示除了 a 以外的都进行匹配，例如把[]中的和 a 换一下位置：
print(re.findall("caa[^,a]", "caa^bcabcaabc"))
输出：
['caa^', 'caab']
2??^
^ 通常用来匹配行首，例如：
print(re.findall("^abca", "abcabcabc"))
输出结果：
['abca']
3?? $
$ 通常用来匹配行尾，例如：
print(re.findall("abc$", "accabcabc"))
输出结果：
['abc']
4?? \
? 反斜杠后面可以加不同的字符表示不同的特殊含义，常见的有以下 3 种。
\d:匹配任何十进制数等价于[0-9]
print(re.findall("c\d\d\da", "abc123abc"))
输出结果为：
['c123a']
\可以转义成普通字符，例如：
print(re.findall("^abc", "^abc^abc"))
输出结果：
['^abc', '^abc']
5?? s
匹配任何的空白字符例如：
print(re.findall("\s\s", "a c"))
输出结果：
[' ', ' ']
6?? \w
匹配任何字母数字和下划线，等价于[a-zA-Z0-9_]，例如：
print(re.findall("\w\w\w", "abc12_"))
输出：
['abc', '12_']
7?? {n}
{n}可以避免重复写，比如前面我们用\w 时写了 3 次\w，而这里我们这需要用用上{n}就可以，n 表示匹配的次数，例如：
print(re.findall("\w{2}", "abc12_"))
输出结果：
['ab', 'c1', '2_']
8?? *
*表示匹配零次或多次（尽可能的多去匹配），例如：
print(re.findall("010-\d*", "010-123456789"))
输出：
['010-123456789']
9?? +
+表示匹配一次或多次，例如
print(re.findall("010-\d+", "010-123456789"))
输出：
['010-123456789']
?? .
.是个点，这里不是很明显，它用来操作除了换行符以外的任何字符，例如：
print(re.findall(".", "010\n?!"))
输出：
['0', '1', '0', '?', '!']
1?? 1?? ？
？表示匹配一次或零次
print(re.findall("010-\d?", "010-123456789"))
输出：
['010-1']
这里要注意一下贪婪模式和非贪婪模式。
贪婪模式：尽可能多的去匹配数据，表现为\d 后面加某个元字符，例如\d*：
print(re.findall("010-\d*", "010-123456789"))
输出：
['010-123456789']
非贪婪模式：尽可能少的去匹配数据，表现为\d 后面加？，例如\d?
print(re.findall("010-\d*?", "010-123456789"))
输出为：
['010-']
1??2??{m,n}
m,n 指的是十进制数,表示最少重复 m 次，最多重复 n 次，例如：
print(re.findall("010-\d{3,5}", "010-123456789"))
输出：
['010-12345']
加上？表示尽可能少的去匹配
print(re.findall("010-\d{3,5}?", "010-123456789"))
输出：
['010-123']
{m,n}还有其他的一些灵活的写法，比如：
{1,} 相当于前面提过的 + 的效果
{0，1} 相当于前面提过的 ？ 的效果
{0，} 相当于前面提过的 * 的效果
关于常用的元字符以及使用方法就先到这里，我们再来看看正则的其他知识。
1.编译正则
在 Python 中，re 模块可通过 compile() 方法来编译正则，re.compile(正则表达式),例如：
s = "010-123456789"
rule = "010-\d*"
rule_compile = re.compile(rule) #返回一个对象
print(rule_compile)
s_compile = rule_compile.findall(s)
print(s_compile) #打印 compile()返回的对象是什么
输出结果：
['010-123456789']
2.正则对象的使用方法
正则对象的使用方法不仅仅是通过我们前面所介绍的 findall() 来使用，还可以通过其他的方法进行使用，效果是不一样的，这里我做个简单的总结：
（1）findall()
找到 re 匹配的所有字符串，返回一个列表
（2）search()
扫描字符串，找到这个 re 匹配的位置（仅仅是第一个查到的）
（3）match()
决定 re 是否在字符串刚开始的位置（匹配行首）
就拿上面的 compile()编译正则之后返回的对象来做举例，我们这里不用 findall() ,用 match() 来看一下结果如何：
s = "010-123456789"
rule = "010-\d*"
rule_compile = re.compile(rule) # 返回一个对象
print(rule_compile)
s_compile = rule_compile.match(s)
print(s_compile) # 打印 compile()返回的对象是什么
输出：
<re.Match object; span=(0, 13), match='010-123456789'>
可以看出结果是 1 个 match 对象，开始下标位置为 0~13，match 为 010-123456789 。既然返回的是对象，那么接下来我们来讲讲这个 match 对象的一些操作方法。
3.Match object 的操作方法
这里先介绍一下方法，后面我再举例，Match 对象常见的使用方法有以下几个：
（1）group()
返回 re 匹配的字符串
（2）start()
返回匹配开始的位置
（3）end()
返回匹配结束的位置
（4）span()
返回一个元组：（开始,结束）的位置
举例：用 span()来对 search()返回的对象进行操作：
s = "010-123456789"
rule = "010-\d*"
rule_compile = re.compile(rule) # 返回一个对象
s_compile = rule_compile.match(s)
print(s_compile.span()) #用 span()处理返回的对象
结果为：
(0, 13)
4.re 模块的函数
re 模块中除了上面介绍的 findall()函数之外，还有其他的函数，来做一个介绍：
（1）findall()
根据正则表达式返回匹配到的所有字符串，这个我就不多说了，前面都是在介绍它。
（2）sub(正则,新字符串,原字符串)
sub() 函数的功能是替换字符串，例如：
s = "abcabcacc" #原字符串
l = re.sub("abc","ddd",s) #通过 sub()处理过的字符串
print(l)
输出：
ddddddacc #把 abc 全部替换成 ddd
(3)subn(正则,新字符串,原字符串)
subn()的作用是替换字符串，并返回替换的次数
s = "abcabcacc" #原字符串
l = re.subn("abc","ddd",s) #通过 sub()处理过的字符串
print(l)
输出：
('ddddddacc', 2)
（4）split()
split()分割字符串，例如：
s = "abcabcacc"
l = re.split("b",s)
print(l)
输出结果：
['a', 'ca', 'cacc']
================================================================
操作系统可以执行多个任务，比如我们的 Windows 系统，除了目前在执行的、你能看得到的几个任务，还有很多后台正在执行的任务，可以用 Ctrl+Alt+Del 键调出任务管理器看一下就知道了。
我的电脑配置经常会看到有几核处理器的属性，例如我的电脑是 12 核的，也就是说电脑最多能同时执行 12 个任务，最多运行 12 个进程同时进行。
但为什么我们的电脑却能够同时运行几百个任务呢？
其实这得益于于操作系统的任务调度，大部分的操作系统是采用抢占时间片的形式进行调度。系统在极其微小的时间内，在多个任务之间进行极快速的切换，比如说 8 核的操作系统理论上 1 秒钟之内只能同时执行 8 个任务，但是系统在 1 秒钟之内可能在上百个任务之间进行切换，A 任务执行一下、B 任务执行一下、C 任务执行一下…结果 1 秒钟之内很多任务都能被执行到，造成了肉眼可见的几百个任务在一直执行。
术语叫“宏观并行，微观串行”，实际上电脑在极端的时间内只能执行不超过配置核数的任务数，8 核还是只能执行 8 个任务。
1.何为进程？
既然讲到了任务，那么进程就是任务，1 个进程就相当于 1 个任务，是操作系统分配资源的最小单位。在 python 中，想要实现多任务可以使用进程来完成，进程是实现多任务的一种方式。
2.何为线程？
进程的多个子任务就称之为线程，线程是进程的最小执行单位， 一个进程可以有很多线程，每个线程执行的任务都不一样。
Python 既支持多进程又支持多线程，接下来我们就开始进入 Python 的进程与线程的学习。
?? （二）Python 的多进程 multiprocessing（包）
如果你利用多进程，你的 Python 代码是从头到尾逐行执行的，这其实就是在执行 1 个进程，这一点应该很好理解。
要想更多利用 CPU 资源，我们可以利用多进程，这里介绍一个 Python 多进程时常用的包 multiprocessing，它拥有很多的功能，比如子进程、通讯、共享、执行不同的形式等等,我们来了解一些常用的。
1.Process——进程类
Process 是 multiprocessing 里面的一个进程类，通过它就能实现多进程。我们先来看一下它的用法，后面我们会有实际的例子去讲述。
Process(target,name,args,kwargs)
target 是目标，在哪里新开进程让系统去执行？得给系统一个目标。
name 是进程的名字，你可以设置也可以不设置，默认是 Process-N，N 是从 1,2,3…N，系统默认从小到大取名。
args 和 kwargs 是参数，可用于传递到目标。
Process 里面有很多方法，其中最常用的就是 start（）启动进程的方法。
进程名.start() #开始进程
举例：写好的代码如下，我想看看开启和没开启多进程调用函数的效果。
import time
#2 个要同时执行的函数
def music() :
for i in range(5): #执行 5 次
print("听音乐中...")
time.sleep(0.2) #延迟 0.2s，目的是让效果对比更明显一些
def movie():
for i in range(5):
print("看视频中...")
time.sleep(0.2) #延迟 0.2s
music()
movie()
print("主进程执行完毕")
在没有开启多进程时，执行效果如下：
可以看到，这是很正常的运行情况，程序从上运行到下，逐行运行，music()里面的三次循环没有执行完毕就不会执行 movie（）里面，以及这两个函数如果没有执行完毕，就不会执行最后一行的 print(“主进程执行完毕”)。
我们再来看在上面案例的代码中加入多进程:
import time
import multiprocessing
2 个要同时执行的函数
def music():
for i in range(5): # 执行 5 次
print("听音乐中...")
time.sleep(0.2) # 延迟 0.2s，目的是让效果对比更明显一些
def movie():
for i in range(5):
print("看视频中...")
time.sleep(0.2) # 延迟 0.2s
if name == "main": # 解决 Windows 系统下调用包时的递归问题
创建子进程
music_process = multiprocessing.Process(target=music)
movie_process = multiprocessing.Process(target=movie)
启用进程
music_process.start()
movie_process.start()
print("主进程执行完毕")
代码中我加入了一个 if 语句来判断__name__这个，为什么？因为在 Windows 系统下， multiprocessing 这个包会发生递归现象，就是会在“导入模块—调用模块”之间反复执行，不信你可以把 if 语句去掉，把里面的代码全部放到外面来执行就会报错，这是 Windows 系统下会发生的一个现象，mac、linux 等系统是不用加 ifl 来做判断的。
关于__name__ = "main"这个知识点我在模块与包的初始化时候有讲过，不懂的可以回去看一下。
运行效果：
可以看出来，这开启进程之后，代码运行时是有 3 个进程同时进行的，一个是从上往下执行的主进程，执行到下面输出“主进程执行完毕”，另外两个子进程去执行 music（）和 movie()进程，从他们的执行速度来看，它们是同时在进行的，所以没有像刚才那样非要等其中一个函数里面的代码执行 3 遍才开始第 2 个函数。
同样的代码，你们的执行效果可能会跟我有所差异，因为效果是根据系统当前的状况去随机分配的，但并不影响你能看出来它的结果是多线程在进行。
最后补充一下，前面我们讲过 Process 里面有 args 和 kwargs 可进行参数传递，args 是普遍参数的传递，kwargs 是以字典的形式进行参数传递，我们还是以上面的代码为例，进行一下有参数传递的多进行。
2.获取当前进程的编号
前面我们讲到了代码执行时有多个进程在同时进行任务，那么怎么样查看当前进程的编号来得知目前有哪些进程在运行呢？哪些是主进程哪些是子进程呢？3 个方法，我们先来看一下方法，后面再结合例子一起使用。
（1）获取当前进程的编号：
需要用到一个 os 模块里面的 getpid()方法，用法如下：
os.getpid()
（2）获取当前进程的名字
这里用的还是 multiprocessing 包，里面有个 current_process()的方法，用法如下：
multiprocessing.current_process()
（3）获取当前父进程（主进程）的编号
子进程是属于哪个父进程的？这个用的是 os 模块里面的 getppid() ，用法如下：
os.getppid()
那么方法都看到了，我们来在刚才的例子的基础上，获取并打印一下当前进程的名字、编号以及父进程的编号。
import time
import multiprocessing
import os
2 个要同时执行的函数
def music():
print("music 子进程名字：", multiprocessing.current_process())
print("music 子进程编号：", os.getpid())
print("music 所属主进程的编号：", os.getppid())
for i in range(5): # 执行 5 次
print("听音乐中...")
time.sleep(0.2) # 延迟 0.2s，目的是让效果对比
更明显一些
def movie(a, b):
print("movie 子进程名字：", multiprocessing.current_process())
print("movie 子进程编号：", os.getpid())
print("movie 所属主进程的编号：", os.getppid())
for i in range(5):
print("看视频中...")
time.sleep(0.2) # 延迟 0.2s
if name == "main": # 解决 Windows 系统下调用包时的递归问题
创建子进程
music_process = multiprocessing.Process(target=music)
movie_process = multiprocessing.Process(target=movie, kwargs={"a": 30, "b": 40})
启用进程
music_process.start()
movie_process.start()
print("主进程编号：",os.getpid())
运行结果：
可以只要我们使用获取线程的方法的线程，都能被打印出来编号和名字。
多进程能同时运行几个任务，前面我们讲过进程的最小单位是线程，那么线程也同样可以进行多个任务。如果一个进程只有 1 个任务（主进程），那么也可以说是只有 1 个线程，就比如我们不使用多进程运行代码的时候，这时候就可以说 1 个主进程或 1 个主线程。
1.多线程的类 Thread 类
多线程常用的一个模块是 threading，里面有个教 Thread 的类，跟前面我们将多进程时用到的 Process 类差不多，我们先来看看用法：
Thread(target=None,name=None,args=(),kwargs=None)
target:可执行目标
name：线程的名字默认 Thread-N
args/kwargs:目标参数
同样的，多线程也要有开启的方法，跟前面的也差不多：
start()
还有获取线程名字的方法：
threading.current_thread()
知道了这些知识点，我们开始举例：用跟上面差不多的例子去使用一下我们的多线程。
import threading,time
def music(name,loop):
for i in range(loop):
print("听音乐 %s , 第 %s 次"%(name,i))
time.sleep(0.2)
def movie(name,loop):
for i in range(loop):
print("看电影 %s , 第 %s 次"%(name,i))
time.sleep(0.2)
if name =="main":
music_thread = threading.Thread(target=music,args=("最亲的人",3))
movie_thread = threading.Thread(target=movie,args=("唐探 2",3))
music_thread.start()
movie_thread.start()
print("主线程执行完毕")
运行结果：
听音乐 最亲的人 , 第 0 次
看电影唐探 2 , 第 0 次
主线程执行完毕
听音乐 最亲的人 , 第 1 次看电影唐探 2 , 第 1 次
看电影唐探 2 , 第 2 次听音乐 最亲的人 , 第 2 次
可以看出来，我们的多线程其实是跟多进程差不多的，同样可以运行多个任务，这里我们还增加了参数的使用。
2.继承 Thread 类
我们除了用上面的方法实现多线程任务，还可以用继承类的方式去实现多线程。
举例：通过多线程的方式，去打印“凉凉”和“头发没了"。
import threading,time
#多线程的创建
class MyThread(threading.Thread):
def init(self,name): #初始化
super().init() #调用父类 Thread 的初始化方法
self.name = name #name 变成实例属性
def run(self):
#线程要做的事情
for i in range(5):
print(self.name)
time.sleep(0.2)
#实例化子线程
t1 = MyThread("凉凉")
t2 = MyThread("头发没了")
t1.start()
t2.start()
MyThread 这个类是我们自己创建的，它是继承于父类 threading.Thread ，同时我们需要写上 MyThread 的初始化方法，每当被调用的时候把准备工作做好，super（）.int（） 这个我们也讲过了，在前面的面向对象时有讲过，不懂的可以去看看面向对象那篇文章的内容。
运行结果：
凉凉
头发没了
凉凉
头发没了
凉凉头发没了
凉凉头发没了
凉凉
头发没了
随机效果是有的，你们的效果和我的可能会不一样，每台电脑在运行多线程代码时，哪个线程能够抢到时间片谁就先执行。
通过类 Thread 继承一样可以实现多线程。
=======================================================================
在 Python 中，容器是把多种元素组织在一起的数据结构，容器中的元素就可以逐个迭代获取。说白了，它的作用就像它的名字一样：用来存放东西（数据）。
容器实际上是不存在的，它并不是一种数据类型，只是人为的一种概念，只是为了方便学习所创造的一个概念词，它可以用成员关系操作符（in 或 not in）来判断对象是否在容器里面。
当然了，它不是我创造的，我没有那么大本事哈，是官方创造的好吧，你也不用担心我是在教你一些奇奇怪怪的名词，说出去别人都听不懂…python 中都是这么叫的。
常见的容器类型有列表（list）、元组（tuple）、字符串（str）、字典（dict）以及集合（set ）。
既然容器里面的数据是可以迭代获取的，那么我们又得来学一个新概念：可迭代对象。
什么是可迭代对象？
在 python 中，可迭代对象并不是指某种具体的数据类型，它是指存储了元素的一个容器对象。
也就是说，如果容器里面没有存储数据，那它就不是可迭代对象，并不是所有的容器都是可迭代对象，容器包含但并不仅限于可迭代对象。
注意两个点：
1.很多容器都是可迭代对象（容器包含了可迭代对象）。
2.一个可迭代对象是不能独立的进行迭代的，迭代是通过 for 来完成的，凡是可迭代对象都可以直接使用 for 循环进行访问。
for 循环大家应该不陌生吧？有没有想过，for 循环内部是怎么实现的？比如说这个 for 循环的例子，为什么能输出列表里的每一个元素？它的内部是怎么实现的？
其实 for 循环做了两件事情：
1.使用 iter() 返回 1 个迭代器，迭代器在下面会讲，这里先知道有这么个东西。
2.使用 next() 获取迭代器中的每一个元素。
那么我们不用 for 循环来输出列表里的每一个元素，
l = [1,2,3,4]
for i in l:
print(i)
ite =l.iter() #接收一下 ietr()干了什么
print(ite) #打印
print(ite.next()) #for 循环干第 2 件事情的时候做的第 1 步
print(ite.next()) #for 循环干第 2 件事情的时候做的第 2 步
print(ite.next()) #for 循环干第 2 件事情的时候做的第 3 步
print(ite.next()) #for 循环干第 2 件事情的时候做的第 4 步
输出结果：
可以看出来，如果我们去掉哪行打印 ite 的代码，执行效果就是跟 for 循环输出列表里面的每一个元素是一样的，for 循环里面限定了范围是 4 次，实际上就执行了 1 次__iter__()和 4 次__next__()，也就是说 for 循环访问迭代对象的本质就是通过这么去实现的。
而且，for 循环本质上干的那两件事情，缺一不可，也就是说如果没有__iter__()先返回了迭代器，__next()__也无法获取到元素，恰恰说明了前面说要注意的两点中的第 2 点：一个可迭代对象是不能独立的进行迭代的。
有两个内置函数跟它们原理是一样的，本质相同，一般要用的话用内置函数要方便一些，起码不用写那么多下划线：
内置函数 iter() 的本质是 inter() ，也是返回一个迭代器。
内置函数 next（） 的本质是 next()，也是有了迭代器之后获取元素。
可以看出来结果也是一模一样的，既然讲到了迭代器，那么就来看看什么是迭代器。
通过上面的 for 循环例子我们大概也能看得出来，
只要是实现了__iter__()和__next__()的对象，就是迭代器，迭代器是一个可迭代对象。
总之，迭代器是有__iter__()生成，可以通过__next__()进行调用。
既然如此，我们在学 Python 基础的时候讲过 range()是一个可迭代对象，那么它也是可以通过__iter__()生成一个迭代器的。
序列在【赋值语句】那个专题文章中我有提过，这里再讲一下，序列也是一个抽象的概念，它包含了列表、元组和字符串，它本身是不存在的，也是便于学习所创造的一个概念词。
可迭代对象包含序列，既然序列包含了列表、元组和字符串，前面我们的例子中也涉及到 了，所以说序列可以被 iter（）和 next（）使用。
序列可以分为有限序列和无限序列。有限序列就是有范围的，比如说 range(10)就已经限定了范围，相反的，无限序列也就是没有限定范围的序列。
我们来生成一个无限序列，这里需要用到 1 个新模块 itertools，itertools 用于高效循环的迭代函数集合,它下面有一个方法 count()，可生成迭代器且无范围，可以理解为无限迭代器。
通过这个例子我们可以看出来，只要执行一次，next()就会获取一次迭代器里面的内容并逐次获取，我这里只写了 4 个 next()，你多写几次就会多输出几次。
像 next()这种什么时候需要就什么时候调用的机制叫做懒加载机制，也叫懒汉式加载；
相反地就有饿汉式加载。比如 for 循环这种的，只要一执行就会把可迭代器里面的所有对象都获取。
列表推导式跟生成器有关，在讲生成器之前，需要先知道什么是列表推导式，列表推导式就是生成列表的一种方法，语法是这样的：
l = [i for i in 可迭代对象]
i 表示要放进列表里的对象，for 循环是一个式子。
比如我们用列表推导式来生成一个列表试试：
l = [i for i in range(5)]
print(l)
运行结果：
[0, 1, 2, 3, 4]
运用列表推导式可以很方便地生成我们想要的列表。
同时它也有很多灵活的用法，比如在后面加上条件判断
l = [i for i in range(5) if 4<5]
print(l)
运行结果：
[0, 1, 2, 3, 4]
if 后面的条件判断为真，则可以正常生成列表，如果为假，则列表推导式是无效的，此时的 l 将是一个空列表。
还有其他灵活的用法，比如操作前面的 i,比如让 i 的数值全都翻 2 倍：
我们把迭代对象换一下，换成字符串，也同样可以输出，只是*在字符串里面表示重复操作符，所以效果变成了这样：
不仅如此，前面的 i*2 我们还可以用函数来进行操作，比如：
总而言之，列表推导式就是用来快速和自定义生成列表的一种方法，很灵活。
那么有人可能会举一反三了，列表推导式都是用 [] 来进行操作的，那如果用（）来操作行吗?它会不会生成一个元组？我们来看看：
[] 换成（）之后，返回的是一个生成器 generrator ，那么下面我们再来讲讲生成器：
生成器是真实存在于 Python 中的对象，与容器这种概念词是不同的，它是可以直接通过 next()进行调用的。
1.生成器的第一种创建方法：生成器表达式
第一种创建方法跟列表推导式是差不多的，就是 [] 换成了（）：
l = (i for i in 可迭代对象)
比如我们来生成一个生成器，看看能不能用 next()直接调用：
l = (i for i in "abcd")
print(next(l))
运行结果：
a
可以看出，生成器是可以直接调用的。那么既然生成器可以被 next()调用，那么生成器就是一个特殊的迭代器，是一个可迭代对象。
2.生成器的第二种创建方法：yield
除了用上面那种方法创建生成器，还可以用 yield 来创建，方法如下：
yield 关键字
比如说我们用一个函数中包含 yield 来创建生成器：
def fun():
a = 10
while 1:
a += 1
yield a
b = fun()
print(b)
运行结果：
<generator object fun at 0x000001F2AD95E900>
结果就是生成了一个生成器，而且此时的函数 fun()就已经不再是一个函数了，它是一个生成器，只要函数中出现了 yield，函数就变成了生成器。
为什么 while 循环没有一直执行？先不着急，我们输出看看：
def fun():
a = 10
while 1:
a += 1
yield a
b = fun()
print(next(b))
print(next(b))
print(next(b))
运行结果：
11
12
13
我调用了三次，所以它就运行了三次，while 循环虽然存在，但是却不起作用，是因为前面我们提过的懒汉式加载。
什么时候需要了，什么时候用 next()调用，就是懒汉式加载，不像饿汉式加载那样，提前生成了所有对象，如果这里换成 for 循环来完成，比如：
def fun():
a = 10
while 1:
a += 1
print(a)
b = fun()
运行之后程序将会进入死循环，一直给 a 自加 1，你可以试试看效果，这就是饿汉式加载提前生成了迭代器并调用了全部迭代器对象，饿汉式加载占用资源的放大镜。
最后用一张图来总结一下它们的关系：
===============================================================
1.什么是修饰器？
修饰器又叫装饰器，本身也是一个函数，是在原有的函数或者是方法上增添一些额外的功能。
2.修饰器的作用
概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。
比如说这个函数是注册的功能，但有时候这个用户在执行这个操作的时候，他是已注册的用户，我这个函数已经写好了，不想动它了，那么我们就可以通过修饰器来给这个函数增加一个登录的功能。
它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。
修饰器的具体操作，我们来慢慢学习。
1.使用说明
在使用修饰器之前，我们得记住几个关于修饰器的使用说明：
（1）修饰器的关键字是 @ ，Python 代码中只要出现了它，你就可以想到是修饰器了。
(2）修饰器修饰的是函数或者是方法，不能修饰一个类。
(3)修饰器必须出现在被修饰函数或者方法的前一行，不能够将修饰器定义在函数的同行。
例子：
虽然修饰器本身是一个函数，但它的出现是有规定的，我上面的修饰器就没有出现在被修饰函数或者方法的前 1 行，所以连 print(“龙叔”) 这一行代码都执行不了。
(4)修饰器本身是一个函数，将被修饰的函数作为参数，传递给修饰器，执行修饰器中功能，返回传递进来的函数对象，调用返回出来的函数。
这几个点很重要，下面我们通过修饰器的多种使用方式来加深理解。
2.基本使用方式
如果被修饰的函数不调用，则执行 @后面的函数，并把被修饰的函数当做参数传递过去了，则修饰器函数的返回值可以是任意值。
例子：
def dec(a): #修饰器函数
print(a) #看一下形参传了什么
print("helloworld")
return None
@dec #使用修饰器
def funA(): #被修饰的函数
pass
运行结果：
<function funA at 0x0000018D849BB670>
helloworld
最后
Python 崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS 等更加高级的领域。Python 可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python 可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
??Python 所有方向的学习路线??
Python 所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
??Python 必备开发工具??
工欲善其事必先利其器。学习 Python 常用的开发软件都在这里了，给大家节省了很多时间。
??Python 全套学习视频??
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。
??实战案例??
学 python 就与学数学一样，是不能只看书不做题的，直接看步骤和答案会让人误以为自己全都掌握了，但是碰到生题的时候还是会一筹莫展。
因此在学习 python 的过程中一定要记得多动手写代码，教程只需要看一两遍即可。
??大厂面试真题??
我们学习 Python 必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
Python编程资料加Q群免费领取：419829237 2022.03.14 加入
还未添加个人简介
评论