python容器類型的常見操作總結

1、list列表（可變的）

（1）基本操作

• list列表中可存儲不同元素類型的數據，通過索引訪問相應的元素，類似於數組的操作方式；
• append()方法再在尾部追加元素；
• insert(索引號， 插入內容)實現在指定位置插入元素；
• pop()方法直接刪除尾部元素，而pop(0)表示刪除第一個元素，也支持pop(索引)形式，並打印出被刪除的元素；
• remove(要移除的元素)實現刪除任意要刪除的元素；

（2）深淺拷貝
一般的操作是：
取出列表中的某個元素賦值給一個新變量，然後操作該新變量，這個過程新變量其實指向的還是原list那個元素的內存地址，因此修改的過程，list中的元素也會發生變化。

爲了在操作的過程中不影響原list列表的各元素值，就需要拷貝。

• 淺拷貝：
  使用copy()函數將你要拷貝的元素或整個列表賦值給一個新變量，則該新變量會指向新的內存空間保存複製過來的值，此時對其修改不會影響原列表的元素。

• 深拷貝：
  然而當list列表中又包含list對象時，此時若仍採用copy()進行淺拷貝，會發現當修改list中的list的某個元素時，原list值還是會發生改變（也就是說只能保證父對象的改變不影響原list,但對於list其中的子對象，淺拷貝實際並沒有拷貝出來，還是指向原list的空間地址），爲此引入了深拷貝，不改變原嵌套list中的值，使用deepcopy()函數實現。例如：

a = [1,2,[3,4,5]]
ac = a.copy()  #淺拷貝
ac[0] = 10
ac[2][1] = 40
print(a[0] == ac[0])  #False
print(a[2][1] == ac[2][1])  #True ,說明原list發生了改變

from copy import deepcopy

a = [1,2,[3,4,5]]
ac = deepcopy(a)  #深拷貝
ac[0] = 10
ac[2][1] = 40
print(a[0] == ac[0])  #False
print(a[2][1] == ac[2][1])  #False， 說明原list不發生改變

（3）切片
假設定義一個list對象a:

• a[-1]：取最後一個元素
• a[ : -1]：取除去最後一個元素的list
• a[1 : 5]：取索引1到4的list,不包括索引5元素
• a[1 : 5 : 2]：指定步長爲2取索引1到4的元素
• a[ : : 3]：按步長3取所有元素
• a[ : : -3]：倒序按步長3取所有元素
• a[ : : -1]：倒序原list ,等效於reverse()函數

（4）元素出現個數統計函數
count(你要統計的元素)

2、tuple元組（不可變的）

與list一致，但是不支持增加刪除操作，特殊情況：若元組中包含list列表對象，那麼該list列表的操作還是滿足原來具有的特性，但無論如何，元組的長度是固定不變的。

常見應用場景：二維座標點的元組

注：set傳入的參數也需要是不可變的，可哈希的，也就是說不能包含list對象。

3、dict字典

（1）五種創建方法
手動創建：

dic = {'a':1, 'b':3, 'c':5}

dict()函數創建：

dict(a=1, b=2, c=3)

鍵值對+關鍵字參數：

dict({'a':1, 'b':2}, c=3, d=4)

可迭代對象：

dict([('a',1),('b',2)], c=3)

fromkeys()方法：該方法只用來創建新字典，不負責保存

{}.fromkeys(['k1', 'k2', 'k3'], [1, 2, 3])
#輸出：{'k1': [1, 2, 3], 'k2': [1, 2, 3], 'k3': [1, 2, 3]}

（2）遍歷字典：

for key, val in dict.items():
	print(key, val)
#獲取所有鍵集合：
set(dict) 或者 set(dict.keys())
#獲取所有值集合：
set(dict.values())
#獲取某鍵對應的值：
dict.get('c')
#刪除一個鍵值對：
del dict['c'] 或者 dict.pop('c')

注：可哈希的對象才能作爲字典的鍵，不可哈希的對象不能作爲字典的鍵。。。比如將list對象就不可以作爲鍵.

4、set集合

特點：不允許元素出現重複，且打印輸出時，順序是隨機的
注意：同字典一樣，list和dict等不可哈希的對象不能最爲集合的元素，如{[1, 2]}寫法是錯誤的。
（1）求並集：

a = {1,3,5,7}
b, c = {3,4,5,6}, {6,7,8,9}
d = a.union(b,c) # {1, 3, 4, 5, 6, 7, 8, 9}

