Lấy giá trị từ từ điển lồng nhau python

Bạn phải làm quen với từ điển trong Python. Tuy nhiên, trước khi tiếp tục với chương trình nghị sự của bài viết của chúng tôi, chúng ta hãy tóm tắt nhanh về từ điển trong Python

Từ điển trong Python là một trong những cấu trúc dữ liệu phổ biến nhất. Từ điển được sử dụng để lưu trữ dữ liệu ở định dạng cặp "khóa-giá trị". Các khóa luôn là duy nhất trong một từ điển. Các giá trị của từ điển Python có thể là duy nhất hoặc không. Chúng ta có thể định nghĩa một từ điển bằng cách đặt một danh sách các cặp khóa-giá trị được phân tách bằng dấu phẩy trong dấu ngoặc nhọn [{}]. Một dấu hai chấm [. ] tách từng khóa khỏi giá trị được liên kết của nó

Vì vậy, từ điển lồng nhau là gì?

Trong Python, từ điển lồng nhau là từ điển bên trong từ điển. Về cơ bản, nó là một tập hợp các từ điển được lưu giữ trong một từ điển duy nhất

Từ điển lồng nhau là một trong những cách để biểu diễn và lưu trữ thông tin có cấu trúc [tương tự như một số 'bản ghi' trong các ngôn ngữ khác]

Dưới đây đưa ra là một ví dụ đơn giản về một từ điển lồng nhau

my_dict = { 'dict1': {'key_A': 'value_A'},
        'dict2': {'key_B': 'value_B'}}
