一、数字类型
1.int类型：
基本使用：
用途：用于年龄，手机号，身份证号；
定义：
age=18；
常用操作+内置方法：
正常的运算赋值；
进制转换：
print(bin(3)); 把十进制3转换成二进制并输出，结果为0b11
print(oct(8));把十进制8转换成八进制并输出，结果为0o10
print(hex(16));把十进制16转换成十六进制并输出，结果为0x10
2.float类型
基本使用：
用途：用于身高，体重，薪资；
定义：
heighe=1.81;
常用操作+内置方法：
正常的运算赋值；
3.int和float类型总结：
存一个值or多个值：
只能存一个值；
可变or不可变：
不可变； （值变id不变为可变，值变id跟着变为不可变）
二、字符串类型
1基本使用：
用途：描述性数据，用于名字，家庭住址，性别爱好；
定义方式：在单引号/双引号/三引号中的字符，注意：三引号用于多段字符，单引号内可用双引号，双引号套单引号，但不能，单引号内套单，双套双；
name='zhanglong'
掌握：str(10)，int('10')
str能将整型10转换为字符串’10‘ ，而int只能讲字符串’10‘转换为整型10，不能讲字符串’a‘转换为整型；
2.常用操作+内置方法：
优先掌握的操作：
1.安照索引取值：
name='zhanglong'
print(name[0]) #从前往后取,索引第一位对应的是0
结果为z；
print(name[-1]) #从后往前取，索引第一位对应的是-1
结果为g;
2.切片（顾头不顾尾，步长）
count='123456789'
print(count[0:6:1])
结果为：123456，0是开头，6是结尾，结尾不包括在内，也就是012345位，1是步长，走一步，0，再走1步，1；
count='123456789'
print(count[1:7:2])
结果为246，1是开头，对应的是2，走两步，23，输出4，走两步，45，输出6，7是结尾，不包括；
3.长度len
name='zhanglong'
print(len(name))
结果输出为9，也就是输出字符串的位数。
4.成员运算in和not in
in：在
not in：不在
name='zhanglong'
print('zhang' in name)
结果为True，也就是字符串’zhang‘在字符串name中，自然是正确的
name='zhanglong'
print('zhang' not in name)
结果为False，也就是字符串’zhang‘不在字符串name中，自然是错误的；
5.移除空白strip
test='*****练习*****'
print(test.strip('*'))
输出结果为：练习，两边的*被strip清除了，如何没加字符，会清除空格
6.切分split
name='zhanglong:zhoahu:wangerma'
print(name.split(':'))
结果为：['zhanglong', 'zhoahu', 'wangerma'] 字符串中统一的符号：被切除，并将其转换成列表模式输出，name并为被改边，只是结果改变，可以赋值个新的变量；
7.循环
name='zhanglong'
i=0
while i<len(name)
print(name[i])
i+=1;
用while循环 循环输出字符串中的字符；
name='zhaohu'
for ser in name:
print(ser)
用for循环，循环输出name的字符
3月20日补充
3.需要掌握的操作
1.strip.rstrip.lstrip
strip:去除字符两边的特殊符号；调用，字符串.strip()，（）可以输入其他字符，不输入则清除空白，输入则清除其他值；
rstrip：去除字符右边的特殊符号；调用，字符串.strip()，（）可以输入其他字符，不输入则清除空白，输入则清除其他值；
lstrip:去除字符左边的特殊符号；调用，字符串.strip()，（）可以输入其他字符，不输入则清除空白，输入则清除其他值；
2.lower.upper
lower:将字符串全部转换为小写；调用，字符串.lower();
upper:将字符串全部转换为大写；调用，字符串.upper();
3.startswith.endswith
startswith:判断字符串开头；调用，字符串.startswith()，（）内输入你要判断的字符，输出为真，则输入字符是次字符串的开头；
endswith：判断字符串结尾；调用，字符串endswith()，（）内输入你要判断的字符，输出为真，则输入字符是次字符串的结尾；
4.format的三种用法
format：字符串格式化；：第一种用法，字符串.format(),字符串中加入{}，（）内输入值，用逗号，隔开，按顺序替换{}；
format：字符串格式化；：第二种用法，字符串.format(),字符串中加入{}并且在{}中加入索引，（）内输入值，用逗号，隔开，按索引替换{}；
format：字符串格式化；：第一种用法，字符串.format(),字符串中加入{}并且在{}内输入值名，（）内输入值名值=值，用逗号，隔开，按你输入的值名替换{}；
5.split.rsplit
split:切分，把有规律的字符串中规律符号切分，得到列表；调用字符串.split()，（）括号内输入规律符号，或者你想分割的符号，符号后用逗号隔开输入你想切分次数，不输入则全部切分； rsplit：从右边切分，把有规律的字符串中规律符号切分，得到列表；调用字符串.split()，（）括号内输入规律符号，或者你想分割的符号，符号后用逗号隔开输入你想切分次数，不输入则全部切分；
6.join
join：以某字符为连接把列表合成字符串； 调用：''.join(列表)，join前输入你想要的连接符，不输入则空为连接符，（）内输入需要连接的列表；
注意：join方法传入的列表只能包含str类型的元素，也就是字符串类型的元素；
7.replace
replace：替换，把字符串中某些字符串替换成你想输入的字符串；调用：字符串.join(),（）内第一个输入被替换的，第二个输入你想替换的字符串，第三个你想替换的个数，空为全部替换，输入内容用逗号隔开；
8.isdigit
isdigit:判断字符串内是否都是数字（不能判断小数）；调用：字符串.isdigit.
2.字符串类总结
存一个值or存多个值
存一个值；
有序or无序
有序
可变or不可变
不可变
三、列表
作用：多个爱好， 多个课程，多个女朋友等；
定义：
cmd=['abc','aoe','iwy']
[]内用逗号分隔多个元素，列表内元素无类型限制；
或 l=list('abc') 用list创建列表，（）内为列表的值
常用操作+内置方法：
优先掌握的操作：
1、按索引存取值(正向存取+反向存取)：即可改也可以取
x=['a','b','c']
print(x[0])
x[0]='A'
调用：列表名[]，[]内放索引，则取出列表值，把新的列表值赋予列表名[索引]，则更改其值
2、切片(顾头不顾尾，步长)
stus=['alex','egon','wxx','yxx','lxx']
print(stus[1:3])
调用：列表名[],[]放三个值，第一个为头，第二个为尾，第三个为步长
方式与字符串相同
3、长度
stus=['alex','egon','wxx','yxx','lxx']
print(len(stus))
调用：len（），（）放列表名，输入的是列表的个数；
4、成员运算in和not in
stus=['alex','egon','wxx','yxx','lxx']
print('alex' in stus)
in==在，not in==不在
5、追加
stus=['alex','egon','wxx','yxx','lxx']
stus.append('wupei')
stus.append('peiqi')
print(stus)
调用：列表名.append（）；（）内放入需要添加的值，添加永远只从后面添加；
6、插入
stus=['alex','egon','wxx','yxx','lxx']
stus.insert(1,'艾利克斯')
print(stus)
调用：列表名.insert（）；（）中第一位为列表索引，第二位为要插入的元素，以逗号分隔；
7、删除
stus=['alex','egon','wxx','yxx','lxx']
del stus[1]
print(stus)
stus.remove('alex')
print(stus)
调用：列表名.remove(),（）内为你要删除的元素；
stus.pop(1)
stus.pop() # 默认删除末尾
print(stus)
调用：列表名.pop(),（）中为你需要删除的索引，不输入则默认删除索引；pop删除的元素可以赋值给别的变量；
res1=stus.remove('alex') # 单纯的删除
print(res1)
res2=stus.pop(0) # 取走一个值
print(res2)
8、循环
stus=['alex','egon','wxx','yxx','lxx']
依赖索引
i=0
while i < len(stus):
print(stus[i])
i+=1
循环输出；while；
for i in range(len(stus)):
print(i,stus[i])
不依赖索引
for item in stus:
print(item)
循环输出；for；
补充for循环
依赖索引for循环
for i in range(0,5,2): #0 2 4
print(i)
for i in range(10):#默认从零起始
print(i)
for i in range(10,-2,-1):
print(i)
需要掌握的操作
stus=['alex','egon','alex','wxx','yxx','lxx']
print(stus.count('alex'))
count：统计元素个数；用法：列表名.count(),（）输入你想统计的元素
stus.extend(['a','b','c'])
print(stus)
extend:增加多个元素； 调用：变量名.extend(),（）输入[]，再在内放入多个元素，也可以说直接增加一个列表的元素；
print(stus.index('alex',1,5))
index:查找元素索引；调用：变量名.index();()可输入3个值，第一个为你要查找的元素，第二个为范围开头，第三个为范围结尾，不输入范围，从头查找；
stus.reverse()
print(stus)
reverse：把整个列表倒过来；调用：变量名.reverse（）；
l=[1,10,3,12]
l.sort(reverse=True)
print(l)
sort：排序； 调用列表名.sort(),从小到大排序，（）输入reverse=True，从大到小排序；（注意，只能排序数字字符）
大前提：只能同类型直接比较大小，对于有索引值直接的比较是按照位置一一对应进行比较的
s1='hello'
s2='hf'
print(s1 > s2)
l1=[3,'a','b','c']
l2=['xxx','d']
print(l1 > l2)
print('Z' > 'a')
A-Za-z
print('a' > 'B')
字符串比大小，从第一位开始比，不同直接决定大小，相同向后排；小写字母到大写字母比较，小z为最大，大A 为最小；
补充for循环
enumerate:输出索引与列表的值 ； 调用：enumerate（列表名）；
goods=['mac','apple','iphone','tesla']
for i in range(len(goods)): #根据列表长度，输入索引和列表值
print(i,goods[i])
print(enumerate(goods))
for x,y in enumerate(goods): #x,y=[0, 'mac'] #用enumerate来输出索引和值
print(x,y)
s='hello'
for x,y in enumerate(s): #0h 1e 2l 3l 4o #用enumerate来输出索引和值
print(x,y)
s='hello'
l=list()
for item in s:
print(item)
l.append(item)
print(l)
list('hello')
enumerate('hello') #(0, 'h') (1, 'e') ...
for item in enumerate('hello'):
print(item)
res=list(enumerate('hello'))
print(res)
总结列表类型
多值
有序
可变；
四、元组
什么是元组：“元组就是一个不可变的列表”
1.用途：存多个值，但是只有读的需求，没有改的需求
强调：在元素个数相同的情况下，使用元组更加节省空间
2 定义方式
t=(1,2,3,4) #t=tuple((1,2,3,4))
print(id(t),type(t),t)
3 常用操作+内置的方法
优先掌握的操作：
1、按索引取值(正向取+反向取)：只能取
2、切片(顾头不顾尾，步长)
t=(1,2,3,4,5,6)
print(t[1:4])
print(tuple('hello')) #创建一个元组b并输出
for i in range(10000): #
print(i)
print(tuple(range(10000)))
3、长度
4、成员运算in和not in
5、循环
t=('a','b','c','c')
print(t.index('a'))
print(t.count('c'))
该类型总结
1 存多个值
2 有序
3 不可变
五、字典
1 用途：以key：value的形式存多个值
优点：存取都快，每一个值都有对应的key
2 定义方式:{}内以逗号分隔多个元素，格式为key:value，
其中key必须为不可变类型，value可以是任意类型
dic={'x':1,'y':1,'x':1111} #dic=dict({'x':1,'y':1,'x':1111})
print(dic)
dic=dict(x=1,y=2,z=3)
print(dic)
3 常用操作+内置的方法
优先掌握的操作：
1、按key存取值：可存可取
dic={'name':'egon'}
dic['age']=10 #增加一个字典元素
print(dic)
dic['name']='EGON' #更改name的值
print(dic)
dic['name']=dic['name'].upper() #将name映射的值改为大写
print(dic)
2、长度len
dic={'name':'egon','age':18}
print(len(dic))
3、成员运算in和not in:判断的字典的key
4、删除
dic={'name':'egon','age':18}
del dic['name'] #删除一个值
print(dic)
res=dic.pop('name') #pop 取走一个值
print(res)
print(dic)
res=dic.pop('sex',None) #取走一个没有的值 返回为空
print(res)
5、键keys()，值values()，键值对items()
dic={'name':'egon','age':18}
print(dic.keys()) #得出所有的键值
print(dic.values()) #得出值
print(dic.items()) #打印出所有的键值，小元组的方式，for循环可以打印出一个一个键值
4、掌握的操作
dic={'name':'egon','age':18}
print(dic.get('namexxxxxxxxxxx'))
get：用get输出值，不在里面就返回空
print(dic.popitem())
popitem():随机弹出一个元组形式的键值对
dic.setdefault()
setdefaul的用处：
1、字典有中有key，则不修改，返回原key对应的原值
dic={'name':'egon','age':18}
res=dic.setdefault('name','EGON')
print('返回值',res)
print(dic)
2、没有对应的key，则添加，返回添加的key对应的value
dic={'age':18}
res=dic.setdefault('name','EGON')
print('返回值',res)
print(dic) #{'age': 18, 'name': 'EGON'}
dic.update({'x':1,'age':19})
update：更新，对与老字典来说，更新指的是，新字典中有而老字典中没有则添加，新有而老有，则覆盖
print(dic)
dic.fromkeys()
fromkeys:快速创建一个字典；
print({}.fromkeys(['name','age','sex'],None))
{'name':None,'age':None,'sex':None}
循环字典：
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
for key in msg_dic:
print(key,msg_dic[key])
总结
1、存多个值
2、无序
3、可变
六、集合
用途
1、 关系运算
2、去重
s1=set('hello')
print(s1) #
l=['a','b',1,'a','a']
print(list(set(l)))
想去重还想保证原来的顺序：了解
l = ['a', 'b', 1, 'a', 'a']
l_new=[]
s=set()
for item in l:
if item not in s:
s.add(item) #s={'a','b',1}
l_new.append(item) #l_new=['a','b',1]
定义方式:在{}内用逗号分隔开一个个元素
注意的问题
1、集合内没有重复的元素
2、集合的元素必须是不可变类型
s={1,2,3,4,4,4,4,4,4,4,'a'} #s=set({1,2,3,4,'a'})
print(id(s),type(s),s)
s={[1,2,3],'aa'}
常用操作与内置方法
stus_linux={'alex','egon','张全蛋','李铁蛋','oldboy'}
stus_python={'李二丫','wxx','liudehua','alex','egon'}
既报名linux又报名python的学生：交集
print(stus_linux & stus_python)
print(stus_linux.intersection(stus_python))
所有的学生：并集
print(stus_linux | stus_python)
print(stus_linux.union(stus_python))
只报名linux，没有报名python的：差集
print(stus_linux - stus_python)
print(stus_linux.difference(stus_python))
print(stus_python - stus_linux)
print(stus_python.difference(stus_linux))
没有同时报名两门课程的学生姓名：交叉补集
print(stus_linux ^ stus_python)
print(stus_linux.symmetric_difference(stus_python))
优先掌握，循环取值
长度len
成员运算in和not in
查看
s1={1,'a','b','c','d'}
for item in s1:
print(item)
增加
s1={'a','b','c'}
s1.add() # 一次添加一个值
s1.add(4)
print(s1)
s1.update({3,4,5}) #一次添加多个值
print(s1)
删除
s1.discard() ## 当删除的元素不存在的时候，不会报错
s1.discard(4)
print(s1)
s1.remove() # 当删除的元素不存在的时候，报错
s1.remove(4)
s1.pop() #随机取走一个元素
res=s1.pop()
print(res)
了解的方法
s1={1,2,3}
s2={1,2}
s1=s1.difference(s2)
print(s1)
s1.difference_update(s2)
print(s1)
s1.isdisjoint() #如果两个集合没有交集则返回True
s1={1,2,3}
s2={4,5,6}
print(s1.isdisjoint(s2))
print(s2.isdisjoint(s1))
了解的知识点
父集:爹包含儿子
s1={1,2,3}
s2={1,2}
print(s1.issubset(s2))
print(s2.issubset(s1))
print(s1.issuperset(s2))
print(s1 > s2) # 代表s1包含s2，s1是s2父集
print(s2 < s1) # s2是s1子集
s3={1,2,3}
s4={1,2,3}
print(s3.issuperset(s4))
print(s4.issuperset(s3))
print(s3 == s4)
print( s3 >= s4)
print( s4 >= s3)
七、字符编码
1、知识储备
cpu
内存
硬盘
2 文本编辑器存原理
结论：在编写py的程序的时候，是没有语法的限制的，编辑的结果跟编写一个普通的文本文件是没有任何区别，只有把py程序交给python解释并且在运行的第三个阶段才有了
语言意义
3 python解释器执行python程序的原理
python3 test.py
第一阶段：先启动python解释器这个软件
第二阶段：把test.py文件的内容读入内存
第三阶段：解释执行，识别语法
4 文本编辑器读原理
5：什么是字符编码
人类的字符----》翻译-------》数字
翻译的过程必须遵循一个标准:字符与数字一一对应的关系
这个标准称之为字符编码表
ASCII
8bit=1bytes,一个英文字符占用1字节
GBK
16bit=2bytes ，2个字节表示一个中文字符，1字节表示一个英文字符
unicode(内存中固定的编码)：
16bit=2bytes,2个字节表示一个字符
utf-8:Unicode Transformation Format
1字节表示一个英文字符,3bytes表示一个中文字符
保证不乱吗的核心就是：
文件是以什么编码存的，就必须以该读取
强调：我们能控制的只是存到硬盘上的编码
python3解释器：默认utf-8编码
python2解释器：默认ascii编码
文件头的作用：#coding:utf-8 是告诉python解释器，用我指定的字符编码
6：执行python程序第三个阶段发生的事
会识别python语法，定义的字符串类型又涉及到字符编码的概念
x='上' #x=str('上')
python2:
字符串分为两种形式：
x='上' #python2的str类型会按照文件头指定的编码来存‘上’
python3：
str：被存成了unicode
7：转换
unicode---编码encode--->gbk
gbk------->解码decode---》unicode
print(2**16-1)
整片字符编码一定要记住：文件是以什么编码存的，就用什么编码读取
八、文件处理
1、打开文件
f=open(r'文件的路径',mode='打开文件的模式',encoding='操作文件的字符编码')
f=open(r'a.txt',mode='r')
print(f)
2、读/写
read():只读，输出文件里的全部内容
data=f.read()
print(data)
del f
3、关闭文件
close() :关闭操作系统内的文件，回收操作系统的资源；
f.close()
print(f)
f.read()
with:管理文件上下文操作，帮你打开文件，帮你关闭系统文件；还可连续管理多个文件定义过第一个文件后，用逗号定义第二个；
with open(r'a.txt',mode='r') as f: # 打开一个文件
print('===>')
print(f.read()) #read 读取文件
f1=open(r'a1.txt',mode='r')
f2=open(r'a2.txt',mode='r')
with open(r'a1.txt',mode='r') as f1,open('a2.txt',mode='r') as f2: #管理2个文件，
print('===>')
print(f1.read())
print(f2.read())
4.默认的打开文件的编码是：当前操作系统默认的编码，win：gbk，linux：utf-8 mac：utf-8
encoding: 选择打开文件的编码；
f=open('a.txt',mode='r',encoding='utf-8')
print(f.read())
f.close()
5.文件默认的打开模式是t模式：文本模式
6.操作文件的模式有三种：r，w，a
r：默认的打开模式,只读模式
注意：当文件不存在时，报错
f=open('a.txt',mode='r',encoding='utf-8') #mode='rt'
f.write('哈哈啊哈哈啊啊 啊啊123213213123\n') #抛出异常，不能写
print(f.readable()) #判断这个文件是不是可读的
print('=============>1')
print(f.read()) #第一次打印
print('=============>2')
print(f.read()) #第二次打印，read是全部打印，所以第二次打印无效
f.close()
readline: 只读一行
f=open('a.txt',mode='r',encoding='utf-8') #mode='rt'
print(f.readline(),end='') # 读第一行
print(f.readline(),end='') # 读第二行
print(f.readline(),end='') #读第三行
f.close()
readlines: 以\n为分隔 把文件以列表的形式读出来
f=open('a.txt',mode='r',encoding='utf-8') #mode='rt'
print(f.readlines())
f.close()
for line in f.readlines(): #循环文件不要使用该方式，因为在文件过大的情况下有可能会撑爆内存
print(line,end='')
with open('a.txt',encoding='utf-8') as f:
for line in f: #for循环输出f的值
print(line,end='') #去除换行
w：只写模式
注意
1、当文件存在时，清空
2、当文件不存在时，创建空文档
print(f.writable()) #判断是否是可写模式
write:写，用于往文件中写字符，注意不会自动换行，需要换行时请添加换行符
f=open(r'a1.txt',mode='w',encoding='utf-8') #默认是wt
f.write(‘第一行\n第二行') #写入第一行和第二行，用换行符隔开
writelines:可以吧列表、元组写入文件
f.writelines(['111111\n','222222\n','333333\n']) #把列表写入，要写换行符
f.write('aaaa\nbbbb\ncccc\n') #把字符串写入，区别就是，一个写入列表类，一个写入字符串类
f.close()
a：只追加写模式
注意：
在文件不存在时，创建空文件
在文件存在时，光标直接跑到文件末尾
f=open('access.log',mode='a',encoding='utf-8') # 追加模式，操作与方法与写模式相同 ，并且不可读
f.readlines() #报错 证明不可读
f.write('5555555555555\n') #可写
f.close()
7.文件的打开模式b模式
强调：
1、与t模式类似不能单独使用，必须是rb，wb，ab
2、b模式下读写都是以bytes单位的
3、b模式下一定不能指定encoding参数
rb模式
with open('1.jpg',mode='rb',) as f: # 打开文件一1
data=f.read() #读文件，数据赋予data
print(data,) #输出读的文件
print(type(data)) #输出data的格式
with open('db.txt',mode='rb',) as f: #打开文件db
data=f.read() # 赋值
print(data.decode('utf-8')) #bytes-----unicode #字符编码转换 因为用的是rb模式，date的值为二进制，解码后才能输出人类字符；
print(type(data)) #字符类型
wb模式
with open('b.txt',mode='wb') as f: #用b模式只写打开b文件
msg='你好啊，吴三炮'
f.write(msg.encode('gbk')) # 将msg编码成gbk模式写入 f
with open('b.txt',mode='wb') as f: #用b模式只写打开b文件
msg='你好啊，吴三炮'
f.write(msg.encode('utf-8')) #将msg的值编码为utf-8模式写入f
with open('b.txt',mode='rb') as f: #用b模式只读打开b文件
data=f.read()
print(type(data)) #测试data的类型
print(data.decode('utf-8')) #用utf-8将data解码
with open('1.jpg',mode='rb') as f: #用b模式只读打开图片1
data=f.read()
print(type(data)) #测试类型
print(data.decode('utf-8')) # 用utf-8解码data
ab模式
用法与wb相同
with open('b.txt',mode='ab') as f: #用b模式追加打开文件b
f.write('你好'.encode('utf-8')) #把'你好'用utf-8编码写入文件b
8.可读可写模式（了解）
r+t ：读写模式，先读，然后可以写
with open('b.txt','r+t',encoding='utf-8') as f: #用读写模式打开b
print(f.readable()) #判断是否可读
print(f.writable()) #判断是否可写
print(f.readline()) #读一行
f.write('\n吴大炮你也号\n') #写入
w+t 写读模式，先写入，然后可以读
a+t 追读模式，一样先写入，后读
U ：通用换行符 （已经废弃）
9.修改文件方式一：
1、先把文件内容全部读入内存
2、然后在内存中完成修改
3、再把修改后的结果覆盖写入原文件
缺点：会在文件内容过大的情况下，占用过多的内存
with open('user.txt',mode='r',encoding='utf-8') as f: #只读打开文件
data=f.read()
data=data.replace('吴佩其','吴佩其[老男孩第二帅的人]') #置换方法，把吴佩琪换成，逗号后的字符串
with open('user.txt',mode='w',encoding='utf-8') as f: #只写方法打开文件
f.write(data) #把刚刚我们置换好的值，写进去
修改文件方式二：
1、以读的方式打开原文件，以写的方式打开一个新文件
2. 在老文件判断找出要修改的字符串修改，并写入新文件
3.最后把老文件删除，并把新文件改名；
import os #导入os 模块
with open('user.txt',mode='rt',encoding='utf-8') as read_f,\ #用只读的方式打开文件user
open('user.txt.swap',mode='wt',encoding='utf-8') as write_f: #用只写的方式打开一个新的文件 。
for line in read_f: #for循环输出老文件里的内容
if '吴佩其' in line: #判断要修改的在不在其中
line=line.replace('吴佩其','吴佩其[老男汉特别特别的老]') #在则修改，不在继续循环
write_f.write(line) #不需要修改的写入老文件
os.remove('user.txt') #删除文件
os.rename('user.txt.swap','user.txt') #改文件名；