一文搞定Python列表、字典、元組和集合

推薦學習：

列表

1.列表

什麼是列表呢？
變數可以儲存一個元素，而列表可以儲存N個元素。
列表相當於其他語言中的陣列。
不同的是python中的列表可儲存多個不同型別的元素。

a=10   #變數儲存的是一個物件的id(即地址)lst=['hello','world',98]print(id(lst))print(type(lst))print(lst)

注意：變數儲存的是一個元素的id，而列表存放的是多個元素的id,如圖：

lst儲存了列表的id，而列表的每一個位置儲存了每一個元素的id，這樣我們就可以用列表來儲存多個不同種類的元素。

2.列表的建立與刪除

建立：
① [ , ] 使用中括號，元素與元素間用‘，’ 如 lst1=[‘hello’,‘world’,11]
② 呼叫內建函數list() 如lst2=list([‘hello’,‘world’,11])
建立空列表
list3=[]或list3=list()

列表的特點：
列表元素按順序有序排列；
索引對映唯一元素；
索引正序為正，從0開始，逆序為負，從-1開始；

可儲存重複資料；
任意資料型別混存；
根據需要動態分配和回收記憶體。

3.列表的查詢操作

獲取列表中指定元素的索引

index(元素)
如列表中性存在多個相同元素，只返回相同元素中第一個元素的索引；
如果查詢的元素不在列表中，則會出現錯誤ValueError;
可以在指定start和end之間查詢。

value=0lst=['hello','world',11,'hello']print(lst.index('hello'))  
#0#print(lst.index(value))       
報錯：找不到#print(lst.index('hello',1.3))  
報錯：找不到print(lst.index('hello',1,4))  
#3

獲取列表中的單個元素

正向索引從0到N-1,如 lst[0]
逆向索引從-N到-1，如 lst[-N]
指定索引不存在，出現IndexError

獲取列表中的多個元素（切片）

語法：
列表名[start: end :step ]
切片的結果：原列表片段的拷貝；
切片的範圍：[start,end);
step預設為1：簡寫為[start: end]

lst=[10,20,30,40,50,60,70,80,90]lst1=lst[2:6:2]print(lst)print(lst1)print('原列表',id(lst))print('切片',id(lst1))      
#切片是一個新的列表物件

step為正數時，從start開始往後切片；
切片的第一個元素預設為列表的最後一個元素；
切片的最後一個元素預設為列表的第一個元素。

lst=[10,20,30,40,50,60,70,80,90]print(lst[1:6:2])    
#[20, 40, 60]print(lst[:6:2])     
#[10, 30, 50]print(lst[1::2])     
#[20, 40, 60, 80]

step是負數時，從start開始往前切片

lst=[10,20,30,40,50,60,70,80,90]print(lst[::-1])      
#[90, 80, 70, 60, 50, 40, 30, 20, 10]print(lst[6::-2])     
#[70, 50, 30, 10]print(lst[6:0:-2])    
#[70, 50, 30]print(lst[:2:-2])     
#[90, 70, 50]

判斷指定元素在列表中是否存在

語法：
元素 in 列表名
元素 not in 列表名

列表元素的遍歷

語法:
for 迭代變數 in 列表名：
操作

print(10 in lst)print(100 not in lst)for item in lst:
    print(item)

4.列表元素的增、刪、改操作

列表元素的增加

lst=[10,20,30,40,50,60,70,80,90]
lst1=['hello','world']
lst2=['python',66,88]
#四種方法
#第一種 append() 在列表的末尾新增一個元素
lst.append(100)
print(lst[9])
lst.append(lst1)    #將lst1作為一個元素新增在lst末尾
print(lst)
#第二種 extend() 在列表的末尾新增至少一個元素
lst.extend(lst1)    #將lst1作為兩個元素新增在lst末尾
print(lst)
#第三種 insert() 在列表的任意位置新增一個元素
lst.insert(1,11)    #在1處插入11
print(lst)
#第四種  切片 在列表的任意位置新增至少一個元素
lst[1:]=lst2    #實質為在切掉的部分新增一個列表
print(lst)

