Hướng dẫn merge multiple dictionaries in a list python - hợp nhất nhiều từ điển trong một python danh sách

Nếu bạn cho rằng các khóa mà bạn quan tâm ở cùng mức lồng nhau, bạn có thể đệ quy qua từng từ điển và tạo một từ điển mới sử dụng khóa đó, hợp nhất một cách hiệu quả.

merged = {}
for d in dicts:
    def walk(d,merge):
        for key, item in d.items():
            if isinstance(item, dict):
                merge.setdefault(key, {})
                walk(item, merge[key])
            else:
                merge.setdefault(key, [])
                merge[key].append(item)
    walk(d,merged)

Ví dụ: giả sử bạn có các từ điển sau bạn muốn hợp nhất.

dicts = [{'A': {'A1': {'FOO': [1,2,3]}}},
         {'A': {'A1': {'A2': {'BOO': [4,5,6]}}}},
         {'A': {'A1': {'FOO': [7,8]}}},
         {'B': {'B1': {'COO': [9]}}},
         {'B': {'B2': {'DOO': [10,11,12]}}},
         {'C': {'C1': {'C2': {'POO':[13,14,15]}}}},
         {'C': {'C1': {'ROO': [16,17]}}}]

Sử dụng khóa ở mỗi cấp độ, bạn sẽ nhận được một cái gì đó như thế này:

{'A': {'A1': {'FOO': [[1, 2, 3], [7, 8]], 
              'A2': {'BOO': [[4, 5, 6]]}}},
 'B': {'B1': {'COO': [[9]]}, 
       'B2': {'DOO': [[10, 11, 12]]}},
 'C': {'C1': {'C2': {'POO': [[13, 14, 15]]}, 
              'ROO': [[16, 17]]}}}

Lưu ý: Tôi giả sử lá ở mỗi nhánh là một danh sách một số loại, nhưng rõ ràng bạn có thể thay đổi logic để làm bất cứ điều gì cần thiết cho tình huống của bạn.

Python: Làm thế nào để hợp nhất nhiều từ điển?

Vấn đề: Giả sử, bạn đã có một danh sách các từ điển:: Say, you’ve got a list of dictionaries:

[{'a': 0}, {'b': 1}, {'c': 2}, {'d': 3}, {'e': 4, 'a': 4}]

Lưu ý cách từ điển đầu tiên và cuối cùng mang cùng một khóa

dicts = [{'A': {'A1': {'FOO': [1,2,3]}}},
         {'A': {'A1': {'A2': {'BOO': [4,5,6]}}}},
         {'A': {'A1': {'FOO': [7,8]}}},
         {'B': {'B1': {'COO': [9]}}},
         {'B': {'B2': {'DOO': [10,11,12]}}},
         {'C': {'C1': {'C2': {'POO':[13,14,15]}}}},
         {'C': {'C1': {'ROO': [16,17]}}}]
0.

Làm thế nào để bạn hợp nhất tất cả các từ điển đó thành một từ điển để có được từ sau?

{'a': 4, 'b': 1, 'c': 2, 'd': 3, 'e': 4}

Lưu ý làm thế nào giá trị của khóa trùng lặp

dicts = [{'A': {'A1': {'FOO': [1,2,3]}}},
         {'A': {'A1': {'A2': {'BOO': [4,5,6]}}}},
         {'A': {'A1': {'FOO': [7,8]}}},
         {'B': {'B1': {'COO': [9]}}},
         {'B': {'B2': {'DOO': [10,11,12]}}},
         {'C': {'C1': {'C2': {'POO':[13,14,15]}}}},
         {'C': {'C1': {'ROO': [16,17]}}}]
0 là giá trị của phần cuối và không phải là dict đầu tiên trong danh sách các dicts.

Để hợp nhất nhiều từ điển, cách pythonic nhất là sử dụng khả năng hiểu từ điển

dicts = [{'A': {'A1': {'FOO': [1,2,3]}}},
         {'A': {'A1': {'A2': {'BOO': [4,5,6]}}}},
         {'A': {'A1': {'FOO': [7,8]}}},
         {'B': {'B1': {'COO': [9]}}},
         {'B': {'B2': {'DOO': [10,11,12]}}},
         {'C': {'C1': {'C2': {'POO':[13,14,15]}}}},
         {'C': {'C1': {'ROO': [16,17]}}}]
