列表、字典、元組、檔案——Python__Python

列表（list）：

列表是Python中最具靈活性的有序集合物件類型。

與字串不同的是列表可以包含任何種類的對象，列表都是可變對象，支援在原處修改操作，可以通過指定的位移值和分區、列表方法調用、刪除語句等方法來實現。 Python列表的主要屬性：

    任意對象的有序集合——列表就是收集其他對象的地方，包含的每一項都保持從左至右的順序

    通過位移讀取——隊列表對象通過位移進行索引

    可變長度、異構、任意嵌套——列表可以即時的增長、縮短，可以包含任何類型的對象，支援任意嵌套

    屬於可變序列分類——支援在原處修改

    對象引用數組——在Python解譯器內部，列表就像C中的數組而不是連結結構。

常見的列表常量和操作：

為了得到更全面的資訊，可以查閱Python標準庫手冊，或者運行help(list)，dir(list)查看list方法的完整列表清單。

L = []                                   #一個空列表

L = [0,1,2,3]                         #四項：索引為0到3

L = ['abc' , ['def' , 'ghi']]        #嵌套的子列表

L = list('spam')                     #可迭代項目的列表

L = list(range(-4,4))             #連續整數的列表，傳回值：[-4, -3, -2, -1, 0, 1, 2, 3]

L[i]                                     #索引

L[i][j]                                  #索引的索引

L[i:j]                                   #分區

len(L)                                 #求長度

L1+L2                                #合并

L*3                                    #重複

for x in L：print (x)             #迭代

3 in L                                  #成員關係

L.append(4)                        #增長

L.extend([5,6,7])                 

L.insert(I,X)                        #插入

L.index(1)                          

L.Count(x)

L.sort()                             #索引

L.reverse()                       #反轉

del L[k]                            #方法：縮短語句

del L[k:j]

L.pop()

L.remove(2)

L[k:j] = []

L[k] = 1                           #索引賦值

L[k:j] = [4，5，6]             #分區賦值

L = [x**2 for x in range(5)]                    #列表解析

list(map(ord,'spam'))

實際應用中的列表：

由於列表是序列，支援很多與字串相同的操作。 基本欄表操作：

>>> len([1,2,3])3>>> [1,2,3]+[4,5,6][1, 2, 3, 4, 5, 6]>>> [1,2,3]*2[1, 2, 3, 1, 2, 3]

不能將一個列表和一個字串和併到一起，除非先把字串轉換為列表或把列錶轉換為字串：

>>> str([1,2])+"34"'[1, 2]34'>>> [1,2]+list("34")[1, 2, '3', '4']

列表迭代和解析：

>>> 3 in [1, 2, '3', '4']False>>> for x in [1, 2, '3', '4']:...     print x... 1234

列表解析——通過對序列中的每一項應用一個運算式來構建一個新的列表方式：

>>> res = [c*4 for c in 'spam']>>> res['ssss', 'pppp', 'aaaa', 'mmmm']

等同效果的手動構建：

>>> res = []>>> for c in 'spam':...     res.append(c*4)... >>> res['ssss', 'pppp', 'aaaa', 'mmmm']

map——內建函數map對序列中的各項應用一個函數並把結果收集到一個新列表中

>>> list(map(abs,[-1,-2,0,1,2]))[1, 2, 0, 1, 2]

索引、分區、矩陣

由於列表都是序列，對於列表而言，索引和分區操作和字串中基本相似——對列表進行索引的結果就是指定的位移處的對象，對列表進行分區返回一個新列表。

>>> L = ['I','Love','Pyton']>>> L[2]'Pyton'>>> L[-2]'Love'>>> L[1:]['Love', 'Pyton']

矩陣（多維陣列）：Python中為嵌套了子列表的列表

由於列表允許嵌套，所以有時需要多次索引操作連在一起使用。下面的例子中：使用一次索引操作得到一個嵌套的子列表，使用兩次索引得到子列表中具體的項。

>>> matrix = [[1,2,3],[4,5,6],[7,8,9]]>>> matrix[1][4, 5, 6]>>> matrix[1][1]5>>> matrix[2][0]

原處修改列表：

由於列表是可變的，所以支援原處修改列表的操作，而不會像字串那樣強迫建立新的拷貝。

索引、分區、賦值：

>>> L = ['I','Love','Pyton']>>> L[1] = 'LOVE'>>> L['I', 'LOVE', 'Pyton']>>> L[0:2] = ['Bob','like']>>> L['Bob', 'like', 'Pyton']

注意：索引和分區都是原地修改即對列表直接修改，而不是產生一個新的列表作為結果

>>> L = [1,2,3]>>> L[2] = [4,5]>>> L[1, 2, [4, 5]]>>> L[1:2] = [4,5]>>> L[1, 4, 5, [4, 5]]

分區賦值可以理解為兩步（但是實際情況並非如此）：

1）刪除：刪除等號左邊指定的分區

2）插入：將等號右邊的對象插中的片段插入舊分區被刪除的位置

這樣可以協助你理解為什麼插入的元素不需要與刪除的元素數目相等
列表方法調用：

