day3

Posted 2020-07-12

set 集合

索引
-----------------
一. 集合解析
1.解析
二. 创建集合
1.语法
2.举例
三. 操作集合
1. 添加
2. 拆分
3. 删除
4. 差集
5. 交集
6. 并集
7. 更新
-----------------



一. 集合解析 : 无序，不重复，可嵌套

1. python 的 set 和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算. 
2. set 支持 x in set, len(set),和 for x in set。作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持 indexing, slicing, 或其它类序列（sequence-like）的操作。  


二. 创建集合

语法:
集合名 = {元素1,元素2,......} #以字符串方式创建集合
集合名 = set((‘字符串‘) #以字符串方式创建集合,并且只能有一个元素,多了就会报错
集合名 = set((元素1,元素2,......)) #以元组方式创建集合
集合名 = set([元素1,元素2,......]) #以元组方式创建集合
集合名 = set({"alex":30,"wml":20}) #如果字典方式,创建集合,集合会把key 与 value 当成一个元素
集合名 = set() #创建空集合

举例:
set0 = {11,22,33,4,‘wml‘}
set1 = set(‘alex‘)
set2 = set((11,22,33,4,‘wml‘))
set3 = set([11,22,33,4,‘wml‘])
set4 = set({"alex":30,"wml":20})

print(set0)
print(set1)
print(set2)
print(set3)
print(set4)

打印结果
{11, 33, ‘wml‘, 4, 22}
{‘l‘, ‘a‘, ‘x‘, ‘e‘}
{33, ‘wml‘, 11, 4, 22}
{33, ‘wml‘, 11, 4, 22}
{‘wml‘, ‘alex‘}


三. 操作集合

1. 添加
=========================================================
语法:
集合名.add(元素) #每次只能添加一个元素

举例:
set1 = {‘wml‘,‘alex‘,‘madong‘}
print(set1)

addname = set1.add(‘python‘)
print(set1)

打印结果
{‘wml‘, ‘python‘, ‘alex‘, ‘madong‘}


2. 拆分
=========================================================
update：是把要传入的元素拆分，做为个体传入到集合中

语法:
集合名.update(元素)

举例:
set1 = {‘wml‘,‘alex‘,‘madong‘}
print(set1)

u_set = set1.update(‘python‘)
print(set1)

打印结果
{‘wml‘, ‘madong‘, ‘alex‘}
{‘p‘, ‘wml‘, ‘o‘, ‘h‘, ‘t‘, ‘madong‘, ‘alex‘, ‘y‘, ‘n‘}


3. 删除
=========================================================
语法:
集合名.remove(元素) # 删除指定元素，如果元素本来就不存在，会报错
集合名.discard(元素) # 删除指定元素，如果元素本来不存在，也不报错
集合名.pop() # 随机移除元素并输出被删除的元素

举例:
remove() 删除指定元素
----------------------------------------------------------
set1 = {‘wml‘,‘alex‘,‘madong‘}
print(set1)

u_set = set1.remove(‘wml‘)
print(set1)

# 打印结果
{‘wml‘, ‘madong‘, ‘alex‘}
{‘madong‘, ‘alex‘}



pop() 随机移除元素并输出被删除的元素
----------------------------------------------------------
set1 = {‘wml‘,‘alex‘,‘madong‘}
print(set1)
print(set1.pop())

# 打印结果
{‘wml‘, ‘alex‘, ‘madong‘}
alex



删除指定元素
----------------------------------------------------------
s1 = {11,22,33,‘wml‘}
s2 = {22,33,44}

s1.discard(‘wml‘)

print(s1)
print(s2)

# 打印结果
{33, 11, 22}
{33, 44, 22}



4. 差集
=========================================================
语法:
集合1.difference(集合2) #集合1中存在,集合2中不存在

举例:
A = {11,22,33}
B = {22,33,44}
print(A.difference(B)) #输出 , A中存在，B中不存在

打印结果
{11}


对称差集 （把两个集合相同的去掉，输出不相同的）
---------------------------------------------------------------------------
语法:
集合1.symmetric_difference(集合2)

举例:
s1 = {11,22,33}
s2 = {22,33,44}
print(s1.symmetric_difference(s2))

打印结果
{11, 44}


差集更新 （取A中存在，B中不存在的，把两个集合的差集覆盖A）
---------------------------------------------------------------------------------------
语法:
集合1.difference_update(集合2)

举例:
s1 = {11,22,33}
s2 = {22,33,44}
s1.difference_update(s2)
print(s1)
print(s2)

打印结果
{11}
{33, 44, 22}


对称差集更新 （把两个集合相同的去掉，把不相同的覆盖A）
---------------------------------------------------------------------------------------
语法:
集合1.symmetric_difference_update(集合2)

举例:
s1 = {11,22,33}
s2 = {22,33,44}
#s1.difference_update(s2)
s1.symmetric_difference_update(s2)
print(s1)
print(s2)

打印结果
{11, 44}
{33, 44, 22}



5. 交集
=========================================================
语法:
集合1.intersection(集合2) #取两个集合的相同处

举例:
s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.intersection(s2)
print(s3)

打印结果
{33, 22}


交集更新
---------------------------------------------------------------------------------------
语法:
集合1.intersection_update(集合2) #取两个集合的相同处覆盖A

举例:
s1 = {11,22,33}
s2 = {22,33,44}
s1.intersection_update(s2)
print(s1)

打印结果
{33, 22}



6. 并集
=========================================================
去掉重复元素，联合两个集合输出

语法:
集合1.union(集合2)

举例:
s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.union(s2)
print(s3)

打印结果
{33, 22, 11, 44}

更新


7. 更新
=========================================================

也是添加，因为update()内部执行过程中执行了for

语法:
集合名.update(可以被迭代的对象) #字符串，元组，列表，字典都可以迭代

举例:

字符串
--------------------------------------
s1 = {11,22,33}
li = ‘wml‘,‘alex‘
s1.update(li)
print(s1)

打印结果
{33, 11, ‘wml‘, ‘alex‘, 22}


列表
--------------------------------------
s1 = {11,22,33}
li = [‘wml‘,‘alex‘]
s1.update(li)
print(s1)

打印结果
{‘wml‘, 33, 11, 22, ‘alex‘}


元组
--------------------------------------
s1 = {11,22,33}
li = (‘wml‘,‘alex‘)
s1.update(li)
print(s1)

打印结果
{‘wml‘, 33, 11, ‘alex‘, 22}


字典
--------------------------------------
s1 = {11,22,33}
li = {‘wml‘:20,‘alex‘:30}
s1.update(li)
print(s1)

打印结果
{33, ‘alex‘, 11, ‘wml‘, 22}

 

定义函数
========================================================================
def 函数名(参数): #定义函数
       函数体
返回值

函数名() #执行函数



函数构成
========================================================================
1.def 创建函数
2.函数名
3.函数体
4.返回值
5.参数
普通参数
指定参数
默认参数
动态参数
*args
**kwargs
万能参数
*args,**kwargs
6.补充：
a.
def f1
def f1
函数重新赋值
b. 引用
c. 全局变量
读，均可读
赋值，global
字典，列表，可修改
全部变量名要用大写




返回值
========================================================================

return "value" #在函数中，一旦执行return,函数执行过程立即中止，下面不会执行，不指定任何值，会返回None

def f1():
print(123)
return
print(456)
r = f1()
print(r)

打印结果
123
None


def f1():
print(123)
return 111
print(456)
r = f1()
print(r)

打印结果
123
None




捕捉异常处理
========================================================================
try:
except:


发邮件程序
--------------------------------------------------------------------------------------------------------------------
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Wml
def sendmail():
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr

msg = MIMEText(‘邮件内容‘, ‘plain‘, ‘utf-8‘)
msg[‘From‘] = formataddr(["武沛齐",‘[email protected]‘])
msg[‘To‘] = formataddr(["走人",‘[email protected]‘])
msg[‘Subject‘] = "主题"

server = smtplib.SMTP("smtp.126.com", 25)
server.login("[email protected]", "WW.3945.59")
server.sendmail(‘[email protected]‘, [‘[email protected]‘,], msg.as_string())
server.quit()
sendmail()



def sendmail():
try:
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
msg = MIMEText(‘邮件内容‘, ‘plain‘, ‘utf-8‘)
msg[‘From‘] = formataddr(["武沛齐",‘[email protected]‘])
msg[‘To‘] = formataddr(["走人",‘[email protected]‘])
msg[‘Subject‘] = "主题"

server = smtplib.SMTP("smtp.126.com", 25)
server.login("[email protected]", "WW.3945.5")
server.sendmail(‘[email protected]‘, [‘[email protected]‘,], msg.as_string())
server.quit()
except:
# 发送失败
return "失败"
else:
# 发送成功
return "cc"

ret = sendmail()
print(ret)
if ret == "cc":
print(‘发送成功‘)
else:
print("发送失败")



函数参数
========================================================================

形式参数
def 函数名(形参1,形数2,....):

实际参数
函数名(实参1,实参2,.....)


参数构成
--------------------------------------------------------------------------------------------------
1.普通参数（必须按照参数位置传参）
2.默认参数（必须放到参数列表的最后）
3.指定参数（传参时调用形参名直接传值，传参时不用考虑摆放位置）
4.动态参数
* 默认将传入参数，全部放置在元组中， f1(*[11,22,33,44])
** 默认将传入参数，全部放置在字典中， f1(**{‘k1‘:‘v1‘,‘k2‘:‘v2‘})
5.万能参数
*args,**kwargs （*args必须在前，**kwargs在后面）
--------------------------------------------------------------------------------------------------





1. 普通参数 （必须按照参数位置传参）
-----------------------------------------------------------
语法:
def 函数名(形参1,形参2,...):
函数体

函数名(实参1,实参2,...)

举例:
def send(can1,can2):
print(can1,can2)
return True
send(‘alex‘,‘sb‘)

执行结果
alex sb


2. 默认参数 （必须放到参数列表的最后）
-----------------------------------------------------------
语法:
def 函数名(形参1,形参2,...,形参n=‘values‘): #传参时参数可加，可不加，不加的话，走默认参数
函数体

函数名(实参1,实参2,...,实参n可加可不加) #实参n不加走默认参数值

举例:
def send(xxoo,content,xx=‘OK‘):
print(xxoo,content,xx)
return True
send(‘alex‘,‘sb‘)
send(‘alex‘,‘sb‘,‘BB‘)

执行结果
alex sb OK
alex sb BB


3. 指定参数 （传参时调用形参名直接传值，传参时不用考虑摆放位置）
----------------------------------------------------------------------------------------------------------
语法:
def 函数名(形参名1,形参名2,...):
函数体

函数名(形参名2=‘values‘,形参名1=‘values‘,...) #这里的形参名可以随意摆放，只要和函数名里的形参名对应

举例:
def send(xxoo,content):
print(xxoo,content)
return True
send(content=‘alex‘,xxoo=‘sb‘)

输出结果
sb alex



4. 动态参数
----------------------------------------------------------------------------------------------------------------

* 默认将传入参数，全部放置在元组中， f1(*[11,22,33,44])
------------------------------------------------------------------------------------
语法:
def 函数名(*args):
函数体

将字符串传入到元组输出
------------------------------------------
函数名(11,22,‘alex‘,‘hhhh‘)

将列表传入到元组输出
------------------------------------------
列表名 = [11,22,‘alex‘,‘hhhh‘]
函数名(列表名) #将整个列表当做一个元素传值

将列表格式为字符串输出
------------------------------------------
函数名(*列表名) #将列表每个值当做一个元素传值

将字符串for循环拆分输出
------------------------------------------
字符变量名 = ‘alex‘
函数名(*字符变量名)


举例:

任意传参，形参中有*号，会将任何传参以元组形式输入
def f1(*args):
print(args,type(args))

将字符串传入到元组输出
f1(11,22,‘alex‘,‘hhhh‘)

将列表传入到元组输出
li = [11,22,‘alex‘,‘hhhh‘]
f1(li) #将整个列表当做一个元素传值

将列表格式为字符串输出
f1(*li) #将列表每个值当做一个元素传值

将字符串for循环拆分输出
li = ‘alex‘
f1(*li)

执行结果
(11, 22, ‘alex‘, ‘hhhh‘) <class ‘tuple‘>
([11, 22, ‘alex‘, ‘hhhh‘],) <class ‘tuple‘>
(11, 22, ‘alex‘, ‘hhhh‘) <class ‘tuple‘>
(‘a‘, ‘l‘, ‘e‘, ‘x‘) <class ‘tuple‘>



** 默认将传入参数，全部放置在字典中， f1(**{‘k1‘:‘v1‘,‘k2‘:‘v2‘})
---------------------------------------------------------------------------------------------
语法:
def 函数名(**args):
函数体

函数名(key1=‘values‘,key2=‘values‘,......) 或 函数名(**{‘key1‘=‘values‘,‘key2‘=‘values‘,......})

举例:
def f1(**args):
print(args, type(args))
f1(n1 = ‘alex‘)

def f2(**args):
print(args, type(args))
f2(n1 = ‘alex‘,n2 = ‘wml‘)

输出结果
{‘n1‘: ‘alex‘} <class ‘dict‘>
{‘n1‘: ‘alex‘, ‘n2‘: ‘wml‘} <class ‘dict‘>

传参时，**的区别
--------------------------------------------------------------------------------------
def f1(**args):
print(args)
f1(n1=‘alex‘,n2=18)

dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘}
f1(kk=dic) #将整个字典当做一个元素传值
f1(**dic) #将字典中每个key当做一个元素传值

