Python基础复习总结

Python基础复习

Python的下载与安装

Python下载地址：https://www.python.org/downloads/
安装详细教程：https://blog.csdn.net/qq_53280175/article/details/121107748

标识符

1、区分大小写: Myname与myname是两个不同的标识符。
2、首字符可以是下画线(_ )或字母,但不能是数字。
3、除首字符外的其他字符必须是下画线、字母和数字。
4、关键字不能作为标识符。
5、不要使用Python的内置函数作为自己的标识符

关键字

模块

一个模块就是一个文件

import <模块名>
from <模块名> import <代码元素>
from <模块名> import <代码元素> as <代码元素别名>

条件、循环语句

if elif else

score = int(input("请输 入“个0~100整数: "))
if score >= 90:
	grade =' A ”
elif score >= 80:
	grade =' B'
elif score >=70:
	grade = 'C'
elif score >= 60:
	grade =' D'
else:
	grade = 'F'
print("Grade ="+ grade)

for循环

for i in range(0,10):
	print("i = %d"%(i)) # 打印i=0到9

# 计算1+2+3+...+N
print("请输入N的值：")
N = int(input()) # 键盘输入N的值
sumN = 0
for i in range(1,N+1):
	sumN = sumN + i
print(sumN)	

while循环

i=0
while i * i< 1000:
	i += 1
print("i =" + str(i)) # i = 32
print("i * i ="+ str(i * i)) # i * i = 1024

成员测试

成员测试运算符有两个: in和not in,
in用于测试是否包含某一个元素,
not in用于测试是否不包含某一个元素。

a = "Hello"
print('e' in a) # True

Python中的数据类型

Python中有6种主要的内置数据类型:数字、字符串、列表、元组、集合和字典。
Python中有4种数字类型:整数类型、浮点类型、复数类型和布尔类型。

Python中的整数类型为int类。

Python的浮点类型为float类。

复数在数学中被表示为: a + bi,其中a被称为实部，b被称为虚部，i被称为虚数单位。

Python中的布尔类型为bool类:它只有两个值:True和False。

1.隐式类型的转换

2.显式类型的转换

序列

序列(sequence) 是一种可迭代的、元素 有序的容器类型的数据。

strtest = "Hello"
print(strtest[0]) # H
print(strtest[-5]) # H
print(strtest[-1]) # o

print(strtest*2) # HelloHello
print(strtest+" World") # Hello World

# 切片操作
# 切片运算符的语法形式为[start:end:step]。其中,start是开始索引，end是结束索引,step是步长(切片时获取的元素的间隔,可以为正整数，也可以为负整数)。
a = "Hello"
print(a[1:3]) # el
print(a[0:3:2]) # Hl

列表 list

列表(ist) 是一种可变序列类型，我们可以追加、插入、删除和替换列表中的元素。

1.在列表中追加单个元素时， 可以使用列表的append(x)方法。
2.在列表中追加多个元素时，可以使用加(+) 运算符或列表的extend(t)方法

想向列表中插入元素时，可以使用列表的list.insert(i, x)方法

l = [20,30,50]
l.insert(2,80)
print(l) # [20,30,80,50]

想替换列表中的元素时，将列表下标索引元素放在赋值符号(=)的左边，进行赋值即可。

l = [20,30,50]
l[1] = 80
print(l) # [20,80,50]

使用列表的list.remove(x)方法。

l = [20,30,50]
l.remove(30)
print(l) # [20,50]

元组 tuple

元组(tuple) 是一种**不可变**序列类型。
1.tuple(iterable)函数
2.(元素1,元素2,元素3…)

sid,sname = (110,'张三')
print(sid) # 110
print(sname) # 张三

集合 set

集合(set)是一种可迭代的、无序的、不能包含 重复元素的容器类型的数据。
1.set(iterable)函数
2.{元素1,元素2,元素3, … }

a = set()
b = {1,2,'abc'}

集合中不包含重复的元素

# 其他数据类型转为集合
a = 'abcd' # 字符串
test = set(a)
print(test) # {'a','b','c','d'}

b = [1,2,3] # 列表
test = set(b)
print(test) # {1,2,3}

c = (1,2,'abc') # 元组
test = set(c)
print(test) # {1,2,'abc'}

d = {'a':1,'b':2,'c':3} # 字典
test = set(d)
print(test) # {'a','b','c'}

