05-Python—列表、元祖、字典、集合操做大全:建議收藏

數據結構基本上就是——它們是能夠處理一些 數據 的 結構 。或者說，它們是用來存儲一組相關數據的。

在Python中有四種內建的數據結構——列表、元組和字典，集合。咱們將會學習如何使用它們，以及它們如何使編程變得簡單

1、列表list

是處理一組有序項目的數據結構，即你能夠在一個列表中存儲一個 序列 的項目。假想你有一個購物列表，上面記載着你要買的東西，你就容易理解列表了。只不過在你的購物表上，可能每樣東西都獨自佔有一行，

而在Python中，你在每一個項目之間用逗號分割。列表中的項目應該包括在方括號中，這樣Python就知道你是在指明一個列表。

一旦你建立了一個列表，你能夠添加、刪除或是搜索列表中的項目。因爲你能夠增長或刪除項目，咱們說列表是 可變的 數據類型，即這種類型是能夠被改變的

# 購物清單
shoplist = ['蘋果', '芒果', '胡蘿蔔', '香蕉']

基本操做

print ('我有', len(shoplist),'個商品在個人購物清單.')
print ('它們是:'), # 提示
​
for item in shoplist:
    print(item)
print ('我還買了大米.')
​
shoplist.append('大米')
print ('如今個人購物清單是', shoplist)
# ['蘋果', '芒果', '胡蘿蔔', '香蕉','大米']

基本操做——增

append 追加

li = ['蘋果', '芒果', '胡蘿蔔', '香蕉']
li.append('大米')
print(li)
# ['蘋果', '芒果', '胡蘿蔔', '香蕉','大米']
​
li.append(1)
# ['蘋果', '芒果', '胡蘿蔔', '香蕉','大米', 1]
​
print(li.append('hello'))   
#None：無返回值，li.append()只是一個方法、動做
​
print(li)   
# ['蘋果', '芒果', '胡蘿蔔', '香蕉','大米', 1 , 'hello']

insert 插入

li = ['蘋果', '芒果', '胡蘿蔔', '香蕉']
li.insert(3,'草莓')
​
print(li)   
# ['蘋果', '芒果', '胡蘿蔔', '草莓', '香蕉']

extend 追加到末尾

li = ['蘋果', '芒果', '胡蘿蔔', '香蕉']
li.extend('cc')
print(li)
# ['蘋果', '芒果', '胡蘿蔔', '香蕉', 'c', 'c']
​
li.extend([1,2,3])
print(li)
# ['蘋果', '芒果', '胡蘿蔔', '香蕉', 'c', 'c', 123]
​
li.extend(123) #報錯：數字不能迭代
print(li)   
#TypeError: 'int' object is not iterable

應用實例：

連續輸入員工姓名，輸入Q/q退出並打印列表

li = []
while True:
    username = input("請輸入要添加的員工姓名：")
    if username.strip().upper() == 'Q':
        break
    li.append(username)
    print(li)
print(li)

運行結果：

]

列表——刪

remove：按照元素刪除

li = ['蘋果', '芒果', '胡蘿蔔', '香蕉']
li.remove('芒果')
print(li)  
#  ['蘋果', '胡蘿蔔', '香蕉']

pop：按照索引刪除——有返回值

li = ['蘋果', '芒果', '胡蘿蔔', '香蕉']
name = li.pop(1)  #有返回值
print(name,li)
# 芒果 ['蘋果', '胡蘿蔔', '香蕉']
​
name = li.pop()  #不寫索引則默認刪除最後一個
print(name,li)
# 香蕉 ['蘋果', '胡蘿蔔']

clear： 清空

li = ['蘋果', '芒果', '胡蘿蔔', '香蕉']
li.clear()
print(li)
#[]

del：刪除

li = ['蘋果', '芒果', '胡蘿蔔', '香蕉']
del li[2:]
print(li)
# ['蘋果', '芒果']
​
del li  #刪除以後，已經不存在，打印報錯
print(li)
 #NameError: name 'li' is not defined

循環刪除

li = [11,22,33,44,55]
for i in range(len(li)):
    print(i)
    del li[0]
    print(li)

列表——改

li[索引] = ‘被修改的內容’

li = ['蘋果', '芒果', '胡蘿蔔', '香蕉']
li[0] = '火龍果'  #將索引爲0的位置改成‘火龍果’
print(li)
# ['火龍果', '芒果', '胡蘿蔔', '香蕉']

li[切片] = ‘被修改的內容’（迭代式：分紅最小的元素，一個一個添加）