2 để lặp lại lần đầu tiên trên tất cả các từ điển trong danh sách
dicts = [{'A': {'A1': {'FOO': [1,2,3]}}},
         {'A': {'A1': {'A2': {'BOO': [4,5,6]}}}},
         {'A': {'A1': {'FOO': [7,8]}}},
         {'B': {'B1': {'COO': [9]}}},
         {'B': {'B2': {'DOO': [10,11,12]}}},
         {'C': {'C1': {'C2': {'POO':[13,14,15]}}}},
         {'C': {'C1': {'ROO': [16,17]}}}]
3 và sau đó lặp lại tất cả (khóa, giá trị) trong mỗi từ điển.

Hãy cùng khám phá tất cả các tùy chọn có sẵn trong bài viết còn lại:

Bài tập: Chạy mã Phương pháp mà phương thức nào tạo ra một đầu ra khác với tất cả các phương pháp khác?: Run the code—which method generates a different output than all the other methods?

Phương pháp 1: Hiểu từ điển với bối cảnh lồng nhau

Bạn có thể sử dụng khả năng hiểu từ điển

dicts = [{'A': {'A1': {'FOO': [1,2,3]}}},
         {'A': {'A1': {'A2': {'BOO': [4,5,6]}}}},
         {'A': {'A1': {'FOO': [7,8]}}},
         {'B': {'B1': {'COO': [9]}}},
         {'B': {'B2': {'DOO': [10,11,12]}}},
         {'C': {'C1': {'C2': {'POO':[13,14,15]}}}},
         {'C': {'C1': {'ROO': [16,17]}}}]
2 để lặp lại trước tất cả các từ điển trong danh sách
dicts = [{'A': {'A1': {'FOO': [1,2,3]}}},
         {'A': {'A1': {'A2': {'BOO': [4,5,6]}}}},
         {'A': {'A1': {'FOO': [7,8]}}},
         {'B': {'B1': {'COO': [9]}}},
         {'B': {'B2': {'DOO': [10,11,12]}}},
         {'C': {'C1': {'C2': {'POO':[13,14,15]}}}},
         {'C': {'C1': {'ROO': [16,17]}}}]
3 và sau đó lặp lại tất cả (khóa, giá trị) trong mỗi từ điển.

  • Tạo một từ điển mới bằng cách sử dụng ký hiệu
    dicts = [{'A': {'A1': {'FOO': [1,2,3]}}},
             {'A': {'A1': {'A2': {'BOO': [4,5,6]}}}},
             {'A': {'A1': {'FOO': [7,8]}}},
             {'B': {'B1': {'COO': [9]}}},
             {'B': {'B2': {'DOO': [10,11,12]}}},
             {'C': {'C1': {'C2': {'POO':[13,14,15]}}}},
             {'C': {'C1': {'ROO': [16,17]}}}]
    
    6.
  • Đi qua tất cả các từ điển trong danh sách từ điển
    dicts = [{'A': {'A1': {'FOO': [1,2,3]}}},
             {'A': {'A1': {'A2': {'BOO': [4,5,6]}}}},
             {'A': {'A1': {'FOO': [7,8]}}},
             {'B': {'B1': {'COO': [9]}}},
             {'B': {'B2': {'DOO': [10,11,12]}}},
             {'C': {'C1': {'C2': {'POO':[13,14,15]}}}},
             {'C': {'C1': {'ROO': [16,17]}}}]
    
    3 bằng cách sử dụng vòng lặp bên ngoài
    dicts = [{'A': {'A1': {'FOO': [1,2,3]}}},
             {'A': {'A1': {'A2': {'BOO': [4,5,6]}}}},
             {'A': {'A1': {'FOO': [7,8]}}},
             {'B': {'B1': {'COO': [9]}}},
             {'B': {'B2': {'DOO': [10,11,12]}}},
             {'C': {'C1': {'C2': {'POO':[13,14,15]}}}},
             {'C': {'C1': {'ROO': [16,17]}}}]
    
    8.
  • Đi qua tất cả (khóa, giá trị) các cặp trong từ điển hiện tại
    dicts = [{'A': {'A1': {'FOO': [1,2,3]}}},
             {'A': {'A1': {'A2': {'BOO': [4,5,6]}}}},
             {'A': {'A1': {'FOO': [7,8]}}},
             {'B': {'B1': {'COO': [9]}}},
             {'B': {'B2': {'DOO': [10,11,12]}}},
             {'C': {'C1': {'C2': {'POO':[13,14,15]}}}},
             {'C': {'C1': {'ROO': [16,17]}}}]
    
    9 bằng cách sử dụng phương thức
    {'A': {'A1': {'FOO': [[1, 2, 3], [7, 8]], 
                  'A2': {'BOO': [[4, 5, 6]]}}},
     'B': {'B1': {'COO': [[9]]}, 
           'B2': {'DOO': [[10, 11, 12]]}},
     'C': {'C1': {'C2': {'POO': [[13, 14, 15]]}, 
                  'ROO': [[16, 17]]}}}
    
    0 trả về một cặp (khóa, giá trị).
  • Điền vào từ điển mới bằng (khóa, giá trị) các cặp
    {'A': {'A1': {'FOO': [[1, 2, 3], [7, 8]], 
                  'A2': {'BOO': [[4, 5, 6]]}}},
     'B': {'B1': {'COO': [[9]]}, 
           'B2': {'DOO': [[10, 11, 12]]}},
     'C': {'C1': {'C2': {'POO': [[13, 14, 15]]}, 
                  'ROO': [[16, 17]]}}}
    
    1 bằng cách sử dụng cú pháp hiểu từ điển chung
    {'A': {'A1': {'FOO': [[1, 2, 3], [7, 8]], 
                  'A2': {'BOO': [[4, 5, 6]]}}},
     'B': {'B1': {'COO': [[9]]}, 
           'B2': {'DOO': [[10, 11, 12]]}},
     'C': {'C1': {'C2': {'POO': [[13, 14, 15]]}, 
                  'ROO': [[16, 17]]}}}
    
    2.
