#2.while嵌套循环语句（制作九九乘法表）
x,y=0,0 #多变量一次性赋值
while x<9: #外循环条件
x +=1
while y<x: #内循环条件
y +=1
txt='{}×{}={}'.format(y,x,x*y) #格式化
print(txt,end='\t') #'\t'表示制表符，用于文本中创建水平间距
y=0 #内循环一次结束后又重新赋值y为0
print() # 另起一行

#3.if多条件分支语句（判断等级）
lst=[69,89,95,54]
for num in lst:
if num>=90:
print(num,'优')
elif num>=80:
print(num,'良')
elif num>=60:
print(num,'中')
else:
print(num,'差')

#4.break在while和for循环中的应用
# 例1：循环序列数，当符合某个条件时终止循环
num=100
while True: #条件为True，循环将无限执行
num +=1
print(num)
if num==111: #当num等于111时
break #退出循环
print('-----')
# 例2：在一组数字中寻找第3个大于或等于90的数字
num=0 # 循环次数初始值
for score in [98,85,93,97,88,96]: # 从一组数字中循环提取各个数字
if score>=90: # 当某个数字大于等于90时
# print(score) # 注释最后3行，不注释此行，则输出所有大于等于90的数字（98 93 97 96）
num +=1 # 循环次数加1
if num==3: # 如果第3次找到符合条件的数字，
break # 立即退出循环
print(score) # 输出该数字（97）

#5.continue在while和for循环中的应用
# 例1:打印奇数
num=0
while num<5:
num +=1
if num%2==0: #除以2的余数等于0，即原数是偶数，则输出奇数；反之，除以2的余数等于1，即原数是奇数，则输出偶数
continue #退出本次循环。若用break,则退出整个循环。
print(num) # 输出:1 3 5
# 例2：寻找等级
for num in [90,85,99,78,100]:
if num<90:
continue #退出本次循环。作用是整个循环结束后只输出大于90的数
txt='{} 优秀'.format(num)
print(txt) # 输出:90 优秀 99 优秀 100 优秀

#6.字符串切片（提取身份证号码信息）
from datetime import datetime
year=datetime.now().year #获取当前年份
txt='340828195512240114'
sheng='安徽省' if str(txt[0:2])=='34' else '' #提取并判断省名
shi='安庆市' if str(txt[2:4])=='08' or str(txt[2:4])=='28' else '' #提取并判断市名
xian='岳西县' if str(txt[4:6])=='28' else '' #提取并判断县名
nian=int(txt[6:10]) #提取年份
nl=year-nian #年龄
yue=str(txt[11:12]) if int(txt[10:12][0:1])==0 else str(txt[10:12]) #提取月份
ri=str(txt[13:14]) if int(txt[12:14][0:1])==0 else str(txt[12:14]) #提取日期
xb='男' if int(txt[-2])%2==1 else '女' #提取倒数第2个数，判断性别
jg='{}{}{}'.format(sheng,shi,xian) #籍贯
cs='{}年{}月{}日'.format(nian,yue,ri) #出生年月日
nl='{}'.format(nl) # 年龄
xb='{}'.format(xb) # 性别
print('提取信息：籍贯：'+jg+'，出生：'+cs+'，年龄：'+nl+'，性别：'+xb+'。')

#7.列表切片
# 例1：单元素切片
lst1=['张三',19,[80,89,97]]
print(lst1[0],lst1[1],lst1[2]) #返回张三 19 [80, 89, 97]
# print(lst1[-1],lst1[-2],lst1[-3]) #返回[80, 89, 97] 19 张三
# 例2：多元素切片
lst2=[7,3,12,54,6,9,88,2,47,33,55]
# print(lst2[2:5]) #返回[12, 54, 6]，左闭右开，正数从左0数起
# print(lst2[-9:-6]) #返回[12, 54, 6]，左闭右开，负数从右1数起
# print(lst2[:4]) #返回[7, 3, 12, 54]，左闭右开
# print(lst2[6:]) #返回[88, 2, 47, 33, 55]，包含结尾
# print(lst2[-5:]) #返回[88, 2, 47, 33, 55] 右空即闭
# print(lst2[5:-2]) #返回[9, 88, 2, 47]
# print(lst2[-6:9]) #返回[9, 88, 2, 47]
# print(lst2[:]) #返回全部列表内容
print(lst2[::2]) #步长为2，即隔1位切出1个，效果同lst[0:12:2]，返回[7, 12, 6, 88, 47, 55]
# print(lst2[1:8:2]) #步长为2，在1到8位切片，返回[3, 54, 9, 2]
# print(lst2[::-1]) #步长为负数，就是倒切，返回[55, 33, 47, 2, 88, 9, 6, 54, 12, 3, 7]
# print(lst2[::-2]) #返回[55, 47, 88, 6, 12, 7]

