Python搬磚之旅(4th day)：串列資料型別專題

第1章 串列的創建

串列是在Python編程程序中最常見的資料型別之一，串列是一組"有序的、可重復的元素集合"，也就是說，從資料結構角度看，Python 的串列是一個"長度可變"的、每一個元素順序排列的"佇列"，串列中的每一
個位置存放的都是資料物件的"指標"，

我們可以將不同資料型別的元素"有序"地存放在串列當中，元素與元素之間使用逗號","隔開，

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> li
[123, 123.5, 'hello', b'Python', [1, 2, 3]]
>>> id(li)
45716616
>>> id(li[0])
1745059104
>>> id(li[1])
29956880
>>> id(li[2])
45734128
>>> id(li[3])
37271792
>>> id(li[4])
45740552

串列創建之后，為什么其中的資料型別可以不一樣呢？
因為串列中的每一個的元素，都是一個指標，指向不同的資料物件，我們使用id()函式分別查看li, li[0], li[1], li[2], li[3], li[4]在記憶體中的地址，發現其實這些元素在記憶體空間上都是"不連續"的，而正因為串列中包含了指向這些元素的"指標"，這些元素看起來才是"有序"的，下面使用一幅圖來說明這個問題，

創建空串列的兩種方法：
第1種，使用一對方括號，

li = []    #  創建一個空串列，
>>> 

第2種方法：呼叫list() 方法

li = list()

這兩種方法的效果是一樣的，

第2章 訪問并修改串列元素

與字串相似，串列也是通過index索引訪問串列中的元素，

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> li[0]
123
>>> li[1]
123.5
>>> li[2]
'hello'
>>> li[3]
b'Python'
>>> li[4]
[1, 2, 3]
>>> li[-1]
[1, 2, 3]

注意：索引的數值不能超出串列的長度（串列中的元素個數）

與字串不同的是，字串是"不可修改"的序列，如果要修改字串中的某個字符需要重新賦值；
但是，串列中的元素可以直接通過索引訪問并修改元素，

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> li[-1] = [1, 2, 3, 4]     # 修改串列中最后一個元素
>>> li
[123, 123.5, 'hello', b'Python', [1, 2, 3, 4]]
>>> li[0], li[1] = li[1], li[0]    # 串列中前兩個元素互換
>>> li
[123.5, 123, 'hello', b'Python', [1, 2, 3, 4]]

小練習：
li = [‘a’, ‘b’, ‘c’]， 將’a’ 改為 ‘A’，
答案：li[0] = ‘A’

第3章 遍歷串列元素

串列的遍歷有四種方式：
第1種方式：使用while回圈

li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
i = 0    # 設定索引從0開始
while i < len(li):
    print(li[i], end=" ")
    i += 1

第2種方式：使用迭代

li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
for i in li:
    print(i, end=" ")

第3種方式：使用迭代+索引

li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
for i in range(len(li)):
    print(li[i], end=" ")

第4種：使用enumerate()函式遍歷
enumerate()函式可以將一個可迭代物件，如串列、元組或字串組合成為一個索引序列，同時列出索引和元素值，一般與for 回圈結合使用，

li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
for i, value in enumerate(li):
    print(f'第{i}個索引對應的值是：{value}', end="\n")

第4章 增加串列元素

增加串列元素的方式有3種：
方法1：使用list.insert (index, obj)的方法，將資料物件obj插入到串列指定的位置上，

>>> li = [1, 2, 3]
>>> li.insert(0, "a")   # 把字串"a"插入到串列的第一個位置
>>> li
['a', 1, 2, 3]

方法2：使用list.append(obj)的方法，將資料物件obj插入到串列的最后，

>>> li = [1, 2, 3]
>>> li.append("a")      # append()方法會把元素插入到串列末尾
>>> li
[1, 2, 3, 'a']

方法3： 使用list.extend() 方法，將兩個串列的元素合并到一個串列中，

>>> li_1 = ["a", "b", "c"]
>>> li_2 = [1, 2, 3]
>>> li_1.extend(li_2)
>>> li_1
['a', 'b', 'c', 1, 2, 3]

