python集合概念_python中集合的特點和注意點

A. python 簡明教程 ---13，Python 集合

前幾節我們已經介紹了Python 中的列表list ，元組tuple 和字典dict ，本節來介紹Python 中的最後一種數據結構—— 集合set 。

Python 中的 set 與 dict 很像，唯一的不同是， dict 中保存的是鍵值對，而 set 中只保存鍵，沒有值。

Python 集合有如下特點：

Python 集合的聲明有兩種方式：

創建空集合時，只能用 set() ，而不能用 {} ：

創建非空集合時，可以用 set() ，也可以用 {} ：

由於集合中的元素是唯一的，如果初始化時的可迭代數據中有重復的元素，則會自動刪去重復的元素：

使用 len() 函數可以查看集合中元素的個數：

由於Python 集合中的元素的是無序的，所以可不能使用下標的方式來訪問集合中的單個元素。

我們可以使用 for 循環來遍歷集合中的所有元素：

我們可以對兩個集合進行如下運算：

交集與並集

in 運算

使用 dir(set) 查看集合支持的所有方法：

下面一一介紹這些非魔法方法，共17 個。

1. add 方法

由於集合中的元素是唯一的，向集合中添加元素時有兩種情況：

示例：

2. remove 方法

示例：

3. discard 方法

示例：

4. pop 方法

示例：

5. union 方法

示例：

6. update 方法

示例：

7. clear 方法

示例：

8. 方法

示例：

9. difference 方法

示例：

10. difference_update 方法

示例：

11. intersection 方法

示例：

12. intersection_update 方法

示例：

13. isdisjoint 方法

示例：

14. issubset 方法

示例：

15. issuperset 方法

示例：

16. symmetric_difference 方法

示例：

17. symmetric_difference_update 方法

示例：

（完。）

推薦閱讀：

Python 簡明教程 --- 8，Python 字元串函數
Python 簡明教程 --- 9，Python 編碼
Python 簡明教程 ---10，Python 列表
Python 簡明教程 ---11，Python 元組
Python 簡明教程 ---12，Python 字典

B. Python序列,集合,映射在數據關系層面的含義是什麼

序列：可通過偏移量來進行切片的對象。列表、元組、字元串都屬於序列。

散列：無法通過偏移量來進行切片的對象。比如集合、字典。

Python內置的一種數據類型是列表：list。list是一種有序的集合，可以隨時添加和刪除其中的元素。

比如，列出班裡所有同學的名字，就可以用一個list表示：

>>> classmates = ['Michael', 'Bob', 'Tracy']

>>> classmates

['Michael', 'Bob', 'Tracy']

另一種有序列表叫元組：tuple。tuple和list非常類似，但是tuple一旦初始化就不能修改，比如同樣是列出同學的名字：

>>> classmates = ('Michael', 'Bob', 'Tracy')

(2)python集合概念擴展閱讀：

Python的表達式寫法與C/C++類似。只是在某些寫法有所差別。

主要的算術運算符與C/C++類似。+, -, *, /, //, **, ~, %分別表示加法或者取正、減法或者取負、乘法、除法、整除、乘方、取補、取余。>>, <<表示右移和左移。&, |, ^表示二進制的AND, OR, XOR運算。>, <, ==, !=, <=, >=用於比較兩個表達式的值，分別表示大於、小於、等於、不等於、小於等於、大於等於。在這些運算符裡面，~, |, ^, &, <<, >>必須應用於整數。

Python使用and, or, not表示邏輯運算。

is, is not用於比較兩個變數是否是同一個對象。in, not in用於判斷一個對象是否屬於另外一個對象。

C. python數據類型（集合）

    1.集合（set）是一個無序不重復元素的序列(意思是有重復的會自動刪除,每次列印元素的位置不一定)

2.基本功能是進行成員關系測試和刪除重復元素

3.可以使用大括弧 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典

4.因為set存儲的是無序集合，所以我們沒法通過索引來訪問。訪問 set中的某個元素實際上就是判斷一個元素是否在set中。

1.創建集合

s=set()#創建一個空集合

s1={1,2,3,'a','python'}

2.刪除重復的元素

