摘要：下面讓我們一塊來看下的中高級數據結構。到現在，我們學習了列表元組字典和集合種高級數據結構。

< 返回索引頁

高級數據結構

列表與元組

什么是列表

列表的操作

什么是元組

元組的操作

字典與集合

字典的定義

字典的操作

集合的定義

集合的操作

序列

序列的通用操作

可變類型和不可變類型

深copy和淺copy

總結

練習

參考

我們知道Python的變量數據類型有整型、浮點型、復數、字符串和布爾型，我們會發現這些類型結構都比較的簡單。在我們學習數學時，有整數、浮點數等這些基本的數據類型，還有數組等這種高級的數據類型供我們來處理一些復雜的數據問題使用。那么Python語言作為一門高級的編程語言，對這些高級的數據結構也是支持的。

下面讓我們一塊來看下Python的中高級數據結構。

列表，Python 類為list，一種Python的高級數據結構，使用中括號包含，其中內部元素使用逗號分隔，內部元素可以是任何類型包含空。有點像我們數學中學習的數組。

a = [1,2,3]
b = ["1",2,None]
c = [1,2,[3,4]]
d = []
e = [1]

知識點：
列表中的元素是有序的。

列表的下標操作

獲取列表中的值

列表和字符串一樣是可以通過下標來獲取指定位置的元素的。列表的下標是從1開始的，最大下標值為元素個數減1或-1表示。

>>> a = [1,2,3]
>>> print(a[1])
2

列表更新

可通過列表的下標來替換更新列表中指定元素。

>>> a = [1,2,3]
>>> a[2] = "2"
>>> a
[1, 2, "2"]
>>>

列表的刪除

>>> a
[1, 2, "2"]
>>> del a[2]
>>> a
[1, 2]

切片

可通過下標來做列表的截取等操作，在Python中也叫切片。格式如：list[start_index:end_index:step_length]
start_index開始下標省略時，默認為 0 ；end_index結束下標省略時，默認為最大下標，及長度-1或-1；step_length步長省略時，默認為1。

>>> a
[1, 2, 3, 4]
>>> a[1:-1]
[2, 3]
>>> t = [1,2,3,4,5]
>>> t[::2]
[1, 3, 5]

運算符及內建函數操作

可用使用內建函數len 來獲取列表的長度，該長度及列表元素的個數。

>>> a
[1, 2]
>>> len(a)
2
>>> a[::2]
[1, 3]

列表可使用運算符 +實現連接操作。

>>> [1,2,3]+[5,6,7]
[1, 2, 3, 5, 6, 7]

可以使用內建函數reversed 將列表反轉，該函數返回一個迭代器(可理解為一個可遍歷對象即可，后邊會講解)。

>>> a = [1,2,3,4]
>>> reversed(a)
  
>>> list(reversed(a))
[4, 3, 2, 1]

除了使用reversed 函數，也可使用列表的切片來反轉：

>>> a
[1, 2, 3, 4]
>>> a[::-1]
[4, 3, 2, 1]

python 可使用 * 來實現重復。

>>> [1]*2
[1, 1]

列表也支持in、not in成員運算符

>>> 3 in [1,2,3]
True
>>> 3 not in [1,2,3]
False

列表的方法

>>> dir(list)
["__add__", "__class__", "__contains__", "__delattr__", "__delitem__", "__dir__", "__doc__", "__eq__", "__format__", "__ge__", "__getattribute__", "__getitem__", "__gt__", "__hash__", "__iadd__", "__imul__", "__init__", "__init_subclass__", "__iter__", "__le__", "__len__", "__lt__", "__mul__", "__ne__", "__new__", "__reduce__", "__reduce_ex__", "__repr__", "__reversed__", "__rmul__", "__setattr__", "__setitem__", "__sizeof__", "__str__", "__subclasshook__", "append", "clear", "copy", "count", "extend", "index", "insert", "pop", "remove", "reverse", "sort"]

list.append(obj) 在列表末尾添加新的對象

list.count(obj) 統計某個元素在列表中出現的次數

list.extend(seq) 在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表）

list.index(obj) 從列表中找出某個值第一個匹配項的索引位置

list.insert(index, obj) 將對象插入列表

list.pop([index=-1]]) 移除列表中的一個元素（默認最后一個元素），并且返回該元素的值

list.remove(obj) 移除列表中某個值的第一個匹配項

list.reverse() 反向列表中元素

list.sort(cmp=None, key=None, reverse=False) 對原列表進行排序

list.clear() 清空列表

list.copy() 復制列表