#8.列表元素的增加、删除和修改
# 1.列表元素的修改
lst=['张三',18,[100,90]] # 该列表包含三种类型的元素：字符串，数字，列表
# print(lst) # 返回['张三',18,[100,90]]
lst[0]='小明' # 同类型修改
lst[1]='18岁' # 不同类型修改，数字改为字符
lst[2]=190 # 不同类型修改，列表改为数字
# print(lst) # 返回['小明', '18岁', 190]
lst[0:2]=[100,200] # 实际只修改0和1两个位置上的元素
print(lst)
# 2.列表元素的增加
lst=['张三']
lst +=['6年级']
# print(lst) # 返回['张三', '6年级']
lst.append('9班') # 列表内尾部增加元素
# print(lst) # 返回['张三', '6年级', '9班']
lst.extend([85,96]) # 列表内尾部增加元素
# print(lst) # 返回['张三', '6年级', '9班', 85, 96]
lst.insert(3,'12岁') # 在列表3的位置插入'12岁'
# print(lst) # 返回['张三', '6年级', '9班', '12岁', 85, 96]
# 3.列表元素的删除
lst=['张三', '6年级', '9班', '12岁', 85, 96]
lst.remove('12岁') # 删除'12岁'
print(lst) # 返回['张三', '6年级', '9班', 85, 96]
lst.pop() # 删除列表内尾部元素，相当于-1位置
print(lst) # 返回['张三', '6年级', '9班', 85]
lst.pop(2) # 删除列表内2位置上的元素
print(lst) # 返回['张三', '6年级', 85]
del lst[1:] # 删除列表内1位置起的所有元素。del lst表示删除整个列表
print(lst) # 返回['张三']

#9.列表推导式（列表推导式变异）
lst=[[1,2,3],[10,5,6],[8,5,3],[6,5,4]]
print([l[0]*l[1]*l[2] for l in lst]) # 表达式[l[0]*l[1]*l[2]意思是每次从列表lst里的列表提取的一组数字切片后相乘（见第9行）
print([x*y*z for x,y,z in lst]) # 因列表内的列表包含3个元素，故可以x,y,z表示（见第14行）
# 循环1
lst3=[]
for l in lst:
# lst3 +=[l[0]*l[1]*l[2]]
lst3.append(l[0]*l[1]*l[2]) # 效果与上行同
print(lst3)
# 循环2
lst4=[]
for x,y,z in lst:
lst4 +=[x*y*z]
print(lst4)

#10.列表推导式（嵌套列表推导式）
# 嵌套列表推导式本质上就是 for 嵌套循环的简化，嵌套列表推导式的语法结构：
# ［表达式 for 变量1 in 列表1 for 变量2 in 变量1 for 变量3 in 变量2..…]
# 注意：变量1，变量2，变量3……变量 n ，最后一个变量 n 可以不是可迭代对象。
lst=[[1,2],[3,4,5],[6,7]]
# 简单列表可以直接连接
print([1,2]+[3,4,5]+[6,7]) # 直接连接，返回[1, 2, 3, 4, 5, 6, 7]
print(lst[0]+lst[1]+lst[2]) # 切片后连接，返回[1, 2, 3, 4, 5, 6, 7]
# 采用循环的办法达到上面的效果
lst2=[]
for l in lst:
lst2 +=l
print(lst2) # 返回[1, 2, 3, 4, 5, 6, 7]

