Python中的列表跟元組的使用教學

　　Python 中的 列表跟元組 的使用

　　一、列表和元組基礎：

　　列表和元組，都是一個可以放置任意數據類型的有序集合。

　　在很多語言中，集合的數據類型必須一致。不過，對于 Python 的列表和元組來說，并無此要求：

　　my_list = [66, 77, 'fe', 'cow'] # 列表中同時含有int和string類型的元素

　　print(my_list)

　　# 輸出結果： [66, 77, 'fe', 'cow']

　　my_tuple = ('fe_cow', 666) # 元組中同時含有int和string類型的元素

　　print(my_tuple)

　　# 輸出結果 ('fe_cow', 666)

　　那么它們之間有什么區別呢?

　　列表是動態：長度大小不固定，可以隨意地增加、刪減或者改變元素。

　　元組是靜態：長度大小固定，無法增加刪減或者改變。

　　下面舉個栗子：

　　分別創建一個列表和元組。對于列表很輕松的在列表中添加最后一個元素，但是相同操作元組就會報錯：

　　my_list = [1, 2, 3, 4]

　　my_list[3] = 5 # python 中索引是從0進行開始的 my_list[3] 表示訪問列表的第四個元素

　　print(my_list)

　　# 輸出結果： [1, 2, 3, 5]

　　my_tuple = (1, 2, 3, 4)

　　my_tuple[3] = 5

　　print(my_tuple)

　　# 報錯結果：

　　Traceback (most recent call last):

　　File "", line 1, in

　　TypeError: 'tuple' object does not support item assignment

　　如果想對已有的元組做"改變"，那就只能重新開辟一塊內存，創建新的元組了。

　　my_tuple= (1, 2, 3)

　　new_tuple = my_tuple + (4, )

　　print(new_tuple)

　　# 輸出結果： (1, 2, 3, 4)

　　Python 中的列表和元組都支持負數索引：

　　// 列表的負數索引

　　my_list = [1, 2, 3, 4]

　　my_list[-1]

　　4

　　// 元組的負數索引

　　my_tuple = (1, 2, 3, 4)

　　my_tuple[-2]

　　3

　　-1 表示最后一個元素，-2 表示倒數第二個元素，以此類推。

　　Python 列表和元組都支持切片操作：

　　// 列表切片操作

　　my_list = [1, 2, 3, 4]

　　my_list[1:3]

　　[2, 3]

　　// 元組切片操作

　　my_tuple = (1, 2 ,3 ,4)

　　my_tuple[1:3]

　　(2, 3)

　　索引從1到2，簡單理解：“前閉后開”

　　Python 可通過list() 和 tuple() 函數相互轉換：

　　// 元組轉換成列表

　　list((1, 2, 3))

　　[1, 2, 3]

　　// 列表轉換成元組

　　tuple([1, 2, 3])

　　(1, 2, 3)

　　Python 列表 和 元組的常見內置函數：

　　// 列表操作

　　my_list = [3, 2, 3, 7, 8, 1]

　　my_list.count(3)

　　2

　　my_list.index(7)

　　3

　　my_list.reverse()

　　my_list

　　[1, 8, 7, 3, 2, 3]

　　my_list.sort()

　　my_list

　　[1, 2, 3, 3, 7, 8]

　　// 元組操作

　　my_tuple = (3, 2, 3, 7, 8, 1)

　　my_tuple.count(3)

　　2

　　my_tuple.index(7)

　　3

　　list(reversed(my_tuple))

　　[1, 8, 7, 3, 2, 3]

　　sorted(my_tuple)

　　[1, 2, 3, 3, 7, 8]

　　count(item)：表示統計列表 / 元組中 item 出現的次數。

　　index(item)：表示返回列表 / 元組中 item 第一次出現的索引。

　　list.reverse() 和 list.sort() 分別表示原地倒轉列表和排序。

　　注意，元組沒有內置的這兩個函數，需要把元組轉換成列表在進行此函數的操作

　　reversed() 和 sorted() 同樣表示對列表 / 元組進行倒轉和排序，但是會返回一個倒轉后或者排好序的新的列表 / 元組。