元組，Python中類為 tuple。使用小括號包括，內部元素使用逗號分隔，可為任意值。與列表不同之處為，其內部元素不可修改，及不能做刪除、更新操作。

>>> a = (1,2,3)
>>> b = ("1",[2,3])
>>> c = ("1","2",(3,4))
>>> d = ()
>>> e = (1,)

說明：
當元組中元素只有一個時，結尾要加逗號。若不加逗號，python解釋器將解釋成元素本身的類型，而非元組類型。

通過下標操作

通過小標來獲取元素值，使用方法同列表。

切片的處理，使用方法同列表。

不可通過下標做刪除和更新操作。

>>> c[0] = 1
Traceback (most recent call last):
  File "", line 1, in 
TypeError: "tuple" object does not support item assignment
>>> del c[0]
Traceback (most recent call last):
  File "", line 1, in 
TypeError: "tuple" object doesn"t support item deletion

運算符及內建函數操作

元組本身是不可變，但是可通過+來構成新的元組。

>>> a
(1, 2, 3)
>>> b
("1", [2, 3])
>>> a + b
(1, 2, 3, "1", [2, 3])

可使用內建函數 len 獲取元組長度。

可使用* 元素符實現元素的重復。

>>> a
(1, 2, 3)
>>> a*2
(1, 2, 3, 1, 2, 3)

元組也支持in和not in 成員運算符。

在編程世界中，有一種高級結構是使用比較廣泛的，即key和value值一一對應的映射結構。它就像一個字典一樣，通過關鍵字key，來找到對應的value值。該種結構在Python中叫做字典，英文為dict，使用大括號包括，其中元素為冒號分隔key-value對，中間用逗號分隔。

結構如下：

>>> a = {"name":"Tim", "age":18}
>>> b = {}
>>> c = dict(name="Tim", age=18)
>>> d = {(1,2):"Time"}

知識點：

字典中，key 值唯一，且類型為不可變類型，如字符串、元組、數字。
value 值可以為任意類型；
字典中的元素是無序的。

獲取字典某元素

可使用key和方法get來獲取字典中的值。

>>> a = {"name":"Tim", "age":18}
>>> a["name"]
"Tim"
>>> a.get("name","")
"Tim"
>>> a["address"]
Traceback (most recent call last):
  File "", line 1, in 
KeyError: "address"

知識點：

當字典沒有沒有該key時，使用key獲取，會拋出KeyError錯誤；使用get不會拋出，會返回None。
可使用get(key,[default])函數給

更新和刪除字典

字典是可變的，可通過key來做更新和刪除操作。

# 修改 
>>> a
{"name": "Tim", "age": 18}
>>> a["address"] = "Beijing"
>>> a
{"name": "Tim", "age": 18, "address": "Beijing"}
# 刪除
>>> del a["age"]
>>> a
{"name": "Tim", "address": "Beijing"}

字典的方法操作

字典的方法提供了更加豐富的操作功能：

radiansdict.clear() 刪除字典內所有元素

radiansdict.copy() 返回一個字典的淺復制，返回原字典的引用

radiansdict.fromkeys() 創建一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值

radiansdict.get(key, default=None) 返回指定鍵的值，如果值不在字典中返回default值

key in dict 如果鍵在字典dict里返回true，否則返回false

radiansdict.items() 以列表返回可遍歷的(鍵, 值) 元組數組

radiansdict.keys() 以列表返回一個字典所有的鍵

radiansdict.setdefault(key, default=None) 和get()類似, 但如果鍵不存在于字典中，將會添加鍵并將值設為default

radiansdict.update(dict2) 把字典dict2的鍵/值對更新到dict里

radiansdict.values() 以列表返回字典中的所有值

pop(key[,default]) 刪除字典給定鍵 key 所對應的值，返回值為被刪除的值。key值必須給出。 否則，返回default值。

popitem() 隨機返回并刪除字典中的一對鍵和值(一般刪除末尾對)。

集合（set）和字典（dict）類似，它是一組 key 的集合，但不存儲 value。集合的特性就是：key 不能重復。

>>> s = {"1","2","3"}  # 不推薦，當元素中有字典時，會報錯
>>> s
{"2", "1", "3"}
>>> s2 = set(["1","2","3"])
>>> s2
{"2", "1", "3"}
>>> type(s)

>>> type(s2)

交集、并集和合集

Python中的集合與數學中的集合一樣，也有交集、并集和合集。

>>> s1 = {1,2,3,4,5}
>>> s2 = {1,2,3}
>>> s3 = {4,5}
>>> s1&s2   # 交集
{1, 2, 3}
>>> s1|s2   # 并集
{1, 2, 3, 4, 5}  
>>> s1 - s2  # 差差集
{4, 5}
>>> s3.issubset(s1)   # s3 是否為s1 的子集
True
>>> s1.issuperset(s2)  # s1 是否為 s2 的超集
True

