列表和欄位都可以在原處進行修改，可以按照需求增長或縮短，並且可以包含任何型別的物件或被巢狀。列表和字典儲存的是物件的引用，而不是拷貝。

一，列表

列表是有序的序列，每一個列表項的順序是固定的，這使得列表可以通過指定的偏移來索引和分片。列表是可變的序列，支援在原處修改。

列表項可以是任何型別，或物件，也可以巢狀列表。

1，列表的建立

建立一個空的列表：

>>> l=[]

建立一個純數字列表：

>>> l=[1,2,3]

建立一個數字和字元的混合型別列表：

>>> l=[1,2,'a']

建立一個巢狀物件的列表：

>>> l=[1,'a',[2,'b']]
>>> l
[1, 'a', [2, 'b']]

建立一個範圍列表：

range() 函式用於建立一個整數列表，range函式語法：

range(start, stop[, step])

引數說明：

• start： 計數從 start 開始，預設是從 0 開始。例如range（5）等價於range（0， 5）;
• stop： 計數到 stop 結束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]沒有5
• step：步長，預設為1。例如：range（0， 5） 等價於 range(0, 5, 1)

使用range函式建立一個範圍列表：

>>> list(range(1,10,2))
[1, 3, 5, 7, 9]

2，列表解析

使用列表解析，可以使用迭代器來生成列表：

>>> l=[x**2 for x in range(0,5)]
>>> l
[0, 1, 4, 9, 16]

3，列表的索引和分片

列表和字串都是有序的序列，它們的索引和分片的格式很相似：

• l[i]：索引單個列表項
• l[i][j]：如果列表項是序列，那麼可以使用多重索引
• l[i:j]：對列表分片

例如：對列表進行索引和分片

>>> l=[1,'a',[2,'b']]
>>> l[1]
'a'
>>> l[2]
[2, 'b']
>>> l[2][1]
'b'
>>> l[0:2]
[1, 'a']

二，列表操作

列表的長度是固定的，不能越界訪問列表，列表的最大索引是列表長度-1，越界會導致Python報錯。

1，追加

向列表的末尾追加一個列表項： list.append(obj)

>>> l.append(4)
[1, 'a', [2, 'b'], 4]

向列表的末尾追加一個序列： list.extend(seq)

>>> l.extend([3,5])
[1, 'a', [2, 'b'], 4, 3, 5]

2，插入

向列表的特定位置插入一個列表項：list.insert(index,obj)

>>> l.insert(2,'b')
[1, 'a', 'b', [2, 'b'], 4, 3, 5]

3，移除列表項

移除列表中的列表項：list.pop(index=-1)

>>> l.pop(2)
'b'
>>> l
[1, 'a', [2, 'b'], 4, 3, 5]

或者使用 del 刪除列表項： del list[i]

>>> del l[5]
[1, 'a', [2, 'b'], 4, 3]

或者使用 list.remove(obj) 從列表中刪除指定的列表項：

