5.数据类型 int float str list tuple set dict.py

""""""
"""
06 数据类型总结.mp4
        int
        float
        str
        list
        dict
        bool
        tuple
        set
"""

"1.整型"
# #1. 整型 int
# #======================================基本使用======================================
# #1、用途:存qq号，手机号，不带字母的身份证号...
# #2、定义方式
# age = 18  # age = int(18)
# # int('dsjfjdsf')
# # n = int('1.1')  # int只能转纯数字的字符串，小数点都不行
# # print(n)
#
#
# # 进制转换
"""

二进制是逢2就进位,所有数字中没可能有2或大于2的数字.

八进制是逢8就进位,所有数字中没可能有8或大于8的数字。

十进制是逢10就进位,所有数字中有0~9都有

十六进制数字中含有A~F字母,它是0~9+A~F。

"""
# """
# # 其他进制转10进制
# """
# # 二进制转十进制  0,1
# #10 # 1*(2**1) + 0*(2**0) = 2   # 二进制10 转为十进制 2
#
# # 八进制转十进制  0-7
# #277 # 2*(8**2) + 7*(8**1) + 7*(8**0) = 191
# # 十六进制转十进制 0-9 A-F
# #317 # 3*(16**2) + 1*(16**1) + 7*(16**0)  = 513
#
# print(int('1100',2))  # int可以传第一个参数，表示的是第一个参数到底是什么进制  然后转成十进制
# print(int('14',8))
"""

print(int('288',8))

          ^^^^^^^^^^^^

ValueError: invalid literal for int() with base 8: '288'

"""
# print(int('c',16))
#
# print(int('218',16))  # 二进制数字 01,八进制数字 0-7 十六进制数字 0-f否则会报错
# # 2,8,16 表示第一个参数为 什么进制 转 10 进制
# """
# # 十进制转其他进制:

# 十进制整数转换为二进制整数采用"除2取余，逆序排列"法。

# """
# # 10进制转二进制
# print(bin(12)) # 0b1100 0b表示后面的数字是二进制数
#

# 12 / 2 = 6 / 2 = 3 / 2 = 1 余数 1 = 1100

 
# # 10进制转八进制
# print(oct(12))# 0o14  0o表示后面的数字是八进制数  14 >>> 1*(8**1) + 4*(8**0))

# # 12 / 8 = 1 余数 4 = 14

# # 10进制转16进制
#
# print(hex(12))# 0xc  0x表示后面的数字是十六进制数
#

# 12 / 16 余数 12 # 0-9 + A-F = C

#
# #3、常用操作+内置的方法
# #======================================该类型总结====================================
# #存一个值
# #有序or无序
# #   有序：但凡有索引的数据都是有序的
# #特性: 值:不可变
#
#
# """
# 可变类型: 值改变的情况下,id不变,说明你改的是原值
# 不可变类型:值改变的情况下，id一定变
#
# """
# x = 10
# print(id(x))
# x = 12
# print(id(x))
#
# # 结论,不可变类型
#


"""2.浮点型"""
# # 浮点型
# # 作用:薪资 身高 体重
# # salary = 1.1  # float(1.1)
# res = float('1.11')
# print(type(res))# <class 'float'>
#
# # 2.打印金字塔
# '''            max_level=5
#     *          current_level=1 空格数=4 星号=1
#    ***         current_level=2 空格数=3 星号=3
#   *****        current_level=3 空格数=2 星号=5
#  *******       current_level=4 空格数=1 星号=7
# *********      current_level=5 空格数=0 星号=9
# '''
# max_level=5
# for current_level in range(1,max_level+1):
#     # 先不换行打印打印空格 # 5- 1-6  # 打印空字符 4 - 0
#     for x in range(max_level-current_level):
#         print(' ',end='')
#     # 再不换行打印* # 0 , 2 ,4 ,6,8
#     for y in range(2*current_level - 1):
#         print('*',end='')
#     print()
#
#
# x = float('1.11')
# print(id(x))
# x = float('1.12')
# print(id(x))
"""3.字符串"""
#======================================基本使用======================================
#1、用途:描述性
#2、定义方式:'',"",""""""
# s = 'hello baby'  # str('hello baby')
# s1 = str([1,2,3,4])
# print(type(s1))
# s2 = str({'name':'jason','password':123})
# print(type(s2))

