python基礎2.0版（3）—數據結構之列表與元組

思維導圖

序列

• 概況

序列是一種數據存儲方式，用來存儲一系列數據。在內存中，序列就是一塊地用來存放多個值的連續的內存空間。比如一個整數序列[1，2，3，4]，可以表示爲：

在python3中一起皆對象，在內存中實際是按照下圖方式存儲的：
a=[1，2，3，4]

注意：四個元素就是四個對象，而存入列表的是這些對象的地址，不是值。列表本身也是對象，列表的地址傳給了變量a

• 常用的序列結構：

字符串，列表，元組，字典，集合

一、列表簡介

列表是用於存儲任意數目、任意類型的數據結合
列表是可變序列，是包含多個元素的有序連續的內存空間
列表中的元素可以各不相同，可以是任意類型

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

二、列表的創建

1.基本語法[]創建

2.list（）創建

使用list（）可以將任何可迭代的數據轉化爲列表。數字，字符串均可。

>>> a=list(range(5))
>>> a
[0, 1, 2, 3, 4]
>>> a=list('hello')
>>> a
['h', 'e', 'l', 'l', 'o']

3.range（）創建列表

range（）語法格式爲:
range([start]： end ：step])
start參數:可選，表示起始數字，默認是0
end參數:必選,表示結尾數字。
step參數:可選，表示步長，默認爲1，步長爲複數表示倒序
python3中range（）返回的是一個range 對象，而不是列表。我們需要通過list（）方法將其轉換成列表對象

>>> a=list(range(3,10,3))
>>> a
[3, 6, 9]
>>> a=list(range(3,-6,-1))
>>> a
[3, 2, 1, 0, -1, -2, -3, -4, -5]
>>> a=list(range(3,-6,-2))
>>> a
[3, 1, -1, -3, -5]

4.推導式生成列表

循環創建多個元素

>>> a=[x*3 for x in range(5)] 
>>> a
[0, 3, 6, 9, 12]

用if條件過濾

>>> a=[x*3 for x in range(5) if x%2==0]
>>> a
[0, 6, 12]

三、元素添加

列表元素的增加和刪除

當列表增加和刪圳除元素時,列表會自動就進行內存管理，大大減少了程序員的負擔。但這個特點涉及列表元素的大量移動，效率較低。除非必要,一般只在列表的尾部添加元素或刪除元素，這會大大提高列表的操作效率。

1.append（）方法

原地修改列表對象，在列表尾部添加新的元素,速度最快,推薦使用。

>>> a=[5,6]
>>> a.append(7)
>>> a
[5, 6, 7]

2.+運算符操作

並不是真正的尾部添加元素,而是創建新的列表對象;將原列表的元素和新列表的元素依次複製到新的列表對象中。這樣會涉及大量的複製操作，對於操作大量元索不建議使用。

>>> a=[10,20]
>>> id(a)
2602949497864
>>> a=a+[40]
>>> id(a)
2602949500680
>>> a
[10, 20, 40]
這裏比較奇怪
>>> a+=[2]
>>> a
[10, 20, 40, 2]
>>> id(a)
2602949500680

3.extend（）方法

將目標列表的所有元素添加到本列表的 尾部，是原地操作，不創建新的列表對象

>>> a=[10,20]
>>> b=[20,30]
>>> a.extend(b)
>>> a
[10, 20, 20, 30]

4.insert（）插入元素

使用insert（）方法可以將指定的元素插入到表對象的任意制定位置。這樣會讓插入位置後面所有的元素進行移動，會影響處理速度。涉及大量元素時,儘量避免使用。類似發生這種移動的函數還有:remove（）、pop（）、del（），它們在刪除非尾部元素時也會發生操作位置後面元素的移動。

>>> a=[10,20]
>>> a.insert(1,100) #在a[1]位置插入100
>>> a
[10, 100, 20]

5.乘法擴展