输出结果
{‘n2‘: 18, ‘n1‘: ‘alex‘} <class ‘dict‘>
{‘kk‘: {‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘}} <class ‘dict‘>
{‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘} <class ‘dict‘>

f1(11,22,33,44,k1=‘v1‘,k2=‘v2‘)
dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘}
f1(**dic)



5.万能参数
*args,**kwargs （*args必须在前，**kwargs在后面）
--------------------------------------------------------------------------------------------------
语法:
def 函数名(*args,**kwargs): # *args 将实参封装成元组，**kwargs 将实参封成字典，两者位置不可颠倒
函数体

函数名(11,22,33,44,k1=‘v1‘,k2=‘v2‘)


举例:
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‘}

 

def format(*args,**kwargs) 相同于 str format() 格式化输出
--------------------------------------------------------------------------------------------------
str format() 格式化输出:
---------------------------------------------------------------------------------
s1 =‘i am {0},age {1}‘.format(‘alex‘,18)
print(s1)

s2 =‘i am {0},age {1}‘.format(*[‘alex‘,18])
print(s2)

s3 =‘i am {name},age {age}‘.format(name=‘alex‘,age=18)
print(s3)

dic = {‘name‘:‘alex‘,‘age‘:18}
s4 = ‘i am {name},age {age}‘.format(**dic)
print(s4)
--------------------------------------------------------------------------------------------------