x = 'dsdd'
print(id(x))
x = 'asdsadf'
print(id(x))

# 1.按索引取(正向取+反向取):只能取
# s = 'hello big baby'
# print(s[0]) # h
# print(s[6:9:1],'1')
# print(s[6:3:-1],'2')
#
# #2、切片(顾头不顾尾，步长):从一个大的字符串中截取一段新的小字符串
# print(s[0:5])  # hello
# print(s[0:10:1])  #   步长不写默认是1
# print(s[0:10:2])  # 步长表示隔几个取一个

# 了解负数取值
# print(s[-1]) # y (负 从右往左)
#print(s[0:5:-2])  # 无值 反过来取值 0-5 错误 5-0 应该是# 切片取值默认是从左往右的
# print(s[5:0:-1]) #  olle # 切片取值默认是从左往右的
# print(s[-1:-10:-1]) # ybab gib


#3、长度len：统计的是字符串中字符的个数
# s1 = ' '
# print(len(s1))  # 1  计算字符串的长度
# #4、成员运算in和not in: 判断一个子字符串是否存在于一个大的字符串中
#
# print('egen' in 'egon is sfd and egen is sb')  # True
# print('j' in 'egon is dsb and egon is sb') # False
#
# print('jason' not in 'egon is dsb and egon is sb') # True
#
#
# # 5 去掉字符串两边的字符 strip ,不管中间的
# # username = input('>>>>:  ')
# # username = input('>>>>:  ').strip()
# # if username == 'jason':
# #     print('good')
# # strip()默认去除字符串首尾的空格
# # 使用内置的方法统一采用 句点符(.)
#
# # name3 = '$$$$$eg$on$$$$'
# # print(name3.strip('$'))# eg$on
#
# # 了解即可
# # print(name5.lstrip('$'))  # left左边
# # print(name5.rstrip('$'))  # right右边
#
# """
"""# 字符串 转 列表"""
# 字符串 转 列表
# """
# # 6.切分 split: 针对某种分隔符组织的字符串, 可以用 split 将其切分成列表, 进而进行取值
#
# data = 'jasom n / 123 / handsome'
# # print(data.split('/')) # ['jasom n ', ' 123 ', '', ' handsome']
# print(data.split("/"))
# use,pwd,info = data.split('/')
# print(use,pwd,info)# jasom n   123   handsome
#
# # 强调:split切分出来的数据类型是一个列表
# # print(data.split('o'))  # ['jas', 'm n / 123 / hands', 'me']# 切割的顺序其实从左往右的
# print(data.split('o',1))  # 切割的顺序其实从左往右的
# print(data.rsplit('o',1))  # 切割的顺序其实从右往左的
# # 如果不指定那么split和rsplit效果是一样
# """
# 类似split，区别为从结尾位置开始计数
# sep，分隔符，默认空格
# maxsplit，切分次数，默认最大次数，从起始结尾开始计数
# s = 'a b c'
# res = s.rsplit(sep=' ', maxsplit=1)
# print(res)
# """
# print(data.rsplit(sep='o',maxsplit=0),'1')
#
# #7、循环
# # for i in data:
# #     print(i)
#
#
#
#
# # 补充
# msg = 'aABBBBb'
# res = msg.lower() # aabbbbb # 字符串全部小写
# print(res)
# msg = "asdf"
# print(msg.lower())
# print(msg.upper())
#
# res1 = msg.upper() # AABBBBB  # 字符串全部大写
# print(res1)
#
# #3、startswith,endswith
# msg='alex is dsb'
# print(msg.startswith('alex'))
# print(msg.endswith('sb'))
# # 判断是否以该字符串开始 startswith ,判断是否以该字符串结束 endswitch
#
# # 需要你掌握的
# #1、strip,lstrip,rstrip #去空格
# #2、lower,upper #小写 大写
# #3、startswith,endswith 判断是否以此为开头,结尾哦
# #4、format的三种玩法  {name} format（name='llx）
# print('my name is %s my age is %s' % ('egen',18))  # my name is egen my age is 18
#
# print('my name is {name} my age is {age}'.format(age=18,name='enge'))  # my name is enge my age is 18
# print("{name}:{age}".format(name="llx",age=18))
#
# #5、split,rsplit 切分,字符串转列表
#
#
# #6、join 字符串拼接
#
# s5 = 'llx'
# s6 = s5.join('llx')
# s6 = s5.join('llw')  # 拼接字符串
# print(s6) # lllxlllxw
# #7、replace 替换
# s7 = s6.replace('l','s')
# print(s7) # sssxsssxw
# #8、isdigit # 判断字符串中包含的是否为纯数字
#
# print(s7.isdigit()) # False
#
# # 需要了解的内置方法
# #1、find,rfind,index,rindex,count
# # 查找，查找，索引，索引，索引，计数
# # print(s7.find('x')) # 3 字符串该元素的索引
# print(s7.rfind('s')) # 7 索引  该元素最后一位的索引
#
# print(s7.count('x')) # 2 计数 # 该字符串内 指定 元素的个数
#
# print(s7.index('x'))  #3
# print(s7.rindex('x'))   #7
#
# #2、center居中,ljust左对齐,rjust右对齐,zfill右对齐,不足部分用0补足
# print(s7.center(50,'0'))  # 把字符串放到中间 50表示字符串 len 0 填补元素
# # 00000000000000000000sssxsssxw000000000000000000000
# # print(s7.ljust(50,'0')) # 靠左
# # # sssxsssxw00000000000000000000000000000000000000000
# # print(s7.rjust(50,'0')) # 靠右
#
# print(s7.zfill(50))
# # 00000000000000000000000000000000000000000sssxsssxw
#
#
# #3、expandtabs
#
# """
# expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16...等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。
#
# 语法
# expandtabs() 方法语法：
#
# str.expandtabs(tabsize=8)
# """
# st = "runoob\t12345\tabc"
# print(st.expandtabs(tabsize=8))
# print(st.expandtabs(tabsize=8)) # runoob  12345   abc
# #4、captalize,swapcase,title首字母大写，全部大写，标题
# print(11111111111)
# print(st.capitalize()) # Runoob  12345  abc
# print(st.swapcase())
# print(st.title())
# """
# capitalize()：让字符串首字母变成大写！
# title()：所有单词开头字母变成大写！
# upper()：整个字符串的所有字母变成大写！
# swapcase()：所有字母进行大小写转换！
# """
#
# #5、is数字系列
# #5、is数字系列
# #在python3中
# num1=b'4' #bytes 字节
# num2=u'4' #unicode,python3中无需加u就是unicode(字符编码)
# num3='壹' #中文数字
# num4='Ⅳ' #罗马数字
#
# #''.isnumeric()  判断 是否为 非数字字符: unicode,中文数字，罗马数字
# print('1',num2.isnumeric())
# print('2',num3.isnumeric())
# print('3',num4.isnumeric())
#
# # 1 True
# # 2 True
# # 3 True
#
# #''.isdecimal(): unicode
# # isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象
# print(num2.isdecimal())
# print(num3.isdecimal())
# print(num4.isdecimal())
#
# # ''.isdigit() :bytes,unicode
# print(num1.isdigit())
# print(num2.isdigit())
# print(num3.isdigit())
# print(num4.isdigit())
#
# #6、is其他
# print('abc你'.isalpha()) # 字符串中包含的是字母或者中文字符
#
# # 字符串中包含的是字母（中文字符）或数字
# print('ab'.isalnum())
# print('123中123'.isalnum())
# print('ab123'.isalnum())
#
# # True
# # True
# # True

