python 開發 -- 16集合類型內置方法

文章目錄

• • 一.用途
  • • 1.關系運算
    • 2.去重
  • 二.定義方式
  • 三.類型轉換
  • 四.常用操作
  • 關系運算
  • • 1.交集 : `&`, `.intersection()`
    • 2.並集 : `|`, `.union()`
    • 3.差集 : `-`, `.difference()`
    • 4.對稱差集 : `^`, `.symmetric_difference()`
    • 5.父集 ：`>=`, `.issuperset()`
    • 6.子集 : `<=`, `.issubset()`
  • 去重
  • • 1.簡單去重(無法保證順序)
    • 2.去重並保證原來的順序(了解)
  • 五.內置方法
  • 優先掌握的操作(*********)
  • • 1.長度 : .len( )
    • 2.成員運算 in 和 not in
    • 3.循環取值
  • 需要掌握的操作(****)
  • • 1.更新 .update( )
    • 2.添加 .add( )
    • 3.取走一個值 .pop( )
    • 4.刪除 .remove( ), .discard( )
    • 5.無交集 .isdisjoint( )
  • 不怎麼需要了解的操作(***)
  • • 1..difference_update( )
    • 2..intersection_ update( )
    • 3..symmetric_ difference_ update( )
  • 六.總結
  • • 可以存多個值
    • • 無序
      • 可變類型--->不可 hash 類型

一.用途

1.關系運算

• 交集 : &
• 並集 : |
• 差集 : -
• 交叉補集 : ^

2.去重

• 簡單示例

l = [1,1,2,2,1,3]
s = set(l)
print(list(s)) #[1,2,3]

二.定義方式

• 在 “{ }” 內用逗號分隔開一個個元素
  \1. 集合的元素必須是不可變類型
  \2. 集合內元素無序
  \3. 集合內元素唯一
• 集合的"工廠" : set

s={
1,2,3,4,4,4,4,4,4,4,'a'}
# 背後的操作就是
s=set({
1,2,3,4,'a'})
# 如果元素重復, 只會取一個
print(type(s),s)
#<class 'set'> {1, 2, 3, 4, 'a'}
# 加入可變類型報錯 
s={
[1,2,3],'aa'} #報錯
# 無序的
s = {
1,2,"b",4,"a",6,7}
print(s) #{1, 2, 4, 6, 7, 'b', 'a'}

ps : 定義空集合 與 定義空字典

# 定義空集合
s = set()
print(s,type(s))
#set() <class 'set'>
# 定義空字典
dic = {
}
print(dic,type(dic))
#{} <class 'dict'>

三.類型轉換

• 只要存在可變類型就無法轉換, 會報錯
• 我們說字典的 key 是不可變類型, value 是任意類型, 所以轉換時轉的就是字典的 key, 而不是 value

# 整型--->集合
# res = set({1, 2, 3, 4})
res = {
1, 2, 3, 4}
print(res, type(res))
# {1, 2, 3, 4} <class 'set'>
# 浮點型--->集合
# res1 = set({1.1, 2.2, 3.3, 4.4})
res = {
1.1, 2.2, 3.3, 4.4}
print(res, type(res))
# {1.1, 2.2, 3.3, 4.4} <class 'set'>
# 字符串--->集合
res = set('shawn')
print(res, type(res))
# {'a', 'h', 'n', 'w', 's'} <class 'set'>
# 元組--->集合
res = set((1, 2, 3, (1, 2, 3)))
print(res, type(res))
# {1, 2, 3, (1, 2, 3)} <class 'set'>
# 字典--->集合
存到集合裡面的是字典的 key (不可變)
res = set({
'name':'shawn','age':22})
print(res, type(res))
# {'name', 'age'} <class 'set'>
# 整型、浮點型、字符串、元組、綜合--->集合
res = set((2, 1.1,"song", (111, 222)))
print(res, type(res))
#{1.1, 2, (111, 222), 'song'} <class 'set'>
當綜合裡邊存在字典(可變類型)時無法轉換, 並報錯
res = set((2, 1.1,"song", (111, 222),{
'name': 'shawn', 'age': 22}))
print(res, type(res)) #報錯

四.常用操作

關系運算

# 之後就以以下示例來講解
linux=["song","hai","xing","shawn","shang"] #學Linux的學生
python=["shang","hai","qing","pu","qu","hi"] #學Python的學生
# 使用"for"循環取出兩個都學的學生
linux_python=[]
for s in linux:
if s in python: #兩個都學的學生
linux_python.append(s) #加入到列表裡面
print(linux_python) #["shang","hai"]

• 圖解

1.交集 : &, .intersection()

# 取出兩門課程都學習的學生
linux={
"song","hai","xing","shawn","shang",}
python={
"shang","hai","qing","pu","qu","hi"}
print(linux & python) #["shang","hai"]
print(linux.intersection(python)) #["shang","hai"]

2.並集 : |, .union()

