【Python學習】python學習手冊--第八章 列表與字典

列表與字典在Python中都是其他對象的集合，因其支持嵌套類型，在使用時具有極高的靈活性，幾乎可以在任何場合下表示與處理現實工程中的複雜數據結構。

列表

列表是Python中極具靈活特性的對象類型，與字符串不同的是列表可以包含任何Python核心對象類型，包括數字，字符串，甚至列表中還可以包含列表。列表與字符串一樣，都是Python的有序序列類型，但是與字符串不同的是，列表是可變對象，可以對象本身進行修改。以下總結出Python列表的主要屬性：

• 任意對象的有序集合
• 通過偏移讀取列表內容
• 可變長度，異構以及任意嵌套：異構的含義是列表中的元素可以是不同數據對象類型。
• 屬於可變序列的分類：可以在對象原處修改，任何修改都不會產生新的對象，而是在原來的內存空間上進行修改。
• 對象引用數組：當列表賦值給一個變量時，總是會將該列表的引用賦值給變量，而不是重新拷貝一個新的對象（除非有明確要求使用拷貝，拷貝產生新的對象）

列表基本操作

>>> l=[1,2,3,4,'a','b','c',[6,7,8,9,0]]    #聲明一個列表
>>> len(l)                                 #求列表的長度，即元素的個數
8
>>> l[2]                                   #用偏移量來訪問指定位置元素
3
>>> l[7]                                   #列表中可以嵌套列表
[6, 7, 8, 9, 0] 
>>> l*2                                    #列表複製
[1, 2, 3, 4, 'a', 'b', 'c', [6, 7, 8, 9, 0], 1, 2, 3, 4, 'a', 'b', 'c', [6, 7, 8, 9, 0]]
>>> l                                              
[1, 2, 3, 4, 'a', 'b', 'c', [6, 7, 8, 9, 0]]
>>> l.append('zz')                       #在列表尾端添加元素
>>> l
[1, 2, 3, 4, 'a', 'b', 'c', [6, 7, 8, 9, 0], 'zz']
>>> l.append('[zz]')
>>> l
[1, 2, 3, 4, 'a', 'b', 'c', [6, 7, 8, 9, 0], 'zz', '[zz]']
>>> l.append(['o','p','q'])             # append方法是添加一個元素
>>> l
[1, 2, 3, 4, 'a', 'b', 'c', [6, 7, 8, 9, 0], 'zz', '[zz]', ['o', 'p', 'q']]
>>> l.extend([99,88,77])                # extend方法是，將參數列表合併成爲一個列表
>>> l
[1, 2, 3, 4, 'a', 'b', 'c', [6, 7, 8, 9, 0], 'zz', '[zz]', ['o', 'p', 'q'], 99, 88, 77]
>>> l.sort()                           # 有不同的類型，字符類型與數字無法進行比較排序
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: str() < int()
>>> l.index(1)                         # 找到爲1的元素的偏移量
0
>>> l
[1, 2, 3, 4, 'a', 'b', 'c', [6, 7, 8, 9, 0], 'zz', '[zz]', ['o', 'p', 'q'], 99, 88, 77]
>>> l.index(99)                        # 返回99的元素偏移量
11
>>> l.count(99)                        # 元素99的個數
1
>>> l.pop()                            # 取出尾端元素，並從列表中刪除
77
>>> l
[1, 2, 3, 4, 'a', 'b', 'c', [6, 7, 8, 9, 0], 'zz', '[zz]', ['o', 'p', 'q'], 99, 88]
>>> del l[0]                          # 刪除偏移量爲0的元素
>>> l
[2, 3, 4, 'a', 'b', 'c', [6, 7, 8, 9, 0], 'zz', '[zz]', ['o', 'p', 'q'], 99, 88]
>>> l.remove('a')                     #刪除列表中爲a的元素
>>> l
[2, 3, 4, 'b', 'c', [6, 7, 8, 9, 0], 'zz', '[zz]', ['o', 'p', 'q'], 99, 88]
>>> 

列表迭代和解析

列表迭代就是用循環語句將列表中的每一個元素取出來執行一些特定的語句。
列表解析類似的，就是把序列中的每一個元素取出，執行特定的表達式從而生成新的列表的方式。列表解析的編碼更簡單，而且執行的速度更快。這與map函數有相似的作用。

>>> [ i**2 for i in range(5)]
[0, 1, 4, 9, 16]
>>> [ i**2 for i in range(5) if i % 2 ==0]
[0, 4, 16]
>>> 

分片賦值

>>> l=[1,2,3,4]
>>> l[1:3]=[6,7,8,9]         #分片賦值操作，實際上是將等號座標的偏移量中的元素刪除後，再加入等號右邊的元素
>>> l                        #一次性替換掉整個分片的片段
[1, 6, 7, 8, 9, 4]
>>> l[1:4]=[]               # 因爲分片賦值是先刪除，後插入元素的操作，用這種特性可以巧妙的刪除一個分片片段
>>> l
[1, 9, 4]
>>> 

字典

