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() |
|
4 |
radiansdict.get(key, default=None) |
|
5 |
key in dict |
|
6 |
radiansdict.items() |
|
7 |
radiansdict.keys() |
|
8 |
radiansdict.setdefault(key, default=None) |
|
9 |
radiansdict.update(dict2) |
|
10 |
radiansdict.values() |
|
11 |
pop(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,數據只出現一次,只關心數據是否出現, 不關心其位置;