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()​

​

={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 類型

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

### 1..difference_update( )

### 2..intersection_ update( )

### 3..symmetric_ difference_ update( )

## 六.總結

- ### 可以存多個值

- #### 無序

- #### 可變類型--->不可 hash 類型

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