"""4.列表"""

# list1 = [1,'a',1.1,True,[1,2],{'name':'llx'}]
# """列表类型"""
#
# #作用：多个装备，多个爱好，多门课程，多个女朋友等
#
# #定义：[]内可以有多个任意类型的值，逗号分隔
#
# # list内部原理就是for循环取值 然后一个个塞到列表中去
#
# """
""" 字符串转列表"""
# """
# l = list("abc")
# print(l)  # ['a', 'b', 'c']
# # s1 = 'a/bc/ed'
# # print(s1.split('/'))# ['a', 'bc', 'ed']
#
#
# # 优先掌握的操作:
# # 1.按索引存取值(正向存取 + 反向存取):即可存 也可取
# l1 = [1,2,3,4]
# print(l1[0:4:2]) # [1, 3]  0 4 分别为起始 2 间隔长
# print(l1[0::])  # [1, 2, 3, 4]
# # print(l1[4:0:-2]) # [4, 2]
# # l1[0] = 'abc'
# # print(l1) # ['abc', 2, 3, 4]
#
# # 切片 (顾头不顾尾,步长)
# l2 = [11,22,33,44]
# l3 = [99,88,77,66]
# print(l2.extend(l3)) # 一次性添加多个元素
# print(l2)  # [11, 22, 33, 44, 99, 88, 77, 66]
# #
# # 1.尾部添加一 个 111
# l= [1, 2, 3, 4]
# l2 = l.append(111) # # 注意append值能将被添加的数据当作列表的一个元素
# print(l2)  # [1, 2, 3, 4, 111]
#
# # 2.任意位置添加元素
# l.insert(2,77)
# print(l) # [1, 2, 77, 3, 4, 111]
# # # 注意insert值能将被添加的数据当作列表的一个元素
#
# # 3. 添加容器类型数据
# l1 = [99,88,77,66]
# l.append(l1)
# print(l)  # [1, 2, 77, 3, 4, 111, [99, 88, 77, 66]]
# l.insert(-2,l1)
# print(l)
# # [1, 2, 77, 3, 4, [99, 88, 77, 66], 111, [99, 88, 77, 66]]
# l.extend(l1)#  # 内部原理for循环l1一个个追加到列表的尾部
# print(l)
# # [1, 2, 77, 3, 4, [99, 88, 77, 66], 111, [99, 88, 77, 66], 99, 88, 77, 66]
#
# #3、长度
# print(len(l))  #12
#
# # 4.成员运算 in    not in
# print(77 in l) # True
# print(189 not in l) # True
#
# #5、往列表中添加元素（******）
# # append
# l = [1,2,3,4]
# l.append(11) # 自动加到末尾
# print(l) #[1, 2, 3, 4, 11]
# # insert
# l.insert(2,3) # 按索引加到指定位置
# print(l) # [1, 2, 3, 3, 4, 11]
# # extend #  内部原理for循环l1一个个追加到列表的尾部
# l.extend([1,2]) # [1, 2, 3, 3, 4, 11, 1, 2]
# print(l)
# l.extend(range(0,10)) # [1, 2, 3, 3, 4, 11, 1, 2]
# print(l)
#
#
# # 6.删除 del  适用于所有的删除操作
# l = [1, 2, 3, 4, 11]
# del l[1] # 索引
# print(l)  # [1, 3, 4, 11]
#
# res = l.pop() # # 尾部弹出
# print(res,l)  # 11 [1, 3, 4]
#
# res1 = l.pop(2) # 可以指定 索引
# print(res1,l) # 4 [1, 3]
#
# l = [1, 3, 4, 11]
# res3 = l.remove(1) # # 指定要删除的元素的值
# print(res3,l) # None [3, 4, 11]
#
#
# # 删字符串
# s = 'haha'
# print(s,'1')
# del s
# # print(s,'2')
#
#
# # 需要掌握的操作
# l=['egon','egon','lxx','yxx',444,555,66666]
# print(l.count('egon'),'计数') # 2
# print(l.index('egon'),'索引') #0
# print(l.index('yxx',0,5),'位置') # 0-5 索引区间
# l.clear() # 结束
# print(l) # []
#
# l=['egon','egon','lxx','yxx',444,555,66666]
# l.reverse()  # reverse() 方法用于颠倒数组中元素的顺序。
# print(l)
#
# nums=[3,-1,9,8,11]
# nums.sort(reverse=True) # sort() 方法用于对数组的元素进行大小排序
# print(nums) # [11, 9, 8, 3, -1]
#
#
# #二：该类型总结
# # 1 存多个值
#
# #
# # 2 有序
# #
# # 3 可变
# l=['a','b','c']
# print(id(l))
# l.append('d')
# print(id(l))
#
# # 2781376293448
# # 2781376293448
#
#
# # 队列: 先进先出
# l = []
# # 入队
# l.append('first')
# l.append('two')
# l.append('scend')
# print(l)  # ['first', 'two']
# # 出对
# print(l.pop(0)) # first
# print(l.pop(0)) # two
# print(l.pop(0)) # secend
# print(l) # []
#
# # 堆栈 :先进后出
# l = []
# # 入栈
# l.append('first')
# l.append('second')
# l.append('third')
# print(l) # ['first', 'second', 'third']
#
# # 出栈
# print(l.pop())
# print(l.pop())
# print(l.pop())
#
# # third
# # second
# # first