验证函数的执行顺序
--------------------------------------------------------------------------------------------------
def f1(a1,a2):
return a1+a2

def f1(a1,a2):
return a1*a2

ret = f1(8,8)
print(ret)

执行结果
64


相同于
name = ‘alex‘
name = ‘ben‘
print(name)

执行结果
ben

局部变量
-------------------------------------------------------------
def f1():
name = ‘alex‘
print(name)

def f2():
print(name) #函数f1中的 name变量 不会在f2中获取到执行，因为它只属于f1函数的局部变量




全局变量
-------------------------------------------------------------
1.所有作用域可读
2.重新赋值，需要global
3.特殊：列表，字典，可修改，不可重新赋值
4.全局变量要求变量名大写
NAME = ‘alex‘

global 变量名
变量名 = 新值



def f1(a1,a2):
return a1+a2

def f1(a1,a2):
return a1 * a2

ret = f1(8,8) #接收一下
print(ret)




#函数传递参类的是引用
def f1(a1):
a1.append(999)

li = [11,22,33,44]
f1(li)
print(li)

def f1():
name = "alex"
print(name)
def f2():
print(name)


#全局变量,所有作用域都可读，如果冲突，先读自己的
#对全局变量进行重新赋值，需要global
#特殊：列表字典,可修改，不可重新赋值
#定义全局变量一定要全是大写，好格式



