数据类型:set的基本使用及内置方法，数据类型总结

• 集合类型set的基本使用

• 1、用途：

  去重
  ​ （1）无法保证顺序

msg = "hello"
res = set(msg)
print(res)     # 去重且无序，得到是集合类型
print(''.join(res))  # 转换回字符串得到的是乱序

names = ['egon', 'lxx', 'lili', "egon", "egon"]
print(set(names))           # {'egon', 'lili', 'lxx'} 转集合后，去重无序
print(list(set(names)))     # ['lxx', 'egon', 'lili'] 去重转回列表类型，去重且无法保证原始顺序

​ （2）只能针对不可变类型元素的去重

students_info = [
    {"name":"egon", "age":18, "gender":"male"},
    {"name":"tom", "age":19, "gender":"male"},
    {"name":"jack", "age":38, "gener":"female"},
    {"name":"egon", "age":18, "gender":"male"},
    {"name":"egon", "age":18, "gender":"male"},
]
new_l = []
for info in students_info:
    if info not in new_l:
        new_l.append(info)  # 用l.append一点一点的遍历
print(new_l)                # 达到去重效果并且保证顺序，此种方式是去重常用     

​ 关系运算

• 定义方式：在{ }内用逗号分隔开多个元素，集合内元素的特点有三个

  (1）集合类元素必须是不可变类型
  （2）集合类元素不能重复
  （3）集合内元素无序

#   整型 浮点型  字符串    元组     
s = {11, 3.1, "xxx", (1, 2, 3)}
print(s)         # {3.1, (1, 2, 3), 11, 'xxx'}

s = {11, 11, 11, 11, 11, 22, 33}    # s = set(...)
print(s)          # {33, 11, 22} 重复元素只能留一个
print(type(s))    # <class 'set'>

# 数据类型转换
res = set("hello")
print(res)      # {'o', 'h', 'l', 'e'}  去重且无序

s = set()       # 定义空集合,必须得用set()
print(s, type(s))   # set()  <class 'set'>

• 3、常用操作+内置的方法

  =》=》=》优先掌握的操作：(*****)

（1）交集：取两个集合的共同部分----->既报名pythons又报名linuxs的学生

pythons = {"tom", "jack","alex", "egon", "lxx"}
linuxs = {"lili", "hanmeimei", "zhangsan", "egon", "lxx", "jay"}

print(pythons & linuxs)              # 方式一   # {'lxx', 'egon'}
print(pythons.intersection(linuxs))  # 方式二


# 将两个集合的交集结果赋值给pythons
pythons = pythons & linuxs   
print("pythons")             # 方式一   # pythons

pythons.intersection_update(linuxs)
print("pythons")             # 方式二

（2）并集：两个集合并到一起----->所有学生的姓名

pythons = {"tom", "jack","alex", "egon", "lxx"}
linuxs = {"lili", "hanmeimei", "zhangsan", "egon", "lxx", "jay"}

print(pythons | linuxs)       # 方式一
print(pythons.union(linuxs))  # 方式二

（3）差集： 一个集合减掉与另外一个集合共同的部分

pythons = {"tom", "jack","alex", "egon", "lxx"}
linuxs = {"lili", "hanmeimei", "zhangsan", "egon", "lxx", "jay"}

# 只学了python的学生姓名
print(pythons - linuxs)             # 方式一  # {'jack', 'tom', 'alex'}
print(pythons.difference(linuxs))   # 方式二  
      
# 只学了linux的学生姓名
print(linuxs - pythons)     # 方式一 # {'lili', 'zhangsan', 'jay', 'hanmeimei'}
print(linuxs.difference(pyehons))    # 方式二   

(4) 交叉补集/对称差集：两个集合互相减，然后再并到一起----->取没有同时学两门课程的学生

pythons = {"tom", "jack","alex", "egon", "lxx"}
linuxs = {"lili", "hanmeimei", "zhangsan", "egon", "lxx", "jay"}

res = (pythons - linuxs) | (linuxs - pythons) 
res = pythons ^ linuxs                         
print(res)             # ^ 与 | 方式更简单    # 方式一   

print(pythons.symmetric_difference(linuxs)) # 方式二

（5）父子集合：当一个集合完全包含了另外一个集合，该集合才能称爹

s1 = {1,2,3}
s2 = {3,4,5}
print(s1 >= s2)   # False 没有包含关系，s1不包含s2所以无法成立，只能说明s1不是s2它爹
print(s2 <= s1)   # False 大于等于和小于等于指的不是传统认知的比大小，指的是包含关系


s1 = {1,2,3}
s2 = {1,2}
print(s1 >= s2)   # Ture 有包含关系，集合成立说明s1包含s2，s1是s2它爹  # 方式一
print(s1.issuperset(s2))   # 方式二
             
print(s2 <= s1)   # Ture  #方式一  
print(s2.issubset(s1))        # 方式二

=》=》需要掌握的（****）

# 1、s1.update()  # 更新，把两个集合并到一起，去重，
s1 = {1,2,3}
s1.update({3,4,5})
print(s1)        # {1, 2, 3, 4, 5}  # 相当于可以一次性加多个值

# 2、s1.add()    # 加值，一次加一个值
s1 = {1,2,3}
s1.add(4)
print(s1)

# 3、删除
s1 = {1,2,3}
s1.remove(3)  # 指的元素删除
print(s1)     # {1, 2}

s1 = {11,22,33,44,55,"xx","yy","zz","aa"}
s1.remove(333333333)   # 删除元素不存在 报错
s1.discard(333333333)  # 删除元素不存在 啥事都不会做，不会报错
print(s1)

s1 = {11,22,33,44,55,"xx","yy","zz","aa"}
res=s1.pop()  
print(s1)       # 随机删除元素
print(res)      # 返回删除值，相当于pop取走的值

s1 = {11,22,33,44,55,"xx","yy","zz","aa"}
s1.clear()     # 整个清空掉
print(s1)      # set() 空集合

# 4、s1.copy()  # 复制集合，无序
s1 = {11,22,33,44,55,"xx","yy","zz","aa"}
s1.copy()
print(s1)

# 5、s1.isdisjoint() # 判断两个集合完全没有共同部分，毫不相干
s1 = {1,2,3}
s2 = {4,5,6}
print(s1.isdisjoint(s2))  # True  没有相同部分

s1 = {1,2,3}
s2 = {3,4,5,6}
print(s1.isdisjoint(s2))  # False  有相同部分

• 该类型总结

  ​ 存多个值

​ 无序

​ 可变

s1 = {1,2,3}
print(id(s1))    # 2048402597696
s1.add(4)      
print(s1)     # {1, 2, 3, 4}
print(id(s1))    # 2423667894080 id没变
# 集合本身纯粹的元素应该是不可变类型，但集合本身就是一个可变类型。

---

• 数据类型总结

• 按存储空间的占用分（从低到高）

整型int、浮点型float
字符串str
集合set   ：无序，即无序存索引相关信息
元组tuple ：有序，需要存索引相关信息，不可变
列表list  ：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典dict  ：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

• 按存值个数区分

• 标量／原子类型（不可再分，只能存一个值）：整型int，浮点型float，字符串str

• 容器类型（能存多个值）：列表list，字典dict，元组tuple，集合set

• 按可变不可变区分

• 可变：列表list，字典dict，集合set

• 不可变：整型int，浮点型float，字符串str，元组tuple

• 按访问顺序区分

• 直接访问：整型int,浮点型float

• 顺序访问（序列类型）：字符串str，列表list，元组tuple

• key值访问（映射类型）：字典dict