# for循环打印集合中的元素
test = {1,2,'abc'}
for item in test:
	print(item)

add(elem):添加元素，如果元素已经存在， 则不能添加， 不会抛出错误。
remove(elem) :删除元素， 如果元素不存在,则抛出错误。
clear(): 清除集合。

# 集合添加删除元素
nums = {1,2,3}
nums.add(6)
nums.remove(1)
print(nums) # {2,3,6}
nums.clear() # 清除集合

# 集合之间的运算
# 交集 &或者intersection
# 并集 |或者union
# 差集 -或者difference
a = {1,2,3,4}
b = {3,4,5,6}

print(a&b) # {3,4}
print(a.intersection(b))

print(b&a) # {3,4}
print(b.intersection(a))

print(a|b) # {1,2,3,4,5,6}
print(a.union(b))

print(a-b) # {1,2}
print(a.difference(b))

print(b-a) # {5,6}
print(b.difference(a))

字典 dict

1、字典(dict) 是可迭代的、 通过键(key)来访问元素的可变的容器类型的数据。
2、键视图不能包含重复的元素，值视图能。在键视图中， 键和值是成对出现的。

container = {'苹果':'A','香蕉':'C','桃子':'B','梨子':'D'}
print(container)
print(container['桃子'])

# 创建字典
name = {}
name = dict()

dictname[key] = value

字典可以被修改，但都是针对键和值同时操作的,对字典的修改包括添加、替换和删除。

items():返回字典的所有键值对视图。
keys():返回字典键视图。
values(): 返回字典值视图。

Python关系运算

v1 = True
v2 = False
print(v1) # True
print(v2) # False
print(int(v1)) # 1
print(int(v2)) # 0
print(v1+v2) # 1

算术运算符

比较运算符

逻辑运算符

位运算符

赋值运算符

运算符优先级

字符串

表示字符串