>>> l.remove(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

4，修改列表項

由於列表是可變的，支援原處修改列表項，也就是說，可以通過索引直接修改列表物件。

>>> l[4]=l[4]+2
>>> l
[1, 'a', [2, 'b'], 4, 5]

5，對列表進行排序：list.sort()

 當列表項具有可比性時，可以對列表進行排序，list.sort(reverse=False)，

• reverse -- 排序規則，reverse = True 降序， reverse = False 升序（預設）。

>>> sl=['a','c','e','d']
>>> sl.sort()
>>> sl
['a', 'c', 'd', 'e']

6，檢視某一元素得索引 list.index(obj)

從列表中找出某個值第一個匹配項的索引位置

>>> l.index(5)
4

7，列表的其他操作

• 統計列表元素的數量：len(list)
• 列表的合併：list1+list2，生成新的列表
• 列表的重複：list*2，等價於 list+list，生成新的列表
• 列表的迭代： obj in list

+和* 會生成新的列表，而list.append()，list.sort()，list.xxx()等函式和del list[i]是在原處修改，不會生成新的列表。

三，字典

字典是鍵/值對構成的集合，字典通過大括號來建立，字典的鍵是字串，而值可以是任何資料物件。

字典有兩個重要的特徵：

• 字典是無序的，字典項沒有特定的順序，只能通過鍵來獲取值；
• 字典是可變的，支援原處修改鍵的值；
• 字典是作為散列表來實現的，可增長，搜尋非常快速；
• 和列表一樣，字典儲存的是物件的引用，不是拷貝。

1，建立字典

建立空的字典：

>>> d={}

建立包含兩個專案的字典：

>>> d={'name':'vic','age':28}

建立包含巢狀型別的字典：

>>> d={'student':{'name':'vic','age':28}}

通過dict函式來建立字典：

>>> d=dict(name='vic',age=28)
>>> d
{'name': 'vic', 'age': 28}

2，字典解析

使用字典解析，可以使用迭代器來生成字典：

>>> d={x:x**2 for x in range(0,5)}
>>> d
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

3，引用字典的值

通過鍵來引用字典的值

>>> d['name']
'vic'
>>> d['age']
28

或者使用dict.get(key, default)來獲取鍵對應的值，其中default引數的作用是：當不存在鍵時，返回default作為該鍵的值：

>>> d.get('name')
'vic'
>>> d.get('nam','jim')
'jim'

四，字典操作

字典的基本操作有：

• len(dict)：字典項的數量，或者字典鍵的數量
• dict.keys()：所有字典鍵的集合
• dict.values()：所有字典值得集合
• dict.items()：字典項（鍵/值對）的集合
• list(dict.keys())：把所有字典鍵轉換為列表
• list(dict.values())：把所有字典鍵的值轉換為列表
• d[key],d.get(key)：根據字典的鍵獲取值
• key in dict：檢查該key是否是字典的鍵

1，新增/修改字典項

如果字典中不存在Key，那麼新增該Key/Value對；如果存在該Key，那麼修改該Key的值。

>>> d=dict(name='vic',age=28)
>>> d['sex']='male'
{'name': 'vic', 'age': 28, 'sex': 'male'}
>>>
>>> d['sex']='man'
{'name': 'vic', 'age': 28, 'sex': 'man'}

2，刪除字典項

dict.pop(key) 用於刪除鍵為key的字典項

>>> d.pop('sex')
'man'
>>> d
{'name': 'vic', 'age': 28}

或者使用 del dict[key]來刪除鍵為key的字典項：

>>> del d['sex']

3，合併字典

dict.update(dict2)，把字典dict2合併到dict中

>>> d.update({'tel':'120'})
{'name': 'vic', 'age': 28, 'tel': '120'}

4，複製字典

dict.copy()獲得字典的一個深拷貝（deep copy）物件，深拷貝就是增加一個指標並且申請一個新的記憶體，使這個增加的指標指向這個新的記憶體。

dict2=dict：獲得字典的一個淺拷貝（shallow copy）物件，淺拷貝只是增加了一個指標指向已經存在的記憶體。

例如，深拷貝物件和原物件，指向不同的記憶體空間，修改任意一個字典，不會影響另外一個字典：

>>> d=dict(name='vic',age=28)
>>> dc=d.copy()   # deep copy
>>> dc['tel']=120
>>> d
{'name': 'vic', 'age': 28}
>>> dc
{'name': 'vic', 'age': 28, 'tel': 120}

而淺拷貝物件和原物件指向相同的記憶體空間，修改任意一個字典，另一個字典也會修改：

>>> d=dict(name='vic',age=28)
>>> sc=d     # shallow copy
>>> sc['tel']=110
>>> sc
{'name': 'vic', 'age': 28, 'tel': 110}
>>> d
{'name': 'vic', 'age': 28, 'tel': 110}

 

五，元組

元組（tuple）由小括號、逗號和資料物件構成的集合，各個項通過逗號隔開，元組的特點是：

• 元組項可以是任何資料型別，也可以巢狀
• 元組是一個位置有序的物件的集合，通過偏移來訪問元組項，
• 只不過元組是不可變的，不能在原處修改；
• 元組的各個項可以重複，例如，一個元組可以是：(1, 1, 2, 2, 3)

1，建立元組

建立空的元組，一個空元組就是一個內控的小括號：

>>> t=()

建立包含一個項的元組，t=(1,)是一個元組，t=(1)是一個整數：

>>> t=(1,)
(1,)

建立包含兩個項的元組：

>>> t=(1,'a')

使用tuple()函式建立元組：

>>> t=tuple('a')
>>> t
('a',)

2，索引元組

• t[i]：索引元組
• t[i][j]：索引巢狀元組
• t[i:j]：元組分片

六，元組的基本操作

• len(t)：元組項的數量
• t1+t2：元組的合併
• t*2 ：元組的重複，相當於t+t
• x in t：檢查x是否存在於元組t中
• t.index(obj)：元組中第一個項是obj的索引
• t.count(obj)：元組項為obj的數量

 

 

參考文件：