Python——列表、元祖、字典、集合的基本操作

列表

1. 列表——增

（1）append

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']
li.append('nihao')
print(li)   #['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰', 'nihao']
li.append(1)
print(li)   #['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰', 'nihao', 1]
print(li.append('hello'))   #None：無返回值，li.append()只是一個方法、動作
print(li)   #['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰', 'nihao', 1, 'hello']

 （2）insert

li = ['xcsd','cdc',[1,5,2],'eht','辛辰']
li.insert(3,'bxb')
print(li)   #['xcsd', 'cdc', [1, 5, 2], 'bxb', 'eht', '辛辰']

（3）extend

li = ['xcsd','cdc',[1,5,2],'eht','辛辰']
li.extend('cc') #['xcsd', 'cdc', [1, 5, 2], 'bxb', 'eht', '辛辰', 'c', 'c']
print(li)
li.extend([1,2,3])
print(li)   #['xcsd', 'cdc', [1, 5, 2], 'bxb', 'eht', '辛辰', 'c', 'c', 1, 2, 3]

#報錯：數字不能迭代
li.extend(123)
print(li)   #TypeError: 'int' object is not iterable

應用實例：

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

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

運行結果：

2. 列表——刪

(1) remove：按照元素刪除

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']
li.remove('xcsd')
print(li)   #['cdc', [1, 5, 2], 'eht', '辛辰']

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

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']
name = li.pop(1)   #有返回值
print(name,li)  #cdc ['xcsd', [1, 5, 2], 'eht', '辛辰']
name = li.pop()   #不寫索引則默認刪除最后一個
print(name,li)  #辛辰 ['xcsd', [1, 5, 2], 'eht']

(3) clear： 清空

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']
li.clear()
print(li)  #[]

(4) del ：刪除

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']
# del li[2:]
# print(li)  #['xcsd', 'cdc']
del li      #刪除之后，已經不存在，打印報錯
print(li)   #NameError: name 'li' is not defined

(5) 循環刪除

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

3. 列表——改

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

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']
li[0] = 'ns'    #將索引為0的位置改為‘ns’
print(li)   #['ns', 'cdc', [1, 5, 2], 'eht', '辛辰']

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

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']
li[0:2] = 'yjhpl'   #將索引0-2替換為yjphl,切片之后迭代處理
print(li)   #['y', 'j', 'h', 'p', 'l', [1, 5, 2], 'eht', '辛辰']
li[0:3] = [[1,2,3],'ff','nng']
print(li)   #[[1, 2, 3], 'ff', 'nng', 'eht', '辛辰']

4. 列表——查

（1）從頭到尾 ：for循環

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']
for i in li:
    print(i)

（2）某一個：索引

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']
print(li[1])    #cdc

（3）一段：切片

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']
print(li[0:2])   #['xcsd', 'cdc']

5. 列表——嵌套

li = ['xcsd', 'cdc', ['alex','egon',88], 'eht', 88,'辛辰','💗沉沉']
print(li[5][1]) #辰
li[0] = li[0].capitalize()  #把列表中第一個元素的首字母大寫
print(li)   #['Xcsd', 'cdc', ['alex', 'egon', 88], 'eht', 88, '辛辰', '💗沉沉']
print(li[5].replace('辰','chen'))    #辛chen
li[2][0] = li[2][0].upper() #把列表中第三個元素列表的第一個元素變為大寫
print(li)   #['Xcsd', 'cdc', ['ALEX', 'egon', 88], 'eht', 88, '辛chen', '💗沉沉']

6. 列表——循環打印

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

　　運行結果：

 

二、元祖

1. 元祖

元祖：只讀列表，只能查詢；兒子不能改，孫子是列表則可以改

 　　  只有一個元素，不加逗號，是原數據類型；否則是元祖類型

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'>

2. 元組的基本操作

tu = (1,2,3,'alex',[2,3,4,'xxcc'],'egon')
print(tu[2])    #3
print(tu[0:4])  #(1, 2, 3, 'alex')
for i in tu:
    print(i)    #循環打印元祖
tu[4][3] = tu[4][3].upper() #把xxcc改為大寫
print(tu)   #(1, 2, 3, 'alex', [2, 3, 4, 'XXCC'], 'egon')
tu[4].append('sb')  #在xcxc后面增加sb
print(tu)   #(1, 2, 3, 'alex', [2, 3, 4, 'XXCC', 'sb'], 'egon')
tu[4].insert(4,'bs')    #在元組的索引為4的元素列表的索引為4的地方添加bs
print(tu)   #(1, 2, 3, 'alex', [2, 3, 4, 'XXCC', 'bs', 'sb'], 'egon')
tu[4].extend('xc')  #在元組的索引為4的元素列表中迭代增加xc
print(tu)   #(1, 2, 3, 'alex', [2, 3, 4, 'XXCC', 'sb', 'bs', 'x', 'c'], 'egon')

