『壹』 Python中內置數據類型list，tuple，dict，set的區別和用法
這篇文章主要給大家介紹了Python中內置數據類型list,tuple,dict,set的區別和用法，都是非常基礎的知識，十分的細致全面，有需要的小夥伴可以參考下。
Python語言簡潔明了，可以用較少的代碼實現同樣的功能。這其中Python的四個內置數據類型功不可沒，他們即是list, tuple, dict, set。這里對他們進行一個簡明的總結。
List
字面意思就是一個集合，在Python中List中的元素用中括弧[]來表示，可以這樣定義一個List:
L = [12, 'China', 19.998]
可以看到並不要求元素的類型都是一樣的。當然也可以定義一個空的List:
L = []
Python中的List是有序的，所以要訪問List的話顯然要通過序號來訪問，就像是數組的下標一樣，一樣是下標從0開始：
>>> print L[0]
12
千萬不要越界，否則會報錯
>>> print L[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
IndexError: list index out of range
List也可以倒序訪問，通過「倒數第x個」這樣的下標來表示序號，比如-1這個下標就表示倒數第一個元素：
>>> L = [12, 'China', 19.998]
>>> print L[-1]
19.998
-4的話顯然就越界了
>>> print L[-4]
Traceback (most recent call last):
File "<pyshell#2>", line 1, in <mole>
print L[-4]
IndexError: list index out of range
>>>
List通過內置的append()方法來添加到尾部，通過insert()方法添加到指定位置（下標從0開始）：
>>> L = [12, 'China', 19.998]
>>> L.append('Jack')
>>> print L
[12, 'China', 19.998, 'Jack']
>>> L.insert(1, 3.14)
>>> print L
[12, 3.14, 'China', 19.998, 'Jack']
>>>
通過pop()刪除最後尾部元素，也可以指定一參數刪除指定位置：
>>> L.pop()
'Jack'
>>> print L
[12, 3.14, 'China', 19.998]
>>> L.pop(0)
12
>>> print L
[3.14, 'China', 19.998]
也可以通過下標進行復制替換
>>> L[1] = 'America'
>>> print L
[3.14, 'America', 19.998]
Tuple
Tuple可以看做是一種「不變」的List，訪問也是通過下標，用小括弧（）表示：
>>> t = (3.14, 'China', 'Jason')
>>> print t
(3.14, 'China', 'Jason')
但是不能重新賦值替換：
>>> t[1] = 'America'
Traceback (most recent call last):
File "<pyshell#21>", line 1, in <mole>
t[1] = 'America'
TypeError: 'tuple' object does not support item assignment
也沒有pop和insert、append方法。
可以創建空元素的tuple:
t = ()
或者單元素tuple (比如加一個逗號防止和聲明一個整形歧義):
t = (3.14,)
那麼tuple這個類型到底有什麼用處呢？要知道如果你希望一個函數返回多個返回值，其實只要返回一個tuple就可以了，因為tuple裡面的含有多個值，而且是不可變的（就像是java裡面的final）。當然，tuple也是可變的，比如:
>>> t = (3.14, 'China', 'Jason', ['A', 'B'])
>>> print t
(3.14, 'China', 'Jason', ['A', 'B'])
>>> L = t[3]
>>> L[0] = 122
>>> L[1] = 233
>>> print t
(3.14, 'China', 'Jason', [122, 233])
這是因為Tuple所謂的不可變指的是指向的位置不可變，因為本例子中第四個元素並不是基本類型，而是一個List類型，所以t指向的該List的位置是不變的，但是List本身的內容是可以變化的，因為List本身在內存中的分配並不是連續的。
Dict
Dict是Python中非常重要的數據類型，就像它的字面意思一樣，它是個活字典，其實就是Key-Value鍵值對，類似於HashMap，可以用花括弧{}通過類似於定義一個C語言的結構體那樣去定義它：
>>> d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59,
'Paul': 75
}
>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}
可以看到列印出來的結果都是Key:Value的格式，可以通過len函數計算它的長度（List，tuple也可以）：
>>> len(d)
4
可以直接通過鍵值對方式添加dict中的元素：
>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}
>>> d['Jone'] = 99
>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jone': 99, 'Bart': 59}
List和Tuple用下標來訪問內容，而Dict用Key來訪問： (字元串、整型、浮點型和元組tuple都可以作為dict的key)
>>> print d['Adam']
95
如果Key不存在，會報錯：
>>> print d['Jack']
Traceback (most recent call last):
File "<pyshell#40>", line 1, in <mole>
print d['Jack']
KeyError: 'Jack'
所以訪問之前最好先查詢下key是否存在：
>>> if 'Adam' in d : print 'exist key'
exist key
或者直接用保險的get方法：
>>> print d.get('Adam')
95
>>> print d.get('Jason')
None
至於遍歷一個dict，實際上是在遍歷它的所有的Key的集合，然後用這個Key來獲得對應的Value:
>>> for key in d : print key, ':', d.get(key)
Lisa : 85
Paul : 75
Adam : 95
Bart : 59
Dict具有一些特點：
查找速度快。無論是10個還是10萬個，速度都是一樣的，但是代價是耗費的內存大。List相反，佔用內存小，但是查找速度慢。這就好比是數組和鏈表的區別，數組並不知道要開辟多少空間，所以往往開始就會開辟一個大空間，但是直接通過下標查找速度快；而鏈表佔用的空間小，但是查找的時候必須順序的遍歷導致速度很慢
沒有順序。Dict是無順序的，而List是有序的集合，所以不能用Dict來存儲有序集合
Key不可變，Value可變。一旦一個鍵值對加入dict後，它對應的key就不能再變了，但是Value是可以變化的。所以List不可以當做Dict的Key，但是可以作為Value:
>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jone': 99, 'Bart': 59}
>>> d['NewList'] = [12, 23, 'Jack']
>>> print d
{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 99, 'Lisa': 85, 'Paul': 75}
Key不可重復。（下面例子中添加了一個'Jone':0，但是實際上原來已經有'Jone'這個Key了，所以僅僅是改了原來的value）
>>> print d
{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 99, 'Lisa': 85, 'Paul': 75}
>>> d['Jone'] = 0
>>> print d
{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 0, 'Lisa': 85, 'Paul': 75}
Dict的合並，如何將兩個Dict合並為一個，可以用dict函數：
>>> d1 = {'mike':12, 'jack':19}
>>> d2 = {'jone':22, 'ivy':17}
>>> dMerge = dict(d1.items() + d2.items())
>>> print dMerge
{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}
或者
>>> dMerge2 = dict(d1, **d2)
>>> print dMerge2
{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}
方法2比方法1速度快很多，方法2等同於：
>>> dMerge3 = dict(d1)
>>> dMerge3.update(d2)
>>> print dMerge
{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}
set
set就像是把Dict中的key抽出來了一樣，類似於一個List，但是內容又不能重復，通過調用set()方法創建：
>>> s = set(['A', 'B', 'C'])
就像dict是無序的一樣，set也是無序的，也不能包含重復的元素。
對於訪問一個set的意義就僅僅在於查看某個元素是否在這個集合裡面：
>>> print 'A' in s
True
>>> print 'D' in s
False
大小寫是敏感的。
也通過for來遍歷：
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
#tuple
for x in s:
print x[0],':',x[1]
>>>
Lisa : 85
Adam : 95
Bart : 59
通過add和remove來添加、刪除元素（保持不重復），添加元素時，用set的add()方法：
>>> s = set([1, 2, 3])
>>> s.add(4)
>>> print s
set([1, 2, 3, 4])
如果添加的元素已經存在於set中，add()不會報錯，但是不會加進去了：
>>> s = set([1, 2, 3])
>>> s.add(3)
>>> print s
set([1, 2, 3])
刪除set中的元素時，用set的remove()方法：
>>> s = set([1, 2, 3, 4])
>>> s.remove(4)
>>> print s
set([1, 2, 3])
如果刪除的元素不存在set中，remove()會報錯：
>>> s = set([1, 2, 3])
>>> s.remove(4)
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
KeyError: 4
所以如果我們要判斷一個元素是否在一些不同的條件內符合，用set是最好的選擇，下面例子：
months = set(['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec',])
x1 = 'Feb'
x2 = 'Sun'
if x1 in months:
print 'x1: ok'
else:
print 'x1: error'
if x2 in months:
print 'x2: ok'
else:
print 'x2: error'
>>>
x1: ok
x2: error
『貳』 Python中的序列與集合
之前有說到 Python 中的字元串、列表以及元組在很多方面上比較相似，很大程度是因為它們的數據存儲是有序的，也就是我們統稱的序列，這才能讓我們通過序號進行數據的獲取，就像下面這樣。
既然已經有了個統稱，那麼必然它們可以有相同的特性，這里列舉了幾個常用的方法，針對有序序列都是通用的。
如圖可知這幾個方法的大體意思，在我們判斷一個元素是否存在於序列的時候會採取 in 或者not in 操作，返回值就是 bool 類型；使用 len 方法來獲取序列的長度，通過 max 和 min 來得到序列中的最大值和最小值。
不過這里有個需要提醒的就是在我們判斷字元串的極大值和極小值的時候，我們是通過 Ascll 碼來比較的，所謂的這個碼其實就是數值，我們通過 ord 方法可以得到字元串或者數字的Ascll 碼，然後再來比較得到極大值和極小值。（空字元串也是有 Ascll 碼的）
說了序列那麼多，我們現在進入正題哈，說說集合，一個有區別於序列的數據類型。
如圖所示，集合是由花括弧包裹的編寫形式，而且大體也擁有部分序列的特性，當然集合與序列最大的不同就是，集合是無序的，也就是說我們不能通過序號去得到相應的集合元素。那怎麼得到集合中的元素呢，這個之後再說，我們先來看集合的一些特性。
對比著圖中的輸出結果，可能有人大概猜到一些東西，這里介紹了三種運算符。首先看看我們的減號在集合中的意義，當一個集合減去另一個集合得到一個新集合，其實也就類似於刪除的感覺，在數學中我們叫做差集（不理解可以翻課本哈），在第一個集合中去除第二個集合中的元素，可能有人問，如果第二個集合更大怎麼說，那麼得到的就應該是空的集合，不理解的可以嘗試看看。
然後我們再來看 & 操作，它代表的意思是取出兩個集合中共同的元素組成的新集合，在數學中我們叫做交集，於此關於 | 操作，它代表的就是兩個集合的合並，在數學中叫做並集，而這里又涉及到集合的一個重要特性，也就是不重復性，在一個集合中是不會出現相同的元素，不管是如何的操作，最後都會去除其中的重復元素。
說完這幾種集合中的操作，我們再來看如何表示一個空的集合呢，如下：
由圖可知，僅僅一個花括弧並不能表示一個空集合，反而表示的是另外的一個數據類型，這個類型我們之後再說，那真正表示一個空集合就是 set() 。
好了，序列和集合的就說這么多，後面再說說其它的數據類型。
『叄』 python--set（集合）
一、創建集合
創建非空集合：集合中set括弧中需要的參數的數據類型有：序列（包括字元串、列表、元組），字典可以轉為集合，注意數值類型不能作為集合的參數，如int類型。
二、添加元素
add() 方法是將要添加的元素作為一個整體添加到集合中
update() 方法是把要傳入的元素拆分成單個字元，存於集合中，並去掉重復的
三、刪除元素
集合的刪除操作使用的方法跟列表是一樣的，使用的也是 remove 方法，只能單個刪除
四、遍歷集合
五、集合與字元串、列表、元組互轉，集合轉字典
六、查找元素並刪除
函數原型： a.discard(b)
參數說明：a為一個set類型的變數；b表示要查找並刪除的元素
函數作用：在集合setVar中查找element元素，如果存在則刪除；如果沒找到，則什麼也不做。該函數沒有返回值
七、pop用法
函數原型： set1.pop() 刪除並返回集合set1中的第一個元素，如果為空引發KeyError錯誤+
八、clear、和len的用法
clear 方法用於清空集合中的所有元素
方法用於集合拷貝
len 跟求序列的長度的函數len()是一樣的，返回的是集合中有多少個元素
九、求集合的交集、並集、差集和difference的用法
求集合的 交集 使用的符號是 「&」
求集合的 並集 用的是符號 「|」
求集合的 差集 使用的符號是減號 「-」
difference 等價於集合的差集 ，查看兩個集合的不同之處。這種不同指的是集合s1相對於集合s2，不同的地方，也就是所有在集合s1中，而不再集合s2中的的元素組成的新集合
十、運算符判斷集合間關系和issuperset、issubset的用法
集合可以使用大於（>）、小於（<）、大於等於（>=）、小於等於（<=）、等於（==）、不等於（！=）來判斷某個集合是否完全包含於另一個集合，也可以使用子父集判斷函數。
issuperset 集合st1是否是集合st2的父集
issubset 集合st1是否是集合st2的子集
十一、不可變集合frozenset的用法
frozenset 該集合中的內容是不可改變的，其他功能及操作跟可變集合set一樣
『肆』 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中最基本的數據結構。序列是一種數據存儲方式，用來存儲一系列的數據。
在內存中，序列就是一塊用來存放多個值的連續的內存空間。比如一個整數序列[10,20,30,40]
序列中的每個元素都分配一個數字 - 它的位置，或索引。第一個索引是0，第二個索引是1，依此類推。
列表：用於存儲任意數目、任意類型的數據集合。
列表是內置可變序列，是包含多個元素的有序連續的內存空間。列表定義的標准語法格式：
其中，10，20，30，40 這些稱為：列表a的元素。
列表中的元素可以各不相同，可以是任意類型。比如：a = [10,20,"abc",True,[]]
當列表增加元素時,列表會自動進行內存管理，減少了程序員的負擔。但是列表元素大量移動，效率低所以一般建議在尾部添加。
本地電腦運行結果：
列表是可變數據類型，地址不變，值可變。因此，添加新的值之後，地址也是不變的。
解析：在索引2處要引用50這個元素
申請了8個內存空間但是list實際用來存儲元素只使用了其中5個內存空間
insert的時間復雜度是O(n)
pop () 方法 刪除並返回指定位置的元素，如果未指定位置則默認操作
pop () 方法 刪除並返回指定位置的元素，如果未指定位置則默認操作
結果運行：
『陸』 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基礎必掌握的集合Set使用
數學中對集合的嚴格定義可能是抽象的且難以掌握。但實際上可以將集合簡單地認為是定義明確的不同對象的集合，通常稱為元素或成員。
Python 提供了一個內置的集合類型來將對象分組到一個集合中。集合類型（set type）是處理集合的數據類型。
集合類型的特點是它是一種與列表類型非常相似的數據類型，但它不能存儲重復值，它沒有下標和鍵等概念，並且是唯一元素，並且元素是可維護的。
利用這個特性，集合類型可以進行集合、交集、差等集合操作，適合管理類型。
整套學習自學教程中應用的數據都是《三國志》、《真·三國無雙》系列 游戲 中的內容。
集合是無序的，並且元素是唯一的，集合本身可以修改，但集合中包含的元素必須是不可變類型。
list方式
tuple方式
字元串方式
list和dict不能被set
方法 len() 、in 、 not in 的應用。
x1.union(x2[, x3 ...])
x1 | x2 [| x3 ...]
多種合並操作
x1.intersection(x2[, x3 ...])
x1 & x2 [& x3 ...]
多種交集操作
x1.difference(x2[, x3 ...])
x1 - x2 [- x3 ...]
更多的是集合差異操作
x1.symmetric_difference(x2)
x1 ^ x2 [^ x3 ...]
更多的集合對稱差操作
x1.isdisjoint(x2) ，包含返回 False，不包含返回 True（x1 & x2是空集）。
x1.issubset(x2) ，是則返回 True，否則返回 False，即x1
『捌』 python中集合的特點和注意點
集合的特點：
1.不同元素組成（元素不能重復百）
2.無序（集合元素的順序和定義、添加的順序不一致）
3.集合中的元素必度須是不可變類型
集合的注意點：
1.定義一個集合，如果直接寫my_set
=
{}，不添加數據，python解釋器會把my_set作為字典處理版
2.可以在集合中做添加相同元素的操作，但是集合只存儲一個
如果想深入了解可以搜索黑馬權程序員視頻庫，裡面有很多免費的軟體測試教程
『玖』 Python中內置數據類型list，tuple，dict，set的區別和用法
python 中list，tuple，dict，set是最常用的集合類型。
list列表，相當於一個數組，不過list的長度是自動變化的而且列表元素自由的，不必每個元素都是同一種類型。它的簡潔的定義方式是a=[]。有序組合
tuple也是一個組合。不過tuple在定義好之後就不能再變化。它的簡潔的定義方式是a=1,3也可以是a=(1,3).有序組合。
dict是字典類型。也就是鍵值對類型。鍵名不可以重復，並且不可以變化（字元串就符合這個要求，常用字元串作為鍵名）。它的簡潔的定義方式是a={}.無序組合（意思就是你無法按照添加的順序對他進行遍歷）。
set是set類型（不好翻譯，用的也少）。也是一個無序的組合，元素是互斥的，也就不會出現相同的元素。可以把一個序列轉換成無重復元素的set.無序組合。
以下是使用的示例代碼。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
a_tuple=(1,3423,'34')
a_list=[12,12.34,'sds']
a_dict={'key1':1,'key2':2}
a_set=set('2323')
for t in a_tuple:
print('%s in tuple'%t)
print('*'*10)
for l in a_list:
print('%s in list'%l)
print('*'*10)
for k,v in a_dict.items():
print('key=%s,value=%s in dict'%(k,v))
print('*'*10)
for s in a_set:
print('%s in set'%s)
print('*'*10)
『拾』 Python的集合介紹
和列表類似，集合也是一個數據集合，其也不要求元素的類型一致。但是集合有下面兩個特點：
•集合內元素唯一。如不可以用1、2、1、1組成集合，因為其包含重復的1。
•集合是無序的，添加元素時不能指定位置，刪除元素時也不能通過指定位置，只能通過指定值。當然也不能通過位置來定位某個元素。
1、創建集合
我們可以從列表創建集合，將列表中的元素都加入到集合中，如果有重復的元素就僅保留一個。
a = set([1, 1, 3])
print(a)#輸出結果：set([1, 3])
也可以從元組、字典和其他集合構建集合。比如：
a = set((0, 1, 2, 3, 3, 2))
使用的是字典的鍵來構建集合，字典的值沒有被使用到，比如：
a = set({1:10, 2:20, 3:30})
從字元串構建集合，其每個字元都成為集合的一個元素，比如：
a = set("abcdefabc")
輸出結果：a={'c', 'e', 'f', 'b', 'd', 'a'}
另外一個集合構建集合，比如：
a = set([1, 2, 3])
b = set(a) 輸出結果：b={1, 2, 3}
當然也可以構造一個空的集合，使用的方法是set()。空集合沒有任何元素，比如：
a = set()
1.添加元——add（值）
該函數只能添加一個元素。
如果添加的元素已經在集合中存在，那麼不會發生任何變化。
2.扔掉元素——discard（值）
該函數刪除集合中指定的值對應的元素。
如果指定值在集合中不存在，則不做任何操作。
3.刪除指定值——remove（值）
該函數和discard()的不同之處在於，如果指定的值在集合中不存在，會拋出異常。
4.清空所有元素——clear()
該函數扔掉所有的元素。執行完該函數後，該集合將變成一個空的集合。
a.clear()
5.刪除第一個元素——pop()
如果集合中有元素，則返回值為刪除掉的元素的值。
如果集合為空，則拋出異常。
6.得到差集——difference（集合對象）
該函數返回一個新的集合，該集合包含所有屬於a而不屬於b的元素，如圖所示。該操作不會改變原始集合a或者b的內容。
7.差集操作符（-）
該操作符和difference()類似，返回一個新的集合，該集合包含所有屬於a而不屬於b的元素。該操作不會改變原始輸入集合a或者b的內容。
8.從集合中刪除另一個集合中存在的元素——difference_update（集合對象）
該函數和difference()的不同是操作數a會被修改，而且沒有返回值。
9.得到兩個集合的交集——intersection（集合）
該函數返回所有的同時屬於集合a和集合b的元素組成的集合，即返回的是一個集合，該集合的所有元素都同時屬於集合a和b，如圖所示。輸入集合a和b在該過程中沒有發生任何改變。
10.交集操作符（&）
該操作符和intersection()的效果是一樣的。
11.刪除集合a中所有不屬於集合b的元素——intersection_update（集合）
該函數也是求交集，與intersection()不同的是其修改原始輸入集合，並且沒有返回值。這也是為何該介面函數後面帶有update字樣，因為其更新了原來的輸入集合。
12.是否存在交集——isdisjoint()
該函數判斷是否存在這樣的元素，其同時屬於集合a和集合b。如果存在這樣的元素，返回False；否則返回True。
13.並集——union（集合a，集合b）
該函數返回一個新的集合，該集合的元素要麼屬於輸入集合a要麼屬於集合b。該操作不修改作為輸入的兩個集合a和b。如圖表示該函數返回的集合的內容。
14.並集操作符（|）
該操作符和union()的效果是一樣的。其返回一個並集，並且不修改輸入集合的內容。
15.添加屬於b而不屬於a的元素——update()
該函數在集合a中添加屬於b而不屬於a的所有元素。該操作和union()不同的是，其修改了輸入集合a，並且沒有返回值。
16.外集——symmetric_difference()
外集就是由只屬於集合a或者只屬於集合b的元素組成的集合，如圖所示。該操作返回一個新的集合，並且不修改原來的輸入集合a和b。
17.外集操作符（^）
該操作符和symmetric_difference()的效果是一樣的，也是返回一個新的集合，並且不會修改輸入的集合a或者b。
18.a和b的並集減去a和b的交集——symmetric_difference_update()
該函數和symmetric_difference()的區別是，其修改了集合a的值，並且沒有返回值。
19.是指定集合的子集嗎——issubset()
a是b的子集就是說集合a的所有元素都屬於集合b。
如果a等於b，那麼a和b互為子集。
20.是指定集合的超集嗎——issuperset()
a是b的超集合就是說集合b中的所有元素都屬於集合a。
如果a是b的超集，那麼b就是a的子集。
如果a等於b，那麼它們互為子集，同時也互為超集。