1 se = {'123','234'}
2 se=set()

#转换：
li=[1,2,3]
s1=set(li)  转换一个列表为集合
#原理就是调用了set   __init__构造方法，就是做了一个for循环。

 1 set.add()   #添加，只能一个元素一个元素的添加，不能同时添加多个元素
 2
 3 set.clear() #清除
 4
 5 set.copy() #浅拷贝
 6
 7 set.difference()  #差集
 8 #例子：
 9 s1,difference(s2) #找出s1中存在的s2中不存在的元素
10
11 set.symmetric_difference()  #把两个集合的相互不存在的元素找出来，对称差集
12
13 s1 = {1,2,3}
14 s2 = {2,3,4}
15 s1.difference_update(s2)
16 print(s1)
17 {1}    # 把s1存在s2不存在的找出来并且更新覆盖到s1
18
19 s1.symmetrice.difference_update(s2) #把互相不存在的更新到s1中。
20 print(s1)
21 {1,4}
22
23 s1.discrd(3) #移除s1中的3，如果没有3则不报错
24
25 s1.remove(3) #移除s1中的3，如果没有则报错
26
27 s1.pop()         #随机删除一个参数并获取它，没有参数
28
29 s1.intersection(s2) # 找s1 s2的交集
30
31 s1.intersection.update(s2)   #找s1 s2的交集并赋给s1
32
33 s1.isdisjoint（s2）   # 判断s1,s2是否不向交
34
35 s2.issubest(s1)        #s1，s2是否有交集
36
37 s3=s2.union(s1)       #s3为s1和s2的并集
38
39 s1.update()          #向s1中批量添加一组可迭代的对象
40 #例子 list  dict tuple 可以，现在以dict为例
41 s3={'k1':'v1','k2':'v2'}
42 #想要添加s3的key
43 s2.update(s3)
44 #也可以添加s3的values
45 s2.update(s3.values())

old_dict = {"#1": 8,"#2":4,"#4":2,
}new_dict = {"#1":4,"#2":4,"#3":2,
}#old_dict是服务器原内存插槽位置及内存容量，
#new_dict是服务器新内存插槽位置及内存容量。
#应该删除那几个槽位，
#应该更新那几个槽位
#应该增加那几个槽位            

def f1()return True

 1 def sendmail():    #声明函数  sendmail为函数名
 2     import smtplib
 3     from email.mime.text import MIMEText
 4     from email.utils import formataddr
 5
 6     msg = MIMEText('邮件内容', 'plain', 'utf-8')
 7     msg['From'] = formataddr(["alex", 'alex@126.com'])
 8     msg['To'] = formataddr(["走人", 'alex@qq.com'])
 9     msg['Subject'] = "主题"
10
11     server = smtplib.SMTP("smtp.126.com", 25)
12     server.login("alex@126.com", "密码")
13     server.sendmail('alex@126.com', ['alex@qq.com', ], msg.as_string())
14     server.quit()
15
16 sendmail()      #使用函数  

def send(arg1,arg2)      　 #arg1,arg2是 形式参数，目的是占位。  print(arg1,arg2)        #函数内的形式参数也是占位，但是名字要和#声明函数中的形式参数一一对应#可以按照位置传输实际参数
send('alex','nb')#也可以指定传输实际参数
send(arg2="nb",arg1="alex")         

def send(arg1,arg2='alex')　　　　　　　　#arg1的默认参数位alex，默认参数,一定要放到所有形参的最右边，否则会报错。　　　　print(arg2,arg1) 

#使用函数并传递参数时如果不传递参数则使用默认参数 send('nb') alex nb

#也可以传递删除 send('nb','wo') wo nb 

def f1(*arg)print(arg)for i  in arg:print(i)l=[1,2,3]
f1(l)
#这样传输l就被当成一个元素穿进去，那么这样的结果是：

([1,2,3],)   #这样传入的元素被当成了一个元组
[1,2,3]       #循环后就得出了这个元组内的元素。

def f1(*arg)print(arg)l=[1,2,3]
f1(*l)
#这样传输l就被当成一个元素穿进去，那么这样的结果是：

