（python）資料結構——列表

一、數字的處理函式

（一）int()

取整數部分，與正負號無關，舉例如下：

print(int(-3.6), int(-2.5), int(-1.4))
print(int(3.6), int(2.5), int(1.4))

執行結果如下：

　-3 -2 -1
　3 2 1

（二）//

整除並且向下取整，舉例如下：

print(7//2, 7//-2, -7//2, -(7//2))
print(2//3, -2//3, -1//3)

執行結果如下：

　3 -4 -4 -3
　0 -1 -1

（三）round()

四捨六入五取偶，舉例如下：

print(round(2.5), round(2.5001), round(2.6))
print(round(3.5), round(3.5001), round(3.6), round(3.3))
print(round(-2.5), round(-2.5001), round(-2.6))
print(round(-3.5), round(-3.5001), round(-3.6), round(-3.3))

執行結果如下：

　2 3 3
　4 4 4 3
　-2 -3 -3
　-4 -4 -4 -3

（四）floor()

向下取整，舉例如下：

import math

print(math.floor(2.5), math.floor(-2.5))

執行結果如下：
2 -3

（五）ceil()

向上取整，舉例如下：

import math

print(math.ceil(2.5), math.ceil(-2.5))

執行結果如下：
3 -2

（六）max()

獲取最大值

（七）min()

獲取最小值

（八）pow(x, y)

求次方（x的y次方），相當於x**y，也可以寫成這種形式。

（九）sqrt()

求平方根，舉例如下：

import math

print(math.sqrt(3))

執行結果如下：
1.7320508075688772

（十）bin()

將數字轉換為二進位制

（十一）oct()

將數字轉換為八進位制

（十二）hex()

將數字轉換為十六進位制

二、列表

（一）定義

• 列表是可變的、線性的資料結構
• 列表內的個體稱為元素，由若干個元素組成列表
• 元素可以是任意物件（數字、字串、物件、列表等）
• 列表內的元素是有序的，可以使用索引

（二）對列表的相關操作

1、列表索引訪問

列表可以通過索引去訪問其中的元素，索引的順序是從0開始的（從左向右），-1索引表示列表中的最後一個元素，依次類推。

lst = [`a`, 3, `b`]
print(lst[1])

執行結果如下：
3

2、list.index(value, [start, [stop]])

• 通過值value，從指定區間[start, stop]查詢元素中是否有這個值，如果有則返回對應位置的索引，如果沒有，就拋異常ValueError。
• 時間複雜度：O(n)，隨著資料規模的增大，效率下降，所以儘量避免使用這個方法。

lst = [`a`, 3, `b`]
print(lst.index(`a`))

執行結果如下:
0

3、list.count(value)

• 返回列表中值value的出現次數。
• 時間複雜度：O(n)，隨著資料規模的增大，效率下降，所以儘量避免使用這個方法。

lst = [`a`, 3, `b`, `a`]
print(lst.count(`a`))

執行結果如下：
2

4、列表元素的修改

• 列表是可變的有序的資料結構，所以可以根據其索引來修改列表中對應的元素。
• 注意，索引不能超界，否則丟擲異常IndexError。

lst = [`a`, 3, `b`, `a`]
lst[3] = `c`
print(lst)

執行結果如下：
[`a`, 3, `b`, `c`]

5、list.append(object)

• 在列表的尾部追加元素。
• 返回None，就地修改。
• 時間複雜度：O(1)，直接在列表尾部追加，所以對於效率沒有什麼影響。

lst = [`a`, 3, `b`, `a`]
lst.append(`d`)
print(lst)

執行結果如下：
[`a`, 3, `b`, `a`, `d`]

6、list.insert(index, object)

• 根據索引index，將元素插入到對應的位置。
• 返回None，就地修改。
• 時間複雜度：O(n)，所以這種方法不推薦使用，推薦使用append這種方法。
• 插入元素的時候索引可以超界，超過上界，頭部追加，超過下界，尾部追加。

lst = [`a`, 3, `b`, `a`]
lst.insert(2, `d`)
print(lst)

執行結果如下：
[`a`, 3, `d`, `b`, `a`]

7、list.extend(iteratable)

• 將可迭代物件的元素追加進行來。
• 返回None，就地修改。

lst = [`a`, 3, `b`, `a`]
lst.extend(`d`)
print(lst)

執行結果如下：
[`a`, 3, `b`, `a`, `d`]

8、+

• 將兩個列表連線起來，返回一個新的列表，原列表不變。

9、*

• 重複操作，將列表中的元素重複n次，返回一個新的列表。

10、list.remove(value)

• 找到匹配的值value，移除該值。
• 返回None，就地修改。
• 時間複雜度：O(n)，不建議使用這個方法。

lst = [3, 4, 2, 7]
lst.remove(4)
print(lst)

執行結果如下：
[3, 2, 7]

11、list.pop([index])

• 不指定索引index，則直接彈出列表尾部的值，指定索引，則彈出指定索引的值。
• 時間複雜度：不指定索引，時間複雜度O(1)，指定索引，時間複雜度O(n)。
• 注意，索引不能超界，否則拋異常IndexError。

lst = [3, 4, 2, 7]
lst.pop()
print(lst)
lst.pop(1)
print(lst)

執行結果如下：

　[3, 4, 2]
　[3, 2]

12、list.clear()

• 清除列表中的所有元素，返回一個空的列表。

13、list.reverse()

• 將列表中的元素進行反轉。
• 返回None，就地修改。

lst = [3, 4, 2, 7]
lst.reverse()
print(lst)

執行結果如下：
[7, 2, 4, 3]

14、list.sort(key=None, reverse=False)

• 將列表中的元素進行排序，預設為升序。
• 返回None，就地修改。
• reverse改為True，降序排列。

lst = [3, 4, 2, 7]
lst.sort()
print(lst)

執行結果如下：
[2, 3, 4, 7]

15、list.copy()

• 淺拷貝，將列表中的元素進行拷貝，返回一個新的列表。
• 注意，淺拷貝如果遇到引用型別的資料時，修改其中一個列表的引用型別另一個列表中的值也會改變。

lst = [3, [3, 4], 7]
lst2 = lst.copy()
print(lst2)
lst2[1][0] = 10
print(lst)
print(lst2)

執行結果如下：

　[3, [3, 4], 7]
　[3, [10, 4], 7]
　[3, [10, 4], 7]

16、copy.deepcopy(list)

• 深拷貝，將列表中的元素拷貝返回一個新的列表。
• 深拷貝就沒有引用型別資料修改變化的問題了。

import copy

lst = [3, [3, 4], 7]
lst2 = copy.deepcopy(lst)
print(lst2)
lst2[1][0] = 10
print(lst)
print(lst2)

執行結果如下：

　[3, [3, 4], 7]
　[3, [3, 4], 7]
　[3, [10, 4], 7]

三、random模組

1、randint(a, b)

• 返回a到b之間的整數

import random

print(random.randint(1, 10))

2、choice(seq)

• 從非空序列的元素中隨機挑選出一個元素

import random

print(random.choice([2, 5, 8]))

3、randrange([start, ] stop, [, step])

• 從指定範圍[start, stop]，按照指定的步數step隨機獲取一個數，step預設值為1.

import random

print(random.randrange(1, 10, 2))

4、shuffle(list)

• 就地打亂列表中的元素

import random

lst = [1, 2, 3, 4, 5]
random.shuffle(lst)
print(lst)

5、sample(population, k)

• 從樣本空間population中隨機取出k個不同的元素，返回一個新的列表。

import random

lst = [1, 2, 3, 4, 5]
lst2 = random.sample(lst, 2)
print(lst2)