# 创建set集合
s1 = {11, 22, 33}
print(s1,type(s1))
==> {33, 11, 22} <class 'set'>l1 = [2, 3, 4,]
s1 = set(l1)
print(l1,type(l1))
==> [2, 3, 4] <class 'list'>print(s1,type(s1))
==> {2, 3, 4} <class 'set'># 集合中增加元素
s1 = {11, 22, 33}
s1.add(44)
print(s1)
==> {33, 11, 44, 22}# 清空集合中元素
s1 = {11, 22, 33}
print(s1)
==> {33, 11, 22}s1.clear()
print(s1)
==> set()# 找到在s1中有，s2中没有的元素，并保存到一个新的集合
s1 = {11,22,33,}
s2 = {22,33,44,}
s3 = s1.difference(s2)
print("%s \n%s \n%s" % (s1,s2,s3))
==> {33, 11, 22}
==> {33, 44, 22}
==> {11}# 找到在s1中有，s2中没有的元素，把结果更新到s1中
s1 = {11,22,33,}
s2 = {22,33,44,}
s1.difference_update(s2)
print("%s \n%s" % (s1,s2))
==> {11}
==> {33, 44, 22}# 找到即在集合s1中，又在集合s2中的元素，并把结果保存到一个新的集合里
s1 = {11,22,33,}
s2 = {22,33,44,}
s3 = s1.intersection(s2)
print("%s \n%s \n%s" % (s1,s2,s3))
==> {33, 11, 22}
==> {33, 44, 22}
==> {33, 22}# 找到即在集合s1中，又在集合s2中的元素，并把结果更新到s1中
s1 = {11,22,33,}
s2 = {22,33,44,}
s1.intersection_update(s2)
print("%s \n%s" % (s1,s2))
==> {33, 22}
==> {33, 44, 22}# 判断两个集合是否有交集，没有交集时返回True，有交集时返回False
s1 = {11,22,33,}
s2 = {22,33,44,}
s3 = {1,2,3,}
s1.isdisjoint(s2)
==> False
s1.isdisjoint(s3)
==> True# 判断s1是不是s2的子集
s1 = {11,22,}
s2 = {11,22,33,44,}
s3 = {22,33,}
s1.issubset(s2)
==> Trues1.issubset(s3)
==> False# 判断s1是不是s2的父集
s1 = {11,22,33,44,55}
s1 = {11,22,33,44,55,}
s2 = {22,33,55,}
s3 = {44,33,66,}
s1.issuperset(s2)
==> Trues1.issuperset(s3)
==> False# 任意删除并返回一个元素
s1 = {11,22,33,44,55,}
s1.pop()
==> 33# 删除指定的一个元素，这个元素必须在集合中，否则报错。区别于discard()
s1 = {11,22,33,}
s1.remove(11)
print(s1)
==> {33, 22}s1.remove(44)
==> Traceback (most recent call last):File "<stdin>", line 1, in <module>KeyError: 44# 删除指定的一个元素，如果元素不存在不报错。可以起到判断元素是否在集合中时，代码不报错的作用
s1 = {11,22,33,}
s1.discard(11)
print(s1)
==> {33, 22}s1.discard(44)   # 44 不在s1中，操作时不报错
print(s1)
==> {33, 22}# 相当于取两个集合的并集，再把他俩的交集删掉。返回这个新集合
s1 = {11,22,33,44,}
s2 = {22,44,55,66}
s3 = s1.symmetric_difference(s2)
print("%s \n%s \n%s" % (s1,s2,s3))
==> {33, 11, 44, 22}
==> {66, 44, 22, 55}
==> {33, 66, 11, 55}# 取s1，s2两个集合的并集，再把他俩的交集删掉。结果赋值给s1
s1 = {11,22,33,44,}
s2 = {22,44,55,66}
s1.symmetric_difference_update(s2)
print("%s \n%s" % (s1,s2))
==> {33, 66, 11, 55}
==> {66, 44, 22, 55}# 取两个集合的并集，结果返回到一个新集合中
s1 = {11,22,33,44,}
s2 = {22,44,55,66}
s3 = s1.union(s2)
print("%s \n%s \n%s" % (s1,s2,s3))
==> {33, 11, 44, 22}
==> {66, 44, 22, 55}
==> {33, 66, 11, 44, 22, 55}# s1.update(s2) 去两个集合的并集，将结果赋值给s1
s1 = {11,22,33,44,}
s2 = {22,44,55,66}
s1.update(s2)
print("%s \n%s" % (s1,s2))
==> {33, 66, 11, 44, 22, 55}
==> {66, 44, 22, 55}

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author He Xu