集合是一個無序不重復元素的序列(意思是有重復的會自動刪除,每次列印元素的位置不一定)

3.成員關系測試(檢測某個成員是否在集合中)

案例:從終端輸入5位數,以空格隔開,把這5位數存入列表中,剔除重復的數據,列印出來

#提示,列表轉集合,集合轉列表

a=input("請輸入5位數字:")

mylist=a.split()

print(mylist)

b=set(mylist)

c=list(b)

print(c)

4.集合常用操作

1.添加元素

2.刪除元素

3.刪除整個集合

4.獲取集合的長度

5.不支持改元素

集合操作-添加元素

格式:

集合.add(元素)

格式:

集合.update(元素)

區別:

add不能添加列表,update可以

update是將字元串中的拆分成字元進行追加

add，是當做整體追加在集合中

#案例:從終端輸入一個數字就加入集合中,然後列印,又輸入一個數字,然後列印,直到輸入-1,退出輸入

#然後列印最終的集合

ms=set()

while 1:

a=int(input("請輸入一個數字:"))

if a==-1:

    break

ms.add(a)

print(ms)

print(ms)

#案例:從終端輸入一個字元串就加入集合中,然後列印,又輸入一個字元串,然後列印,直到輸入q,退出輸入

#然後列印最終的集合,字元串要分開存儲,如輸入hello,存儲的列表是{'h','e','l','0'}

ms=set()

while 1:

a=input("請輸入一個字元串:")

if a=='q':

    break

ms.update(a)

print(ms)

print(ms)

集合操作-刪除元素及刪除整個集合

格式:

集合.remove(元素) # 元素如果不存在會引發KeyError

集合.discard(元素) # 元素如果不存在不發生任何事

集合.pop() # 集合元素是字元串類型時刪除隨機元素。集合元素是其他數據類型時，刪除左邊第一個元素

del 集合名 #刪除整個集合

#案例:有集合{1,2,3,'hello','world'},刪除全部字元串,然後最左邊第一個元素

a={1,2,3,'hello','world'}

a.discard("hello")

a.discard("world")

a.pop()

print(a)

集合操作-獲取集合的長度

格式:

len(集合名)

#案例:有集合{1,2,3,4,'hello','a'},保留1個元素,其他的刪除,假如元素個數不確定

s={1,2,3,4,'hello','a'}

for i in range(len(s)-1):

            s.pop()

print(s)

集合的集運算

集合的交集,並集,差集,對稱差集的運算

{1,2,3,4}交集{4,5,6,7} -->4 交集(&)

{1,2,3,4}並集{4,5,6,7} ->1,2,3,4,5,6,7 並集(|)

{1,2,3,4}差集{4,5,6,7} ->1,2,3 差集(-)

{1,2,3,4}對稱差集{4,5,6,7}->1,2,3,5,6,7 4同時出現在兩個集合中,不選它對稱差集(^)

#案例:使用花括弧和set創建各一個集合,然後對集合進行交、並、差、對稱差運算

s={1,2,3,4,5,6}

s1=set([6,7,8,9,10])

print(s&s1)

print(s|s1)

print(s-s1)

print(s^s1)

D. python基礎-列表元組集合字典區別和用法

Python中有六個標準的數據類型：Number(數字)，String(字元串)，List(列表)，Tuple(元組)，Set(集合)，Dictionary(字典)。其中：Number(數字）、String(字元串)、Tuple（元組）是不可變數據，其餘三種是可變數據。

轉義字元

輸出結果

布爾值
布爾值是一個邏輯值，只有真(True)和假（False)

輸出結果

Python數據結構包括列表(list)、元組(tuple)、集合(set)、字典(dict)等，這里主要講解列表，列表有兩個特點：

輸出結果

修改表中元素

輸出結果

列表中插入元素

輸出結果

輸出列表中的元素

輸出結果

元素是否在列表元素中及統計個數

輸出結果

查找某個元素在列表中的位置

輸出結果

順序結構

輸出結果

if 條件 1

輸出結果

if 條件 2

輸出結果

循環結構

輸出結果

循環語句求和

輸出結果

可重復，類型可不同。 類型不同也是跟數組最本質的區別。 python里的列表用「[]」表示：

對比a和b的結果

