Hướng dẫn how do i read nested dictionaries in python? - làm cách nào để đọc các từ điển lồng nhau trong python?

Một từ điển có thể chứa một từ điển khác, từ đó có thể chứa từ điển, v.v. đến độ sâu tùy ý. Điều này được gọi là & NBSP; Từ điển lồng nhau.nested dictionary.

Từ điển lồng nhau là một trong nhiều cách để thể hiện thông tin có cấu trúc (tương tự như ‘bản ghi, hoặc‘ cấu trúc trong các ngôn ngữ khác).structured information (similar to ‘records’ or ‘structs’ in other languages).

Tạo một từ điển lồng nhau

Một từ điển lồng nhau được tạo giống như cách tạo ra một từ điển bình thường. Sự khác biệt duy nhất là mỗi giá trị là một từ điển khác.

Hãy để xây dựng một từ điển lưu trữ hồ sơ nhân viên.

D = {'emp1': {'name': 'Bob', 'job': 'Mgr'},
     'emp2': {'name': 'Kim', 'job': 'Dev'},
     'emp3': {'name': 'Sam', 'job': 'Dev'}}

Người xây dựng dict ()

Có một số cách để tạo một từ điển lồng nhau bằng cách sử dụng một hàm tạo loại gọi là & nbsp; dict ().

Để tạo một từ điển lồng nhau, chỉ cần chuyển khóa từ điển: cặp giá trị làm đối số từ khóa cho hàm tạo

D = dict(emp1 = {'name': 'Bob', 'job': 'Mgr'},
         emp2 = {'name': 'Kim', 'job': 'Dev'},
         emp3 = {'name': 'Sam', 'job': 'Dev'})

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}

D = dict(emp1 = {'name': 'Bob', 'job': 'Mgr'},
         emp2 = {'name': 'Kim', 'job': 'Dev'},
         emp3 = {'name': 'Sam', 'job': 'Dev'})

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}

D = dict(emp1 = {'name': 'Bob', 'job': 'Mgr'},
         emp2 = {'name': 'Kim', 'job': 'Dev'},
         emp3 = {'name': 'Sam', 'job': 'Dev'})

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}

Bạn có thể sử dụng hàm Dict () cùng với chức năng & nbsp; zip () & nbsp; để kết hợp các danh sách các khóa và giá trị riêng biệt thu được động trong thời gian chạy.

IDs = ['emp1','emp2','emp3']

EmpInfo = [{'name': 'Bob', 'job': 'Mgr'},
           {'name': 'Kim', 'job': 'Dev'},
           {'name': 'Sam', 'job': 'Dev'}]

D = dict(zip(IDs, EmpInfo))

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}

Bạn thường muốn tạo một từ điển với các giá trị mặc định cho mỗi khóa. Phương thức FromKeys () cung cấp một cách để làm điều này.

IDs = ['emp1','emp2','emp3']
Defaults = {'name': '', 'job': ''}

D = dict.fromkeys(IDs, Defaults)

print(D)
# Prints {'emp1': {'name': '', 'job': ''},
#         'emp2': {'name': '', 'job': ''},
#         'emp3': {'name': '', 'job': ''}}

Truy cập các mục từ điển lồng nhau

Bạn có thể truy cập các mục riêng lẻ trong một từ điển lồng nhau bằng cách chỉ định khóa trong nhiều dấu ngoặc vuông.

D = {'emp1': {'name': 'Bob', 'job': 'Mgr'},
     'emp2': {'name': 'Kim', 'job': 'Dev'},
     'emp3': {'name': 'Sam', 'job': 'Dev'}}

print(D['emp1']['name'])
# Prints Bob

print(D['emp2']['job'])
# Prints Dev

Nếu bạn đề cập đến một khóa không có trong từ điển lồng nhau, một ngoại lệ sẽ được nêu ra.

print(D['emp1']['salary'])
# Triggers KeyError: 'salary'

Để tránh ngoại lệ như vậy, bạn có thể sử dụng từ điển đặc biệt & nbsp; get () & nbsp; phương thức. Phương thức này trả về giá trị cho khóa nếu khóa nằm trong từ điển, khác & nbsp; ____ ____ 16, để phương pháp này không bao giờ tăng A & nbsp; ____ ____ 17.

# key present
print(D['emp1'].get('name'))
# Prints Bob

# key absent
print(D['emp1'].get('salary'))
# PrintsNone

Thay đổi các mục từ điển lồng nhau

Để thay đổi giá trị của một mục cụ thể trong từ điển lồng nhau, hãy tham khảo khóa của nó.