old_dict = {"#1":8,"#2":4,"#4":2,
}new_dict = {"#1":4,"#2":4,"#3":2,
}# 需求：将插槽4的内存放到插槽3，将插槽1的内存改为4G# 因为是字典
new_set = set(new_dict.keys())
old_set = set(old_dict.keys())# 应该删除槽位4: old存在，new不存在的key
remove_set = old_set.difference(new_set)
print(remove_set)
==> {'#4'}# 应该增加槽位3: new存在，old不存在的
add_set = new_set.difference(old_set)
print(add_set)
==> {'#3'}# 应该更新槽位1: 两个都有的,取交集
update_set = old_set.intersection(new_set)
print(update_set)
==> {'#2', '#1'}

def sendmail():try:import smtplibfrom email.mime.text import MIMETextfrom email.utils import formataddrmsg = 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", "WW.3945.59")server.sendmail('wptawy@126.com', ['664076968@qq.com', ], msg.as_string())server.quit()except:# 发送失败传给sendmail()return  False # return值可以是字符串else:# 发送成功传给sendmail()return True   # return值可以是字符串

ret = sendmail()
print(ret)
# 后面还可以加if判断

# 普通参数，按顺序传参
def send(name,age):print(name,age)return Truesend('hexu',28)==> hexu 28# 默认参数
def send(name,age,content='is a person'):print(name,age,content)return Truesend('Hexu',28)  # 默认参数：如果没指定参数，就会把默认参数打出来
send('Xuelu',26,"is a god") # 指定一个参数，就会打指定的参数==> Hexu 28 is a person
==> Xuelu 26 is a god# 指定参数:将实际参数复制给指定的形式参数
def send(name,age):print(name,age)return Truesend(age=28,name='hexu')==> hexu 28# 带*的，可以接收动态参数
def f1(*args):print(args,type(args))f1(11)  # 一个参数
f1(11,22,'hexu')  # 多个参数
f1([11,22,'hexu'],'liuwei') # 参数也可以是列表
f1(*['aa','bb',28]) # 实际参数前面带*，会将列表中的每一个元素当做元组中的一个元素
f1(*'hexu')  # 实际参数前面带*，会将字符串中的每一个元素当做元组中的一个元素==> (11,) <class 'tuple'>
==> (11, 22, 'hexu') <class 'tuple'>
==> ([11, 22, 'hexu'], 'liuwei') <class 'tuple'>
==> ('aa', 'bb', 28) <class 'tuple'>
==> ('h', 'e', 'x', 'u') <class 'tuple'># 带两个*的,生成的是字典
def f1(**args):print(args,type(args))f1(n1="hexu",n2=28) # 这种键值的组合，会自动生成字典

dic = {'k1':'v1','k2':'v2'}f1(kk=dic) # kk是key，dic是value
f1(**dic)==> {'n2': 28, 'n1': 'hexu'} <class 'dict'>
==> {'kk': {'k2': 'v2', 'k1': 'v1'}} <class 'dict'>
==> {'k2': 'v2', 'k1': 'v1'} <class 'dict'># 万能参数
def f1(*args,**kwargs):print(args)print(kwargs)
f1(11,22,33,k1='hexu',k2='liuwei')==> (11, 22, 33)
==> {'k2': 'liuwei', 'k1': 'hexu'}# 引出字符串的格式化
s1 = 'i am {0},age {1}'.format('hexu',28)
print(s1)
s2 = 'i am {0},age {1}'.format(*['hexu',28])
print(s2)==> i am hexu,age 28
==> i am hexu,age 28# 必须指定
s3 = 'i am {name},age {age}'.format(name='hexu',age=28)
print(s3)
dic = {'name':'hexu','age':28}
s4 = 'i am {name},age {age}'.format(**dic)
print(s4)==> i am hexu,age 28
==> i am hexu,age 28