Chúng ta sẽ hiểu đoạn mã trên sâu hơn
Tạo một từ điển lồng nhau
Tạo một từ điển lồng nhau rất giống với cách chúng ta tạo bất kỳ từ điển bình thường nào khác. Có một sự khác biệt rất cơ bản là trong từ điển lồng nhau, giá trị cũng có thể là một từ điển
Hãy để chúng tôi hiểu điều này rõ ràng thông qua một ví dụ. Giả sử, chúng tôi đã lưu hồ sơ của 3 sinh viên trong một cuốn từ điển. Giả sử, một học sinh cá nhân có các thuộc tính sau. Tên, Lớp, và Số
Chúng ta có thể trình bày điều này rất rõ ràng thông qua một từ điển lồng nhau
school = {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
Giải trình. Trong ví dụ trên, chúng tôi đã tạo một từ điển có tên là "school". Đây là một từ điển lồng nhau có chỉ mục sinh viên làm khóa và các thuộc tính của sinh viên như tên, cuộn và lớp là các giá trị của khóa. Nhưng ở đây, xin lưu ý rằng mọi khóa được ánh xạ tới một giá trị mà chính nó là một từ điển. Nói một cách đơn giản, các giá trị trong từ điển này chính là từ điển. Vì vậy, đây là cách chúng tôi tạo một từ điển lồng nhau
Hãy cũng chúng tôi tìm hiểu về một cách quan trọng để tạo từ điển lồng nhau
Trình tạo dict[]
Có một "hàm tạo kiểu" được gọi là dict[] trong Python, có thể được sử dụng để tạo từ điển python từ các đối số từ khóa hoặc bất kỳ loại cặp khóa-giá trị nào. Nó thậm chí có thể tạo một từ điển từ một từ điển khác và các đối số từ khóa
Các thuật ngữ này có thể không có ý nghĩa gì đối với bạn, do đó, hãy cho chúng tôi hiểu hàm tạo dict[] được sử dụng để tạo từ điển lồng nhau như thế nào thông qua các ví dụ đơn giản
1. Đối số từ khóa cho từ điển lồng nhau
Để tạo một từ điển lồng nhau, chúng ta chỉ cần chuyển khóa từ điển của mình. cặp giá trị làm đối số từ khóa cho hàm tạo dict[]. Ví dụ, nhìn vào đoạn mã dưới đây --

# using the dict constructor to convert 
# Keyword Arguments to nested dictionary
school = dict['student1'= {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2'= {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3'= {'name': 'Ron', 'roll': '18', 'class': '6'}]

print[school]
đầu ra
    {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
Trong ví dụ trên, xin lưu ý rằng chúng tôi đã đặt từ điển của mình trong dấu ngoặc tròn '[]' và chuyển nó tới hàm tạo dict[] --
#using the dict[] constructor
dict['a'={...},'b'={...}]
Kết quả là hàm tạo dict[] đã chuyển đổi các đối số từ khóa ở trên thành từ điển lồng nhau
Nhấn vào đây để đọc về Constructor trong Python
2. Sử dụng phương thức zip[] trong Python
Hàm zip[] nhận một số lần lặp [có thể bằng 0 hoặc nhiều hơn], tính tổng chúng trong một bộ và trả về chúng. Chúng tôi có thể sử dụng zip để kết hợp các danh sách khóa và giá trị riêng biệt. Chúng ta cũng có thể tự động chuyển danh sách khóa và giá trị cho hàm zip[] khi chạy

  

# student list contains the student indexes
studentList = ['student1', 'student2', 'student3']

# studentinfo contains the information regarding the students
studentInfo = ['student1'= {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2'= {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3'= {'name': 'Ron', 'roll': '18', 'class': '6'}]

# zipping up the studentlist and studentinfo list into
# a dictionary using the zip[] method
school = dic[zip[studentList, studentInfo]]
print[school]
đầu ra
    {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
3. Sử dụng Phương thức fromkeys[] của Từ điển Python
Phương thức fromkeys[] trong từ điển python tạo một từ điển mới với giá trị mặc định cho tất cả các khóa được chỉ định. Trong trường hợp chúng tôi không chỉ định bất kỳ giá trị mặc định nào thì tất cả các khóa được đặt thành Không có
Mã số
#Syntax
dict.fromkeys[keys,value]

# Example
# Create a dictionary and set default value 'Employee' for all keys
emp = dict.fromkeys[['A', 'B', 'C'], 'Employee']
print[emp]
đầu ra
________số 8
Chúng ta có thể sử dụng lệnh. fromkeys[] để tạo một từ điển lồng nhau với một số giá trị mặc định. Ví dụ: hãy xem xét đoạn mã đã cho bên dưới --
Mã số
# student list contains the student indexes
studentList = ['student1', 'student2', 'student3']

# studentinfo contains the default properties that should  # be present for a student
studentDefault = {'name':'','roll':'','class':''}

# passing the studentList and studentDefault 
# to dic.fromkeys for creating nested dictionary
school = dic.fromkeys[studentList, studentDefault]
print[school]
đầu ra
school = {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
0
Giải trình. Như chúng tôi đã giải thích ở trên, fromkeys[] đã tạo một từ điển dựa trên các khóa và mặc định các giá trị mà chúng tôi đã truyền cho nó
Truy cập các mục từ điển lồng nhau
Chúng ta có thể truy cập các mục của từ điển bằng cách chỉ định khóa của từ điển và khóa của từ điển lồng vào trong dấu ngoặc vuông. Ví dụ: xem xét đoạn mã dưới đây
Mã số
school = {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
1
đầu ra
Ngoại lệ. Nếu chúng tôi cố gắng truy cập bất kỳ cặp khóa-giá trị nào không tồn tại trong từ điển của chúng tôi, chúng tôi sẽ gặp lỗi khóa
Mã số
school = {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
2
đầu ra
Tuy nhiên, chúng tôi có thể ngăn mã của mình rơi vào bất kỳ lỗi khóa nào. Điều này có thể được thực hiện bằng cách sử dụng phương thức get[] từ điển đặc biệt. Phương thức get[] trả về giá trị cho khóa nếu khóa có trong từ điển, ngược lại, nó trả về Không có. Do đó, chúng tôi không bao giờ nhận được keyError nếu chúng tôi sử dụng phương pháp này
Mã số
school = {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
3
đầu ra
Xóa từ điển khỏi từ điển lồng nhau
Xóa từ điển khỏi từ điển lồng nhau là một thao tác đơn giản, chúng ta có thể sử dụng từ khóa del của python. Một cách khác để xóa từ điển là sử dụng phương thức pop[] trong python
1. Sử dụng Phương thức pop[]
pop[] thường được sử dụng khi chúng ta muốn giá trị của từ điển sau khi xóa nó. Vì vậy, pop[] trả về một giá trị. Ví dụ, nhìn vào đoạn mã dưới đây

  

Mã số
school = {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
4
đầu ra
school = {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
5
2. Sử dụng từ khóa del
Một cách khác để xóa từ điển là sử dụng từ khóa del trong Python. Điều này thường được sử dụng khi chúng tôi không muốn giá trị bị xóa. Ví dụ, nhìn vào đoạn mã dưới đây
Mã số
school = {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
6
đầu ra
school = {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
7
Chúng ta có thể thêm hoặc cập nhật các thành phần của từ điển lồng nhau rất đơn giản. Tuy nhiên, có một sự khác biệt khi chúng tôi đang cố gắng thêm một khóa mới vào từ điển của mình hoặc cập nhật bất kỳ khóa hiện có nào. Sự khác biệt là --
Nếu khóa đã có trong từ điển, giá trị sẽ được cập nhật
Nếu khóa không có trong từ điển, một khóa mới. cặp giá trị được thêm vào từ điển
Hãy để chúng tôi hiểu những điều này sâu bên dưới thông qua mã. Nếu chúng ta thêm một cặp khóa-giá trị vào từ điển lồng nhau, với một khóa đã có trong từ điển lồng ban đầu, thì giá trị cũ sẽ được cập nhật. Ví dụ, nhìn vào đoạn mã dưới đây
Mã số
school = {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
8
đầu ra
school = {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
9
Giải trình. Trong ví dụ trên, chúng tôi cố gắng thêm một phần tử vào từ điển, nhưng xin lưu ý rằng khóa đã tồn tại trong từ điển của chúng tôi. Vì khóa đã có trong từ điển nên giá trị của nó được thay thế bằng khóa mới
Bây giờ chúng ta hãy xem bằng cách thêm một yếu tố mới vào từ điển của chúng ta
Mã số

# using the dict constructor to convert 
# Keyword Arguments to nested dictionary
school = dict['student1'= {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2'= {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3'= {'name': 'Ron', 'roll': '18', 'class': '6'}]

print[school]
0
đầu ra

# using the dict constructor to convert 
# Keyword Arguments to nested dictionary
school = dict['student1'= {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2'= {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3'= {'name': 'Ron', 'roll': '18', 'class': '6'}]

print[school]
1
Trong ví dụ này, chúng tôi đã sử dụng một khóa mới để nó được thêm trực tiếp vào từ điển lồng nhau của chúng tôi. Và, do đó từ điển có thêm một yếu tố mới. Vì vậy, đây là một sự khác biệt lớn, nếu khóa của chúng tôi đã tồn tại trong từ điển của chúng tôi thì từ điển của chúng tôi sẽ được cập nhật, nếu không, một cặp khóa-giá trị mới sẽ được thêm vào từ điển
Xóa các phần tử khỏi từ điển lồng nhau
Chúng ta đã thấy cách xóa một mục từ điển khỏi từ điển lồng nhau. Ở đây chúng ta sẽ tìm hiểu cách chúng ta có thể xóa một phần tử hoặc giá trị khỏi từ điển lồng nhau
Xóa giá trị khỏi từ điển lồng nhau rất giống với xóa chính mục từ điển. Chủ yếu có 2 cách [chính xác là 3]. Hãy để chúng tôi tìm hiểu từng người trong số họ
Sử dụng từ khóa del trong Python
Chúng tôi có thể sử dụng từ khóa del để xóa một phần tử khỏi từ điển lồng nhau của chúng tôi. Tuy nhiên, del không trả lại bất cứ thứ gì do đó chúng tôi không thể truy xuất phần tử mà chúng tôi đã xóa bằng cách sử dụng nó. Hãy để chúng tôi xem một ví dụ để chứng minh việc sử dụng nó
Mã số

# using the dict constructor to convert 
# Keyword Arguments to nested dictionary
school = dict['student1'= {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2'= {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3'= {'name': 'Ron', 'roll': '18', 'class': '6'}]

print[school]
2
đầu ra

  


# using the dict constructor to convert 
# Keyword Arguments to nested dictionary
school = dict['student1'= {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2'= {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3'= {'name': 'Ron', 'roll': '18', 'class': '6'}]

print[school]
3
Giải trình. Trong ví dụ trên, chúng tôi đã sử dụng từ khóa del để xóa giá trị khỏi từ điển. Chúng tôi đã lấy giá trị của từ điển bằng cách sử dụng khóa. Chúng tôi cũng có thể sử dụng lập chỉ mục để xóa các phần tử tại bất kỳ chỉ mục cụ thể nào
Sử dụng phương thức pop[]
Chúng ta có thể sử dụng phương thức pop[] để xóa một phần tử khỏi từ điển lồng nhau của chúng ta. Không giống như từ khóa del, pop[] trả về giá trị bất cứ khi nào nó xóa bất kỳ mục nào. Vì vậy, nên sử dụng phương thức pop[] bất cứ khi nào chúng ta muốn tìm nạp giá trị của phần tử mà chúng ta đã xóa. Dưới đây đưa ra là một ví dụ về việc sử dụng pop để xóa các phần tử
Mã số

# using the dict constructor to convert 
# Keyword Arguments to nested dictionary
school = dict['student1'= {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2'= {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3'= {'name': 'Ron', 'roll': '18', 'class': '6'}]

print[school]
4
đầu ra

# using the dict constructor to convert 
# Keyword Arguments to nested dictionary
school = dict['student1'= {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2'= {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3'= {'name': 'Ron', 'roll': '18', 'class': '6'}]

print[school]
5
Giải trình. Như đã giải thích ở trên, chúng tôi tìm nạp các giá trị phần tử từ điển sẽ bị xóa bằng cách sử dụng khóa của từ điển lồng nhau. Sau đó, chúng tôi lưu trữ các giá trị của các phần tử được bật lên bằng cách sử dụng pop[]
Lặp lại qua từng phần tử trong từ điển lồng nhau
Trong các từ điển thông thường, chúng ta có thể lặp lại từ điển bằng cách sử dụng dict. mặt hàng[]. Nhưng, đây không phải là trường hợp với từ điển lồng nhau. Ở đây, chúng ta có thể có từ điển trong từ điển và do đó chúng ta phải chuyển sang một cấp độ khác để lặp qua các giá trị của chúng
Chúng ta có thể lặp lại trong một từ điển lồng nhau bằng cách sử dụng vòng lặp for lồng nhau. Hãy để chúng tôi nhìn vào mã của chúng tôi để hiểu nó tốt hơn
Mã số

# using the dict constructor to convert 
# Keyword Arguments to nested dictionary
school = dict['student1'= {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2'= {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3'= {'name': 'Ron', 'roll': '18', 'class': '6'}]

print[school]
6
đầu ra

# using the dict constructor to convert 
# Keyword Arguments to nested dictionary
school = dict['student1'= {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2'= {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3'= {'name': 'Ron', 'roll': '18', 'class': '6'}]

print[school]
7
Giải trình. Trong ví dụ trên, trước tiên chúng tôi lặp lại các mục từ điển, từ đó cung cấp cho chúng tôi cặp giá trị khóa keykeykey, valvalval. Bây giờ, giá trị kết quả valvalval là một từ điển khác. Do đó, chúng tôi lặp lại trên val. items[] để lấy NestedKeynestedKeynestedKey và NestedValnestedValnestedVal. Mã này sẽ hoạt động tốt nếu chúng ta chỉ có một cấp từ điển lồng nhau. Đối với cấp độ n của từ điển lồng nhau, đây không phải là cách thích hợp
Trong bài viết này, chúng ta đã học cách lặp qua một từ điển lồng nhau được lồng 1 cấp độ [chỉ có 1 từ điển bên trong một từ điển]. Tuy nhiên, có những trường hợp chúng ta có thể có n cấp từ điển lồng nhau. Đối với họ, cách đơn giản nhất để lặp lại là thông qua gọi đệ quy đó là từng cấp độ lồng nhau. Xin lưu ý rằng từ điển lồng cấp n không thuộc phạm vi của bài viết này
Hợp nhất hai từ điển lồng nhau
Hai từ điển lồng nhau có thể được hợp nhất bằng phương thức update[] trong Python
Phương thức update[] cập nhật từ điển bằng khóa. cặp giá trị từ phần tử
Nếu khóa đã có trong từ điển, giá trị sẽ được cập nhật
Nếu khóa không có trong từ điển, một khóa mới. cặp giá trị được thêm vào từ điển
cú pháp

# using the dict constructor to convert 
# Keyword Arguments to nested dictionary
school = dict['student1'= {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2'= {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3'= {'name': 'Ron', 'roll': '18', 'class': '6'}]

print[school]
8
Hãy cho chúng tôi xem đoạn mã dưới đây để cập nhật bất kỳ từ điển nào
Mã số

# using the dict constructor to convert 
# Keyword Arguments to nested dictionary
school = dict['student1'= {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2'= {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3'= {'name': 'Ron', 'roll': '18', 'class': '6'}]

print[school]
9
đầu ra
    {'student1': {'name': 'Ace', 'roll': '10', 'class': '5'},
     'student2': {'name': 'Bob', 'roll': '15', 'class': '5'},
     'student3': {'name': 'Ron', 'roll': '18', 'class': '6'}}
0
Giải trình. Trong ví dụ trên, chúng tôi cập nhật từ điển my_dict1 bằng từ điển my_dict2. Trong khi làm như vậy, bất kỳ khóa nào đã có trong my_dict1 sẽ bị ghi đè bởi khóa của my_dict2. Và, nếu không có khóa, thì một khóa mới sẽ được thêm vào. Ví dụ: khóa BBB được cập nhật trong từ điển my_dict1. Và khóa DDD mới được thêm vào my_dict1, vì nó chưa có
kết luận quan trọng
update[] ghi đè mù quáng các giá trị của cùng một khóa nếu có xung đột [hoặc khóa bằng nhau trong 2 từ điển]
update[] cập nhật trực tiếp từ điển, nó không trả về bất cứ thứ gì
Liên kết đến các bài viết tương tự khác --
Bài viết này bao gồm tất cả những điểm chính mà bạn cần biết để có một ý tưởng ngắn gọn về các từ điển lồng nhau trong Python. Bạn cũng có thể tham khảo các bài viết về trình chia tỷ lệ bên dưới để biết thêm về Từ điển trong Python. Ngoài ra, điều kiện tiên quyết cho bài viết này là từ điển trong Python
Trong bài viết này, chúng ta đã tìm hiểu về từ điển lồng nhau trong Python. Hãy để chúng tôi tóm tắt lại những gì chúng tôi đã học được trong suốt
 

			
Làm cách nào tôi có thể trích xuất tất cả các giá trị từ một từ điển trong Python?
			
Dưới đây là 3 cách tiếp cận để trích xuất các giá trị từ điển dưới dạng danh sách trong Python.  . 
 
[1] Sử dụng hàm list[]. my_list = danh sách [my_dict. giá trị[]]
 
[2] Sử dụng cách hiểu danh sách. my_list = [i cho tôi trong my_dict. giá trị[]]
 
[3] Sử dụng vòng lặp For. my_list = [] cho tôi trong my_dict. giá trị[]. danh sách của tôi. nối thêm [i]
 
		
			
Làm cách nào để lấy giá trị từ từ điển trong Python?
			
Trong Python, bạn có thể lấy giá trị từ một từ điển  bằng cách chỉ định khóa như dict[key] . Trong trường hợp này, KeyError được nâng lên nếu khóa không tồn tại. Lưu ý rằng không có vấn đề gì khi chỉ định khóa không tồn tại nếu bạn muốn thêm phần tử mới. 
		
			
Làm cách nào để lặp qua từ điển Python lồng nhau?
			
chỉ cần  viết d.  items[]  , nó sẽ hoạt động, theo mặc định khi lặp lại tên của dict chỉ trả về các khóa.