python3 清單，元組，字典，集合中常見的操作方法彙錦！

python3清單，元組，字典，集合中常見的操作方法彙錦：

【1.以下的字典，清單，集合用于資料存儲處理的這幾個對象，如果沒有傳回值一般都是直接修改原有對象，如果有傳回值那麼原對象值不變。】

【2.有傳回值的一般都需要使用變量接收傳回值，沒有傳回值的一般都不能直接列印并改變原有對象的值。】

【3.索引跟下标：下标指元素的位置，索引指元素名稱，通路像set、dict、list、tuple這樣的類型資料一般使用都是使用下标跟索引來通路！】

【4.以下四大資料類型中沒有列出tuple：因為tuple不能增删改，是以操作函數比較少，但是tuple有索引也有下标，跟清單一樣！】

【5.都支援嵌套！】

一. 清單的操作：

概念：有索引有下标！清單是這四個資料類型中比較靈活的，竟可以通過下标通路也可以通過索引通路元素

1.替換/添加清單元素，也可以說更新

文法：list[obj_index] = obj 解析：list，清單名字；index，索引

舉例：

list1=[1,2,3,4,5]

list1 [4] = 2020

print(list1)

# 結果：

# [1,2,3,4,2020]

2.删除清單元素

文法：del list5[index] 解析：del == delete，删除；list，清單名字；index，需要删除的元素索引位置。ps：沒有傳回值

舉例：

list2 = [1,2,3,4,5]

del list2[3]

print(list)

# 結果：

# [1,2,3,5]

3.向清單添加元素

文法：list3.inster（index,object）解析：list3.inster ，調用函數inster（）；index，元素添加的索引位置；object，需要添加的對象

舉例：

list3=[1,2,3,4,5]

list3.inster(2,2020)

print(list)

# 結果：

# [1,2,2020,3,4,5]

4.向清單的結束位置添加元素（當不知道清單元素多少個的時候使用，不然用inster（）感覺也夠用了

文法：list4.append(object) 解析：list4.append ，調用函數append()； object ，需要向清單中添加的對象

舉例：

list4=[1,2,3,4,5]

list4.append(2020)

print(list4)

# 結果：

# [1,2,3,4,5,2020]

5.移除清單的中的元素。預設最後一個（會傳回被移除的元素) ， ps：适用于dcit，set，list

文法：list5.pop(index) 解析：list5.pop(),調用函數pop() ; index ,可以指定需要移除元素的索引值，如果添加索引，預設為移除最後一個元素，

舉例：

list5=[1,2,3,4,5]

list5.pop()/list5.pop(1)  # / 表示或，注意區分! 

print(list5)

# 結果：

# [1,2,3,4]/[1,3,4,5,]  # / 表示或，注意區分!

6.按順序排列lsit ：

負下标排序法：（隻能反轉字元适用于所有可疊代對象)

舉例：

list6=[1,2,3,4,5,5,4,6]

print(list6[::-1])

使用内置函數排序：sort(), ps：沒有傳回值

方式1：

list6=[1,2,3,4,5,6]

list1.sort(reverse=True)

print(list6)

# 結果：[6, 5, 4, 3, 2, 1]

細節提示：list6=[1,'2','3',4,5,6]

list1.sort(reverse=True)

print(list6)

#  報錯：因為數字是不能跟字元串同時排序的！

使用可疊代對象函數排序：ps：可對一切可疊代對象使用！,這兩個方法沒有傳回值

就是使用sorted()跟reverse()下面有具體解析！

7.清空對象：.clear()，ps：可對一切可疊代對象（比如：list，dict這樣的，元組除外元組不能增删改）使用！,該方法沒有傳回值

文法：obj.clear()

舉例：

list7=[1,2,3,4,5]

list7.clear() #不能在清空的時候直接列印！

print(list7)

# 結果：空清單

# [ ]

8.統計元素在該對象中出現的次數：count() ，索引值也就是下标從1開始！ps：可對一切對象使用！該方法沒有傳回值

文法：obj.count()

舉例：

list8=[1,2,3,4,4,4,3,5]

list8.count(4)

print(list8)

# 結果：4總共在list8裡出現過3次

# 3

9.複制對象：.copy() , ps：可對一切對象使用！該方法沒有傳回值！

文法：obj.copy()

dict1 = {"name":"tyc","age":18,"sex":"boy"}

dict2=dict1.copy()

print(dict2)

# result：{"name":"tyc","age":18,"sex":"boy"}

10.最大值，最小值：max(obj) ; min(obj)；ps：可對數字跟str使用！不适用于像字典(dict)這樣！

max(obj)文法：max(obj)

舉例：

list8=[1,2,3,4,4,4,3,5]

list9=max(list8)

print(list9)

# 結果：ps：也可以對字元串操作！

# 5

min(obj)文法: min(obj)

舉例：

list8=[1,2,3,4,4,4,3,5]

list9=min(list8)

print(list9)

# 結果：ps：也可以對字元串操作！

# 1

11.适用list，tuple，set中數字對象的總和：ps：不能操作str，還有字典這樣的！

文法：sum(obj)