列表元素的刪除

lst=[10,20,30,40,50,60,70,80,40]
print(lst)
#五種方法
#第一種 remove()  一次刪除一個元素；重複元素只刪除第一個；元素不存在出錯ValueError.
lst.remove(40)
print(lst)
#第二種 pop() 刪除一個指定索引位置上的元素；不指定索引刪除最後一個元素；指定索引不存在出錯IndexError
lst.pop(3)
print(lst)
#第三種 切片 一次至少刪除一個元素,但切片會產生新的列表物件
new_list=lst[1:3]
#使用以下方式則不會：
lst[1:3]=[]
print(lst)
#第四種 clear() 清空列表
lst.clear()
print(lst)
#第五種 del   刪除列表
del lst
print(lst)   #報錯

列表元素的修改

lst=[10,20,30,40,50]
print(lst)
#第一種 為指定索引的元素賦予一個新值
lst[1]=11
print(lst)
#第二種 為指定的切片賦予一個新值
lst[1:3:]=[666,777,888,999,]
print(lst)

5.列表元素的排序

#兩種排序方式
print('第一種方法：')
lst=[11,7,99,86,59,108]
print(lst,id(lst))
#第一種 呼叫sort()方法，列表中的所有元素預設從小到大排序，
#可以指定reverse=True進行降序排序
lst.sort()     #相當於lst.sort(reverse=False)
print(lst,id(lst))    #升序排序
lst.sort(reverse=True)
print(lst)            #降序排序
print('第二種方法：')
lst=[11,7,99,86,59,108]
print(lst,id(lst))
#第二種 呼叫內建函數sorted(),可以指定降序排序，原列表不發生改變,將產生一個新的列表物件
new_list=sorted(lst)
print(lst,id(lst))
print(new_list,id(new_list))  #升序排序
desc_list=sorted(lst,reverse=True)
print(desc_list,id(desc_list))  #降序排序

6.列表生成式

即生成列表的公式。

語法：
列表名=[ 列表元素表示式 for i in range( , ) ]
注意：表示式中一般包含自定義變數 i

lst=[i*i for i in range(1,10)]  print(lst)#輸出為  [1, 4, 9, 16, 25, 36, 49, 64, 81]

七、字典

1.什麼是字典

可變序列：進行增刪改操作的序列，如列表
不可變序列：不能在原來的基礎上增刪改，如字串、整數
字典是python內建的資料結構之一，與列表一樣是一個可變序列；
以鍵值對的方式儲存資料，字典是一個無序的序列；（列表單身狗，字典成一對）