使用乘法擴展列表，生成一個新列表，新列表元素是原列表元素的多次重複

>>> a=[10,20]
>>> id(a)
2602949567304
>>> a*3
[10, 20, 10, 20, 10, 20]
>>>
>>> id(a*3)
2602949578376

四、元素刪除

1.del 刪除
刪除列表指定位置的元素

>>> a=[1,2,3,4,5,6]
>>> del a[1]
>>> a
[1, 3, 4, 5, 6]

2.pop（）方法
pop（）刪除並返回指定位置元素，如果沒有指定位置則默認操作列表最後一個元素

>>> a=[1,2,3,4,5,6]
>>> a.pop()
6
>>> a
[1, 2, 3, 4, 5]
>>> a.pop(3) #3是列表中元素的位置
4
>>> a
[1, 2, 3, 5]

3.remove（）方法
刪除首次出現的指定元素，不存在該元素拋出異常

>>> a=[1,2,3,4,5,6]
>>> a.remove(9)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> a.remove(5)
>>> a
[1, 2, 3, 4, 6]

五、元素訪問和計數

1.通過索引直接訪問元素

我們可以通過索引 直接訪問元素，索引的區間在[0，len(列表)-1]，超出這個範圍報錯

>>> a=[1,2,3,4,5,6]
>>> a[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> a[5]
6

2.index（）

index()獲得指定元素在列表中首次出現的索引
語法：index（value，[start，end]）

>>> a=[1,2,3,4,5,4,3,2,1]
>>> a.index(2)
1
>>> a.index(3,3)#從索引位置3開始向後搜索第一個3
6
>>> a.index(4,1,7) #從索引位置1開始向後搜索第一個4，直到索引位置7，不包括位置7
3

3.count（）獲得指定元素在列表中出現的次數

>>> a=[1,2,3,4,5,4,3,2,1]
>>> a.count(5)
1

4.len（）

返回列表長度，即是列表包含元素個數

5.成員資格判斷

判斷列表中是否有某個元素用關鍵字in

>>> a=[1,2,3,4,5,4,3,2,1]
>>> 6 in a
False

六、切片操作

切片是Python序列及其重要的操作,適用於列表、元組、字符串等等。切片的格式下:
切片slice 操作可以讓我快速提是取子列表或修改。標格式爲:
[起始偏移量start：終止偏移量end：步長step]
注:當步長省略時順便可以省略第二個冒號

• 典型操作(三個量爲正數的情況)如下:
  
• 其他操作(三個量爲負數的情況)如下:
  
  注：切片操操作時，起始偏移量和終止偏移量不在範圍內，也不報錯。起始偏移量小於0則會當做0，終止偏移量大於‘列表長度-1’，會被當成‘列表長度-1’

>>> a=[1,2,3,4,5,4,3,2,1]
>>> a[0:10]
[1, 2, 3, 4, 5, 4, 3, 2, 1]

七、排序

1.sort()修改原列表，不建新列表

>>> a=[1,2,3,4,5,4,3,2,1]
>>> a.sort() #默認升序
>>> a
[1, 1, 2, 2, 3, 3, 4, 4, 5]
>>> a.sort(reverse=True) #降序
>>> a
[5, 4, 4, 3, 3, 2, 2, 1, 1] 

2.sorted()建新列表

排序返回新列表 ，不對原列表修改

>>> a=[1,2,3,4,5,4,3,2,1]
>>> id(a)
2602949822728
>>> a=sorted(a)
>>> a
[1, 1, 2, 2, 3, 3, 4, 4, 5]
>>> id(a)
2602949833928

3.reverse（）

單純將列表元素反着排序

>>> a=[1,2,3,4,5,4]
>>> a.reverse()
>>> print(a)
[4, 5, 4, 3, 2, 1]

4.reversed（）返回迭代器

reversed（）也支持逆序排列，與列表對象reverse（）方法的區別是，reversed（）不對原列表修改，只是返回一個逆序排列的迭代器對象

>>> a=[1,2,3,4,5,4,3,2,1]
>>> c=reversed(a)
>>> c
<list_reverseiterator object at 0x0000025E0BE6D9C8>
>>> list(c)
[1, 2, 3, 4, 5, 4, 3, 2, 1]
>>> list(c) #第二次運行，已經變成空列表
[]

八、列表相關的其它內置函數

1.max和min，用於返回列表中最大值和最小值
2.sum對數值型列表的所有元素進行求和，對非數值運算報錯

>>> a=[1,2,3,4,5,4,3,2,1]
>>> max(a)
5
>>> sum(a)
25

九、多維列表

一維列表存儲一維、線性數據
二維列表存儲二維、表格的數據

姓名 年齡 城市
狗蛋 22 北京
旺財 23 長沙
鐵柱 22 南京

>>> a=[['狗蛋',22,'北京'],
... ['旺財',23,'長沙'],
... ['鐵柱',22,'南京']]
>>> a
[['狗蛋', 22, '北京'], ['旺財', 23, '長沙'], ['鐵柱', 22, '南京']]
>>> a[1]
['旺財', 23, '長沙']
>>> a[1][2]
'長沙'

嵌套循環打印二維列表所有數據

>>> for m in range(3):
...     for n in range(3):
...         print(a[m][n],end="\t")
...     print()
...
狗蛋    22      北京
旺財    23      長沙
鐵柱    22      南京

十、元組

1.特點

列表屬於可變序列,可以任意修改列表中的元素。元組屬於不可變序列,不能修改元組中的 元素。因此,元組沒有增加元素、修改元素、刪除元素相關的方法。
因比,我們只需要學習元組的創建和刪除，元組中元素的訪間問和計數即可。元組支持如下操作:
索引訪間
切片操作
連接操作
成員關係操作
比較運算操作年
計數∶元組長度len、最大值max、最小值min、求和 sum等。
並且這些操作與列表是一樣的

2.元組的創建

通過（）創建，（）可以省略

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

如果元組只有一個元素，必須後面加逗號

通過tuple（）創建

>>> b=tuple('123')
>>> b
('1', '2', '3')
>>> b=tuple([1,2,3])
>>> b
(1, 2, 3)

生成器推導創建元組

從形式上看，生成器推導式與列表推導式類似,只是生成器推導式使用小括號。列表推導式直接生成爲表對象，生成器推導式生成的不是列表也不是元組，而是—個生成器對象。
我們可以通過生成器對象，轉化成列表或者元組。也可以使用生成器對象的_next_()方法進行遍歷，或者直接作爲迭代器對象來使用。不管什麼方式使用，元素訪問結束後，如果需要重新訪問回其中的元素，必須重新創建該生成器對象。

>>> a=(x*3 for x in range(5))
>>> a
<generator object <genexpr> at 0x0000025E0BE32C48>
>>> tuple(a)
(0, 3, 6, 9, 12)
>>> list(a) #只能訪問一次，第二次就爲空了，需要再生成一次
[]
>>> a
<generator object <genexpr> at 0x0000025E0BE32C48>


>>> a=(x*3 for x in range(5))
>>> a.__next__()
0
>>> a.__next__()
3
>>> a.__next__()

十一、元組元素的訪問、排序

1.訪問

同列表一樣，不過返回的是元組對象

>>> a=(1,2,3,4,5,4,3,2,1)
>>> a[0:2]
(1, 2)

2.排序

因爲元組元素不能修改，只能用sorted（）排序

>>> a=(1,2,3,4,5,4,3,2,1)
>>> sorted(a)
[1, 1, 2, 2, 3, 3, 4, 4, 5]

十二、元組總結

1.元組的核心帶點是:不可變序列。
2.元組的訪問和處理速度比列表快。
3.與整數和字符串一樣，元組可以作爲字典的鍵，列表則永遠不能作爲字典的鍵使用。