"""5.元组() """
# tuple 元组
# #作用：能够存储多个元素，元素与元素之间逗号隔开  元素可以是任意类型,元组不能被修改
#
# # 定义: 与列表类型比,只不过[] 换成 ()
# age = (11,22,33,44,55,66) # 本质age = tuple((11,22,33,44,55,66))
#
#
# #优先掌握的操作：
# #1、按索引取值(正向取+反向取)：只能取
# #2、切片(顾头不顾尾，步长)
# #3、长度
# #4、成员运算in和not in
# #5、循环
# print(type(age)) # <class 'tuple'>
# print(tuple(1))#  报错  必须传容器类型
#
# n = ('a')
# n1 = (1)
# print(type(n),type(n1))  # <class 'str'>  <class 'int'>
# # 在定义容器类型的时候，哪怕内部只有一个元素，你也要用逗号隔开 区分一下（******）
#
#
#
# #1、按索引取值(正向取+反向取)：只能取
# print(age[0]) # 11  # 可以用索引取值
# print(age[0:3:1])  # (11, 22, 33)
# print(age[3:0:-1]) # (44, 33, 22)
#
# age = (11,22,33,44,55,66,'a',[22,33])
# age[-1][0] = '[1,2,3,4]'
# print(age)  # (11, 22, 33, 44, 55, 66, 'a', ['[1,2,3,4]', 33])
#
#
# # age[1] = '111' # 报错 元组不能被修改
#
# # del 删除
# del age[-1][1]  # 元组不能被修改 # 列表可以修改
# print(age)
# # (11, 22, 33, 44, 55, 66, 'a', ['[1,2,3,4]', 33])
# # (11, 22, 33, 44, 55, 66, 'a', ['[1,2,3,4]'])
#
#
# # #2、切片(顾头不顾尾，步长)
# print(age[0:5:2]) # (11, 33, 55)
# print(len(age))  # 8
#
# #4、成员运算in和not in
# print('a' in age) # True
#
# # 循环
# for i in age:
#     print(i)
#
# # count index
# print(age.count('a'))  # 1
# print(age.index(11))  # 0
#
# """
# 能存多个值
# 有序
# 不可变
# """
#
# print(id(age))
#
# # list 增 append
# age[-1].append(66)
# age[-1].insert(0,77777)
# print(age)
#
# # 2030676272184
# # (11, 22, 33, 44, 55, 66, 'a', ['[1,2,3,4]', 66])