# 采用双循环的办法达到上面的效果
lst3=[]
for l in lst: # print(l) 返回[1, 2][3, 4, 5][6, 7]
for v in l: # print(v) 返回1 2 3 4 5 6 7
lst3 +=[v] # print(lst3) 列表内元素逐次增加，打印7次，返回[1]……[1, 2, 3, 4, 5, 6, 7]
# print(lst3) # 列表内元素逐层增加，打印3次，返回[1, 2][1, 2, 3, 4, 5][1, 2, 3, 4, 5, 6, 7]
# lst3.append(v) # 效果与20行同
print(lst3) # 打印1次，返回[1, 2, 3, 4, 5, 6, 7]

# 嵌套列表推导式
print([v for l in lst for v in l])
# 先从lst中循环提取各组元素赋给l，再从l中循环提取各个元素赋给v，最后将v表达出来（置前），整个过程在列表内进行（加[]）。

#11.条件列表推导式的作用就是对列表做筛选，它的语法结构是：
# [表达式 for 变量 in 列表 if 条件判断]
# 1.简单条件列表推导
lst=[85,68,98,74,95,82,93,88,74]
lst1=[n for n in lst if n>=90] # 从lst中循环读取各个元素赋给变量n，如果n大于等于90，则置前显示。
print(lst1) # 返回[98, 95, 93] 效果与8~11行同
lst2=[]
for n in lst:
if n>=90:
lst2.append(n)
print(lst2) # 返回[98, 95, 93]
# 2.多条件列表推导
lst=[[25],[68,43],[120],[14,25],[63,24],[45,12,46]]
print([l for l in lst if sum(l)>=100 and len(l)>=2])
# 从lst中循环读取各个列表赋给变量l，如果l里元素的和大于等于100，且l包含元素的个数大于等于2，则置前显示l。返回[[68, 43], [45, 12, 46]]
# 3.嵌套条件列表推导
print([n for l in lst for n in l if n>=50]) # 返回[68, 120, 63]
# 从lst中循环读取各个列表赋给变量l，又从l中循环读取各个元素赋给变量n，如果n大于等于50.则置前显示n。
print([l for l in lst for n in l if n>=50]) # 返回[[68, 43], [120], [63, 24]]
# 从lst中循环读取各个列表赋给变量l，又从l中循环读取各个元素赋给变量n，如果n大于等于50.则置前显示l（列表）。

#12.列表的转换（转换为列表和列表反转）
# 1.转换为列表
# print(list()) # 返回[]，list()相当于创建空列表
print(list('123'),[n for n in '123']) # 用list转换的列表与for循环形成的列表相同：['1', '2', '3'] ['1', '2', '3']
# print(list((1,2,3))) # 将元组(1,2,3)转换为列表：[1, 2, 3]
# print(list({1,2,3})) # 将集合{1,2,3}转换为列表：[1, 2, 3]
# print(list({'a':1,'b':2,'c':3})) # 将字典转换为列表（只转换键，不转换值）：['a', 'b', 'c']
# print(list(range(1,5))) # range()可迭代对象的转换：[1, 2, 3, 4]
# print([n for n in range(1,5)]) # 在列表内应用列表推导式亦可实现转换：[1, 2, 3, 4]
# num=[]
# for n in range(1,5):
# num.append(n)
# print(num) # 9~12行，应用for循环在空列表依次添加元素，同样可 实现转换：[1, 2, 3, 4]
# 2.列表反转
lst=['a','b','c','d'] # 以[1,2,3,4]为例亦可
# lst.reverse() # 应用反转函数reverse()，最简捷
# print(lst) # 返回['d', 'c', 'b', 'a']
print([lst[n] for n in range(len(lst)-1,-1,-1)]) # 用列表推导式实现反转：['d', 'c', 'b', 'a']
# print(lst[::-1]) # 用切片的方法实现反转：['d', 'c', 'b', 'a']

#13.列表的转换（浅复制与深复制）
# 1.赋值
# lst1=[1,2,3,4]
# lst2=lst1
# print(lst1,lst2) # 返回[1, 2, 3, 4] [1, 2, 3, 4]
# lst1[0]=100 # 把lst1里的1换成100
# print(lst1,lst2) # lst2[0]同样跟着变，返回[100, 2, 3, 4] [100, 2, 3, 4]
# lst2[3]=400 # 把lst2里的4换成400
# print(lst1,lst2) # lst1[3]也跟着变，返回[100, 2, 3, 400] [100, 2, 3, 400]