l = [{'a': 0}, {'b': 1}, {'c': 2}, {'d': 3}, {'e': 4, 'a': 4}]

d = {k:v for x in l for k,v in x.items()}
print(d)
# {'a': 4, 'b': 1, 'c': 2, 'd': 3, 'e': 4}

Đây là cách pythonic nhất để hợp nhất nhiều từ điển thành một từ và nó hoạt động cho một số lượng từ điển tùy ý.

Phương pháp 2: Vòng lặp lồng nhau đơn giản

Sử dụng một vòng lặp lồng nhau đơn giản để thêm từng cặp (khóa, giá trị) riêng biệt vào một từ điển mới được tạo:

  • Tạo một từ điển mới, trống rỗng.
  • Đi qua từng từ điển trong danh sách từ điển.
  • Đi qua từng cặp (khóa, giá trị) trong từ điển hiện tại.
  • Thêm cặp (giá trị, giá trị) vào từ điển mới, có thể ghi đè lên các phím cũ hơn với các khóa hiện tại.
l = [{'a': 0}, {'b': 1}, {'c': 2}, {'d': 3}, {'e': 4, 'a': 4}]

d = {}
for dictionary in l:
    for k, v in dictionary.items():
        d[k] = v

print(d)
{'a': 4, 'b': 1, 'c': 2, 'd': 3, 'e': 4}

Bạn có thể trực quan hóa luồng thực thi của mã này ở đây:

Đây là cách dễ đọc nhất đối với nhiều lập trình viên mới bắt đầu, nhưng nó ít ngắn gọn hơn và ít pythonic hơn.

Phương pháp 3: Sử dụng phương thức Update ()

Phương thức

{'A': {'A1': {'FOO': [[1, 2, 3], [7, 8]], 
              'A2': {'BOO': [[4, 5, 6]]}}},
 'B': {'B1': {'COO': [[9]]}, 
       'B2': {'DOO': [[10, 11, 12]]}},
 'C': {'C1': {'C2': {'POO': [[13, 14, 15]]}, 
              'ROO': [[16, 17]]}}}
3 cập nhật từ điển mà nó được gọi với một loạt các cặp mới (khóa, giá trị) được đưa ra trong đối số từ điển
dicts = [{'A': {'A1': {'FOO': [1,2,3]}}},
         {'A': {'A1': {'A2': {'BOO': [4,5,6]}}}},
         {'A': {'A1': {'FOO': [7,8]}}},
         {'B': {'B1': {'COO': [9]}}},
         {'B': {'B2': {'DOO': [10,11,12]}}},
         {'C': {'C1': {'C2': {'POO':[13,14,15]}}}},
         {'C': {'C1': {'ROO': [16,17]}}}]
9. Phương pháp hợp nhất nhiều từ điển rất đơn giản:

  • Tạo một từ điển mới, trống rỗng.
  • Đi qua từng từ điển trong danh sách từ điển.
  • Cập nhật từ điển mới với các giá trị trong từ điển hiện tại.
l = [{'a': 0}, {'b': 1}, {'c': 2}, {'d': 3}, {'e': 4, 'a': 4}]

d = {}
for dictionary in l:
    d.update(dictionary)

print(d)
# {'a': 4, 'b': 1, 'c': 2, 'd': 3, 'e': 4}

