Hướng dẫn python merge two dictionaries add values - python hợp nhất hai từ điển thêm giá trị

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}

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

Đã 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

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

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

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}

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

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

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}

• 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

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

  3 chỉ yêu cầu các giá trị có thể đặt hàng.
• Đối với các hoạt động tại chỗ 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}
  

  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.
• 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

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

  8 yêu cầu số nguyên. Nó bỏ qua số không và âm tính.

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}

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}

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)])

HOẶ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}

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)])

Đã 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}

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}

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)])

Đã 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)])

Mã 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)])

Đã 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)])

Đã 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)])

Bạ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)])

Sau đó, 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}

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)])

Đã 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)])

Đã 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}

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)])

Giả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}

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)])

Đ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)])

Output:

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)])

Đã 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}

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)])

Từ https://docs.python.org/3/l Library/stdtypes.html#dict:

https://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)])

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

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}

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

Đã 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)])

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)])

example:

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ụ 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)])

Đã 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}

Đã 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}

Hợ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}

Trở 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}

Đã trả lời ngày 17 tháng 11 năm 2017 lúc 9:18Nov 17, 2017 at 9:18

1

Làm thế nào để bạn thêm một giá trị từ hai từ điển trong Python?

Làm thế nào để bạn thêm một giá trị vào một từ điển trong Python?

Bạn có thể nối các giá trị vào từ điển không?