除了列表之外，Python中的字典也是很靈活的核心對象類型。與列表不同的是，字典是無序的映射集合（列表是有序的序列集合），字典主要有以下幾個主要屬性：

• 通過鍵而不是偏移量來讀取：因字典是映射而且無序的集合，字典就無法通過偏移量來讀取內容，只能採取鍵的形式
• 任意對象的無序集合：字典中的對象沒有順序。
• 可變長，異構，任意嵌套
• 屬於可變映射類型
• 對象引用表（散列表）：字典是支持鍵讀取的引用表，從本質上講，字典是作爲散列表（支持快速檢索的數據結構）來實現的，此外，Python採用最優化的散列算法來尋找鍵，因此搜索是很快速的。

字典基本操作

字典是在花括號中，以一系列的”鍵：值(key:value)”對形式寫出的。

>>> zi={"name":"liximin","age":88,"address":'chengdu'}
>>> zi
{'address': 'chengdu', 'age': 88, 'name': 'liximin'}
>>> zi
{'address': 'chengdu', 'age': 88, 'name': 'liximin'}
>>> for i in zi : print(i)                                    # 字典鍵值的迭代
... 
address
age
name
>>> zi
{'address': 'chengdu', 'age': 88, 'name': 'liximin'}
>>> zi.update({'interest':{'music':'classic','balls':'football'}})     #字典合併 
>>> zi
{'address': 'chengdu', 'interest': {'music': 'classic', 'balls': 'football'}, 'age': 88, 'name': 'liximin'}
>>> zi['interest']['balls']                                        # 字典嵌套多層鍵值引用
'football'
>>> zi['age']
88
>>> zi
{'address': 'chengdu', 'interest': {'music': 'classic', 'balls': 'football'}, 'age': 88, 'name': 'liximin'}
>>> zi.pop('age')                                                 # 字典取出元素
88
>>> zi
{'address': 'chengdu', 'interest': {'music': 'classic', 'balls': 'football'}, 'name': 'liximin'}
>>> zi.keys()
dict_keys(['address', 'interest', 'name'])
>>> len(zi)                                                       # 字典長度
3
>>> 'name' in zi                                                # 判斷字典中鍵值是否存在
True
>>> zi.get('aaa','ppp')                                         # 如果沒有找到相應的鍵值，則返回一個默認值
'ppp'

雖然字典是無序，但是如果要對他們進行排序，可以取出他們的鍵值列表再對列表進行排序，以按照順序來取的字典中的值。

字典使用注意事項

• 序列運算對於字典來說無效。字典是映射機制，並不是序列。
• 對新鍵值賦值會添加字典元素。
• 鍵不一定總是字符串，字典中的鍵值總是唯一。

Python3.0中的字典變化

• 支持一種新的字典解析表達式，這與列表解析很類似
• 對於字典中的key,values,items方法返回的不再是列表，而是可迭代的視圖
• 不再直接支持相對大小的比較——取而代之的是手動比較
• 不再有has_key方法——相反，使用in成員關係測試

字典解析

動態初始化一個字典的標準方式都是：將其鍵和值對應起來，並把它傳遞給dict函數。zip函數是在調用鍵和值的兩個列表來構建字典的方式：

>>> list(zip(['a','b','c'],[1,2,3]))               
[('a', 1), ('b', 2), ('c', 3)]
>>> dict(zip(['a','b','c'],[1,2,3]))             #Python2.6和Python3.0中都可以使用
{'a': 1, 'c': 3, 'b': 2}
>>> 

在python3.0中可以使用字典解析來構建一個新的字典：

>>> {i:i**2 for i in range(10)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
>>> 

Python3中，字典有自己的迭代器，它會返回連續鍵。

>>> zi
{'address': 'chengdu', 'interest': {'music': 'classic', 'balls': 'football'}, 'name': 'jy'}
>>> for i in zi: print(i)
... 
address
interest
name
>>> 

字典鍵值排序

字典的key values items方法返回值都相比python2.6來說都有些不同，不會直接返回列表，再排序之前需要轉化爲列表：

>>> zi.items()
dict_items([('address', 'chengdu'), ('interest', {'music': 'classic', 'balls': 'football'}), ('name', 'jy')])
>>> zi.keys() 
dict_keys(['address', 'interest', 'name'])
>>> zi.values()
dict_values(['chengdu', {'music': 'classic', 'balls': 'football'}, 'jy'])
>>> zi.keys().sort(0
... 
KeyboardInterrupt
>>> zi.keys().sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'dict_keys' object has no attribute 'sort'
>>> zikey=list(zi.keys())              # 將keys函數返回的對象轉化成爲列表，然後對列表進行排序
>>> zikey.sort()
>>> zikey
['address', 'interest', 'name']
>>> 

總結

字典與列表在python中是很常見的，使用起來非常靈活而且功能也非常強大，它們都是可變的，支持在原處修改對象本身。在使用時要分清可變性與不可變性。
列表是有序的序列類型，可以根據偏移量來訪問列表內部的元素；字典是無序的映射類型，只能通過鍵值來訪問，如果對字典中的元素順序有要求時，可以對鍵值進行排序。字典的迭代器會返回自己的鍵值。