<pre code_snippet_id="384110" snippet_file_name="blog_20140609_11_4711602" name="code" class="python" style="margin-top: 4px; margin-right: 0px; margin-bottom: 4px; margin-left: 0px; background-color: rgb(240, 240, 240); ">>>> L = ['I','love','Python']>>> L.append('more')  #將一個單項加至列表末端，append只允許傳入單一對象；L.append(X)與L+[X]的結果</span>

                       一樣但是前者會原地修改L，後者會產生新的列表</span>

>>> L['I', 'love', 'Python', 'more']>>> L.sort()           #sort原地對列表進行排序，以遞增順序進行排序>>> L['I', 'Python', 'love', 'more']   

我們可以通過傳入關鍵字參數來修改排序行為：

>>> L = ['abc','ABD','aBe']>>> L.sort()>>> L['ABD', 'aBe', 'abc']>>> L.sort(key=str.lower)>>> L['abc', 'ABD', 'aBe']>>> L = ['abc','ABD','aBe']>>> L.sort(key=str.lower,reverse=True)>>> L['aBe', 'ABD', 'abc']</span>

其他方法調用：

sorted：

>>> sorted(L,key=str.lower,reverse=True)['aBe', 'ABD', 'abc']>>> sorted([x.lower() for x in L],reverse=True)  #使用列表解析在排序之前轉換為小寫['abe', 'abd', 'abc']

extend()——在列表末端插入多個元素。

pop()——刪除一個元素。 reversed ()——原地翻轉列表使用時必須包含在一個list調用中，因為它是一個迭代器。

<span style="font-family:Arial, Helvetica, sans-serif;"><span style="white-space: normal;"><span style="font-family:monospace;"><span style="white-space: pre;"></span></span></span></span><p style="margin-top: 4px; margin-right: 0px; margin-bottom: 4px; margin-left: 0px; padding-top: 2px; padding-right: 0px; padding-bottom: 2px; padding-left: 0px; "><span style="font-family:monospace;"><span style="white-space: pre; "></span></span></p><span style="font-family:monospace;"></span><pre name="code" class="python" style="margin-top: 4px; margin-right: 0px; margin-bottom: 4px; margin-left: 0px; background-color: rgb(240, 240, 240); ">>>> L = [1,2]>>> L.extend([4,5,6])>>> L[1, 2, 4, 5, 6]>>> L.pop()6>>> L[1, 2, 4, 5]>>> L.reverse()>>> L[5, 4, 2, 1]>>> list(reversed(L))[1, 2, 4, 5]

>>> L = []
>>> L.append(1)
>>> L.append(2)
>>> L
[1, 2]
>>> L.pop() #pop()方法預設值為最後一個元素
2
>>> L = ['I','Love','Pyton']
>>> L.index('Love')
1
>>> L.insert(1,'LOVE')
>>> L
['I', 'LOVE', 'Love', 'Pyton']
>>> L.remove('Love')
>>> L
['I', 'LOVE', 'Pyton']
>>> L.pop(1) #pop()方法也可以指定將刪除並返回元素的位移
'LOVE'
>>> L
['I', 'Pyton']

其他常見列表操作：

del——列表是可變的，可以使用del語句在原處刪除某項或某片段

>>> L = ['I','Love','Pyton']>>> del L[0]>>> L['Love', 'Pyton']>>> del L[1:]>>> L['Love']

因為分區賦值是刪除加插入操作，所以可以通過將空列表賦值給分區來刪除列表片段

>>> L = ['I','Love','Pyton']>>> L[1:] = []>>> L['I']>>> L[0] = []>>> L[[]]

字典（dictionary）：

除了列表以外，字典也許是Python之中最靈活的內建資料結構類型。如果把列表看作有序的對象集合，那麼就可以把字典當成無序的對象集合，他們的主要差別在於：字典中的元素是通過鍵來存取的，而不是通過位移存取的。 Python字典的主要屬性：

    通過鍵而不是位移量來讀取——字典有時叫做關聯陣列或是散列表，通過鍵將一系列值聯絡在一起。

    任意對象的無序集合——字典中的項沒有特定順序。

    可變長、異構、任意嵌套——字典可在原處增長、縮短（無鬚生成一份拷貝），可以包含任何類型對象，支援任意深                                            度嵌套。

    屬於可變映射類型——通過索引賦值，字典可在原處修改。

    對象參考資料表——字典支援鍵讀取的無序對象參考資料表，列表則支援位置讀取的對象引用數組。 常見字典常量和操作：

該例總結了一些具有代表性的字典操作（查看庫手冊或者運行dir(dict)——{使用dir擷取模組內部可用變數名的列表}或是help(dict)可以得到完整的清單，類型名為dict）。當寫成常量運算式時，字典以一系列"鍵:值(key:value)"形式出現，用逗號隔開，大括弧括起來。一個空字典就是一對大括弧，字典可以作為另一個字典的（列表、元組）中的某一個值被嵌套。

>>> D = {} #空字典

>>> D = {'spam':2,'eggs':3} #兩項目字典

>>> D = {'food':{'ham':1,'eggs':2}} #嵌套

