python笔记
1. 主要使用的变量
# int
# float
# boolean
# string
# list
# tuple
# dict
# int
money = 5000
# float
apple = 1.2
# boolean
sex = True
gender = False
# string
# 不允许单引号套单引号，双引号套双引号
st = '田中脊髓剑'
s1 = '"好家伙"'
s2 = "'好家伙'"
print(s1+','+s2)
# list
name_list = ['周杰伦','闪电旋风劈']
print(name_list)
# tuple
age_tuple = (18,19,10)
print(age_tuple)
# dict
# 应用于scrapy框架使用
person = {'name':'收藏夹','age':'18'}
print(person)
使用type()来查看变量的数据类型
# type判断变量数据类型
print(type(person))2. 类型转换
2.1 转换为整数型
# str --> int
a = '123'
print(type(a))
b = int(a)
print(type(b))
# float --> int
c = 1.66
print(type(c))
d = int(c)
print(d)
#此处输出的数为小数点前面的数字，此处为1，不会四舍五入
print(type(d))
# boolean --> int
# True ---> 1
# False ---> 0
e = True
print(type(e))
f = int(e)
print(f)
#输出为1
print(int(f))
g = '1.23'
print(type(g))
h = int(g)
print(h)
#此操作会出现以下报错，因为出现了非法字符，无法完成类型转换
"""
Traceback (most recent call last):
File "E:/CODE/pycharm/type_of_python.py", line 57, in <module>
h = int(g)
ValueError: invalid literal for int() with base 10: '1.23'
"""
i = '12ab'
print(type(i))
j = int(i)
print(j)
#此处依旧会报错
#则说明字符串当中如果出现非法字符，则依旧不能够进行转换
2.2 转换为浮点数
# str --> float
a1 = '12.34'
print(type(a1))
b1 = float(a1)
print(b1)
print(type(b1))
# int --> float
a2 = 666
print(a)
print(type(a))
b2 = float(a2)
print(b2)
print(type(b2))
#以下是输出结果
"""
666
<class 'int'>
666.0
<class 'float'>
"""
2.3 转换为字符串类型
# int --> string
a3 = 80
print(type(a))
b3 = str(a3)
print(b3)
print(type(b3))
# float --> string
a4 = 1.2
print(type(a4))
b4 = str(a4)
print(b4)
print(type(b4))
# boolean --> string
a5 = True
print(type(a5))
b5 = str(a5)
print(b5)
# 终端输出的是True
print(type(b5))2.4 转换为布尔类型
# int --> boolean
aa = 2
print(type(aa))
bb = bool(aa)
print(bb)
#输出为True
print(type(bb))
# float --> boolean
a6 = 1.2
print(type(a6))
b6 = bool(a6)
print(b6)
# 输出为True
print(type(b6))
# 对非零数（包含正数和负数）进行bool类型转换，全部都是True
# string --> boolean
as1 = 'haojiahuo'
as2 = ''
as3 = ""
print(type(as1))
print(type(as2))
print(type(as3))
bs1 = bool(as1)
bs2 = bool(as2)
bs3 = bool(as3)
print(bs1)
# 输出为True
print(bs2)
# 输出为Flase
print(bs3)
# 输出为Flase
print(type(bs1))
print(type(bs2))
print(type(bs3))
# 只要字符串值不为空，则转换为bool类型为True
# list --> boolean
al1 =['好家伙','好家伙1','绷不住','绷不住2']
print(type(al1))
bl1 = bool(al1)
print(bl1)
# 输出为True
print(type(bl1))
al2 = []
print(type(al2))
bl2 = bool(al2)
print(bl2)
# 输出为Flase
print(type(bl2))
# 只要列表中有数据，那么强制类型转换为bool时，就返回True
# tuple --> boolean
at1 = (1,2,3,4)
at2 = ('asa','asas','sasa')
at3 = ()
print(type(at1))
print(type(at2))
print(type(at3))
bt1 = bool(at1)
bt2 = bool(at2)
bt3 = bool(at3)
print(bt1)
# 输出为True
print(bt2)
# 输出为True
print(bt3)
# 输出为Flase
print(type(bt1))
print(type(bt2))
print(type(bt3))
# 只要元组中有数据，那么强制类型转换为bool时，就返回True
# dict --> boolean
ad1 = {'name':'jiji'}
print(type(ad1))
bd1 = bool(ad1)
print(bd1)
# 输出为True
print(type(bd1))
ad2 = {}
print(type(ad2))
bd2 = bool(ad2)
print(bd2)
# 输出为Flase
print(type(bd2))
# 只要字典中有数据，那么强制类型转换为bool时，就返回True因此转换为bool类型时，以下情况为False
print(bool(0))
print(bool(0.0))
print(bool(''))
print(bool(""))
print(bool([]))
print(bool(()))
print(bool({}))3. 运算符
运算符的基础使用
a = 3
b = 2
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a // b)#取整
print(a % b)#取余
print(a ** b)#取指数
print((5 + 1) * 2)
print(5 + 1 * 2)
# 输出如下
1
6
1.5
1
1
9
12
7
字符串的加法意思是两字符串进行拼接，字符串无法与其他类型进行运算。
字符串乘以n是将相同字符串拼接n次
赋值运算符
a = 10
print(a)
b = c =20
print(a , b , c)
d,e,f = 1,2,3
print(d,e,f)复合赋值运算符
a = 1
a = a + 2
print(a)
a += 2
print(a)
a = a * 3
print(a)
a *= 3
print(a)
a = a -2
print(a)
a -= 2
print(a)
a = a /2
print(a)
a /= 2
print(a)
a = a // 2
print(a)
a //= 2
print(a)
a = a % 5
print(a)
a %= 5
print(a)
a = a ** 3
print(a)
a **= 3
print(a)
#输出结果如下
3
5
15
45
43
41
20.5
10.25
5.0
2.0
2.0
2.0
8.0
512.0
进程已结束,退出代码0
比较运算符
# 与C语言基本一致逻辑运算符
# and 与 or 或 not非
# True and True ----> True
# True and Flase ----> Flase
# Flase and Flase ----> Flase
# True or True ----> True
# True or Flase ----> True
# Flase or Flase ----> Flase
# not True ----> Flase
# not Flase ----> True逻辑运算符的使用
# 短路与的应用
a = 36
a > 10 and print(a)
# 输出是36
a < 10 and print(a)
# 无输出
# 当and 前面的结果是False的情况下，那么后面的代码就不再执行了
# 短路或的应用
a = 38
a > 39 or print(a)
# 输出38
a < 39 or print(a)
# 无输出
# 只要or的前条件成立，后条件就不执行4. 输入输出
普通输出
# 普通输出
print('好家伙')
# 格式化输出
# scrapy框架中会用到，会将数据放在 excel文件、mysql、redis
age = 18
print('my age is' + str(18))# print('my age is ' + 18)违规
name = '李工'
# %s 代表的是字符串 %d 代表的是数值
print('我的名字是%s,我的年龄是%d'% (name,age))
"""
输出结果如下:
好家伙
my age is18
我的名字是李工,我的年龄是18
"""
普通输入
# 普通输入
input('请输入您的姓名')#需要回车来进行确认
name = input('请输入您的姓名')
print(name)
print('我的名字是：%s' % name)
print('我的名字是' + name)5. 流程控制语句
if判断语句
# if判断条件
# 如果判断为True的时候执行下列内容
#如果年龄大于8岁，则可以开车
age = 19
if age > 18:
print('你可以开车了')
gender = True
if gender == True:
print('你是一个男性')if案例
# 在控制台上输入一个年龄，如果年龄大于18，那么就可以去网吧了
age = input('请输入您的年龄')#input返回的是字符串类型
if int(age) > 18:
print('可以去网吧了')if_else 关键词
# if_else 关键词
# if 判断条件：
# 判断条件为True的时候执行的代码
# else：
# 判断条件为False的时候执行的代码
agee = 17
if agee > 18:
print('可以去网吧')
else:
print('回家写作业吧')if_else案例
# if_else 案例
ag = input('请输入年龄')
if int(ag) > 18:
print('欢迎光临')
else:
print('回家吧')elif语句
#elif 语句
# 控制台输入成绩
score = int(input('请输入您的成绩'))
if score >= 90:
print('优秀')
elif score >= 80:
print('良好')
elif score >= 70:
print('中等')
elif score >= 60:
print('及格')
else:
print('不及格')for语句
for语句语法格式：
for 临时变量 in 待处理数据集 (序列):
循环满足条件时执行的代码for循环无法定义循环条件，只能被动取出数据处理
# for循环语句
"""
for
格式：
for 变量 in 要遍历的数据:
方法体
"""
s = 'china'
print(s[0])
# 输出 c
for i in s:
print(i)
"""
输出：
c
h
i
n
a
"""
# range(5) --> （0，4） 左闭右开区间
for i in range(5):
print(5)
"""
输出：
5
5
5
5
5
"""
# range(1,6) --> (0,5)
for i in range(1,6):
print(i)
"""
输出：
1
2
3
4
5
"""
# range(1,10,3) --> range(起始值,结束值,步长)
for i in range(1,10,3):
print(i)
"""
输出：
1
4
7
"""
a_list = ['周杰伦','林俊杰','芜湖']
print(len(a_list))#输出 3
for i in range(len(a_list)):
print(i)
"""
输出：
0
1
2
"""
for i in range(len(a_list)):
print(s[i])
"""
输出：
c
h
i
"""
while语句
# while 条件:
#当条件满足时，会无限循环执行
i = 0
while i < 10:
print('hello')
i += 1
"""
输出：
hello
hello
hello
hello
hello
hello
hello
hello
hello
hello
"""
# while 案例
import random
num = random.randint(1,100)
count = 0
flag = True
while flag:
guess_num = int(input("guess a number"))
count += 1
if guess_num == num:
print('猜中了')
flag = False
else:
if guess_num > num:
print('it is big')
else:
print('small')
print(f'you have guess {count} times')
"""
guess a number1
small
guess a number88
it is big
guess a number55
small
guess a number66
small
guess a number77
small
guess a number80
猜中了
you have guess 6 times
进程已结束,退出代码0
"""
6. 数据类型的高级使用
字符串的高级使用
获取长度 len
s = 'china'
print(len(s))
c
查找内容 find
s1 = 'china'
print(s1.find('c'))
# 输出 0判断 startswith.endswith
s2 = 'china'
print(s2.startswith('c'))# 输出 True
print(s2.endswith('w'))# 输出 False计算出现次数 count
s3 = 'aaabbb'
print(s3.count('a'))
# 输出 3替换内容 replace
s4 = 'dddccd'
print(s4.replace('c','d'))
#输出 dddddd切割字符串 split
s5 = '1#2#3#4'
print(s5.split('#'))
#输出：['1', '2', '3', '4']修改大小写 upper,lower
s6 = 'Leijianx'
print(s6.upper())#输出 LEIJIANX
print(s6.lower())#输出 leijianx空格处理 strip
s7 = ' a '
print(len(s7))#输出 8
print(len(s7.strip()))#输出 1字符串拼接 join
s9 = '1'
print(s9.join(('hello')))
#输出 h1e1l1l1o列表的高级使用
添加元素的方法
append 在末尾添加元素
# append
food_list = ['haojaihuo','widhaidhi']
print(food_list)
#输出： ['haojaihuo', 'widhaidhi']
food_list.append('dhjaw')
print(food_list)
#输出：['haojaihuo', 'widhaidhi', 'dhjaw']insert 在指定位置插入元素
# insert
char_list = ['a','c']
print(char_list)
#输出：['a', 'c']
char_list.insert(1,'b')
print(char_list)
#输出：['a', 'b', 'c']extend 合并两个列表(底层用的append)
# extend
num_list = [1,2,3]
num_list2 = [4,5,6]
num_list.extend(num_list2)
print(num_list)
# 输出： [1, 2, 3, 4, 5, 6]修改元素的方法
city_list = ['北京','上海','深圳','武汉','洛阳']
print(city_list)
# output: ['北京', '上海', '深圳', '武汉', '洛阳']
city_list[4] = '大连'
print(city_list)
# output:['北京', '上海', '深圳', '武汉', '大连']查询元素的方法
co_list = ['火爆肉','锅贴','地三鲜']
co = input("请输入您想吃的食物")
if co in co_list:
print('在')
else:
print('不在')
ball_list = ['篮球','排球','羽毛球']
ball = input('请输入您喜欢的球类运动')
if ball not in ball_list:
print('不在')
else:
print('在')
删除元素的操作
a_list = [1,2,3,4,5,6]
print(a_list)
#输出 ：[1, 2, 3, 4, 5, 6]
#根据下标删除list中的元素
del a_list[3]
print(a_list)
#输出 ：[1, 2, 3, 5, 6]
# 删除最后一个元素
a_list.pop()
print(a_list)
# 输出：[1, 2, 3, 5]
#根据元素的值进行删除
a_list.remove(2)
print(a_list)
#输出：[1, 3, 5]
元组的高级使用
Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。
#元组
a_tuple = (1,2,3,4)
print(a_tuple[0]) # 输出：1
print(a_tuple) #输出： (1，2，3，4)
a_tuple[0] = 6
print(a_tuple)
"""
输出：
Traceback (most recent call last):
File "E:/CODE/pycharm/use_of_tuple.py", line 12, in <module>
a_tuple[0] = 6
TypeError: 'tuple' object does not support item assignment
"""
Python不允许修改元组的数据，包括不能删除其中的元素
b_tuple = (5)
print(type(b_tuple))
#输出： <class 'int'>
c_tuple = (5,)
print(type(c_tuple))
# 输出： <class 'tuple'>当元组中只有一个数据的时候，那么这个元组将会被作为整型进行运算。不过可以在唯一的数据后添加“,”来强制转换为元组类型。
切片
切片是指对操作的对象截取其中一部分操作。字符串、列表、元组都支持切片操作。
切片的语法：[起始:结束:步长]，或者是[起始:结束]
注意：选取的区间是从“起始位”开始，到“结束”位的前一位结束（不包含结束位本身），步长表示选取间隔。
a = 'hello,world'
#在切片中直接写一个下标
print(a[1])# 输出：e
# 左闭右开区间，包含左边的数据，不包含右边的数据
print(a[0:4])# 输出：hell
#从起始值开始一直到末尾
print(a[1:])# 输出：ello,world
#从下标为零的元素开始 依旧遵循左闭右开区间
print(a[:4])# 输出：hell
#从下标为0的位置开始，到下标为6的位置结束，每次增长两个长度
print(a[0:6:2])#输出：hlo字典的高级
字典的查询
person = {'name':'ll','age':'10'}
print(person) #output:{'name': 'll', 'age': '10'}
print(person['name']) #output:ll
print(person['sex'])
"""
Traceback (most recent call last):
File "E:/CODE/pycharm/use_of_dict.py", line 10, in <module>
print(person['sex'])
KeyError: 'sex'
"""
print(person.name)
"""
Traceback (most recent call last):
File "E:/CODE/pycharm/use_of_dict.py", line 18, in <module>
print(person.name)
AttributeError: 'dict' object has no attribute 'name'
"""
print(person.get('name')) #output:ll
print(person.get('sex')) #output:None字典的修改
son = {'name':'sh','age':'19'}
print(son)# output:{'name': 'sh', 'age': '19'}
son['name'] = 'szj'
print(son)# output:{'name': 'szj', 'age': '19'}字典的添加
person = {'name':'ll','age':'10'}
print(person) #output:{'name': 'll', 'age': '10'}
person['keys'] = '0909'
print(person)# output:{'name': 'll', 'age': '10', 'keys': '0909'}字典的删除
指定元素删除
print(person)# output:{'name': 'll', 'age': '10', 'keys': '0909'}
del person['age']
print(person)# output:{'name': 'll', 'keys': '0909'}删除整个字典
del person
print(person)
"""
Traceback (most recent call last):
File "E:/CODE/pycharm/use_of_dict.py", line 50, in <module>
print(person)
NameError: name 'person' is not defined
"""清空字典，但是保留字典结构
# clear
print(son) #output:{'name': 'szj', 'age': '19'}
son.clear()
print(son)# output:{}字典的遍历
所谓遍历就是将数据一个一个的输出
遍历字典的key
#遍历字典的key
hell = {'name':'lili','host':'op','cctv':'9'}
for key in hell.keys():
print(key)
"""
输出：
name
host
cctv
"""
遍历字典的value
#遍历字典的value
for value in hell.values():
print(value)
"""
输出：
lili
op
9
"""遍历字典的key和value
#遍历字典的key和value
for key,value in hell.items():
print(key,value)
"""
输出：
name lili
host op
cctv 9
"""遍历字典的项/元素
#遍历字典的项/元素
for key in hell.items():
print(key,value)
"""
输出：
('name', 'lili') 9
('host', 'op') 9
('cctv', '9') 9
"""
for value in hell.items():
print(key,value)
"""
输出：
('cctv', '9') ('name', 'lili')
('cctv', '9') ('host', 'op')
('cctv', '9') ('cctv', '9')
"""7. 函数的使用
函数的定义与调用
#函数的定义
def f1():
print('jkjks')
print('djskdj')
#调用函数
f1()
"""
输出：
jkjks
djskdj
"""函数的参数
def sum():
a = 1
b = 2
c = a + b
print(c)
sum()
"""
输出：
3
"""
# 位置参数
def sum1(a,b):
c = a + b
print(c)
sum1(100,200)
# 输出：300
#关键词传参
def sum1(a,b):
c = a + b
print(a)
print(c)
sum1(b = 200,a = 100)
# 输出： 100
# 300函数的返回值
返回值就是函数完成一件事情后，最后给调用者的结果。
#函数的返回值
#返回值的关键词是return，存在函数中
def buyIceCream():
return '冰淇淋'
food = buyIceCream()
print(food)
# 输出：冰淇淋
#定义一个函数，然后让函数计算两个数值之和，并返回这个计算的结果
def add(a,b):
c = a + b
return c
a = add(22,121)
print(a)
#输出：143局部变量和全局变量
局部变量：在函数内部定义的变量，其作用域范围是函数内部，函数外部不可用
#局部变量
def f1():
a = 1
print(a)
f1()#输出：1
print(a)
"""
Traceback (most recent call last):
File "E:/CODE/pycharm/use_of_function.py", line 75, in <module>
print(a)
NameError: name 'a' is not defined
说明这个a未被定义，只能在函数内部使用
"""全局变量：定义在函数外部的变量，我们称之为全局变量，可在函数外部使用，也可在函数内部使用
# 全局变量
a = 1
print(a)
def f1():
print(a)
f1() #输出：1
print(a) #输出：1但是在满足条件的情况下，要使用作用域最小的一个范围
8. 文件的操作
文件的打开与关闭
在python中使用open函数，可以打开一个已经存在的文件，或者创建一个新的文件。
open(文件路径,访问模式)
文件路径：
绝对路径：指的是绝对位置，完整地描述了目标所在地，所有目录层级关系是一目了然的。从电脑盘符开始就基本就是绝对路径。
相对路径：是指从当前文件所在文件夹开始的路径。
test.txt，是指在当前文件夹中查找test.txt文件
./test.txt，也是在当前文件夹中查找test.txt文件，./表示的是当前文件夹。../test.txt，从当前文件夹的上一级文件夹中查找test.txt文件。../表示的是上一级文件夹
demo/test.txt，在当前文件夹里查找demo这个文件夹，并在这个文件夹里查找test.txt文件
访问模式：
f = open('test.txt','w')
"""
文件夹中本没有test.txt，但w模式在该文件夹中创建了一个test.txt的空白文件
"""
f.write('hello,world')
# test.tst空白文件中出现：hello,world
fp = open('demo/test.txt','w')
"""
Traceback (most recent call last):
File "E:/CODE/pycharm/use_of_document.py", line 15, in <module>
fp = open('demo/test.txt','w')
FileNotFoundError: [Errno 2] No such file or directory: 'demo/test.txt'
这个模式下不能创建文件夹，需要手动创建
"""关闭文件
#关闭一个文件
f = open('test.txt','w')
f.close()
#用完一个文件一定要关闭文件的读写
#文件的写入
fp = open('test.txt','w')
fp.write('EdgeRunner\n' * 5)
fp.close()
"""
输出：
EdgeRunner
EdgeRunner
EdgeRunner
EdgeRunner
EdgeRunner
原来的数据都消失了
如果文件存在，会在原来的情况清空再写
模式a才是追加写入而不是覆盖写入
"""
pf = open('test.txt','a')
pf.write('Lucy & David\n' * 5)
pf.close()
"""
输出：
EdgeRunner
EdgeRunner
EdgeRunner
EdgeRunner
EdgeRunner
Lucy & David
Lucy & David
Lucy & David
Lucy & David
Lucy & David
"""
#读数据
gf = open('test.txt','r')
contain = gf.read()
print(contain)
gf.close()
"""
输出：
EdgeRunner
EdgeRunner
EdgeRunner
EdgeRunner
EdgeRunner
Lucy & David
Lucy & David
Lucy & David
Lucy & David
Lucy & David
"""
# read是一字节一字节的读，效率比较低
jk = open('test.txt','r')
contain = jk.readline()
print(contain)
# 输出：EdgeRunner
contain = jk.readlines()
print(contain)
#输出：['EdgeRunner\n', 'EdgeRunner\n', 'EdgeRunner\n', 'EdgeRunner\n', 'Lucy & David\n', 'Lucy & David\n', 'Lucy & David\n', 'Lucy & David\n', 'Lucy & David\n']
序列化和反序列化
通过文件操作，我们可以将字符串写入到一个本地文件。但是，如果一个对象（例如列表、字典、元组等），就无法直接写入到一个文件里，需要对这个对象进行序列化，然后才能写入到文件里。
序列化：设计一套协议，按照某种规则，把内存中的数据转换成字节序列，保存在文件，这就是序列化。（对象-->字节序列）
反序列化：从文件的字节序列恢复到内存当中（字节序列-->对象）
python提供了JSON这个模块进行实现数据的序列化和反序列化
JSON（JavaScriptObjectNotation，JS对象简谱）是一种轻量级的数据交换标准本质就是字符串。
JSON提供了dump和dumps方法，将一个对象进行序列化。
dump方法的作用是把对象转换为字符串，本身并不具备将数据写入文件的功能。
fp = open('test.txt','w')
# 默认情况下，我们只能将字符串写入到文件中
fp.write('leijianx')
fp.close()
fp = open('test.txt','w')
# 默认情况下，我们只能将字符串写入到文件中
name_list = ['leijianx','6']
fp.write(name_list)
fp.close()
"""
Traceback (most recent call last):
File "E:/CODE/pycharm/use_of_dump_or_dumps.py", line 15, in <module>
fp.write(name_list)
TypeError: write() argument must be str, not list
对象类型（元组，字典，列表）无法写入到文件中。
"""序列化的两种方式
dumps()
# dumps
#创建一个文件
fp = open('test.txt','w')
# 定义一个列表
name_list = ['sc','lei']
#导入json模块到该文件中
import json
#序列化
names = json.dumps(name_list)
print(names)
#输出：["sc", "lei"]
print(type(names))
#输出：<class 'str'>,将python对象变成json字符串
fp.write(names)
#输出：["sc", "lei"]
fp.close()dump()
#dump
# 在讲对象转换为字符串的同时，指定一个文件的对象，然后把转换后的字符串写入到这个文件里
fp = open('test.txt','w')
name_list = ['sc','lei']
import json
json.dump(name_list,fp)
#输出：["sc", "lei"]
fp.close()反序列化
# 反序列化
#loads
fp = open('test.txt','r')
content = fp.read()
print(content)
#输出：["sc", "lei"]
print(type(content))
#输出：<class 'str'>
import json
# 将json字符串转换为python对象
result = json.loads(content)
print(result)
#输出：['sc', 'lei']
print(type(result))
#输出：<class 'list'>
fp.close()
#load
fp = open('test.txt','r')
import json
result = json.load(fp)
print(result)
#输出：['sc', 'lei']
print(type(result))
#输出：<class 'list'>
fp.close()9. 异常
在程序运行当中，由于我们的编码不规范，或者其他原因一些客观原因，导致我们程序无法继续运行，此时程序就会出现异常。如果我们不对异常进行处理，程序可能会由于异常直接中断掉，为了保证程序的健壮性，我们在程序设计里提出了异常处理这个概念
读取文件异常
当所读取的文件不存在时，就会报出
FileNotFoundError错误# # 文件读取异常 # # fp = open('rrr.txt','r') # # fp.read() # fp.close() """ Traceback (most recent call last): File "E:/CODE/pycharm/Various_Error.py", line 9, in <module> fp = open('rrr.txt','r') FileNotFoundError: [Errno 2] No such file or directory: 'rrr.txt' """ try: fp = open('rrr.txt','r') fp.read() except FileNotFoundError: print('该文件不存在在该系统中') # 输出：该文件不存在在该系统中
评论区