li = ['蘋果', '芒果', '胡蘿蔔', '香蕉']
li[0:2] = 'abcd' 
# 將索引0-2替換爲abcd,切片以後迭代處理
​
print(li)
// ['a', 'b', 'c', 'd', '胡蘿蔔', '香蕉']
​
li[0:3]=['我','喜歡','吃','水果']
print(li)
// ['我', '喜歡', '吃', '水果', 'd', '胡蘿蔔', '香蕉'

列表——查

從頭至尾 ：for循環

li = ['蘋果', '芒果', '胡蘿蔔', '香蕉']
for i in li:
    print(i)

某一個：索引

li = ['蘋果', '芒果', '胡蘿蔔', '香蕉']
print(li[1])    #芒果

一段：切片

li = ['蘋果', '芒果', '胡蘿蔔', '香蕉']
print(li[0:2])    #['蘋果', '芒果', '胡蘿蔔']

列表——嵌套

li = ['蘋果', '芒果', '胡蘿蔔', ['a','b','c'],'香蕉']
print(li[2][1]) #蘿
li[3][0].upper() 
#把列表中第四個元素列表的第一個元素變爲大寫
​
print(li)
# ['蘋果', '芒果', '胡蘿蔔', ['a', 'b', 'c'], '香蕉']

列表——循環打印

#索引默認從零開始
li = ['alex','taibai','wusir','egon']
for i in li:
    print(li.index(i),i)
指定索引從100開始

運行結果：

其餘經常使用操做

split:字符串轉換成列表 str--->list

s = 'xcsd_cdc_eht_木木'
print(s.split('_'))  
// ['xcsd', 'cdc', 'eht', '木木']
​
s1 = 'xc sdc dc eht曾 木木'
print(s1.split(' '))    
// ['xc', 'sdc', 'dc', 'eht曾', '木木']

join:列表轉換成字符串 list--->str

join(可迭代對象iterable) split

可迭代對象iterable：list,str,元祖

li = ['xcsd', 'cdc', 'eht', '木木']
s = ''.join(li)
print(s)  #xcsdcdceht木木
s1 = '_'.join(li)
print(s1)  #xcsd_cdc_eht_木木

range：顧頭不顧尾——至關於有序的數字列表(能夠反向，加步長)

for i in range(2,6):
    print(i)

應用實例：

循環打印，列表裏遇到列表也須要循環打印

li = [1,2,3,5,'alex',[2,3,4,5,'taibai'],'afds']
for i in li:
    if type(i) == list:
        for n in i:
            print(n)
    else:
        print(i)

運行結果：

2、元祖

元組和列表十分相似，只不過元組和字符串同樣是 不可變的 即你不能修改元組。元組經過圓括號中用逗號分割的項目定義。

元組一般用在使語句或用戶定義的函數可以安全地採用一組值的時候，即被使用的元組的值不會改變

tu1 = (1)
tu2 = (1,)
print(tu1,type(tu1))    #1 <class 'int'>
print(tu2,type(tu2))    #(1,) <class 'tuple'>

tu3 = ([1])
tu4 = ([1],)
print(tu3,type(tu3))    #[1] <class 'list'>
print(tu4,type(tu4))    #([1],) <class 'tuple'>

元組的基本操做

tu = (1,2,3,'alex','egon')
print(tu[2])    #3
print(tu[0:2])  #(1, 2)
for i in tu:
    print(i)    #循環打印元祖

字典

字典相似於你經過聯繫人名字查找地址和聯繫人詳細狀況的地址簿，即，咱們把鍵（名字）和值（詳細狀況）聯繫在一塊兒。注意，鍵必須是惟一的，就像若是有兩我的恰巧同名的話，你沒法找到正確的信息。

注意，你只能使用不可變的對象（好比字符串）來做爲字典的鍵，可是你能夠把不可變或可變的對象做爲字典的值。

基本說來就是，你應該只使用簡單的對象做爲鍵。

鍵值對在字典中以這樣的方式標記：d = {key1 : value1, key2 : value2 }。

注意它們的鍵/值對用冒號分割，而各個對用逗號分割，全部這些都包括在花括號中

dict
key（鍵）必須是不可變數據類型，可哈希
value（值）任意數據類型

dict 優勢：二分查找去查詢
　　　　存儲大量的關係型數據
特色：<=3.5版本無序，3.6之後都是有序

1.字典— 增

dic['鍵'] = 值

