人生苦短，我用Python
使用Python做數據挖掘已經兩年多了，在處理數據的過程中經常會使用到一些數據結構，比如，列表、元組、集合、字典，雖然經常用，但是老是記不住他們常用的一些函數和方法，那就趁此機會整理一下
注：文章內容根據小甲魚的《零基礎入門學習Python》課程而整理
列表
一：創建列表 ：列表中元素以逗號隔開並且以中括號將他們括起來
在Python中列表的含義和其他程序語言中的數組類似，由一系列元素組成並且可以通過下標進行訪問。不同的是，列表裡面的元素可以是任何數據類型，甚至可以是一個列表。
1）創建一個純由字符串組成的列表，並賦值給變量member
member = ['小甲魚','黑夜','牡丹','怡靜']
2）創建一個混合列表，列表內的元素有數字，字符串和純數字列表，並將其賦值給變量mix
mix = ['小甲魚',120,[3,2,1]]
3）創建一個空列表，並將其賦值給變量empty：
empty = []
二：通過列表相關函數向列表內添加新元素
在這裡我們主要介紹列表的三個函數 append() extent() insert()並舉實例介紹它們的用法
1） append()函數
append()函數需要一個參數，該參數將作為一個元素加入到列表的末尾，這種方法一次只能加一個元素
member = ['小甲魚','黑夜','牡丹','怡靜']
>>>member.append('青牛')
>>>member
['小甲魚','黑夜','牡丹','怡靜','青牛']
2） extend()函數，實現了一次性加入多個元素
這個參數是一個列表，通過這個函數可以將此列表內的元素加到列表末尾，調用方式為 列list.extend(newlist)
member = ['小甲魚','黑夜','牡丹','怡靜']
newlist = ['醉酒','John_farmer']
>>>member.extent(newlist)
>>>member
['小甲魚','黑夜','牡丹','怡靜','醉酒','John_farmer']
3）insert()函數
上述兩種方法，加入的元素自動被添加到列表的末尾，而insert()函數允許用戶將加入的元素放置到任何位置，因此它需要兩個參數第一個是新元素在列表中的位置，第二個為該元素，其調用形式為 列表.insert(位置,元素) 注意列表中第一個元素位置是從0開始的
member = ['小甲魚','黑夜','牡丹','怡靜'] 我們想將"醉酒"這個字符串元素放到列表member首位
>>>member.insert(0,'醉酒')
>>>member
['醉酒','小甲魚','黑夜','牡丹','怡靜']
三,通過索引值獲得單個列表元素方法，刪除列表中某一元素的方法及通過列表分片實現獲取列表中多個元素的方法。
1. 通過索引值獲得列表中元素
>>>member = ['小甲魚','黑夜','牡丹','怡靜']
>>>member[0]
'小甲魚'
2. 從列表中刪除元素的方法
1）remove()函數
參數是一個元素，調用該函數則刪除該列表中的該元素，如果輸入的元素不在列表中，則程序報錯，例如
member = ['小甲魚','黑夜','牡丹','怡靜']
>>>member.remove('黑夜')
['小甲魚','牡丹','怡靜']
而此時如果再執行member.remove('黑夜'),由於該元素已經不存在此列表中，執行時將會報錯
2）del語句
直接刪除一個元素值，可以直接通過索引值獲得需要刪除的元素，例如：
>>>member = ['小甲魚','黑夜','牡丹','怡靜']
>>>del member[2]
>>>member
['小甲魚','黑夜','怡靜']
而執行語句del member，則member列表被刪除，如果想再訪問member則程序報錯，因為它已經不存在了。
3）pop()函數
不需要參數，直接返回列表中最後一個元素並刪除，例如：
>>>member = ['小甲魚','黑夜','牡丹','怡靜']
>>>name = member.pop()
>>>name
'怡靜
>>>member
['小甲魚','黑夜','牡丹']
3. 列表分片(slice)
當需要從列表一次性取出多個元素時，需要通過列表分片的方式來實現，其基本形式是列表名[左索引值:右索引值]，左右索引值都可以省略，左索引值省略時表明，列表元素從0開始，右索引值省略表示包含左索引值右邊的所有元素。例如：
>>>member = ['小甲魚','黑夜','牡丹','怡靜']
>>>split1 = member[1:3]，則split1= ['黑夜','牡丹'] #member本身元素並沒有發生變化，相當於生成了包含元素1和2的新列表
split2 = member[:3]，則列表split2= ['小甲魚','黑夜','牡丹'] #表示從第0個索引值開始
split3 = member[1:]，則列表split3= ['黑夜','牡丹','怡靜'] #表示從左索引值開始到列表右邊所有元素
split4 = member[:]，則列表split4= ['小甲魚','黑夜','牡丹','怡靜'] #相當於複製了一份原列表
四：列表中一些常用操作符和列表內的一些常用的內置函數使用
1. 列表中一些常用的操作符
1）比較操作符
列表是可以比較大小的，例如：
list1 = [123,456]
list2 = [456,123]
>>>list1>list2
False
在Python中會直接取兩個數組的第0個元素進行比較，如果相等則繼續對列表下一個元素進行比較，不相等則給出False或者True的值。這裡面需要注意：元素的值必須符合比較運算符的適用範圍，例如可以是兩個數字進行對比，也可以是兩個字符進行對比。
2）邏輯操作符
list1, list2, list3 = [123,456], [456,123], [123,456]
>>>(list1 < list2) and (list1 == list3) #先對兩個列表進行比較，再進行邏輯與運算
True
3）連接操作符
在列表中連接操作符為+，例如：
list1, list2 = [123,456], [789]
list3 = list1 + list2
則list3=[123,456,789]，+號起到了將兩個列表中的元素連接起來的作用，這裡需要注意的是，＋號兩邊必須都是列表 "list3+345"是會報錯的
4）重複操作符
以*進行列表中的元素重複操作，例如：
>>>list1 = [123,456]
>>>list1*3
[123,456,123,456,123,456]
5）成員關係操作符
in 和 not in 分別表示參數是否在列表中，
list1=[123,456]
>>>123 in list1
True，
>>>'小甲魚' in list1
False，
>>>'小甲魚' not in list1
True。
另外，in 和 not in只能訪問屬於列表同一層的元素，例如：
list1 = [123,456,['小甲魚'，'醉酒'],789] 這是一個列表中含有列表元素的的列表。
>>> '醉酒' in list1
False #因為'醉酒'是在list1[2]這個元素列表中，
>>>'醉酒' in list1[2]
True
那麼問題來了，如何訪問元素'小甲魚'和'醉酒'呢，這裡是通過類似其他程序語言的二維數組形式實現的。例如list1[2][0]為'小甲魚'。
2. 列表內的內置函數
首先通過dir(list)找出列表中有哪些內置函數：append clear copy count extend index insert pop remove reverse sort
1）clear() 函數
用於刪除列表中的所有元素，形成一個空的列表，例如：
>>>list1 = [123,456,789]
list1.clear() 的值為[]，一個空的列表
2）copy()函數
用於淺拷貝一個列表，例如：
list1 = [123,456]
list2 = list1.copy()
>>>list2
[123,456]
它的功能和列表分片功能 list2 = list1[:]作用是一樣的；他們兩個與賦值運算符=是有區別的，前者是在內存中重新申請一個空間並存放列表的值，而=則是將列表的地址直接賦值給了另一個列表
list1 = [1,3,5]
list2 =list1
list3 = list1.copy()
list1.append（'醉酒'）
>>>list1
[1,3,5,'醉酒']
>>>list3
[1,3,5]
3）count()函數
用於統計所需參數在列表中出現的次數，例如：
list1 = [1,3,1,4,1,5,1,10]
>>>list1.count(1)
4
>>>list1.count(100)
0
4）index()函數
用於尋找所輸入參數在列表中的第一個位置並返回該位置值，還有兩個參數可以確定尋找該值的的列表範圍，例如：
list1 = [1,3,1,4,1,5,1,10]
>>>list1.index(1)
0
>>>list1.index(1,2,4)
2
>>>list1.index(100) 則報錯，因為100不存在該列表中
5）reverse()函數
將列表中所有元素倒置，例如
list1 = [1,2,3,4,5]
>>>list1.reverse()
[5,4,3,2,1]
6）sort()函數&sorted()函數
這是一個比較重要的函數，其有三個參數值，前兩個分別是指定排序算法和算法搭配的關鍵字，最後一個是reverse =False，說明默認狀態下sort是按照從小到大進行排序，如果想改為從大到小則將reverse=True，例如
>>>list1 = [12,7,9,15,18,4]
>>>list1.sort()
[4,7,9,12,15,18]
>>>list1.sort(reverse=True) 從大到小排列
[18,15,12,9,7,4]
>>>sorted([5,2,3,1,4])
[1,2,3,4,5]
sort()與sorted()的不同在於，sort是在原位重新排列列表，而sorted()是產生一個新的列表。
元組，通過與列表進行對比來介紹元組獨有的用法和特點，
1. 創建和訪問元組，元組一旦建立，元組內的元素不允許修改和刪除。
1.1 元組的創建：大多數時候，元組的標示是一個()，例如：
empty = () #定義了一個空元組
tuple1 = (1,7,4) #定義了一個純數字的普通元組
tuple2 = (2,'小甲魚','醉酒青牛',5) #定義了一個具有數字和字符串的混合元組
然而，當元組中僅有一個元素時，需要將元素後面加上逗號，例如：
tuple3 = (1,) #定義了一個只包含數字1的元組，1後面必須加上逗號才表示元組
甚至，不需要括號，僅僅有逗號就行，例如：
tuple4 = 1,
1.2 元組的訪問：
元組的訪問形式與列表一樣都是:tuple[index]，
例如：tuple4 = (1,5,9)
>>>tuple4[1]
5
tuple4[1] = 4 #將會報語法錯誤,不允許修改
和列表一樣，可以對元組使用拼接操作符，重複操作符，邏輯操作符，關係操作符和成員操作符等。
2. 更新和刪除元組
雖然元組本身不允許修改和刪除，我們可以對原元組的元素進行修改並新生成一個新的元組存放這些修改後元素，例如：
tuple5 = ('小甲魚','黑夜','小布丁') #定義一個純字符串的元組
tuple5 = tuple5[:2] +("醉酒",)+ tuple5[2:] #通過元組分片形式和拼接操作，生成了在原元組的第一個位置上插入'醉酒青牛'元素的新元組
>>>tuple5
('小甲魚','醉酒','黑夜','小布丁') #這樣就實現了tuple5元組的更新，其實相當於重新生成了一個新的元組，並將其複製給了tuple5，原先的元組還存在，只是已經不再叫tuple5，它會被Python內存垃圾回收。
可以通過del語句直接刪除一個元組，但是不允許利用del刪除元組的一個元素，例如：
tuple6 = (1,3)
del tuple6
當然也可以採取變通的方法去掉元組的一個元素，例如：
tuple7 = ('小甲魚','醉酒','黑夜','小布丁') #定義一個純字符串的元組
tuple7 = tuple7[:1] + tuple7[2:] #通過元組分片形式和拼接操作，生成了去掉了'醉酒青牛'元素的新元組並賦值給tuple7
>>>tuple7
('小甲魚','黑夜','小布丁') #原先的元組還存在，只是已經不再叫tuple7，它會被Python內存垃圾回收。
另外：Python中的函數是可以返回多個值的，其實是以元組的形式返回多個值
集合
一： 集合的概念和使用
在這裡集合的概念和數學裡集合的概念是一致的，都是一組元素的集，且元素之間不能重複。
1，Python中集合的定義和字典類似，都需要大括號，區別在於集合不需要映射
>>> dict1 = {}
>>> type(dict1)
>>> set1 = {1,4,'小甲魚'}
>>> type(set1)
2. set()函數
和序列工廠函數list()，str()，tuple()一樣，可以將序列類型直接強制轉換為一個集合類型
一個列表[1,2,3,4,5,5,3,1,0]，如何去除列表內的重複元素，兩種方法可供選擇，第一種是常規方法，見下面所示：
>>> list2 = [1,2,3,4,5,5,3,1,0]
>>> list3 = []
>>> for each in list2:
if each not in list3:
list3.append(each)
>>> list3
[1, 2, 3, 4, 5, 0]
第二種方法使用集合的元素不重複性，通過將列表先強制轉換為集合，再轉換為列表形式實現
>>> list4 = [1,2,3,4,5,5,3,1,0]
>>> list4 = list(set(list4))
>>> list4
[0, 1, 2, 3, 4, 5]
3. 集合類型幾個內置函數：
add()增加一個元素到集合內，remove()從集合內刪除一個元素
>>> set2 = {1,2,3,4}
>>> set2.add(5)
>>> set2
{1, 2, 3, 4, 5}
>>> set2.remove(1)
>>> set2
{2, 3, 4, 5}
4. 將一個集合凍結使之無法添加和刪除元素的函數frozenset()
>>> set3 = frozenset(set2)
>>> set3
frozenset({2, 3, 4, 5})
>>> set3.remove(2)
Traceback (most recent call last):
File "
set3.remove(2)
AttributeError: 'frozenset' object has no attribute 'remove'
字典
1. 字典的創建和訪問
字典不同於前述的序列類型，它是一種映射類型，它的引入就是為了簡化定義索引值和元素值存在特定關係的定義和訪問問題。字典的定義形式為：字典變量名 = {key1:value1,key2:value2....}。這裡面key代表索引值，而value代表映射的值，通過大括號將其括起來進行字典的定義。訪問字典時直接以字典變量名[key]進行訪問，例如定義一個阿拉伯數字與相應英文的映射字典，舉例說明：
>>> dict1 = {1:'one',2:'two',3:'three'}
>>> dict1[2]
'two'
2. dict()函數的用法
創建一個空字典，舉例說明：
>>> dict3 = dict()
>>> dict3
{}
通過將key和value作為一個序列類型（元組或列表）創建一個字典
>>> dict4 = dict((('李寧','一切皆有可能'),('魚C工作室','讓編程改變世界')))
>>> dict4
{'李寧': '一切皆有可能', '魚C工作室': '讓編程改變世界'}
通過對關鍵字賦值創建一個字典，注意關鍵字必須是一個字符串類型且不能加引號，因為程序會默認為其加上一個引號，舉例說明：
>>> dict5 = dict(李寧='一切皆有可能', 魚C工作室='讓編程改變世界')
>>> dict5
{'李寧': '一切皆有可能', '魚C工作室': '讓編程改變世界'}
3. 修改或添加字典元素
通過將變量賦值給字典訪問類修改或者增加字典的元素、
>>> dict6 = {'李寧': '一切皆有可能', '魚C工作室': '讓編程改變世界'}
>>> dict6['李寧'] = '打造民族品牌'
當key值存在於字典內時，則重置key的value值
>>> dict6
{'李寧': '打造民族品牌', '魚C工作室': '讓編程改變世界'}
>>> dict6['小甲魚']='讓更多的人學會編程'
當key值不存在於字典內時，則字典增加一個相（key:value）
>>> dict6
{'小甲魚': '讓更多的人學會編程', '李寧': '打造民族品牌', '魚C工作室': '讓編程改變世界'}
常用的內置函數
主要涉及到創建一個新的字典並返回該對象的fromkeys()，訪問字典函數函數keyes(),values(),items()，成員操作符in not in，清除一個字典內容的clear()和複製一個新的字典的copy()，自動去除一個字典item的pop()和popitem()，以及最後更新字典的setdefault()和update()。
1. 工廠函數的概念
和序列類型的工廠函數一樣，dict()也是一個工廠函數2. 字典類型內置函數的用法
2.1 fromkeys(iterable, value=None, /) 創建並返回一個新的字典。其中第一個參數是一個可迭代對象（序列類型），第二個參數是value值，當第二個參數不提供時，則默認為none，舉例說明：
>>> dict1 = dict()
>>> dict2 = dict1.fromkeys((1, 2, 3), 'number')
>>> dict2
{1: 'number', 2: 'number', 3: 'number'}
>>> dict1
{}
>>> dict3 = dict1.fromkeys((1, 2, 3))
>>> dict3
{1: None, 2: None, 3: None}
2.2 訪問字典的內置函數，這裡主要是訪問字典的key的keys()，訪問字典的value的values()，訪問item的items()。當然也可以直接用get()通過key訪問其對應的value。
>>> dict4 = dict1.fromkeys((1,2,3),'贊')
>>> dict4
{1: '贊', 2: '贊', 3: '贊'}
>>> dict4.keys()
dict_keys([1, 2, 3])
>>> for eachkey in dict4.keys():
print(eachkey)
1
2
3
>>> for eachvalue in dict4.values():
print(eachvalue)
贊
贊
贊
>>> for eachitem in dict4.items():
print(eachitem)
(1, '贊')
(2, '贊')
(3, '贊')
get(k[,d])通過key返回對應的value值，第一個參數為key值，第二個參數為默認返回的value值，當key存在則返回對應的value，不存在字典內時返回該值，如果不提供則默認為none，舉例說明
>>> dict5 = {1:'one',2:'two',3:'three'}
>>> dict5.get(3,'木有')
'three'
>>> dict5.get(4,'木有')
'木有'
>>> dict5.get(4)
>>> print(dict5.get(4))
None
2.3 清空字典和複製一個字典函數clear()和copy()。這裡面主要要搞清楚copy()和=賦值的區別，copy()相當於複製出一個新的字典，兩者互不影響，而賦值=僅是將字典內存地址賦值出去，兩者共同指向一個地址，
>>> dict6 = dict5
>>> dict7 = dict5.copy()
>>> id(dict6)
58796168
>>> id(dict5)
58796168
>>> id(dict7)
58795208
>>> dict5
{1: 'one', 2: 'two', 3: 'three'}
>>> dict6.clear()
>>>dict6
{}
>>> dict5
{}
>>> dict7
{1: 'one', 2: 'two', 3: 'three'}
2.4 去除字典一個元素內置函數。pop(k[,d])，當k存在字典的key時，在字典內去除該key對應的（key,value），否則返回d的值，當d不提供時返回錯誤，舉例說明：
>>> dict7
{1: 'one', 2: 'two', 3: 'three'}
>>> dict7.pop(1,'木有')
'one'
>>> dict7
{2: 'two', 3: 'three'}
>>> dict7.pop(1,'木有')
'木有'
>>> dict7.pop(1)
Traceback (most recent call last):
File "
dict7.pop(1)
KeyError: 1
popitem()去除字典內的一個（key,value），如果字典本身為空時報錯
>>> dict7
{2: 'two', 3: 'three'}
>>> dict7.popitem()
(2, 'two')
>>> dict7
{3: 'three'}
2.5 給字典增加一個item，setdefault(k[,d])，返回k對應的value值，當k不在字典內時則返回d的值，如果d沒提供則返回空；同時如果k不存在字典內時，將d作為value映射給k
>>> dict7
{3: 'three'}
>>> dict7.setdefault(1,'one')
'one'
>>> dict7
{1: 'one', 3: 'three'}
>>> dict7.setdefault(2)
>>> dict7
{1: 'one', 2: None, 3: 'three'}
>>> dict7.setdefault(3,'有')
'three'
D.update([E, ]**F) 將一個字典內的item作為item添加到字典內
>>> dict7
{1: 'one', 2: None, 3: 'three', 4: 'two'}
>>> dict7.pop(4)
'two'
>>> dict7
{1: 'one', 2: None, 3: 'three'}
>>> dict8 = {4:'four'}
>>> dict7.update(dict8)
>>> dict7
{1: 'one', 2: None, 3: 'three', 4: 'four'}
>>> dict9 = {2:'two'}
>>> dict7.update(dict9)
>>>dict7
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}
閱讀更多 愛數據的小司機 的文章
