Ảnh của Mathilde DeCourcelle trên undplash 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 là 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.dictionaries. This is the second article in the series named “Data Structures in Python”. The first part of this series was about lists. Từ điển là các 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 đặt hàng [các cặp giá trị khóa], có nghĩa là thứ tự không được bảo tồn. Các chìa khóa là bất biến. Giống như danh sách, các giá trị của từ điển có thể chứa dữ liệu không đồng nhất, tức là, số nguyên, phao, chuỗi, nan, booleans, danh sách, mảng và thậm chí từ điển lồng nhau.keys for indexing. They are an unordered sequence of items [key-value pairs], which means the order is not preserved. The keys are
immutable. Just like lists, the values of dictionaries can hold heterogeneous data i.e., integers, floats, strings, NaN, Booleans, lists, arrays, and even nested dictionaries. Bài viết này sẽ cung cấp cho bạn một sự hiểu biết rõ ràng và cho phép bạn làm việc thành thạo với từ điển Python. Python dictionaries. Các chủ đề sau đây được đề cập trong bài viết này:Một trong những cấu trúc dữ liệu quan trọng nhất trong Python
1] Tạo một từ điển và thêm các yếu 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 xoăn [{}]. Một từ điển trống, tất nhiên, không có chiều dài.
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 khóa có một giá trị tương ứng. Cả hai, khóa và giá trị, có thể là loại chuỗi, 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 giá trị khóa. Một từ điển bao gồm một hoặc nhiều cặp giá trị khóa.keys and values. Each key has a corresponding value. Both, the key and the value, can be of type string, float, integer, NaN, etc. Adding elements to a dictionary means adding a key-value pair. A dictionary is composed of one or more key-value pairs.
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à chìa 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 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'}
Lưu ý: Python nhạy cảm trường hợp, 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. Python being case-sensitive,
>>> 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}
7 and dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a.keys[]0 act as two different 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']]]
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 tìm thấy phương pháp trên để thêm các phần tử một cách 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 giá trị khóa.
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ó 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ù bạn nên sử dụng các tên có ý nghĩa cho các khóa khi chúng biểu thị các chỉ số của từ điển. Cụ thể, tránh sử dụng phao và np.nan làm chìa khóa.np.nan as keys.
2] Truy cập các yếu tố từ điển
Đã tạo ra từ điển của chúng tôi, chúng tôi hãy xem làm thế nào chúng tôi có thể truy cập các yếu 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ả các khóa và giá trị dưới dạng các bộ dữ liệu bằ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 một vòng lặp For For để truy cập/in cùng một lần.
# Printing keys
for key in dic_a.keys[]:
print [key, end=' ']
>>> A B C############################## Printing values
for key in dic_a.values[]:
print [key, end=' ']
>>> Apple Ball Cat
Bạn có thể tránh hai vòng lặp cho các vòng lặp 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 For For sẽ lặp lại thông qua các cặp giá trị khóa đượ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à 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_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}for key, value in dic_a.items[]:
print [key, value]
>>> A Apple
B Ball
C Cat
Truy cập các yếu tố cá nhân
Các mục từ điển không thể được truy cập bằng cách sử dụng lập chỉ mục giống như danh sách.
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]
>>> ----> 1 dic_a[0] KeyError: 0
Bạn cần sử dụng các khóa để truy cập các giá trị tương ứng từ từ điển.
# Accessing the value "Apple"
dic_a['A']
>>> 'Apple'# Accessing the value "Cat"
dic_a['C']
>>> 'Cat'
Bạ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 các lỗi chính như vậy trong trường hợp các khóa 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ả 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']]]
# 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 yếu tố từ điển như trong danh sách
Nếu bạn muốn truy cập các yếu tố từ điển [khóa hoặc giá trị] bằng các chỉ số, 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] Loại bỏ các yếu tố 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 giá trị khóa với nhau.
Sử dụng del
Bạn có thể xóa các phần tử từ điển bằng từ khóa
# Printing keys0 và khóa có giá trị bạn muốn xóa. Việc xóa là tại chỗ, điều đó có nghĩa là bạn không cần phải chỉ định lại giá trị của từ điển sau khi xóa.deletion is in-place, which means you do not need to re-assign the value of the dictionary after deletion.
for key in dic_a.keys[]:
print [key, end=' ']
>>> A B C############################## Printing values
for key in dic_a.values[]:
print [key, end=' ']
>>> Apple Ball Cat
# 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 hàm pop pop [] để xóa các phần tử. Nó trả về giá trị được bật ra [đã xóa] và từ điển được sửa đổi tại chỗ.modified in-place.
# 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ẽ nhận được một KeyError nếu khóa bị xóa không tồn tại trong từ điển. Trong trường hợp của pop pop [], bạn có thể chỉ định thông báo lỗi để 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 yếu tố
Không có cách trực tiếp nhưng bạn có thể sử dụng một vòng lặp cho vòng lặp như hình dưới đây.
# 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 yếu tố mới
Bạn có thể thêm một phần tử tại một thời điểm vào một từ điển đã hiện có như hình dưới đây.
# 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 tại 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 Update []
Bạn cũng có thể sử dụng chức năng
# Printing keys1 để thêm một cặp giá trị khóa mới bằng cách chuyển cặp làm đối số.
for key in dic_a.keys[]:
print [key, end=' ']
>>> A B C############################## Printing values
for key in dic_a.values[]:
print [key, end=' ']
>>> Apple Ball Cat
# 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
# Printing keys1 cũng cho phép bạn thêm nhiều cặp giá trị khóa đồng thời vào từ điển hiện có.
for key in dic_a.keys[]:
print [key, end=' ']
>>> A B C############################## Printing values
for key in dic_a.values[]:
print [key, end=' ']
>>> Apple Ball Cat
dic_a['a'] = 'apple'print [dic_a]0
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
5] Từ điển hợp nhất/nối
Bạn có thể hợp nhất hai hoặc nhiều từ điển bằng toán tử giải nén [
# Printing keys3] bắt đầu Python 3.5 trở đi.
for key in dic_a.keys[]:
print [key, end=' ']
>>> A B C############################## Printing values
for key in dic_a.values[]:
print [key, end=' ']
>>> Apple Ball Cat
dic_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 nhưng chỉ muốn thêm
# Printing keys4 cho
for key in dic_a.keys[]:
print [key, end=' ']
>>> A B C############################## Printing values
for key in dic_a.values[]:
print [key, end=' ']
>>> Apple Ball Cat
# Printing keys5 hiện tại, bạn chỉ cần cập nhật từ điển đầu tiên như được hiển thị trước đó.
for key in dic_a.keys[]:
print [key, end=' ']
>>> A B C############################## Printing values
for key in dic_a.values[]:
print [key, end=' ']
>>> Apple Ball Cat
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 kết nối?
Một trong những đặc điểm của từ điển Python là chúng không thể có các khóa trùng lặp, tức là, một khóa không thể xuất hiện hai lần. Vì vậy, điều gì 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.they cannot have duplicate keys i.e., a key cannot appear twice. So, what happens if you concatenate two or more dictionaries that have one or more common keys.
Câu trả lời là cặp giá trị khóa trong từ điển được hợp nhất cuối cùng [theo thứ tự sáp nhập] sẽ tồn tại. Trong ví dụ sau, Key
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 sáp nhập cuối cùng [# Printing keys7].
for key in dic_a.keys[]:
print [key, end=' ']
>>> A B C############################## Printing values
for key in dic_a.values[]:
print [key, end=' ']
>>> Apple Ball Cat
dic_a['a'] = 'apple'print [dic_a]3
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
Lời cảnh báo
Tôi chỉ nói rằng các từ điển không thể có các khóa trùng lặp. Nói đúng ra, bạn có thể xác định một từ điển với 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. Một hình dưới đây, chỉ các khóa duy nhất được trả về và đối với khóa trùng lặp [‘A ở đây], chỉ có 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ử
# Printing keys8 để nối hai hoặc nhiều từ điển.
for key in dic_a.keys[]:
print [key, end=' ']
>>> A B C############################## Printing values
for key in dic_a.values[]:
print [key, end=' ']
>>> Apple Ball Cat
dic_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_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}for key, value in dic_a.items[]:1, bạn có thể sử dụng một bài tập đơn giản.
print [key, value]
>>> A Apple
B Ball
C Cat
dic_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 một từ điển. Bạn có thể sắp xếp một từ điển bằng cách sử dụng các phím hoặc các giá trị bằng hàm
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}for key, value in dic_a.items[]:2.
print [key, value]
>>> A Apple
B Ball
C Cat
Sắp xếp bằng các phím
Nếu các phím 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 đối với các khóa, chúng tôi sử dụng phần tử đầu tiên, tức là các phím và do đó, chỉ số được sử dụng trong hàm Lambda là trên [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 phải là nơi. Như được hiển thị bên dưới, nếu bây giờ bạn in từ điển, nó vẫn chưa được đặt hàng, như khởi tạo ban đầu. Bạn sẽ phải gán 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, chỉ định từ khóa
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}for key, value in dic_a.items[]:3.
print [key, value]
>>> A Apple
B Ball
C Cat
dic_a['a'] = 'apple'print [dic_a]9
>>> {'A': 'Apple', 'B': 'Ball', 'a': 'apple'}
Sắp xếp bằ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] Từ điển Hiểu
Đó là một phương pháp rất hữu ích để tạo từ điển một cách linh hoạt. 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 sự hiểu biết từ điển sẽ trông giống như những điều sau đây. dynamically. Suppose you want to create a dictionary where the key is an integer and the value is its square. A dictionary comprehension would look like the following.
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}
1Nếu bạn muốn các phím của mình là chuỗi, bạn có thể sử dụng F-Strings.
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}
29] Các cách khác để tạo từ điển
Tạo một từ điển từ các danh sách
Giả sử bạn có hai danh sách và bạn muốn tạo một từ điển trong số chúng. Cách đơn giản nhất là sử dụng hàm tạo
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}for key, value in dic_a.items[]:4.
print [key, value]
>>> A Apple
B Ball
C Cat
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}
3Bạn cũng có thể zip hai danh sách lại với nhau và tạo từ điển bằng cách sử dụng từ điển hiểu từ điển như được hiển thị trước đó.
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}
4Vượt qua các cặp giá trị khóa
Bạn cũng có thể chuyển một danh sách các cặp giá trị khóa được phân tách bằng dấu phẩy cho cấu trúc
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}for key, value in dic_a.items[]:4 và nó sẽ trả về một từ điển.
print [key, value]
>>> A Apple
B Ball
C Cat
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}
5Nếu các khóa của bạn là chuỗi, bạn có thể sử dụng ngay cả khi khởi tạo đơn giản hơn chỉ bằng cá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ự tinh tế liên quan đến cơ chế sao chép từ điển, và, tôi khuyên người đọc nên chỉ bài đăng Overflow Stack này để 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 cha mẹ] cho một từ điển mới, cả hai đều chỉ ra cùng một đối tượng [gán tài liệu tham khảo của Hồi giáo].“reference assignment”].
Hãy xem xét ví dụ sau đây khi bạn gán lại
# Printing keys5 thành
for key in dic_a.keys[]:
print [key, end=' ']
>>> A B C############################## Printing values
for key in dic_a.values[]:
print [key, end=' ']
>>> Apple Ball Cat
# Printing keys4.
for key in dic_a.keys[]:
print [key, end=' ']
>>> A B C############################## Printing values
for key in dic_a.values[]:
print [key, end=' ']
>>> Apple Ball Cat
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}
7Bây giờ, nếu bạn sửa đổi ________ 64 [ví dụ: 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
# Printing keys5.
for key in dic_a.keys[]:
print [key, end=' ']
>>> A B C############################## Printing values
for key in dic_a.values[]:
print [key, end=' ']
>>> Apple Ball Cat
dic_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_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]0. Trong một bản sao nông, hai từ điển đóng vai trò là 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 giá trị khóa mới trong từ điển mới [bản sao nông], nó sẽ không hiển thị trong từ điển cha mẹ. same reference. If you add a new key-value pair in the new dictionary [shallow copy], it will not show up in the parent dictionary.
>>> ----> 1 dic_a[0] KeyError: 0
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}
9Bây giờ, nếu các nội dung trong từ điển cha mẹ [Hồi DIC_A,] sẽ thay đổi tùy thuộc vào loại giá trị. Ví dụ, trong phần sau, nội dung là các chuỗi đơn giản là bất biến. Vì vậy, thay đổi giá trị trong DIC DIC_B, đối với một khóa đã cho [
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}
7in 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 DIC_A.strings that are immutable. So changing the value in “dic_b” for a given key [dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}
7in this case] will not change the value of the key dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}
7 in “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 DIC_A là một danh sách, thì việc thay đổi giá trị của nó trong DIC DIC_B, sẽ phản ánh những thay đổi trong DIC DIC_A [từ điển cha mẹ], vì các danh sách có thể thay đổi.dic_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ế chìa khóa của Adam Adam bằng cách sử dụng Alex Alex. Bạn có thể sử dụng chức năng
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]4 vì nó xóa khóa được truyền [ở đây, Adam Adam] và trả về giá trị đã xóa [85 tại đây]. Vì vậy, bạn giết hai con chim chỉ bằng một phát bắn. Sử dụng giá trị được trả về [đã xóa] để gán giá trị cho khóa mới [Alex Alex ở đây]. Có thể có những trường hợp phức tạp hơn trong đó khóa là một tuple. Những trường hợp như vậy nằm ngoài phạm vi của bài viết này.
>>> ----> 1 dic_a[0] KeyError: 0
dic_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àm tổ. Ở đây, từ điển bên ngoài [Lớp 1] chỉ có một cặp giá trị khóa. 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 giá trị khóa của từ điển bên trong [Lớp 2], giờ đây bạn cần sử dụng
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]5 làm từ điển.
>>> ----> 1 dic_a[0] KeyError: 0
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}
4Từ điển ba lớp
Hãy để chúng tôi thêm một lớp bổ sung của từ điển lồng nhau. Bây giờ,
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]5 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ên.
>>> ----> 1 dic_a[0] KeyError: 0
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}
513] Kiểm tra xem một khóa có tồn tại trong từ điển không
Bạn có thể tìm thấy nếu một khóa cụ thể tồn tại trong một từ điển bằng toán tử
dic_a = {'A': 'Apple', 'B': 'Ball', 'C': 'Cat'}dic_a[0]7.
>>> ----> 1 dic_a[0] KeyError: 0
dic_b = {1: 'Ace', 'B': 123, np.nan: 99.9, 'D': np.nan, 'E': np.inf}
6Trong mã trên, bạn không cần phải sử dụng trên DIC_A.KEYS [] vì vì trong DIC_A, đã tìm kiếm trong các phím.
Điều này đưa tôi đến cuối bài viết này. Bạn có thể truy cập vào phần đầu tiên của loạt bài này trên các cấu trúc dữ liệu của Python tại đây.