D = {'emp1': {'name': 'Bob', 'job': 'Mgr'},
     'emp2': {'name': 'Kim', 'job': 'Dev'},
     'emp3': {'name': 'Sam', 'job': 'Dev'}}

D['emp3']['name'] = 'Max'
D['emp3']['job'] = 'Janitor'

print(D['emp3'])
# Prints {'name': 'Max', 'job': 'Janitor'}

Thêm hoặc cập nhật các mục từ điển lồng nhau

Thêm hoặc cập nhật các mục từ điển lồng nhau là dễ dàng. Chỉ cần tham khảo mục của nó bằng khóa của nó và gán một giá trị. Nếu khóa đã có trong từ điển, giá trị của nó được thay thế bằng cái mới.

D = {'emp1': {'name': 'Bob', 'job': 'Mgr'},
     'emp2': {'name': 'Kim', 'job': 'Dev'},
     'emp3': {'name': 'Sam', 'job': 'Dev'}}

D['emp3'] = {'name': 'Max', 'job': 'Janitor'}

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Max', 'job': 'Janitor'}}

Nếu khóa là mới, nó sẽ được thêm vào từ điển với giá trị của nó.

D = {'emp1': {'name': 'Bob', 'job': 'Mgr'},
     'emp2': {'name': 'Kim', 'job': 'Dev'},
     'emp3': {'name': 'Sam', 'job': 'Dev'}}

D['emp4'] = {'name': 'Max', 'job': 'Janitor'}

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'},
#         'emp4': {'name': 'Max', 'job': 'Janitor'}}

Hợp nhất hai từ điển lồng nhau

Sử dụng phương thức Cập nhật () tích hợp để hợp nhất các khóa và giá trị của một từ điển lồng nhau sang một từ khác. Lưu ý rằng phương pháp này một cách mù quáng ghi đè lên các giá trị của cùng một khóa nếu có một cuộc đụng độ.

D = dict(emp1 = {'name': 'Bob', 'job': 'Mgr'},
         emp2 = {'name': 'Kim', 'job': 'Dev'},
         emp3 = {'name': 'Sam', 'job': 'Dev'})

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}

Ở đây, bản ghi EMP2 ′ được cập nhật trong khi EMP3 được thêm vào từ điển.

Xóa các mục từ điển lồng nhau

Có một số cách để loại bỏ các mục khỏi một từ điển lồng nhau.

Xóa một mục bằng khóa

Nếu bạn biết khóa của mục bạn muốn, bạn có thể sử dụng & nbsp; pop () & nbsp; phương thức. Nó loại bỏ khóa và trả về giá trị của nó.

D = dict(emp1 = {'name': 'Bob', 'job': 'Mgr'},
         emp2 = {'name': 'Kim', 'job': 'Dev'},
         emp3 = {'name': 'Sam', 'job': 'Dev'})

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}

Nếu bạn không cần giá trị bị loại bỏ, hãy sử dụng câu lệnh

D = dict(emp1 = {'name': 'Bob', 'job': 'Mgr'},
         emp2 = {'name': 'Kim', 'job': 'Dev'},
         emp3 = {'name': 'Sam', 'job': 'Dev'})

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}

D = dict(emp1 = {'name': 'Bob', 'job': 'Mgr'},
         emp2 = {'name': 'Kim', 'job': 'Dev'},
         emp3 = {'name': 'Sam', 'job': 'Dev'})

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}

Xóa mục được chèn cuối cùng

Phương thức PopItem () loại bỏ và trả về mục được chèn cuối cùng dưới dạng tuple.

D = dict(emp1 = {'name': 'Bob', 'job': 'Mgr'},
         emp2 = {'name': 'Kim', 'job': 'Dev'},
         emp3 = {'name': 'Sam', 'job': 'Dev'})

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}

Trong các phiên bản trước 3.7,

D = dict(emp1 = {'name': 'Bob', 'job': 'Mgr'},
         emp2 = {'name': 'Kim', 'job': 'Dev'},
         emp3 = {'name': 'Sam', 'job': 'Dev'})

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}

Lặp lại thông qua một từ điển lồng nhau

Bạn có thể lặp lại tất cả các giá trị trong một từ điển lồng nhau bằng cách sử dụng lồng nhau cho vòng lặp.

D = dict(emp1 = {'name': 'Bob', 'job': 'Mgr'},
         emp2 = {'name': 'Kim', 'job': 'Dev'},
         emp3 = {'name': 'Sam', 'job': 'Dev'})

print(D)
# Prints {'emp1': {'name': 'Bob', 'job': 'Mgr'},
#         'emp2': {'name': 'Kim', 'job': 'Dev'},
#         'emp3': {'name': 'Sam', 'job': 'Dev'}}