普通字符串指用单引号(') 或双引号(")括起来的字符串。
常用的转义符：

# 长字符串
s = """1213123123453434342342245412125142534254
352352435231523425325345234524352435243"""

字符串与数字类型的转换

1、将字符串转换为数字
2、将数字转换为字符串

将字符串转换为数字，可以使用int()和float()实现， 如果成功则返回数字，否则引发异常。

将数字转换为字符串，可以使用str()函数， str()函数可以将很多类型的数据都转换为字符串。

字符串格式化

使用字符串的format0方法，它不仅可以实现字符串的拼接,还可以格式化字符串。

要想将表达式的计算结果插入字符串中，则需要用到占位符({}) 。

格式化控制符：

操作字符串

str.find(sub[, start[ end]])查找子字符串，在索引start到end之间查找子字符串sub,
如果找到，则返回最左端位置的索引;如果没有找到，则返回-1。

str.replace(old, new[, count])字符串替换,new子字符串替换old子字符串。count参数指定了替换old子字符串的个数，count被省略,则替换所有old子字符串。

str.split(sep=None, maxsplit=-1) ，使用sep子字符串分割字符串str。maxsplit是最大分割次数,
如果maxsplit被省略， 则表示不限制分割次数。

函数

定义函数

def rect_area(w,h):
	area = w * h
	return area
def print_area(w,h):
	area = w * h
	print("{0}x{1}长方形的面积是{2}".format(w,h,area))	

调用函数
在调用函数时传递的实参与定义函数时的形参顺序一致,这是调用函数的基本形式。
在调用函数时可以采用“关键字=实参”的形式，其中，关键字的名称就是定义函数时形参的名称。

参数的默认值
可变参数
Python中的函数可以定义接收不确定数量的参数，这种参数被称为可变参数。可变参数有两种，即在参数前加*或**。

def sum(*numbers):
	total = 0.0
	for number in numbers:
		total += number
	return total	

print(sum(100.0,20.0,30.0)) # 输出150.0
print(sum(30.0,80.0)) # 110.0	

def show_info(**info):
	print('---show info---')
	for key,value in info.items():
	print('{0} - {1}'.format(key,value))

show_info(name = 'Tony',age = 18,sex = True)

函数变量的作用域
全局变量 局部变量

x = 20
def print_value():
	global x # 将x变量提升为全局变量
	x = 10
	print(x)

函数的类型
Python中的任意一个函数都有 数据类型，这种数据类型是function,被称为函数类型。
1、一个函数可以作为另一个函数返回值使用。
2、一个函数可以作为另一个函数参数使用。

filter函数

def f1(x):
	return x > 50
data = [66,15,91,28,98,50,7,80,99]	
filtered = filter(f1,data)
data2 = list(filtered)
print(data2) # [66,91,98,80,99]

map函数

#提供变换规则的函数
def f1(x):
	return x*2 #变换规则乘以2
data1 = [66, 15, 91,28, 98, 50, 7, 80，99]
mapped = map(f1, data1)
data2 = list(mapped) # 转换为列表
print(data2) # [132, 30, 182,56, 196, 100, 14, 160，198]

lambda函数
在Python中使用lambda关键字定义匿名函数。lambda关键字定义的函数也被称为lambda函数。

def calc(opr):
	if opr == '+':
		return lambda a, b:(a + b) #替代add函数
	else:
		return lambda a, b: (a - b) # 替代sub函数
f1 = calc('+')
f2 = calc('-')
print("10 + 5 = {0}".format(f1(10,5)))
print("10 - 5 = {0}".format(f2(10,5)))

使用Python进行目录的搜索移动

import os # 导入系统库os
import shutil # 实现移动文件的功能需求

# path代表待搜索的目录路径.res存储搜索到的文件路径列表
def search_dir(path,res):
	child_files = os.listdir(path)
	for child in child_files:
		child = os.path.join(path,child)
		res.append(child)
		if os.path.isdir(child): # 如果child是一个子目录
		search_dir(child,res) # 递归

input_dir = input("输入待搜索的目录：")
output_dir = input("输入保存文件的目录：")

files = list()
search_dir(input_dir,files)		
for file1 in files:
	print("find %s"%(file1))
	if os.path.isfile(file1) and file1.endswith(".docx"):
	print("move %s"%(file1))
	shutil.move(file1,output_dir)

Python爬虫-数据获取

# 样例代码
import urllib.request
url = "https://movie.douban.com/top250"
header = {
	"User-Agent":"Mozilla/5.0 (Windows NT 10.0; WOW64)"	
	"AppleWebKit/537.36 (KHTML, like Gecko)"
	"Chrome/76.0.3809.87 Safari/537.36 SLBrowser/6.0.1 .8131"
}
req = urllib.request.Request(url=url,headers = header)
response = urllib.request.urlopen(req)
html = response.read().decode("utf-8")
print(html)

import urlib.request
def download_html(url):
	header = {
		"User-Agent":"Mozilla/5.0 (Windows NT 10.0; WOW64)"	
	"AppleWebKit/537.36 (KHTML, like Gecko)"
	"Chrome/76.0.3809.87 Safari/537.36 SLBrowser/6.0.1 .8131"
	}
	req = urllib.request.Request(url=url,headers = header)
	response = urllib.request.urlopen(req)
	html = response.read().decode("utf-8")
	return html

html = download_html("https://movie.douban.com/top250")
import re
pattern = "https://movie.douban.com/subject/[0-9]+/"
urls = re.findall(pattern,html)
urls = set(urls)
print("urls count = %d"%(len(urls)))
for url in urls:
	print(url)	

import urlib.request
import re

def download_html(url):
	header = {
		"User-Agent":"Mozilla/5.0 (Windows NT 10.0; WOW64)"	
	"AppleWebKit/537.36 (KHTML, like Gecko)"
	"Chrome/76.0.3809.87 Safari/537.36 SLBrowser/6.0.1 .8131"
	}
	req = urllib.request.Request(url=url,headers = header)
	response = urllib.request.urlopen(req)
	html = response.read().decode("utf-8")
	return html

def extract_url(html):
	pattern = "https://movie.douban.com/subject/[0-9]+/"
	urls = re.findall(pattern,html)
	urls = set(urls)
	return urls	

file1 = open("douban.txt",'r')
output = open('movie.txt','w')

lines = file1.readlines()
for url in lines:
	url = url.strip()
	print(url)
	html = 	download_html(url)
	urls = extract_url(html)
	for url in urls:
		output.write(url+'\n')
file1.close()
output.close()

面向对象

面向对象个绍

面向对象是一种编程思想，即按照真实世界的思维方式构建软件系统。

定义类

class类名[(父类)]:
\t 类体

class Car(object):
	# 类体
	pass

创建对象

class Car(object):
	# 类体
	pass

car = Car()

class Person (object) :
	def __new__(cls, *args, **kwargs) : 
		print('__ new__ 被调用执行 了,cls的id值为{0}'.format(id(cls)))
		obj=super().__ new__(c1s)
		print('创建的对象的id为: {0}'.format (id(obj)))
		return obj
	def __init__(self, name, age) :
		print('__ init__ 被调用 了，self的id值为: {0}'. format (id(self)))
		self.name = name
		self.age = age

print('object这个类对象的id为: {0}'.format(id(object)))
print('Person这个类对象的id为: {0}'.format(id (Person)))
#创建Person类的实例对象
p1 = Person('张三',20)
print('p1这个Person类的实例对象的id: {0}'. format(id(p1)))
# object这个类对象的id为:1407177961 13232
# Person这个类对象的id为:2690679899360
# __new__被调用执行 了，cls的id值为2690679899360 
# 创建的对象的id为: 2690436007104
# __init__被调用了，self的id值为:2690436007104
# p1这个Person类的实例对象的id: 2690436007104 

类的成员

实例变量就是对象个体特有的“数据”，例如狗狗的名称和年龄等。

class Dog:
	def __init__(self,name,age):
		self.name = name #创建和初始化实例变量name
		self.age = age #创建和初始化实例变量age
d = Dog('球球',2)
print('我们家狗狗名叫{0}，{1}岁 了。'.format(d.name, d.age))

类中的__ init__()方法是- -个非常特殊的方法，用来创建和初始化实例变量，这种方法就是“构造方法”。

class Dog:
	def __init__(self, name, age, sex='雌性'):
		self.name = name #创建和初始化实例变量name
		self.age = age #创建和初始化实例变量age
		self.sex = sex #创建和初始化实例变量sex
d1 = Dog('球球'，2)
d2 = Dog('哈哈',1,‘雄性')
d3 = Dog(name='拖布'，sex= ' 雄性'，age=3)
print('{0}: {1}岁{2}。'.format(d1.name, d1.age, d1.sex))
print('{0}: {1}岁{2}。'.format(d2.name, d2.age, d2.sex))
print('{0}: {1}岁{2}。'.format(d3.name, d3.age, d3.sex))

实例方法与实例变量-样，都是某个实例 (或对象)个体特有的方法。

class Dog:
	#构造方法
	def __init__ (self, name ,age, sex='雌性'):
		self.name = name #创建和初始化实例变量name
		self.age = age #创建和初始化实例变量age
		self.sex = sex #创建和初始化实例变量sex
	#实例方法
	def run(self):
		print("{}在跑...". format(self.name))
	#实例方法
	def speak(self, sound) :
		print('{}在叫，"{}"!'. format(self.name, sound))
dog = Dog('球球'，2)
dog. run()
dog. speak('旺旺旺')

类变量是属于类的变量，不属于单个对象。

class Account:
	interest_ rate = 0.0568 # 类变量利率interest_ rate
	def __init__ (self, owner, amount):
		self.owner = owner #创建并初始化实例变量owner
		self.amount = amount #创建并初始化实例变量amount
account = Account( 'Tony', 800000.0)
print('账户名: {0}'.format(account.owner))
print('账户金额: {0}'.format(account.amount) )
print('利率: {0}'.format (Account.interest_ rate))

类方法与类变量类似，属于类，不属于个体实例。

class Account:
	interest_rate = 0. 0668 #类变量利率
	def __init__(self, owner, amount):
		self.owner = owner #定义实例变量账户名
		self.amount = amount # 定义实例变量账户金额
	#类方法
	@classmethod
	def interest_ by(cls, amt):
		return cls.interest_rate * amt
interest = Account.interest_ by(12000.0)
print('计算利息: {0: .4f}'.format(interest))

封装性

封装隐藏了对象的内部细节，只保留有限的对外接口，外部调用者不用关心对象的内部细节，使得操作对象变得简单。

为了防止外部调用者随意存取类的内部数据(成员变量)，内部数据(成员变量)会被封装为‘私有变量”。
私有变量,则在变量前加上双下画线(__)。

class Account:
	__interest_ rate = 0.0568 #类变量利率interest_ rate
	def __init__(self, owner, amount) :
		self.owner = owner #创建并初始化公有实例变量owner
		self.__amount = amount #创建并初始化私有实例变量__amount
	def desc(self):
		return "{0}金额: {1}利率: {2}。 " . format(self.owner,self._ amount ,Account.__ interest rate)

私有方法与私有变量的封装是类似的，在方法前加上双下画线 (__) 就是私有方法了。

class Account :
	__interest_rate = 0.0568 #类变量利率__ interest_ rate
	def __init__(self, owner, amount) :
		self.owner = owner #创建并初始化公有实例变量owner
		self.__amount = amount #创建并初始化私有实例变量___ amount
	def __get_info(self):
		return "{0}金额: {1}利率: {2}。 " . format( self.owner,self.__amount,Account._ interest rate )
	def desc(self):
		print(self.__get_info())

为了实现对象的封装，在一个类中不应该有公有的成员变量，这些成员变量应该被设计为私有的，然后通过公有的set (赋值)和get (取值) 方法访问。

class Dog:
	#构造方法
	def __init__(self, name, age,sex='雌性'):
		self.name = name #创建和初始化实例变量name
		self.__age = age #创建和初始化私有实例变量__age
	#实例方法
	def run(self):
		print("{}在跑...". format(self.name))
	@property
	def age(self):
		#替代get_age(self):
		return self.__age
	@age.setter
	def age(self, age): 
		# 替代set_age(self, age)
		self.__age = age
dog = Dog('球球',2)
print('狗狗年龄: {}'. format(dog.age))
dog.age = 3 # dog.set_ age(3)
print('修改后狗狗年龄: {}' .format(dog.age))

继承性

1、继承性也是面向对象重要的基本特性之- 。在现实世界中继承关系无处不在。
2、例如猫与动物之间的关系:猫是一 种特殊动物，具有动物的全部特征和行为，即数据和操作。在面向对象中动物是一般类,被称为”父类”;猫是特殊类，被称为“子类”。特殊类拥有一般类的全部数据和操作，可称之为子类继承父类。

class Animal :
	def __init__(self,name):
		self.name = name #实例变量name
	def show_info(self):
		return "动物的名字: {0}". format(self.name )
	def move(self):
		print("动动...")
class Cat(Animal):
	def __init__(self,name, age):
		super().__ init__(name)
		self.age = age # 实例变量age
cat = Cat('Tom', 2)
cat.move()
print(cat.show_info())

多继承

class Horse:
	def __init__(self, name):
		self.name = name # 实例变量name
	def show_info(self):
		return "马的名字: {0}". format(self.name)
	def run(self):
		print("马跑...")
class Donkey:
	def __init__(self, name):
		self.name = name #实例变量name
	def show_info(self):
		return "驴的名字: {0}".format(self.name)
	def run(self):
		print("驴跑...")
	def roll(self):
		print("驴打滚...")
class Mule(Horse, Donkey): # 多继承 优先性
	def __init__(self, name, age):
		super().__init__ (name)
		self.age = age #实例变量age
m = Mule('骡保丽',1)
m.run() # 继承父类Horse方法
m.roll() # 继承父类Donkey方法
print(m.show_info()) # 继承父类Horse方法

方法重写

class Horse:
	def __init__(self, name):
		self.name = name # 实例变量name
	def show_info(self):
		return "马的名字: {0}". format(self.name)
	def run(self):
		print("马跑...")
class Donkey:
	def __init__(self, name):
		self.name = name #实例变量name
	def show_info(self):
		return "驴的名字: {0}".format(self.name)
	def run(self):
		print("驴跑...")
	def roll(self):
		print("驴打滚...")
class Mule(Horse, Donkey): # 多继承 优先性
	def __init__(self, name, age):
		super().__init__ (name)
		self.age = age #实例变量age
	def show_info(self):
		return "骡：{0},{1}岁。".format(self.name,self.age)	

多态性

1、“多态”指对象可以表现出多种形态。
2、例如，猫、狗、鸭子都属于动物,它们有”叫”和"动”等行为，但是”叫”的方式不同，"动”的方式也不同。

在多个子类继承父类，并重写父类方法后，这些子类所创建的对象之间就是多态的。这些对象采用不同的方式实现父类方法。

class Animal :
	def speak(self):
		print('动物叫，但不知道是哪种动物叫!')
class Dog(Animal):
	def speak(self):
		print('小狗:旺旺叫...')
class Cat(Animal):
	def speak(self):
		print('小猫:喵喵叫...')
an1 = Dog()
an2 = Cat()
an1.speak()
an2.speak()

鸭子类型测试与多态
1、鸭子类型测试指:若看到一只鸟走起来像鸭子、游泳起来像鸭子、 叫起来也像鸭子，那么这只鸟可以被称为鸭子。
2、Python支持鸭子 类型测试，Python解释器不检查发生多态的对象是否继承了同一个父类，只要它们有相同的行为(方法)它们之间就是多态的。

1、设计一个函数start()，它接收具有“叫"speak()方法的对象:

def start(obj): #接收obj对象具有speak()方法
	obj.speak( )

2、定义了几个类，它们都有speak()方法:

class Animal:
	def speak(self):
		print( '动物叫，但不知道是哪种动物叫! ' )
class Dog(Animal):
	def speak(self):
		print('小狗:旺旺叫...')
class Cat(Animal):
	def speak(self):
		print('小猫:喵喵叫...')
class Car:
	def speak(self):
		print('小汽车:嘀嘀叫...')

3、start()可以接收所有speak()方法对象，代码如下:

start(Dog())
start(Cat())
start(Car())

异常

除零异常：ZeroDivisionErrpr异常

i = input('请输入数字: ')
n = 8888
result = n / int(i)
print(result)
print('{0}除以{1}等于{2}' .format(n, i, result))

异常捕获

我们不能防止用户输入0，但在出现异常后我们能捕获并处理异常，不至于让程序发生终止并退出。亡羊补牢，为时未晚。

i = input('请输入数字:')
n = 8888
try:
	result = n / int(i)
	print (result)
	print(' {0}除以{1}等于{2}'.format(n, i, result))
except ZeroDivisionError as e: # except:
	print("不能除以0，异常: {}".format(e) )

i = input(’ 请输入数字:”)
n = 8888
try:
	result = n / int(i)
	print (result)
	print( {0}除以{1}等于{2}'.format(n, i, result))
except ZeroDivisionError as e:
	print("不能除以0，异常: {} ".format(e) )
except ValueError as e:
	print("输入的是无效数字，异常: {}".format(e))

i = input('请输入数字: ')
n = 8888
try:
	result = n / int(i)
	print (result)
	print('{0}除以{1}等于{2}'.format(n, i, result))
except (ZeroDivisionError, ValueError) as e:
	print("异常发生: {}".format(e))

i = input('请输入数字: ')
n = 8888
try:
	i2 = int(i) 
	try :
		result=n/i2
		print('{0}除以{1}等于{2}'.format(n, i2, result))
	except ZeroDivisionError as el:
		print("不能除以0，异常: {}".format (e1))
except ValueError as e2:
	print("输入的是无效数字，异常: {}".format (e2))

使用finally代码块

i = input('请输入数字:' )
n = 8888
try:
	result=n / int(i)
	print(result)
	print('{0}除以{1}等于{2}'.format(n, i, result))
except ZeroDivisionError as e:
	print("不能除以0，异常: {}".format(e) )
except ValueError as e:
	print ("输入的是无效数字，异常: {}".format (e))
finally: 
	# 释放资源代码
	print('资源释放...' )

自定义异常类

# 自定义异常类 MyError ，继承普通异常基类 Exception
class MyError(Exception):
        def __init__(self, value):
            self.value = value

        def __str__(self):
            return repr(self.value)

try:
    num = input("请输入数字：")
    if not num.isdigit():  # 判断输入的是否是数字
        raise MyError(num)  # 输入的如果不是数字，手动指定抛出异常
except MyError as e:
    print("MyError：请输入数字。您输入的是：", e.value)

手动引发异常

def demo_bad_catch():
    try:
        raise ValueError('Represents a hidden bug, do not catch this')
        raise Exception('This is the exception you expect to handle')
    except Exception as error:
        print('Caught this error: ' + repr(error))

>>> demo_bad_catch()
Caught this error: ValueError('Represents a hidden bug, do not catch this',)

【参考】https://www.bilibili.com/video/BV19M411r7ix
【参考】https://www.bilibili.com/video/BV1wD4y1o7AS/?spm_id_from=333.999.0.0&vd_source=ae10349a11947050eef839ac15d08136
【参考】https://blog.csdn.net/manongajie/article/details/106344964
【参考】https://blog.csdn.net/p15097962069/article/details/103381588