Làm thế nào để hợp nhất nhiều quân số với cùng một khóa?

Tôi có nhiều cặp số / cặp khóa-giá trị như thế này:

d1 = {key1: x1, key2: y1}  
d2 = {key1: x2, key2: y2}  

Tôi muốn kết quả là một chính tả mới (theo cách hiệu quả nhất, nếu có thể):

d = {key1: (x1, x2), key2: (y1, y2)}  

Trên thực tế, tôi muốn kết quả d là:

d = {key1: (x1.x1attrib, x2.x2attrib), key2: (y1.y1attrib, y2.y2attrib)}  

Nếu ai đó chỉ cho tôi cách lấy kết quả đầu tiên, tôi có thể tìm ra phần còn lại.

giả sử tất cả các khóa luôn hiện diện trong tất cả các quân số:

ds = [d1, d2]
d = {}
for k in d1.iterkeys():
    d[k] = tuple(d[k] for d in ds)

Lưu ý: Trong Python 3.x, hãy sử dụng mã dưới đây:

ds = [d1, d2]
d = {}
for k in d1.keys():
  d[k] = tuple(d[k] for d in ds)

và nếu dic chứa các mảng numpy:

ds = [d1, d2]
d = {}
for k in d1.keys():
  d[k] = np.concatenate(list(d[k] for d in ds))

Đây là một giải pháp chung sẽ xử lý một lượng từ điển tùy ý, với các trường hợp khi các khóa chỉ nằm trong một số từ điển:

from collections import defaultdict

d1 = {1: 2, 3: 4}
d2 = {1: 6, 3: 7}

dd = defaultdict(list)

for d in (d1, d2): # you can list as many input dicts as you want here
    for key, value in d.items():
        dd[key].append(value)

print(dd)

Trình diễn:

defaultdict(<type 'list'>, {1: [2, 6], 3: [4, 7]})

Ngoài ra, để có được của bạn .attrib, chỉ cần thay đổi append(value)thànhappend(value.attrib)

Nếu bạn chỉ có d1 và d2,

from collections import defaultdict

d = defaultdict(list)
for a, b in d1.items() + d2.items():
    d[a].append(b)

dict1 = {'m': 2, 'n': 4}
dict2 = {'n': 3, 'm': 1}

Đảm bảo rằng các khóa theo cùng một thứ tự:

dict2_sorted = {i:dict2[i] for i in dict1.keys()}

keys = dict1.keys()
values = zip(dict1.values(), dict2_sorted.values())
dictionary = dict(zip(keys, values))

cho:

{'m': (2, 1), 'n': (4, 3)}

Đây là một cách tiếp cận bạn có thể sử dụng sẽ hoạt động ngay cả khi cả hai nhà độc tài không có cùng khóa:

d1 = {'a':'test','b':'btest','d':'dreg'}
d2 = {'a':'cool','b':'main','c':'clear'}

d = {}

for key in set(d1.keys() + d2.keys()):
    try:
        d.setdefault(key,[]).append(d1[key])        
    except KeyError:
        pass

    try:
        d.setdefault(key,[]).append(d2[key])          
    except KeyError:
        pass

print d

Điều này sẽ tạo ra đầu vào bên dưới:

{'a': ['test', 'cool'], 'c': ['clear'], 'b': ['btest', 'main'], 'd': ['dreg']}

Cập nhật Python 3.x

Từ câu trả lời của Eli Bendersky:

Python 3 đã loại bỏ dict.iteritems sử dụng dict.items thay thế. Xem Python wiki: https://wiki.python.org/moin/Python3.0

from collections import defaultdict

dd = defaultdict(list)

for d in (d1, d2):
    for key, value in d.items():
        dd[key].append(value)

Phương pháp này kết hợp hai phái ngay cả khi các khóa trong hai từ điển khác nhau:

def combine_dict(d1, d2):
    combined = {}
    for k in set(d1.keys()) | set(d2.keys()):
        combined[k] = tuple(d[k] for d in [d1, d2] if k in d)
    return combined

Thí dụ:

d1 = {
    'a': 1,
    'b': 2,
}
d2` = {
    'b': 'boat',
    'c': 'car',
}
combine_dict(d1, d2)
# Returns: {
#    'a': (1,),
#    'b': (2, 'boat'),
#    'c': ('car',)
# }

Giả sử rằng bạn có danh sách TẤT CẢ các khóa (bạn có thể lấy danh sách này bằng cách duyệt qua tất cả các từ điển và lấy các khóa của chúng). Hãy đặt tên cho nó listKeys. Cũng thế:

• listValues là danh sách TẤT CẢ các giá trị cho một khóa duy nhất mà bạn muốn hợp nhất.
• allDicts: tất cả các từ điển mà bạn muốn hợp nhất.

result = {}
for k in listKeys:
    listValues = [] #we will convert it to tuple later, if you want.
    for d in allDicts:
       try:
            fileList.append(d[k]) #try to append more values to a single key
        except:
            pass
    if listValues: #if it is not empty
        result[k] = typle(listValues) #convert to tuple, add to new dictionary with key k

def merge(d1, d2, merge):
    result = dict(d1)
    for k,v in d2.iteritems():
        if k in result:
            result[k] = merge(result[k], v)
        else:
            result[k] = v
    return result

d1 = {'a': 1, 'b': 2}
d2 = {'a': 1, 'b': 3, 'c': 2}
print merge(d1, d2, lambda x, y:(x,y))

{'a': (1, 1), 'c': 2, 'b': (2, 3)}

Để bổ sung các giải pháp hai danh sách, đây là một giải pháp để xử lý một danh sách duy nhất .

Danh sách mẫu (liên quan đến NetworkX; được định dạng thủ công tại đây để dễ đọc):

ec_num_list = [((src, tgt), ec_num['ec_num']) for src, tgt, ec_num in G.edges(data=True)]

print('\nec_num_list:\n{}'.format(ec_num_list))
ec_num_list:
[((82, 433), '1.1.1.1'),
  ((82, 433), '1.1.1.2'),
  ((22, 182), '1.1.1.27'),
  ((22, 3785), '1.2.4.1'),
  ((22, 36), '6.4.1.1'),
  ((145, 36), '1.1.1.37'),
  ((36, 154), '2.3.3.1'),
  ((36, 154), '2.3.3.8'),
  ((36, 72), '4.1.1.32'),
  ...] 

Lưu ý các giá trị trùng lặp cho các cạnh giống nhau (được xác định bởi các bộ giá trị). Để đối chiếu những "giá trị" đó với "khóa" tương ứng của chúng:

from collections import defaultdict
ec_num_collection = defaultdict(list)
for k, v in ec_num_list:
    ec_num_collection[k].append(v)

print('\nec_num_collection:\n{}'.format(ec_num_collection.items()))
ec_num_collection:
[((82, 433), ['1.1.1.1', '1.1.1.2']),   ## << grouped "values"
((22, 182), ['1.1.1.27']),
((22, 3785), ['1.2.4.1']),
((22, 36), ['6.4.1.1']),
((145, 36), ['1.1.1.37']),
((36, 154), ['2.3.3.1', '2.3.3.8']),    ## << grouped "values"
((36, 72), ['4.1.1.32']),
...] 

Nếu cần, hãy chuyển đổi danh sách đó thành dict:

ec_num_collection_dict = {k:v for k, v in zip(ec_num_collection, ec_num_collection)}

print('\nec_num_collection_dict:\n{}'.format(dict(ec_num_collection)))
  ec_num_collection_dict:
  {(82, 433): ['1.1.1.1', '1.1.1.2'],
  (22, 182): ['1.1.1.27'],
  (22, 3785): ['1.2.4.1'],
  (22, 36): ['6.4.1.1'],
  (145, 36): ['1.1.1.37'],
  (36, 154): ['2.3.3.1', '2.3.3.8'],
  (36, 72): ['4.1.1.32'],
  ...}

Người giới thiệu

• [chủ đề này] Làm thế nào để hợp nhất nhiều quân số với cùng một khóa?
• [Tài liệu Python] https://docs.python.org/3.7/library/collections.html#collections.defaultdict

Từ câu trả lời blubb:

Bạn cũng có thể trực tiếp tạo bộ tuple bằng cách sử dụng các giá trị từ mỗi danh sách

ds = [d1, d2]
d = {}
for k in d1.keys():
  d[k] = (d1[k], d2[k])

Điều này có thể hữu ích nếu bạn có một đơn đặt hàng cụ thể cho bộ giá trị của mình

ds = [d1, d2, d3, d4]
d = {}
for k in d1.keys():
  d[k] = (d3[k], d1[k], d4[k], d2[k]) #if you wanted tuple in order of d3, d1, d4, d2

Thư viện này đã giúp tôi, tôi có một danh sách chính tả các khóa lồng nhau có cùng tên nhưng có giá trị khác nhau, mọi giải pháp khác vẫn ghi đè các khóa lồng nhau đó.

https://pypi.org/project/deepmerge/

from deepmerge import always_merger

def process_parms(args):
    temp_list = []
    for x in args:
        with open(x, 'r') as stream:
            temp_list.append(yaml.safe_load(stream))

    return always_merger.merge(*temp_list)

Nếu các khóa được lồng vào nhau:

d1 = { 'key1': { 'nkey1': 'x1' }, 'key2': { 'nkey2': 'y1' } } 
d2 = { 'key1': { 'nkey1': 'x2' }, 'key2': { 'nkey2': 'y2' } }

ds = [d1, d2]
d = {}
for k in d1.keys():
    for k2 in d1[k].keys():
        d.setdefault(k, {})
        d[k].setdefault(k2, [])
        d[k][k2] = tuple(d[k][k2] for d in ds)

sản lượng:

{'key1': {'nkey1': ('x1', 'x2')}, 'key2': {'nkey2': ('y1', 'y2')}}

Một khả năng nhỏ gọn

d1={'a':1,'b':2}
d2={'c':3,'d':4}
context={**d1, **d2}
context
{'b': 2, 'c': 3, 'd': 4, 'a': 1}