# 2.浅复制
# lst1=[1,2,3,4]
# lst2=lst1.copy()
# print(lst1,lst2) # 返回[1, 2, 3, 4] [1, 2, 3, 4]
# lst1[0]=100 # 修改lst1
# print(lst1,lst2) #lst2不变，返回[100, 2, 3, 4] [1, 2, 3, 4]
# lst2[3]=400 # 修改lst2
# print(lst1,lst2) #lst1不变，返回[1, 2, 3, 4] [1, 2, 3, 400]
# 特殊情况：
# lst3=[1,[2,3],4] # 列表中包含列表
# lst4=lst3.copy() # 复制时，1,4为不可变对象，可以复制，[2,3]为可变对象，只能是引用
# print(lst3,lst4) # 返回[1, [2, 3], 4] [1, [2, 3], 4]
# lst3[2]=10 # 改变lst3里非列表元素，lst4不变
# print(lst3,lst4) # 返回[1, [2, 3], 10] [1, [2, 3], 4]
# lst3[1][0]=100 # 改变lst3里列表元素，lst4跟着变
# print(lst3,lst4) # 返回 [1, [100, 3], 4] [1, [100, 3], 4]

# 3.深复制
import copy # 导入库
lst3=[1,[2,3],4]
lst4=copy.deepcopy(lst3) # 这种复制是新建内存，lst3与lst4互不影响
print(lst3,lst4) # 返回[1, [2, 3], 4] [1, [2, 3], 4]
# lst3[2]=10
# print(lst3,lst4) # 返回[1, [2, 3], 10] [1, [2, 3], 4]
lst3[1][0]=100
print(lst3,lst4) # 返回[1, [100, 3], 4] [1, [2, 3], 4]

#14.列表常用统计方式
#常见统计操作
lst=[100,99,81,86]
print(len(lst)) # 计数，返回4
print(sum(lst)) # 求和，返回366
print(max(lst)) # 求最大值，返回100
print(min(lst)) # 求最小值，返回81
print(sum(lst)/len(lst)) # 求平均值，返回91.5

#统计指定元素出现的次数
lst=['a','b','c','b','b']
print(lst.count('b')) # 查询'b'在lst中出现的次数，返回3
print(lst.index('b')) # 查询'b'在lst中出现的位置，返回1
print(lst.index('b',2)) #从第2位开始查询'b'在lst中出现的位置，返回3

#15.元组的基本操作（循环与转换）：元组可以像列表一样做元组推导式和for循环
# 1.元组推导式（返回generator<生成器>：按需生成并返回结果）
tup=(1,2,3)
tup1=(t*10 for t in tup)
# print(tup1) # 返回<generator object <genexpr> at 0x0000000001DF7890>
print(list(tup1)) # 用list可将元组转换为列表，返回[10, 20, 30]
# 2.元组的for循环
tup2=()
for t in tup: # 用for循环打印列表
tup2 +=(t*10,)
print(tup2) # 返回(10, 20, 30)
# 3.元组的转换：像使用list类函数可以将可迭代对象转换为列表，对于元组则可以使用tuple类对象将可迭代对象转换为元组。
print(list('123')) # 返回['1', '2', '3']
print(tuple('123')) # 将字符串转换为元组，返回('1', '2', '3')
print(tuple([1,2,3])) # 将列表转换为元组，返回(1, 2, 3)
print(tuple({1,2,3})) # 将集合转换为元组，返回(1, 2, 3)
print(tuple({'a':1,'b':2,'c':3})) # 将字典键转换为元组，返回('a', 'b', 'c')
print(tuple(zip([1,2],[10,20]))) # 将列表迭代器转换为元组，返回((1, 10), (2, 20))
print(tuple(range(1,10))) # 将range()函数生成的整数系列转换为元组，返回(1, 2, 3, 4, 5, 6, 7, 8, 9)