（2）求差集：

a = {1,3,5,7}
b, c = {3,4,5,6}, {6,7,8,9}
d = a.difference(b,c) # {1}

（3）求交集：

a = {1,3,5,7}
b, c = {3,4,5,6}, {6,7,8,9}
d = a.intersection(b,c) # {}

（4）判定a是b的子集：

a.issubset(b)

3、實際案例

（1）判斷list中有無重複元素(有：True, 無：False)
方法1：通過count()函數判斷是否大於1
方法2：set方法，也就是len(list) != len(set(list))

(2)zip（）實現連接

(3)最長列表

def max_len(*lists):   #帶有*的參數爲可變的位置參數，也就是可傳入任意多個位置參數
	return max(*lists, key = lambda v: len(v))
	#max的key參數定義比較對象函數(也就是指定如何進行比較)，
	#這裏比較的是長度，使用lambda表達式返回各列表的長度，max函數返回比較後對應的列表

#測試
r = max_len([1, 2, 3], [4, 5, 6, 7], [8])
print(f'{r}')   #f爲format的縮寫

#輸出  [4, 5, 6, 7]

（4）出現次數最多的元素

def mode(lst):
	if lst is None or len(lst)==0: 
		return None
	return max(lst, key=lambda v: lst.count(v))

（5）斐波那契數列
常規寫法：

def fibonacci(n):
        if n <= 1:
            return [1]
        fib = [1, 1]
        while len(fib) < n:
            fib.append(fib[len(fib) - 1] + fib[len(fib) - 2])
        return fib

生成器版本：使用yield節省內容空間

In [11]: def fibonacci(n):
         a, b = 1, 1
         for _ in range(n):
             yield a  #遇到 yield 返回，下次再進入函數體時，從 yield 的下一句開始執行。
             a, b = b, a + b

（6）批量插入鍵值對

d = {'a': 1, 'b': 2}
d.update({'c':3,'d':4,'e':5})
#或者寫成：
d.update([('c',3),('d',4),('e',5)])
#或者寫成：
d.update([('c',3),('d',4)],e=5)

#輸出d:
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

（7）setdefault用法
如果僅當字典中不存在某個鍵值對時，才插入到字典中；如果存在，不必插入（也就不會修改鍵值對）。

（8）topn鍵
找出字典前 n 個最大值，對應的鍵。
導入 Python 內置模塊 heapq 中的 nlargest 函數，獲取字典中的前 n 個最大值。

from heapq import nlargest
def topn_dict(d, n):
	return nlargest(n, d, key=lambda k: d[k])

(9)一鍵對多值字典
常規寫法：

d = {}
lst = [(1,'apple'),(2,'orange'),(1,'compute')]
for k,v in lst:	
	if k not in d:
	   d[k]=[]
	d[k].append(v)
	
#輸出d:
{1: ['apple', 'compute'], 2: ['orange']}

使用defaultdict先創建不重複字典：

from collection import defaultdict
lst = [(1,'apple'),(2,'orange'),(1,'compute')]
d = defaultdict(list)  #這裏就創建了list的不重複鍵字典
#合併鍵值對
for k, v in list:
	d[k].append(v)  #無需做if判斷了

（10）邏輯上合併字典
普通合併，只會生成新的字典，改變某個鍵值原字典不會發生改變：

dic1 = {'x': 1, 'y': 2 }
dic2 = {'y': 3, 'z': 4 }
merged = {**dic1, **dic2} 
#輸出merged:
{'x': 1, 'y': 3, 'z': 4}
merged['x'] = 10
#輸出merged:
{'x': 10, 'y': 3, 'z': 4}
#輸出dic1:不發生改變
{'x': 1, 'y': 2 }

採用ChainMap函數合併，內部會創建一個容納這些字典的列表，改變某個鍵值原字典也會發生改變：

from collections import ChainMap
dic1 = {'x': 1, 'y': 2 }
dic2 = {'y': 3, 'z': 4 }
merged = ChainMap(dic1,dic2)
#輸出merged:
ChainMap({'x': 1, 'y': 2}, {'y': 3, 'z': 4})
merged['x'] = 10
#輸出merged:
ChainMap({'x': 10, 'y': 2}, {'y': 3, 'z': 4})
#輸出dic1:發生改變
{'x': 10, 'y': 2}