#数组、元组、字典
#一维列表的申明以及访问
#创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
# list1 = ['亢龙有悔', '见龙在田', 2020, 2028] #不同数据类型混合
# list2 = [1, 2, 3, 4, 5 ] #单纯的整数列表
# list3 = ["甜老丝", "天轰穿", "老田", "小甜"] #纯字符串列表
#访问的方式，可以直接指向列表的位置（索引、下标）
# print('直接顺序访问下标:',list1[2],list1[3]) #直接访问下标
# print('直接倒序访问下标:',list1[-1],list1[-2]) #读取list1的倒数第一项和倒数第二项
#print('直接顺序访问1:3:',list3[1:3]) #访问下标的一个范围
#print('从第零项开始读取到第二项(实际是第三项):',list2[:2]) #从第零项开始读取到第二项(实际是第三项)
# print('从第二项（实际是第三项）开始读取后面的全部:',list2[2:]) #从第二项（实际是第三项）开始读取后面的全部
#print('直接读取一个列表的全部:',list2) #直接读取一个列表的全部
# #修改列表中的值
# list1 = ['亢龙有悔', '见龙在田', 2020, 2028]
# list1[2]='潜龙勿用' #修改下标为2，也就是第三项的值为 潜龙勿用
# list1.append('双龙取水') #在列表后面新增一项 “双龙取水”
# for i in range(len(list1)):
# print(list1[i],end='-') #来个end，很重要，但以前没专门讲
# #破坏性修改---删除列表项
# list4 = ["甜老丝", "天轰穿", "老田", "小甜"]
# print(list4)
# del list4[2]
# print('删除第二项，看看第二项是没有了，或者只是数值空了呢')
# print(list4)
#Python列表脚本操作符
#列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
# l1=[1,2,3] #名字是 12 还是小写的 L 2 呢？ 为什么
# l2=[6,7,8]
# l3=l1+l2 #两个列表组合，相加
# print(l3)
# l4=[8,1]*6 #重复 6 次
# print(l4)
# #判断某个元素是否在列表中,
# print(3 in [1,2,3]) #哦，这个就是只在内存中开辟了空间，但并没有给变量
# #当然也可以正常点，例如
# list66=[1,2,3]
# tf=3 in list66
# print(tf)
#列表函数&方法，都说了，他们没啥区别，唯一的区别是
'''
函数的用法是
函数名字(对象)
方法的用法是
对象.方法名（参数）
'''
# 对列表进行常见统计算法
# import operator
# list11=[0,1,2,3,4,5,6,7,8,9,9.25,9.50,9.75]
# list22=[0,1,2,3,4,5,6,7,8,9,9.25]
# print(operator.eq(list11,list22)) #对比两个列表是否相同
#给你个作业，看看这两个列表变量与内存空间的关系，还记得那个叫 is 的菇娘么
# #获取最大的
# list11=[0,1,2,3,4,5,6,7,8,9,9.25,9.50,9.75]
# list22=['a','b','c','d','e','f','g']
# print('list11 最大的值是：',max(list11))
# print('list22 最大的值是：',max(list22))
# #
# print('list11 最小的值是：',min(list11))
# print('list22 最小的值是：',min(list22))
#获取列表的长度
# list11=[0,1,2,3,4,5,6,7,8,9,9.25,9.50,9.75]
# print(len(list11))
#将元组转换为列表(把申明列表的中括号换成小括号，就是申明元组)
# yuanzu=(0,1,2,3,4,5,6,7,8,9,9.25,9.50,9.75)
# list11=list(yuanzu)
# print(list11)
############下面开始用方法############
# list11=[0,1,2,3,4,5,6,7,8,9,9,9,9.25,9.50,9.75]
# print(list11.count(9))
#找到某个元素在列表中的某个地方
# list11=[0,0.2,0.4,1,2,3,4,5,6,7,8,9,9,9,9.25,9.50,9.75]
# print(list11.index(3))
#对列表进行排序
# list11=[2,5,8,3,4,1,6,7,4]
# list11.sort(reverse=False) #排序 倒序reverse=True 顺序reverse=False
# print(list11)
#对列表的项进行 反向排序，什么是反向排序，就是把你头朝下，脚朝上提起来
# list11=[2,5,8,3,4,1,6,7,4]
# list11.reverse()
# print(list11)
#多维列表排序
#二维列表示例一
# rd = [[2, 2], [3, 4], [4, 1], [1, 3]] #申明一个多维列表，为什么是多维呢？因为每一个数据里面又有两个数
# print(rd[3][0]) #访问多维列表
#二维列表示例二
rd1=[['洪武年间','2473万石','471万石','1000万两'],['正德初年','2216万石','462万石','1100万两'],['嘉靖后期','1822万石','462万石','1320万两']]
# for x in rd1:
# print(x) #这里为什么直接是访问的x，而不是 呢？
#如果要显示里面再具体的项，应该咋做呢？
# for x in rd1:
# for y in x:
# print(y,end=' -- ')
# print('\n')
#三维列表
# rd2=[[[2,1], [3,4]], [[3, 4],[8,7]], [[4, 1,[9,7]]], [[1, 3],[5,1]],[[5,6],[9,8]]]
# print(rd2[1][1][1])
#来个作业，写一个三层for循环嵌套的，读取上面这个列表
# 申明一个方法，用于获取传入参数这个列表的第一个元素
# def GetOne(elem): #申明一个方法，名字是GetOne，需要一个参数
# return elem[0]
#
# # 列表，列表中每一个项是一个元组，每一个元组两个项
# random = [[8, 2], [6, 4], [4, 1], [6, 3]]
#
# # 指定每一项里面的第一个元素排序
# random.sort(key=GetOne)
#
# # 输出排序之后的效果
# print('排序列表：', random)
# 元组 Python 的元组与列表类似，不同之处在于元组的元素不能修改。
# 元组使用小括号，列表使用方括号。
# 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
# tuple1=(2,5,8,3,4,1,6,7,4) #创建一个元组
# tp2=() #创建一个空的元组，为什么会有这个需求呢，主要是在日常运算中，有可能一个元组类型的参数，但你实际没数据可给，那就给个空的
# #为什么有此一问，对列表就没有这个问题呢，因为元组一旦申明，不可改变，但列表可以随便更改，所以就好奇了
# tp3=(50) #申明一个元组，只有一个值，这个时候，他不是一个元组，他是一个 整形（int），如何才能是只有一个数字的元组呢？
# tp4=(50,) #结尾加个逗号就行了
#
# #访问元组，和列表一样
# print(tuple1)
# print(tuple1[1])
# print(tuple1[2:5])
# print(tuple1[:3])
# print(tuple1[2:])
#修改元组
#都说，元组和列表最大的区别是，不能修改，不可变类型，懂？？？
#不死心的试试，老夫就是传说中的“不见棺材不落泪”
# tu5=("甜老丝", "天轰穿", "老田", "小甜")
# #改里面的值
# tu5[2]='大田'
# #增项
# tu5.append('甜到腻歪')
# #减项
# del tu5[2]
# #正确的修改元组的方法,我信你个鬼，这个根本就不是改变
# tup1 = (12, 34.56)
# tup2 = ('abc', 'xyz')
# # 创建一个新的元组
# tup3 = tup1 + tup2
# print(tup3)
#
# 删除元组
# 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
# tup = ('abc', 'xyz')
# print(tup)
# del tup
# print("删除后的元组 tup : ")
# print(tup)
#将元组转换为列表
# list1 = ['亢龙有悔', '见龙在田', 2020, 2028]
# print(type(list1)) #查看这个变量的类型
# print(list1)
# tup6=tuple(list1) #将list1转化为tuple，并教给新的变量tup6
# print(type(tup6))
# print(tup6)
#所以，如果你一定要修改元组，那么最简单的办法
#第一步：把要修改的元组转换为列表
#第二步：修改这个列表
#第三步：把修改后的列表转换为新的元组
#但是，你这么无聊搞一大堆，目的是什么呢？？
#要你管，反正有用就行了呗
# #自定义画玫瑰花或者多边形
# color=('red','blue','yellow','purple','green','black','pink','coral')
# import turtle
# number=int(input('请输入多边形的边数或者玫瑰花的瓣数：\n'))
# shape=input('请选择画多边形还是圆形，圆形=r,其他的你高兴就好：\n')
# turtle.pensize(10)
# turtle.speed(100) #设置画笔移动速度,画笔绘制的速度范围[0,10]整数,数字越大越快,其实还可以更大，比如100
#
# for x in range(number): #有多少条边就循环多少次
# if x<len(color):
# turtle.pencolor(color[x])
#
# if shape=='r': #如果是画圆
# for i in range(100):
# turtle.circle(i) #那就设定半径为100的圆
# else: #如果不是圆
# turtle.forward(150) #单边长150
#
# turtle.left(360/number) #转向，为什么是转360除边呢？当然是计算角度嘛，最终只要360度就封口了
# print('打完收工')
# turtle.mainloop()
#++++++++++++++++++集合（Set）++++++++++++++++++
#申明一个集合
s={'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
s1={1,2,3,4,5,6,7,8}
#或者
s2=set('甜老丝儿的python很流弊哦')
#注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
s2={} #错误的，因为这样创建的不是集合，而是 空字典
s3=set() #这才是对的，嘿嘿哈哈哈哈哈哈
#访问集合
#print(s[1]) #哈哈，你是来搞笑的么，都说了集合是没有索引的
#迭代访问集合
# s6={'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
# s8=set('甜老丝儿的python很流弊哦')
# for x in s8:
# print(x)
#集合是不重复的，凡是重复的，都拖出去剁吧剁吧
# s4={1,1,2,2,3,3,3}
# print(s4) #被去重了
# #其他类型转换为集合
# l = [1.23, "a"] # 列表类型
# d = {1: "a", 2: "b"} # 字典类型
# a = (1, 2, "b") # 元组类型
# s = "厉害了，我的国" # 字符串
#
# # 将列表，字典，元组，字符串转化为集合
# s2 = set(s)
# s3 = set(l)
# s4 = set(d)
# s5 = set(a)
#
# print(s2)
# print(s3)
# print(s4)
# print(s5)
#补充一句：要删除列表、元素中重复的项，转换成集合，再转回去，快得一笔
#为什么要说快呢，计算机再计算的时候是要花时间的，虽然算个 1+1 确实很快，但要算10000000000000000000000000000000000次呢？
#而程序里面几乎每一步要需要很多步骤的计算，只不过很多很基本的计算是计算机底层去做了，我们编程看不到而已，包括你看到的这句话
# #修改集合---------添加元素
# s1 = {1.23, "a"}
# s1.add('c') #向集合添加一个元素，对，一次只能一个，比如字符串
# s1.add(88) #也可以添加一个整数
# print(s1)
#能不能添加一个list、元组、集合、字典进去呢？
# s1 = {1.23, "a"}
# list1=[11,22,33] #造一个列表
#
#
# s1.update(list1) #把列表加到集合s1里面去
# s1.update('甜老丝') #把字符串加到列表里面去
# print(s1)
# s1 = {1.23, "a"}
# tu1=('AA','BB') #造一个元组
# #s1.update(332) #把整数加到列表里面去，不行，有add（）你不用，给你个错误镇压
# s1.update((332,)) #你要实在想加，那就酱紫也行，不过，你这是图什么呢？
# s1.update([99,88],[77,66,55],tu1,'字符串') #把列表、元组、字符串混合加到集合中
# print(s1)
# #删除元素
# s3={'aa','bb',888,(11,22)} #申明一个集合来玩儿
# print('删除前：',s3) #这里的链接符号用 + 号要出错，思考下是为虾米
# # #删除前先判断，否则会出错，你试试看错误信息是什么？ 注意：快速看懂错误信息也是一个非常主要的能力
# if 'aa' in s3:
# s3.remove('aa')
# print('删除后：',s3)
# #
#还有一个方法，移除不存在的元素，不会出错
# s4={'aa','bb',888,(11,22)} #申明一个集合来玩儿
# s4.discard('cc')
#最无聊的删除---随机删除一个元素
# s5={'aa','bb',888,666,999,'cc',(11,22)} #申明一个集合来玩儿
# s5.pop()
# s5.pop()
# s5.pop()
# print('删除后：',s5)
# #最狠的删除---清空
# s6={'aa','bb',888,666,999,'cc',(11,22)} #申明一个集合来玩儿
# s6.clear()
# print('删除后：',s6)
# #python集合的运算：事实上，之所以必须讲，倒不是在初级的时候有多重要，主要是NOIP里面也要考这个点，所以早点交给大家
# a = set('abcde')
# b = set('cdefg')
#
# #∪ （并集）
# print('∪ （并集）',a | b) # 集合a或b中包含的所有元素
# print('用方法得到并集：',a.union(b))
# # ∩ （交集）
# print('∩ （交集）',a & b) # 集合a和b中都包含了的元素
# print('用方法得到交集：',a.intersection(b))
# # \ （差集）
# print('\ （差集）',a - b) # 集合a中包含而集合b中不包含的元素
# print('用方法得到差集：',a.difference(b))
#
# # △ （对称集）
# print('△ （对称集）',a ^ b) # 不同时包含于a和b的元素
# print('用方法得到对称集：',a.symmetric_difference(b))
# #++++++++++++++++Dictionary（字典）++++++++++++++++++++++
# #申明方式一
# dt = {'A': '2341', 'B': '9102', 'C': '3258'}
# #申明方式二
# dt1 = { 'a': 456 }
# dt2 = { 'abc': 123, 1: 37 }
#
# #通过key进行访问
# dt3 = {'A': '2341', 'B': '9102', 'C': '3258',168:(66,99)}
# print(dt3)
# print(dt3['A'])
# print(dt3[168][1])
#
# #如果字典里没有的键值对，就会报错
# print('给劳资来一个大写的 服 ',dt3['服不服'])
#迭代访问
# dt4 = {'A': '2341', 'B': '9102', 'C': '3258',168:(66,99)}
# for x in dt4:
# print('key是：',x)
# print('value是：',dt4[x])
#修改字典---添加键值对
# dt1 = {12:'A',13:'B',16:'E'}
# dt1[14]='C' #添加项
# dt1[15]='D'
# print(dt1)
# #----删除字典元素
dt1 = {12:'A',13:'B',16:'E'}
# del dt1[13] #删除键为13的这个项
# print(dt1)
#
# dt1.clear() #删光，一个不留
# print(dt1)
# #
# del dt1 #删除这个字典
# print(dt1)
#补充说明
#字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
#不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，比如
# dt6={1:'甜老丝',1:'老田'}
# print(dt6[1])
#键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
# dict = {['Name']: '甜老丝', 'Age': 18}
# print("dict['Name']: ", dict['Name'])
#不过除非轰了，为什么一定要用列表、元组来做键呢？不服，你试试呗
#一维列表的申明以及访问
#创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
# list1 = ['亢龙有悔', '见龙在田', 2020, 2028] #不同数据类型混合
# list2 = [1, 2, 3, 4, 5 ] #单纯的整数列表
# list3 = ["甜老丝", "天轰穿", "老田", "小甜"] #纯字符串列表
#访问的方式，可以直接指向列表的位置（索引、下标）
# print('直接顺序访问下标:',list1[2],list1[3]) #直接访问下标
# print('直接倒序访问下标:',list1[-1],list1[-2]) #读取list1的倒数第一项和倒数第二项
#print('直接顺序访问1:3:',list3[1:3]) #访问下标的一个范围
#print('从第零项开始读取到第二项(实际是第三项):',list2[:2]) #从第零项开始读取到第二项(实际是第三项)
# print('从第二项（实际是第三项）开始读取后面的全部:',list2[2:]) #从第二项（实际是第三项）开始读取后面的全部
#print('直接读取一个列表的全部:',list2) #直接读取一个列表的全部
# #修改列表中的值
# list1 = ['亢龙有悔', '见龙在田', 2020, 2028]
# list1[2]='潜龙勿用' #修改下标为2，也就是第三项的值为 潜龙勿用
# list1.append('双龙取水') #在列表后面新增一项 “双龙取水”
# for i in range(len(list1)):
# print(list1[i],end='-') #来个end，很重要，但以前没专门讲
# #破坏性修改---删除列表项
# list4 = ["甜老丝", "天轰穿", "老田", "小甜"]
# print(list4)
# del list4[2]
# print('删除第二项，看看第二项是没有了，或者只是数值空了呢')
# print(list4)
#Python列表脚本操作符
#列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
# l1=[1,2,3] #名字是 12 还是小写的 L 2 呢？ 为什么
# l2=[6,7,8]
# l3=l1+l2 #两个列表组合，相加
# print(l3)
# l4=[8,1]*6 #重复 6 次
# print(l4)
# #判断某个元素是否在列表中,
# print(3 in [1,2,3]) #哦，这个就是只在内存中开辟了空间，但并没有给变量
# #当然也可以正常点，例如
# list66=[1,2,3]
# tf=3 in list66
# print(tf)
#列表函数&方法，都说了，他们没啥区别，唯一的区别是
'''
函数的用法是
函数名字(对象)
方法的用法是
对象.方法名（参数）
'''
# 对列表进行常见统计算法
# import operator
# list11=[0,1,2,3,4,5,6,7,8,9,9.25,9.50,9.75]
# list22=[0,1,2,3,4,5,6,7,8,9,9.25]
# print(operator.eq(list11,list22)) #对比两个列表是否相同
#给你个作业，看看这两个列表变量与内存空间的关系，还记得那个叫 is 的菇娘么
# #获取最大的
# list11=[0,1,2,3,4,5,6,7,8,9,9.25,9.50,9.75]
# list22=['a','b','c','d','e','f','g']
# print('list11 最大的值是：',max(list11))
# print('list22 最大的值是：',max(list22))
# #
# print('list11 最小的值是：',min(list11))
# print('list22 最小的值是：',min(list22))
#获取列表的长度
# list11=[0,1,2,3,4,5,6,7,8,9,9.25,9.50,9.75]
# print(len(list11))
#将元组转换为列表(把申明列表的中括号换成小括号，就是申明元组)
# yuanzu=(0,1,2,3,4,5,6,7,8,9,9.25,9.50,9.75)
# list11=list(yuanzu)
# print(list11)
############下面开始用方法############
# list11=[0,1,2,3,4,5,6,7,8,9,9,9,9.25,9.50,9.75]
# print(list11.count(9))
#找到某个元素在列表中的某个地方
# list11=[0,0.2,0.4,1,2,3,4,5,6,7,8,9,9,9,9.25,9.50,9.75]
# print(list11.index(3))
#对列表进行排序
# list11=[2,5,8,3,4,1,6,7,4]
# list11.sort(reverse=False) #排序 倒序reverse=True 顺序reverse=False
# print(list11)
#对列表的项进行 反向排序，什么是反向排序，就是把你头朝下，脚朝上提起来
# list11=[2,5,8,3,4,1,6,7,4]
# list11.reverse()
# print(list11)
#多维列表排序
#二维列表示例一
# rd = [[2, 2], [3, 4], [4, 1], [1, 3]] #申明一个多维列表，为什么是多维呢？因为每一个数据里面又有两个数
# print(rd[3][0]) #访问多维列表
#二维列表示例二
rd1=[['洪武年间','2473万石','471万石','1000万两'],['正德初年','2216万石','462万石','1100万两'],['嘉靖后期','1822万石','462万石','1320万两']]
# for x in rd1:
# print(x) #这里为什么直接是访问的x，而不是 呢？
#如果要显示里面再具体的项，应该咋做呢？
# for x in rd1:
# for y in x:
# print(y,end=' -- ')
# print('\n')
#三维列表
# rd2=[[[2,1], [3,4]], [[3, 4],[8,7]], [[4, 1,[9,7]]], [[1, 3],[5,1]],[[5,6],[9,8]]]
# print(rd2[1][1][1])
#来个作业，写一个三层for循环嵌套的，读取上面这个列表
# 申明一个方法，用于获取传入参数这个列表的第一个元素
# def GetOne(elem): #申明一个方法，名字是GetOne，需要一个参数
# return elem[0]
#
# # 列表，列表中每一个项是一个元组，每一个元组两个项
# random = [[8, 2], [6, 4], [4, 1], [6, 3]]
#
# # 指定每一项里面的第一个元素排序
# random.sort(key=GetOne)
#
# # 输出排序之后的效果
# print('排序列表：', random)
# 元组 Python 的元组与列表类似，不同之处在于元组的元素不能修改。
# 元组使用小括号，列表使用方括号。
# 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
# tuple1=(2,5,8,3,4,1,6,7,4) #创建一个元组
# tp2=() #创建一个空的元组，为什么会有这个需求呢，主要是在日常运算中，有可能一个元组类型的参数，但你实际没数据可给，那就给个空的
# #为什么有此一问，对列表就没有这个问题呢，因为元组一旦申明，不可改变，但列表可以随便更改，所以就好奇了
# tp3=(50) #申明一个元组，只有一个值，这个时候，他不是一个元组，他是一个 整形（int），如何才能是只有一个数字的元组呢？
# tp4=(50,) #结尾加个逗号就行了
#
# #访问元组，和列表一样
# print(tuple1)
# print(tuple1[1])
# print(tuple1[2:5])
# print(tuple1[:3])
# print(tuple1[2:])
#修改元组
#都说，元组和列表最大的区别是，不能修改，不可变类型，懂？？？
#不死心的试试，老夫就是传说中的“不见棺材不落泪”
# tu5=("甜老丝", "天轰穿", "老田", "小甜")
# #改里面的值
# tu5[2]='大田'
# #增项
# tu5.append('甜到腻歪')
# #减项
# del tu5[2]
# #正确的修改元组的方法,我信你个鬼，这个根本就不是改变
# tup1 = (12, 34.56)
# tup2 = ('abc', 'xyz')
# # 创建一个新的元组
# tup3 = tup1 + tup2
# print(tup3)
#
# 删除元组
# 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
# tup = ('abc', 'xyz')
# print(tup)
# del tup
# print("删除后的元组 tup : ")
# print(tup)
#将元组转换为列表
# list1 = ['亢龙有悔', '见龙在田', 2020, 2028]
# print(type(list1)) #查看这个变量的类型
# print(list1)
# tup6=tuple(list1) #将list1转化为tuple，并教给新的变量tup6
# print(type(tup6))
# print(tup6)
#所以，如果你一定要修改元组，那么最简单的办法
#第一步：把要修改的元组转换为列表
#第二步：修改这个列表
#第三步：把修改后的列表转换为新的元组
#但是，你这么无聊搞一大堆，目的是什么呢？？
#要你管，反正有用就行了呗
# #自定义画玫瑰花或者多边形
# color=('red','blue','yellow','purple','green','black','pink','coral')
# import turtle
# number=int(input('请输入多边形的边数或者玫瑰花的瓣数：\n'))
# shape=input('请选择画多边形还是圆形，圆形=r,其他的你高兴就好：\n')
# turtle.pensize(10)
# turtle.speed(100) #设置画笔移动速度,画笔绘制的速度范围[0,10]整数,数字越大越快,其实还可以更大，比如100
#
# for x in range(number): #有多少条边就循环多少次
# if x<len(color):
# turtle.pencolor(color[x])
#
# if shape=='r': #如果是画圆
# for i in range(100):
# turtle.circle(i) #那就设定半径为100的圆
# else: #如果不是圆
# turtle.forward(150) #单边长150
#
# turtle.left(360/number) #转向，为什么是转360除边呢？当然是计算角度嘛，最终只要360度就封口了
# print('打完收工')
# turtle.mainloop()
#++++++++++++++++++集合（Set）++++++++++++++++++
#申明一个集合
s={'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
s1={1,2,3,4,5,6,7,8}
#或者
s2=set('甜老丝儿的python很流弊哦')
#注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
s2={} #错误的，因为这样创建的不是集合，而是 空字典
s3=set() #这才是对的，嘿嘿哈哈哈哈哈哈
#访问集合
#print(s[1]) #哈哈，你是来搞笑的么，都说了集合是没有索引的
#迭代访问集合
# s6={'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
# s8=set('甜老丝儿的python很流弊哦')
# for x in s8:
# print(x)
#集合是不重复的，凡是重复的，都拖出去剁吧剁吧
# s4={1,1,2,2,3,3,3}
# print(s4) #被去重了
# #其他类型转换为集合
# l = [1.23, "a"] # 列表类型
# d = {1: "a", 2: "b"} # 字典类型
# a = (1, 2, "b") # 元组类型
# s = "厉害了，我的国" # 字符串
#
# # 将列表，字典，元组，字符串转化为集合
# s2 = set(s)
# s3 = set(l)
# s4 = set(d)
# s5 = set(a)
#
# print(s2)
# print(s3)
# print(s4)
# print(s5)
#补充一句：要删除列表、元素中重复的项，转换成集合，再转回去，快得一笔
#为什么要说快呢，计算机再计算的时候是要花时间的，虽然算个 1+1 确实很快，但要算10000000000000000000000000000000000次呢？
#而程序里面几乎每一步要需要很多步骤的计算，只不过很多很基本的计算是计算机底层去做了，我们编程看不到而已，包括你看到的这句话
# #修改集合---------添加元素
# s1 = {1.23, "a"}
# s1.add('c') #向集合添加一个元素，对，一次只能一个，比如字符串
# s1.add(88) #也可以添加一个整数
# print(s1)
#能不能添加一个list、元组、集合、字典进去呢？
# s1 = {1.23, "a"}
# list1=[11,22,33] #造一个列表
#
#
# s1.update(list1) #把列表加到集合s1里面去
# s1.update('甜老丝') #把字符串加到列表里面去
# print(s1)
# s1 = {1.23, "a"}
# tu1=('AA','BB') #造一个元组
# #s1.update(332) #把整数加到列表里面去，不行，有add（）你不用，给你个错误镇压
# s1.update((332,)) #你要实在想加，那就酱紫也行，不过，你这是图什么呢？
# s1.update([99,88],[77,66,55],tu1,'字符串') #把列表、元组、字符串混合加到集合中
# print(s1)
# #删除元素
# s3={'aa','bb',888,(11,22)} #申明一个集合来玩儿
# print('删除前：',s3) #这里的链接符号用 + 号要出错，思考下是为虾米
# # #删除前先判断，否则会出错，你试试看错误信息是什么？ 注意：快速看懂错误信息也是一个非常主要的能力
# if 'aa' in s3:
# s3.remove('aa')
# print('删除后：',s3)
# #
#还有一个方法，移除不存在的元素，不会出错
# s4={'aa','bb',888,(11,22)} #申明一个集合来玩儿
# s4.discard('cc')
#最无聊的删除---随机删除一个元素
# s5={'aa','bb',888,666,999,'cc',(11,22)} #申明一个集合来玩儿
# s5.pop()
# s5.pop()
# s5.pop()
# print('删除后：',s5)
# #最狠的删除---清空
# s6={'aa','bb',888,666,999,'cc',(11,22)} #申明一个集合来玩儿
# s6.clear()
# print('删除后：',s6)
# #python集合的运算：事实上，之所以必须讲，倒不是在初级的时候有多重要，主要是NOIP里面也要考这个点，所以早点交给大家
# a = set('abcde')
# b = set('cdefg')
#
# #∪ （并集）
# print('∪ （并集）',a | b) # 集合a或b中包含的所有元素
# print('用方法得到并集：',a.union(b))
# # ∩ （交集）
# print('∩ （交集）',a & b) # 集合a和b中都包含了的元素
# print('用方法得到交集：',a.intersection(b))
# # \ （差集）
# print('\ （差集）',a - b) # 集合a中包含而集合b中不包含的元素
# print('用方法得到差集：',a.difference(b))
#
# # △ （对称集）
# print('△ （对称集）',a ^ b) # 不同时包含于a和b的元素
# print('用方法得到对称集：',a.symmetric_difference(b))
# #++++++++++++++++Dictionary（字典）++++++++++++++++++++++
# #申明方式一
# dt = {'A': '2341', 'B': '9102', 'C': '3258'}
# #申明方式二
# dt1 = { 'a': 456 }
# dt2 = { 'abc': 123, 1: 37 }
#
# #通过key进行访问
# dt3 = {'A': '2341', 'B': '9102', 'C': '3258',168:(66,99)}
# print(dt3)
# print(dt3['A'])
# print(dt3[168][1])
#
# #如果字典里没有的键值对，就会报错
# print('给劳资来一个大写的 服 ',dt3['服不服'])
#迭代访问
# dt4 = {'A': '2341', 'B': '9102', 'C': '3258',168:(66,99)}
# for x in dt4:
# print('key是：',x)
# print('value是：',dt4[x])
#修改字典---添加键值对
# dt1 = {12:'A',13:'B',16:'E'}
# dt1[14]='C' #添加项
# dt1[15]='D'
# print(dt1)
# #----删除字典元素
dt1 = {12:'A',13:'B',16:'E'}
# del dt1[13] #删除键为13的这个项
# print(dt1)
#
# dt1.clear() #删光，一个不留
# print(dt1)
# #
# del dt1 #删除这个字典
# print(dt1)
#补充说明
#字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
#不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，比如
# dt6={1:'甜老丝',1:'老田'}
# print(dt6[1])
#键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
# dict = {['Name']: '甜老丝', 'Age': 18}
# print("dict['Name']: ", dict['Name'])
#不过除非轰了，为什么一定要用列表、元组来做键呢？不服，你试试呗
