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
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']0 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;
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']1Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']3Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']4Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']6Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']7Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']8Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']9Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']8dict_keys[[1, 2, 3]]1
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']8dict_keys[[1, 2, 3]]3
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']8dict_keys[[1, 2, 3]]5
dict_keys[[1, 2, 3]]6
dict_keys[[1, 2, 3]]7
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 dict_keys[[1, 2, 3]]9
[1, 2, 3]0
[1, 2, 3]1
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']7[1, 2, 3]4
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 [1, 2, 3]6
[1, 2, 3]7
[1, 2, 3]8
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']7[1, 2, 3]1
[1, 2, 3]2
[1, 2, 3]3
[1, 2, 3]4
[1, 2, 3]5
[1, 2, 3]6
[1, 2, 3]7
[1, 2, 3]8
[1, 2, 3]9
Output:
Output:
[1, 2, 3, 4, 5] : 1 [1, 2, 3, 4, 5] : 1
Đưa ra một từ điển, hãy viết một chương trình Python để lấy các khóa từ điển làm danh sách. & NBSP;
Examples:
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']Phương thức & NBSP; 1: Nhận các khóa từ điển làm danh sách bằng Dict.Keys [] Get dictionary keys as a list using dict.keys[]
Phương thức Dict.Keys [] trong Từ điển Python, trả về một đối tượng Xem hiển thị danh sách tất cả các khóa trong từ điển theo thứ tự chèn.
Python3
[1, 2, 3]0
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 [1, 2, 3]2
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']7[1, 2, 3]4
[1, 2, 3]55518
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']9[1, 2, 3]4
[1, 2, 3]9__18__18
[1, 2, 3]6
['a', 'b', 'c']6
[1, 2, 3]0
['a', 'b', 'c']8
Output:
dict_keys[[1, 2, 3]]
Phương pháp 2: Nhận các khóa từ điển làm danh sách bằng Dict.Keys [] Get dictionary keys as a list using dict.keys[]
Hàm danh sách Python [] lấy bất kỳ tham số nào và trả về danh sách. Trong Python Itable là đối tượng bạn có thể lặp lại.
Python3
['a', 'b', 'c']9
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 [1, 2, 3]22
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']7[1, 2, 3]4__55555
a = [1, 2, 3, 4, 5]4
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 a = [1, 2, 3, 4, 5]6a = [1, 2, 3, 4, 5]7[1, 2, 3]6
a = [1, 2, 3, 4, 5]9Output:
[1, 2, 3]
Phương thức & NBSP; 3: Nhận các khóa từ điển làm danh sách sử dụng cho phương thức vòng lặp và nối Get dictionary keys as a list using For Loop and append method
Trong phương thức này, chúng tôi sẽ lặp lại từng khóa bằng cách sử dụng hàm Dict.Keys [] và nối chúng vào một danh sách mới có tên là Danh sách.
Python3
a = [1, 2, 3, 4, 5, 6]0 a = [1, 2, 3, 4, 5, 6]1
[1, 2, 3]0
a = [1, 2, 3, 4, 5, 6]3[1, 2, 3]5
a = [1, 2, 3, 4, 5]6 Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 a = [1, 2, 3, 4, 5, 6]7[1, 2, 3]5
[1, 2, 3]1
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']00[1, 2, 3]3
[1, 2, 3]0
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']03Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']04a = [1, 2, 3, 4, 5]6Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']06[1, 2, 3]5
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']08 a = [1, 2, 3, 4, 5]6[1, 2, 3]0
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 [1, 2, 3]2
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']7Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']14[1, 2, 3]5
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']8Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']9Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']14[1, 2, 3]9__18__18
[1, 2, 3]6
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']26[1, 2, 3]0
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']28Output:
[1, 2, 3]
Phương pháp 4: & NBSP; Khóa từ điển để liệt kê bằng cách sử dụng danh sách hiểu biết
Ở đây, chúng tôi sẽ cố gắng rút ngắn mã của chúng tôi bằng cách sử dụng danh sách hiểu trong Python.
Python3
[1, 2, 3]0
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 [1, 2, 3]2
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']7[1, 2, 3]4
[1, 2, 3]55518
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']9[1, 2, 3]4
[1, 2, 3]9__18__18
Phương pháp 2: Nhận các khóa từ điển làm danh sách bằng Dict.Keys []
[1, 2, 3]6
a = [1, 2, 3, 4, 5]9Output:
[1, 2, 3]
Hàm danh sách Python [] lấy bất kỳ tham số nào và trả về danh sách. Trong Python Itable là đối tượng bạn có thể lặp lại. Dictionary Keys to List using Unpacking with *
['a', 'b', 'c']9
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 [1, 2, 3]22
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']7[1, 2, 3]4__55555
Python3
a = [1, 2, 3, 4, 5, 6]0 a = [1, 2, 3, 4, 5, 6]1
[1, 2, 3]0
a = [1, 2, 3, 4, 5, 6]3a = [1, 2, 3, 4, 5]4
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 a = [1, 2, 3, 4, 5]6a = [1, 2, 3, 4, 5]7[1, 2, 3]0
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 [1, 2, 3]2
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']67[1, 2, 3]4__55555
[1, 2, 3]6
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']26[1, 2, 3]0
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']28Output:
['a', 'b', 'c']
[1, 2, 3]
Dictionary Keys to List using itemgetter
Phương thức & NBSP; 3: Nhận các khóa từ điển làm danh sách sử dụng cho phương thức vòng lặp và nối
Python3
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']83 Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']84Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']85 Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']86a = [1, 2, 3, 4, 5, 6]0 a = [1, 2, 3, 4, 5, 6]1
[1, 2, 3]0
a = [1, 2, 3, 4, 5, 6]3[1, 2, 3]5
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']08 a = [1, 2, 3, 4, 5]6['a', 'b', 'c']6
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']95Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']96Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']97Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']98[1, 2, 3]0____
dict_keys[[1, 2, 3]]00
[1, 2, 3]0
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']2 [1, 2, 3]2
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']67[1, 2, 3]4__55555
[1, 2, 3]6
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']26[1, 2, 3]0
Input : {1:'a', 2:'b', 3:'c'}
Output : [1, 2, 3]
Input : {'A' : 'ant', 'B' : 'ball'}
Output : ['A', 'B']28Output:
['a', 'b', 'c']