dic1 = {'age':18,'name':'xc','sex':'female'}
dic1['height'] = 165
print(dic1) 
# 沒有鍵值對，增長
# {'age': 18, 'name': 'xc', 'sex': 'female', 'height': 165}
​
dic1['age'] = 21
print(dic1) 
#有鍵值對，則修改
#{'age': 21, 'name': 'xc', 'sex': 'female', 'height': 165}

setdefault 設置默認

# dic1 = {'age':18,'name':'xc','sex':'female'}
dic1.setdefault('weight',120)
print(dic1)     
# 沒有鍵值對，增長
# {'age': 18, 'name': 'xc', 'sex': 'female', 'weight': 120}
​
dic1.setdefault('name','aa')
print(dic1)      
#有鍵值對，不作任何操做
# {'age': 18, 'name': 'xc', 'sex': 'female', 'weight': 120}

2. 字典—— 刪

刪除優先使用pop(有返回值，要刪除的內容不存在時不報錯)，而不是del

pop 刪除

dic1 = {'age':18,'name':'xc','sex':'female'}
print(dic1.pop('age'))  
#有age直接刪除---有返回值，按鍵刪除
​
print(dic1)     
#18   {'name': 'xc', 'sex': 'female'}
​
print(dic1.pop('erge','沒有此鍵/None')) 
 #沒有erge----可設置返回值：沒有此鍵/None
print(dic1)

popitem 隨機刪除

dic1 = {'age':18,'name':'xc','sex':'female'}
print(dic1.popitem())  
#('sex', 'female')
#隨機刪除：有返回值-----返回元祖：刪除的鍵值

clear 清空

dic1 = {'age':18,'name':'xc','sex':'female'}
dic1.clear()    #清空字典
print(dic1)     #{}

del 刪除

dic1 = {'age':18,'name':'xc','sex':'female'}
del dic1['name']   
# 有，則刪除
# del dic1['name1']  #沒有，則報錯
​
print(dic1)     
#{'age': 18, 'sex': 'female'}

3. 字典—— 改

update

dic = {'age':18,'name':'xc','sex':'female'}
dic2 = {'name':'alex','weight':'168'}
dic2.update(dic)      
#有則更新覆蓋，沒有則增長
​
print(dic)  
#{'age': 18, 'name': 'xc', 'sex': 'female'}
​
print(dic2) 
#{'name': 'xc', 'weight': '168', 'age': 18, 'sex': 'female'}

4. 字典——查

keys，values，items

dic1 = {'age':18,'name':'xc','sex':'female'}
​
print(dic1.keys(),type(dic1.keys()))    
#鍵 dict_keys(['age', 'name', 'sex']) <class 'dict_keys'>
​
print(dic1.values())    
#值 dict_values([18, 'xc', 'female'])
​
print(dic1.items())     
#元祖 dict_items([('age', 18), ('name', 'xc'), ('sex', 'female')])

獲得鍵值，首選get

print(dic1['name'])      #有則打印
#print(dic1['name1'])    #沒有則報錯
​
print(dic1.get('name'))  
#有name直接輸出---有返回值
​
print(dic1.get('name1','沒有此鍵'))  
#沒有name1----可設置返回值：沒有此鍵/None

循環輸出

for i in dic1:
    print(i)    #循環打印鍵(默認爲鍵)
for i in dic1.keys():
print(i)    #循環打印鍵
for i in dic1.values():
print(i)    #循環打印值

5. 字典的嵌套

dic = {    'name':['alex','wusir','xinchen'],
    'py9':{
        'time':'1213',
        'study_fee':19800,
        'addr':'CBD',
    },
    'age':21
}

dic['age'] = 56 
# 找到age，再更新爲56
print(dic)
​
dic['name'].append('rt')    
#找到name，在添加名字
print(dic)
​
dic['name'][1] = dic['name'][1].upper() 
#找到name，再把wusir變爲大寫
print(dic)
​
dic['py9']['female'] = 6    
#找到元祖，增長鍵值對female:6
print(dic)

應用實例：

#輸入一串字符，遇到字母，轉換爲‘_’,並打印輸出

info = input('請輸入：')
for i in info:
    if i.isalpha():
        info = info.replace(i,'_')
print(info)

　　運行結果：

4、集合

集合 相似於列表，但每一個元素都必須是獨一無二且不可變的：

它是無序的

基本操做

print(set1)     
#{1, 2, 3}
​
set2 = {1,2,3,[2,3],{'name':'xc'}}  
#列表是可變的（不可哈希），因此出錯
print(set2)     
#TypeError: unhashable type: 'list'

1. 集合——增

add