#16.字典的基础操作（字典创建、删除和数据获取）
# 字典的结构：{key键 :value值}，键具有唯一性，须是不可变对象，如字符串、数字或元组；值可以重复，可以是任何可变对象。字典是无序的，只能通过键来存取对应的值。
# 1.字典的创建
# 空字典创建的两种方法
dic1=dict();print(dic1) # 返回{}
dic2={};print(dic2) # 返回{}
# # 非空字典创建的两种方法
dic3=dict(王五=22,麻子=24);print(dic3) # 返回{'王五': 22, '麻子': 24}
dic4={'王五': 22, '麻子': 24};print(dic4) # 返回{'王五': 22, '麻子': 24}
# # 2.字典的删除
# del dic4
# print(dic4) # 打印出错
# 3.字典的数据获取
dic={'张三':18,'李四':20}
# 获取指定键的值
print(dic['李四']) # 返回20
# 获取所有的键
print(dic.keys()) # 返回:dict_keys(['张三', '李四'])
# 获取所有的值
print(dic.values()) # 返回:dict_values([18, 20])
# 获取所有的键和值
print(dic.items()) # 返回:dict_items([('张三', 18), ('李四', 20)])

#18.字典的转换（dict与dict.fromkeys）：将列表、元组等可迭代对象的元素转换为对应的字典
# 1.使用dict类创建转换字典
# 创建字典：
dic1=dict(a=1,b=2);print(dic1) # 返回：{'a': 1, 'b': 2}
# 将元组转换为字典：
dic2=dict((('a','b'),(1,2)));print(dic2) # 返回：{'a': 'b', 1: 2} ，'b'成了值，1成了键
dic2=dict(zip(('a','b'),(1,2)));print(dic2) # 转换前先用zip函数将元组重新组合，返回：{'a': 1, 'b': 2}
# 将列表转换为字典：
dic3=dict([['a',1],('b',2)]);print(dic3) # 返回：{'a': 1, 'b': 2}
# 2.使用dict.fromkeys函数转换为字典
# 将元组转换为字典：
dic1=dict.fromkeys(('a','b'),1);print(dic1) # 返回：{'a': 1, 'b': 1}
# 将列表转换为字典：
dic2=dict.fromkeys(['a','b'],1);print(dic2) # 返回：{'a': 1, 'b': 1}
# 将字符串转换为字典：
dic3=dict.fromkeys('abc',1);print(dic3) # 返回：{'a': 1, 'b': 1, 'c': 1}
# 两种特殊情形：
dic4=dict.fromkeys(['a','a','b']);print(dic4) # 返回：{'a': None, 'b': None} 缺少值
dic5=dict.fromkeys([('a',1),('a',1)]);print(dic5) # 返回：{('a', 1): None} 将相同的('a',1)作为键，缺少值

#19.集合的创建与删除
set1=set();print(set1) #创建空集合，返回：set()
set2={1,2,3};print(set2) #创建有元素的集合，返回：{1, 2, 3}
set3=frozenset(set2);print(set3) #转换为不可变集合，返回：frozenset({1, 2, 3})
del set1 #删除指定的集合
# print(set1) #打印出错
set4={1,89,24,37,89,24};print(set4) #返回：{89, 1, 37, 24}
set5={'张三','李四','王五','张三','刘六'};print(set5) #返回：{'李四', '刘六', '张三', '王五'} （顺序不固定）

#20.集合元素的添加与删除
# 1.集合元素的添加
# set1={1,2,3} # 原集合
# set1.add(4);print(set1) # 向集合中添加单个元素，返回：{1, 2, 3, 4}
# set1.update({5,6,7});print(set1) # 向集合中添加多个元素，返回： {1, 2, 3, 4, 5, 6, 7}
# # update()函数的参数可以是任何可迭代的对象，比如字符串、列表、元组等
# set1.update('dehtfed');print(set1) # 向集合中添加字符串，返回：{1, 2, 3, 4, 5, 6, 7, 'e', 'f', 't', 'h', 'd'}
# set1.update([7,8,9,10]);print(set1) # 向集合中添加列表，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'd', 'f', 'h', 'e', 't'}
# set1.update((12,14,13));print(set1) # 向集合中添加元组，返回：{1, 2, 3, 4, 5, 6, 7, 'f', 8, 9, 10, 12, 13, 14, 't', 'e', 'd', 'h'}
set2={'张三','李四','王五'}
set2.add('张三');print(set2) # 添加已有的字符串，原集合不变，返回：{'李四', '王五', '张三'}
set2.add('刘六');print(set2) # 添加没有的字符串，原集合元素增加，返回：{'王五', '刘六', '张三', '李四'}
# 2.集合元素的删除
set1={'a','b','c','d'};print(set1) # 原集合;返回：{'c', 'b', 'd', 'a'}
set1.remove('a');print(set1) # 删除集合中的元素“a”，返回：{'c', 'b', 'd'}
set1.discard('b');print(set1) # 删除集合中的元素“b”，返回：{'c', 'd'}
set1.pop();print(set1) # 随机删除集合中的一个元素，返回：{'d'}
set1.clear();print(set1) # 清空集合中的所有元素，返回：set()