語法：例如
scores={ '張三’：99，‘李四’: 66, ‘王五’: 11}
（：之前的稱作鍵，、：之後的叫值）

字典示意圖：（1，2，3代表元素順序）
與列表第一個元素存在第一個位置，第二個元素存在第二個位置不同，字典中元素的存放位置與進入順序無關，而是雜湊函數計算得出的位置。

2.字典的原理

字典的實現原理與我們在現實中查字典類似，現實中我們是先根據偏旁部首或拼音查詢對應頁碼，Python中與此類似，是先通過hash函數計算元素key值，然後根據key值找到value。

3.字典的建立與刪除

字典的建立

#字典的建立 兩種方式
#第一種  { }
score={'張三':11,'李四':99,'王五':7}
print(score,type(score))
#第二種 使用內建函數dict()
people=dict(name='蘇沐',age=20)
print(people,type(people))

#空字典
a={}   #或a=dict()
print(a,type(a))

4.字典的查詢操作

字典中元素的獲取

score={'張三':11,'李四':99,'王五':7,'age':20}
print(score)
#兩種方法獲取字典中的元素  根據鍵獲取值
#第一種 ['鍵']
print(score['張三'])
print(score['age'])

#第二種 .get()方法
print(score.get('張三'))

#兩種方法的區別：
#print(score['蘇沐'])  報錯：發生異常: KeyError
print(score.get('蘇沐'))  #正常執行，結果為None
print(score.get('楚風',66)) #字典中不存在元素時輸出設定的預設值

兩種方法的區別：
[]如果字典中不存在指定的key，則會出現異常
get()如果字典中不存在指定的key，會返回None，並可以通過引數設定預設的value，使指定的key不存在時返回

Key的判斷

score={'張三':11,'李四':99,'王五':7,'age':20}
# in 指定的key在字典中返回True
print('張三' in score)
# not in 指定的key在字典中不存在返回True
print('張三' not in score)

5.字典元素的增、刪、改

字典元素的刪除

score={'張三':11,'李四':99,'王五':7,'age':20}
print(score)
# del 刪除某一個鍵值對
del score['張三']
print(score)
# clear() 清空字典的元素
score.clear()
print(score)

字典元素的新增和修改

score={'張三':11,'李四':99,'王五':7,'age':20}
print(score)
score['蘇沐']=66  #新增
print(score)
score['蘇沐']=88  #修改
print(score)

6.獲取字典檢視

三種方法：
keys() 獲取字典中所有key
values() 獲取字典中所有value
items() 獲取字典中所有key.value鍵值對

score={'張三':11,'李四':99,'王五':7,'age':20}
print(score)
#  keys() 獲取字典中所有key
a=score.keys()
print(a,type(a))
print(list(a))     #可用list將所有key組成的檢視轉成列表

# values()   獲取字典中所有value
b=score.values()
print(b,type(b))
print(list(b))

# items()   獲取字典中所有key.value鍵值對
c=score.items()
print(c,type(c))
print(list(c)) #轉換後的list元素為元組。

7.字典元素的遍歷

score={'張三':11,'李四':99,'王五':7,'age':20}for i in score:
    print(i,score[i],score.get(i))

i輸出的是鍵，後面兩個輸出的是值

8.字典生成式

即生成字典的公式
內建函數zip() 將可迭代的物件作為引數，將物件中對應的元素打包成一個元組，然後返回由這些元組組成的列表。

語法：
{ 表示字典key的表示式：表示字典value的表示式 for 自定義表示key的變數，自定義表示value的變數 in zip(可迭代物件1，可迭代物件2）}

lst1=['Hello','World','Python']
lst2=[10,20,30,40]
a={key:value for key,value in zip(lst1,lst2)}
print(a)
b={key.upper():value for key,value in zip(lst1,lst2)}
print(b)

若兩個可迭代物件中元素個數不一致，以元素少的那個為準。

9.總結字典的特點

字典中的所有元素都是一個key-value鍵值對，key不能重複，重複會覆蓋，value可以重複；
字典中的元素是無序的；
字典中的key必須是不可變物件；（可變序列無法計算雜湊值）
字典也可根據需要自動動態伸縮；
字典會浪費較大的記憶體，是一種使用空間換時間的資料結構。

八、元組

1.什麼是元組

在字典中我們已經知道可變序列與不可變序列下面重申一遍：
可變序列：可以對序列進行增、刪、改操作，物件地址不發生改變。如列表、字典
不可變序列：無增刪改操作，如字串、元組。
所以元組也是Python內建的資料結構之一，是不可變序列
注意：小沐認為可變不可變關鍵看元素的記憶體地址有沒有發生變化。

2.元組的建立方式

三種方式建立

#三種方式建立元組
# 第一種  直接用小括號（）小括號可省
a=('Python','Hello',11)  #或 a='Python','Hello',11
print(a,type(a))

#第二種 使用內建函數tuple()
b=tuple(('Python','yyds',666))
print(b,type(b))

#第三種 只包含一個元組的元素需要使用逗號和小括號,不加逗號系統認為是基本資料型別int等
c=(888,)  #括號可省，逗號不能省
print(c,type(c))
#空元組的建立
t1=()
t2=tuple()

3.元組的遍歷

可以通過索引的方式輸出元組元素，但要是不知道元素數目，可以用for in

t=(10,[20,30],40,50)
# 第一種 索引
print(t[0])

# 第二種  for in
for item in t:
    print(item)

4.注意事項

首先，我們為什麼要將元組設計成不可變序列呢？
因為這樣設計，在多工環境下比如多人共同作業時，不會存在在一個人操作物件時物件需要加鎖的問題，因為元組本身就是不可變序列，只能讀取。我們在程式中也應該儘量使用不可變序列。

注意事項：
元組中儲存的是物件的參照（地址）
如果元組中物件本身是不可變物件，則不能再參照其他物件
如果元組中的資料是可變物件，則可變物件的參照不允許改變，但資料可以改變

t=(10,[20,30],40,50)
# t[1]=100  報錯
t[1].append(10)
print(t)  #列表是可變序列，可以向列表中新增元素，但列表的記憶體地址不變

九、集合

1.什麼是集合

集合是Python提供的內建資料結構之一；
與列表、字典一樣都屬於可變型別的序列；
集合是沒有值value的字典。
所在儲存位置同樣是由雜湊函數計算得出的。

2.集合的建立

兩種方式：
注意：同字典中鍵不能重複一樣，集合中的元素也不能重複。

#兩種方式
#第一種  {}
s1={'hello','world','python',11}
print(s1,type(s1))

#第二種 使用內建函數set()
s2=set(range(6))
print(s2,type(s2))
s3=set([1,2,5,5,5,9,7,6])  #將列表內元素轉為集合，同時去掉重複元素
print(s3,type(s3))
s4=set((2,11,77,88,66,66)) #將元組轉成集合
print(s4,type(s4))
s5=set('python')  #字串轉成集合
print(s5,type(s5))

#定義空集合  不能直接用{}否則是空字典
s6=set()
print(s6,type(s6))

3.集合的增、刪、改、查操作

集合元素的判斷

#判斷元素是否存在——in  not in
s={10,20,30,40,50,99}
print(s)
print(10 in s)
print(100 not in s)

集合元素的新增

#兩種方法  add()   update()
s={10,20,30,40,50,99}
print(s)
#第一種 呼叫add()方法，一次新增一個元素
s.add(100)
print(s)
#第二種 呼叫update()方法，至少新增一個元素
s.update({666,888,999})  #給集合新增集合中的所有元素
print(s)
s.update([6666,8888,9999]) #給集合新增列表中的所有元素
print(s)
s.update((66666,88888,99999)) #給集合新增元組中的所有元素
print(s)

集合元素的刪除

#四種方法  remove()  discard()  pop()  clear()
s={10,20,30,40,50,99}
print(s)
#第一種 remove方法，一次刪除一個指定元素，如果指定元素不存在報錯KeyError
s.remove(99)
print(s)
#第二種 discard()方法，一次刪除一個指定元素，如果指定元素不存在不出現異常
s.discard(100)
print(s)
#第三種 pop()方法，一次性只刪除一個任意元素
s.pop()  #括號裡不能指定引數
print(s)
#第四種 clear()方法 清空集合
s.clear()
print(s)

4.集合間的關係

兩個集合間的關係主要有相等、子集、超集、交集，我們用程式碼看下如何判斷：

s1={10,20,30,40,50,99}
s2={10,20,30}
#判斷相等可以用==  != (元素相同即可)
print(s1==s2)
#判斷s2是否是s1的子集可用issubset()方法
print(s2.issubset(s1))
#判斷s1是否是s2的超集可用方法issuperset判斷
print(s1.issuperset(s2))
#判斷兩個集合沒有交集可用方法isdisjoint進行判斷，
print(s1.isdisjoint(s2))

5.集合的數學操作

s1={10,20,30,40,50,99}
s2={10,20,30,80}
# 1.求交集
print(s1.intersection(s2))
print(s1 & s2)
# 2.求並集
print(s1.union(s2))
print(s1 | s2)
# 3.求差集
print(s1.difference(s2))
print(s1-s2)
# 4.求對稱差集
print(s1.symmetric_difference(s2))
print(s1^s2)

注：數學操作之後原集合是不變的。

6.集合生成式

集合生成式就是用於生成集合的公式。

s={i+2 for i in range(5)}print(s)

注意：集合、字典、列表都有生成式，但元組由於為不可變序列無生成式

推薦學習：

以上就是一文搞定Python列表、字典、元組和集合的詳細內容，更多請關注TW511.COM其它相關文章！