Đây là một cách rất dễ đọc và hiệu quả và nó ngắn hơn Phương pháp 2.

Phương pháp 4: Giải nén từ điển

Khi được áp dụng cho một từ điển

{'A': {'A1': {'FOO': [[1, 2, 3], [7, 8]], 
              'A2': {'BOO': [[4, 5, 6]]}}},
 'B': {'B1': {'COO': [[9]]}, 
       'B2': {'DOO': [[10, 11, 12]]}},
 'C': {'C1': {'C2': {'POO': [[13, 14, 15]]}, 
              'ROO': [[16, 17]]}}}
5, toán tử Asterisk kép
{'A': {'A1': {'FOO': [[1, 2, 3], [7, 8]], 
              'A2': {'BOO': [[4, 5, 6]]}}},
 'B': {'B1': {'COO': [[9]]}, 
       'B2': {'DOO': [[10, 11, 12]]}},
 'C': {'C1': {'C2': {'POO': [[13, 14, 15]]}, 
              'ROO': [[16, 17]]}}}
6 Giải nén tất cả các phần tử trong
{'A': {'A1': {'FOO': [[1, 2, 3], [7, 8]], 
              'A2': {'BOO': [[4, 5, 6]]}}},
 'B': {'B1': {'COO': [[9]]}, 
       'B2': {'DOO': [[10, 11, 12]]}},
 'C': {'C1': {'C2': {'POO': [[13, 14, 15]]}, 
              'ROO': [[16, 17]]}}}
5 vào từ điển bên ngoài. Bạn chỉ có thể sử dụng phương pháp từ điển từ điển này trong một môi trường (trong trường hợp của chúng tôi, một từ điển) có khả năng xử lý các cặp (khóa, giá trị).

Lưu ý bên cạnh: Đôi khi, nó cũng được sử dụng cho các đối số từ khóa.

l = [{'a': 0}, {'b': 1}, {'c': 2}, {'d': 3}, {'e': 4, 'a': 4}]

d = {**l[0], **l[1], **l[2], **l[3], **l[4]}
print(d)
# {'a': 4, 'b': 1, 'c': 2, 'd': 3, 'e': 4}

Đây là một cách ngắn gọn, hiệu quả và pythonic để hợp nhất nhiều từ điển.

Tuy nhiên, nó không tối ưu vì bạn phải gõ thủ công từng thao tác giải nén. Nếu từ điển có 100 yếu tố, thì điều này sẽ không khả thi.

LƯU Ý: Bạn không thể sử dụng từ điển Giải nén trong Từ điển Hiểu để giảm bớt vấn đề này.: you cannot use dictionary unpacking in dictionary comprehension to alleviate this problem—Python will throw a SyntaxError!

Hướng dẫn merge multiple dictionaries in a list python - hợp nhất nhiều từ điển trong một python danh sách

Phương pháp 5: Sử dụng Chainmap với việc giải nén

Nếu bạn không hài lòng với một trong hai phương pháp đó, bạn cũng có thể sử dụng cấu trúc dữ liệu

{'A': {'A1': {'FOO': [[1, 2, 3], [7, 8]], 
              'A2': {'BOO': [[4, 5, 6]]}}},
 'B': {'B1': {'COO': [[9]]}, 
       'B2': {'DOO': [[10, 11, 12]]}},
 'C': {'C1': {'C2': {'POO': [[13, 14, 15]]}, 
              'ROO': [[16, 17]]}}}
8 từ thư viện bộ sưu tập.

l = [{'a': 0}, {'b': 1}, {'c': 2}, {'d': 3}, {'e': 4, 'a': 4}]

from collections import ChainMap
d = dict(ChainMap(*l))
print(d)
# {'e': 4, 'a': 0, 'd': 3, 'c': 2, 'b': 1}

Tuy nhiên, điều này không chính xác đáp ứng các thông số kỹ thuật của chúng tôi: Từ điển thứ năm trong bộ sưu tập của chúng tôi không ghi đè lên các cặp (khóa, giá trị) của từ điển đầu tiên.

Ngoài ra, nó là một cách nhanh chóng để hợp nhất nhiều từ điển và tôi muốn đưa nó vào đây để hiểu được.

Đi đâu từ đây?

Đủ lý thuyết. Hãy để có được một số thực hành!

Các lập trình viên được trả tiền sáu con số và hơn thế nữa vì họ có thể giải quyết các vấn đề hiệu quả hơn bằng cách sử dụng trí thông minh máy móc và tự động hóa.