>>> D = dict.fromkeys(['a','b']) #其他構造技術

>>> D = dict(zip(keylist,valslist)) #關鍵字、對應的對、鍵列表

>>> D = dict(name='Bob',age=42)

>>> D['eggs'] #以鍵進行索引運算

>>> D['food']['ham' ]

>>> 'eggs' in D #鍵存在測試

>>>D.keys #方法：鍵

>>>D.values#方法：值

>>>D.items #方法：鍵+值>>>D.copy#方法：副本

>>>D.get(key,values)#方法：預設

>>>D.update(D2)#合并

>>>D.pop(key) #刪除等

>>>len(D) #長度

>>>D[key] = 42 #新增/修改 鍵，刪除鍵

>>>delD[key] #根據鍵刪除條目

>>>list(D.keys()) #字典視圖（Python 3.0）

>>>D1.keys() & D2.keys() >>>Dictionary views (Python 3.0)

>>>D = {x: x*2 for x in range(10)} #字典解析（Python 3.0）

實際應用中的字典：

字典通過鍵進行索引，被嵌套的字典是通過一系列的索引表示的，當Python建立字典時，會按照任意所選，從左至右的順序來儲存項，為了取值需要提供鍵。 字典的基本操作：

>>> D = {'spam':2,'ham':1,'eggs':3}>>> D['spam']2>>> D{'eggs': 3, 'ham': 1, 'spam': 2}

注意：本例中最後的輸出和原先設定的順序不同。這樣設計的目的是為了快速進行鍵尋找（也就是散列尋找），鍵需在記憶體中隨機設定這裡就是為什麼假設從左至右的順序操（例如：分區和合并）作不適合字典，在字典中只能用鍵進行取值，而不是用位置進行取值。

>>> len(D)                   #返回keys列表長度或字典中元素數目3>>> 'ham' in D               #測試鍵是否存在True>>> list(D.keys())           #建立關於key的列表['eggs', 'ham', 'spam']

原處修改字典：

字典是可變的因此可以在原處對其進行修改，擴充，縮短而不需要產生新的字典。

簡單的一個賦值就可以產生或者改變元素。

>>> D{'eggs': 3, 'ham': 1, 'spam': 2}>>> D['ham'] = ['I','am','wy']          #改變索引值對應的valus>>> D{'eggs': 3, 'ham': ['I', 'am', 'wy'], 'spam': 2}>>> del D['eggs']                 #通過索引值刪除values>>> D{'ham': ['I', 'am', 'wy'], 'spam': 2}>>> D['new'] = 'apple'            #增加新的values 為 apple，key為'new'>>> D{'new': 'apple', 'ham': ['I', 'am', 'wy'], 'spam': 2}

注意：在列表中Python會將超出列表末尾的位移視為越界並報錯，所以在列表中需要使用append方法或分區賦值來實現，但是在字典中可以對新的字典鍵進行賦值，而不需要考慮上述問題。

其他字典方法：

Eg：

字典的values和items方法分別返回字典的值列表和（key,values）對元組。

>>> D = {'spam':2,'ham':1,'eggs':3}>>> list(D.values())[3, 1, 2]>>> list(D.items())[('eggs', 3), ('ham', 1), ('spam', 2)]

上述方法在逐項遍曆字典項的迴圈中是很有效。讀取不存在的鍵會出錯， 鍵不存在時通過get的方法會返回預設值（None或使用者定義的預設值）。這是當鍵不存在時為了避免missing-key錯誤而填入預設值的一個方法：

>>> D.get('spam')2>>> print D.get('new')None>>> D.get('new',12)12

字典的update方法有點類似於合并，但是它和從左至右的順序無關（再一次強調，字典中沒有這樣的事情）。

>>> D = {'spam':2,'ham':1,'eggs':3}>>> D2 = {'new':4,'name':6}>>> D.update(D2)>>> D{'new': 4, 'eggs': 3, 'ham': 1, 'name': 6, 'spam': 2}

把一個字典的索引值合并到另一個字典中時會有覆蓋索引值的情況存在：

>>> D = {'spam':2,'ham':1,'eggs':3}>>> D2 = {'new':4,'eggs':6}>>> D.update(D2)>>> D{'new': 4, 'eggs': 6, 'ham': 1, 'spam': 2}

字典的pop方法能從字典中刪除一個鍵並返回他的值（和列表的pop方法區別在於刪除的是鍵而不是一個可選位置）：

>>> D = {'new': 4, 'eggs': 3, 'ham': 1, 'name': 6, 'spam': 2}>>> D{'new': 4, 'eggs': 3, 'spam': 2, 'ham': 1, 'name': 6}>>> D.pop('new')4>>> D{'eggs': 3, 'spam': 2, 'ham': 1, 'name': 6}>>> L = ['aa','bb','cc','dd']>>> >>> L.pop()'dd'>>> L.pop(1)'bb'>>> L['aa', 'cc']

元組：

元組——無法修改的對象的集合。

元組由簡單的對象構成，與列表相似，之不過元組不能在原處修改（它們是不可變的），通常寫成圓括弧中的一系列