列表的 --- 增 -- 刪 -- 改 -- 查

循環輸出列表內容，在結尾添加指定的內容

字元串是 Python 中最常用的數據類型。 我們可以使用引號('或")來創建字元串。

元組與列表相似，不一樣之處在於 元組的元素不能修改。
元組使用小括弧，列表使用方括弧。
元組建立很簡單，只須要在括弧中添加元素，並使用逗號隔開便可。

字典是另外一種可變容器模型，且可存儲任意類型對象。
字典的每一個鍵值(key=>value)對用冒號(:)分割，每一個對之間用逗號(,)分割，整個字典包括在花括弧({})中 ,格式以下所示：
d = {key1 : value1, key2 : value2 }

字典函數

集合（set）是一個 無序的不重復元素序列。
可使用大括弧 { } 或者 set() 函數建立集合，注意：建立一個空集合必須用 set() 而不是 { }，由於 { } 是用來建立一個空字典。
它的主要做用以下： 1.去重，把一個列表變成集合，就自動去重了 。2.關系測試，測試兩組數據以前的交集、差集、並集等關系。

關系測試

輸出結果

元素的添加和刪除

E. python集合

*事先說明：以下代碼及結果來自本設備Python控制台，在不同設備上可能結果有區別，望自己嘗試為妙

集合（set），是一種Python里的類（class），

集合類似於列表（list），可更改，可迭代（iterable），但是元素不重復

定義集合使用花括弧{}，例如：

>>> s = {"apple", "banana", "strawberry", "watermelon"}

警告！！！如果使用空括弧

>>> a = {}

>>> a.__class__

<class 'dict'>

a將成為一個字典

想要定義空集合，

請使用類名。

>>> a = set()

類名定義也可以把迭代轉換為集合：

>>> b = set("abc")

>>> b

{'a', 'b', 'c'}

但是，保存後它是無序的。

>>> s

{'banana', 'watermelon', 'strawberry', 'apple'}

（結果僅供參考，在不同設備上略有不同）

下面介紹它的性質：

1. 可更改：

使用add(x)方法添加元素x：

>>> s.add("lemon")

>>> s

{'banana', 'strawberry', 'lemon', 'watermelon', 'apple'}

使用update(iter1, iter2, …)方法添加多個可迭代對象（如列表，元組（tuple），另一個集合）里的元素：

>>> s.update(("orange", "grape"))

>>> s

{'banana', 'strawberry', 'orange', 'lemon', 'watermelon', 'apple', 'grape'}

警告！！！如果使用字元串，字元串也會被迭代：

>>> a = set()

>>> a.update("apple")

>>> a

{'a', 'p', 'e', 'l'}

使用remove(x)移除元素x，如果x不存在，則拋出KeyError錯誤

>>> s.remove("lemon")

>>> s

{'banana', 'strawberry', 'orange', 'watermelon', 'apple', 'grape'}

>>> s.remove("cat")

Traceback (most recent call last):

File "<stdin>", line 1, in <mole>

s.remove("cat")

KeyError: 'cat'

使用discard(x)移除元素x，不會發生錯誤

>>> s.discard("grape")

>>> s

{'banana', 'strawberry', 'orange', 'watermelon', 'apple'}

>>> s.discard("dog")

>>> s

{'banana', 'strawberry', 'orange', 'watermelon', 'apple'}

2. 可迭代：

>>> for x in s:

... print(x)

banana

strawberry

orange

watermelon

apple

3. 可以使用 len 函數獲取集合長度；

>>> len(s)

可以使用in關鍵字檢查一個元素是否在集合內，將返回邏輯值（bool）：

>>> "apple" in s

True

>>> "candy" in s

False

4.集合具有不重復性，因此它會自動去重：

>>> c = set("Hello World!")

>>> c

{' ', 'e', 'l', 'H', '!', 'r', 'W', 'o', 'd'}

5. 集合的運算

>>> d = set("abcdef")

>>> e = set("efghij")

>>> d

{'c', 'e', 'a', 'b', 'f', 'd'}

>>> e

{'h', 'e', 'g', 'j', 'f', 'i'}

>>> d - e # 集合d去掉集合e含有的元素，或者說集合d包含而集合e不包含的元素（不改變原集合）

{'a', 'b', 'd', 'c'}

>>> d | e # 集合d,e的所有元素

{'c', 'e', 'h', 'g', 'a', 'b', 'j', 'f', 'd', 'i'}

>>> d & e # 集合d,e都包含的元素

{'f', 'e'}

>>> d ^ e # 不同時出現在集合d, e中的元素

{'c', 'g', 'h', 'a', 'b', 'j', 'd', 'i'}

注意！！！

字元串、列表通用的+和*不適用於集合

>>> "abc" + "def"

'abcdef'

>>> [1, 2, 3] + [4, 5, 6]

[1, 2, 3, 4, 5, 6]

>>> d + e

Traceback (most recent call last):

File "<stdin>", line 1, in <mole>

d + e

TypeError: unsupported operand type(s) for +: 'set' and 'set'

>>> "a" * 5

'aaaaa'

>>> [1] * 3

[1, 1, 1]

>>> d*3

Traceback (most recent call last):

File "<stdin>", line 1, in <mole>

d * 2

TypeError: unsupported operand type(s) for *: 'set' and 'int'

(作者的小觀點：既然集合是不能重復的，那麼乘以、重復是沒有意義的)

F. Python的集合有哪些操作

集合是一個無序的，不重復的數據組合，它有著兩個主要作用：去重以及關系測試。去重指的是當把一個列表變成了集合，其中重復的內容就自動的被去掉了
關系測試指的是，測試兩組數據之間的交集、差集、並集等關系。
去重測試代碼如下：
#創建一個列表--裡面存在一些重復值
test_list = [1,2,3,4,2,2,3,4,3,2,3,4]
#利用集合將列表中重復的內容去掉
test_list = set(test_list)
#列印測試並且查看test_list被賦予新值後的數據類型print(test_list,type(test_list)) # {1, 2, 3, 4}
Tip：需要注意的是，集合和字典一樣都是無序的。
獲取交集需要使用集合中的方法intersection方法，獲取兩個集合中的交集代碼如下：
#創建兩個集合，並且獲取集合的交集
test_list_01 = set(['YanYan','LiBai','LuLu','YangMi'])
test_list_02 = set(['YanYan','LiuDeHua','ZhangXueYou','LiBai'])
#在上面的兩個集合中，存在相同的值，那麼現在我們取出兩個集合中的交集
test_intersection = test_list_01.intersection(test_list_02)print(test_intersection) # {'YanYan', 'LiBai'}
獲取並集的方式需要採用集合中union方法，獲取兩個集合的並集代碼如下：
#創建兩個集合，並且獲取集合的交集
test_list_01 =set(['YanYan','LiBai','LuLu','YangMi'])
test_list_02 =set(['YanYan','LiuDeHua','ZhangXueYou','LiBai'])
#採用集合中的union方法獲取並集
test_list_union = test_list_01.union(test_list_02)
print(test_list_union) # {'LiBai', 'LuLu', 'ZhangXueYou', 'LiuDeHua', 'YangMi', 'YanYan'}
獲取差集的方式要採用集合中的difference方法，獲取兩個集合的差集的代碼如下所示：
#創建兩個集合，並且獲取集合的交集
test_list_01 = set(['YanYan','LiBai','LuLu','YangMi'])
test_list_02 = set(['YanYan','LiuDeHua','ZhangXueYou','LiBai'])
#使用集合中的difference方法來獲取差集
test_difference = test_list_01.difference(test_list_02)
test_difference2 = test_list_02.difference(test_list_01)
print(test_difference) # {'LuLu', 'YangMi'}print(test_difference2) # {'ZhangXueYou', 'LiuDeHua'}
判斷一個集合是否是另外一個集合的子集可以使用issubset()方法，同樣，還可以使用issuperset()方法判斷一個集合是否是另外一個集合的父級
代碼如下：
#創建兩個集合
list_set = set([1,2,3,4])
list_son = set([2,3])
#判斷list_son是否是list_set的子集print(list_son.issubset(list_set)) # True#判斷list_set是否是list_son的父級print(list_set.issuperset(list_son)) # True
對稱差集(又有人稱之為叫做反向差集)，指的是取出兩個集合中互相都沒有的值取出放在一個集合中。
代碼如下：
#創建兩個集合
list_set_num1 = set([1,3,5,7,9])
list_set_num2 = set([2,3,4,6,9,10])
#獲取兩個集合的對稱差集print(list_set_num1.symmetric_difference(list_set_num2)) # {1, 2, 4, 5, 6, 7, 10}
如果上述的難以理解的話，可以對對稱差集理解為去掉兩個集合中都存在的內容，將剩餘的內容取到一個新的集合中。
除了上述的這些方法實現的關系功能之外，還有一個方法isdisjoint()，功能是判斷兩個集合中是否有相同的值，如果兩個集合中沒有相同的值(即沒有交集)，那麼返回True
代碼如下：
#創建集合
test_set_num1 = set([1,2,3,4])
test_set_num2 = set([5,6,7,8])
test_set_num3 = set([1,3,7,8])
#使用isdisjoint()方法來判斷print(test_set_num1.isdisjoint(test_set_num2)) # Trueprint(test_set_num1.isdisjoint(test_set_num3)) # False
通過運算符來進行關系測試
在上面的應用中，主要是通過python中的方法進行的關系測試，那麼在python中，除了使用方法以外，還可以使用關系運算符來進行關系測試。
實例代碼如下：
test_list_01 =set(['YanYan','LiBai','LuLu','YangMi'])
test_list_02 =set(['YanYan','LiuDeHua','ZhangXueYou','LiBai'])
#獲取交集&print(test_list_01 & test_list_02) # {'LiBai', 'YanYan'}
#獲取並集|print(test_list_01 | test_list_02) # {'LuLu', 'LiBai', 'LiuDeHua', 'YanYan', 'ZhangXueYou', 'YangMi'}
#獲取差集-print(test_list_01 - test_list_02) # {'LuLu', 'YangMi'}print(test_list_02 - test_list_01) # {'LiuDeHua', 'ZhangXueYou'}
#獲取對稱差集print(test_list_01 ^ test_list_02) # {'ZhangXueYou', 'YangMi', 'LuLu', 'LiuDeHua'}
集合的增刪改查
添加
語法：Set.add()
代碼如下：
#創建一個集合
test_set =set(['YanYan'])
#添加
test_set.add('LiBai') #添加一項
test_set.update(['LuLu','JingJing']) #一次性向集合中添加多項
#輸出集合
print(test_set) #{'YanYan', 'LuLu', 'LiBai', 'JingJing'}
刪除
刪除集合中的某一個元素可以使用remove方法
代碼如下：
#創建一個集合
test_set = set(['YanYan'])
#使用remove方法刪除元素
test_set.remove('YanYan')print(test_set) # set()
刪除項目除了使用remove以外，還可以使用pop()方法，但是pop()方法刪除內容不能夠指定，只是隨機刪除。
pop方法會把刪除的內容返回，示例代碼如下：
#創建一個集合
test_set = set([20,9,'a',1,2,3,4])print(test_set.pop()) # 1print(test_set.pop()) # 2print(test_set.pop()) # 3
刪除元素還可以使用discard()方法，這個方法沒有返回值，如果列印返回值的話會輸出None
#創建一個集合
test_list = set([1,2,3,4,5])
#使用discard()方法刪除--注意，discard()方法刪除返回None，也就是沒有返回值print(test_list.discard(3)) # None#此時原集合中的3已經被刪除了print(test_list) # {1, 2, 4, 5}
查詢
xins #判斷x是否是s的成員
xnotins 判斷x是否是s的成員
len(x) #查看x的長度
s <= t #測試是否s中的每一個元素都在t中
s >= t #測試是否t中的每一個元素都在s中

G. python中集合的特點和注意點

1、集合概念

Python中的集合，是一個無序的、沒有重復項的集。它支持數學概念上的集合操作，如交集、並集、補集和差集。集合是可變的，可以在其中添加或刪除項。集合用花括弧「{}」括起來，並用逗號「,」來分隔其中的項。

2、創建集合

可以使用花括弧「{}」創建集合，集合會自動去除重復的項。下面的集合包含了幾種用字元串表示的水果：

>>>#創建fruits集合時，'apple'出現了兩次
>>>fruits={'apple','banana','watermelon','strawberry','apple'}
>>>fruits#查看fruits集合，'apple'只有保留了一個
{'apple','strawberry','banana','watermelon'}

與列表、元組、字典一樣，集合也可以用工廠函數set()來創建。set()函數的參數要麼為空，要麼為可迭代對象(如列表、元組和字元串)：

>>>fruits=set(['apple','banana','watermelon','strawberry','apple'])#以列表為參數創建集合
>>>fruits
{'apple','strawberry','banana','watermelon'}
>>>numbers=set((1,2,3,3,2,4))#以元組為參數創建集合
>>>numbers
{1,2,3,4}
>>>letters=set('banana')#以字元串為參數創建集合
>>>letters
{'b','a','n'}

如果想要創建一個空集合，那麼使用空的花括弧「{}」是行不通的，因為這樣創建的是一個空字典：

>>>empty={}
>>>empty
{}
>>>type(empty)
<class'dict'>

創建空集合的唯一方式就是使用不包含任何參數的set()函數：

>>>empty=set()
>>>empty#空集合表示為set()
set()
>>>type(empty)
<class'set'>

3、集合添加項

集合是可變的數據類型，在創建集合之後，可以使用集合的add()方法向其添加項：

>>>numbers={1,2,3}
>>>numbers.add(4)#向numbers集合中添加整數4
>>>numbers
{1,2,3,4}
>>>numbers.add('five')#向numbers集合中添加字元串'five'
>>>numbers
{1,2,3,4,'five'}
>>>numbers.add((5,6,7))#向numbers集合中添加元組(5,6,7)
>>>numbers
{1,2,3,4,(5,6,7),'five'}

如果向某個集合中添加已經存在的項，那麼什麼也不會發生：

>>>fruits={'apple','strawberry','banana','watermelon'}
>>>fruits
{'banana','apple','watermelon','strawberry'}
>>>fruits.add('apple')#添加已經存在的項'apple'
>>>fruits#fruits集合並沒有改變
{'banana','apple','watermelon','strawberry'}

也可以使用集合的update()方法向集合中添加項，參數必須是可迭代對象，如列表、字元串或另一個集合。類似於列表的append()方法和extend()方法，但區別是集合的update()方法總是會將可迭代對象「展開」：

>>>numbers={1}
>>>numbers
{1}
>>>numbers.update((5,6,7))
>>>numbers#可以看出update()方法和add()方法的區別
{1,5,6,7}
>>>numbers.update({4,5},{6,7,8})#參數為兩個集合
>>>numbers
{1,4,5,6,7,8}

4、集合刪除項

可以使用集合的remove()方法刪除某個集合中的指定項：

>>>numbers={1,2,3,5,7}
>>>numbers.remove(1)
>>>numbers
{2,3,5,7}
>>>numbers.remove(3)
>>>numbers
{2,5,7}

如果試圖刪除集合中不存在的項，那麼Python解釋器會報錯：

>>>numbers={1,2,3,5,7}
>>>numbers.remove(4)
Traceback(mostrecentcalllast):
File"<stdin>",line1,in<mole>
KeyError:4

還可以使用集合的discard()方法來刪除項，它和remove()方法唯一的區別是，當試圖刪除不存在的項時，discard()方法並不會報錯，而是什麼也不會發生：

>>>numbers={1,2,3,5,7}
>>>numbers.discard(1)
>>>numbers
{2,3,5,7}
>>>numbers.discard(3)
>>>numbers
{2,5,7}
>>>numbers.discard(4)
>>>numbers#什麼也沒發生
{2,5,7}

5、檢查某個項是否在集合中

集合的in操作符用於檢查指定項是否在集合中，not in操作符用於檢查指定項是否不在集合中：

>>>numbers={1,2,3,5,7}
>>>1innumbers#1在numbers集合中，返回True
True
>>>3innumbers#3在numbers集合中，返回True
True
>>>4innumbers#4不在numbers集合中，返回False
False
>>>4notinnumbers#notin是in的反向操作
True

6、查看集合的長度

集合的內建函數len()用於查看集合的長度，即集合中項的個數：

>>>empty=set()
>>>len(empty)
0
>>>numbers={1,2,3,5,7}
>>>len(numbers)
5

H. Python精講：Python中集合的交集並集差集和對稱差集運算方法詳解

歡迎你來到站長在線的站長學堂學習Python知識，本文學習的是《Python中集合的交集、並集、差集和對稱差集運算方法詳解》。主要講的是集合運算的相關的概念，及運算方法，包括：集合的交集、集合的並集、集合的差集、集合的對稱差集、集合的交集運算方法、集合的並集運算方法、集合的差集運算方法、集合的對稱差集運算方法。

在Python中，集合最常用的操作就是進行交集、並集、差集和對稱差集的運算。

要想學習集合的交集、並集、差集和對稱差集運算方法，首先我們來了解這些名詞的含義：

設A、B兩個集合，由所有屬於集合A且屬於集合B的元素所組成的集合，叫做集合A與集合B的交集。在Python中，進行交集運算時使用「&」符號。

給定兩個集合A、B，把他們所有的元素合並在一起組成的集合，叫做集合A與集合B的並集。在Python中，進行並集運算時使用「|」符號。

設A，B是兩個集合，則所有屬於A且不屬於B的元素構成的集合，叫做集合A與集合B的差集。在Python中，進行差集運算時使用「-」符號。

對稱差集也稱為對稱差分或者補集，設A，B是兩個集合，所有不相同的集合，叫做集合A與集合B的對稱差集（對稱差分或者補集）。在Python中，進行對稱差集運算時使用「^」符號。

上面都是概念性的描述，下面站長在線來舉實際的場景來對交集、並集、差集和對稱差集運算方法進行深入淺出的解讀。

場景模擬：某高中三年級，文科班高考的科目是語文、數學、英語、政治、歷史和地理。理科班高考的科目是語文、數學、英語、物理、化學和生物。

設定集合A為文科班高考的科目，集合B為理科班高考的科目。

A = {'語文','數學','英語','政治',' 歷史 ','地理'}

B = {'語文','數學','英語','物理','化學','生物'}

我們使用集合的交集運算的時候可以採用兩種方式，一種是使用「&」運算符進行操作，另一種是使用 intersection() 方法來實現。

運行結果：

運行結果：

同理集合B和集合A的交集也是一樣。我這里就不重復了，自己去體驗一下。

集合的並集運算也有兩種方式，一種是使用「|」運算符進行操作，另一種是使用union()方法來實現。

運行結果如下：

運行結果為：

同理集合B和集合A的並集也是一樣。自己去體驗一下吧！

集合的差集運算也有兩種方式，一種是使用「-」運算符進行操作，另一種是使用difference()方法來實現。

運行結果為：

上面是集合A和集合B的差集，但是集合B和集合A的差集就不是一樣的了哦！

運行結果為：

從上面可以看出，集合A和集合B的差集與集合B和集合A的差集是不一樣的，(A - B)是A中存在的部分，(B - A)是B中存在的部分。

運行結果：

同理，使用difference()方法進行集合B和集合A的差集也是不同的

運行結果：

集合的差集運算也有兩種方式，一種是使用「^」運算符進行操作，另一種是使用symmetric_difference()方法來實現。

運行結果為：

運行結果為：

同樣的，集合B與集合A的對稱差集也是一樣，自己去體驗一下。

我們對集合的交集、並集、差集和對稱差集運算方法全部詳細的講解了一遍，通過運行結果，我們得出結論：

集合中進行交集、並集、對稱差集進行運算的時候，集合A與集合B，位置替換的時候，結果相同。

集合中進行差集運算的時候，集合A與集合B，位置替換的時候，結果不同，為前面那個集合獨立存在的部分。

到此為止，本節課的內容《Python中集合的交集、並集、差集和對稱差集運算方法詳解》就完全講完了，主要講的集合運算的相關的概念，及運算方法，包括：集合的交集、集合的並集、集合的差集、集合的對稱差集、集合的交集運算方法、集合的並集運算方法、集合的差集運算方法、集合的對稱差集運算方法。

導航:首頁 > 編程語言 > python集合概念

python集合概念

與python集合概念相關的資料