Sử dụng
>>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
4:>>> from collections import Counter
>>> A = Counter[{'a':1, 'b':2, 'c':3}]
>>> B = Counter[{'b':3, 'c':4, 'd':5}]
>>> A + B
Counter[{'c': 7, 'b': 5, 'd': 5, 'a': 1}]
Các bộ đếm về cơ bản là một lớp con của
>>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
5, vì vậy bạn vẫn có thể làm mọi thứ khác với chúng mà bạn thường làm với loại đó, chẳng hạn như lặp lại các khóa và giá trị của chúng.Đã trả lời ngày 13 tháng 6 năm 2012 lúc 9:22Jun 13, 2012 at 9:22
Martijn Pieters ♦ Martijn Pieters♦Martijn Pieters
993K277 Huy hiệu vàng3911 Huy hiệu bạc3256 Huy hiệu đồng277 gold badges3911 silver badges3256 bronze badges
12
Một giải pháp chung chung hơn, cũng hoạt động cho các giá trị không phải là số lượng:
a = {'a': 'foo', 'b':'bar', 'c': 'baz'}
b = {'a': 'spam', 'c':'ham', 'x': 'blah'}
r = dict[a.items[] + b.items[] +
[[k, a[k] + b[k]] for k in set[b] & set[a]]]
hoặc thậm chí còn chung chung hơn:
def combine_dicts[a, b, op=operator.add]:
return dict[a.items[] + b.items[] +
[[k, op[a[k], b[k]]] for k in set[b] & set[a]]]
Ví dụ:
>>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
Rafaelc
55.3K15 Huy hiệu vàng54 Huy hiệu bạc79 Huy hiệu đồng15 gold badges54 silver badges79 bronze badges
Đã trả lời ngày 13 tháng 6 năm 2012 lúc 9:41Jun 13, 2012 at 9:41
8
>>> A = {'a':1, 'b':2, 'c':3}
>>> B = {'b':3, 'c':4, 'd':5}
>>> c = {x: A.get[x, 0] + B.get[x, 0] for x in set[A].union[B]}
>>> print[c]
{'a': 1, 'c': 7, 'b': 5, 'd': 5}
Đã trả lời ngày 13 tháng 6 năm 2012 lúc 9:25Jun 13, 2012 at 9:25
Ashwini Chaudharyashwini ChaudharyAshwini Chaudhary
238K56 Huy hiệu vàng449 Huy hiệu bạc498 Huy hiệu Đồng56 gold badges449 silver badges498 bronze badges
2
Giới thiệu: Có các giải pháp tốt nhất [có thể]. Nhưng bạn phải biết nó và nhớ nó và đôi khi bạn phải hy vọng rằng phiên bản Python của bạn không quá cũ hoặc bất kể vấn đề nào có thể. There are the [probably] best solutions. But you have to know it and remember it and sometimes you have to hope that your Python version isn't too old or whatever the issue could be.
Sau đó, có những giải pháp 'hacky' nhất. Chúng rất tuyệt và ngắn nhưng đôi khi khó hiểu, để đọc và nhớ.
Mặc dù vậy, có một sự thay thế là để cố gắng phát minh lại bánh xe. - Tại sao phải phát minh lại bánh xe? - Nói chung bởi vì đó là một cách thực sự tốt để học [và đôi khi chỉ vì công cụ đã tồn tại không làm chính xác những gì bạn muốn và/hoặc cách bạn muốn nó] và cách dễ nhất nếu bạn không biết hoặc Đừng nhớ công cụ hoàn hảo cho vấn đề của bạn.
Vì vậy, tôi đề xuất phát minh lại bánh xe của lớp
6 từ mô -đun >>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
7 [ít nhất là một phần]:, I propose to reinvent the wheel of the >>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
>>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
6 class from the >>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
7 module
[partially at least]:class MyDict[dict]:
def __add__[self, oth]:
r = self.copy[]
try:
for key, val in oth.items[]:
if key in r:
r[key] += val # You can custom it here
else:
r[key] = val
except AttributeError: # In case oth isn't a dict
return NotImplemented # The convention when a case isn't handled
return r
a = MyDict[{'a':1, 'b':2, 'c':3}]
b = MyDict[{'b':3, 'c':4, 'd':5}]
print[a+b] # Output {'a':1, 'b': 5, 'c': 7, 'd': 5}
Có lẽ sẽ có cách khác để thực hiện điều đó và đã có công cụ để làm điều đó nhưng thật tuyệt khi hình dung cách mọi thứ về cơ bản sẽ hoạt động.
Đã trả lời ngày 18 tháng 2 năm 2013 lúc 6:45Feb 18, 2013 at 6:45
Jeromejjeromejjeromej
9.3822 Huy hiệu vàng42 Huy hiệu bạc62 Huy hiệu Đồng2 gold badges42 silver badges62 bronze badges
1
Chắc chắn tóm tắt các ____38 là cách pythonic nhất để đi trong những trường hợp như vậy nhưng chỉ khi nó dẫn đến một giá trị tích cực. Dưới đây là một ví dụ và như bạn có thể thấy, kết quả không có ____39 sau khi phủ định giá trị của ____ 39 trong từ điển
>>> A = {'a':1, 'b':2, 'c':3}
>>> B = {'b':3, 'c':4, 'd':5}
>>> c = {x: A.get[x, 0] + B.get[x, 0] for x in set[A].union[B]}
>>> print[c]
{'a': 1, 'c': 7, 'b': 5, 'd': 5}
1.only if it results in a positive value.
Here is an example and as you can see there is no >>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
9 in result after negating the >>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
9's value in >>> A = {'a':1, 'b':2, 'c':3}
>>> B = {'b':3, 'c':4, 'd':5}
>>> c = {x: A.get[x, 0] + B.get[x, 0] for x in set[A].union[B]}
>>> print[c]
{'a': 1, 'c': 7, 'b': 5, 'd': 5}
1 dictionary.In [1]: from collections import Counter
In [2]: A = Counter[{'a':1, 'b':2, 'c':3}]
In [3]: B = Counter[{'b':3, 'c':-4, 'd':5}]
In [4]: A + B
Out[4]: Counter[{'d': 5, 'b': 5, 'a': 1}]
Đó là bởi vì
>>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
6 được thiết kế chủ yếu để hoạt động với các số nguyên dương để thể hiện số lượng chạy [số lượng âm là vô nghĩa]. Nhưng để giúp với các trường hợp sử dụng đó, Python ghi lại phạm vi tối thiểu và các hạn chế loại như sau:
- Bản thân lớp quầy là một lớp con từ điển không có hạn chế về các khóa và giá trị của nó. Các giá trị được dự định là số đại diện cho số lượng, nhưng bạn có thể lưu trữ bất cứ thứ gì trong trường giá trị.
- Phương thức
3 chỉ yêu cầu các giá trị có thể đặt hàng.>>> A = {'a':1, 'b':2, 'c':3} >>> B = {'b':3, 'c':4, 'd':5} >>> c = {x: A.get[x, 0] + B.get[x, 0] for x in set[A].union[B]} >>> print[c] {'a': 1, 'c': 7, 'b': 5, 'd': 5}
- Đối với các hoạt động tại chỗ như
4>>> A = {'a':1, 'b':2, 'c':3} >>> B = {'b':3, 'c':4, 'd':5} >>> c = {x: A.get[x, 0] + B.get[x, 0] for x in set[A].union[B]} >>> print[c] {'a': 1, 'c': 7, 'b': 5, 'd': 5}
5, loại giá trị chỉ cần hỗ trợ cộng và trừ. Vì vậy, các phân số, phao và số thập phân sẽ hoạt động và các giá trị âm được hỗ trợ. Điều tương tự cũng đúng với>>> A = {'a':1, 'b':2, 'c':3} >>> B = {'b':3, 'c':4, 'd':5} >>> c = {x: A.get[x, 0] + B.get[x, 0] for x in set[A].union[B]} >>> print[c] {'a': 1, 'c': 7, 'b': 5, 'd': 5}
6 và>>> A = {'a':1, 'b':2, 'c':3} >>> B = {'b':3, 'c':4, 'd':5} >>> c = {x: A.get[x, 0] + B.get[x, 0] for x in set[A].union[B]} >>> print[c] {'a': 1, 'c': 7, 'b': 5, 'd': 5}
7 cho phép các giá trị âm và 0 cho cả đầu vào và đầu ra.>>> A = {'a':1, 'b':2, 'c':3} >>> B = {'b':3, 'c':4, 'd':5} >>> c = {x: A.get[x, 0] + B.get[x, 0] for x in set[A].union[B]} >>> print[c] {'a': 1, 'c': 7, 'b': 5, 'd': 5}
- Các phương pháp Multiset chỉ được thiết kế cho các trường hợp sử dụng với các giá trị dương. Các đầu vào có thể là âm hoặc bằng không, nhưng chỉ các đầu ra có giá trị dương được tạo ra. Không có hạn chế loại, nhưng loại giá trị cần hỗ trợ bổ sung, trừ và so sánh.
- Phương pháp
8 yêu cầu số nguyên. Nó bỏ qua số không và âm tính.>>> A = {'a':1, 'b':2, 'c':3} >>> B = {'b':3, 'c':4, 'd':5} >>> c = {x: A.get[x, 0] + B.get[x, 0] for x in set[A].union[B]} >>> print[c] {'a': 1, 'c': 7, 'b': 5, 'd': 5}
Vì vậy, để giải quyết vấn đề đó sau khi tính tổng quầy của bạn, bạn có thể sử dụng
>>> A = {'a':1, 'b':2, 'c':3}
>>> B = {'b':3, 'c':4, 'd':5}
>>> c = {x: A.get[x, 0] + B.get[x, 0] for x in set[A].union[B]}
>>> print[c]
{'a': 1, 'c': 7, 'b': 5, 'd': 5}
9 để có được đầu ra mong muốn. Nó hoạt động như class MyDict[dict]:
def __add__[self, oth]:
r = self.copy[]
try:
for key, val in oth.items[]:
if key in r:
r[key] += val # You can custom it here
else:
r[key] = val
except AttributeError: # In case oth isn't a dict
return NotImplemented # The convention when a case isn't handled
return r
a = MyDict[{'a':1, 'b':2, 'c':3}]
b = MyDict[{'b':3, 'c':4, 'd':5}]
print[a+b] # Output {'a':1, 'b': 5, 'c': 7, 'd': 5}
0 nhưng thêm số lượng thay vì thay thế chúng.In [24]: A.update[B]
In [25]: A
Out[25]: Counter[{'d': 5, 'b': 5, 'a': 1, 'c': -1}]
Đã trả lời ngày 10 tháng 3 năm 2017 lúc 11:12Mar 10, 2017 at 11:12
MazdakmazdakMazdak
102K18 Huy hiệu vàng157 Huy hiệu bạc183 Huy hiệu đồng18 gold badges157 silver badges183 bronze badges
0
myDict = {}
for k in itertools.chain[A.keys[], B.keys[]]:
myDict[k] = A.get[k, 0]+B.get[k, 0]
Đã trả lời ngày 4 tháng 7 năm 2014 lúc 10:06Jul 4, 2014 at 10:06
Người không có nhập khẩu thêm!no extra imports!
Chúng là một tiêu chuẩn pythonic gọi là EAFP [dễ dàng yêu cầu tha thứ hơn là sự cho phép]. Mã dưới đây dựa trên tiêu chuẩn Python đó.
# The A and B dictionaries
A = {'a': 1, 'b': 2, 'c': 3}
B = {'b': 3, 'c': 4, 'd': 5}
# The final dictionary. Will contain the final outputs.
newdict = {}
# Make sure every key of A and B get into the final dictionary 'newdict'.
newdict.update[A]
newdict.update[B]
# Iterate through each key of A.
for i in A.keys[]:
# If same key exist on B, its values from A and B will add together and
# get included in the final dictionary 'newdict'.
try:
addition = A[i] + B[i]
newdict[i] = addition
# If current key does not exist in dictionary B, it will give a KeyError,
# catch it and continue looping.
except KeyError:
continue
EDIT: Cảm ơn Jer nhận thấy những gợi ý cải tiến của anh ấy.
Đã trả lời ngày 3 tháng 5 năm 2014 lúc 6:20May 3, 2014 at 6:20
3
a = {'a': 'foo', 'b':'bar', 'c': 'baz'}
b = {'a': 'spam', 'c':'ham', 'x': 'blah'}
r = dict[a.items[] + b.items[] +
[[k, a[k] + b[k]] for k in set[b] & set[a]]]
0HOẶC
Thay thế bạn có thể sử dụng bộ đếm như @martijn đã đề cập ở trên.
Gaurav Ojha
1.0941 Huy hiệu vàng12 Huy hiệu bạc35 Huy hiệu đồng1 gold badge12 silver badges35 bronze badges
Đã trả lời ngày 4 tháng 7 năm 2014 lúc 10:49Jul 4, 2014 at 10:49
AdeeladeelAdeel
7516 Huy hiệu bạc22 Huy hiệu Đồng6 silver badges22 bronze badges
Đối với một cách chung chung và có thể mở rộng kiểm tra hợp nhất. Nó sử dụng
class MyDict[dict]:
def __add__[self, oth]:
r = self.copy[]
try:
for key, val in oth.items[]:
if key in r:
r[key] += val # You can custom it here
else:
r[key] = val
except AttributeError: # In case oth isn't a dict
return NotImplemented # The convention when a case isn't handled
return r
a = MyDict[{'a':1, 'b':2, 'c':3}]
b = MyDict[{'b':3, 'c':4, 'd':5}]
print[a+b] # Output {'a':1, 'b': 5, 'c': 7, 'd': 5}
1 và có thể hợp nhất các giá trị dựa trên các loại của nó.Example:
a = {'a': 'foo', 'b':'bar', 'c': 'baz'}
b = {'a': 'spam', 'c':'ham', 'x': 'blah'}
r = dict[a.items[] + b.items[] +
[[k, a[k] + b[k]] for k in set[b] & set[a]]]
1Đã trả lời ngày 14 tháng 11 năm 2014 lúc 10:43Nov 14, 2014 at 10:43
schettino72schettino72schettino72
2.85026 huy hiệu bạc27 Huy hiệu đồng26 silver badges27 bronze badges
Ngoài ra, xin lưu ý
class MyDict[dict]:
def __add__[self, oth]:
r = self.copy[]
try:
for key, val in oth.items[]:
if key in r:
r[key] += val # You can custom it here
else:
r[key] = val
except AttributeError: # In case oth isn't a dict
return NotImplemented # The convention when a case isn't handled
return r
a = MyDict[{'a':1, 'b':2, 'c':3}]
b = MyDict[{'b':3, 'c':4, 'd':5}]
print[a+b] # Output {'a':1, 'b': 5, 'c': 7, 'd': 5}
2 nhanh hơn 2 lần so với class MyDict[dict]:
def __add__[self, oth]:
r = self.copy[]
try:
for key, val in oth.items[]:
if key in r:
r[key] += val # You can custom it here
else:
r[key] = val
except AttributeError: # In case oth isn't a dict
return NotImplemented # The convention when a case isn't handled
return r
a = MyDict[{'a':1, 'b':2, 'c':3}]
b = MyDict[{'b':3, 'c':4, 'd':5}]
print[a+b] # Output {'a':1, 'b': 5, 'c': 7, 'd': 5}
3a = {'a': 'foo', 'b':'bar', 'c': 'baz'}
b = {'a': 'spam', 'c':'ham', 'x': 'blah'}
r = dict[a.items[] + b.items[] +
[[k, a[k] + b[k]] for k in set[b] & set[a]]]
2Đã trả lời ngày 20 tháng 8 năm 2017 lúc 15:11Aug 20, 2017 at 15:11
Shouldseeshouldseeshouldsee
4156 Huy hiệu bạc7 Huy hiệu Đồng6 silver badges7 bronze badges
Từ Python 3.5: Hợp nhất và tổng kết
Cảm ơn @ToKeInizer_FSJ đã nói với tôi trong một nhận xét rằng tôi đã không nhận được hoàn toàn ý nghĩa của câu hỏi [tôi nghĩ rằng thêm có nghĩa là chỉ thêm các khóa mà cuối cùng khác nhau trong hai câu chuyện và thay vào đó, tôi có nghĩa là các giá trị khóa phổ biến nên được tổng hợp]. Vì vậy, tôi đã thêm vòng lặp đó trước khi hợp nhất, để từ điển thứ hai chứa tổng của các khóa chung. Từ điển cuối cùng sẽ là người có giá trị sẽ tồn tại trong từ điển mới là kết quả của việc hợp nhất hai người, vì vậy tôi giải quyết vấn đề được giải quyết. Giải pháp có giá trị từ Python 3.5 và các phiên bản sau.
a = {'a': 'foo', 'b':'bar', 'c': 'baz'}
b = {'a': 'spam', 'c':'ham', 'x': 'blah'}
r = dict[a.items[] + b.items[] +
[[k, a[k] + b[k]] for k in set[b] & set[a]]]
3Mã tái sử dụng
a = {'a': 'foo', 'b':'bar', 'c': 'baz'}
b = {'a': 'spam', 'c':'ham', 'x': 'blah'}
r = dict[a.items[] + b.items[] +
[[k, a[k] + b[k]] for k in set[b] & set[a]]]
4Đã trả lời ngày 28 tháng 8 năm 2016 lúc 9:47Aug 28, 2016 at 9:47
PythonProgrammipyThonProgrammiPythonProgrammi
21.2k3 Huy hiệu vàng39 Huy hiệu bạc34 Huy hiệu đồng3 gold badges39 silver badges34 bronze badges
1
Một giải pháp dòng là sử dụng khả năng hiểu từ điển.
a = {'a': 'foo', 'b':'bar', 'c': 'baz'}
b = {'a': 'spam', 'c':'ham', 'x': 'blah'}
r = dict[a.items[] + b.items[] +
[[k, a[k] + b[k]] for k in set[b] & set[a]]]
5Đã trả lời ngày 12 tháng 9 năm 2021 lúc 2:46Sep 12, 2021 at 2:46
Phao Rinabuoy RinaBuoy Rina
3881 Huy hiệu vàng1 Huy hiệu bạc6 Huy hiệu đồng1 gold badge1 silver badge6 bronze badges
a = {'a': 'foo', 'b':'bar', 'c': 'baz'}
b = {'a': 'spam', 'c':'ham', 'x': 'blah'}
r = dict[a.items[] + b.items[] +
[[k, a[k] + b[k]] for k in set[b] & set[a]]]
6Bạn có thể dễ dàng khái quát điều này:
a = {'a': 'foo', 'b':'bar', 'c': 'baz'}
b = {'a': 'spam', 'c':'ham', 'x': 'blah'}
r = dict[a.items[] + b.items[] +
[[k, a[k] + b[k]] for k in set[b] & set[a]]]
7Sau đó, nó có thể lấy bất kỳ số lượng chính thức.
Đã trả lời ngày 10 tháng 6 năm 2016 lúc 13:11Jun 10, 2016 at 13:11
Jonas Kölkerjonas KölkerJonas Kölker
7.6002 Huy hiệu vàng43 Huy hiệu bạc51 Huy hiệu Đồng2 gold badges43 silver badges51 bronze badges
Đây là một giải pháp đơn giản để hợp nhất hai từ điển trong đó
class MyDict[dict]:
def __add__[self, oth]:
r = self.copy[]
try:
for key, val in oth.items[]:
if key in r:
r[key] += val # You can custom it here
else:
r[key] = val
except AttributeError: # In case oth isn't a dict
return NotImplemented # The convention when a case isn't handled
return r
a = MyDict[{'a':1, 'b':2, 'c':3}]
b = MyDict[{'b':3, 'c':4, 'd':5}]
print[a+b] # Output {'a':1, 'b': 5, 'c': 7, 'd': 5}
4 có thể được áp dụng cho các giá trị, nó chỉ được lặp lại trong một từ điển chỉ một lầna = {'a': 'foo', 'b':'bar', 'c': 'baz'}
b = {'a': 'spam', 'c':'ham', 'x': 'blah'}
r = dict[a.items[] + b.items[] +
[[k, a[k] + b[k]] for k in set[b] & set[a]]]
8Đã trả lời ngày 28 tháng 6 năm 2017 lúc 21:31Jun 28, 2017 at 21:31
Ragardnerragardnerragardner
1.7043 huy hiệu vàng20 Huy hiệu bạc44 Huy hiệu đồng3 gold badges20 silver badges44 bronze badges
Giải pháp này rất dễ sử dụng, nó được sử dụng làm từ điển bình thường, nhưng bạn có thể sử dụng hàm tổng.
a = {'a': 'foo', 'b':'bar', 'c': 'baz'}
b = {'a': 'spam', 'c':'ham', 'x': 'blah'}
r = dict[a.items[] + b.items[] +
[[k, a[k] + b[k]] for k in set[b] & set[a]]]
9Đã trả lời ngày 9 tháng 12 năm 2016 lúc 14:26Dec 9, 2016 at 14:26
Các giải pháp trên là tuyệt vời cho kịch bản mà bạn có một số lượng nhỏ
>>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
6s. Nếu bạn có một danh sách lớn về chúng, thì một cái gì đó như thế này đẹp hơn nhiều:def combine_dicts[a, b, op=operator.add]:
return dict[a.items[] + b.items[] +
[[k, op[a[k], b[k]]] for k in set[b] & set[a]]]
0Giải pháp trên về cơ bản là tổng hợp các
>>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
6 bằng cách:def combine_dicts[a, b, op=operator.add]:
return dict[a.items[] + b.items[] +
[[k, op[a[k], b[k]]] for k in set[b] & set[a]]]
1Điều này làm điều tương tự nhưng tôi nghĩ rằng nó luôn luôn giúp xem những gì nó đang làm một cách hiệu quả bên dưới.
Đã trả lời ngày 1 tháng 8 năm 2017 lúc 4:58Aug 1, 2017 at 4:58
Hội trường Michael HallmichaelMichael Hall
2.4411 Huy hiệu vàng20 Huy hiệu bạc35 Huy hiệu đồng1 gold badge20 silver badges35 bronze badges
Thế còn:
def combine_dicts[a, b, op=operator.add]:
return dict[a.items[] + b.items[] +
[[k, op[a[k], b[k]]] for k in set[b] & set[a]]]
2Output:
def combine_dicts[a, b, op=operator.add]:
return dict[a.items[] + b.items[] +
[[k, op[a[k], b[k]]] for k in set[b] & set[a]]]
3Đã trả lời ngày 12 tháng 6 năm 2018 lúc 17:45Jun 12, 2018 at 17:45
LacobuslacobusLacobus
1.52011 Huy hiệu bạc19 Huy hiệu đồng11 silver badges19 bronze badges
Đây là một tùy chọn khác bằng cách sử dụng các hệ thống từ điển kết hợp với hành vi của
class MyDict[dict]:
def __add__[self, oth]:
r = self.copy[]
try:
for key, val in oth.items[]:
if key in r:
r[key] += val # You can custom it here
else:
r[key] = val
except AttributeError: # In case oth isn't a dict
return NotImplemented # The convention when a case isn't handled
return r
a = MyDict[{'a':1, 'b':2, 'c':3}]
b = MyDict[{'b':3, 'c':4, 'd':5}]
print[a+b] # Output {'a':1, 'b': 5, 'c': 7, 'd': 5}
7:def combine_dicts[a, b, op=operator.add]:
return dict[a.items[] + b.items[] +
[[k, op[a[k], b[k]]] for k in set[b] & set[a]]]
4Từ //docs.python.org/3/l Library/stdtypes.html#dict:
//docs.python.org/3/library/stdtypes.html#dict
Và cũng vậy
Nếu các đối số từ khóa được đưa ra, các đối số từ khóa và giá trị của chúng được thêm vào từ điển được tạo từ đối số vị trí.
Sự hiểu biết chính thống
def combine_dicts[a, b, op=operator.add]:
return dict[a.items[] + b.items[] +
[[k, op[a[k], b[k]]] for k in set[b] & set[a]]]
5tay cầm thêm Dict1 [1] vào
class MyDict[dict]:
def __add__[self, oth]:
r = self.copy[]
try:
for key, val in oth.items[]:
if key in r:
r[key] += val # You can custom it here
else:
r[key] = val
except AttributeError: # In case oth isn't a dict
return NotImplemented # The convention when a case isn't handled
return r
a = MyDict[{'a':1, 'b':2, 'c':3}]
b = MyDict[{'b':3, 'c':4, 'd':5}]
print[a+b] # Output {'a':1, 'b': 5, 'c': 7, 'd': 5}
8. Chúng tôi không cần một class MyDict[dict]:
def __add__[self, oth]:
r = self.copy[]
try:
for key, val in oth.items[]:
if key in r:
r[key] += val # You can custom it here
else:
r[key] = val
except AttributeError: # In case oth isn't a dict
return NotImplemented # The convention when a case isn't handled
return r
a = MyDict[{'a':1, 'b':2, 'c':3}]
b = MyDict[{'b':3, 'c':4, 'd':5}]
print[a+b] # Output {'a':1, 'b': 5, 'c': 7, 'd': 5}
9 rõ ràng ở đây vì giá trị mặc định cho In [1]: from collections import Counter
In [2]: A = Counter[{'a':1, 'b':2, 'c':3}]
In [3]: B = Counter[{'b':3, 'c':-4, 'd':5}]
In [4]: A + B
Out[4]: Counter[{'d': 5, 'b': 5, 'a': 1}]
0 của chúng tôi có thể được đặt thành 0 thay thế.Đã trả lời ngày 19 tháng 3 lúc 21:40Mar 19 at 21:40
erik258erik258erik258
12.8k2 Huy hiệu vàng26 Huy hiệu bạc28 Huy hiệu đồng2 gold badges26 silver badges28 bronze badges
Cách thông thường hơn để kết hợp hai dict. Sử dụng các mô -đun và công cụ là tốt nhưng hiểu logic đằng sau nó sẽ giúp trong trường hợp bạn không nhớ các công cụ.
Chương trình kết hợp hai giá trị thêm từ điển cho các khóa chung.
def combine_dicts[a, b, op=operator.add]:
return dict[a.items[] + b.items[] +
[[k, op[a[k], b[k]]] for k in set[b] & set[a]]]
6
m4n0
28.1K26 Huy hiệu vàng73 Huy hiệu bạc87 Huy hiệu đồng26 gold badges73 silver badges87 bronze badges
Đã trả lời ngày 12 tháng 9 năm 2021 lúc 1:39Sep 12, 2021 at 1:39
A.RanjanA.RanjanA.Ranjan
892 Huy hiệu bạc12 Huy hiệu Đồng2 silver badges12 bronze badges
Đây là một giải pháp rất chung chung. Bạn có thể đối phó với bất kỳ số lượng các khóa Dict + chỉ trong một số Dict + dễ dàng sử dụng bất kỳ chức năng tổng hợp nào bạn muốn:
def combine_dicts[a, b, op=operator.add]:
return dict[a.items[] + b.items[] +
[[k, op[a[k], b[k]]] for k in set[b] & set[a]]]
7example:
def combine_dicts[a, b, op=operator.add]:
return dict[a.items[] + b.items[] +
[[k, op[a[k], b[k]]] for k in set[b] & set[a]]]
8ví dụ các khóa không giống hệt nhau và tập hợp chung:
def combine_dicts[a, b, op=operator.add]:
return dict[a.items[] + b.items[] +
[[k, op[a[k], b[k]]] for k in set[b] & set[a]]]
9Đã trả lời ngày 23 tháng 10 năm 2021 lúc 7:50Oct 23, 2021 at 7:50
Yann Duboisyann DuboisYann Dubois
1.10513 huy hiệu bạc15 huy hiệu đồng13 silver badges15 bronze badges
>>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
0Đã trả lời ngày 19 tháng 3 lúc 21:44Mar 19 at 21:44
1
Hợp nhất ba dicts a, b, c trong một dòng mà không có bất kỳ mô -đun hoặc libs nào khác
Nếu chúng ta có ba dicts
>>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
1Hợp nhất tất cả với một dòng và trả về một đối tượng Dict bằng cách sử dụng
>>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
2Trở lại
>>> a = {'a': 2, 'b':3, 'c':4}
>>> b = {'a': 5, 'c':6, 'x':7}
>>> import operator
>>> print combine_dicts[a, b, operator.mul]
{'a': 10, 'x': 7, 'c': 24, 'b': 3}
3Đã trả lời ngày 17 tháng 11 năm 2017 lúc 9:18Nov 17, 2017 at 9:18
1