函数中引用全局变量
NAME = ‘alex ‘ #没有写到函数里的变量是全局变量

def f1():
age=18
print(age,NAME)

def f2():
age=19
print(age,NAME)

f1()
f2()

#输出结果
#18 alex
#19 alex


修改全局变量
----------------------------------------------------------------------
语法:
global 变量名
变量名 = ‘values‘

举例:
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
NAME.append(‘100‘)
print(age,NAME)

def f2():
age = 20
print(age,NAME) #打印f1修改后的全局变量

f1()
f2()Microsoft WDM Image Capture (Win32)




字符串
------------------------------------
NAME = "11,22,33,44"
def f1():
age = 18
global NAME
NAME = 100
print(age,NAME)
f1()
print(NAME)

输出结果
18 100
100

列表
------------------------------------
NAME = [11,22,33,44]
def f1():
age = 18
global NAME
NAME=100
print(age,NAME)
f1()
print(NAME)

输出结果
18 100
100

元组
------------------------------------
NAME = (11,22,33,44)
def f1():
age = 18
global NAME
NAME = 100
print(age,NAME)
f1()
print(NAME)

输出结果
18 100
100

字典
------------------------------------
NAME = {‘k1‘:11,‘k2‘:22}
def f1():
age = 18
global NAME
NAME=100
print(age,NAME)
f1()
print(NAME)

