目錄
前言：
一、以表格的形式展示他們的差別：
二、清單、元組、字典、集合的定義區分：
1、清單的定義：
2、元組的定義：
3、字典的定義：
4、集合的定義：
三、清單、元組、字典、集合的方法（函數）：
1、清單的方法：
2、元組的方法：
3、字典的方法：
4、集合的方法：
四、清單、元組、字典、集合之間的比較：
1、元組和清單差別
2、字典和清單差別
3、集合和字典的差別
五、推導式建立序列：
1、清單推導式，文法如下：
2、字典推導式，文法如下：
3、集合推導式，文法如下：
4、元組沒有推導式：
前言：
面試Python時，如果把清單、元組、字典以及集合之間的差別，這個基礎的知識點講解清楚，就能反映出面試者的基礎水準，也必定會給面試官一個很好的印象。我們開始來闡述他們差別。
一、以表格的形式展示他們的差別：
| 清單 | 元組 | 字典 | 集合 | |
|---|---|---|---|---|
| 英文 | list | tuple | dict | set |
| 是否可讀寫 | 讀寫 | 隻讀 | 讀寫 | 讀寫 |
| 是否可重複 | 可以 | 可以 | 可以 | 不可以 |
| 存儲方式 | 值 | 值 | 鍵值對（鍵不可以重複） | 鍵（不能重複） |
| 是否有序 | 有序 | 有序 | 無序，自動正序 | 無序 |
| 初始化 | [1, 'aa'] | ('aa', 'bb') | {‘a’: 1, 'b': 2} | set([1, 2])或{‘a’, 'b'} |
| 添加 | append | 隻讀 | d[key] = 'value' | add |
| 讀元素 | l[1] | t[1] | d['a'] | 無 |
二、清單、元組、字典、集合的定義區分：
1、清單的定義：
list是存儲在方括号中的一組有序元素的資料結構，清單中的元素是可以添加、修改、删除、還可以查詢其中的元素。清單是可變、可嵌套的資料類型。python裡的清單用“[]”表示：
test_list = [1, 2, 3, 4]
print(test_list[0]) # 搜素其中某一項
# 1
test_list[1] = 'aa' # 修改某一項
print(test_list)
# [1, 'aa', 3, 4]
test_list.append('花花') # 添加一項
print(test_list)
# [1, 'aa', 3, 4, '花花']
test_list.extend('華晨宇') # 添加一項
print(test_list)
# [1, 'aa', 3, 4, '花花', '華', '晨', '宇']
2、元組的定義：
元組和清單類似，是存儲在圓括号中一組有序不可修改的元素的序列，隻可查詢其中的元素。通常情況下，元組用于儲存無需修改的内容。Python裡的元組用“()”表示：
需要注意的一點是，當建立的元組中隻有一個字元串類型的元素時，該元素後面必須要加一個逗号‘,’，否則 Python 解釋器會将它視為字元串。
t_tuple = ('故宮', '長城', '香山')
t_tuple
# ('故宮', '長城', '香山')
print(type(t_tuple))
# <class 'tuple'>
t2 = ('天壇')
t3 = ('頤和園',) # 當元組中隻有一個元素時，需要加一個逗号，否則Python解釋器認為是字元串。
print(type(t2), type(t3))
# <class 'str'> <class 'tuple'>
3、字典的定義：
字典是一種可變的容器模型，且可存儲任意類型的對象。元素由鍵（key）和值（value）組成的鍵值對 ，元素之間用逗号“，”分隔，鍵與值之間用冒号“：”隔開。
鍵必須是不可變且唯一的，如字元串，數字或元組，但值可以重複，值可以取任何資料類型。Python裡的元組用“{}”表示：
d_dict = {1: 'a', 2: 'b', 3: 'c'}
print(type(d_dict))
# <class 'dict'>
4、集合的定義：
與字典類似，但隻包含鍵，而沒有對應的值，包含的資料不重複。
s_set = {1, 2, 3}
print(type(s_set))
# <class 'set'>
三、清單、元組、字典、集合的方法（函數）：
1、清單的方法：
| 方法（函數） | 作用 | 具體的方法描述 |
|---|---|---|
| list.append(x) | 增加元素 | 将元素x增加到清單list尾部 |
| list.extend(alist) | 增加元素 | 将清單alist所有元素增加到清單list尾部 |
| list.insert(index,x) | 增加元素 | 将清單list指定位置index處插入元素x |
| list.remove() | 删除元素 | 在清單list中删除首次出現的指定元素x |
| list.pop([index]) | 删除元素 | 删除并傳回清單list指定位置index處的元素，預設是最後一個元素 |
| list.clear() | 删除所有元素 | 删除清單list中所有元素，并不是删除清單對象 |
| list.count(x) | 計數 | 傳回指定元素x在清單list中出現的次數 |
| len(list) | 清單長度 | 傳回清單中包含元素的個數 |
| list.reverse() | 翻轉清單 | 所有元素原地翻轉 |
| list.sort() | 排序 | 所有元素原地排序 |
| list.copy() | 淺拷貝 | 傳回清單對象的淺拷貝 |
舉例說明：
t_list = [1, 2]
t_list.append('python') # append()函數是1個參數，為要添加的元素。
t_list
# [1, 2, 'python']
t_list.extend(['java', 'go']) # extend()函數也是1個參數，可以多個元素，但是必須寫成清單的形式。
t_list
# [1, 2, 'python', 'java', 'go']
t_list.insert(1, 'linux')
t_list
# [1, 'linux', 2, 'python', 'java', 'go']
t_list.remove(2)
t_list
# [1, 'linux', 'python', 'java', 'go']
t_list.pop()
# 'go'
t_list
# [1, 'linux', 'python', 'java']
t_list.pop(0)
Out[13]: 1
t_list
Out[14]: ['linux', 'python', 'java']
t_list.clear()
t_list
# []
my_list = [1, 2, 3, 'a', 'b', 'c', 1, 2, 3]
my_list.count(3)
# 2
len(my_list)
# 9
my_list.reverse()
my_list
# [3, 2, 1, 'c', 'b', 'a', 3, 2, 1]
list1 = [1, 5, 3, 6, 2]
list1.sort() # sort()排序時要保證清單是相同類型的元素，否則無法比較大小而排序。
list1
# [1, 2, 3, 5, 6]
list2 = list1.copy() # copy()淺拷貝是隻複制數值，不複制架構、類等。
print(list2)
[1, 2, 3, 5, 6]
2、元組的方法：
(1.)建立元組：
t_1 = ('故宮', '長城', '香山')
t_2 = ('頤和園',) # 當元組中隻有一個元素時，需要加一個逗号，否則Python解釋器認為是字元串。
(2.)合并元組：
t_1 = ('故宮', '長城', '香山')
t_2 = ('頤和園',)
t_3 = t_1 + t_2
t_3
# ('故宮', '長城', '香山', '頤和園')
(3.)删除元組：（t_3已經删除不存在，所有報錯）
注：元組的基本操作與清單的操作一緻，除了不能修改元組本身外。
3、字典的方法：
(1.)字典的建立：
dict1 = {'a': 12, 'b': 16, 'b': 18}
dict1
# {'a': 12, 'b': 18} # 因為鍵存在相同，是以後面的鍵值替換了前面的鍵值
(2.)通路字典中的值：
(3.)修改字典：
dict1['a'] = 666
dict1
# {'a': 666, 'b': 18}
(4.)删除字典元素，能删單一的元素也能清空字典，并且可以直接删除字典：
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict1
# {'a': 1, 'b': 2, 'c': 3}
del dict1['b']
dict1
# {'a': 1, 'c': 3}
dict1.clear()
dict1
# {}
del dict1
dict1
Traceback (most recent call last):
File "D:\ProgramData\Anaconda3\lib\site-packages\IPython\core\interactiveshell.py", line 2961, in run_code
exec(code_obj, self.user_global_ns, self.user_ns)
File "<ipython-input-35-e36219336d90>", line 1, in <module>
(5.)pop()删除指定鍵值對，并傳回對應的“值對象”
(6.)popitem() ：随機删除和傳回該鍵值對。字典是“無序可變序列”，是以沒有第一個元素、最後一個元素的概念；popitem 彈出随機的項，因為字典并沒有"最後的元素"或者其他有關順序的概念。若想一個接一個地移除并處理項，這個方法就非常有效（因為不用首先擷取鍵的清單）。
a = {1: 'aaa', 2: 'bbb', 3: 'ccc', 4: 'ddd', 5: 'eee'}
print(a)
# {1: 'aaa', 2: 'bbb', 3: 'ccc', 4: 'ddd', 5: 'eee'}
a.pop(2)
# Out[13]: 'bbb'
print(a)
# {1: 'aaa', 3: 'ccc', 4: 'ddd', 5: 'eee'}
print(a.popitem())
# (5, 'eee')
print(a)
# {1: 'aaa', 3: 'ccc', 4: 'ddd'}
(7)Python字典包含了以下内置函數：
cmp(dict1, dict2) #比較兩個字典元素。
len(dict) #計算字典元素個數，即鍵的總數。
str(dict) #輸出字典可列印的字元串表示。
type(variable) #傳回輸入的變量類型，如果變量是字典就傳回字典類型。
(8)Python字典包含了以下内置方法：
dict.clear() #删除字典内所有元素
dict.copy() #傳回一個字典的淺複制
radiansdict.fromkeys() #建立一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值
dict.get(key, default=None) #傳回指定鍵的值，如果值不在字典中傳回default值
dict.has_key(key) #如果鍵在字典dict裡傳回true，否則傳回false
dict.items() #以清單傳回可周遊的(鍵, 值) 元組數組
dict.keys() #以清單傳回一個字典所有的鍵
dict.values() #以清單傳回字典中的所有值
dict.setdefault(key, default=None) #和get()類似, 但如果鍵不已經存在于字典中，将會添加鍵并将值設為default
dict.update(dict2) #把字典dict2的鍵/值對更新到dict裡
4、集合的方法：
s1 ={3, 8, 'apple', 'dog'}
# 判斷元素是否在集合中
'apple' in s1
# Out[4]: True
'banana' in s1
# Out[5]: False
# 将值添加到集合中，如果值存在，則不作任何操作
s1.add('cat')
s1
# Out[8]: {3, 8, 'apple', 'cat', 'dog'}
# 删除元素
s1.remove(8)
s1
Out[12]: {3, 'apple', 'cat', 'dog'}
s1.remove(0) # 如果元素不存在會發生錯誤
Traceback (most recent call last):
File "D:\ProgramData\Anaconda3\lib\site-packages\IPython\core\interactiveshell.py", line 2961, in run_code
exec(code_obj, self.user_global_ns, self.user_ns)
File "<ipython-input-13-3f824745aed8>", line 1, in <module>
s1.remove(0)
KeyError: 0
# 這種方式如果元素不存在不會發生錯誤
s1.discard(2)
s1
# Out[15]: {3, 'apple', 'cat', 'dog'}
# 計算集合中元素的個數
len(s1)
# Out[17]: 4
#清空集合
s1.clear()
s1
# Out[20]: set()
四、清單、元組、字典、集合之間的比較：
1、元組和清單差別
- 元組比清單操作速度快；
- 元組對資料“寫保護“ ；
- 元組可用于字元串格式化中 ；
- 元組可作為字典的key；
2、字典和清單差別
- 字典的查找和插入的速度極快，不會随着key的增加而增加 ；
- 但是字典需要占用大量的記憶體，記憶體浪費多；
- 清單的查找和插入的時間随着元素的增加而增加；
- 但是清單的占用空間小，浪費記憶體很少；
- 是以，dict是用空間來換取時間的一種方法。
3、集合和字典的差別
- 集合和字典的唯一差別僅在于沒有存儲對應的value；
- 結合和字典的原理一樣，同樣不可以放入可變對象，因為無法判斷兩個可變對象是否相等，也就無法保證set内部“不會有重複元素”。
五、推導式建立序列：
推導式是從一個或者多個疊代器快速建立序列的一種方法。它可以将循環和條件判斷結合，進而避免冗長的代碼。推導式是典型的 Python 風格。
1、清單推導式，文法如下：
- [表達式foritemin 可疊代對象 ]或者：[表達式foritemin 可疊代對象if條件判斷]
[x for x in range(0,10)]
Out[21]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[x for x in range(1,20) if x%5==0]
Out[22]: [5, 10, 15]
cells = [(row,col) for row in range(0,5) for col in range(11,15)] # 多個for循環
for cell in cells:
print(cell)
2、字典推導式，文法如下：
- {key_expression:value_expressionfor表達式in可疊代對象}類似于清單推導式，字典推導也可以增加 if 條件判斷、多個 for 循環。
統計文本中字元出現的次數：
text = ' i love you, i love china, i love niuniuxiaoai'
char_count = {c:text.count(c) for c in text}
char_count
3、集合推導式，文法如下：
- {表達式foritemin 可疊代對象 }或者：{表達式foritemin 可疊代對象if條件判斷}
{x for x in range(1,100) if x%9==0}
# Out[28]: {9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99}