　　二、列表和元組存儲方式差異：

　　// 使用__sizeof__() 查看 存儲空間

　　my_list = [1,2 ,3 ,4]

　　my_list.__sizeof__()

　　72

　　my_tuple = (1, 2, 3, 4)

　　my_tuple.__sizeof__()

　　56

　　可以看到，放置了相同的元素，那么元組存儲的空間卻比列表要少16字節。為什么呢?原因如下：

　　列表是動態的，所以它需要存儲指針，來指向對應的元素(int型，8字節)。

　　列表可變，所以需要額外存儲已經分配的長度大小(8 字節)，這樣才可以實時追蹤列表空間的使用情況，當空間不足時，及時分配額外空間。

　　下面描述列表空間分配過程：鄭州人流價格 http://www.zzzykdfk.com/

　　my_list = []

　　my_list.__sizeof__() // 空列表的存儲空間為40字節

　　40

　　my_list.append(1)

　　my_list.__sizeof__()

　　72 // 加入了元素1之后，列表為其分配了可以存儲4個元素的空間 (72 - 40)/8 = 4

　　# 記錄往后加入4個元素

　　my_list.append(2)

　　my_list.__sizeof__()

　　72 // 由于之前分配了空間，所以加入元素2，列表空間不變

　　my_list.append(3)

　　my_list.__sizeof__()

　　72 // 加入元素3，列表空間不變

　　my_list.append(4)

　　my_list.__sizeof__()

　　72 // 加入元素4，列表空間不變

　　my_list.append(5)

　　my_list.__sizeof__()

　　104 // 加入元素5之后，列表的空間不足，所以又額外分配了可以存儲4個元素的空間

　　為了減少列表每次的增加/刪除操作時空間分配的開銷，Python每次分配空間時，都會額外多分配一些;

　　這樣機制保證了其操作的高效性：增加/刪除的時間復雜度0(1);

　　對于元組來說，元組長度大小固定，元素不可變，所以存儲空間固定。

　　三、列表和元組的性能：

　　從上述的兩者之間的存儲方式差異，可以得出結論，元組要比列表更加輕量級一些，元組的性能速度要略優于列表。

　　在Python后臺，對靜態數據做一些資源緩存。因為垃圾回收機制的存在，如果一些變量不被使用了，Python 就會回收它們所占用的內存，返還給操作系統，以便其他變量或其他應用使用。

　　對于一些靜態變量，比如元組，它不被使用并且占用空間不大時，Python 會暫時緩存這部分內存。下次我們再創建同樣大小的元組時，Python 就不用再向操作系統發出請求，可直接尋找內存，而是可以直接分配之前緩存的內存空間，這樣就能大大加快程序的運行速度。

　　四、列表和元組的使用場景：

　　如果存儲的數據和數量不變，僅需要將數據直接傳給前端渲染，那么肯定選用元組更合適。

　　// 比如給前端返回經緯度

　　def get_location():

　　.....

　　return (longitude, latitude)

　　如果存儲的數據或數量是可變的，那么則用列表更合適。

　　// 比如給前端返回 每個增加教師的信息

　　teacher_list = [] // 里面存儲的是

　　result = DB(teacherID) // 從數據庫拿出一周內新增教師的信息，返回的是QuerySet

　　for item in result:

　　teacher_list.append(item)

　　五、總結：

　　列表和元組都是有序的，可以存儲任意的數據類型的集合，主要區別在于：

　　列表是動態的，長度可變，可以隨意的增加、刪減或改變元素。

　　列表的存儲空間略大于元組，性能略遜于元組;

　　元組是靜態的，長度大小固定，不可以對元素進行增加、刪減或者改變操作。

　　元組相對于列表更加輕量級，性能稍優;

　　六、list()、與 [ ] 效率有什么區別嗎?

　　區別在于：

　　list( ) 是一個函數的調用，Python 函數調用 會創建 堆，并且進行一系列參數檢查的操作。

　　[ ] 是一個 內置的C函數，可以直接調用，因此效率較高。