输出结果
18 100
100








登录注册功能
------------------------------------------------------------------------------------------
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Wml

#!/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 = "\n" + username + "|" + password
f.write(temp)
f.close()


def main():
t=input("1:登录;2:注册:")
if t == "1":
user =input("请输入用户名：")
pwd = input("请输入密码：")
r = login(user,pwd)
if r:
print("登录成功")
else:
print("登录失败")
elif t=="2":
user =input("请输入用户名：")
pwd = input("请输入密码：")
register(user,pwd)

main()
------------------------------------------------------------------------------------------

 

内置函数

布尔值 #0,None,"",[],() 全是false
----------------------------------------------------------------------------------------------------------------------------
语法:
bool(value)

举例:
print(bool(-1))
print(bool(1))
print(bool(None))
print(bool(‘‘))
print(bool([]))
print(bool(()))
print(bool({}))

执行结果
True
True
False
False
False
False
False



abs 取绝对值
----------------------------------------------------------------------------------------------------------------------------
语法:
abs(value)

举例:
print(abs(-1))

执行结果:
1


all() # 接收可以被循环的对象，全为真，则为Ture，否则为False
any() # 任何一个为真，则为真
#0,None,"",[],() 全是false
----------------------------------------------------------------------------------------------------------------------------
all()
------------------------------------------------
语法:
all("value")
all([value1,value2,.....])
all((value1,value2,.....))
all({‘key1‘:value,‘key2‘:value,.....})

举例:
print(all("1"))
print(all([1,2,3,4]))
print(all((1,2,3,4)))
print(all({1,2,3,4}))

执行结果:
True
True
True
True


any()
------------------------------------------------
语法:
any("value")
any([value1,value2,.....])
any((value1,value2,.....))
any({‘key1‘:value,‘key2‘:value,.....})

举例:
print(any("wml"))
print(any([0,1,2,None,""]))
print(any((0,1,2,None,"")))
print(any({‘wml‘:30}))