舉例：

list8=(1,2,3,4,4,4,3,5)

list9=sum(list8)

print(list9)

# 結果：26

12.移除對象中的某一進制素：适用于dict，list，set。ps：預設移除第一個（set除外），該方法沒有傳回值。

文法：object.remove(要移除的元素/元素位置)

舉例：

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']

list1.remove(list1[1])

print ("清單現在為 : ", list1)

# 結果：清單現在為 : ['Google', 'Taobao', 'Baidu']

二. 字典（dict）的操作：

概念：字典也是跟集合一樣無序的，但有索引，不能通過下标通路，隻能通過索引(key)來通路。

1.列印出dict（字典）的所有鍵（key）：

文法：obejct.keys()；字典.keys()

舉例:

dict = {"name":"tyc","age":18,"sex":"boy"}

mun = dict.keys()

print(mun)

2.列印出dict（字典）的所有值（value）:

文法: object.values() ; 字典.value()

舉例:

dict1 = {"name":"tyc","age":18,"sex":"boy"}

mun1 = dcit1.values()

print(mun1)

3.以清單（list）形式傳回字典（dict）的鍵跟值：

文法: object.items(); 解析: items() 字典操作函數（傳回字典的鍵跟值）

舉例:

dict2 = {"name":"tyc","age":18,"sex":"boy"}

mun2 = dict2.items()

print(mun2)

# 結果：dict_items([('name', 'tyc'), ('age', 18), ('sex', 'boy')])

還可以使用for循環周遊鍵跟值:

dict2 = {"name":"tyc","age":18,"sex":"boy"}

i=0

for key,value in dict2.items():

i+=1

print(f"這是dict的第{i}鍵：{key}，這是dict的第{i}值：{value}")

# 結果:

# 這是dict的第1鍵：name，這是dict的第1值：tyc

# 這是dict的第2鍵: age，這是dict的第2值：18

# 這是dict的第3鍵：sex，這是dict的第3值：boy

4.将清單裝換成字典：

方法1：使用dict.fromkeys() ps：該方法隻能給所有key指定一個預設value，不能給每個key，指定不同的value

舉例：

list1 = ['name','age','sex']

x ='18'

list2 = dict.fromkeys(list1,x)

print(list2)

# result:  {'name': '18', 'age': '18', 'sex': '18'}

方法2：使用 dict(zip())

舉例：

list3 = ['name','age','sex']

list4 = ['adi','18','boy']

list5 =dict(zip(list3,list4))

print(list5)

# result:  {'name': 'adi', 'age': '18', 'sex': 'boy'}

5.指定字典的key跟value：dict.fromkeys(keys,value) ，參數value不能傳入整個清單！

文法：變量 = dict.fromkeys(keys,初始化的值)

舉例：

list1= ['Google', 'Runoob', 'Taobao', 'Baidu']

list2=[1,2,3,4]

dict1= dict.fromkeys(list1,None )

# dict1= dict.fromkeys(list1,list2) # 注意：如果把另一個list做值，value就是整個list2清單！

print ("清單現在為 : ",dict1)

# 結果：清單現在為 : {'Google': None, 'Runoob': None, 'Taobao': None, 'Baidu': None}

6.往字典添加鍵和值： ps：預設添加位置是後面！

文法：字典對象.['鍵名']=‘值’

舉例：

dict3 = {"name":"tyc","age":18,"sex":"boy"}

dict3['adi']='千燈'

print('dict3')

# 結果：

# {"name":"tyc","age":18,"sex":"boy","adi" : "千燈" }

三. 集合的操作與概念：

概念：在python中集合是無序的，沒有索引沒有下标。不能通過下标或者索引通路其中的元素。

特别之處：1.無法通過索引下标通路特定的元素！2.set中的元素不能重複出現！3.不支援運算符将兩個集合相加！

4.可以使用笨方法學py書中的【if obj in set：】來判斷元素是否存在于集合set中——第四點适用于所有類型。

1.向集合中添加元素：add()：隻能一次添加一個；updata([obj_list])：可以一次添加多個，以list形式添加；【ps：這兩個方法沒有傳回值！】

文法：obj.add()

舉例：

friends = {'dog','cat'}

friends.add('duck')

print(friends) # 因為set是無序的是以添加元素位置也是随機的（ps：不能指定位置添加）！

# 結果：{'dog', 'duck', 'cat'}

文法：obj.updata([obj_list])

舉例：

friends = {'dog','cat'}

friends.update(['duck','Cattle'])

print(friends) # 因為set是無序的是以添加元素位置也是随機的（ps：不能指定位置添加）！

# 結果：{'cat', 'dog', 'duck', 'Cattle'}

2.删除集合中的元素：

使用前面清單中學過的remove()【移除某個元素】,關鍵詞：del obj【删除某個元素】,clear()【清空整個對象】三個函數即可，ps：三個都沒有傳回值

3.多個集合相加： .obj.union() , 因為前面說過集合不能使用運算符相加，是以隻能使用指定方法相加，如果兩個集合有相同元素，相加之後隻會出現一個！