#21.集合的运算（并集、交集）
# 1.并集运算
# set1={1,2,3,4,5,6}
# set2={4,5,6,7,8,9}
# print(set1.union(set2)) # 将集合1与集合2作并集运算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# print(set2.union(set1)) # 将集合2与集合1作并集运算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# print(set1|set2) # 将集合1与集合2作并集运算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# print(set2|set1) # 将集合2与集合1作并集运算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# 2.交集运算
set1={1,2,3,4,5,6}
set2={4,5,6,7,8,9}
# set3=set1.intersection(set2) # 求集合1与集合2的交集，将结果存储在集合3中
# print(set3) # 返回：{4, 5, 6}
# set3=set2.intersection(set1) # 求集合2与集合1的交集，将结果存储在集合3中
# print(set3) # 返回：{4, 5, 6}
# set3=set1&set2 # 求集合1与集合2的交集，将结果存储在集合3中
# print(set3) # 返回：{4, 5, 6}
# set3=set2&set1 # 求集合2与集合1的交集，将结果存储在集合3中
# print(set3) # 返回：{4, 5, 6}

# 两个集合作交集运算,结果存入新集合中，可用 ③=①.intersection(②)
# 两个集合作交集运算,结果存入其中一个集合①中，可用 ①.intersection_update(②)
print(set1) # 集合1返回：{1, 2, 3, 4, 5, 6}
set1.intersection_update(set2) # 集合1与集合2作交集运算，结果存入集合1
print(set1) # 集合1返回：{4, 5, 6}
print(set2) # 集合2返回：{4, 5, 6, 7, 8, 9}
set2.intersection_update(set1) # 集合2与集合1作交集运算，结果存入集合2
print(set2) # 集合2返回：{4, 5, 6}

#22.集合的运算（差集与对称差集）
# 1.差集运算
# set1={1,2,3,4,5,6} # 集合1
# set2={4,5,6,7,8,9} # 集合2
# set3=set1.difference(set2);print(set3) # 集合1减去集合2，将结果存储在新集合3中，返回：{1, 2, 3}
# set3=set2.difference(set1);print(set3) # 集合2减去集合1，将结果存储在新集合3中，返回：{8, 9, 7}
# set3=set1-set2;print(set3) # 与5行同，返回：{1, 2, 3}
# set3=set2-set1;print(set3) # 与6行同，返回：{8, 9, 7}
# set1.difference_update(set2);print(set1) # 集合1减去集合2，将结果存储在集合1中，返回：{1, 2, 3}
# set2.difference_update(set1);print(set2) # 集合2减去集合1，将结果存储在集合2中，返回：{7, 8, 9}

# 2.对称差集运算
set1={1,2,3,4,5,6}
set2={4,5,6,7,8,9}
# set=set1|set2;print(set) # 与下行对照，这是并集运算结果，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9} (重复者4,5,6都保留一个)
set3=set1.symmetric_difference(set2);print(set3) # 这是对称差集运算结果，返回：{1, 2, 3, 7, 8, 9} (重复者4,5,6都不保留)
# 去掉集合1与集合2中相同的元素，将结果存储在新集合3中。
set3=set2.symmetric_difference(set1);print(set3) # 去掉集合2与集合1中相同的元素，将结果存储在新集合3中。返回：{1, 2, 3, 7, 8, 9}
set3=set1^set2;print(set3) # 与16行同
set3=set2^set1;print(set3) # 与18行同
# set1.symmetric_difference_update(set2);print(set1) # 去掉集合1与集合2中相同的元素，将结果存储集合1中。返回：{1, 2, 3, 7, 8, 9}
set2.symmetric_difference_update(set1);print(set2) # 去掉集合2与集合1中相同的元素，将结果存储集合2中。返回：{1, 2, 3, 7, 8, 9}
# 试行归纳如下：
# seta=set1|set2;print(seta) # 并集运算，返回： {1, 2, 3, 4, 5, 6, 7, 8, 9}
# setb=set1&set2;print(setb) # 交集运算，返回： {4, 5, 6}
# setc=seta-setb;print(setc) # 差集运算，返回： {1, 2, 3, 7, 8, 9}
# setd=seta^setb;print(setd) # 对称差集运算,返回:{1, 2, 3, 7, 8, 9}
# 由此看出，两个集合的对称差集运算结果，实际上就是两个集合的并集减去两个集合的交集所得的差。