执行结果
True
True
True
True



ascii()
------------------------------------------------------------------------------------
自动执行对象的 __repr__方法

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



字符串转为字节
--------------------------------------------------------------------------------
语法:
bytes(要转换的字符串,字符编码)

举例:
s = ‘李杰‘

n = bytes(s,encoding=‘utf-8‘)
print(n)
n = bytes(s,encoding=‘gbk‘)
print(n)

打印结果
b‘\xe6\x9d\x8e\xe6\x9d\xb0‘
b‘\xc0\xee\xbd\xdc‘


# utf-8 一个汉字：三个字节
# gbk 一个汉字：二个字节
# utf-8
s = "李杰"
# 一个字节8位，一个汉字三个字节
# 0101010 10101010 101010101 0101010 10101010 101010101
# 23 23 23 23 23 23 15
# 2f 2a 2c 2c 2e 2f f




字节转为字符串
--------------------------------------------------------------------------------
语法:
str(bytes(‘字符串‘,encoding=‘utf-8‘),encoding=‘utf-8‘)

举例:
s = str(bytes(‘李杰‘,encoding=‘utf-8‘),encoding=‘utf-8‘)
print(s)

 

三元运算，三目运算

语法:
变量名 = ‘values‘ if 比较条件 else ‘values‘

举例:
用于写简单的if else 的
if 1 == 1:
name = "alex"
else:
name = "SB"

#三元运算，三目运算
#如果1 == 1 成立，name 等于alex，否则：name 等于 "SB"
name = "alex" if 1 == 1 else "SB"

 

lambda 表达式 （就是定义函数的另一种方式）

语法:
函数名 = lambda 形参1,形参2,....:

举例:

第一种定义函数方法
------------------------------------------------------------------
def f1(a1):
return a1 + 100


下面的操作，与上面定义的函数完全一样
------------------------------------------------------------------
f1 = lambda a1:a1+100
ret = f1(10)
print(ret)

打印结果
110


f2 = lambda a1,a2=9:a1+a2+100 #多参数
r2 = f2(9)
print(r2)

打印结果
118

 

语法:
-----------------------------------------------------------------------------------------------------
基本语法
--------------------------------------------------------
对象名 = open(‘文件名‘,‘权限‘,字符编码)
操作参数
对象名.close()

for循环文件对象
--------------------------------------------------------
对象名 = open(‘文件名‘,‘权限‘,字符编码)
for line in 对象名: #这里的line只是举例
操作参数
对象名.close()
-----------------------------------------------------------------------------------------------------




权限:
-----------------------------------------------------------------------------------------------------
单权限
-----------------------------------------------
r , 只读模式 [默认]
w , 只写模式 [不可读；不存在则创建,存在则清空内容]
x , 只写模式 [不可读；不存在则创建,存在则报错]
a , 追加模式 [可读 ；不存在则创建,存在则只追加内容]


+ 表示可以同时读写某个文件
-----------------------------------------------
r+ , 读写 [可读，可写]
w+ , 写读 [可读，可写]
x+ , 写读 [可读，可写]
a+ , 写读 [可读，可写]


b 表示以字节的方式操作
-----------------------------------------------
rb 或 r+b
wb 或 w+b
xb 或 w+b
ab 或 a+b

注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型
-----------------------------------------------------------------------------------------------------




参数
-----------------------------------------------------------------------------------------------------
变量名.read() 读，无参数，读全部
有参数，按字节，按字符
变量名.close() 关闭
变量名.write() 写数据，有b权限,必须调用bytes()转为字节写入，无b权限,以字符写入
变量名.seek() 主动将指针调到指定位置
变量名.tell() 获取当前指针的位置（按字节）
变量名.seek(变量名.tell()) 当前指针位置开始向后覆盖（按字节）
变量名.flush() 强刷
变量名.readline() 仅读取一行
变量名.truncate() 截断，根据指针位置截断
-----------------------------------------------------------------------------------------------------




