摘要：下面讓我們一塊來看下的中高級數(shù)據(jù)結(jié)構(gòu)。到現(xiàn)在，我們學(xué)習(xí)了列表元組字典和集合種高級數(shù)據(jù)結(jié)構(gòu)。

< 返回索引頁

高級數(shù)據(jù)結(jié)構(gòu)

列表與元組

什么是列表

列表的操作

什么是元組

元組的操作

字典與集合

字典的定義

字典的操作

集合的定義

集合的操作

序列

序列的通用操作

可變類型和不可變類型

深copy和淺copy

總結(jié)

練習(xí)

參考

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

下面讓我們一塊來看下Python的中高級數(shù)據(jù)結(jié)構(gòu)。

列表，Python 類為list，一種Python的高級數(shù)據(jù)結(jié)構(gòu)，使用中括號包含，其中內(nèi)部元素使用逗號分隔，內(nèi)部元素可以是任何類型包含空。有點像我們數(shù)學(xué)中學(xué)習(xí)的數(shù)組。

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

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

列表的下標(biāo)操作

獲取列表中的值

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

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

列表更新

可通過列表的下標(biāo)來替換更新列表中指定元素。

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

列表的刪除

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

切片

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

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

運算符及內(nèi)建函數(shù)操作

可用使用內(nèi)建函數(shù)len 來獲取列表的長度，該長度及列表元素的個數(shù)。

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

列表可使用運算符 +實現(xiàn)連接操作。

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

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

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

除了使用reversed 函數(shù)，也可使用列表的切片來反轉(zhuǎn)：

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

python 可使用 * 來實現(xiàn)重復(fù)。

>>> [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) 統(tǒng)計某個元素在列表中出現(xiàn)的次數(shù)

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

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

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

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

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

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

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

list.clear() 清空列表

list.copy() 復(fù)制列表

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

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

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

通過下標(biāo)操作

通過小標(biāo)來獲取元素值，使用方法同列表。

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

不可通過下標(biāo)做刪除和更新操作。

>>> 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

運算符及內(nèi)建函數(shù)操作

元組本身是不可變，但是可通過+來構(gòu)成新的元組。

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

可使用內(nèi)建函數(shù) len 獲取元組長度。

可使用* 元素符實現(xiàn)元素的重復(fù)。

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

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

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

結(jié)構(gòu)如下：

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

知識點：

字典中，key 值唯一，且類型為不可變類型，如字符串、元組、數(shù)字。
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"

知識點：

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

更新和刪除字典

字典是可變的，可通過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() 刪除字典內(nèi)所有元素

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

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

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

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

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

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

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

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

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

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

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

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

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

>>> type(s2)

交集、并集和合集

Python中的集合與數(shù)學(xué)中的集合一樣，也有交集、并集和合集。

>>> 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中是一種具有相同特性的高級數(shù)據(jù)結(jié)構(gòu)的統(tǒng)稱，可以使用下標(biāo)來獲取元素和切分。到現(xiàn)在，我們學(xué)習(xí)了列表、元組、字典和集合4種高級數(shù)據(jù)結(jié)構(gòu)?？梢园l(fā)現(xiàn)，列表和元組在操作上有許多相同的地方。除了列表和元組，還有字符串也是序列。可見列表、元組、字符串為序列，字典、集合、數(shù)值為非序列。

通過索引來獲取元素值

分片操作

通過+合并元素

通過*來復(fù)制元素

支持成員運算符

最大值、最小值和長度函數(shù)支持

>>> 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中還可以根據(jù)數(shù)據(jù)結(jié)構(gòu)內(nèi)存中的數(shù)值是否可以被改變，分為可變類型和不可變類型。

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

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

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

在學(xué)習(xí)字典時，字典有個copy，可以得到字典的副本。其他類型如何處理呢，Python提供了一個內(nèi)置的copy庫用來支持其他類型的復(fù)制。copy庫主要有2個方法，copy 和 deepcopy分別表示淺拷貝和深拷貝。淺拷貝是新創(chuàng)建了一個跟原對象一樣的類型，但是其內(nèi)容是對原對象元素的引用。這個拷貝的對象本身是新的，但內(nèi)容不是?？截愋蛄蓄愋蛯ο螅斜碓M）時，默認(rèn)是淺拷貝。

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

普通情況下，賦值只是創(chuàng)建一個變量，該變量指向值內(nèi)存地址，如下例：

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

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

淺拷貝，在內(nèi)存中只額外創(chuàng)建第一層數(shù)據(jù)，如下圖：

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

深拷貝，在內(nèi)存中將所有的數(shù)據(jù)重新創(chuàng)建一份（排除最后一層，即：python內(nèi)部對字符串和數(shù)字的優(yōu)化），如下圖：

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

圖片來源：博客地址

到此，我們把Python的基本語法和數(shù)據(jù)結(jié)構(gòu)過了一遍。那我們來總結(jié)下，我們都學(xué)到了什么：

1、高級數(shù)據(jù)結(jié)構(gòu)及其操作：列表、元組、字典、集合、序列；

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

1、現(xiàn)在有一個包含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