"""6.字典"""
# 字典及内置方法
# # 定义
# dic = {
#     'name':'egon',
#     "age":12,
#     'pwd':123
#        } # dic = dict({'name':'egon',"age":12,'pwd':123}
# """
# #作用：能存存储多组 key:value键值对  key是对value的描述  key通常情况下都是字符串
# # 其实这个key只能是不可变类型,value可以是任意数据类型
#
# # 强调:字典的key是不能重复的 要唯一标识一条数据
# # 如果重复了 只会按照最后一组重复的键值对存储
# """
#
# # 优先掌握的操作
# # 1.按照key存取值:可存可取
# d = {'name':'jason','password':'123'}
# print(id(d)) # 1615478509712
#
# print(d['name'],d['password'])  # jason 123
#
# # 修改
# d['name'] = 'egon'
# d['name'] = 'kevin'
# d['name'] = 'xxx'
# d['name'] = 'ooo'
#
# d['age'] = 18  # 赋值语句当key不存在的情况下，会自动新增一个键值对(******)
# print(d,id(d)) # {'name': 'ooo', 'password': '123', 'age': 18} 2090566668432
#
# # 2.长度len
# # # 统计的键值对的个数
# print(len(d)) #3
# #
# # #3、成员运算in和not in   对于字典来说只能判断key值
# d = {'name':'jason','password':'123'}
# print('123' in d) # False
# print('name' in d) # True
#
# # 4.删除 del pop clear
# d3 = {'name':'jason','password':'123'}
# del d3['name']
# print(d3)  # {'password': '123'}
# d3 = {'name':'jason','password':'123'}
# res = d3.pop('name')  # 弹出仅仅是value
# print(res,d3) #jason  {'password': '123'}
# # res1 = d3.pop('age')  # 当键不存在的时候直接报错
#
# d3.clear() # 清空
# print(d3)  # {}
#
#
# """*****"""
# # 定义字典的三种方式
# # 1
# d1 = {'name':'jason','password':123}
# # 2
# d2 = dict(name='llx',pwd=123)
# print(d2) # {'name': 'llx', 'pwd': 123}
#
#
#
# # 了解即可 : 列表化字典
# l = [
#     ['name','jason'],
#     ['age',18],
#     ['hobby','read']
# ]
#
# d = {}
# # for i in l: # [name,jason],[age,18]...
# for k,v in l:
#     print(k,v)
#     d[k] = v
#     print(d) # {'name': 'jason', 'age': 18, 'hobby': 'read'}
# d3 = dict(l)
# print(d3) # {'name': 'jason', 'age': 18, 'hobby': 'read'}
#
# # 5键 keys(),值values() 键值对items()
# d4 = {'name':'jason','password':123}
# print(d4.keys())  # dict_keys(['name','pasword])
# # for k in d4.keys():
# #     print(k)
# print(d4.values())  # dict_values(['jason', 123])  老母猪  现在就把它当成一个列表来看即可
#
# print(d1.items()) # dict_items([('name', 'jason'), ('password', 123)])
# """# 就把它看成是列表套元组，元组的第一个元素是字典的key 第二个元素是字典的value"""
#
# # get()根据key获取value（*******************************）
# d1 = {'name':'jason','pwd':123}
# print(d1['name'])
#
# print(d1.get('name'),d1.get('pwd'),'1') # jason 123 1
#
# """
# # print(d1.get('name','你给我的name在字典的key中'))
# # res = d1.get('age')  # 当字典的key不存在的情况 不报错 返回None
# """
#
# """
# # # get可以传第二个参数。当你的key不存在的情况下，返回第二个你写好的参数信息
# # print(res1)
# # print(d1.get('xxx','asdsad'))
# # 第二个参数不写的话 当key不存在的情况下返回None，写了就返回写了内容
#
# """
# print(d1.get('age',12))  # 12
# print(d1)
#
# # dict.fromkeys()  快速的创建一个字典
#
# l1 = ['name','pwd','age','hobby']
# print(dict.fromkeys(l1)) # {'name': None, 'pwd': None, 'age': None, 'hobby': None}
#
# dict.popitem()
# print(d1.popitem(),'1') # 尾部以元组的形式弹出键值对  # ('pwd', 123) 1
# print(d1) # {'name': 'jason'}
#
# # dict.setdefault()
# d1 = {'name':'jason','pwd':123}
# real1 = d1.setdefault('name','llx')
# print(real1,d1) # jason {'name': 'jason', 'pwd': 123}
# """# 当键存在的情况下 不修改值 并且将原先key对应值返回给你"""
# real2 = d1.setdefault('age',12)
# print(real2,d1) #12 {'name': 'jason', 'pwd': 123, 'age': 12}
# """当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你"""
#
# """
# 语法
# setdefault() 方法语法：
#
# dict.setdefault(key, default=None)
# 参数
# key -- 查找的键值。
# default -- 键不存在时，设置的默认键值。
# 返回值
# 如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值。
# """
#
# # dict.update() 更新
# d1 = {'name':'jason','pwd':123}
# d2 = {"age":18}
# d1.update(d2)
# print(d1) #{'name': 'jason', 'pwd': 123, 'age': 18}
# d1.update(age=666)
# print(d1) # {'name': 'jason', 'pwd': 123, 'age': 666
#
#
# #6、循环 k
# d1 = {'name':'jason','password':123}
# for i in d1:
#     print(i)
# # }
#
# """
# 存多个值
# 无序
# 可变
#
#
# """

