#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.字符串切片（根据身份证号划分年龄段）
#根据身份证号划分年龄段(高龄组：70岁及以上；老龄组：65~69岁；老年组：60~64岁；成年组：60岁以下)
dic=dict(
    张三=340828195512240114,
    李四='34082819640425011x',
    王老五=340828195305012610,
    刘老六=340828195208091919,
    陈小七=340828196811080127
)
# print(dic.items()) # 上行单名里的空格必须删去
dic0 = {name: str(num)[6:14] for name,num in dic.items()} # 如果身份证号码前后都用单引号，则此行str()可去掉
# print(dic0) # 身份证号码截取出生年月日
dic1 = dict(sorted(dic0.items(), key=lambda x: x[1]))
# print(dic1) # 出生年月日按升序排列
from datetime import datetime
# now=datetime.now()
year=datetime.now().year
month=datetime.now().month
day=datetime.now().day
print('当前日期：{}年{}月{}日'.format(year,month,day))  #当前年、月、日
print('----------------')
def pdnianling(year,month,day,nian,yue,ri):
    nl=year-nian
    if (month<yue) or (month==yue and day<ri):
        nl -= 1
    return nl
m=0;n=0;j=0;k=0;q=0
for name,num in dic1.items():
    nian = int(str(num)[0:4])  # 提取居民出生年份
    yue = int(str(num)[4:6])  # 提取居民出生年份
    ri = int(str(num)[6:8])  # 提取居民出生年份
    # print(nian,yue,ri)
    nl=pdnianling(year,month,day,nian,yue,ri)
    m = m + 1
    if nl>=70:
        n=n+1
        if n>1:
            print('{:>18} {}'.format(name, nl))  # web用>18,终端用>10
        else:
            print('高龄组：{} {}'.format(name, nl))
    elif int(nl)>= 65:
        j=j+1
        if j>1:
            print('{:>18} {}'.format(name, nl))
        else:
            print('老龄组：{} {}'.format(name, nl))
    elif int(nl)>= 60:
        k=k+1
        if k>1:
            print('{:>18} {}'.format(name, nl))
        else:
            print('老年组：{} {}'.format(name, nl))
    else:
        q=q+1
        if q>1:
            print('{:>18} {}'.format(name, nl))
        else:
            print('成年组：{} {}'.format(name, nl))
print('----------------')
print('本次统计共'+str(m)+'人，其中：\n①高龄组(>=70)'+str(n)+'人，②老龄组(>=65,<70)'+str(j)+'人，\n③老年组(>=60,<65)'+str(k)+'人，④成年组(<60)'+str(q)+'人。')

#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)

#17.字典键值的修改、增加和删除
# 1.字典键值的增加
dic={}
# 向空字典里添加键值的两种方法（update是更新、修改的意思，如果修改的键值原来不存在，就相当于增加）
dic.update(李四=88);print(dic) # 返回{'李四': 88}
dic.update({'麻子':96});print(dic) # 返回{'李四': 88, '麻子': 96}
dic.update(李四=102);print(dic) # 修改李四的值，返回{'李四': 102, '麻子': 96}
# 2.字典键值的删除
dic={'张三':84,'李四':88,'王二':79,'麻子':99}
print(dic) # 打印{'张三': 84, '李四': 88, '王二': 79, '麻子': 99}
dic.pop('张三');print(dic) # 删除张三的键值，返回{'李四': 88, '王二': 79, '麻子': 99}
# dic.clear();print(dic) # 清空所有键值，返回{}
# del dic;print(dic) # 删除整个字典，打印字典出错
# 3.字典键值的修改
dic1={'张三':20,'李四':18,'麻子':35}
# 修改指定键的值
dic1['张三']=100;print(dic1) # 返回{'张三': 100, '李四': 18, '麻子': 35}
# 修改指定键（先删后加）
# print(dic1.pop('李四')) # 删除李四这个键，但保留其值，返回18
dic1['王五']=dic1.pop('李四');print(dic1) # '李四'改为'王五'，值不变。返回{'张三': 100, '麻子': 35, '王五': 18}

#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]

#30.字符替换（单个字符与多个字符）
# 1.单个字符替换
str='三国演义，西游记、水浒，红楼梦'
print(str.replace('，','|')) # 返回：三国演义|西游记、水浒|红楼梦

# 2.多个字符替换(建立并应用自定义增强版替换函数)
def replaces(string,new,*old):  # 替换函数（原字符串，要替换的新字符，被替换的旧字符（可以指定多个）
    for i in old:  # 循环提取各个旧字符赋给变量i
        string=string.replace(i,new) # 将i的值替换为new的值，再赋给string参数
    return string # 返回替换后的值给函数
print('《'+replaces(str,'》《','，','、','|')+'》') # 返回：《三国演义》《西游记》《水浒》《红楼梦》