文法：變量= obj.union(參數1，參數2……) # 有傳回值！

舉例：

friends = {'dog','cat'}

friends1={'duck','cat'}

friends2 = friends.union(friends1) # 這是集合的并集操作

print(friends2) # 因為集合元素不會重複的特點是以之後保留一個cat，日常也可以使用這一特點去重

# 結果：{'cat', 'dog', 'duck'}

4.找出多個集合中的交集（也就是相同的元素）：.object.intersection()，也就是找出兩個或者多個集合中相同的元素！

文法：變量 = object.intersection(params1，params2……) # 有傳回值

舉例：

friends = {'dog','cat'}

friends1={'duck','cat'}

friends2 = friends.intersection(friends1)

print(friends2)

# 結果：{'cat'}

5.找出多個集合中的差集并傳回其中其中一個的內插補點：.object.difference()，就是找出多個set中不相同的元素，任何傳回其中你想要的其中一個set的不同元素。

文法：變量 = 要傳回的set_obj.difference(params1，params2……) # 有傳回值

舉例：

friends = {'dog','cat'}

friends1={'duck','cat'}

friends2 = friends1.difference(friends)

print(friends2)

# 結果：{'duck'} # 傳回了friends1中的差集值

6. 找出多個集合中的差集并傳回所有集合的差集：.sysmmetric_difference()，找出多個set中不同的元素，然後傳回所有集合的差集值。

文法：變量 = 要傳回的set_obj.sysmmetric_difference(params1，params2……) #有傳回值

舉例：

friends = {'dog','cat'}

friends1={'duck','cat'}

friends2 = friends1.symmetric_difference(friends)

print(friends2)

# 結果：{'duck', 'dog'}  # 傳回了friends1跟friends中的差集值

7. 一個集合所有元素是否包含于另外一個集合中：obj.issuperset()

文法：變量 = 包含的set_obj.issuperset(被包含的set_obj) # 有傳回值 -- 傳回True,False

舉例：

friends = {'dog','cat','duck'}

friends1={'duck','cat'}

friends2 = friends.issuperset(friends1)

print(friends2)

# 結果：傳回True

8. 判斷兩個集合中是否不存在相同的元素：obj_set1.isdisjoint(set2_obj)

文法：變量 = obj_set1.isdisjoint(set2_obj) #有傳回值：如果不存在傳回False，如果存在傳回True

舉例：

friends = {'dog','cat','duck'}

friends1={'duck','cat'}

friends2 = friends.isdisjoint(friends1)

print(friends2)

# 結果： 傳回False

# 因為friends跟friends1存在相同的元素：“cat”

使用sorted()跟reverse()對所有可疊代對象排序：

sorted() 函數對所有可疊代的對象進行排序操作：

sorted 文法：

sorted(iterable, key=None, reverse=False)

參數說明：

iterable -- 可疊代對象。(可疊代對象表示可以周遊的對象！原本清單有一個排序函數sort()，但是sort()是清單操作函數，隻對清單有效，像其他可以疊代的對象如字典，集合等不能進行排序）

L=[('b',2),('a',1),('c',3),('d',4)]
def adi(x,y):
    if x>y:
        return True
    elif x<y:
        return -1
    else:
        return False
adi = adi(L[1],L[1])
print(adi)
if adi ==-1:
    reverse_test = L
else:
    reverse_test = sorted(L,reverse=adi)
print(reverse_test)

# 結果：
# False
# [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

看你輸入的對比值是什麼！其實沒有什麼兩樣。

key -- 主要是用來進行比較的元素，隻有一個參數，具體的函數的參數就是取自于可疊代對象中，指定可疊代對象中的一個元素來進行排序。

【adi：key-- 可以指定哪個值放在首位！】

reverse -- 排序規則，reverse = True 降序， reverse = False 升序（預設）。

a = [5,7,6,3,4,1,2] 

b = sorted(a) # 保留原清單

a [5, 7, 6, 3, 4, 1, 2]

b [1, 2, 3, 4, 5, 6, 7]

L=[('b',2),('a',1),('c',3),('d',4)]

sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))    # 利用cmp函數,沒啥用，傳回0表示false，傳回0表示false，傳回-1表示保留原來的模樣 [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

sorted(L, key=lambda x:x[1])    # 利用key，按第一個（x[1]也就是L[1]）開始排序 [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

sorted(students, key=lambda s: s[2])  # 按年齡排序 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

sorted(students, key=lambda s: s[2], reverse=True)    # 按降序,按第2個（s[2]也就是students[2]）開始排序 [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

reverse() 函數用于倒序可疊代對象中元素：（如果是字元串則直接反轉！不進行排序！排序隻對數值排序！）

reverse()方法文法：list.reverse()

舉例1：

list1 = [, 'xyz', 'zara', 'abc', 'xyz']
list1.reverse()
print(list1)
# result ： ['xyz', 'abc', 'zara', 'xyz', 123]

舉例2：

list1 = [1, 2, 4, 3, 5]

list1.reverse()

print(list1)

# result ： [5, 3, 4, 2, 1]

python3 清單，元組，字典，集合中常見的操作方法彙錦！