集合的方法操作

集合中常用方法如下：

set.add(obj) 添加集合元素

set.remove(obj) 刪除集合元素

set.update(set) 合并集合

set.pop() 隨機刪除一個元素，并返回該元素

序列(sequence)，在Python中是一種具有相同特性的高級數據結構的統稱，可以使用下標來獲取元素和切分。到現在，我們學習了列表、元組、字典和集合4種高級數據結構。可以發現，列表和元組在操作上有許多相同的地方。除了列表和元組，還有字符串也是序列。可見列表、元組、字符串為序列，字典、集合、數值為非序列。

通過索引來獲取元素值

分片操作

通過+合并元素

通過*來復制元素

支持成員運算符

最大值、最小值和長度函數支持

>>> l = [1,2,3]
>>> t = (1,2,3)
>>> s = "123"
>>> print(l[0],t[1],s[2])
1 2 3
>>> print(l[:1],t[:2],s[:-1])
[1] (1, 2) 12
>>> print(l+[4], t+(4,), s+"4" )
[1, 2, 3, 4] (1, 2, 3, 4) 1234
>>> print(l*2, t*2, s*2)
[1, 2, 3, 1, 2, 3] (1, 2, 3, 1, 2, 3) 123123
>>> print(2 in l, 2 in t, "2" in s)
True True True
>>> print(max(l), min(t), len(s))
3 1 3

除了序列，Python中還可以根據數據結構內存中的數值是否可以被改變，分為可變類型和不可變類型。

這里的可變不可變，是指內存中的值是否可以被改變。如果是不可變類型，在對對象本身操作的時候，必須在內存中新申請一塊區域(因為老區域#不可變#)。如果是可變類型，對對象操作的時候，不需要再在其他地方申請內存，只需要在此對象后面連續申請(+/-)即可，也就是它的地址會保持不變，但區域會變長或者變短。

可變類型（mutable）：列表，字典，集合；

不可變類型（unmutable）：數字，字符串，元組；

在學習字典時，字典有個copy，可以得到字典的副本。其他類型如何處理呢，Python提供了一個內置的copy庫用來支持其他類型的復制。copy庫主要有2個方法，copy 和 deepcopy分別表示淺拷貝和深拷貝。淺拷貝是新創建了一個跟原對象一樣的類型，但是其內容是對原對象元素的引用。這個拷貝的對象本身是新的，但內容不是。拷貝序列類型對象（列表元組）時，默認是淺拷貝。

下面咱們來分析下淺拷貝和深拷貝的區別。

普通情況下，賦值只是創建一個變量，該變量指向值內存地址，如下例：

n4 = n3 = n2 = n1 = "123/"Wu""

n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n2 = n1

淺拷貝，在內存中只額外創建第一層數據，如下圖：

import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n3 = copy.copy(n1)

深拷貝，在內存中將所有的數據重新創建一份（排除最后一層，即：python內部對字符串和數字的優化），如下圖：

import copy
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n4 = copy.deepcopy(n1)

圖片來源：博客地址

到此，我們把Python的基本語法和數據結構過了一遍。那我們來總結下，我們都學到了什么：

1、高級數據結構及其操作：列表、元組、字典、集合、序列；

這些只是基本語法的組成元素。在程序運行時，可能會有多種情況，需要對這些結構做判斷或者需要按順序讀取列表的全部元素，那么這個時候便需要邏輯處理結構。下一章，我們來講解Python中的邏輯處理的控制流語法。

1、現在有一個包含N個元素的元組或者是序列，怎樣將它里面的值解壓后同時賦值給N個變量？

>>> data = [ "ACME", 50, 91.1, (2012, 12, 21) ]
>>> name, shares, price, date = data
>>> data = [ "ACME", 50, 91.1, (2012, 12, 21) ]
>>> _, shares, price, _ = data

2、怎樣從一個集合中獲得最大或者最小的N個元素列表？

max([1,2,2,3])
min([1,2,3,4])

3、大家知道字典是無序的，如何給字典排序?

from collections import OrderedDict

d = OrderedDict()
d["foo"] = 1
d["bar"] = 2
d["spam"] = 3
d["grok"] = 4
print(d)

https://github.com/jackfrued/Python-100-Days/blob/master/Day01-15/Day02/%E8%AF%AD%E8%A8%80%E5%85%83%E7%B4%A0.md

http://www.cnblogs.com/wupeiqi/articles/5433925.html