"""7.集合{} 去重"""
# 集合set
#
#
# p1 = ['李二丫','张金蛋','李银弹','赵铜蛋','张锡蛋','alex','oldboy']
# l1 = ['lxx','egon','张金蛋','张锡蛋','alex','陈独秀']
#
# l = []
# for name in p1:
#     if name in l1:
#         print(name)
#         l.append(name)
#         print(l) # ['张金蛋', '张锡蛋', 'alex']
#
#
# # 群体之间做比较 不涉及单个元素
#
# """
# 1.用途:关系运算,去重
# 2.定义方式: 在{}内用逗号分开的多个值
# # 集合的三大特性
# 2.1每个值都必须是不可变类型
# 2.2元素不能重复
# 2.3集合内元素无序
# """
#
# # 定义
# s = {1,2,3,4,5,6}  # <class 'set'>  # s = set()
# print(type(s))
#
# s1 = set()
# "# 注意在定义空集合的只能用关键字set"
# print(s1,type(s1))  #set() <class 'set'>
# x = {}  # <class 'dict'>  如果你仅仅只写了一个大括号 那么python默认将它当做字典类型
# print(type(x))
#
# # t = ()  # <class 'tuple'>
# # print(type(t))
#
#
# """# 定义集合:可以包含多个元素,用逗号分隔
# # 集合的元素遵循三个原则：
# # 1：每个元素必须是不可变类型
# # 可变:不可hash
# # 不可变:可hash
#
# 对于 Python 的内建类型来说，只要是创建之后无法修改的(immutable)类型都是 hashable 如字符串，可变动的都是 unhashable的比如：列表、字典、集合，他们在改变值的同时却没有改变id,无法由地址定位值的唯一性,因而无法哈希。我们自定义的类的实例对象默认也是可哈希的（hashable），而hash值也就是它们的id()
# """
# # s = {1,2,3,4,5,6,'a',(1,2),[1,2]}  # 报错
# # s = {1,2,3,4,5,6,'a',(1,2),{"name":'jason'}}  # 报错
"""集合中 无法存在可变类型,列表,字典,"""
# d = {'a','name'} #<class 'set'>
# print(type(d))
#
# # 2: 没有重复的元素  # 主要用途
# s = {1,2,2,2,2,2,2,2,2,2,3,4,4,4,4,4,5}
# print(s) #{1, 2, 3, 4, 5} # 自动将重复的元素 去除
#
# # 3：无序,无法用索引取值
# s = {1, 2, 3, 4, 5, 6}
# # print(s[1]) # 报错
#
# "可以通过for取值"
# for i in s:
#     print(i)
#
# "# 注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值"
#
# # 优先掌握的操作：
# # 1、长度len
# s = {1,2,3,4}
# print(len(s))  # 4
# # 2、成员运算in和not in
# pythons={'李二丫','张金蛋','李银弹','赵铜蛋','张锡蛋','alex','oldboy'}
# linuxs={'lxx','egon','张金蛋','张锡蛋','alex','陈独秀'}
# # 3、|合集
# # 取所有报名老男孩课程的学员:并集
# print(pythons | linuxs)
# print(pythons.union(linuxs))  # union 联盟 合并
# # {'alex', '陈独秀', '李二丫', 'oldboy', '李银弹', 'lxx', 'egon', '张锡蛋', '赵铜蛋', '张金蛋'}
# # 4、&交集
# # 取及报名python课程又报名linux课程的学员:交集
# print(pythons & linuxs) # {'张锡蛋', 'alex', '张金蛋'}
# # intersection 交叉
# print(pythons.intersection(linuxs)) # {'张锡蛋', 'alex', '张金蛋'}
# # 5、-差集
# print(pythons - linuxs)
# print(pythons.difference(linuxs)) # difference 不同 差异
# # {'oldboy', '李二丫', '李银弹', '赵铜蛋'}
# # 6、^对称差集
# print(pythons ^ linuxs)
# print(pythons.symmetric_difference(linuxs)) # symmetric 对称
# # {'lxx', '赵铜蛋', 'oldboy', '陈独秀', '李二丫', 'egon', '李银弹'}
#
# # 7、== 是否相等
#
# s = {1,2,3}
# s1 = {3,1,2}
#
# print( s == s1) # True
# # 8、父集：>,>=
# s1={1,2,3}
# s2={1,2}
# print(s1 >= s2)
# print(s1.issuperset(s2)) # True
#
# # issuperset is 是 superset父集
#
# # 9.子集
# s1={1,2,3}
# s2={1,2}
# print(s2 <= s1)
# print(s2.issubset(s1))
# issubset子集
#
# """需要掌握的操作"""
# # 1.add 加入
# s = {1,2,3,4,5}
# print(s.add(666))
# print(s.add((1,2,3,4)))  # 将容器类型也当成一个元素传入
# print(s) # {1, 2, 3, 4, 5, 666}
#
# # 2.remove 移除
# print(s.remove(2))
# print(s) # {1, 3, 4, 5, (1, 2, 3, 4), 666}
#
# # 3.update 更新
# s1={1,2,3}
# s1.update({3,4,5})
# s1.update('666')
# print(s1,'1') # {1, 2, 3, 4, 5, '6'} 1
#
# # pop
#
# res = s1.pop()
# print(res,s1) # 1 { 2, 3, 4, 5,6}
# # difference_update 不同 更新
# s1={1,2,3}
# s2={1,2}
# s1.difference_update(s2) #s1=s1.difference(s2)
# print(s1)
# s1={1,2,3}
# res=s1.discard(3) ##单纯的删除,返回值为None
# print(s1)
# print(res)
# # s1.remove(444444) #删除的元素不存在则报错
# s1.discard(444444) #删除的元素不存在不会报错
# # discard丢弃 discard
#
# s1={1,2,3}
# s2={1,2,4}
# s3={7,8,9}
# print(s1.isdisjoint(s3),'1') ##如果两个集合没有交集则返回True
# # isdisjoint 不相交
#
#
# #二：该类型总结
# # 1 存多个值
# #
# # 2 无序
# #
# # 3 set可变
# s={1,2,3}
# print(id(s))
# s.add(4)
# print(id(s))
#
# # 集合去重
# # 局限性
# #1、无法保证原数据类型的顺序
# #2、当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重
# names=['alex','egon','alex','alex','egon','lxx']
# s=set(names)
# print(s)
# l=list(s)
# print(l) # ['egon', 'alex', 'lxx']
#
#
#
# stus_info=[
#     {'name':'egon','age':18},
#     {'name':'alex','age':73},
#     {'name':'oldboy','age':84},
#     {'name': 'egon', 'age': 18},
#     {'name': 'egon', 'age': 18},
#     {'name': 'egon', 'age': 18},
#     {'name': 'oldboy', 'age': 84},
#
# ]
# # set(stus_info) # 报错
# l=[]
# for info in stus_info:
#     if info not in l:
#         l.append(info)
#
# print(l)
# # [{'name': 'egon', 'age': 18}, {'name': 'alex', 'age': 73}, {'name': 'oldboy', 'age': 84}]
# stus_info=l
# print(stus_info)
#
#
#
#
# l = [1,2,3,4]
# print(id(l))
# l[1] = 5
# print(id(l))