(1,2,3,)   #这样传入列表中的元素就被遍历后再一个一个的传入到f1中

def f1(args):print(args)d={'a':1,'b':2}
f1(d){'b': 2, 'a': 1}

def f1(**args):print(args)f1(a=1,b=2){'b': 2, 'a': 1}

def f1(**args):print(args)d1={'a':1,'b':2}
f1(**d1)

{'a': 1, 'b': 2}

def f1(*args,**kwargs)print(args)print(kwargs)#这样往这个函数里面传参就不用考虑实际参数类型了。

 def format(self, *args, **kwargs): # known special case of str.format"""S.format(*args, **kwargs) -> str

s = "i am {0},i am {1}" .format('jack',18)
i am jack,age18#jack 和 18 都别识别为 给*args传参数。也可以定义一个可遍历的对象如：
a=['jack',11]
s = "i am {0},i am {1}" .format(*a)
i am jack,age 11==================================
还有一个格式：
s = "i am {name},i am {age}" .format(name='jack',age=18)也可以利用万能参数的特性
a={'name':'hx','age':19}
s="i am {name},age {age}".format(**a)
i am hx,age 19

#有两个同名的函数def f1(a1,a2):return a1 + a2def f1(a1,a2):return a1 * a2ret = f1(8,8)
print(ret)
64#函数默认是从上自下依次执行的。

 def f1(a):a.append(999)
li=[111,222,333]
f1(li)
print(li)
[11, 22, 33, 999]
#函数中对li进行了添加操作，最后函数外的li被函数给改变了。#所以python传参数传递的是引用。

 AGE=22def f1():name = 'hx'global AGEAGE = '26'print(name,AGE)
f1()
print(AGE)hx 26
26  此时外面的AGE也被修改了其他的函数如果要调用AGE的时候就是修改后的数值了。===============================AGE=22def f1():name = 'hx'AGE = '26'print(name,AGE)
f1()
print(AGE)hx 26
22 此时外面的AGE没有被修改

NAME=[1,2,3]DIC = {'k1':11,'k2':22}def f1():    NAME.append(4)    DIC.clear()f1()print(NAME)print(DIC)

[1,2,3,4]{}#但是如果想重新赋值就需要加上global了

def f1():    global NAME,DIC    NAME = [2,3,4]    DIC = {'k1': 13, 'k2':14}

f1()print(NAME)print(DIC)

[2, 3, 4]
{'k1': 13, 'k2': 14}

if 1==1:name='abarma'else:name='putin' 

name ='abarma' if 1 == 1 else 'putin'

def f1(a):return a+100

f1 = lambda a ：a + 100

f1:函数名a：xingcana+100：函数的return

#形参在lambda里也可以设置默认值：f1 = lambda a b=20 : a + b + 100

abs（） #取绝对值all（） #接受一个可迭代对象，所有元素如果都为真返回为真，则为假。any（） #接受一个可迭代对象，所有的元素如果有一个为真就为真。ascii（） #自动执行对象的__repr___方法：　　class Foo:　　　　def __repr__(self):　　　　return "111"　　n = ascii(Foo())　　print(n)　　111bin()   #接受10进制转为2进制  ob开头oct()   #接收10进制转为8进制　0o开头hex()　　#接受10进制转16进制  0x开头

bytes()  #把一个汉字转换成字节　　对于utf-8 来讲一个汉字三个字节 一个字节8位，

　　s="哈哈"　　n = bytes(s,encoding="utf-8")　　print(n)　　b'\xe5\x93\x88\xe5\x93\x88'

　　对于gbk，一个汉字2个字节　　s="哈哈"　　n = bytes(s,encoding="gbk")　　print(n)　　b'\xb9\xfe\xb9\xfe'#上面的表现形式就是把汉字转换成字节的类型

字节转化成 字符串使用str就可以转换

new_list = str(bytes(s,encoding="utf-8"),encoding="utf-8")#这样就给转化你回来了。

a=bytes("哈哈",encoding="utf-8")print(a)b'\xe5\x93\x88\xe5\x93\x88'