set1 = {'alex','wusir','ritian','egon','barry'}
# (1)add    #由於集合是無序的，因此每次運行結果不必定同樣，增長的位置也不必定同樣
set1.add('nvshen')  
#{'ritian', 'nvshen', 'egon', 'wusir', 'alex', 'barry'}
print(set1)

update

set1.update('xc')   
#迭代添加，依然是無序的
print(set1) 
#{'egon', 'x', 'wusir', 'nvshen', 'c', 'alex', 'ritian', 'barry'}

2. 集合——刪

set1 = {'alex','wusir','ritian','egon','barry'}

pop--隨機刪除

print(set1.pop())   
#egon：有返回值，返回本次刪除的內容
​
print(set1)     
#{'barry', 'alex', 'wusir', 'ritian'}

remove——指定元素刪除

set1.remove('alex')
print(set1)    
 #{'egon', 'wusir', 'barry', 'ritian'}

clear——清空

set1.clear()
print(set1)     
#空集合：set()

del

del set1        
​
#刪除以後集合不存在，報錯
print(set1)    
 #NameError: name 'set1' is not defined

3.集合不能改

集合是無序；

集合中的元素是不可變數據類型

4. 集合——查

set1 = {'alex','wusir','ritian','egon','barry'}
for i in set1:
    print(i)

　　運行結果：

5. 集合之間的操做

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

交集

print(set1 & set2)      
#(1) {4, 5}
​
print(set1.intersection(set2))      
#(2) {4, 5}

並集

print(set1 | set2)          
#(1) {1, 2, 3, 4, 5, 6, 7, 8}
​
print(set1.union(set2))     
#(2) {1, 2, 3, 4, 5, 6, 7, 8}

反交集--除交集之外的其餘元素

print(set1 ^ set2)          
#(1) {1, 2, 3, 6, 7, 8}
​
print(set1.symmetric_difference(set2))     
#(2) {1, 2, 3, 6, 7, 8}

差集--前者獨有的

print(set1 - set2)              #(1) {1, 2, 3}
print(set1.difference(set2))     #(2) {1, 2, 3}
print(set2 - set1)              #(1) {8, 6, 7}
print(set2.difference(set1))     #(2) {8, 6, 7}

子集與超集

set3 = {1,2,3,4,5}
set4 = {1,2,3,4,5,6,7,8}
print('------ set3是set4的子集 ------')
print(set3 < set4)      #True
print(set3.issubset(set4))   #True
​
print('------ set4是set3的超集 ------')
print(set4 > set3)      #True
print(set4.issuperset(set3))   #True

5、公共方法

排序

正向排序：sort()

li = [1,5,4,2,6,7,3]
li.sort()
print(li)   #[1, 2, 3, 4, 5, 6, 7]

倒序排序：li.sort(reverse = True)

li = [1,5,4,2,6,7,3]
li.sort(reverse = True)
print(li)   #[7, 6, 5, 4, 3, 2, 1]

反轉：li.reverse()

li = [1,5,4,2,6,7,3]
li.reverse()
print(li)     #[3, 7, 6, 2, 4, 5, 1]

補充：

字符串列表排序——根據字符串的第一個字符對應的ASCII碼排序

li = ['ojhy','asa','cvd','hdk']
li.sort()
print(li)   #['asa', 'cvd', 'hdk', 'ojhy']

count() 數元素出現的次數

li = ['xcsd', 'cdc', '木木',[1, 5, 2], 'eht', '木木']
num = li.count('木木')
​
print(num)  #2：'木木'出現2次

len() 計算列表的長度

li = ['xcsd', 'cdc', '木木',[1, 5, 2], 'eht', '木木']
l = len(li)
print(l)   #6:列表長度爲6

li.index('元素') 查看索引

li = ['xcsd', 'cdc', '辛辰',[1, 5, 2], 'eht', '辛辰']
print(li.index('eht'))  
#4:'eht'的索引爲4元祖

六. 區別與異同

	列表list	元組 tuple	集合 set	字典 dict
能否讀寫	讀寫	只讀	讀寫	讀寫
能否重複	是	是	否	是
存儲方式	值	值	鍵<br/>(不能重複)	鍵值對<br/>(鍵不能重複)
是否有序	有序	有序	無序	自動正序
初始化	[1,'a']	('a', 1)	set([1,2])<br/>或 {1,2}	{'a':1,'b':2}
添加	append	只讀	add	d['key'] = 'value'
讀元素	l[2:]	t[0]	無	d['a']

練習地址：www.520mg.com/it