文件操作构成
-----------------------------------------------------------------------------------------------------
打开文件 open()
操作文件 操作参数: read(),write(),seek(),tell(),flush(),readline,truncate
关闭文件 .close()
-----------------------------------------------------------------------------------------------------




举例
-----------------------------------------------------------------------------------------------------
读文件
f = open(‘dd.txt‘,‘r‘, encoding=‘utf-8‘)
data = f.read()
print(data,type(data))
f.close()

以二进制读文件
f = open(‘dd.txt‘,‘rb‘)
data = f.read()
print(data,type(data))
f.close()

追加
f = open(‘db.txt‘,‘a‘)
f.write(‘hello‘)
f.close()

x 权限是只写，文件存在则报错，不存在就创建并写入
f = open(‘db.txt‘,‘x‘)
f.write(‘hello‘)
f.close()

以二进制方式追加，需要在bytes将字符串转为二进制之后在追加
f = open(‘db‘,‘ab‘)
f.write(bytes(‘李杰‘,encoding=‘utf-8‘))
f.close()


读写文件，只能追加到文件最底行的行尾（因为read()读文件从开头读到行尾，自然而然的追加到最低行的行尾）
f = open(‘db‘,‘r+‘,encoding=‘utf-8‘)
data = f.read()
print(data)
f.write(‘777‘)
f.close()

按指定位置读写()
f = open(‘db‘,‘r+‘,encoding=‘utf-8‘) #打开文件，给读并写权限
data = f.read(1) #读取第一个字符
print(f.tell()) #获取当前指针位置
f.seek(f.tell()) #从当前指针下向后覆盖
f.write(‘888‘) #添加并覆盖原位置字符
f.close() #关闭文件

强刷
f = open(‘ss.txt‘,‘a‘,encoding=‘utf-8‘)
f.write(‘123,hello‘)
f.flush()
input(‘请输入内容‘) #这里我执行时什么都不输入，上面的123,hello也会被写入到ss.txt文件中，就因为加了flush()强刷

我这里连 close()关闭文件都没有，也一样写入



根据指针位置截断
f = open(‘db.txt‘,‘r+‘,encoding=‘utf-8‘) #打开db.txt,给读写权限
f.seek(3) #第3个位置的字节
f.truncate() #在上面定义的第3个位置的字节，向后截断清空
f.close()
-----------------------------------------------------------------------------------------------------



for循环文件对象
-----------------------------------------------------------------------------------------------------
举例:
f = open(‘ss.txt‘,‘r+‘,encoding=‘utf-8‘) #首先你的 ss.txt,我的ss.txt文件有6行123,hello
for line in f: #循环打印 ss.txt 的每一行
print(line.strip())
f.close()

执行结果
123,hello
123,hello
123,hello
123,hello
123,hello
123,hello
-----------------------------------------------------------------------------------------------------







with 循环处理上下文（就是不需要手动close()关闭了，自动会关闭）
--------------------------------------------------------------------------------------------------------------------------------------------------------------
语法:
with open(‘文件名‘,‘权限‘,‘字符编码‘) as 对象名1,open(....) as 对象名2,.........
操作内容


举例:

打开一个文件
------------------------------------
with open(‘db1.txt‘) as f:
pass

打开两个文件，可以打开更多
-------------------------------------------------------------------
with open(‘db1.txt‘) as f1,open(‘db2.txt‘) as f2:
pass

在第1文件读1行，向第二文件写1行，写到第10行结果不在写了
--------------------------------------------------------------------------------------------------------------------------
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


replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次
---------------------------------------------------------------------------------------------------------------------------------------------------------------
with open(‘db1.txt‘, ‘r‘, encoding="utf-8") as f1, open("db2.txt", ‘w‘,encoding="utf-8") as f2: #在第db1.txt文件读1行，向第db2.txt文件写1行
for line in f1:
new_str = line.replace("alex", ‘st‘) #把带有alex字符串替换成st
f2.write(new_str)