3. 其他常用操作

（1）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辛', '辰']

（2）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_辛辰

（3）range：顧頭不顧尾——相當於有序的數字列表(可以反向，加步長)

for i in range(2,6):
    print(i)
for i in range(3):   #從0開始，0可省略
    print(i)
for i in range(1,10,2):   #起始，截至，步長
    print(i)
for i in range(10,0,-2):   #倒着打印輸出
    print(i)

#筆試題：成功運行，不輸出任何結果，不報錯
for i in range(0,10,-1):
    print(i)   

應用實例：

#Q&A:循環打印，列表里遇到列表也需要循環打印
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)

運行結果：

三、字典

1. 字典

（1）數據類型划分：
　　　　 可變(不可哈希)數據類型 : list,dict,set,
　　 　　不可變(可哈希)數據類型 : 元祖,bool,int,str,
（2）dict
　　　　key（鍵）必須是不可變數據類型，可哈希
　　　　value（值）任意數據類型
（3）dict 優點：二分查找去查詢
　　　　存儲大量的關系型數據
（4）特點：<=3.5版本無序，3.6以后都是有序

2. 增

（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}

（2）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}

3. 刪

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

  (1) 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)     #沒有此鍵/None    {'name': 'xc', 'sex': 'female'}

  (2) popitem

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

  (3) clear

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

  (4) del

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

　　應用實例：

#dict:刪除鍵中有k的鍵和值

dic = {'k1':'v1','k2':'v2','a3':'v3'}
# （1）
dic1 = {}
for i in dic:
    if 'k' not in i:
        dic1.setdefault(i,dic[i])
        print(dic1)
dic = dic1
print(dic)

# （2）
l = []
for i in dic:
    if 'k' in i:
        l.append(i)
        print(l)
for k in l:
    del dic[k]
print(dic)

　　運行結果：

4. 改

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'}

5. 查------得到鍵值，首選get

dic1 = {'age':18,'name':'xc','sex':'female'}

print(dic1.keys(),type(dic1.keys()))    #鍵
print(dic1.values())    #值
print(dic1.items())     #元祖[(‘鍵’，值),(‘鍵’，值),(‘鍵’，值)]

# 得到鍵值，首選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)    #循環打印值
for i in dic1.items():
    print(i)    #循環打印鍵值對

for k,v in dic1.items():
    print(k,v)    #打印鍵和值

6. 字典的嵌套

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)

　　運行結果：

四、集合

1. 集合

　　集合：可變的數據類型，里面的元素必須是不可變的數據類型
　　　　   無序----每次運行結果都不一定一樣
　　　　   不重復----列表去重：先轉換為集合，再轉換成列表即可

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

2. 基本操作

（1）增

set1 = {'alex','wusir','ritian','egon','barry'}
# (1)add    #因為集合是無序的，所以每次運行結果不一定一樣，增加的位置也不一定一樣
set1.add('nvshen')  #{'ritian', 'nvshen', 'egon', 'wusir', 'alex', 'barry'}
print(set1)
# (2)update
set1.update('xc')   #迭代添加，依然是無序的
print(set1) #{'egon', 'x', 'wusir', 'nvshen', 'c', 'alex', 'ritian', 'barry'}

（2）刪

set1 = {'alex','wusir','ritian','egon','barry'}
#（1）pop--隨機刪除
print(set1.pop())   #egon：有返回值，返回本次刪除的內容
print(set1)     #{'barry', 'alex', 'wusir', 'ritian'}
#（2）remove——指定元素刪除
set1.remove('alex')
print(set1)     #{'egon', 'wusir', 'barry', 'ritian'}
#（3）clear--清空
set1.clear()
print(set1)     #空集合：set()
#（4）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

（6）frozenset

#將set(可變數據類型)轉換為不可變數據類型（只讀）
s1 = set('nvshen')
print(s1,type(s1))  #{'s', 'h', 'n', 'v', 'e'} <class 'set'>
s = frozenset('nvshen')
print(s,type(s))    #frozenset({'h', 'n', 's', 'v', 'e'}) <class 'frozenset'>
for i in s:
    print(i)    #可以循環打印(只讀)，但不能增加修改刪除

五、公共方法

（1）排序

　　a. 正向排序：sort()   

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

　　b. 倒序排序：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]

　　c. 反轉：li.reverse()

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

　　d. 補充：字符串列表排序——根據字符串的第一個字符對應的ASCII碼排序

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

（2） count()  數元素出現的次數

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

（3）len()  計算列表的長度

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

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

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