《Python Cookbook》學(xué)習(xí)筆記拿出來分享給大家，暫時更新第一煤裙、二章掩完。
同步自知乎https://zhuanlan.zhihu.com/p/53457483
Jupyter notebook鏈接
1.第一章數(shù)據(jù)結(jié)構(gòu)和算法
2.第二章.字符串和文本
1.第一章數(shù)據(jù)結(jié)構(gòu)和算法
1.1將序列分解為單個變量
任何一個可以迭代的對象都可以通過簡單的賦值操作分解成單個變量
p = (2, 3)
x, y = p
x
2
y
3
data = ['acme', 90, 40, (2018,12,12)]
name, price, shares, date = data
name
'acme'
date
(2018, 12, 12)
name, price, shares, (a,d,c) = data
p = (2, 3)
x, y = p
a
2018
d
12
#如果數(shù)量不匹配
a, c = data
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-10-5f238cb0a912> in <module>()
1 #如果數(shù)量不匹配
----> 2 a, c = data
ValueError: too many values to unpack (expected 2)
只要對象可以迭代，那么就可以進(jìn)行分解操作
h, e, l , l, o = 'hello'
h
'h'
l
'l'
可以使用一些用不到的變量名來丟棄數(shù)值
h, _,_,_,_ = 'hello'
h
'h'
1.2從任意長度的可迭代對象分解元素
解決方案：‘表達(dá)式’可以解決這個問題*
#去掉最高最低分取得平均分
def drop_first_last(data):
fist,*_,last = data
return avg(middle)
record = ('libo', 'libo_vae@163.com', '110', '120')
name, email, phone, *others = record
name
'libo'
*others
File "<ipython-input-18-06f24e34ae71>", line 1
*others
^
SyntaxError: can't use starred expression here
others
['120']
record = ('libo', 'libo_vae@163.com', '110', '120')
*others, phome = record
others
#返回的是一個列表
['libo', 'libo_vae@163.com', '110']
*語句在迭代一個可變長度的元組序列時硼砰，尤其有用
record = [('a',1,2), ('b',1,2,3), ('c',1,2,3,4)]
for i, *other in record:
print(i, other)
a [1, 2]
b [1, 2, 3]
c [1, 2, 3, 4]
#綜合使用
record = ['abc',50,123.3,(2018,12,20)]
name, *ignore, (year, *ignore) = record
name
'abc'
year
2018
#一個神奇的遞歸且蓬，使用*表達(dá)式
def _sum(items):
head, *_it = items
return head + sum(_it) if _it else head
_sum([i for i in range(10)])
45
from collections import deque
def search(lines, pattern, history=5):
previous_lines = deque(maxlen=history)
for line in lines:
if pattern in line:
yield line, previous_lines
previous_lines.append(line)
注意這里的previous_lines.append（line）放在yield的后面，依然會被執(zhí)行题翰，這與return不相同恶阴。如果把這一句提前，會print兩次python * deque（maxlen=number）創(chuàng)建了一個固定長度的隊列遍愿，當(dāng)有新的記錄出現(xiàn)的時候存淫，且隊列已經(jīng)滿了，舊的會被擠掉沼填，新的添加桅咆。 有append方法
with open('untitled.txt', encoding='utf-8') as f:
for line, previlines in search(f, 'python', 5):
for pline in previlines:
print(pline)
print(line, end='')
print('-'*10)
12345
678910
python
----------
678910
python
1112
1
2
python
----------
q = deque(maxlen=3)
q.append(1)
q.append(2)
q.append(3)
q.append(4)
q
deque([2, 3, 4])
#當(dāng)不指定maxlen的時候，隊列長度無限
q = deque()
q.append(1)
q.append(2)
q
deque([1, 2])
q.appendleft(10)
q
deque([10, 1, 2])
q.pop()
2
q.popleft()
10
q
deque([1])
1.4尋找最大最小的n個元素
在某個集合中尋找最大或者最小的n個元素
# heapq 中有兩個函數(shù)——nlargest（）和nsmallest（）坞笙， 可以完成這一工作
import heapq
num = [-1.2,3,3-45,33-4,44,0]
print(heapq.nlargest(3, num))
print(heapq.nsmallest(2, num))
[44, 29, 3]
[-42, -1.2]
# 這兩個函數(shù)還可以接受參數(shù)key岩饼， 傳遞一個函數(shù)fun， 根據(jù)fun的值進(jìn)行選擇
portfolio = [
{'name':'libo', 'price':10, 'grades':3},
{'name':'libobo','price':11, 'grades':4}
]
print(heapq.nlargest(2, portfolio, key=lambda s: s['grades']))
print(heapq.nsmallest(1, portfolio, key=lambda s: s['grades']))
[{'name': 'libobo', 'price': 11, 'grades': 4}, {'name': 'libo', 'price': 10, 'grades': 3}]
[{'name': 'libo', 'price': 10, 'grades': 3}]
使用堆的方法可以更加節(jié)省性能薛夜，當(dāng)數(shù)據(jù)量很大籍茧，我們只要取得最小的那么幾個的時候，這個速度更快
import math
nums = [int(math.sin(3*i)*15) for i in range(10)]
nums
[0, 2, -4, 6, -8, 9, -11, 12, -13, 14]
heap = list(nums)
heapq.heapify(heap) # heapify（）
heap
[-13, -8, -11, 2, 0, 9, -4, 12, 6, 14]
heapq.heappop(heap)
-13
heapq.heappop(heap)
# secondly
-11
值得注意的是梯澜，當(dāng)獲取的數(shù)量和集合元素數(shù)量接近時寞冯，排序是最好的辦法，sorted（item）[:N]
1.5實現(xiàn)優(yōu)先級隊列
對不同元素按照優(yōu)先級進(jìn)行排序
class Item():
def __init__(self, name):
self.name = name
def __repr__(self):
return 'Item({!r})'.format(self.name)
item1 = Item('book')
item1
# 注意這里使用！r和不使用它的區(qū)別吮龄，不使用時：結(jié)果是Item（book）俭茧，沒有引號
Item('book')
import heapq
class PriorityQueue():
def __init__(self):
self.queue = []
self.index = 0
def push(self, item, priority):
heapq.heappush(self.queue, (-priority, self.index, item)) # 注意 heappush（）的用法
self.index += 1 # index是第二排序準(zhǔn)則
def pop(self):
return heapq.heappop(self.queue)
q = PriorityQueue()
q.push(Item('foo'), 2)
q.push(Item('fooo'), 2)
q.push(Item('foooo'), 3)
q.push('123', 4)
q.pop()
(-4, 3, '123')
q.pop()
(-3, 2, Item('foooo'))
q.pop()
(-2, 0, Item('foo'))
q.pop()
(-2, 1, Item('fooo'))
（priority，item）形式也可以比較優(yōu)先級漓帚，但優(yōu)先級相同會出現(xiàn)問題母债。可以考慮添加inde
a = (1, 'a')
b = (2, 'b')
a < b
True
b < (2, 'c')
True
1.6在字典中將鍵映射到多個值上
d = {
'a':[1,2],
'b':[3,4]
}
d['c']=[5,6]
d
{'a': [1, 2], 'b': [3, 4], 'c': [5, 6]}
from collections import defaultdict
d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['b'].append(3)
d
defaultdict(list, {'a': [1, 2], 'b': [3]})
# 自己構(gòu)建多值映射也可以
d = {
'a':[2]
}
pairs = [
('a',1),
(2,2)
]
for key, values in pairs:
if key not in d:
d[key] = []
d[key].append(values)
d
{2: [2], 'a': [2, 1]}
1.7讓字典有序
可以使用collection中的OrderDict類尝抖。對字典做迭代時候毡们，會按照添加順序
from collections import OrderedDict
d = OrderedDict()
d['a'] = 1
d['b'] = 2
d
OrderedDict([('a', 1), ('b', 2)])
import json
json.dumps(d)
'{"a": 1, "b": 2}'
1.8與字典有關(guān)的排序問題
# 找到股價最低的股票
price ={
'Alibaba':30,
'Tenxun':20,
'IBM':21,
'FB':35
}
min_price = min(zip(price.values(), price.keys()))
min_price
(20, 'Tenxun')
# zip()的用法
z = zip(['a', 'b', 'c'], [1, 2, 3])
print(list(z))
[('a', 1), ('b', 2), ('c', 3)]
其他一般方法
min(price)
'Alibaba'
max(price)
'Tenxun'
min(price.values())
20
key = min(price, key=lambda x: price[x]) # 'Tenxun'
price[key]
20
1.9尋找兩個字典中的相同點（key，value）
a = {
'a':1,
'y':2,
'c':3
}
b = {
'x':3,
'y':2,
'z':1
}
# Find keys in common
a.keys() & b.keys()
{'y'}
a.values() & b.values()
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-79-29f31ab220a5> in <module>()
----> 1 a.values() & b.values()
TypeError: unsupported operand type(s) for &: 'dict_values' and 'dict_values'
a.keys() | b.keys()
{'a', 'c', 'x', 'y', 'z'}
a.keys() - b.keys()
{'a', 'c'}
# find (key, value) pairs in item
a.items() & b.items()
{('y', 2)}
a.items() | b.items()
{('a', 1), ('c', 3), ('x', 3), ('y', 2), ('z', 1)}
list(a.items())
[('a', 1), ('y', 2), ('c', 3)]
1.10從序列總移除重復(fù)項且保持元素間的迅速不變
# 如果序列中的值是可哈希的（hashable）
def dedupe(items):
seen = set()
for item in items:
if item not in seen:
yield item
seen.add(item)
a = [i*i for i in range(-5,5)]
list(dedupe(a))
[25, 16, 9, 4, 1, 0]
a.append([1,2])
a
[25, 16, 9, 4, 1, 0, 1, 4, 9, 16, [1, 2]]
[1,2] in a
True
list(dedupe(a))
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-90-10e1eea397e9> in <module>()
----> 1 list(dedupe(a))
<ipython-input-85-74764d4efed6> in dedupe(items)
3 seen = set()
4 for item in items:
----> 5 if item not in seen:
6 yield item
7 seen.add(item)
TypeError: unhashable type: 'list'
set(a) # 列表不能哈厦亮桑化
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-91-e927598b8019> in <module>()
----> 1 set(a) # 列表不能哈涎萌郏化
TypeError: unhashable type: 'list'
1.可哈希（hashable）和不可改變性（immutable）
如果一個對象在自己的生命周期中有一哈希值（hash value）是不可改變的，那么它就是可哈希的（hashable）的奴迅，因為這些數(shù)據(jù)結(jié)構(gòu)內(nèi)置了哈希值饵逐，每個可哈希的對象都內(nèi)置了hash方法梢灭，所以可哈希的對象可以通過哈希值進(jìn)行對比磨隘，也可以作為字典的鍵值和作為set函數(shù)的參數(shù)油挥。所有python中所有不可改變的的對象（imutable objects）都是可哈希的，比如字符串暇检，元組产阱，也就是說可改變的容器如字典，列表不可哈希（unhashable）块仆。我們用戶所定義的類的實例對象默認(rèn)是可哈希的（hashable）构蹬，它們都是唯一的，而hash值也就是它們的id()悔据。
- 哈希
它是一個將大體量數(shù)據(jù)轉(zhuǎn)化為很小數(shù)據(jù)的過程庄敛，甚至可以僅僅是一個數(shù)字，以便我們可以用在固定的時間復(fù)雜度下查詢它科汗，所以藻烤，哈希對高效的算法和數(shù)據(jù)結(jié)構(gòu)很重要。
- 不可改變性
它指一些對象在被創(chuàng)建之后不會因為某些方式改變头滔，特別是針對任何可以改變哈希對象的哈希值的方式
- 聯(lián)系：
因為哈希鍵一定是不可改變的怖亭，所以它們對應(yīng)的哈希值也不改變。如果允許它們改變坤检，兴猩，那么它們在數(shù)據(jù)結(jié)構(gòu)如哈希表中的存儲位置也會改變，因此會與哈希的概念違背早歇，效率會大打折扣
# 稍作改變倾芝，使得值哈咸智冢化
def dedupe(items, key=None):
seen = set()
for item in items:
val = item if key==None else key(item)
if val not in seen:
yield item
seen.add(val)
b = [{'x':1,'y':2}, {'x':4,'y':2}, {'x':1,'y':3}, {'x':1,'y':2}]
de = dedupe(b, key=lambda x:(x['x'],x['y']))
list(de) # 去除了重復(fù)的{'x':1,'y':2}
[{'x': 1, 'y': 2}, {'x': 4, 'y': 2}, {'x': 1, 'y': 3}]
其實使用集合的方法就可以實現(xiàn)，但是定義函數(shù)的目的在于蛀醉，對任意可以迭代對象都可以使用該方法悬襟，比如 \n f = open('aa.txt') for line in dedupe(f): ……
set(b)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-95-1390747a0750> in <module>()
----> 1 set(b)
TypeError: unhashable type: 'dict'
1.10對切片命名
item = [i for i in range(10)]
a = slice(2, 4)
item[a]
[2, 3]
del item[a]
item
[0, 1, 4, 5, 6, 7, 8, 9]
a.start
2
a.stop
4
1.11找出序列中出現(xiàn)最多的元素
collections模塊中的Couner類衅码，正是為此問題而設(shè)計的拯刁。它的most_common（）方法可以快速給出答案。
word = [str(int(math.sin(i)*5)) for i in range(20)]
word
['0',
'4',
'4',
'0',
'-3',
'-4',
'-1',
'3',
'4',
'2',
'-2',
'-4',
'-2',
'2',
'4',
'3',
'-1',
'-4',
'-3',
'0']
from collections import Counter
word_counter = Counter(word)
top_3 = word_counter.most_common(3)
top_3
[('4', 4), ('0', 3), ('-4', 3)]
可以給Counter對象提供任意可以哈鲜哦危化的序列作為參數(shù)垛玻。 在底層實現(xiàn)中，Counter是一個字典奶躯，在元素和次數(shù)之間做了映射
word_counter['2']
2
#如果需要更新counter帚桩，可以手動添加‘’
for w in word:
word_counter[w] += 1
word_counter['2']
4
#也可以使用update方法
word.append('2')
word_counter.update(word)
word_counter['2'] #4+2+1
7
#另外 counter對象也可以進(jìn)行加減運算
1.13通過公共鍵對字典列表排序
# 前面我們討論過多了鍵值排序方法。即嘹黔，不同股票價格排序的方法账嚎。如果字典有多對key-vlue組成一個列表，根據(jù)其中一個如何排序
rows = [
{'fname':'li5', 'lname':'bo', 'uid':101},
{'fname':'li2', 'lname':'bo2', 'uid':102},
{'fname':'li3', 'lname':'bo3', 'uid':103},
{'fname':'li4', 'lname':'bo4', 'uid':104},
]
from operator import itemgetter
rows_by_fname = sorted(rows, key=itemgetter('fname'))
rows_by_fname
[{'fname': 'li2', 'lname': 'bo2', 'uid': 102},
{'fname': 'li3', 'lname': 'bo3', 'uid': 103},
{'fname': 'li4', 'lname': 'bo4', 'uid': 104},
{'fname': 'li5', 'lname': 'bo', 'uid': 101}]
在這個例子中儡蔓，rows被傳遞給sorted函數(shù)郭蕉，該函數(shù)接受一個關(guān)鍵字參數(shù)key，key作為一個可調(diào)用對象（callable）喂江。callable從rows中選取一個單獨的元素作為輸入并返回一個用來排序的依據(jù)值召锈。
# 根據(jù)這個思想，我們可以這樣
rows_by_fname = sorted(rows, key=lambda x: x['fname'])
rows_by_fname
[{'fname': 'li2', 'lname': 'bo2', 'uid': 102},
{'fname': 'li3', 'lname': 'bo3', 'uid': 103},
{'fname': 'li4', 'lname': 'bo4', 'uid': 104},
{'fname': 'li5', 'lname': 'bo', 'uid': 101}]
#對照前面的例子
price
{'Alibaba': 30, 'FB': 35, 'IBM': 21, 'Tenxun': 20}
sorted(price, key=lambda k:price[k])
['Tenxun', 'IBM', 'Alibaba', 'FB']
1.14對不原生支持比較操作對象排序
# 這里詳細(xì)體會sorted函數(shù)key作為回調(diào)對象的用法
class User():
def __init__(self,id):
self.id = id
def __repr__(self):
return 'U{}'.format(self.id)
uses = [User(40), User(20), User(30)]
uses
[U40, U20, U30]
sorted(uses, key=lambda x:x.id)
[U20, U30, U40]
與from operator import itemgetter 對應(yīng) 有operator.attrgetter()
import operator
sorted(uses, key=operator.attrgetter('id'))
[U20, U30, U40]
之所以會有這種方法获询，是因為這種方法比自己構(gòu)造匿名函數(shù)涨岁，性能更加高效
1.15根據(jù)字段（如日期）將數(shù)據(jù)進(jìn)行分組
rows = [
{'address':'555N 444W', 'date':'2018/12/27'},
{'address':'555N 44W', 'date':'2018/12/2'},
{'address':'555N 4W', 'date':'2018/1/27'},
{'address':'55N 444W', 'date':'2018/1/27'},
{'address':'5N 444W', 'date':'2018/2/27'},
{'address':'5N 444W', 'date':'2018/12/7'},
{'address':'55N 44W', 'date':'2018/12/27'},
]
from operator import itemgetter
from itertools import groupby
rows.sort(key=itemgetter('date'))
rows
[{'address': '555N 4W', 'date': '2018/1/27'},
{'address': '55N 444W', 'date': '2018/1/27'},
{'address': '555N 44W', 'date': '2018/12/2'},
{'address': '555N 444W', 'date': '2018/12/27'},
{'address': '55N 44W', 'date': '2018/12/27'},
{'address': '5N 444W', 'date': '2018/12/7'},
{'address': '5N 444W', 'date': '2018/2/27'}]
for date, item in groupby(rows, key=itemgetter('date')):
print(date)
for i in item:
print(' ', i)
2018/1/27
{'address': '555N 4W', 'date': '2018/1/27'}
{'address': '55N 444W', 'date': '2018/1/27'}
2018/12/2
{'address': '555N 44W', 'date': '2018/12/2'}
2018/12/27
{'address': '555N 444W', 'date': '2018/12/27'}
{'address': '55N 44W', 'date': '2018/12/27'}
2018/12/7
{'address': '5N 444W', 'date': '2018/12/7'}
2018/2/27
{'address': '5N 444W', 'date': '2018/2/27'}
如果不事先排序好的話，會有這樣的結(jié)果：
rows = [
{'address':'555N 444W', 'date':'2018/12/27'},
{'address':'555N 44W', 'date':'2018/12/2'},
{'address':'555N 4W', 'date':'2018/1/27'},
{'address':'55N 444W', 'date':'2018/1/27'},
{'address':'5N 444W', 'date':'2018/2/27'},
{'address':'5N 444W', 'date':'2018/12/7'},
{'address':'55N 44W', 'date':'2018/12/27'},
]
for date, item in groupby(rows, key=itemgetter('date')):
print(date)
for i in item:
print(' ', i)
2018/12/27
{'address': '555N 444W', 'date': '2018/12/27'}
2018/12/2
{'address': '555N 44W', 'date': '2018/12/2'}
2018/1/27
{'address': '555N 4W', 'date': '2018/1/27'}
{'address': '55N 444W', 'date': '2018/1/27'}
2018/2/27
{'address': '5N 444W', 'date': '2018/2/27'}
2018/12/7
{'address': '5N 444W', 'date': '2018/12/7'}
2018/12/27
{'address': '55N 44W', 'date': '2018/12/27'}
從中可見groupby（）的用法吉嚣。 group（）會依據(jù)前后的key產(chǎn)生一個類似字典的迭代器梢薪，前后相同的key被打包，對應(yīng)的value是一個子迭代器尝哆。
討論：我們也可以這樣操作來實現(xiàn)按照日期排序：使用date作為key秉撇，字典作為value，構(gòu)造一個多值對應(yīng)的字典
dic = {
}
for row in rows:
dic[row['date']] = []
for row in rows:
dic[row['date']].append(row)
for key in dic:
print(key)
print(dic[key])
2018/12/27
[{'address': '555N 444W', 'date': '2018/12/27'}, {'address': '55N 44W', 'date': '2018/12/27'}]
2018/12/2
[{'address': '555N 44W', 'date': '2018/12/2'}]
2018/1/27
[{'address': '555N 4W', 'date': '2018/1/27'}, {'address': '55N 444W', 'date': '2018/1/27'}]
2018/2/27
[{'address': '5N 444W', 'date': '2018/2/27'}]
2018/12/7
[{'address': '5N 444W', 'date': '2018/12/7'}]
# 事實上利用前面講到的 創(chuàng)建一鍵多值 的 defaultdict（）更加方便
from collections import defaultdict
row_by_date = defaultdict(list)
for row in rows:
row_by_date[row['date']].append(row)
for key in row_by_date:
print(key)
print(row_by_date[key])
2018/12/27
[{'address': '555N 444W', 'date': '2018/12/27'}, {'address': '55N 44W', 'date': '2018/12/27'}]
2018/12/2
[{'address': '555N 44W', 'date': '2018/12/2'}]
2018/1/27
[{'address': '555N 4W', 'date': '2018/1/27'}, {'address': '55N 444W', 'date': '2018/1/27'}]
2018/2/27
[{'address': '5N 444W', 'date': '2018/2/27'}]
2018/12/7
[{'address': '5N 444W', 'date': '2018/12/7'}]
1.16依據(jù)條件對列表元素進(jìn)行篩選
# 列表推導(dǎo)式
mylist = [i for i in range(10)]
[n for n in mylist if n>5]
[6, 7, 8, 9]
如果列表數(shù)據(jù)多较解，會產(chǎn)生龐大結(jié)果占據(jù)內(nèi)存畜疾。那么可以使用生成器表達(dá)式通過迭代的方式篩選結(jié)果
pos = (n for n in mylist if n>5 )
pos
<generator object <genexpr> at 0x0000024B2F8D4780>
for x in pos:
print(x)
6
7
8
9
pos = [n for n in mylist if n>5]
pos
[6, 7, 8, 9]
當(dāng)篩選條件復(fù)雜的時候，沒法用簡單的表達(dá)式表示時印衔， 可以考錄使用內(nèi)建函數(shù)filter()
values = [1,2,3,'3','#','na']
def is_int(n):
try:
int(n)
return True
except:
return False
newlist = list(filter(is_int, values))
print(newlist)
[1, 2, 3, '3']
# 篩選和替換數(shù)據(jù)
clip_neg = [n if n > 5 else 0 for n in mylist]
clip_neg
[0, 0, 0, 0, 0, 0, 6, 7, 8, 9]
# compress的用法
from itertools import compress
list(compress(['a','b','c'], [True, False, True]))
['a', 'c']
1.17從字典中提取子集（字典篩選）
price = {
'Aliba': 10,
'Ten':20,
'Fb':10.2,
'IBM': 11.2,
'BB':42
}
pl = {key:value for key,value in price.items() if value>15}
pl
{'BB': 42, 'Ten': 20}
# 另一種方法
pos = ((key,value) for key,value in price.items())
pos
<generator object <genexpr> at 0x0000024B2F8D4048>
dict(pos)
{'Aliba': 10, 'BB': 42, 'Fb': 10.2, 'IBM': 11.2, 'Ten': 20}
1.19同時對數(shù)據(jù)做轉(zhuǎn)換和換算
num = [i for i in range(10)]
sum(x*x for x in num)
285
# 這是把生成器作為函數(shù)的參數(shù)啡捶，省去了多余的括號,節(jié)省了內(nèi)存
s = sum((x*x for x in num))
1.20將多個映射合并為單個映射
a = {'x':1,'y':2}
b = {'x':2,'z':3}
from collections import ChainMap
c = ChainMap(a,b)
c
ChainMap({'x': 1, 'y': 2}, {'x': 2, 'z': 3})
c['x']
1
list(c.keys())
['z', 'x', 'y']
update()方案可以起到類似的效果
a.update(b)
a
{'x': 2, 'y': 2, 'z': 3}
# 使用ChainMap的優(yōu)勢在于不會更改原始數(shù)據(jù)
merged = ChainMap(a,b)
merged
ChainMap({'x': 2, 'y': 2, 'z': 3}, {'x': 2, 'z': 3})
merged['z']
3
a['z']=100
merged['z']
100
a['z']
100
b['z']
3
# 修改ChainMap的操作只會進(jìn)行再第一個字典上，如這里的a
merged['z']=106
a['z']
106
b['z']
3
編輯于 23:38
