list
Python 内置的一種資料類型是清單：list。list 是一種有序的集合，可以
随時添加和删除其中的元素
如：
classmates = ['Michael', 'Bob', 'Tracy']
len(classmates) 計算個數
通路
>>> classmates[0]
'Michael'
>>> classmates[1]
'Bob'
>>> classmates[2]
'Tracy’
還可以用 -1 做索引，直
接擷取最後一個元素：
>>> classmates[-1]
'Tracy'
當索引超出了範圍時，Python 會報一個 IndexError 錯誤，是以，要確定
索引不要越界，記得最後一個元素的索引是 len(classmates) - 1 。
添加
1 classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']
append 往 list 中追加元素到末尾
2 classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
Insert 把元素插入到指定的位置，比如索引号為 1 的位置
删除
1 classmates.pop('Adam')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']
pop ()删除 list 末尾的元素 删除指定位置的元素，用 pop(i) 方法，其中 i 是索引位置
修改
classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']
list 裡面的元素的資料類型也可以不同，比如：
>>> L = ['Apple', 123, True]
list 元素也可以是另一個 list，比如：
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
擷取的方式 s[2][1]
Python清單腳本操作符
清單對 + 和 * 的操作符與字元串相似。+ 号用于組合清單，* 号用于重複清單。
如下所示：
| Python 表達式 | 結果 | 描述 |
| len([1, 2, 3]) | 3 | 長度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 組合 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重複 |
| 3 in [1, 2, 3] | True | 元素是否存在于清單中 |
| for x in [1, 2, 3]: print x, | 1 2 3 | 疊代 |
Python清單截取與拼接
Python的清單截取與字元串操作類型，如下所示：
L=['Google', 'Runoob', 'Taobao']
操作：
| Python 表達式 | 結果 | 描述 |
| L[2] | 'Taobao' | 讀取第三個元素 |
| L[-2] | 'Runoob' | 從右側開始讀取倒數第二個元素: count from the right |
| L[1:] | ['Runoob', 'Taobao'] | 輸出從第二個元素開始後的所有元素 |
Python清單函數&方法
Python包含以下函數:
| 序号 | 函數 |
| 1 | len(list) 清單元素個數 |
| 2 | max(list) 傳回清單元素最大值 |
| 3 | min(list) 傳回清單元素最小值 |
| 4 | list(seq) 将元組轉換為清單 |
Python包含以下方法:
| 序号 | 方法 |
| 1 | list.append(obj) 在清單末尾添加新的對象 |
| 2 | list.count(obj) 統計某個元素在清單中出現的次數 |
| 3 | list.extend(seq) 在清單末尾一次性追加另一個序列中的多個值（用新清單擴充原來的清單） |
| 4 | list.index(obj) 從清單中找出某個值第一個比對項的索引位置 |
| 5 | list.insert(index, obj) 将對象插入清單 |
| 6 | list.pop(obj=list[-1]) 移除清單中的一個元素（預設最後一個元素），并且傳回該元素的值 |
| 7 | list.remove(obj) 移除清單中某個值的第一個比對項 |
| 8 | list.reverse() 反向清單中元素 |
| 9 | list.sort([func]) 對原清單進行排序 |
| 10 | list.clear() 清空清單 |
| 11 | list.copy() 複制清單 |
tuple
另一種有序清單叫元組：tuple。tuple 和 list 非常類似，但是 tuple 一旦
初始化就不能修改，
如：
tup1 = ('Google', 'Runoob', 1997, 2000);
建立空元組
tup1 = ();
元組中隻包含一個元素時，需要在元素後面添加逗号
tup1 = (50,);
元組與字元串類似，下标索引從0開始，可以進行截取，組合等。
通路元組
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])print ("tup2[1:5]: ", tup2[1:5])
以上執行個體輸出結果：
tup1[0]: Google
tup2[1:5]: (2, 3, 4, 5)
修改元組
元組中的元素值是不允許修改的，但我們可以對元組進行連接配接組合，如下執行個體:
#!/usr/bin/python3
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
# 以下修改元組元素操作是非法的。# tup1[0] = 100
# 建立一個新的元組
tup3 = tup1 + tup2;print (tup3)
以上執行個體輸出結果：
(12, 34.56, 'abc', 'xyz')
删除元組
元組中的元素值是不允許删除的，但我們可以使用del語句來删除整個元組，如下執行個體:
#!/usr/bin/python3
tup = ('Google', 'Runoob', 1997, 2000)
print (tup)del tup;print ("删除後的元組 tup : ")print (tup)
以上執行個體元組被删除後，輸出變量會有異常資訊，輸出如下所示：
删除後的元組 tup : Traceback (most recent call last):
File "test.py", line 8, in <module>
print (tup)NameError: name 'tup' is not defined
元組運算符
與字元串一樣，元組之間可以使用 + 号和 * 号進行運算。這就意味着他們可以組合和複制，運算後會生成一個新的元組。
| Python 表達式 | 結果 | 描述 |
| len((1, 2, 3)) | 3 | 計算元素個數 |
| (1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 連接配接 |
| ('Hi!',) * 4 | ('Hi!', 'Hi!', 'Hi!', 'Hi!') | 複制 |
| 3 in (1, 2, 3) | True | 元素是否存在 |
| for x in (1, 2, 3): print x, | 1 2 3 | 疊代 |
元組索引，截取
因為元組也是一個序列，是以我們可以通路元組中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
元組：
L = ('Google', 'Taobao', 'Runoob')
| Python 表達式 | 結果 | 描述 |
| L[2] | 'Runoob!' | 讀取第三個元素 |
| L[-2] | 'Taobao' | 反向讀取；讀取倒數第二個元素 |
| L[1:] | ('Taobao', 'Runoob!') | 截取元素，從第二個開始後的所有元素。 |
運作執行個體如下：
>>> L = ('Google', 'Taobao', 'Runoob')>>> L[2]'Runoob'>>> L[-2]'Taobao'>>> L[1:]('Taobao', 'Runoob')
元組内置函數
Python元組包含了以下内置函數
| 序号 | 方法及描述 | 執行個體 |
| 1 | len(tuple) 計算元組元素個數。 | >>> tuple1 = ('Google', 'Runoob', 'Taobao')>>> len(tuple1)3>>> |
| 2 | max(tuple) 傳回元組中元素最大值。 | >>> tuple2 = ('5', '4', '8')>>> max(tuple2)'8'>>> |
| 3 | min(tuple) 傳回元組中元素最小值。 | >>> tuple2 = ('5', '4', '8')>>> min(tuple2)'4'>>> |
| 4 | tuple(seq) 将清單轉換為元組。 | >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']>>> tuple1=tuple(list1)>>> tuple1('Google', 'Taobao', 'Runoob', 'Baidu') |
Python list和tuple的互相轉換
list轉為tuple：
temp_list = [1,2,3,4,5]
将temp_list進行強制轉換：tuple(temp_list)
檢視是否轉換成功：print type(temp_list)
tuple 轉為list：
temp_tuple = (1,2,3)
方法類似，也是進行強制轉換即可：list(temp_tuple)
檢視是否轉換成功：print type(temp_tuple)
list 特點
1. 查找和插入的時間随着元素的增加而增加；
2. 占用空間小，浪費記憶體很少
List 和tuple 差別
不同點：
1 定義的方式
list[] tuple()
2 是否可變
list可變 tuple() 不可變
3 list中有 append()，insert() 函數，tuple中沒有
相同點：
都是有序的集合
dict
Python 内置了字典：dict 的支援，dict 全稱 dictionary，在其他語言中也
稱為 map，使用鍵-值（key-value）存儲，具有極快的查找速度
如：
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
指派
一個 key 隻能對應一個 value，是以，多次對一個 key 放入 value，
後面的值會把前面的值沖掉
擷取
如果 key 不存在，dict 就會報錯避免 key 不存在的錯誤，有兩種辦法
1 'Thomas' in d
False
2 通過 dict 提供的 get 方法，如果 key 不存在，可以傳回 None，或者
自己指定的 value：
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
添加
d[‘test’] =’adfds’
删除
删除一個 key，用 pop(key) 方法，對應的 value 也會從 dict 中删除：
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}
注意，dict 内部存放的順序和 key 放入的順序是沒有關系的
周遊字典方式
1 for key in user.keys():
print("key:",key)
print("value:",user[key])
2
for key,value in user.items():
print(key,value)
字典内置函數&方法
Python字典包含了以下内置函數：
| 序号 | 函數及描述 | 執行個體 |
| 1 | len(dict) 計算字典元素個數，即鍵的總數。 | >>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> len(dict)3 |
| 2 | str(dict) 輸出字典，以可列印的字元串表示。 | >>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> str(dict)"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}" |
| 3 | type(variable) 傳回輸入的變量類型，如果變量是字典就傳回字典類型。 | >>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> type(dict)<class 'dict'> |
Python字典包含了以下内置方法：
| 序号 | 函數及描述 |
| 1 | radiansdict.clear() 删除字典内所有元素 |
| 2 | radiansdict.copy() 傳回一個字典的淺複制 |
| 3 | radiansdict.fromkeys() 建立一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值 |
| 4 | radiansdict.get(key, default=None) 傳回指定鍵的值，如果值不在字典中傳回default值 |
| 5 | key in dict 如果鍵在字典dict裡傳回true，否則傳回false |
| 6 | radiansdict.items() 以清單傳回可周遊的(鍵, 值) 元組數組 |
| 7 | radiansdict.keys() 以清單傳回一個字典所有的鍵 |
| 8 | radiansdict.setdefault(key, default=None) 和get()類似, 但如果鍵不存在于字典中，将會添加鍵并将值設為default |
| 9 | radiansdict.update(dict2) 把字典dict2的鍵/值對更新到dict裡 |
| 10 | radiansdict.values() 以清單傳回字典中的所有值 |
| 11 | pop(key[,default]) 删除字典給定鍵 key 所對應的值，傳回值為被删除的值。key值必須給出。 否則，傳回default值。 |
| 12 | popitem() 随機傳回并删除字典中的一對鍵和值。 |
key 必須是 不可變對象？ str number 元組
這是因為 dict 根據 key 來計算 value 的存儲位置，如果每次計算相同的
key 得出的結果不同，那 dict 内部就完全混亂了。這個通過 key 計算位
置的算法稱為雜湊演算法（Hash）。要保證 hash 的正确性，作為 key 的對象就不能變。在 Python 中，字元串、整數等都是不可變的，是以，可以放心地作為 key。而 list 是可變
的，就不能作為 key
Dict特點：
1：查找和插入的速度極快，不會随着 key 的增加而增加
2：浪費空間
3：key不可以重複，且不可變
4：資料無序排放
set
set 和 dict 類似，也是一組 key 的集合，但不存儲 value。由于 key 不能
重複，是以，在 set 中，沒有重複的 key。
建立一個 set，需要提供一個 list 作為輸入集合：
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
重複元素在 set 中自動被過濾
添加
通過 add(key) 方法可以添加元素到 set 中
>>> s.add(4)
>>> s
{1, 2, 3, 4}
删除
remove(key) 方法可以删除元素
兩個 set 可以做數學意義上的交集、并集等操作：
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
set 和dict差別
set 和 dict 的唯一差別僅在于沒有存儲對應的 value，但是，set 的原理和
dict 一樣，是以，同樣不可以放入可變對象，因為無法判斷兩個可變對
象是否相等，也就無法保證 set 内部“不會有重複元素”。
總結
list:清單,有序的項目, 通過索引進行查找,使用方括号”[]”;
tuple:元組,元組将多樣的對象集合到一起,不能修改,通過索引進行查找, 使用括号”()”;
dict:字典,字典是一組鍵(key)和值(value)的組合,通過鍵(key)進行查找,沒有順序, 使用大括号”{}”;
set:集合,無序,元素隻出現一次, 自動去重,使用”set([])”
dict的建立、通路時間一定是大于tuple的,但是在python中，dict是做過極度優化的，其效率已經非常高了是以在實際程式設計中，一般我們隻根據實際需求來考慮使用什麼資料結構 (dict, list, set, tuple)，而不是根據不同資料結構的通路速度差别。
應用場景:
list, 簡單的資料集合,可以使用索引;
tuple, 把一些資料當做一個整體去使用,不能修改;
dict,使用鍵值和值進行關聯的資料; key value
set,資料隻出現一次,隻關心資料是否出現, 不關心其位置;
![TestLink導出用例轉換工具(XML2Excel)[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)