第5章 洗掉串列元素

洗掉串列元素有3種方法，
方法1：使用del li[index]的方法

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> del li[0]
>>> li
[123.5, 'hello', b'Python', [1, 2, 3]]
>>> del li
>>> li
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    li
NameError: name 'li' is not defined

說明：
1，使用del 陳述句，會對串列造成永久性的改變，會將索引對應的元素從串列中洗掉‘
2，直接使用del + 串列名的方式，會永久性洗掉該串列，

方法2：
使用list.remove(value)的方式，

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> li.remove(123)
>>> li
[123.5, 'hello', b'Python', [1, 2, 3]]
>>> li.remove('China')
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    li.remove('China')
ValueError: list.remove(x): x not in list

說明：
1，使用remove()方法，會對串列造成永久性的改變，會將值所對應的元素從串列中洗掉‘；
2，洗掉不存在于串列中的值會報錯，

方法3：
使用list.pop(index)的方式

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> li.pop()
[1, 2, 3]
>>> li
[123, 123.5, 'hello', b'Python']
>>> li.pop(0)
123
>>> li
[123.5, 'hello', b'Python']

說明：
1，使用pop()方法，會對串列造成永久性的改變，會將索引所對應的元素從串列中洗掉‘并回傳該值；
2，pop()方法默認洗掉并回傳串列中最后一個元素，使用索引后洗掉并回傳索引對應的值，

第6章 串列的運算子

同字串一樣，串列可以使用"+“實作字串的拼接，用”*"實作字串的序列復制，
用in 和 not in 判斷元素是否存在于串列當中，

>>> li_1, li_2 = ["a", "b", "c"], [1, 2, 3]
>>> print(li_1 + li_2)    # + 運算子實作串列元素的拼接
['a', 'b', 'c', 1, 2, 3]
>>> print(li_1 * 2)       # * 運算子實作串列元素的復制
['a', 'b', 'c', 'a', 'b', 'c']
>>> print('a' in li_1)    # in 運算子判斷元素是否屬于串列
True
>>> print(2 not in li_2)  # not in 運算子判斷元素是否不屬于串列
False

注意："+" 運算子的功能等同于list.extend()方法，但是推薦使用"+" 運算子，可以獲得更直觀的效果和更高的運行效率，

第7章 串列的常用內置函式

len() : 回傳串列的長度，即串列中包含的元素個數；
max() : 回傳串列中的元素最大值；
min()： 回傳串列中的元素最小值，
count() ： 回傳元素在串列中出現的次數
index(value)：從串列中找出value第一個匹配項的索引位置
copy() ： 復制串列
clear() ： 清空串列

>>> li = [1, 1, 2, 2, 2, 4, 3, 5]
>>> print(len(li))    # 計算串列長度
8
>>> print(min(li))    # 求串列中的最小值
1
>>> print(max(li))    # 求串列中的最大值
5
>>> print(li.count(2))   # 求串列中元素出現的次數
3
>>> print(li.index(2))   # 求元素在串列中首次出現的位置
2
>>> li_2 = li.copy()     # 復制串列
>>> li_2
[1, 1, 2, 2, 2, 4, 3, 5]
>>> li_2.clear()         # 清除串列
>>> li_2
[]

注意：串列中元素比較大小，
1，字串與字串之間比較轉為ASCII碼比較；
2，字串與數字之間不可以比較，否則會報錯，

第8章 串列的切片

同字串一樣，我們可以對串列進行切片，
切片的語法格式是：list[start : stop : step]
當start起點位置是串列首位時，start 可以忽略；當end終點位置是len(list)+1時，即取到串列最后一位時，stop 可以省略；當步長為1時，step可以省略，

同字串一樣，串列中元素的位置按從左向右的順序，從0開始依次向后；
逆向位置排列是從最后一個元素的位置-1開始，向前依次遞減；
切片的索引發生錯誤并不會報錯，而是會回傳空字串，

