计算机基础知识与Python简介
一，计算机基础知识
- cpu： 相当于人类的大脑，运算和处理问题
- 内存： 临时存储数据，断电就消失了
- 硬盘： 永久存储数据
- 操作系统： 管理计算机硬件与软件资源的计算机程序，控制每个硬件之间数据交互
二，Python简介
龟叔
优美、清晰、简单
主要应用领域：
- 云计算
- WEB开发
- 科学技术、人工智能
- 系统运维
- 爬虫
- 金融量化分析
- 图形GUI
- 游戏
Python发展史
- 1989年，Guido开始写Python
- 1991年，第一个Python解释器诞生
- 2004年，最流行的WEB框架Django诞生
- 2008年，python2和python3版本共存
- python2：C，Java，C#，源码不统一，功能重复，维护难度大
- python3：源码统一，维护难度降低了
python是一个编程语言
分类：编译型、解释型，强类型、弱类型
编译型：只翻译一次
代表语言：C，C++
优点：运行速度快
缺点：开发速度慢
解释型：一句一句的翻译，逐行翻译
优点：开发速度快
缺点：运行速度慢
代表语言：Python，JavaS，PHP
Python的优缺点
优点：
- Python的定位是优雅、明确、简单，初学者容易入门，而且可以编写非常复杂的程序。
- 开发效率非常高，Python有非常强大的第三方库
- 高级语言，无需考虑如何管理你的程序使用的内存一类的底层细节
- 可移植性，由于它的开源本质，Python无需修改就几乎可以在市场上所有的系统平台上运行。
- 可扩展性，可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。
- 可嵌入性，可以把Python嵌入你的C、C++程序，从而向你的程序提供某些功能。
- 缺点：
- 运行速度慢
- 代码不能加密
- 线程不能利用多CPU
Python的种类
- Cpython： 官方版本，使用C语言实现
- Jython： 会把Python代码动态编译成Java字节码，然后在JVM上运行
- IronPython：用C#实现
- PyPy：Python实现的Python，统一编译后再运行
Python基础
一，Python初始
写一个Python程序
print() 打印：打印到屏幕
变量 运算过程中产生的中间值，存储起来便于下一步运算使用
- a = 1
- 起了一个变量名 a
- 有个值 1
- 将值赋给变量名 =
- 命名规范
- 只能包含字母、数字、下划线
- 不能以数字开头，更不能是纯数字
- 不能使用Python中的关键字
- 不能使用中文和拼音
- 区分大小写
- 变量名要具有意义，易分辨
- 推荐写法
- 驼峰体：首字母大写
- 下划线(官方推荐)：alex_age = 98
- a = 1
常量
Python中没有真正的常量，约定变量名全部是大写的变量叫常量。注释
给一些不太能够理解的内容写一个描述 -- 增加程序的可读性
- 单行注释 ： # 注释内容，只能注释一行，不能换行
- 多行注释 ："""注释内容'""' '''注释内容'''
- 注释后的代码是不执行的
基础数据类型初始
- 字符串str
- 整型int
- 布尔值bool True(真) => 1，False(假) => 0
- 浮点数float
- 列表list
- 元组
- 字典
- 集合
用户输入input
temp = input(提示语句) 显示提示语句(可以是数字)并要求用户输入一个值
- python3版本中input获取到的全部都是字符串
- 拓展：import getpass 密码输入不可见
psd = getpass.getpass("请输入密码：")
格式化输出
%s 字符串占位
name = input("Name:") age = input("Age:") job = input("Job:") hobby = input("Hobbie:") info = ''' ------------ info of %s ----------- #这⾥的每个%s就是⼀个占位符，本⾏的代表 后⾯拓号⾥的 name Name : %s #代表 name Age : %s #代表 age job : %s #代表 job Hobbie: %s #代表 hobbie ------------- end ----------------- ''' % (name,name,age,job,hobbie) # 这⾏的 % 号就是 把前⾯的字符串 与拓号 后⾯的 变量 关联起来 print(info)- 字符串格式化的时候，占的数量和填充的数量要一致
- %% -- 转义，把占位转换成普通的%，当字符串中存在%占位时，必须用%%对%进行转义，才能得到普通的%
%d / %i 整型占位
占整型的位置，对应的填充必须是整型
f"{}"
print(f""" -------------info------------ name: {name} # {}内一般放变量，要放字符串需要加上'' age: {age} sex: {sex} job: {job} hobby: {hobby} --------------end------------ """) # f字符串拼接 -- 3.6版本以上才能使用format
name = "alex{}wusir{}" print(name.format("结婚了","要结婚了")） # 按照位置顺序填充 name = "alex{1}wusir{0}" # 按照索引位置填充 print(name.format("结婚了","要结婚了")) name = "alex{a}wusir{b}" print(name.format(a="结婚了",b="要结婚了")) # 指名道姓填充
基础运算符
赋值运算符
a = 1 a += 1 # a = a + 1 a -= 1 # a = a - 1 a *= 1 # a = a * 1 a /= 1 # a = a / 1 a //= 1 # a = a// 1 a **= 1 # a = a ** 1 a %= 1 # a = a % 1
算术运算符
- 加 +
- 减 -
- 乘 *
- 除 /
- 整除(地板除) //
- 幂运算 **
- 取余 %
逻辑运算符
not 非，非真即假，非假即真
and 与，并且，两边都为真的时候才是真
print(1 and 9) # and 两边都是真的时候取and后面的内容 print(False and 0) # 两边都是假的时候取and前面的内容
or 或，或者，有一边为真就是真
print(1 or 2) # or 两边都为真的时候取or前面的内容 print(1>2 or 2) # 有一边为真的时候返回真的内容 print(0 or 2>3) # 两边都为假的时候取or后面的内容
运算顺序
() > not > and > or
比较运算符
== != > >= < <=
成员运算符
in 可以判断xxx字符串是否出现在xxxxx字符串中
not in
a = "abc" print("a" in a) # True print("A" in a) # False print("a" not in a) # False
- 身份运算符
- is 判断是不是同一个值,指向同一个虚拟内存
- is not
编码
ASCII（American Standard Code for Information Interchange，美国标准信息交换代码）是基于拉丁字⺟的⼀套电脑编码系统，主要⽤于显示现代英语和其他⻄欧语⾔，其最多只能⽤ 8 位bit来表示（⼀个字节Byte），即：2**8=256，所以，ASCII码最多只能表示 256 个符号。
GBK, 国标码占⽤2个字节. 对应ASCII码GBK直接兼容. 因为计算机底层是⽤英⽂写的. 你不⽀持英⽂肯定不⾏. ⽽英⽂已经使⽤了ASCII码. 所以GBK要兼容ASCII.
Unicode，万国码，英文占2个字节，中文占4个字节
UTF-8: 每个字符最少占8位. 每个字符占⽤的字节数不定.根据⽂字内容进⾏具体编码. 是⽬前使⽤频率最⾼的⼀种编码。英文占1个字节，欧洲文字占2个字节，亚洲文字占3个字节。
单位转换
8bit = 1Byte
1024Byte = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
编码进阶
- python3内存使用的是unicode
- python2内存使用的是ascii
- 用什么编码就用什么解码
- encode():编码
- decode():解码
二，流程控制与循环
占位符
pass 和 ...
计算字符串的⻓度
len(字符串) -- 工厂函数 -- 所有类型都能用，除了int和bool 求元素个数
流程控制语句 if
if 条件A ： # 条件判断，> < == 等
代码块A # 条件A成立时运行代码块A
elif 条件B：
代码块B # 条件A成立，条件B成立时运行代码块B
else：
代码块C # 以上条件均不成立时运行代码块C
嵌套if
if 条件A ：
if 条件B：
代码块 # 条件A成立，并且条件B成立时运行代码块
while循环
while 条件A：
代码块A(循环体) # 当条件A成立时，运行循环体
else：
代码块B # 当条件A不成立时，运行代码块Bindex = 1 while index < 11: if index == 8: '''break,终止本层循环，不运行后面的代码,如果循环是通过break退出的. 那么while后⾯的else将不会被执⾏, 只有在while条件判断是假的时候才会执⾏这个''' '''continue,跳出本次循环，进行下次循环，重新判断条件，不运行后面的代码''' else: print(index) index = index+1 else: print("你好")
for循环
# for 变量 in 可迭代对象： # pass s = "1234567890" for each in s: # 遍历字符串 print(each) # 1 2 3 4 5 6 7 8 9 0 print(each) # 0 注意range
语法range(start,end,step): 范围，从start到end，不包含end，步长step默认是1
python3中打印range()会打印本身，python2中会打印出列表
for each in range(1,10): print(each) # 1 2 3 4 5 6 7 8 9
三，基础数据类型
字符串str 用' ',"" "" ,''' ''',""" """,引起来的内容是字符串
字符串拼接："a" + "b" => "ab" ，都是字符串才能相加
字符串 * 数字： "a" * 3 => "aaa"
用于储存小量的数据
python中用' '," "，''' ''',""" """括起来的就是字符串
常用操作
索引： 索引就是下标，从左向右， 从0开始；从右向左，从-1开始
num = "1234567890" print(num[1]) => 2 print(num[4]) => 5 print(num[-1]) => 0 print(num[-2]) => 9 print(num[21]) # 索引超出范围，报错
切片：使⽤索引来截取部分字符串的内容
语法: str[start: end: step]
规则: 顾头不顾尾， 从start开始截取， 截取到end位置，但不包括end。
num = "0123456789" num[::] == num[:] # 从头取到尾 print(num[0:3]） => 012 # 不包含索引3对应的"3" print(num[5:8]) => 567 print(num[5:]) => 56789 # 想取到最后，end可以不写 print(num[5:20]) => 56789 # 索引超出范围，不会报错 print(num[-1:-5:-1]) => 9876 # step步长决定取值的方向，默认为1 print(num[1:7:2]) => 135 # step步长决定取值的步子大小，即每step个取一个
常用方法
- 切记, 字符串是不可变的对象, 所以任何操作对原字符串是不会有任何影响的
name = "Hello World" print(name.upper()) => HELLO WORLD 字母全部转换成大写 print(name.lower()) => hello world 字母全部转换成小写 print(name.startswith("H")) => True 是否以"H"开头 print(name.endswith("d")) => True 是否以"d"结尾 print(name.count("o")) => 2 统计"o"出现的次数 print(name.replace("H","A"，次数) => Aello World # 将H替换成A，默认全部替换，可以输入替换次数 a = " Alex " print(a.strip()) => Alex # 去掉两端的某些元素，()内可以指定元素，默认是空白(空格和\n) b = "1,2,3" print(b.split(",")) => ["1","2","3"] # 分割，可以指定用于分割的元素，分割后损失这个元素，默认以空格分隔，返回一个列表。- is 判断系列
name.isdigit() # 判断是不是阿拉伯数字,有漏洞 name.isdecimal() # 判断是不是十进制，可以用于判断数字 name.isalpha() # 判断是不是中文和字母 name.isalnum() # 判断是不是中文，字母和数字
整型int
用于计算和比较，在python3中所有的整数都是int类型
二进制和十进制的转换
十进制转换成二进制：
正整数转换成二进制：除二取余，倒序排列，高位补零
14 % 2 = 0 7 % 2 = 1 3 % 2 = 1 1 % 2 = 1 0 14转换为二进制为：0000 1110
负整数先转换成对应的正整数，转换成二进制，对二进制取反，再对结果加一
二进制转换成十进制:
先将二进制补齐位数，如果首位是0代表是正整数，首位是1代表是负整数
正整数：补齐位数后，将二进制中的位数分别将下边对应的值相乘，然后相加得到十进制
1010 # 先补齐位数 => 0000 1010 128 64 32 16 8 4 2 1 常用的8位 2**3 *1 + 2**2 * 0 + 2**1 * 1 + 2**0 * 0 = 10
负整数，先对二进制取反，再进行换算
bit_length()
求十进制数转换成二进制时所占用的长度
布尔值bool True(真) => 1，False(假) => 0
True 真 非0数字 非空字符串
False 假 0 空字符串
类型转换：想要转换成什么类型，就用这个类型把需要转换的内容括起来
a = "hahahahaha" b = "123456" c = 123456 a1 = bool(a) => True b1 = int(b) => 123456 c1 = str(c) => "123456"
列表list
可以有序的存储大量数据，用以[ ]括起来，每个元素⽤' , '隔开⽽且可以存放各种数据类型。
列表时可变的，即可以在本身上进行修改。
列表的索引和切片
列表和字符串一样是有索引的，也是可迭代的
li = [1,2,3,"123",True] print(li) print(li[-2],type(li[-2])) # 索引查找 print(li[1:4]) # 支持切片 切片所得是列表 print(li[-2:1:-1]) # 支持步长
列表的增删改查
注意, list和str是不⼀样的. lst可以发⽣改变. 所以直接就在原来的对象上进⾏了操作
增
li.append("4") # 追加，在末尾添加一个元素 li.extend([5,6]) # 扩展，迭代添加."10" => "1","2" li.insert(0,"A") # 按索引位置插入一个元素，效率特别低 li2 = [4,5,6] li3 = li + li2 # 列表合并删
lst = ["麻花藤", "王剑林", "李嘉诚", "王富贵"] deleted = lst.pop() # 弹出，可以指定索引位置，默认弹出最后一个元素，有返回值，返回的是弹出的元素 el = lst.pop(2) # 删除2号元素 lst.remove("麻花藤") # 删除指定元素，必须知道元素的内容 lst.remove("哈哈") # 删除不存在的元素会报错 lst.clear() # 清空list，清除列表内全部的信息，得到一个空列表 del lst[2] # 删除特定索引位置的元素 del lst[1:3] # 删除特定索引范围内的元素，也可以改变步长改
li = [1,2,3,"123",True] li[0] = "1" # 指定位置修改 li[1:3] = [9,8,7] # 迭代修改，支持切片修改 # 使用步长时注意取几个必须放几个，步长为1时则不需要注意个数。查
li = [1,2,3,"123",True] print(li[1]) # 指定索引位置查询 for each in li: print(each) # 列表是⼀个可迭代对象, 所以可以进⾏for循环
列表的嵌套
采用降维操作，一层一层的看
li = [1,2,3,"123",[9,8,7]] li[-1][0] => 9
元组tuple
俗称不可变的列表。⼜被成为只读列表，元组也是python的基本数据类型之⼀，⽤⼩括号括起来,⾥⾯可以放任何数据类型的数据，查询可以，循环也可以，切片也可以，但就是不能改。
tu = (1,2,3,"123",[1,2,3]) for each in tu: print(each) # 元组也是可以迭代的，可以用for循环遍历 tu = (1，) # 注意，如果元组中只有一个元素，一定要在后面添加一个逗号，否则就不是元组 tu = () tu = tuple() # 创建空元组
- 关于不可变， 注意: 这⾥元组的不可变的意思是⼦元素不可变。⽽⼦元素内部的⼦元素是可以变，这取决于⼦元素是否是可变对象。
- 元组也有count(), index(), len()等⽅法
元组的嵌套
- 参照列表的嵌套
字典dict
字典(dict)是python中唯⼀的⼀个映射类型.他是以{ }括起来的键值对组成. 在dict中key是唯⼀的. 在保存的时候, 根据key来计算出⼀个内存地址. 然后将key-value保存在这个地址中.这种算法被称为hash算法, 所以, 在dict中存储的key-value中的key必须是可hash的,可哈希就意味着不可变.
语法
{key1: value1, key2: value2....}
注意:key必须是不可变的(可哈希的),value可以保存任意类型的数据
特点
- 无序:python3.6版本以上默认了咱们定义的顺序,python3.5以下是随机显示的.
- 可变的
- 可以存储大量数据,比列表还要大
- 能够将数据进行关联,比较消耗内存
字典的相关操作
新增
dic = {"a":"b","b":"c"} dic["c"] = ["d"] # 给出key和value添加,如果key已存在则会替换value dic.setdefault("c","d") # 先去字典中查看key存不存在,如果key存在会返回key所对应的value(可用于查找),如果key不存在就添加key和value删除
注意:字典没有remove
dic = {"a":"b","b":"c"} dic.pop("a") # 指定key弹出,有返回值,返回删除的value dic.popitem() # 随机弹出,有返回值,返回删除的value del dic["a"] # 指定key删除 del dic # 删除整个字典 dic.clear() # 清空字典,得到空字典修改
dic[key] = "新的值" # 指定key修改,key不存在就新增 dic.update({1:2,'a':'a1'}) # 用字典更新字典,存在的替换,没有的新增,原来有这次没有的不变查询
查询只能通过key获取value,不能通过value获取key.
print(dic[key]) # 指定key查找value,key不存在会报错 print(dic.get(key,"返回")) # 指定key查找value,key不存在会返回给出的返回值,默认None
其他相关操作
dic = {"id": 123, "name": 'sylar', "age": 18, "ok": "科⽐"} dic.keys() # 得到key的高仿列表,但不是列表,不支持索引,支持迭代遍历 dic.values() # 得到value的高仿列表 dic.items() # 得到由(key,value)成对组成的元组组成的列表 for el in dic: # 遍历列表得到key for el in dic.keys(): for el in dic.values(): for el in dic.items(): => (key,value) for k,v in dic.items(): => 得到key和value for el in enumerate(dic,start): # 给你要迭代的对象加一个序号start默认是0,枚举字典的嵌套
dic = { 101:{1:['周杰伦','林俊杰'],2:{'汪峰':['国际章','前妻一','前妻二']}} 102:{1:['李小龙','吴京','李连杰'],2:{'谢霆锋':['张柏芝','王菲']},3:['大象','奇奇']} 103:{1:['郭美美','干爹'],2:{'王宝强':['马蓉','宋哲']}} } print(dic["102"][3][0]) => "大象" # 逐层用key查找
set集合
集合就是一个没有value的字典:无序,去重,可哈希
集合是可变的
语法{1,2,3,4,5}
相关操作
增
s.update() # 迭代添加 s.add() # 单个添加
删
s.pop() # 随即删除 s.remove() # 指定元素删除 s.clear() # 清空 del s # 删除整个集合
改
只能删了再加
查
可以用for循环遍历
其他操作
s1 = {1,2,3,4} s2 = {3,4,5,6} print(s1 - s2) # 差集 1,2 print(s1 | s2) # 并集 1,2,3,4,5,6 print(s1 & s2) # 交集 3,4 print(s1 ^ s2) # 反交集 1,2,5,6 print(s1 > s2) # s1是s2的超集,父集 print(s1 < s2) # s1是s2的子集 f_s = frozenset({1,2,3,4,5,6}) # 冻结集合--变成不可变重要用法
lis = [1,2,2,3,2,4,5,6,5,6,7] print(list(set(lis))) => [1,2,3,4,5,6,7] # 去重是集合最重要的用法
基础数据类型补充
字符串str
s = "aa111aa" print(s.capitalize()) # 首字母大写,只有第一个字母大写 print(s.title()) # 每个单词首字母大写,单词中间用特殊字符或中文隔开 print(s.count("a")) # 统计"a"出现的次数 print(s.swapcase()) # 大小写转换 print(s.find("a")) # 查找"a"的第一个索引,查找不到的时候返回-1 print(s.index("a")) # 查找"a"的第一个索引,查找不到的时候报错列表list
li = [1,2,3,4] l2 = list("1234") # 定义的一种方式 print(li.count(1)) # 统计1出现的次数 print(li.index(1)) # 查找1的第一个索引,查找不到就报错 li.reverse() # 原地反转 li.sort(reverse=True) # 排序,默认升序,加True就降序元组tuple
tu = (1,2,3,4,5) tu1 = tuple("12345") # 定义的一种方式 tu.count(1) # 统计 tu.index(1) # 通过元素找索引,找不到就报错字典dict
dic = {1:"a",2:"b"} dic1 = dict(k=1,k1=2) # 定义的一种方式 dic.popitem() # 随机删除,返回删除的值,3.6版本后默认删除最后一个键值对 dic2 = dict.fromkeys("123",1) # 批量创建字典,迭代key,value相同,指向同一内存地址结合set
s = set("1234") # 定义的一种方式类型转换
str => int :字符串中必须全部都是十进制的数字 int => str :直接转换 str => list : s = "1234" lst = list(s) => ["1","2","3","4"] 或用split()切割 list => str :使用join进行拼接,元素中不能有int list => tuple :直接转换 set => list :直接转换 总结: 字符串 -- 数字 :字符串中必须都是十进制的数字 数字 -- 字符串 :直接转换 列表 -- 字符串 :join()拼接--可迭代的对象中不能出现数字 字符串 -- 列表 :split()分割 除字典外,容器数据类型都能直接相互转换
总结
有序: str,int,bool,list,tuple 无序: dict,set 可变: list,dict,set 不可变: str,int,bool,tuple 访问方式: 直接访问: int,bool,set 顺序访问:str,list,tuple 键访问: dict
坑人的删除
li = [1,2,3,4,5] # 面试题:要求用一个for循环对删除上述列表索引为奇数位置的元素 for el in range(len(li)-1,-1,-1): if el % 2 == 1: li.pop(el) print(li) # 尽量不要在for循环遍历列表的同时修改列表本身的大小 # for循环迭代字典过程中改变字典的大小会报错
四,小数据池和深浅拷贝
小数据池
- 小数据池:⼀种数据缓存机制. 也被称为驻留机制. 各⼤编程语⾔中都有类似的东⻄.用于提高效率.
- 支持的数据类型:str,int,bool
- id() -- 查看元素的内存地址
- is 和 ==
- is 判断两个元素的内存地址是否相同
- == 判断两个元素的值是否相同
- 小数据池规则:
- 数字:-5~256
- 字符串:
- 字符串在做乘法(乘数不为1)的时候总长度不能超过20
- 自己定义的字符串长度不限制,字符串必须是由字母,数字,下划线组成
- 特殊字符(中文除外)定义1个的时候,进行驻留
- 代码块:一个文件,一个模块,一个函数,一个类,终端中每一行都是一个代码块
- 数字:全部驻留
- 字符串:
- 自己定义的字符串全部驻留
- 字符串做乘法(乘数不为1)的时候总长度不能超过20
- python3.7以上版本乘法的时候总长度不能超过4096
深浅拷贝
赋值 =
赋值没有创建新的空间,多个变量指向同一个内存地址.
浅拷贝
- l2 = l1[:] 和 l2 = l1.copy()
- 只拷贝第一层元素
- 会创建一个新的容器,容器中的元素和原容器的元素指向同一个内存地址
深拷贝
import copy
l2 = copy.deepcopy(l1)
不可变的数据类型和原数据指向同一空间
可变数据类型会创建一个新的空间
五,文件操作
语法
# f = open("文件路径", mode="模式", encoding="编码") # open() 调用操作系统打开文件 # mode 对文件的操作方式 # encoding 文件的编码 -- 存储编码要统一 # win -- 默认gbk # linux,mac -- 默认utf-8 # f 文件句柄 -- 操作文件的途径# 另一种打开文件的方式: 帮助自动关闭文件;可以同时开多个文件,用逗号隔开;也可以同时操作一个文件 with open("a", mode="r", encoding="utf-8") as f,\ open("b", mode="w", encoding="utf-8") as f1: import os print(os.getcwd()) # 查看当前工作路径 os.remove() # 删除文件 os.rename() # 更改文件名.(旧名,新名)模式
读
# r f = open("a", mode="r", encoding="utf-8") contend = f.read() # 全部读取 print(contend) print(f.read(3)) # 字符读取 print(f.readline()) # 读取一行,()内可以加入需要读取本行的几个字符 print(f,randlines()) # 读取每一行,存储到列表中 for line in f: # 一行一行读取 -- 防止内存溢出 print(line) # rb -- 读非文本文件,不能指定编码, f = open("a", mode="rb") print(f.read(3)) # 读取3个字节 # r+ -- 读写 -- 先读后写 f = open("a", mode="r+", encoding="utf-8") print(f.read()) f.write("你好啊") f.flush() f.close() # 关闭文件,释放内存 # r+b写
# w 清空写 -- 没有文件就创建,有就打开,先清空,再写入 f = open("a", mode="w", encoding="utf-8") f.write("乳娃娃") # 不能写入int f.flush() f.close() # wb # w+ -- 先清空,写入,再读.用不着 # w+b# a 追加写 -- 文件末尾写入 f = open("a", mode="a", encoding="utf-8") f.write("啊啊啊啊啊啊啊,好烦啊") f.flush() f.close() # ab # a+ -- 追加读,光标默认在末尾 f = open("a", mode="a+", encoding="utf-8") print(f.read()) f.write("真的废物") # a+b
其他操作
- 绝对路径 -- 从磁盘的根处查找
- 相对路径 -- 相对于当前文件进行查找
- tell() -- 查看光标位置,单位是字节
- seek(偏移量,起始位置) -- 起始位置默认0--开头,1--当前位置,2--末尾
来源：https://www.cnblogs.com/zyyhxbs/p/11023164.html