python集合
A. python如何刪除集合
集合刪除操作方法：remove
set(['y', 'python', 'b', 'o'])
>>> a.remove('python')
>>> a
set(['y', 'b', 'o'])
B. Python列表，元組，集合，字典的區別和相互轉
列表是一組值，其中的值可以改變
元組也是一組值，其中的值不能改變
列表與元組可以相互轉換
集合是一組唯一的無順序的值
字典是無固定順序的鍵值對
C. python集合的定義方式
集合的定義
格式：集合名 = {元素1，元素2，...}
例：my_set = {1, 3, 5}
集合是無序的-> 不支持下標索引
集合是可變的數據類型
集合中的元素是唯一的
集合一般用於元組或者列表中的元素去重
定義一個空的集合 my_set = set()
D. 關於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}
E. python集合元素可以是列表嗎
python集合元素可以是列表嗎
集合中元素的數據類型可以不同，但集合中不能嵌套列表、元組、集合、字典
Takoony
.集合（set）的定義
集合（set）是一個無序的不重復元素序列
可以使用大括弧 { } 或者 set( ) 函數創建集合
注意：創建一個空集合必須用 set( ) 而不是 { }，因為 { } 是用來創建一個空字典
集合滿足的三個條件
1.不同元素組成
2.無序
3.集合中的元素必須是不可變類型
因為集合的元素類型只能是不可變數據類型，如整數，浮點數，字元串，元組等（列表，字典，集合類型本身都是可變數據類型，不能做集合的元素出現）
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集合裡面嵌套集合怎麼去出集合裡面的內容
本文實例講述了python判斷一個集合是否包含了另外一個集合中所有項的方法。分享給大家供大家參考。具體如下：
?
1
2
3
4
5
6
>>> L1 = [1, 2, 3, 3]
>>> L2 = [1, 2, 3, 4]
>>> set(L1).difference(L2)
set([ ])
>>> set(L2).difference(L1)
set([4])
H. python集合的作用有哪些
集合可以像元組一樣，設置不可改變的類型;也可以默認像字典，列表一樣，可以迭代改變;同時集合里的元素可以是列表，元組，字典。
1、python集合的作用——創建字典
可使用大括弧 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。
>>> my_set = set(('apple',))
>>> my_set
{'apple'}
2、python集合的作用——添加元素(add(),update())
# add 作為一個整體添加到集合中
my_set = set()
my_set.add("abc")
print(my_set)
#update 是把要傳入的元素拆分，做為個體傳入到集合中
my_set = set()
my_set.update("abc")
print(my_set)
3、python集合的作用——刪除元素(remove()，pop()，discard())
#remove 如果集合種有，則直接刪除;如果沒有，程序報錯 格式：集合名.remove(元素)
my_set = {11, 13, 15}
my_set.remove(13)
print(my_set) my_set.remove(131)
print(my_set)
#pop 隨機刪除集合中的元素 如果集合中沒有元素則程序報錯
my_set = {11, 13, 15}
my_set.pop()
print(my_set)
#discard 如果集合中元素存在，直接刪除; 如果元素不存在 不做任何操作 格式: 集合名.discard(元素)
my_set = {11, 13, 15}
my_set.discard(13)
print(my_set)
my_set.discard(131)
print(my_set)
4、python集合的作用——交集( & )
set1 = {9, 2, 3, 4}
set2 = {3, 4, 5, 16}
new_set = set1 & set2
print(new_set)
# result {3, 4}
5、python集合的作用——並集( | )
set1 = {1, 2, 3, 4}
set2 = {3, 5, 5, 6}[page]
new_set = set1 | set2
print(new_set)
# result {1, 2, 3, 4, 5, 6}
6、python集合的作用——差集(-)
項在前一個集合中，但不在後一個集合中。
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
new_set = set1 - set2
print(new_set)
# result {1, 2}
7、python集合的作用——對稱差集( ^ )
即項在前一個集合或後一個集合中，但不會同時出現在二者中。即交集減去並集。
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
new_set = set1 ^ set2
print(new_set)
# result {1,2,5,6}
8、python集合的作用——子集判斷
set1 = { 3, 4}
set2 = {3, 4, 5, 6}
# 判斷set1是否是set2的子集
print(set1.issubset(set2))
# result True
9、python集合的作用——父集判斷
set1 = { 3, 4}
set2 = {3, 4, 5, 6}
# 判斷set1是否是set2的父集
print(set1.issuperset(set2))
# result False
10、python集合的作用——迭代和枚舉
s={34,56,76,34,56,54,43,23,56}
for i in s:
print(i) ##迭代輸出其內容
for i,v in enumerate(s):
print('index: %s,value: %s' %(i,v))
"""
result:
index: 0,value: 34
index: 1,value: 43
index: 2,value: 76
index: 3,value: 54
index: 4,value: 23
index: 5,value: 56
"""
可觀察出，集合會自動過濾掉相同元素。
python集合的作用都有哪些？原來這些功能才是最實用的，集合可以像元組一樣，設置不可改變的類型;也可以默認像字典，列表一樣，可以迭代改變;同時集合里的元素可以是列表，元組，字典，你能處理好嗎?如果您還擔心自己入門不順利，可以點擊本站的其他文章進行學習。
I. python中集合的特點和注意點
1、集合概念
Python中的集合，是一個無序的、沒有重復項的集。它支持數學概念上的集合操作，如交集、並集、補集和差集。集合是可變的，可以在其中添加或刪除項。集合用花括弧「{}」括起來，並用逗號「,」來分隔其中的項。
2、創建集合
可以使用花括弧「{}」創建集合，集合會自動去除重復的項。下面的集合包含了幾種用字元串表示的水果：
>>>#創建fruits集合時，'apple'出現了兩次
>>>fruits={'apple','banana','watermelon','strawberry','apple'}
>>>fruits#查看fruits集合，'apple'只有保留了一個
{'apple','strawberry','banana','watermelon'}
>>>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'>
>>>empty=set()
>>>empty#空集合表示為set()
set()
>>>type(empty)
<class'set'>
>>>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'}
>>>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}
>>>numbers={1,2,3,5,7}
>>>numbers.remove(1)
>>>numbers
{2,3,5,7}
>>>numbers.remove(3)
>>>numbers
{2,5,7}
>>>numbers={1,2,3,5,7}
>>>numbers.remove(4)
Traceback(mostrecentcalllast):
File"<stdin>",line1,in<mole>
KeyError:4
>>>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}
>>>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
>>>empty=set()
>>>len(empty)
0
>>>numbers={1,2,3,5,7}
>>>len(numbers)
5
與列表、元組、字典一樣，集合也可以用工廠函數set()來創建。set()函數的參數要麼為空，要麼為可迭代對象(如列表、元組和字元串)：
如果想要創建一個空集合，那麼使用空的花括弧「{}」是行不通的，因為這樣創建的是一個空字典：
創建空集合的唯一方式就是使用不包含任何參數的set()函數：
3、集合添加項
集合是可變的數據類型，在創建集合之後，可以使用集合的add()方法向其添加項：
如果向某個集合中添加已經存在的項，那麼什麼也不會發生：
也可以使用集合的update()方法向集合中添加項，參數必須是可迭代對象，如列表、字元串或另一個集合。類似於列表的append()方法和extend()方法，但區別是集合的update()方法總是會將可迭代對象「展開」：
4、集合刪除項
可以使用集合的remove()方法刪除某個集合中的指定項：
如果試圖刪除集合中不存在的項，那麼Python解釋器會報錯：
還可以使用集合的discard()方法來刪除項，它和remove()方法唯一的區別是，當試圖刪除不存在的項時，discard()方法並不會報錯，而是什麼也不會發生：
5、檢查某個項是否在集合中
集合的in操作符用於檢查指定項是否在集合中，not in操作符用於檢查指定項是否不在集合中：
6、查看集合的長度
集合的內建函數len()用於查看集合的長度，即集合中項的個數：
J. 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'
(作者的小觀點：既然集合是不能重復的，那麼乘以、重復是沒有意義的)