Tên lớp ... ok:/ Giải pháp của tôi là tạo một lớp, với các tính năng Dict, nhưng được triển khai như một danh sách với các đối tượng {key, value}. Khóa và giá trị có thể là bất cứ điều gì sau đó.dict features, but implemented as a list with {key, value} objects. key and value can be anything then. class DictKeyDictException(Exception):
pass
class DictKeyDict():
def __init__(self, *args):
values = [self.__create_element(key, value) for key, value in args]
self.__values__ = values
def __setitem__(self, key, value):
self.set(key, value)
def __getitem__(self, key):
return self.get(key)
def __len__(self):
return len(self.__values__)
def __delitem__(self, key):
keys = self.keys()
if key in keys:
index = keys.index(key)
del self.__values__[index]
def clear(self):
self.__values__ = []
def copy(self):
return self.__values__.copy()
def has_key(self, k):
return k in self.keys()
def update(self, *args, **kwargs):
if kwargs:
raise DictKeyDictException(f"no kwargs allowed in '{self.__class__.__name__}.update' method")
for key, value in args:
self[key] = value
return self.__values__
def __repr__(self) -> list:
return repr(self.__values__)
@classmethod
def __create_element(cls, key, value):
return {"key": key, "value": value}
def set(self, key, value) -> None:
keys = self.keys()
if key in keys:
index = keys.index(key)
self.__values__[index] = self.__create_element(key, value)
else:
self.__values__.append(self.__create_element(key, value))
return self.__values__
def keys(self):
return [dict_key_value["key"] for dict_key_value in self.__values__]
def values(self):
return [value["value"] for value in self.__values__]
def items(self):
return [(dict_key_value["key"], dict_key_value["value"]) for dict_key_value in self.__values__]
def pop(self, key, default=None):
keys = self.keys()
if key in keys:
index = keys.index(key)
value = self.__values__.pop(index)["value"]
else:
value = default
return value
def get(self, key, default=None):
keys = self.keys()
if key in keys:
index = keys.index(key)
value = self.__values__[index]["value"]
else:
value = default
return value
def __iter__(self):
return iter(self.keys())
và cách sử dụng: dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
Hầu như bất kỳ loại giá trị nào cũng có thể được sử dụng làm khóa từ điển trong Python. Bạn thậm chí có thể sử dụng các đối tượng tích hợp như các loại và chức năng. Tuy nhiên, có một vài hạn chế rằng các khóa từ điển phải tuân thủ. Đầu tiên, một khóa nhất định chỉ có thể xuất hiện trong một từ điển một lần. Các khóa trùng lặp không được phép. Một từ điển ánh xạ từng khóa theo giá trị tương ứng, do đó, nó không có ý nghĩa gì khi ánh xạ một khóa cụ thể hơn một lần. Nếu bạn chỉ định khóa lần thứ hai trong quá trình tạo từ điển ban đầu, thì lần xuất hiện thứ hai sẽ ghi đè lên thứ nhất. Thứ hai, một khóa từ điển phải thuộc loại bất biến. Ví dụ: bạn có thể sử dụng số nguyên, phao, chuỗi hoặc boolean làm khóa từ điển. Tuy nhiên, cả danh sách và từ điển khác đều không thể đóng vai trò là khóa từ điển, bởi vì danh sách và từ điển đều có thể thay đổi. Mặt khác, các giá trị có thể là bất kỳ loại nào và có thể được sử dụng nhiều lần. Trong Python, chúng tôi sử dụng từ điển để kiểm tra xem có mặt hàng hay không. Từ điển sử dụng khóa: cặp giá trị để tìm kiếm nếu có một khóa hay không và nếu khóa có giá trị của nó là gì. Chúng ta có thể sử dụng số nguyên, chuỗi, bộ dữ liệu làm khóa từ điển nhưng không thể sử dụng danh sách làm khóa của nó. Lý do được giải thích dưới đây.key:value pair to search if a key is present or not and if the key is present what is its value . We can use integer, string, tuples as dictionary keys but cannot use list as a key of it . The reason is explained below . Làm thế nào để từ điển Python tìm kiếm các khóa của họ & nbsp; & nbsp; Nếu từ điển Python chỉ lặp lại các khóa của chúng để kiểm tra xem các khóa đã cho có có hay không, nó sẽ mất thời gian O (N). Nhưng từ điển Python mất O (1) để kiểm tra xem khóa có hay không. Vì vậy, cách từ điển tìm kiếm khóa, cho mỗi khóa mà nó tạo ra giá trị băm cho khóa và bằng giá trị băm này, nó có thể theo dõi các yếu tố của nó.O(N) time. But python dictionaries take O(1) to check if the key is present or not. So, how dictionaries search the key, for every key it generates a hash value for the key and by this hash value, it can track its elements. Các vấn đề nếu danh sách được sử dụng như một khóa của từ điển & nbsp; & nbsp; Danh sách là các đối tượng có thể thay đổi có nghĩa là chúng ta có thể thay đổi các giá trị bên trong danh sách nối thêm hoặc xóa các giá trị của danh sách. Vì vậy, nếu một hàm băm được tạo từ một danh sách và sau đó các mục của danh sách đã thay đổi, từ điển sẽ tạo ra một giá trị băm mới cho danh sách này và không thể tìm thấy nó. Ví dụ: nếu danh sách là a = [1, 2, 3, 4, 5] và giả sử băm của một danh sách là tổng các giá trị bên trong danh sách. Vì vậy, băm (a) = 15. Bây giờ chúng tôi nối 6 vào a. Vì vậy, a = [1, 2, 3, 4, 5, 6] băm (a) = 21. Vì vậy, giá trị băm của một thay đổi. Do đó, nó không thể được tìm thấy bên trong từ điển. Một vấn đề khác là các danh sách khác nhau với cùng giá trị băm. Nếu b = [5, 5, 5] băm (b) = 15. Vì vậy, nếu A (từ ví dụ trên có cùng giá trị băm) có mặt bên trong từ điển và nếu chúng ta tìm kiếm b. Sau đó, từ điển có thể cho chúng ta kết quả sai. Làm thế nào để đối phó với điều này & nbsp;
Chúng ta có thể thay đổi danh sách thành các đối tượng bất biến như chuỗi hoặc tuple và sau đó có thể sử dụng nó làm khóa. & nbsp; Dưới đây là việc thực hiện phương pháp. & nbsp;
d = {}
dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
0=dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
2dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
3dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
4dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
5dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
4dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
7dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
4dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
9dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
4[1, 2, 3, 4, 5] : 1
(1, 2, 3, 4, 5) : 1 1[1, 2, 3, 4, 5] : 1
(1, 2, 3, 4, 5) : 1 2[1, 2, 3, 4, 5] : 1
(1, 2, 3, 4, 5) : 1 3= [1, 2, 3, 4, 5] : 1
(1, 2, 3, 4, 5) : 1 5[1, 2, 3, 4, 5] : 1
(1, 2, 3, 4, 5) : 1 6[1, 2, 3, 4, 5] : 1
(1, 2, 3, 4, 5) : 1 7= dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
3{key, value}0____8 {key, value}2{key, value}3
{key, value}4=
dad = {"name": "dad"}
mom = {"name": "mom"}
boy = {"name": "son"}
girl = {"name": "daughter"}
# set
family = DictKeyDict()
family[dad] = {"age": 44}
family[mom] = {"age": 43}
# or
family.set(dad, {"age": 44, "children": [boy, girl]})
# or
family = DictKeyDict(
(dad, {"age": 44, "children": [boy, girl]}),
(mom, {"age": 43, "children": [boy, girl]}),
)
# update
family.update((mom, {"age": 33})) # oups sorry miss /!\ loose my children
family.set({"pet": "cutty"}, "cat")
del family[{"pet": "cutty"}] # cutty left...
family.set({"pet": "buddy"}, "dog")
family[{"pet": "buddy"}] = "wolf" # buddy was not a dog
print(family.keys())
print(family.values())
for k, v in family.items():
print(k, v)
3{key, value}7 {key, value}8{key, value}9 a = [1, 2, 3, 4, 5]0
a = [1, 2, 3, 4, 5]1a = [1, 2, 3, 4, 5]2a = [1, 2, 3, 4, 5]3a = [1, 2, 3, 4, 5]4a = [1, 2, 3, 4, 5]5
Output:
Output: [1, 2, 3, 4, 5] : 1
(1, 2, 3, 4, 5) : 1
Một từ điển có thể là một chìa khóa trong Python?
Một từ điển hoặc một danh sách không thể là một chìa khóa. Mặt khác, các giá trị có thể là bất cứ điều gì và chúng có thể được sử dụng nhiều lần.. Values, on the other hand, can literally be anything and they can be used more than once.
Có thể một chìa khóa
Một giá trị trong cặp giá trị khóa có thể là một số, chuỗi, danh sách, một tuple hoặc thậm chí từ điển khác.Trên thực tế, bạn có thể sử dụng giá trị của bất kỳ loại hợp lệ nào trong Python làm giá trị trong cặp giá trị khóa.Một chìa khóa trong cặp giá trị khóa phải là bất biến.. In fact, you can use a value of any valid type in Python as the value in the key-value pair. A key in the key-value pair must be immutable.
Một từ điển Python có thể có một bộ điều khiển không?
Sử dụng một bộ tuple làm khóa trong Python, bạn có thể sử dụng một bộ tuple làm chìa khóa nếu tất cả các yếu tố có trong tuple là bất biến..You can use a tuple as a key if all of the elements contained in the tuple are immutable. (If the tuple contains mutable objects, it cannot be used as a key.) Hence a tuple to be used as a key can contain strings, numbers, and other tuples containing references to immutable objects.
Bạn có thể nhận được chìa khóa từ giá trị trong từ điển Python không?
Phương pháp 1: Nhận khóa bằng giá trị bằng cách sử dụng danh sách hiểu.Một danh sách hiểu bao gồm các dấu ngoặc chứa biểu thức, được thực thi cho mỗi phần tử cùng với vòng lặp để lặp lại trên mỗi phần tử trong danh sách Python để lấy khóa từ một giá trị trong từ điển.Get the key by value using list comprehension. A list comprehension consists of brackets containing the expression, which is executed for each element along with the for loop to iterate over each element in the Python list to get the key from a value in Dictionary. |
