• 引子

• 資料型別的基本使用及內建方法

• 集合型別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沒變
# 集合本身純粹的元素應該是不可變型別，但集合本身就是一個可變型別。

• 資料型別總結

• 按儲存空間的佔用分（從低到高）

數字（整型、浮點型）
字串
集合：無序，即無序存索引相關資訊
元組：有序，需要存索引相關資訊，不可變
列表：有序，需要存索引相關資訊，可變，需要處理資料的增刪改
字典：無序，需要存key與value對映的相關資訊，可變，需要處理資料的增刪改

• 按存值個數區分

• 標量／原子型別（不可再分，只能存一個值）：數字，字串

• 容器型別（能存多個值）：列表，元組，字典，集合

• 按可變不可變區分

• 可變：列表，字典，集合

• 不可變：數字，字串，元組

• 按訪問順序區分

• 直接訪問：數字

• 順序訪問（序列型別）：字串，列表，元組

• key值訪問（對映型別）：字典