# 函数执行顺序，自上到下,按最新的函数显示执行结果
def f1(a1,a2):return a1 + a2def f1(a1,a2):return a1 * a2ret = f1(8,8)
print(ret)==> 64# 函数传参，传递的是引用，不是再复制一份
def f1(a1):a1.append(999)li = [1,2,3,4,]  # li是全局变量，从这个例子中可以看出，函数的局部作用域可以对全局变量的进行修改。
f1(li)
print(li) # 最终li中增加了999这个元素# 定义全局变量，要大写！
NAME = 'hexu'def f1():age = 20print(age,NAME)  # 引用全局变量NAMEdef f2():age = 18global NAME    # 修改全局变量要用globalNAME = 'liuwei' # 重新赋值print(age,NAME)f1()
f2()==> 20 hexu
==> 18 liuwei# 特殊情况：不用global的情况下: 列表字典，可修改，不可赋值
LI = [1,2]def f1():LI.append(3)
f1()
print(LI)def f2():LI = [4,5]
f2()
print(LI)==> [1, 2, 3]
==> [1, 2, 3]

# abs() 绝对值
n = -1
print(abs(n))==> 1# 0,None,'',[],{}
# all() 一个为假，就为假
n = all([1,2,3,None])
print(n)==> Flase# any() 一个为真，就为真
n = any([[],0,'',6])
print(n)==> True# bin()十进制转换为二进制  0b
print(bin(5))
==> 0b101# oct() 十进制转换为八进制 0o
print(oct(9))
==>0o11# hex() 十进制转换为十六进制 0x
print(hex(15))
==> 0xf# ut8-f 一个汉字是3个字节
# gbk 一个汉字是2个字节
# 字符串转换成字节
# bytes()  只能转换字符换，按照什么编码，默认转换成16进制，非常重要！！
n = bytes('贺旭',encoding='utf-8')
print(n)
==> b'\xe8\xb4\xba\xe6\x97\xad'n = bytes('贺旭',encoding='gbk')
print(n)
==> b'\xba\xd8\xd0\xf1'# 字节转换成字符串,编码一定要一致
n = str(bytes('贺旭',encoding='utf-8'),encoding='utf-8')
print(n)
==> 贺旭

# db文件原始内容如下
hexu|123
liuwei|999# 以只读形式打开文件
with open('db','r') as fp:data = fp.read()print(data, type(data))输出：
hexu|123
liuwei|999 <class 'str'># 追加到文件的最后，加b是字节，没有b是字符串
with open('db','ab') as fp:data = fp.write(bytes('刘伟',encoding='utf-8'))print(data)输出：
hexu|123
liuwei|999刘伟# r+ 配合seek使用
f = open('db','r+',encoding='utf-8') # 如果没有b，则read，按照字符读取;如果有b,按照字节读取
data = f.read(1)
print(data)
==> 1print(f.tell())  # 找到当前指针所在位置 （字节）
f.seek(f.tell())  # 指针跳转到指针位置（字节）
f.write('88')  # 当前指针位置开始向后覆盖
f.close()输出：
h88u|123
liuwei|999# 同时打开多个文件
with open("db", "r") as file01, open("db.bak", "x") as file02:for i in file01: # 读取db文件的每一行，写入到db.bak文件，如果db.bak文件存在，报错，不做操作
        file02.write(i)with open("db.bak", "r") as f:res = f.read()print(res)

# db原始文件内容
hexu|123
liuwei|999def login(username,password):'''用于用户登录:param username: 用户输入的用户名:param password: 用户输入的密码:return: True，表示登录成功；False，表示登录失败'''with open('db','r') as fp:for line in fp:line_list = line.strip().split('|')if line_list[0] == username and line_list[1] == password:return Truereturn Falsedef register(username,password):'''用于用户注册,注意判断输入的用户名是否在db里已经有了:param username: 用户输入的用户名:param password: 用户输入的密码:return: 默认None'''with open('db','a') as fp:tmp = '\n' + username + '|' + passwordfp.write(tmp)def main():choose = input('1:登录  2:注册')if choose == '1': # 这里的1是字符串user = input('请输入用户名：')pwd = input('请输入密码：')r = login(user,pwd)  # 引用login函数,将用户输入的用户名、密码传进去if r:print('登录成功')else:print('登录失败')elif choose == '2':user = input('请输入用户名：')pwd = input('请输入密码：')register(user,pwd)main()

# 传统模式
a = input("请输入1")
if a == "1":name = "hexu"
else:name = "liuwei"
print(name)# 三元运算 对if else 的简写
a = input("请输入1")
name = "hexu" if a == "1" else "liuwei"
print(name)

# 传统方式
def f1(a1):return a1 + 100
ret = f1(10)
print(ret)
==> 110f2 = lambda a1,a2:a1 + a2 + 100 # 冒号前面的是参数
ret1 = f2(10,20)
print(ret1)
==> 130