#23.集合的运算（集合运算小结）
# 集合运算 运算结果生成新集合 运算结果存储在原集合
# 方式 函数方法 符号方法 函数方法
# 并集 set1.union(set2) set1|set2 —
# 交集 set1.intersection(set2) set1&set2 set1.intersection_update(set2)
# 差集 set1.difference(set2) set1-set2 set1.difference_update(set2)
# 对称差集 set1.symmetric_difference(set2) set1^set2 set1.symmetric_difference_update(set2)
set1={1,2,3,4,5,6} # 集合1
set2={4,5,6,7,8,9} # 集合2
lst=[4,5,6,7,8,9] # 列表
print(set1.union(set2)) # 用函数方法进行集合1与集合2的并集运算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
print(set1|set2) # 用符号方法进行集合1与集合2的并集运算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
print(set1.union(range(5,15))) # 用函数方法进行集合1与整数系列的并集运算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
print(set1.union(lst)) # 用函数方法进行集合1与列表的并集运算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# print(set1|lst) # 用符号方法进行集合1与列表的并集运算，程序报错！
# 所以，用函数方法进行集合运算，函数的参数不一定是集合类型，只要是可迭代的对象即可；
# 而使用符号方法，符号两侧必须是集合类型，否则会出错。

# 从上面的小结中可以看出，在并集运算中，没有运算结果存储在原集合的函数方法，但可以通过集合的update函数来实现，相当于向指定的集合添加元素。
set1={1,2,3,4,5,6}
set2={4,5,6,7,8,9}
set2.update('addfa') # 集合2与字符串的并集运算，实际向集合2添加a、d、f三个元素（去除重复的a、d）
print(set2) # 返回：{4, 5, 6, 7, 8, 9, 'd', 'f', 'a'}

#24.去重示例(输入人名每行不超过170人)
# encoding:utf-8
a1=['张老三','刘老四','陈 五','周九弟','吴小十','杨六郎','黄七哥','赵八爷']
a2=['王老大','李老二','张老三','黄七哥','赵八爷','周九弟','陈 五','杨六郎','吴小十']
a3=['刘老四','黄七哥','赵八爷','周九弟']
b=set(a1)|set(a2)|set(a3)
chang=len(a1)+len(a2)+len(a3)
print('原列表人数分别是：'+str(len(a1))+'、'+str(len(a2))+'、'+str(len(a3))+'，共'+str(chang)+'人。')
print('去除重复姓名后人数是{}人。名单如下：'.format(len(b)))
print('，'.join(b))

#25.集合的运算（集合运算小结）
# 集合运算 运算结果生成新集合 运算结果存储在原集合
# 方式 函数方法 符号方法 函数方法
# 并集 set1.union(set2) set1|set2 —
# 交集 set1.intersection(set2) set1&set2 set1.intersection_update(set2)
# 差集 set1.difference(set2) set1-set2 set1.difference_update(set2)
# 对称差集 set1.symmetric_difference(set2) set1^set2 set1.symmetric_difference_update(set2)
set1={1,2,3,4,5,6} # 集合1
set2={4,5,6,7,8,9} # 集合2
lst=[4,5,6,7,8,9] # 列表
print(set1.union(set2)) # 用函数方法进行集合1与集合2的并集运算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
print(set1|set2) # 用符号方法进行集合1与集合2的并集运算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
print(set1.union(range(5,15))) # 用函数方法进行集合1与整数系列的并集运算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
print(set1.union(lst)) # 用函数方法进行集合1与列表的并集运算，返回：{1, 2, 3, 4, 5, 6, 7, 8, 9}
# print(set1|lst) # 用符号方法进行集合1与列表的并集运算，程序报错！
# 所以，用函数方法进行集合运算，函数的参数不一定是集合类型，只要是可迭代的对象即可；
# 而使用符号方法，符号两侧必须是集合类型，否则会出错。