# 取出全部的學生
print(linux | python)
#{'shawn', 'qing', 'hai', 'song', 'hi', 'qu', 'xing', 'shang', 'pu'}
print(linux.union(python))
#{'shawn', 'qing', 'hai', 'song', 'hi', 'qu', 'xing', 'shang', 'pu'}

3.差集 : -, .difference()

# 只學習"linux"的,沒學習"python"的 (在"linux"班級裡看)
print(linux - python) #{'song', 'xing', 'shawn'}
print(linux.difference(python)) #{'song', 'xing', 'shawn'}
# 只學習"python"的,沒學習"linux"的 (在"python"班級裡看)
print(python - linux) #{'qing', 'qu', 'hi', 'pu'}
print(python.difference(linux)) #{'qing', 'qu', 'hi', 'pu'}

4.對稱差集 : ^, .symmetric_difference()

# 兩個班級加起來看只學習了一門課程的學生
print(stus_linux ^ stus_python)
# {'pu', 'qing', 'shawn', 'xing', 'song', 'qu', 'hi'}
print(stus_linux.symmetric_difference(stus_python))
# {'pu', 'qing', 'shawn', 'xing', 'song', 'qu', 'hi'}

5.父集 ：>=, .issuperset()

 s1={
1,2,3,4,5}
s2={
3,2,1}
print(s1 >= s2) #True
print(s1.issuperset(s2)) #True

6.子集 : <=, .issubset()

print(s2 <= s1)
print(s2.issubset(s1))

ps ：如果兩兩相同，則互為父子集

去重

1.簡單去重(無法保證順序)

s1=set('hello')
print(s1) #{'l','h','o','e'}
# 將一個列表去重
l=['a','b',1,'a','a']
print(list(set(l))) #先變成集合去重，再list變成列表
#[1,'a','b'] 無法保證順序

2.去重並保證原來的順序(了解)

l = ['a', 'b', 1, 'a', 'a']
l2=[]
s=set()
# 通過"for"循環一個一個取, 一個一個加
for item in l:
if item not in s:
l2.append(item) #l2=['a','b',1] 一個一個加進來
print(l2) #['a','b','1']

五.內置方法

優先掌握的操作(*********)

1.長度 : .len( )

s1={
1,'a','b','c','d'}
print(len(s1)) #5

2.成員運算 in 和 not in

s1={
1,'a','b','c','d'}
print(len(s1))
s1={
1,'a','b','c','d'}
print("c" in s1) #True
print("c" not in s1) #False

3.循環取值

• 集合是無序的, 所以使用 for 循環取出來的值也是無序的

s1={
1,'a','b','c','d'}
for i in s1:
print(i)
# d
# 1
# c
# b
# a

需要掌握的操作(****)

1.更新 .update( )

• 新集合更新舊集合, 有則不添加, 無則添加
• 可以一次添加多個值

s1={
'a','b','c'}
s1.update({
"a",3,4,5})
print(s1) # {'a','b','c',3,4,5}

2.添加 .add( )

• 一次只能添加一個值

s1={
'a','b','c'}
s1.add(4)
print(s1) #{'c', 'b', 'a', 4}

3.取走一個值 .pop( )

• 不指定參數, 隨機刪除集合中的任意元素, 並且返回這個值

s={
"aaa",22,3,"bbb"}
res=s.pop()
print(s) #{3, 'aaa', 22}
print(res) #bbb

4.刪除 .remove( ), .discard( )

• .remove( ) : 當刪除的元素不存在時, 報錯
• .discard( ) : 當刪除的元素不存在時, 不報錯

s1={
'a','b','c'}
# "remove"刪除
s1.remove(4) #報錯
# "discard"刪除
s1.discard(4) #不報錯

5.無交集 .isdisjoint( )

• 如果兩個集合沒有任何交集則返回 True

# 無交集實驗
s1={
1,2,3}
s2={
4,5,6}
print(s1.isdisjoint(s2)) #T
print(s2.isdisjoint(s1)) #T
# 有交集實驗
s1={
1,2,3}
s2={
4,5,6,3}
print(s1.isdisjoint(s2)) #T
print(s2.isdisjoint(s1)) #T

不怎麼需要了解的操作(***)

1…difference_update( )

2…intersection_ update( )

3…symmetric_ difference_ update( )

六.總結

• 可以存多個值

• 無序

• 可變類型—>不可 hash 類型

ps : 集合裡面的值必須不可變

print(s1.isdisjoint(s2)) #T
print(s2.isdisjoint(s1)) #T

## 不怎麼需要了解的操作(***)
### 1..difference_update( )
### 2..intersection_ update( )
### 3..symmetric_ difference_ update( )
## 六.總結
- ### 可以存多個值
- #### 無序
- #### 可變類型--->不可 hash 類型
[外鏈圖片轉存中...(img-2rHa53oA-1656084132890)]
ps : 集合裡面的值必須不可變