Trong bài viết này, tôi sẽ nói về từ điển. Đây là bài viết thứ hai trong loạt bài có tên “Cấu trúc dữ liệu trong Python”. Phần đầu tiên của loạt bài này là về danh sách
Từ điển là cấu trúc dữ liệu quan trọng trong Python sử dụng các khóa để lập chỉ mục. Chúng là một chuỗi các mục không có thứ tự [cặp khóa-giá trị], có nghĩa là thứ tự không được bảo toàn. Các phím là bất biến. Cũng giống như danh sách, giá trị của từ điển có thể chứa dữ liệu không đồng nhất. e. , số nguyên, số float, chuỗi, NaN, Booleans, danh sách, mảng và thậm chí cả từ điển lồng nhau
Bài viết này sẽ giúp bạn hiểu rõ và giúp bạn làm việc thành thạo với từ điển Python
Các chủ đề sau đây được đề cập trong bài viết này
- Tạo một từ điển và thêm các yếu tố
- Truy cập các phần tử từ điển
- Loại bỏ các yếu tố từ điển
- Thêm/chèn các phần tử mới
- Hợp nhất/ghép từ điển
- Sửa đổi từ điển
- Sắp xếp từ điển
- hiểu từ điển
- Các cách khác để tạo từ điển
- Sao chép từ điển
- Đổi tên các khóa hiện có
- Từ điển lồng nhau
- Kiểm tra xem một khóa có tồn tại trong từ điển không
1] Tạo từ điển và thêm các phần tử
Giống như danh sách được khởi tạo bằng dấu ngoặc vuông [[ ]], từ điển được khởi tạo bằng dấu ngoặc nhọn [{ }]. Tất nhiên, một từ điển rỗng có độ dài bằng không
dic_a = {} # An empty dictionarytype[dic_a]
>>> dictlen[dic_a]
>>> 0
Một từ điển có hai tính năng đặc trưng. khóa và giá trị. Mỗi phím có một giá trị tương ứng. Cả khóa và giá trị đều có thể là kiểu chuỗi, số float, số nguyên, NaN, v.v. Thêm các phần tử vào từ điển có nghĩa là thêm một cặp khóa-giá trị. Từ điển bao gồm một hoặc nhiều cặp khóa-giá trị
Hãy để chúng tôi thêm một số yếu tố vào từ điển trống của chúng tôi. Sau đây là một cách để làm như vậy. Ở đây,
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}7 là khóa và dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}8 là giá trị của nó. Bạn có thể thêm bao nhiêu yếu tố tùy thích# Adding the first element
dic_a['A'] = 'Apple'print [dic_a]
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print [dic_a]
>>> {'A': 'Apple', 'B': 'Ball'}
Ghi chú. Python phân biệt chữ hoa chữ thường,
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}7 và dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys[]0 hoạt động như hai khóa khác nhau
>>> dict_keys[['A', 'B', 'C']]dic_a.values[]
>>> dict_values[['Apple', 'Ball', 'Cat']]dic_a.items[]
>>> dict_items[[['A', 'Apple'], ['B', 'Ball'], ['C', 'Cat']]]
dic_a['a'] = 'apple'print [dic_a]
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
Khởi tạo từ điển tất cả cùng một lúc
Nếu bạn thấy phương pháp thêm từng phần tử ở trên là mệt mỏi, bạn cũng có thể khởi tạo từ điển cùng một lúc bằng cách chỉ định tất cả các cặp khóa-giá trị
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}Từ điển không đồng nhất
Cho đến nay từ điển của bạn có các chuỗi là khóa và giá trị. Một từ điển cũng có thể lưu trữ dữ liệu của các loại hỗn hợp. Sau đây là một từ điển Python hợp lệ
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}Mặc dù vậy, bạn nên sử dụng các tên có ý nghĩa cho các khóa vì chúng biểu thị các chỉ mục của từ điển. Đặc biệt, tránh sử dụng float và np. nan như chìa khóa
2] Truy cập các phần tử từ điển
Sau khi tạo từ điển của chúng tôi, hãy xem cách chúng tôi có thể truy cập các phần tử của chúng
Truy cập các khóa và giá trị
Bạn có thể truy cập các khóa và giá trị bằng các hàm
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys[]1 và
>>> dict_keys[['A', 'B', 'C']]dic_a.values[]
>>> dict_values[['Apple', 'Ball', 'Cat']]dic_a.items[]
>>> dict_items[[['A', 'Apple'], ['B', 'Ball'], ['C', 'Cat']]]
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys[]2 tương ứng. Bạn cũng có thể truy cập cả khóa và giá trị ở dạng bộ dữ liệu bằng cách sử dụng hàm
>>> dict_keys[['A', 'B', 'C']]dic_a.values[]
>>> dict_values[['Apple', 'Ball', 'Cat']]dic_a.items[]
>>> dict_items[[['A', 'Apple'], ['B', 'Ball'], ['C', 'Cat']]]
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys[]3
>>> dict_keys[['A', 'B', 'C']]dic_a.values[]
>>> dict_values[['Apple', 'Ball', 'Cat']]dic_a.items[]
>>> dict_items[[['A', 'Apple'], ['B', 'Ball'], ['C', 'Cat']]]
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys[]
>>> dict_keys[['A', 'B', 'C']]dic_a.values[]
>>> dict_values[['Apple', 'Ball', 'Cat']]dic_a.items[]
>>> dict_items[[['A', 'Apple'], ['B', 'Ball'], ['C', 'Cat']]]
Ngoài ra, bạn cũng có thể sử dụng vòng lặp “for” để truy cập/in từng tài liệu một
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}3Bạn có thể tránh hai vòng lặp “for” và truy cập các khóa và giá trị bằng cách sử dụng
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys[]3. Vòng lặp “for” sẽ lặp qua các cặp khóa-giá trị được trả về bởi
>>> dict_keys[['A', 'B', 'C']]dic_a.values[]
>>> dict_values[['Apple', 'Ball', 'Cat']]dic_a.items[]
>>> dict_items[[['A', 'Apple'], ['B', 'Ball'], ['C', 'Cat']]]
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys[]3. Ở đây,
>>> dict_keys[['A', 'B', 'C']]dic_a.values[]
>>> dict_values[['Apple', 'Ball', 'Cat']]dic_a.items[]
>>> dict_items[[['A', 'Apple'], ['B', 'Ball'], ['C', 'Cat']]]
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys[]6 và
>>> dict_keys[['A', 'B', 'C']]dic_a.values[]
>>> dict_values[['Apple', 'Ball', 'Cat']]dic_a.items[]
>>> dict_items[[['A', 'Apple'], ['B', 'Ball'], ['C', 'Cat']]]
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys[]7 là các tên biến tùy ý
>>> dict_keys[['A', 'B', 'C']]dic_a.values[]
>>> dict_values[['Apple', 'Ball', 'Cat']]dic_a.items[]
>>> dict_items[[['A', 'Apple'], ['B', 'Ball'], ['C', 'Cat']]]
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}8Truy cập các phần tử riêng lẻ
Không thể truy cập các mục từ điển bằng cách lập chỉ mục giống như danh sách
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}9Bạn cần sử dụng các phím để truy cập các giá trị tương ứng từ từ điển
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}0Bạn sẽ gặp lỗi nếu khóa không tồn tại trong từ điển
# Adding the first element0
dic_a['A'] = 'Apple'print [dic_a]
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print [dic_a]
>>> {'A': 'Apple', 'B': 'Ball'}
Nếu bạn muốn tránh lỗi key như vậy trong trường hợp key không tồn tại, bạn có thể sử dụng hàm
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys[]8. Điều này trả về
>>> dict_keys[['A', 'B', 'C']]dic_a.values[]
>>> dict_values[['Apple', 'Ball', 'Cat']]dic_a.items[]
>>> dict_items[[['A', 'Apple'], ['B', 'Ball'], ['C', 'Cat']]]
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys[]9 khi khóa không tồn tại. Bạn cũng có thể sử dụng một tin nhắn tùy chỉnh để được trả lại
>>> dict_keys[['A', 'B', 'C']]dic_a.values[]
>>> dict_values[['Apple', 'Ball', 'Cat']]dic_a.items[]
>>> dict_items[[['A', 'Apple'], ['B', 'Ball'], ['C', 'Cat']]]
# Adding the first element1
dic_a['A'] = 'Apple'print [dic_a]
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print [dic_a]
>>> {'A': 'Apple', 'B': 'Ball'}
Truy cập các phần tử từ điển như trong danh sách
Nếu bạn muốn truy cập các phần tử từ điển [khóa hoặc giá trị] bằng chỉ mục, trước tiên bạn cần chuyển đổi chúng thành danh sách
# Adding the first element2
dic_a['A'] = 'Apple'print [dic_a]
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print [dic_a]
>>> {'A': 'Apple', 'B': 'Ball'}
3] Xóa các thành phần từ điển
Xóa các phần tử khỏi từ điển có nghĩa là xóa một cặp khóa-giá trị cùng nhau
Sử dụng del
Bạn có thể xóa các thành phần từ điển bằng cách sử dụng từ khóa
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}30 và khóa có giá trị bạn muốn xóa. Việc xóa tại chỗ, nghĩa là bạn không cần phải gán lại giá trị của từ điển sau khi xóa# Adding the first element3
dic_a['A'] = 'Apple'print [dic_a]
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print [dic_a]
>>> {'A': 'Apple', 'B': 'Ball'}
Sử dụng pop[]
Bạn cũng có thể sử dụng chức năng “pop[]” để xóa các phần tử. Nó trả về giá trị được bật [đã xóa] và từ điển được sửa đổi tại chỗ
# Adding the first element4
dic_a['A'] = 'Apple'print [dic_a]
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print [dic_a]
>>> {'A': 'Apple', 'B': 'Ball'}
Trong cả hai phương pháp được mô tả ở trên, bạn sẽ gặp lỗi KeyError nếu khóa cần xóa không tồn tại trong từ điển. Trong trường hợp “pop[]”, bạn có thể chỉ định thông báo lỗi sẽ hiển thị nếu khóa không tồn tại
# Adding the first element5
dic_a['A'] = 'Apple'print [dic_a]
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print [dic_a]
>>> {'A': 'Apple', 'B': 'Ball'}
Xóa nhiều phần tử
Không có cách trực tiếp nhưng bạn có thể sử dụng vòng lặp “for” như hình bên dưới
# Adding the first element6
dic_a['A'] = 'Apple'print [dic_a]
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print [dic_a]
>>> {'A': 'Apple', 'B': 'Ball'}
4] Thêm/chèn các phần tử mới
Bạn có thể thêm từng phần tử vào một từ điển đã có sẵn như hình bên dưới
# Adding the first element7
dic_a['A'] = 'Apple'print [dic_a]
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print [dic_a]
>>> {'A': 'Apple', 'B': 'Ball'}
Nếu khóa bạn đang thêm đã tồn tại, giá trị hiện có sẽ bị ghi đè
# Adding the first element8
dic_a['A'] = 'Apple'print [dic_a]
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print [dic_a]
>>> {'A': 'Apple', 'B': 'Ball'}
Sử dụng cập nhật[]
Bạn cũng có thể sử dụng hàm
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}31 để thêm một cặp khóa-giá trị mới bằng cách chuyển cặp đó làm đối số# Adding the first element9
dic_a['A'] = 'Apple'print [dic_a]
>>> {'A': 'Apple'}# Adding the second element
dic_a['B'] = 'Ball'print [dic_a]
>>> {'A': 'Apple', 'B': 'Ball'}
Hàm
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}31 cũng cho phép bạn thêm đồng thời nhiều cặp khóa-giá trị vào từ điển hiện códic_a['a'] = 'apple'print [dic_a]0
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
5] Hợp nhất/ghép từ điển
Bạn có thể hợp nhất hai hoặc nhiều từ điển bằng cách sử dụng toán tử giải nén [
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}33] bắt đầu từ Python 3. 5 trở đidic_a['a'] = 'apple'print [dic_a]1
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
Nếu bạn không muốn tạo một từ điển mới mà chỉ muốn thêm
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}34 vào dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}35 hiện có, bạn chỉ cần cập nhật từ điển đầu tiên như được hiển thị trước đódic_a['a'] = 'apple'print [dic_a]2
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
Các khóa trùng lặp được xử lý như thế nào trong khi ghép nối?
Một trong những đặc điểm của từ điển Python là chúng không thể có khóa trùng lặp. e. , một phím không thể xuất hiện hai lần. Vì vậy, điều gì sẽ xảy ra nếu bạn nối hai hoặc nhiều từ điển có một hoặc nhiều khóa chung
Câu trả lời là cặp khóa-giá trị trong từ điển được hợp nhất cuối cùng [theo thứ tự hợp nhất] sẽ tồn tại. Trong ví dụ sau, khóa
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}7 tồn tại trong cả ba từ điển và do đó, từ điển cuối cùng lấy giá trị từ từ điển được hợp nhất cuối cùng [dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}37]dic_a['a'] = 'apple'print [dic_a]3
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
Lời cảnh báo
Tôi vừa nói rằng từ điển không thể có khóa trùng lặp. Nói một cách chính xác, bạn có thể định nghĩa một từ điển có các khóa trùng lặp, nhưng khi bạn in nó, chỉ có khóa trùng lặp cuối cùng sẽ được in. A được hiển thị bên dưới, chỉ các khóa duy nhất được trả về và đối với khóa trùng lặp ['A' ở đây], chỉ giá trị cuối cùng được trả về
dic_a['a'] = 'apple'print [dic_a]4
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
Cách dễ dàng hơn trong Python 3. 9+
Từ Python 3. 9 trở đi, bạn có thể sử dụng toán tử
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}38 để nối hai từ điển trở lêndic_a['a'] = 'apple'print [dic_a]5
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
6] Sửa đổi từ điển
Nếu bạn muốn thay đổi giá trị của
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}7 từ dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}8 thành dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}81, bạn có thể sử dụng phép gán đơn giảndic_a['a'] = 'apple'print [dic_a]6
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
7] Sắp xếp từ điển
Thứ tự không được duy trì trong từ điển. Bạn có thể sắp xếp từ điển bằng cách sử dụng khóa hoặc giá trị bằng cách sử dụng hàm
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}82Sắp xếp bằng phím
Nếu các khóa là chuỗi [bảng chữ cái], chúng sẽ được sắp xếp theo thứ tự bảng chữ cái. Trong một từ điển, chúng ta có hai yếu tố chính. khóa và giá trị. Do đó, trong khi sắp xếp theo các khóa, chúng tôi sử dụng phần tử đầu tiên i. e. keys và do đó, chỉ mục được sử dụng trong hàm lambda là “[0]”. Bạn có thể đọc bài đăng này để biết thêm thông tin về các chức năng lambda
dic_a['a'] = 'apple'print [dic_a]7
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
Việc sắp xếp không đúng chỗ. Như hình bên dưới, nếu bây giờ bạn in từ điển ra thì nó vẫn không có thứ tự, như khởi tạo ban đầu. Bạn sẽ phải chỉ định lại nó sau khi sắp xếp
dic_a['a'] = 'apple'print [dic_a]8
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
Nếu bạn muốn sắp xếp theo thứ tự ngược lại, hãy chỉ định từ khóa
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}83dic_a['a'] = 'apple'print [dic_a]9
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
Sắp xếp sử dụng các giá trị
Để sắp xếp một từ điển dựa trên các giá trị của nó, bạn cần sử dụng chỉ mục “[1]” bên trong hàm lambda
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}08] Hiểu từ điển
Đây là một phương pháp rất hữu ích để tạo từ điển động. Giả sử bạn muốn tạo một từ điển trong đó khóa là một số nguyên và giá trị là hình vuông của nó. Một cách hiểu từ điển sẽ giống như sau
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}1Nếu bạn muốn khóa của mình là chuỗi, bạn có thể sử dụng “f-string”
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}29] Các cách khác để tạo từ điển
Tạo từ điển từ danh sách
Giả sử bạn có hai danh sách và bạn muốn tạo một từ điển từ chúng. Cách đơn giản nhất là sử dụng hàm tạo
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}84dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}3Bạn cũng có thể nén hai danh sách lại với nhau và tạo từ điển bằng cách sử dụng tính năng “hiểu từ điển” như đã trình bày trước đó
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}4Truyền cặp khóa-giá trị
Bạn cũng có thể chuyển danh sách các cặp khóa-giá trị được phân tách bằng dấu phẩy cho cấu trúc
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}84 và nó sẽ trả về một từ điểndic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}5Nếu các khóa của bạn là các chuỗi, bạn thậm chí có thể sử dụng cách khởi tạo đơn giản hơn bằng cách chỉ sử dụng các biến làm khóa
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}610] Sao chép từ điển
Tôi sẽ giải thích điểm này bằng một ví dụ đơn giản. Có nhiều sự phức tạp hơn liên quan đến cơ chế sao chép của từ điển và tôi khuyên người đọc nên tham khảo bài đăng Stack Overflow này để được giải thích chi tiết
bài tập tham khảo
Khi bạn chỉ cần gán lại một từ điển hiện có [từ điển mẹ] cho một từ điển mới, cả hai đều trỏ đến cùng một đối tượng [“gán tham chiếu”]
Xem xét ví dụ sau khi bạn gán lại
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}35 thành dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}34dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}7Bây giờ, nếu bạn sửa đổi
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}34[đối với e. g. thêm một phần tử mới], bạn sẽ nhận thấy rằng thay đổi cũng sẽ được phản ánh trong dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}35dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}8Bản sao nông
Một bản sao nông được tạo bằng hàm
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}90. Trong một bản sao nông, hai từ điển hoạt động như hai đối tượng độc lập, với nội dung của chúng vẫn chia sẻ cùng một tài liệu tham khảo. Nếu bạn thêm một cặp khóa-giá trị mới vào từ điển mới [bản sao nông], nó sẽ không hiển thị trong từ điển gốcdic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}9Bây giờ, nếu nội dung trong từ điển gốc [“dic_a”] sẽ thay đổi tùy thuộc vào loại giá trị. Chẳng hạn, trong phần sau, nội dung là các chuỗi đơn giản không thay đổi. Vì vậy, việc thay đổi giá trị trong “dic_b” cho một khóa đã cho [
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}7 trong trường hợp này] sẽ không thay đổi giá trị của khóa dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}7 trong “dic_a”dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}0Tuy nhiên, nếu giá trị của khóa
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}7 trong “dic_a” là một danh sách, thì việc thay đổi giá trị của nó trong “dic_b” sẽ phản ánh những thay đổi trong “dic_a” [từ điển gốc], vì danh sách có thể thay đổidic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}111] Đổi tên các khóa hiện có
Giả sử bạn muốn thay thế khóa “Adam” bằng “Alex”. Bạn có thể sử dụng hàm
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}94 vì nó xóa khóa đã truyền [“Adam” tại đây] và trả về giá trị đã xóa [85 tại đây]. Vì vậy, bạn giết hai con chim bằng một phát bắn duy nhất. Sử dụng giá trị trả về [đã xóa] để gán giá trị cho khóa mới [“Alex” tại đây]. Có thể có nhiều trường hợp phức tạp hơn khi khóa là một bộ. Những trường hợp như vậy nằm ngoài phạm vi của bài viết nàydic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}212] Từ điển lồng nhau
Một từ điển lồng nhau có một hoặc nhiều từ điển trong một từ điển. Sau đây là ví dụ đơn giản nhất về từ điển lồng nhau với hai lớp lồng nhau. Ở đây, từ điển bên ngoài [lớp 1] chỉ có một cặp khóa-giá trị. Tuy nhiên, giá trị bây giờ là một từ điển
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}3Nếu bạn muốn truy cập thêm cặp khóa-giá trị của từ điển bên trong [lớp 2], bây giờ bạn cần sử dụng
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}95 làm từ điểndic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}4Từ điển ba lớpHãy để chúng tôi thêm một lớp bổ sung của từ điển lồng nhau. Bây giờ, bản thân
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}95 là một từ điển lồng nhau, không giống như từ điển lồng nhau đơn giản nhất ở trêndic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}513] Kiểm tra xem khóa có tồn tại trong từ điển không
Bạn có thể tìm xem một khóa cụ thể có tồn tại trong từ điển hay không bằng cách sử dụng toán tử
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}97dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}6Trong đoạn mã trên, bạn không cần sử dụng “in dic_a. keys[ ]” bởi vì “in dic_a” đã tra cứu trong keys
Điều này đưa tôi đến cuối bài viết này. Bạn có thể truy cập phần đầu tiên của loạt bài này về “Cấu trúc dữ liệu trong Python” tại đây