*********第三天*********
一、主要内容
集合 set
函数
-自定义函数
-内置函数
深浅拷贝
装饰器
学习方法：
1.如何创建
2.功能使用
可借鉴博客
http://www.cnblogs.com/wupeiqi
http://www.cnblogs.com/wupeiqi/articles/4938499.html
上节补充
se = {"123","456"}
print(type(se))
在for 和while 循环中最主要的两个参数
break #跳出整个循环
continue #跳出本次循环
while 有else
列表创建两种方式：
li = []
list(wmh)
list()就会执行__init__方法
__init__内部执行for 循环
-----------------------------------------------------------------------------------------
1.set 集合
set集合，是一个无序且不重复的元素集合
set:无序，不重复序列，去重
set #去重显示
a = list('kdjsfkajdkfafafafsfkaf')
set(a)
list.(set(a))
创建空集合：
s = set() #创建空集合，为以后添加内容
去重
li = [11,22,11,22]
s1=set(li) #去重
print(s1)
------结果输出------
{11, 22}
嵌套列表集合，去重
s3 = set([11,22,33,22])
print(s3)
------结果输出------
{33, 11, 22}
操作集合
(1)为空集合添加内容、清空
s = set() #空集合
print(s)
s.add(123) #添加内容,add方法一次只能加一个内容
s.add(123)
s.add(123)
print(s) #打印集合，去重后显示
------结果输出------
set()
{123} #去重后结果
清除集合内容
s.clear()
print(s)
------结果输出------
set()
{123}
set()
A中存在，B中不存在(前面存在的，后面不存在的)
difference 差异对比
s1={11,22,33}
s2={22,33,44}
s3=s1.difference(s2) #s1中存在(前面)，s2中不存在(后面)
print(s3)
------结果输出------
{11} #只回显s1中存在的，s2不存在的
#前面存在的，后面不存在
s3=s2.difference(s1)
print(s3)
------结果输出------
{44} #只回显s2中存在的，s1不存在的
输出差异
#对方没有的整合输出
s3=s1.symmetric_difference(s2)
print(s3)
------结果输出------
{11, 44}
查A中存在，B中不存在的，更新到s1中
s1={11,22,33}
s2={22,33,44}
s1.difference_update(s2) #s1中存在的，s2中不存的,update方法会覆盖原来内容
print(s1)
------结果输出------
{11}
移除
s1={11,22,33}
s1.discard(11) #最有用
------结果输出------
{33, 22}
s1={11,22,33,1111}
s1.remove(1111)
------结果输出------
{33, 11, 22}
移除元素，并打印，随机删除
s1={11,22,33,1111}
s1.pop()
print(s1)
------结果输出------
{11, 22, 1111}
显示随机删除的内容
s1={11,22,33,1111}
ret=s1.pop()
print(ret)
print(s1)
------结果输出------
33
{11, 22, 1111}
***交集：两个集合中都存在的，取相同的***
***并集：两个集合合并后的值，都取,去重取所有***
***差集：只取相差的，对方没有的***
交集,取相同部分
s1={11,22,33}
s2={22,33,44}
s3=s1.intersection(s2)
print(s3)
------结果输出------
{33, 22}
取相同部分，更新覆盖s1
s1={11,22,33}
s2={22,33,44}
s1.intersection_update(s2) #取交集相同部分并覆盖
print(s1)
------结果输出------
{33, 22}
并集，合并，都取,去重取所有
s1={11,22,33}
s2={22,33,44}
s3=s1.union(s2) #联合
print(s3)
------结果输出------
{33, 22, 11, 44}
将列表更新到set集合中，照样去重，不覆盖
s1={11,22,33}
li =[11,22,3,11,2]
s1.update(li)
print(s1)
------结果输出------
{3, 33, 2, 11, 22}
取交集相同部分和拆分字符串后覆盖s1
s1={11,22,33}
li =(11,22,3,11,2)
li = "alexalex"
s1.update(li)
print(s1)
------结果输出------
{33, 'l', 'x', 11, 'a', 'e', 22} #取交集相同部分和拆分字符串后覆盖s1，所以没有3和2
&&&&&&练习题1&&&&&&&&
需求：1.写一个监测内存槽位和内存大小变化的程序
2.一台机器配置为：4个内存槽位，原配置为”1号槽为8G，2号槽为4G，4号槽为2G”，而3号槽没有内存
3.更新后的机器内存配置为：1号槽4G，2号槽4G，3号槽2G,而4号槽坏了，所以没插
模拟程序
#老配置
old_dict = {
"#1":8,
"#2":4,
"#4":2,
}
#新配置
new_dict = {
"#1":4,
"#2":4,
"#3":2,
}
#删除old_dict 4
#old_keys = old_dict.keys()
#old_set =set(old_keys)
#old_set.deffrents(new_dict)
#new_keys=new_dict.keys()
#更新new_dict 1 到old_dict
#添加new_dict 3 到old_dict
&&&实现方法&&&
(1)第一步 将字典key转为set集合
new_set = set(new_dict.keys())
old_set = set(old_dict.keys)
(2)第二步，老新比较，抽出老的不同于新的槽位，A中存在的，B中不存在的（只回显old_set存在的key,其他的均不回显）
remove_set = old_set.difference(new_set)
(3)第三步，新老比较，抽出新的不同于老的槽位，打印新的存在的(A中存在的，B中不存在的(只回显new_set存在的key,其他的均不回显))
add_set=new_set.difference(old_set)
(4)第四步，取相同部分
update_set=old_set.intersection(new_set)
*****注******
取交集，取相同部分，集合名不分前后，下面的code和上面的code结果相同
update_set = new_set.intersection(old_set)
print(update_set)
完整代码
old_dict = {
"#1":8,
"#2":4,
"#4":2,
}
new_dict={
"#1":4,
"#2":4,
"#3":2,
}
new_set = set(new_dict.keys())
old_set = set(old_dict.keys())
remove_set = old_set.difference(new_set) #老配置有的，新配置没有的
print(remove_set)
add_set=new_set.difference(old_set) #新配置有的，老配置没有的
print(add_set)
update_set = new_set.intersection(old_set) #新老配置都有的
print(update_set)
#print(new_set,type(new_set)) #带类型打印
#print(new_dict.values()) #只打印字典值
------结果输出------
{'#4'} #老配置有的，新配置没有的
{'#3'} #新配置有的，老配置没有的
{'#2', '#1'} #新老配置都有的
-------------------------------------------------------------------------------------------
2.函数
反复使用，减少工作量
(1) 创建函数 def f1()
def f1(): #f1 为函数名
函数构成
#1、def关键字 创建函数
#2、函数名
#3、()
#4、函数体(功能)
#5、返回值
发邮件函数(前提必须在发邮件页面开启stmp)
def sendmail():
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
msg = MIMEText('邮件内容', 'plain', 'utf-8')
msg['From'] = formataddr(["武沛齐",'wptawy@126.com'])
msg['To'] = formataddr(["走人",'424662508@qq.com'])
msg['Subject'] = "主题"
server = smtplib.SMTP("smtp.126.com", 25)
server.login("wptawy@126.com", "密码")
server.sendmail('wptawy@126.com', ['faith_wmh@126.com',], msg.as_string())
server.quit()
sendmail()
更改后的发邮件函数
def sendmail():
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
msg = MIMEText('邮件内容', 'plain', 'utf-8') #内容
msg['From'] = formataddr(["王明虎",'faith_wmh@126.com']) #发邮件人信息，不用更改
msg['To'] = formataddr(["走人",'284526658@qq.com']) #收邮件人信息，不用更改
msg['Subject'] = "主题" #主要事情标题
server = smtplib.SMTP("smtp.126.com", 25) #发邮件地址，必要
server.login("faith_wmh@126.com", "密码") #发邮件人的邮箱用户名和密码
server.sendmail('faith_wmh@126.com', ['faith_wmh@126.com',], msg.as_string()) #faith_wmh@126.com前者为发邮件人邮箱，后者为收邮件人邮箱
server.quit()
sendmail()
return用法:一旦执行return,函数执行过程立即终止
def f1():
print(123)
#在函数中，一旦执行return,函数执行过程立即终止,456不返回
return "111"
print(456)
#f1() 如果只执行f1()，会只回显123，不回显111，所以要加print(f1()),但一般不这样用，最好定义个变量接收，之后在调用
r=f1() #定义接收值
print(r)
------结果输出------
123
111
异常处理，定义返回值
def sendmail():
try:
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
msg = MIMEText('邮件内容', 'plain', 'utf-8')
msg['From'] = formataddr(["武沛齐",'wptawy@126.com'])
msg['To'] = formataddr(["走人",'424662508@qq.com'])
msg['Subject'] = "主题"
server = smtplib.SMTP("smtp.126.com", 25)
server.login("wptawy@126.com", "密码")
server.sendmail('wptawy@126.com', ['3628905@qq.com',], msg.as_string())
server.quit()
except:
# 发送失败
return "失败"
else:
# 发送成功
return "cc"
ret = sendmail() #有return就必须定义接收变量，不定义则不返回return的值
print(ret)
if ret == "cc":
print('发送成功')
else:
print("发送失败")
------结果输出------
cc
发送成功
函数传参
def sendmail('xxoo') #xxoo为形参
sendmail('alex') #alex为实参
形式参数
#不改函数体，定形参，传实参，发邮件
def sendmail(xxoo, content): #定义xxoo和content形参
# xxoo = alex
try:
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
msg = MIMEText(content, 'plain', 'utf-8') #content为邮件内容的形参
msg['From'] = formataddr(["武沛齐",'wptawy@126.com'])
msg['To'] = formataddr(["走人",'424662508@qq.com'])
msg['Subject'] = "主题"
server = smtplib.SMTP("smtp.126.com", 25)
server.login("wptawy@126.com", "密码")
server.sendmail('wptawy@126.com', [xxoo,], msg.as_string()) #xxoo为收邮箱用户名
server.quit()
except:
# 发送失败
return "失败"
else:
# 发送成功
return "cc"
while True:
em = input("请输入邮箱地址:")
result = sendmail(em, "SB") #调用input的em变量，提示输入收邮箱的用户名，邮件内容为SB
if result == "cc":
print("发送成功")
else:
print("发送失败")
------结果输出------
请输入邮箱地址：faith_wmh@126.com
发送成功
请输入邮箱地址：fsfdsafdsaf
发送失败
请输入邮箱地址：
#1.普通参数
#2.默认参数(必须放置在参数列表的最后)
#3.指定参数
#4.* 动态参数
# * 默认将传入的参数，全部放置在元组中 f1(*[1,22,33,44])
# ** 默认将传入的参数，全部放置在字典中 f1(**{"k1":"v1","k2":"v2"})
#5.万能参数 *args,**kwargs
#6.补充：
a.
def f1
def f1
b. 引用
c. 全局变量
读，都可读
赋值，global
字典，列表，可修改
好格式：全局变量用大写，一看到大写就是全局变量
#默认参数，有等号
def send(xxoo,content,xx='OK'): #这里有等号即为默认参数
print(xxoo,content,xx)
return True
send('alex','sb') #不给xx传参即回显其默认的OK(默认参数)
send('alex','sb','bb') #给xx传参则回显传的值bb
------结果输出------
alex sb OK
alex sb bb
#普通参数
只定义形参，之后传参
def send(xxoo,content):
print(xxoo,content)
return True
send("alex",'sb')
------结果输出------
alex sb
#指定参数
给形参指定值，可以改变位置
def send(xxoo,content):
print(xxoo,content)
return True
send(content='alex',xxoo='sb')
------结果输出------
sb alex
任意实参（传参）,导入元组，以元组形式输出
def f1(*args): #导入元组
print(args)
f1(11,22,"alex",'hhhh') #以元组传值
------结果输出------
(11, 22, 'alex', 'hhhh')
#实参为列表时，将列表加入元组后输出
def f1(*args):
print(args,type(args))
f1(11)
li = [11,22,"alex","hhhh"]
f1(li,'12')
------结果输出------
([11, 22, 'alex', 'hhhh'], '12') <class 'tuple'>
#列表格式化成字符串，以元组输出
def f1(*args):
print(args,type(args))
li=[11,22,'alex','hhhh']
f1(li)
f1(*li) #列表格式化成字符串，以元组输出
------结果输出------
([11, 22, 'alex', 'hhhh'],) <class 'tuple'>
(11, 22, 'alex', 'hhhh') <class 'tuple'> #转成字符串输出(以元组形式输出)
#实参为字符串，for循环后拆分后加入到元组输出
def f1(*args):
print(args,type(args))
li = 'alex' #字符串
f1(*li) #传入函数
-----结果输出------
('a', 'l', 'e', 'x') <class 'tuple'> #逐个拆分后输出
直接传参和把列表传参，实参加*后，返回结果相同
def f1(*args):
print(args,type(args))
f1(11,22,33,44) #
li=[11,22,33,44]
f1(*li)
------结果输出------
(11, 22, 33, 44) <class 'tuple'>
(11, 22, 33, 44) <class 'tuple'>
**args 默认将传入的参数，全部放置在字典中，以字典形式输出
#有等于时，分拆分开，前面为keys,后面为value
def f1(**args):
print(args,type(args))
f1(n1="alex",n2=18)
dic={'k1':"v1",'k2':'v2'}
f1(kk=dic) #有等于时，分拆分开，前面为keys,后面为value
dic={'k1':"v1",'k2':'v2'}
f1(**dic) #不嵌套原字典输出
------结果输出------
{'n1': 'alex', 'n2': 18} <class 'dict'>
{'kk': {'k1': 'v1', 'k2': 'v2'}} <class 'dict'>
{'k1': 'v1', 'k2': 'v2'} <class 'dict'>
万能参数 一个*的在前面，**在后面，(只能*在前，**不能在前)
def f1(*args,**kwargs):
print(args)
print(kwargs)
f1(11,22,33,44,k1='v1',k2='v2')
------结果输出------
(11, 22, 33, 44)
{'k1': 'v1', 'k2': 'v2'}
format() 格式化输出
str.format() #格式化传参输出
#%s %d
s1 = "i am {0},age {1}".format("alex",18) #自动封装到*args里
print(s1)
s2 = "i am {0},age {1}".format(*["alex",18]) #用*与上相同结果
print(s2)
------结果输出------
i am alex,age18
i am alex,age18
s3 = "i am {name},age {age}".format(name="alex",age=18) #有等号自动封装到**kwargs,以形参名传参，实参位置可变
print(s3)
------结果输出------
i am alex,age18
将字典传到**kwargs输出
dic = {'name':'alex','age':18} #定义字典
s4 = "i am {name},age {age}".format(**dic) #把字典传参给name和age
print(s4)
------结果输出------
i am alex,age18
python是以先后顺序执行的程序，验证：两个函数名相同，执行结果不同，后者生效
#第一个f1函数为两者相加
def f1(a1,a2):
return a1+a2
#第二个f1函数为两者相乘
def f1(a1,a2):
return a1 * a2
ret = f1(8,8) #接收一下
print(ret)
------结果输出------
64
函数传递参数是引用
#f1 和li 没有半毛钱关系，只是引用f1的追加到了li列表
def f1(a1):
a1.append(999)
li = [11,22,33,44]
f1(li)
print(li)
------结果输出------
[11, 22, 33, 44, 999]
全局变量,所有作用域都可读，如果冲突，先读自己的
对全局变量进行重新赋值，需要global
特殊：列表字典,可修改，不可重新赋值
#定义全局变量一定要全是大写，好格式
NAME = 'alex' #没有写到函数里的变量是全局变量
函数中引用全局变量
def f1():
age=18
print(age,NAME)
def f2():
age=19
print(age,NAME)
f1()
f2()
------结果输出------
18 alex
19 alex
global 修改全局变量
def f1():
age=18
global NAME #global指定为全局变量，重新赋值
NAME = "123" #修改全局变量
print(age,NAME)
def f2():
age=19
print(age,NAME) #打印f1修改后的全局变量
f1()
f2()
------结果输出------
18 123
19 123
#追加append,不可以重新赋值
NAME = [11,22,33,44]
def f1():
age = 18
global NAME #追加append，这个global没有意义
NAME.append('100')
print(age,NAME)
def f2():
age = 20
print(age,NAME) #打印f1修改后的全局变量
f1()
f2()
append追加，不可以重新赋值
NAME = [11,22,33,44]
def f1():
age = 18
NAME.append('100')
print(age,NAME)
def f2():
age = 20
print(age,NAME) #打印f1修改后的全局变量
f1()
f2()
------结果输出------
18 [11, 22, 33, 44, '100']
20 [11, 22, 33, 44, '100']
登录程序，先写文件db admin|123 格式
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
def login(username,password):
"""
用于用户登录
:param username:用户输入的用户名
:param password:用户输入的密码
:return: 表示登录成功，false,登录失败
"""
f = open("db",'r')
for line in f: # 一行一行的读
line_list = line.strip().split("|")
if line_list[0] == username and line_list[1] == password:
return True
return False
def register(username,password):
"""
用于用户注册
:param username:用户名
:param password:密码
:return:默认None
"""
f = open("db",'a')
temp = "
" + username + "|" + password
f.write(temp)
f.close()
def main():
t=input("1:登录;2:注册:").strip()
if t == "1":
user =input("请输入用户名：").strip()
pwd = input("请输入密码：").strip()
r = login(user,pwd)
if r:
print("登录成功")
else:
print("登录失败")
elif t=="2":
user =input("请输入用户名：").strip()
pwd = input("请输入密码：").strip()
register(user,pwd)
main()
------结果输出------注册
1:登录 : 2:注册 : 2
请输入用户名 :wangmh
请输入密码 ：123
------结果输出------登录
1:登录 : 2:注册 :1
请输入用户名 ：wangmh
请输入密码 ：123
登录成功
三元运算，三目运算
用于写简单的if else 的
if 1 == 1:
name = "alex"
else:
name = "SB"
#三元运算，三目运算
#一行执行判断
#如果1 == 1 成立，name 等于alex，否则：name 等于 "SB"
name = "alex" if 1 == 1 else "SB"
print(name)
------结果输出------
alex
def f1(a1):
return a1 + 100
ret = f1(10)
print(set)
------结果输出------
110
#函数，lambda表达式 ，lambda用于创建函数的一种方法
f2 = lambda a1:a1+100
函数名 冒号前面为形参 自动return
------结果输出------
109
lambda 多传参函数
f2 = lambda a1,a2:a1+a2+100 #多参数
r2 = f2(9,10)
print(r2)
------结果输出------
119
内置函数
abs 取绝对值
n = abs(-1)
print(n)
------结果输出------
1
all() #所有为真才为真
any() #任何一个为真，即为真
#0,None,"",[],() 全是false
print(bool(()))
print(bool([]))
n = all([1,2,3,4]) #所有都为真返回True
print(n)
------结果输出------
True
n = all([1,2,3,4,0]) #0为假，所以返回False
print(n)
------结果输出------
False
n = any([[],0,"",None]) #任何一个为真，即为真，但这里都为假
print(n)
------结果输出------
False
n = any([[],0,1,None]) #1为真，返回True
print(n)
------结果输出------
True
class Foo:
def __repr__(self):
return "444"
n = ascii(Foo())
print(n)
进制转换
bin() #十进制转二进制
oct() #十进制转八进制
hex() #十进制转十六进制
print(bin(5))
print(oct(9))
print(hex(15))
------结果输出------
0b101
0o11
0xf
3.字节
bytes()
#utf-8 一个汉字：三个字节
#gbk 一个汉字：二个字节
#utf-8
s = "李杰" #一个字节8位，一个汉字三个字节
# 一个字节8位，一个汉字三个字节
# 0101010 10101010 101010101 0101010 10101010 101010101
# 23 23 23 23 23 23 15
# 2f 2a 2c 2c 2e 2f f
#字符串转换字节类型
#bytes(只要转换的字符串，按照什么编码)
n = bytes(s,encoding="utf-8") #UTF-8 三个字节一个汉字，所以输出6个字节
print(n)
------结果输出------
b'xe6x9dx8exe6x9dxb0' #UTF-8 三个字节一个汉字，所以输出6个字节
前三16进制为一个字符，一共组成为”李杰“
n = bytes(s,encoding="gbk") #GBK 两个字节一个汉字，所以输出4个字节
print(n)
------结果输出------
b'xc0xeexbdxdc' #GBK 两个字节一个汉字，所以输出4个字节
前二16进制为一个字符，一共组成为”李杰“
# 字节转化成字符串
new_str = str(bytes("李杰", encoding="utf-8"), encoding="utf-8") #先转成字节，在将字节转成字符串
print(new_str)
------结果输出------
李杰
-----------------------------------------------------------------------------------
4.文件操作
打开文件的模式有：
•r ，只读模式【默认】
•w，只写模式【不可读；不存在则创建；存在则清空内容；】
•x， 只写模式【不可读；不存在则创建，存在则报错】
•a， 追加模式【可读； 不存在则创建；存在则只追加内容；】
"+" 表示可以同时读写某个文件
•r+， 读写【可读，可写】
•w+，写读【可读，可写】
•x+ ，写读【可读，可写】
•a+， 写读【可读，可写】
"b"表示以字节的方式操作
•rb 或 r+b
•wb 或 w+b
•xb 或 w+b
•ab 或 a+b
(1)打开文件
f =open('db','r') #只读
f =open('db','w') #只写，先清空在写
f =open('db','x') #如果存在则报错，不存在创建并写内容
f =open('db','a') #追加
f = open('db','r')
data = f.read() #读每行，循环读
print(data,type(data))
f.close() #关闭文件
------结果输出------
888|123
wml|123
wmh|1243
wangmh|123 <class 'str'>
读utf-8
f = open('db','r',encoding="utf-8")
data = f.read()
print(data,type(data))
f.close()
读gbk
f = open('db','r',encoding="gbk")
data = f.read()
print(data,type(data))
f.close()
直接跟二进制打交道，不要python解释器
#以二进制读取
f = open('db','rb')
data = f.read()
print(data,type(data))
#
f = open('db','ab')
f.write("hello") #报错，因为它需要字节
f.close()
f = open('db','ab')
f.write(bytes("hello",encoding="utf-8")) #以二进制写入
f.close()
f = open('db','ab')
f.write(bytes("李杰",encoding="utf-8")) #以二进制写入
f.close()
------文件内容变化------
888|123
wml|123
wmh|1243
wangmh|123hello李杰 #在其后加了两个字符
#r+ 读定，最常用
f = open("db",'r+',encoding="utf-8")
data = f.read()
print(data)
f.write('777') #把777写入，但是在最后写入
f.close()
------结果输出------
888|123
wml|123
wmh|1243
wangmh|123hello李杰777
#主动调动指针写入，不然默认就写入到最后
f.seek(1)
f = open("db",'r+',encoding="utf-8")
data = f.read()
print(data)
f.seek(1) #在位置1写入777
f.write('777')
f.close()
-------结果输出------
8777123 #在位置1写入777
wml|123
wmh|1243
wangmh|123hello李杰777777
#获取当前指针位置的字节,在那看就在那写(seek)
f.tell()
f = open("db",'r+',encoding="utf-8")
#如果打开模式无b,则read,按照字符读取
data = f.read(1)
print(f.tell()) #tell当前指针所在位置(字节)
f.seek(f.tell()) #调整当前指着你的位置(字节)
f.write('888') #当前指针位置开始向覆盖
f.close()
------结果输出------
1
------文件输出------
7888123 #已覆盖位置1的777
wml|123
wmh|1243
wangmh|123hello李杰777777
2.操作文件
read() #无参数，读全部，有参数，b,按字节
tell() #获取当前指针位置(字节)
seek(1) 指针跳转到指定位置(字节)
f.flush() #强刷
f.readline() #仅读取一行
f.truncate() #截断,根据指针为后的清空
f = open("db",'r+',encoding="utf-8")
f.seek(3)
f.truncate() #清除指针三后的内容
f.close()
------文件结果输出------
788
# 2、操作文件
# read() # 无参数，读全部；有参数，
# b，按字节
# 无b，按字符
# tell() 获取当前指针位置(字节)
# seek(1) 指针跳转到指定位置(字节)
# write（） 写数据，b，字节；无b，字符
# close
# fileno
# flush 强刷
# readline 仅读取一行
# truncate 截断，指针为后的清空
# for循环文件对象 f = open(xxx)
# for line in f:
# print(line)
循环文件对象
f = open("db",'r')
for line in f:
print(line)
------结果输出------
788
fkjdsfjaslfs
fjldsajflsaf
jflkdsajfsaf
jfldsjflsaf
(3) 关闭文件
f.close()
#with自动关闭文件
with open('xb') as f:
pass
用with打开多个文件
with open('db1') as f1,open('db2') as f2:
pass
==========读一个文件内容写入另一个文件========================
------db1文件内容如下-------
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
db1文件没有内容
文件的前十行写到另一个文件
with open('db1', 'r', encoding="utf-8") as f1, open("db2", 'w',encoding="utf-8") as f2:
times = 0
for line in f1:
times += 1
if times <=10:
f2.write(line)
else:
break
-------db2文件内容结果--------
1
2
3
4
5
6
7
8
9
10
replace 替换字符
读一个文件查找alex字符后替换成st写入到第二个文件，先清空第二个文件内容再写入
------db1文件内容如下-------
alex
alexalex
alex
alex
alex
-------db2文件内容如下-------
1
2
3
4
5
6
7
8
9
10
#替换代码如下：作业使用
with open('db1', 'r', encoding="utf-8") as f1, open("db2", 'w',encoding="utf-8") as f2:
for line in f1:
new_str = line.replace("alex", 'st')
f2.write(new_str)
------文件内容变化后输出------
st
stst
st
st
st