Ⅰ python中創建集合的方法有哪些呢
集合分為兩種：可變集合（set）和不可變集合（frozenset），現在學習的是可變集合。
在Python中，有關於集合的操作主要有：集合的創建；集合的添加和刪除；集合的交、並和差集運算。
今天先來學習如何創建集合。
集合的創建有兩種方法：直接賦值法和set()函數法。
1、直接賦值法
和Python的其它序列一樣，採用直接賦值法就可以直接創建一個集合，具體語法格式如下：
setname = {「element1」,「element2」,「element3」,……,「elementn」,}
從格式上看，和其它的序列創建方法基本一樣，就是集合名setname直接使用賦值運算符等號「=」賦值，等號後面的元素內容使用英文半形的大括弧「{ }」括起來，各個元素之間依然使用英文半形的逗號「,」分隔。
這里雖然和字典一樣使用大括弧「{ }」，但是只要記住字典的元素是由鍵值對組成的（詳見前第62節內容），就完全可以區分所創建的是字典還是集合了。
Ⅱ 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中
Ⅲ 關於python集合運算
差集 a-b 從集合a中去除所有在集合b中出現的元素集合
並集 a|b 集合a,b中所有不重復的元素集合
交集 a&b 集合a,b中均出現的元素集合
如 a={1,2,3,4} b={2,4,6,8} a集合中減去b中出現的2,4 a-b為{1,3}
a|b 為 {1,2,3,4,6,8} a&b為 a ，b中均出現的{2,4}
Ⅳ python兩個集合間的and作用是什麼
這個是兩個邏輯條件之間的判斷，跟集合沒關系。
在while 後面的，必須是一個True或者False的布爾表達式。
像這個，m和f都是集合，條件就是 當集合m和f 都不為空時，條件成立。
Ⅳ 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 字典
Ⅵ Python其實很簡單 第十章 字典與集合
前面介紹的列表和元組都是有序序列，而字典與集合屬於無序序列，也就是說，不能通過索引來操作元素。
10.1 字典
語法格式：
dictionary= {key1 : value1, key2 : value2, key3 : value3 ,...., key n : value n }
其中，dictionary是字典名稱，key表示元素的鍵，value表示元素的值，鍵和值必須是成對的。
如：
>>> dict1 = { 'abc': 123, 98.6: 37 }
>>> dict1
{'abc': 123, 98.6: 37}
可以看出，鍵可以是字元串、數字或者元組，但必須是唯一的；而值可以是任何數據類型，也沒有要求是唯一的。
1、創建字典的方法
方法一：同時給定鍵和值，即「關鍵字參數」形式。
dictionary=dict(key1=value1,key2=value2,.....,key n=value n)
注意：這里的key 必須符合Python標識符的命名規則。
例：
先使用「{}」創建字典：
>>> dict1={1:'一',2:'二',3:'三',4:'四',5:'五'}
>>> dict1
{1: '一', 2: '二', 3: '三', 4: '四', 5: '五'}
再通過「關鍵字參數」形式創建：
>>> dict1=dict(1='一',2='二',3='三',4='四',5='五')
SyntaxError: expression cannot contain assignment, perhaps you meant "=="?
創建不成功，原因在於key 不符合Python標識符的命名規則。前面已經介紹過，標識符不能用數字表示或者用數字打頭。
現在對鍵如下修改：
>>> dict1=dict(n1='一',n2='二',n3='三',n4='四',n5='五') #在數字前加了一個字元」n」
>>> dict1
{'n1': '一', 'n2': '二', 'n3': '三', 'n4': '四', 'n5': '五'}
方法二 ：使用已經存在的元組和列表通過映射函數創建字典。
格式：dictionary=dict(zip(tuplekey,listvalue))
例：
>>> tuplekey=('n1','n2','n3','n4','n5') #鍵的序列採用元組
>>> listvalue=['一','二','三','四','五'] #值的序列採用列表
>>> dict1=dict(zip(tuplekey,listvalue))
>>> dict1
{'n1': '一', 'n2': '二', 'n3': '三', 'n4': '四', 'n5': '五'}
注意：tuple(listname)函數可以將列表轉換為元組，list(tuplename)函數可以將元組轉換為列表。
2、通過鍵訪問字典
直接獲取鍵的相應元素的值
>>> dict1['n2']
'二'
利用get()方法
>>> dict1.get('n2')
'二'
get()方法也可以帶參數，當要訪問的鍵不存在時返回一個字元串。如：
>>> dict1.get('n0','can't find!') #當要查找的鍵不存在，返回'can't find!'
"can't find!"
3、遍歷字典
使用字典對象的items()方法可以獲取字典的「鍵.值對」列表。
>>> for item in dict1.items():
print(item)
('n1', '一')
('n2', '二')
('n3', '三')
('n4', '四')
('n5', '五')
也可以獲取具體的每個元素的鍵和值，如：
>>> for key,value in dict1.items():
print(key,'對應的是',value)
n1 對應的是 一
n2 對應的是 二
n3 對應的是 三
n4 對應的是 四
n5 對應的是 五
4、添加、修改和刪除字典元素
使用下面的語句，若指定的鍵存在，就可以修改該元素的值；若指定的鍵不存在，則添加該元素。如：
>>> dict1['n6']='六' # 鍵』n6』不存在，故添加該元素
>>> dict1
{'n1': '一', 'n2': '二', 'n3': '三', 'n4': '四', 'n5': '五', 'n6': '六'}
>>> dict1['n4']='肆' # 鍵』n4』存在，故修改該元素
>>> dict1
{'n1': '一', 'n2': '二', 'n3': '三', 'n4': '肆', 'n5': '五', 'n6': '六'}
5、利用推導式建立字典
import random
dict1={i:random.randint(1,100) for i in range(5)}
# 生成元素的鍵為0到5整數，值為1到100之間的隨機數
print(dict1)
運行結果：{0: 28, 1: 59, 2: 79, 3: 30, 4: 88}
10.2 集合
集合是數學中一個很重要的概念，集合具有確定性、互異性、無序性三個基本屬性。在Python中，集合同樣具有這三個基本屬性，其中，確定性是指對象要麼是集合的元素，要麼不是集合的元素；互異性是指集合中的元素不能重復；無序性是指集合中的元素不分先後次序，可以隨意更換位置。
1、集合的創建
直接使用「{}」創建
>>> set1={'春','夏','秋','冬'}
>>> set1
{'秋', '春', '冬', '夏'}
>>> set2={3,2,1,4,5}
>>> set2
{1, 2, 3, 4, 5}
利用已有的列表、元組創建集合
>>> list1=['東','南','西','北']
>>> set3=set(list1)
>>> set3
{'南', '東', '北', '西'}
利用已有的集合建立一個「副本」
>>> set3
{'南', '東', '北', '西'} #set3和set4的值一樣
>>> set4=set3
>>> set4
{'南', '東', '北', '西'}
>>> set4.add('中') #給set4添加元素
>>> set4
{'西', '中', '東', '南', '北'} # 這個好理解
>>> set3
{'西', '中', '東', '南', '北'} # 意想不到吧？Set3為什麼會發生變化？
再看看簡單變數的情況：
>>> a=2
>>> b=a #是不是與前面set4=set3相似
>>> b+=1
>>> b
3
>>> a
2 #但a的值並沒有發生改變
從上面集合set3、set4和簡單變數a、b的值的變化情況對比，不難發現set3和set4是指向同一地址的對象，而變數a和變數b指向了不同地址，語句b=a是將a的值傳遞個b，並不是將a的地址傳遞給b。列表、元組、字典都和集合一樣具有這樣的性質。
所以，將set4稱為set3的「副本」更為恰當。
2、添加和刪除元素
>>> set3
{'南', '東', '北', '西'}
>>> set3.add('中') # 添加元素
>>> set3
{'西', '中', '東', '南', '北'} # 集合內的元素是無序的，不要糾結次序的變化
>>> set3.remove('中') # 刪除元素
>>> set3
{'西', '東', '南', '北'}
3、集合運算
集合運算包括交(&)、並(|)、差(-)，和數學中的集合運算是一致的。
>>> set3={'南', '東', '北', '西'}
>>> set4={'西', '中', '東', '南', '北'}
>>> set3 & set4 #取set3和set4的交集
{'西', '南', '北', '東'}
>>> set3 | set4 #取set3和set4的並集
{'中', '南', '北', '西', '東'}
>>> set3 - set4 #取set3與set4的差，即set3比set4多出來的元素
set()
>>> set4 -set3 #取set4與set3的差，即set4比set3多出來的元素
{'中'}
Ⅶ python集合支持與整數的乘法運算嗎
可以的，python支持多重數學運算
可以將集合設置成數組的形式，例如
3*［1 2 3 4］
Ⅷ 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)
Ⅸ 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)
5
可以使用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'
(作者的小觀點：既然集合是不能重復的，那麼乘以、重復是沒有意義的)
Ⅹ 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中集合的交集、並集、差集和對稱差集運算方法詳解》就完全講完了，主要講的集合運算的相關的概念，及運算方法，包括：集合的交集、集合的並集、集合的差集、集合的對稱差集、集合的交集運算方法、集合的並集運算方法、集合的差集運算方法、集合的對稱差集運算方法。