b=str(a,encoding="utf-8")print(b)哈哈

b=str(b'\xe5\x93\x88\xe5\x93\x88',encoding="utf-8")或者这样也可以把字节给转换回字符串print(b)哈哈

 r： 只读w： 只写，清空源文件  x： 如果这个文件存在就报错，如果不存在则创建并写。  （python3中新加）    a： 追加rb: 以二进制的形式读取wb: 以二进制的形式读取ab: 以二进制的形式追加　　 r+： 读写  　　 w+： 写读　　 x+： 写读　　 a+： 写读

b： 有b就是字节类型，没有b就是字符串类型f = open('x','rb')     #用rb 的意思就是存或者读文件的时候我告诉python解释器，你不用帮我转换了。我直接转换成字节以2进制的方式存取。
f.read()#如果一开始不是以rb存储的，比如是用utf-8存储的，但是你却用rb去读取。哪肯定读不出来了。

如果你之前用的utf-8写的文件，再次写非要想用个b，可以实现。f.open('a','rb')f.write(bytes('hello',encoding='utf-8')) 　　　　　　这样的话就是告诉解释器：我来写，我使用bytes，把hello使用utf-8来保存。　　　　（我用bytes把‘hello’以utf-8的形式转换成二进制）f.close()

如果你要以r存，然后非要以b读的话怎么办？

with open('aaa','rb') as file1: 　　a=file1.readline()　　 print(a)　　 　　b'\xe5\x93\x88\xe5\x93\x88'　　　　因为a就已经是被utf-8转换的字节了所以可以世界用str转换回来　　b=str(a,encoding="utf-8")　　print(b)　 哈哈

复杂的文件存取模式： +

r+ w+ a+ x+ 功能对比：

r+要先读再写，才能内次写进去。指针在读前是在最开始位置，一点读了以后指针就跑到了最后的位置，之后我们再写就可以把内容追加进去了。如果用r+模式先写在读就会发生指针错乱：本来指针在最开始，等待让我们读，但是我们却写了数据进去，然后指针就到了我们写进数据的后面，此时我们又开始读了，所以我们只能读取到指针后面的东西了。没有 b read()的时候按照字符读取，有 b read() 按照字节读取

r+ 在读写文件时最灵活，可以所以的用seek()调整位置，然后写文件。==========================================================a+:虽然可以读写了，但是不管你读到那里，再写的话永远写到文件的最后面

==========================================================w+:虽然可以读写，它会先清空，再写，最后写进去的东西可以读出来了==========================================================

f.seek() #主动的把指针调整到某一个位置使用f.seek()调整位置后，然后再往里面写东西，新写的文字会覆盖原来的文字。

如果read()无参数则打开全部文件f.read(1)是否+b的区别

在使用 r 读取时没有b 位置单位是一个字符但是我们用 r+b 来读取的时候 位置单位就是一个字节但是seek不管用什么方式打开，都是以字节的方式来找位置。f.tell()   #获取当前指针的位置

readline()  #以字符串的形式仅读取一行

readlines() #把全部文件都读取出来放到一个列表中去。

truncate()  #清空指针后面的字符

seek（）     #指针跳转到指定位置，按照字节来跳转

write()　　　#写数据，如果打开方式有b 只能写字节，无b写字符

fileno()    #文件描述符，查看底层文件有没有变化时用这个flush（）　　#强刷文件

readable()  #判断是否可读， 如果以w方式打开，就是不可读 False

seekable()  #是否可以移动指针

最常用：f = open('ab','r')for line in f　　print(line)或者while True　　x=f.readline()　　if x:　　　　print(x)　　else:　　　　break

f.close()   #关闭文件

with open('xb',r，encoding="utf-8") as f:   pass
#with这个功能，在对文件操作完了就自动关闭了。

源代码定义：def open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True)

2.7以后支持with 同时打开多个文件 

with open('xb','r'，encoding="utf-8") as f，open（'xb2','w',encoding="utf-8"） as f2　　一个读一个就可以把读出来的写到f2里面。