# 从上面的小结中可以看出，在并集运算中，没有运算结果存储在原集合的函数方法，但可以通过集合的update函数来实现，相当于向指定的集合添加元素。
set1={1,2,3,4,5,6}
set2={4,5,6,7,8,9}
set2.update('addfa') # 集合2与字符串的并集运算，实际向集合2添加a、d、f三个元素（去除重复的a、d）
print(set2) # 返回：{4, 5, 6, 7, 8, 9, 'd', 'f', 'a'}

#26.自定义函数编写规范（函数定义与创建）
# 自定义函数的格式
# def 函数名(参数):
# 函数体
# return 返回值
# 1.有返回值的自定义函数
def total_sum1(price,amount): # 这时的参数称为形参（单价，数量）
money=price*amount # 金额=单价×数量
return money # 返回 金额
# 2.无返回值的自定义函数
def total_sum2(price,amount):
str='单价:{} 数量:{} 金额:{}'.format(price,amount,price*amount) # 将单价、数量、金额进行格式化处理，然后赋值给变量str
print(str) # 输出str

print(total_sum1(15,10)) # 返回:150
total_sum2(10,20) # 返回:单价:10 数量:20 金额:200

#27.必选参数的写法及应用（案例-位置参数）
# 判断分数等级的自定义函数
def level(number,lv1,lv2,lv3): # 函数名level，4个必选参数：分数number、等级lv1、lv2、lv3
if number>=90: # 当分数大于或等于90分时
return lv1 # 返回等级lv1
elif number>=60: # 当分数大于或等于60分且小于90分时
return lv2 # 返回等级lv2
elif number>=0: # 当分数大于或等于0分且小于60分时
return lv3 # 返回等级lv3
# 自定义函数的调用
# print(level(59,'上','中','下')) # 返回：下
for score in [95,63,58,69,41,88,96]: # 将列表中的元素循环赋值给变量score
print(score,level(score,'优','中','差')) # 将score,'优','中','差'作为自定义函数level的4个参数，运行函数后打印分数和结果
# 分行返回：95 优 63 中 58 差 69 中 41 差 88 中 96 优
# 也可以用列表推导式把判断结果在一行中表达出来
print([level(score,'优','中','差') for score in [95,63,58,69,41,88,96]]) # 返回等级：
# ['优', '中', '差', '中', '差', '中', '优']
print([(score,level(score,'优','中','差')) for score in [95,63,58,69,41,88,96]]) # 返回分数与等级：
# [(95, '优'), (63, '中'), (58, '差'), (69, '中'), (41, '差'), (88, '中'), (96, '优')]

#28.必选参数的写法及应用
# 给号码分段的自定义函数
def intercept(s,num,delimiter): # 函数名：截取，参数：号码、每段长度、分隔符
s1 = str(s) # 将分段对象转换为字符串类型
lst = [s1[n:n + num] for n in range(0, len(s1), num)] # 仿照7行对数据进行分段处理
s2=delimiter.join(lst) # 合并分段的列表
return s2 # 返回合并结果
s='25364789551678957843529'
print(intercept(s,4,'-'))

#29.可选参数的写法及应用（默认参数）
# iterable:必选参数，可切片的对象，如字符串、列表、元组
# start:可选参数，切片的起始位置，默认值为0
# lenght:可选参数，切片的长度，默认值为1
def mid(iterable,start=0,lenght=1):
return iterable[start:start+lenght] # 返回切片结果（从开始位置到开始位置加切片长度）

print(mid('abcdefgh')) # 返回：a
print(mid('abcdefgh',2)) # 返回：c
print(mid('abcdefgh',2,4)) # 返回：cdef

print(mid([32,35,56,2,75,234,65])) # 返回：[32]
print(mid([32,35,56,2,75,234,65],3,2)) # 返回：[2, 75]