>>> li = [123, 123.5, "hello", b'Python', [1, 2, 3]]
>>> li[:]   # 該方法相當于li[0:len(li)+1:1]
[123, 123.5, 'hello', b'Python', [1, 2, 3]]
>>> li[::2] # 該方法相當于li[0:len(li)+1:2]
[123, 'hello', [1, 2, 3]]
>>> li[1::2] # 該方法相當于li[1:len(li)+1:2]
[123.5, b'Python']
>>> li[::-1] # 該方法相當于li[-1:-6:-1]
[[1, 2, 3], b'Python', 'hello', 123.5, 123]
>>> li[::-2] # 該方法相當于li[-1:-6:-2]
[[1, 2, 3], 'hello', 123]
>>> li[-2::-2]  # 該方法相當于li[-2:-6:-2]
[b'Python', 123.5]

需要注意的是，
1，切片的方向與步長方向應一致，否則會回傳空字串，
2，修改串列的切片會影響串列本身，

第9章 串列的排序

串列的排序：
升序排列：使用list.sort()方法或sorted(list)方法
降序排列：使用list.sort(reverse=True)方法

>>> li = [32, 77, 64, 27, 55, 96, 13]
>>> li.sort()   # sort()方法會永久改變串列中元素的順序
>>> li
[13, 27, 32, 55, 64, 77, 96]

>>> li = [32, 77, 64, 27, 55, 96, 13]
>>> print(sorted(li))   # sorted()方法是一個臨時性方法，不會永久改變串列中元素的順序
[13, 27, 32, 55, 64, 77, 96]
>>> print(li)
[32, 77, 64, 27, 55, 96, 13]

>>> li.sort(reverse = True)   # 實作串列的降序排列需要使用引數reverse=True
>>> li
[96, 77, 64, 55, 32, 27, 13]

注意：
1，sort()方法會永久改變串列中元素的順序，
2，sorted()方法是一個臨時性方法，不會永久改變串列中元素的順序，
3，實作串列的降序排列需要使用引數reverse=True，

第10章 串列的轉置

實作串列的轉置有3種方法：
方法1：使用切片，注意，切片只是在串列的副本上操作，并不會影響串列本身，

>>> li = [32, 77, 64, 27, 55, 96, 13]
>>> print(li[::-1]) 
[13, 96, 55, 27, 64, 77, 32]
>>> print(li)
[32, 77, 64, 27, 55, 96, 13]

方法2：使用list.reverse()方法，注意，reverse()方法會永久改變串列中元素的順序，

>>> li = [32, 77, 64, 27, 55, 96, 13]
>>> li.reverse()   # reverse()方法會永久地改變串列中元素的順序
>>> print(li)
[13, 96, 55, 27, 64, 77, 32]
>>> print(li.reverse()) # reverse()方法不回傳值
None

方法3：使用reversed(list)方法，注意，reversed方法是一個臨時性的方法，不會改變串列本身，

>>> li = [32, 77, 64, 27, 55, 96, 13]
>>> print(reversed(li))   # reversed()方法不能直接使用，需要轉化為串列才可以使用
<list_reverseiterator object at 0x0000000002BCD4A8>
>>> li_2 = list(reversed(li))
>>> print(li_2)    # 強制型別轉化為串列
[13, 96, 55, 27, 64, 77, 32]
>>> print(li)
[32, 77, 64, 27, 55, 96, 13]

第11章 串列的嵌套

串列中包含的元素仍然是串列，通常稱為串列的嵌套，嵌套的層數也稱之為串列的維度，
比如下面這個串列就是一個典型的二維串列，我們可以通過索引的方式來訪問子串列中的元素，
觀察下列代碼，學習使用跌打和索引的方法訪問二維串列中的元素，

li = [[1, 2, 3],[1.1, 2.2, 3.3],["a", "b", "c"]]
# 獲得第二個子串列中1.1這個元素
print(li[1][0])
# 遍歷二維串列
# 方法1：迭代
for list_item in li:
    for item in list_item:
        print(item, end=" ")
print()
# 方法2：使用索引
for i in range(len(li)):
    for j in range(len(li[i])):
        print(li[i][j], end=" ")