Để trở nên thành công hơn trong việc mã hóa, giải quyết nhiều vấn đề thực sự hơn cho người thực. Đó là cách bạn đánh bóng các kỹ năng bạn thực sự cần trong thực tế. Rốt cuộc, những gì mà việc sử dụng lý thuyết học tập mà không ai cần?

Bạn xây dựng các kỹ năng mã hóa có giá trị cao bằng cách làm việc trên các dự án mã hóa thực tế!

Bạn có muốn ngừng học hỏi với các dự án đồ chơi và tập trung vào các dự án mã thực tế kiếm tiền cho bạn và giải quyết các vấn đề thực sự cho mọi người?

Nếu câu trả lời của bạn là có !, Hãy xem xét việc trở thành một nhà phát triển tự do Python! Đó là cách tốt nhất để tiếp cận nhiệm vụ cải thiện các kỹ năng trăn của bạn, ngay cả khi bạn là người mới bắt đầu hoàn toàn.YES!, consider becoming a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.

Nếu bạn chỉ muốn tìm hiểu về cơ hội làm việc tự do, vui lòng xem hội thảo trên web miễn phí của tôi Làm thế nào để xây dựng kỹ năng thu nhập cao của bạn Python và tìm hiểu cách tôi phát triển kinh doanh mã hóa của mình trực tuyến và làm thế nào bạn có thể, từ sự thoải mái của bạn riêng nhà.

Tham gia hội thảo trên web miễn phí ngay bây giờ!

Hướng dẫn merge multiple dictionaries in a list python - hợp nhất nhiều từ điển trong một python danh sách

Trong khi làm việc như một nhà nghiên cứu trong các hệ thống phân tán, Tiến sĩ Christian Mayer đã tìm thấy tình yêu của mình đối với việc dạy các sinh viên khoa học máy tính.

Để giúp học sinh đạt được thành công cao hơn của Python, ông đã thành lập trang web giáo dục chương trình Finxter.com. Ông là tác giả của cuốn sách lập trình phổ biến Python Oneer (Nostarch 2020), đồng tác giả của loạt sách Break Break Python, những cuốn sách tự xuất bản, người đam mê khoa học máy tính, freelancer và chủ sở hữu của một trong 10 blog Python lớn nhất trên toàn thế giới.

Niềm đam mê của ông là viết, đọc và mã hóa. Nhưng niềm đam mê lớn nhất của anh là phục vụ các lập trình viên đầy tham vọng thông qua Finxter và giúp họ tăng cường các kỹ năng của họ. Bạn có thể tham gia học viện email miễn phí của anh ấy ở đây.

Làm cách nào để hợp nhất hai từ điển trong danh sách Python?

Sử dụng | Trong Python 3.9 Trong bản cập nhật mới nhất của Python Now, chúng ta có thể sử dụng Nhà điều hành để hợp nhất hai từ điển. Đó là một phương pháp rất thuận tiện để hợp nhất từ ​​điển. Ví dụ: Python3.use “|” operator to merge two dictionaries. It is a very convenient method to merge dictionaries. Example: Python3.

Làm thế nào tôi có thể hợp nhất 4 từ điển trong Python?

Làm thế nào để hợp nhất từ điển trong Python ?..
1) Sử dụng phương thức Update () ..
2) Sử dụng toán tử hợp nhất (|) ..
3) Sử dụng toán tử ** ..
4) Giải nén từ điển thứ hai ..
5) Sử dụng Phương thức Collection.ChainMap () ..
6) Sử dụng itertools.chuỗi().
7) Sử dụng khả năng hiểu từ điển ..
8) Thêm giá trị của các khóa chung ..

Làm cách nào để hợp nhất một danh sách từ điển?

Để hợp nhất nhiều từ điển, cách pythonic nhất là sử dụng từ điển hiểu {k: v cho x in l cho k, v trong x.items ()} đầu tiên lặp lại trên tất cả các từ điển trong danh sách l và sau đó lặp lại, giá trị) cặp trong mỗi từ điển.use dictionary comprehension {k:v for x in l for k,v in x. items()} to first iterate over all dictionaries in the list l and then iterate over all (key, value) pairs in each dictionary.

Làm cách nào để nối một danh sách các từ điển trong Python?

Nối một từ điển vào một danh sách trong Python #..
Sử dụng phương thức Copy () để tạo một bản sao nông của từ điển ..
Sử dụng danh sách.Phương thức nối () để nối bản sao vào danh sách ..
Danh sách sẽ chứa từ điển theo giá trị chứ không phải bằng tham chiếu ..