Hướng dẫn how do i manually sort a dictionary in python? - làm cách nào để sắp xếp thủ công từ điển trong python?

Cập nhật câu trả lời cho Python 3.6+

Show
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> {k: d[k] for k in keyorder if k in d}
{'ZT21': 14, '10': -10, 'WX21': 12, 'UM': -25, '5': -3, '2': 15}

Legacy Trả lời: Từ điển trong Python không được đặt hàng (trước Python3.6). Bạn có thể nhận được kết quả bạn cần dưới dạng

>>> from collections import OrderedDict
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.index(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
9

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]

hoặc như một đơn đặt hàng

>>> from collections import OrderedDict
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.index(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])

Nếu bạn đang làm rất nhiều trong số này, sẽ hiệu quả hơn khi sử dụng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
0 cho KeyOrder

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])

Bạn đã có một từ điển, nhưng bạn muốn sắp xếp các cặp giá trị khóa. Có lẽ bạn đã thử chuyển một từ điển cho hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 nhưng thiên đường đã nhận được kết quả mà bạn mong đợi. Trong hướng dẫn này, bạn sẽ đi qua mọi thứ bạn cần biết nếu bạn muốn sắp xếp từ điển trong Python.

Trong hướng dẫn này, bạn sẽ::

  • Xem lại cách sử dụng chức năng
    >>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
    >>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
    OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
    
    1
    >>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
    >>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
    OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
    
    1
    function
  • Tìm hiểu làm thế nào để có được chế độ xem từ điển để lặp lạiviews to iterate over
  • Hiểu cách từ điển được đưa vào danh sách trong quá trình sắp xếplists during sorting
  • Tìm hiểu cách chỉ định khóa sắp xếp để sắp xếp từ điển theo giá trị, khóa hoặc thuộc tính lồng nhausort key to sort a dictionary by value, key, or nested attribute
  • Xem lại sự hiểu biết từ điển và trình xây dựng
    >>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
    >>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
    OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
    
    3 để xây dựng lại từ điển của bạncomprehensions and the
    >>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
    >>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
    OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
    
    3 constructor to rebuild your dictionaries
  • Xem xét các cấu trúc dữ liệu thay thế cho dữ liệu giá trị khóa của bạndata structures for your key-value data

Trên đường đi, bạn cũng sẽ sử dụng mô-đun

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
4 theo thời gian mã của bạn và nhận kết quả hữu hình để so sánh các phương pháp phân loại dữ liệu giá trị khóa khác nhau. Bạn cũng sẽ xem xét liệu một từ điển được sắp xếp có thực sự là lựa chọn tốt nhất của bạn hay không, vì nó không phải là một mô hình đặc biệt phổ biến.

Để tận dụng tối đa hướng dẫn này, bạn nên biết về từ điển, danh sách, bộ dữ liệu và chức năng. Với kiến ​​thức đó, bạn sẽ có thể sắp xếp từ điển vào cuối hướng dẫn này. Một số tiếp xúc với các chức năng bậc cao, chẳng hạn như các hàm Lambda, cũng sẽ có ích nhưng không phải là một yêu cầu.

Đầu tiên, bạn sẽ học được một số kiến ​​thức nền tảng trước khi cố gắng sắp xếp một từ điển trong Python.

Đơn đặt hàng từ điển khám phá lại ở Python

Trước Python 3.6, từ điển vốn đã không được đặt hàng. Một từ điển Python là một triển khai của bảng băm, theo truyền thống là một cấu trúc dữ liệu không có thứ tự.unordered. A Python dictionary is an implementation of the hash table, which is traditionally an unordered data structure.

Là một tác dụng phụ của việc thực hiện từ điển nhỏ gọn trong Python 3.6, từ điển bắt đầu bảo tồn thứ tự chèn. Từ 3.7, thứ tự chèn đó đã được đảm bảo.

Nếu bạn muốn giữ một từ điển được đặt hàng làm cấu trúc dữ liệu trước các từ điển nhỏ gọn, thì bạn có thể sử dụng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
5 từ mô -đun
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
6. Tương tự như từ điển nhỏ gọn hiện đại, nó cũng giữ thứ tự chèn, nhưng không loại từ điển nào tự sắp xếp.

Một cách khác để lưu trữ dữ liệu cặp có giá trị khóa được đặt hàng là lưu trữ các cặp dưới dạng danh sách các bộ dữ liệu. Như bạn sẽ thấy sau trong hướng dẫn, sử dụng danh sách các bộ dữ liệu có thể là lựa chọn tốt nhất cho dữ liệu của bạn.

Một điểm thiết yếu để hiểu khi sắp xếp từ điển là mặc dù chúng bảo tồn thứ tự chèn, nhưng chúng không được coi là một chuỗi. Một từ điển giống như một tập hợp các cặp giá trị khóa và các bộ không được đặt hàng.

Từ điển cũng không có nhiều chức năng sắp xếp lại. Họ không thích danh sách, nơi bạn có thể chèn các yếu tố ở bất kỳ vị trí nào. Trong phần tiếp theo, bạn sẽ khám phá hậu quả của giới hạn này hơn nữa.insert elements at any position. In the next section, you’ll explore the consequences of this limitation further.

Hiểu phân loại từ điển thực sự có nghĩa là gì

Bởi vì từ điển don lồng có nhiều chức năng sắp xếp lại, khi sắp xếp từ điển, nên nó hiếm khi được thực hiện tại chỗ. Trong thực tế, không có phương pháp để di chuyển rõ ràng trong từ điển.in-place. In fact, there are no methods for explicitly moving items in a dictionary.

Nếu bạn muốn sắp xếp một từ điển tại chỗ, thì bạn phải sử dụng từ khóa

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
7 để xóa một mục khỏi từ điển và sau đó thêm lại. Xóa và sau đó thêm lại hiệu quả di chuyển cặp giá trị khóa vào cuối.

Lớp

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
5 có một phương pháp cụ thể để di chuyển một mục đến cuối hoặc bắt đầu, có thể làm cho
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
5 thích hợp hơn để giữ một từ điển được sắp xếp. Tuy nhiên, nó vẫn không phổ biến lắm và không có hiệu suất, để nói rằng ít nhất.

Phương pháp điển hình để sắp xếp từ điển là để có được một chế độ xem từ điển, sắp xếp nó và sau đó đưa danh sách kết quả trở lại từ một từ điển. Vì vậy, bạn thực sự đi từ một từ điển đến một danh sách và trở lại từ điển. Tùy thuộc vào trường hợp sử dụng của bạn, bạn có thể không cần chuyển đổi danh sách trở lại từ điển.view, sort it, and then cast the resulting list back into a dictionary. So you effectively go from a dictionary to a list and back into a dictionary. Depending on your use case, you may not need to convert the list back into a dictionary.

Với những sơ bộ ngoài đường, bạn sẽ được sắp xếp từ điển trong phần tiếp theo.

Sắp xếp từ điển trong Python

Trong phần này, bạn sẽ kết hợp các thành phần sắp xếp từ điển để cuối cùng, bạn có thể làm chủ cách phổ biến nhất để sắp xếp từ điển:

>>>

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}

Don Tiết lo lắng nếu bạn không hiểu các đoạn trích bên trên, bạn sẽ xem xét tất cả từng bước trong các phần sau. Trên đường đi, bạn sẽ học cách sử dụng chức năng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 với các khóa sắp xếp, hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
1 và các hàm tạo từ điển.

Sử dụng hàm >>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])} >>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0]))) OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]) 1

Chức năng quan trọng mà bạn sẽ sử dụng để sắp xếp từ điển là hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 tích hợp. Hàm này lấy một điều đáng chú ý làm đối số chính, với hai đối số chỉ từ khóa tùy chọn, một hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 và giá trị boolean
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
5.

Để minh họa cho chức năng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 hành vi của LỚN trong sự cô lập, hãy kiểm tra việc sử dụng nó trong danh sách các số:

>>>

>>> numbers = [5, 3, 4, 3, 6, 7, 3, 2, 3, 4, 1]
>>> sorted(numbers)
[1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7]

Don Tiết lo lắng nếu bạn không hiểu các đoạn trích bên trên, bạn sẽ xem xét tất cả từng bước trong các phần sau. Trên đường đi, bạn sẽ học cách sử dụng chức năng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 với các khóa sắp xếp, hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
1 và các hàm tạo từ điển.comparable elements like numbers in ascending order, and returns a new list. With strings, it sorts them in alphabetical order:

>>>

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']

Don Tiết lo lắng nếu bạn không hiểu các đoạn trích bên trên, bạn sẽ xem xét tất cả từng bước trong các phần sau. Trên đường đi, bạn sẽ học cách sử dụng chức năng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 với các khóa sắp xếp, hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
1 và các hàm tạo từ điển.

Giả sử bạn muốn sắp xếp trên ký tự thứ hai của mỗi từ trong ví dụ cuối cùng. Để tùy chỉnh những gì hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 sử dụng để sắp xếp các phần tử, bạn có thể chuyển trong hàm gọi lại cho tham số
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4.

Chức năng gọi lại là một hàm mà truyền qua như một đối số cho một hàm khác. Đối với

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1, bạn chuyển nó một hàm hoạt động như một phím sắp xếp. Hàm
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 sau đó sẽ gọi lại phím sắp xếp cho mọi phần tử.

Trong ví dụ sau, hàm được truyền khi khóa chấp nhận một chuỗi và sẽ trả về ký tự thứ hai của chuỗi đó:

>>>

>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']

Hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 truyền mọi yếu tố của
>>> numbers = [5, 3, 4, 3, 6, 7, 3, 2, 3, 4, 1]
>>> sorted(numbers)
[1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7]
3 có thể sử dụng được cho hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 và sử dụng giá trị trả về để so sánh. Sử dụng khóa có nghĩa là hàm
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 sẽ so sánh chữ cái thứ hai thay vì so sánh toàn bộ chuỗi.

Nhiều ví dụ và giải thích về tham số

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 sẽ đến sau trong hướng dẫn khi bạn sử dụng nó để sắp xếp từ điển theo các giá trị hoặc các phần tử lồng nhau.

Nếu bạn có cái nhìn khác về kết quả của việc sắp xếp cuối cùng này, bạn có thể nhận thấy sự ổn định của hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1. Ba yếu tố,
>>> numbers = [5, 3, 4, 3, 6, 7, 3, 2, 3, 4, 1]
>>> sorted(numbers)
[1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7]
8,
>>> numbers = [5, 3, 4, 3, 6, 7, 3, 2, 3, 4, 1]
>>> sorted(numbers)
[1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7]
9 và
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
0, tương đương khi được sắp xếp theo ký tự thứ hai của chúng. Bởi vì chúng bằng nhau, hàm
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 bảo tồn thứ tự ban đầu của họ. Python đảm bảo sự ổn định này.

Vậy, làm thế nào về từ điển? Bạn thực sự có thể lấy từ điển và đưa nó thẳng vào hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1:

>>>

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people)
[1, 2, 3, 4]

Hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 truyền mọi yếu tố của
>>> numbers = [5, 3, 4, 3, 6, 7, 3, 2, 3, 4, 1]
>>> sorted(numbers)
[1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7]
3 có thể sử dụng được cho hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 và sử dụng giá trị trả về để so sánh. Sử dụng khóa có nghĩa là hàm
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 sẽ so sánh chữ cái thứ hai thay vì so sánh toàn bộ chuỗi.keys of the dictionary, sort them, and return a list of the keys only. That’s probably not the behavior you had in mind! To preserve all the information in a dictionary, you’ll need to be acquainted with dictionary views.

Nhiều ví dụ và giải thích về tham số >>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"} >>> # Sort by key >>> dict(sorted(people.items())) {1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'} >>> # Sort by value >>> dict(sorted(people.items(), key=lambda item: item[1])) {2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'} 4 sẽ đến sau trong hướng dẫn khi bạn sử dụng nó để sắp xếp từ điển theo các giá trị hoặc các phần tử lồng nhau.

Nếu bạn có cái nhìn khác về kết quả của việc sắp xếp cuối cùng này, bạn có thể nhận thấy sự ổn định của hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1. Ba yếu tố,
>>> numbers = [5, 3, 4, 3, 6, 7, 3, 2, 3, 4, 1]
>>> sorted(numbers)
[1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7]
8,
>>> numbers = [5, 3, 4, 3, 6, 7, 3, 2, 3, 4, 1]
>>> sorted(numbers)
[1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7]
9 và
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
0, tương đương khi được sắp xếp theo ký tự thứ hai của chúng. Bởi vì chúng bằng nhau, hàm
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 bảo tồn thứ tự ban đầu của họ. Python đảm bảo sự ổn định này.

>>>

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])

Hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 truyền mọi yếu tố của
>>> numbers = [5, 3, 4, 3, 6, 7, 3, 2, 3, 4, 1]
>>> sorted(numbers)
[1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7]
3 có thể sử dụng được cho hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 và sử dụng giá trị trả về để so sánh. Sử dụng khóa có nghĩa là hàm
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 sẽ so sánh chữ cái thứ hai thay vì so sánh toàn bộ chuỗi.

>>>

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
0

Hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 truyền mọi yếu tố của
>>> numbers = [5, 3, 4, 3, 6, 7, 3, 2, 3, 4, 1]
>>> sorted(numbers)
[1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7]
3 có thể sử dụng được cho hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 và sử dụng giá trị trả về để so sánh. Sử dụng khóa có nghĩa là hàm
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 sẽ so sánh chữ cái thứ hai thay vì so sánh toàn bộ chuỗi.

Nhiều ví dụ và giải thích về tham số

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 sẽ đến sau trong hướng dẫn khi bạn sử dụng nó để sắp xếp từ điển theo các giá trị hoặc các phần tử lồng nhau.

>>>

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
1

Hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 truyền mọi yếu tố của
>>> numbers = [5, 3, 4, 3, 6, 7, 3, 2, 3, 4, 1]
>>> sorted(numbers)
[1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7]
3 có thể sử dụng được cho hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 và sử dụng giá trị trả về để so sánh. Sử dụng khóa có nghĩa là hàm
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 sẽ so sánh chữ cái thứ hai thay vì so sánh toàn bộ chuỗi.

Nhiều ví dụ và giải thích về tham số

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 sẽ đến sau trong hướng dẫn khi bạn sử dụng nó để sắp xếp từ điển theo các giá trị hoặc các phần tử lồng nhau.

Nếu bạn có cái nhìn khác về kết quả của việc sắp xếp cuối cùng này, bạn có thể nhận thấy sự ổn định của hàm >>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])} >>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0]))) OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]) 1. Ba yếu tố, >>> numbers = [5, 3, 4, 3, 6, 7, 3, 2, 3, 4, 1] >>> sorted(numbers) [1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7] 8, >>> numbers = [5, 3, 4, 3, 6, 7, 3, 2, 3, 4, 1] >>> sorted(numbers) [1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7] 9 và >>> words = ["aa", "ab", "ac", "ba", "cb", "ca"] >>> sorted(words) ['aa', 'ab', 'ac', 'ba', 'ca', 'cb'] 0, tương đương khi được sắp xếp theo ký tự thứ hai của chúng. Bởi vì chúng bằng nhau, hàm >>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])} >>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0]))) OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]) 1 bảo tồn thứ tự ban đầu của họ. Python đảm bảo sự ổn định này.

Vậy, làm thế nào về từ điển? Bạn thực sự có thể lấy từ điển và đưa nó thẳng vào hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1:

Nhưng hành vi mặc định của việc truyền từ điển trực tiếp đến hàm

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 là lấy các khóa của từ điển, sắp xếp chúng và chỉ trả lại danh sách các khóa. Đó có lẽ không phải là hành vi bạn có trong tâm trí! Để lưu giữ tất cả các thông tin trong từ điển, bạn sẽ cần phải làm quen với các chế độ xem từ điển.

Nhận chìa khóa, giá trị hoặc cả hai từ một từ điển means that if you have two tuples,

>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
4 and
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
5, then you start by comparing the first item of each tuple. The first item is
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
6 in both cases, which is equal. The second element,
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
7, is also identical in both cases. The third elements are
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
8 and
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
9, respectively. Since
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
9 is less than
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
8, you’ve found which item is less than the other.

Nếu bạn muốn bảo tồn tất cả thông tin từ một từ điển khi sắp xếp nó, bước đầu tiên điển hình là gọi phương thức

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
4 trên từ điển. Gọi
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
4 trên từ điển sẽ cung cấp một bộ dữ liệu khác nhau đại diện cho các cặp giá trị khóa:

Phương thức

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
4 trả về một đối tượng Chế độ xem từ điển chỉ đọc, phục vụ như một cửa sổ vào từ điển. Quan điểm này không phải là một bản sao hay một danh sách, nó là một điều không thể đọc được chỉ có thể đọc được mà thực sự liên kết với từ điển mà nó được tạo ra từ:

Bạn có thể nhận thấy rằng bất kỳ cập nhật nào cho từ điển cũng được phản ánh trong chế độ xem bởi vì chúng được liên kết. Một chế độ xem đại diện cho một cách nhẹ để lặp lại một từ điển mà không tạo ra một danh sách trước.

Điều quan trọng, bạn có thể sử dụng chức năng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 với các chế độ xem từ điển. Bạn gọi phương thức
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
4 và sử dụng kết quả làm đối số cho hàm
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1. Sử dụng
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
4 giữ tất cả thông tin từ từ điển:sort key. A sort key is a way to extract a comparable value. For instance, if you have a pile of books, then you might use the author surname as the sort key. With the
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 function, you can specify a sort key by passing a callback function as a
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 argument.

Để xem một khóa sắp xếp trong hành động, hãy xem ví dụ này, tương tự như cái bạn thấy trong phần giới thiệu chức năng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1:

>>>

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
2

Trong ví dụ này, bạn thử hai cách vượt qua tham số

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4. Tham số
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 chấp nhận chức năng gọi lại. Hàm có thể là một định danh chức năng bình thường hoặc hàm lambda. Hàm Lambda trong ví dụ là tương đương chính xác của hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
4.

Hàm gọi lại

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 sẽ nhận được từng yếu tố của điều đó mà nó sắp xếp. Chức năng gọi lại của công việc là trả về một cái gì đó có thể được so sánh, chẳng hạn như số hoặc một chuỗi. Trong ví dụ này, bạn đã đặt tên cho hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
4 vì tất cả những gì nó làm là nhận được giá trị từ một tuple giá trị khóa.

Vì hành vi mặc định của

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 với các bộ dữ liệu là sắp xếp từ vựng, tham số
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
4 cho phép bạn chọn một giá trị từ phần tử mà nó so sánh.

Trong phần tiếp theo, bạn sẽ lấy các phím sắp xếp xa hơn một chút và sử dụng chúng để sắp xếp theo giá trị lồng nhau.

Chọn một giá trị lồng nhau với một phím sắp xếp

Bạn cũng có thể đi xa hơn và sử dụng khóa sắp xếp để chọn các giá trị lồng nhau có thể có hoặc không có mặt và trả về giá trị mặc định nếu chúng không có mặt:

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
3

Trong ví dụ này, bạn có một từ điển với các khóa số và từ điển lồng nhau là một giá trị. Bạn muốn sắp xếp theo các kỹ năng Python và JavaScript kết hợp, các thuộc tính được tìm thấy trong bộ phụ

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
9.

Một phần của những gì làm cho việc sắp xếp theo kỹ năng kết hợp trở nên khó khăn là các phím

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
00 và ____101 aren có mặt trong từ điển
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
9 cho tất cả mọi người. Từ điển
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
9 cũng được lồng. Bạn sử dụng
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
04 để đọc các khóa và cung cấp
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
05 như một giá trị mặc định mà Lừa sử dụng cho các kỹ năng bị thiếu.

Bạn cũng đã sử dụng đối số

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}

>>> # Sort by key
>>> dict(sorted(people.items()))
{1: 'Jill', 2: 'Jack', 3: 'Jim', 4: 'Jane'}

>>> # Sort by value
>>> dict(sorted(people.items(), key=lambda item: item[1]))
{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}
5 vì bạn muốn các kỹ năng Python hàng đầu xuất hiện đầu tiên.

Bạn đã sử dụng thành công chức năng bậc cao như một khóa sắp xếp để sắp xếp chế độ xem từ điển theo giá trị. Đó là phần khó khăn. Bây giờ, chỉ còn một vấn đề để giải quyết việc đảo ngược danh sách mà

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 mang lại từ một từ điển.

Chuyển đổi trở lại từ điển

Vấn đề duy nhất còn lại để giải quyết với hành vi mặc định của

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1 là nó trả về một danh sách, không phải là một từ điển. Có một vài cách để chuyển đổi một danh sách các bộ dữ liệu trở lại từ điển.

Bạn có thể lặp lại kết quả bằng một vòng lặp

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
09 và điền vào từ điển trên mỗi lần lặp:

>>>

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
4

Phương pháp này cung cấp cho bạn sự kiểm soát tuyệt đối và tính linh hoạt trong việc quyết định cách bạn muốn xây dựng từ điển của mình. Phương pháp này có thể khá dài để gõ ra, mặc dù. Nếu bạn không có bất kỳ yêu cầu đặc biệt nào để xây dựng từ điển của mình, thì bạn có thể muốn đi trình xây dựng từ điển thay thế: thay vào đó:

>>>

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
5

Đó là tốt đẹp và nhỏ gọn! Bạn cũng có thể sử dụng sự hiểu biết từ điển, nhưng điều đó chỉ có ý nghĩa nếu bạn muốn thay đổi hình dạng của từ điển hoặc trao đổi các phím và giá trị, chẳng hạn. Trong phạm vi hiểu sau đây, bạn trao đổi các khóa và giá trị:

>>>

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
6

Tùy thuộc vào mức độ quen thuộc của bạn hoặc nhóm của bạn với sự toàn diện, điều này có thể không thể đọc được hơn là chỉ sử dụng vòng lặp

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
09 bình thường.

Xin chúc mừng, bạn đã có từ điển được sắp xếp của bạn! Bây giờ bạn có thể sắp xếp nó theo bất kỳ tiêu chí nào mà bạn thích.

Bây giờ bạn có thể sắp xếp từ điển của mình, bạn có thể quan tâm đến việc biết liệu có bất kỳ ý nghĩa hiệu suất nào đối với việc sử dụng từ điển được sắp xếp hay không, hoặc liệu có cấu trúc dữ liệu thay thế cho dữ liệu giá trị khóa.

Xem xét các vấn đề chiến lược và hiệu suất

Trong phần này, bạn sẽ xem nhanh về một số điều chỉnh hiệu suất, cân nhắc chiến lược và các câu hỏi để tự hỏi mình về cách bạn sẽ sử dụng dữ liệu giá trị khóa của mình.

Bạn sẽ tận dụng mô -đun

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
4 để có được một số số liệu để làm việc. Điều quan trọng là phải nhớ rằng để đưa ra bất kỳ kết luận chắc chắn nào về hiệu suất, bạn cần kiểm tra một loạt các phần cứng và với nhiều loại mẫu và kích cỡ mẫu.

Cuối cùng, lưu ý rằng bạn đã thắng được chi tiết về cách sử dụng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
4. Đối với điều đó, hãy xem hướng dẫn về bộ hẹn giờ Python. Bạn có một số ví dụ để chơi với, mặc dù.

Sử dụng các chức năng getter đặc biệt để tăng hiệu suất và khả năng đọc

Bạn có thể nhận thấy rằng hầu hết các chức năng chính mà bạn đã sử dụng cho đến nay aren làm rất nhiều. Tất cả các hàm làm là nhận được một giá trị từ một tuple. Làm chức năng Getter là một mô hình phổ biến đến nỗi Python có một cách đặc biệt để tạo các hàm đặc biệt nhận được giá trị nhanh hơn các hàm thông thường.

Hàm

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 có thể tạo ra các phiên bản hiệu quả cao của các hàm getter.

Bạn vượt qua

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 một đối số, thường là vị trí khóa hoặc chỉ mục mà bạn muốn chọn. Hàm
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 sau đó sẽ trả về một đối tượng getter mà bạn gọi là một hàm.

Đúng vậy, nó là một chức năng trả về một chức năng. Sử dụng chức năng

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 là một ví dụ khác về việc làm việc với các hàm bậc cao hơn.

Đối tượng getter từ

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 sẽ gọi phương thức
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
18 trên mục mà Lừa đã truyền cho nó. Khi một cái gì đó thực hiện một cuộc gọi đến
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
18, nó cần phải vượt qua khóa hoặc chỉ mục về những gì cần nhận. Đối số mà Lừa được sử dụng cho
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
18 là cùng một đối số mà bạn đã chuyển sang
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13:

>>>

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
7

Trong ví dụ, bạn bắt đầu với một tuple, tương tự như một cái mà bạn có thể nhận được như một phần của chế độ xem từ điển.

Bạn thực hiện getter đầu tiên bằng cách vượt qua

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
05 như một đối số cho
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13. Khi getter kết quả nhận được tuple, nó sẽ trả về mục đầu tiên trong bộ tuple, giá trị tại Index
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
05. Nếu bạn gọi
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 với đối số là
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
6, thì nó sẽ nhận được giá trị tại vị trí chỉ mục
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
6.

Bạn có thể sử dụng ItemGetter này làm khóa cho chức năng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1:

>>>

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
8

Trong ví dụ, bạn bắt đầu với một tuple, tương tự như một cái mà bạn có thể nhận được như một phần của chế độ xem từ điển.

Bạn thực hiện getter đầu tiên bằng cách vượt qua

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
05 như một đối số cho
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13. Khi getter kết quả nhận được tuple, nó sẽ trả về mục đầu tiên trong bộ tuple, giá trị tại Index
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
05. Nếu bạn gọi
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 với đối số là
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
6, thì nó sẽ nhận được giá trị tại vị trí chỉ mục
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
6.

Bạn có thể sử dụng ItemGetter này làm khóa cho chức năng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1:

>>>

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
9

Trong ví dụ, bạn bắt đầu với một tuple, tương tự như một cái mà bạn có thể nhận được như một phần của chế độ xem từ điển.

Bạn thực hiện getter đầu tiên bằng cách vượt qua >>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25} >>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2'] >>> sorted(d.items(), key=lambda i:keyorder.index(i[0])) [('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)] 05 như một đối số cho >>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25} >>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2'] >>> sorted(d.items(), key=lambda i:keyorder.index(i[0])) [('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)] 13. Khi getter kết quả nhận được tuple, nó sẽ trả về mục đầu tiên trong bộ tuple, giá trị tại Index >>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25} >>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2'] >>> sorted(d.items(), key=lambda i:keyorder.index(i[0])) [('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)] 05. Nếu bạn gọi >>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25} >>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2'] >>> sorted(d.items(), key=lambda i:keyorder.index(i[0])) [('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)] 13 với đối số là >>> def select_second_character(word): ... return word[1] ... >>> sorted(words, key=select_second_character) ['aa', 'ba', 'ca', 'ab', 'cb', 'ac'] 6, thì nó sẽ nhận được giá trị tại vị trí chỉ mục >>> def select_second_character(word): ... return word[1] ... >>> sorted(words, key=select_second_character) ['aa', 'ba', 'ca', 'ab', 'cb', 'ac'] 6.

Bạn có thể sử dụng ItemGetter này làm khóa cho chức năng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1:

>>> from collections import OrderedDict
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.index(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
0

Trong ví dụ này, bạn bắt đầu bằng cách sử dụng

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 với
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
05 làm đối số. Vì nó hoạt động trên mỗi tuple từ biến
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
31, nên nó nhận được phần tử đầu tiên từ mỗi tuple. Sau đó, ví dụ cho thấy việc khởi tạo một
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
32 với
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
6 làm đối số, chọn mục thứ hai trong tuple.

Cuối cùng, ví dụ cho thấy điều gì sẽ xảy ra nếu bạn đã sử dụng

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 với
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
7 làm đối số. Vì các bộ dữ liệu này chỉ có hai vị trí chỉ mục, cố gắng lấy phần tử thứ ba, với chỉ mục
>>> def select_second_character(word):
...     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
7, dẫn đến
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
37.

>>> from collections import OrderedDict
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.index(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
1

Bạn có thể sử dụng chức năng được tạo bởi

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 thay cho các hàm getter mà bạn đã sử dụng cho đến bây giờ:

Hàm

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 tạo ra một hàm có hiệu ứng chính xác như hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
4 từ các phần trước. Lý do chính mà bạn muốn sử dụng chức năng từ
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 là vì nó hiệu quả hơn. Trong phần tiếp theo, bạn sẽ bắt đầu đặt một số số vào mức độ hiệu quả hơn bao nhiêu.

Đo lường hiệu suất khi sử dụng

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13

Vì vậy, bạn kết thúc với một hàm hoạt động giống như

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
4 gốc từ các phần trước, ngoại trừ phiên bản được trả về từ
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 hiệu quả hơn. Bạn có thể sử dụng mô -đun
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
4 để so sánh hiệu suất của chúng:

Mã này sử dụng mô -đun

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
4 để so sánh các quy trình sắp xếp của hàm từ
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 và hàm Lambda.

Chạy tập lệnh này từ shell sẽ cung cấp cho bạn kết quả tương tự như những gì bên dưới:

Một khoản tiết kiệm khoảng 40 phần trăm là đáng kể!

Hãy nhớ rằng khi thực hiện mã thời gian, thời gian có thể thay đổi đáng kể giữa các hệ thống. Điều đó nói rằng, trong trường hợp này, tỷ lệ phải tương đối ổn định trên các hệ thống.

>>> from collections import OrderedDict
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.index(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
2

Từ kết quả của bài kiểm tra này, bạn có thể thấy rằng sử dụng

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
13 thích hợp hơn từ quan điểm hiệu suất. Thêm vào đó, nó là một phần của thư viện tiêu chuẩn Python, vì vậy, không có chi phí để sử dụng nó.

Bây giờ bạn có thể vắt thêm một chút hiệu suất từ ​​việc sắp xếp từ điển của mình, nhưng nó đáng để lùi lại một bước và xem xét liệu sử dụng từ điển được sắp xếp vì cấu trúc dữ liệu ưa thích của bạn là lựa chọn tốt nhất. Rốt cuộc, một từ điển được sắp xếp là một mô hình rất phổ biến.

Sắp tới, bạn sẽ tự hỏi mình một số câu hỏi về những gì bạn muốn làm với từ điển được sắp xếp của bạn và liệu nó có phải là cấu trúc dữ liệu tốt nhất cho trường hợp sử dụng của bạn hay không.

Đánh giá xem bạn có muốn sử dụng một từ điển được sắp xếp

Một lựa chọn khác là đơn giản là không lo lắng về việc đặt hàng dữ liệu nếu bạn không cần. Bao gồm

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
49,
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
50 hoặc các thuộc tính tương đương khác cho mỗi đối tượng có thể đủ để thể hiện thứ tự. Nếu đơn đặt hàng bị trộn lẫn vì bất kỳ lý do gì, thì đó sẽ luôn là một cách rõ ràng để sắp xếp nó:

>>> from collections import OrderedDict
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.index(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
3

Ví dụ, với một thuộc tính

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
50, nó rõ ràng rằng
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
52 nên được xếp hàng đầu tiên. Rõ ràng về việc đặt hàng dự định của bạn là hoàn toàn phù hợp với câu ngạn ngữ Python cũ của rõ ràng là tốt hơn tiềm ẩn, từ Zen of Python.

Sự đánh đổi hiệu suất với việc sử dụng danh sách từ điển so với từ điển từ điển là gì? Trong phần tiếp theo, bạn sẽ bắt đầu nhận được một số dữ liệu về chính câu hỏi đó.

So sánh hiệu suất của các cấu trúc dữ liệu khác nhau

Nếu hiệu suất là một sự cân nhắc, có lẽ bạn sẽ làm việc với các bộ dữ liệu lớn, ví dụ như bạn nên xem xét cẩn thận những gì bạn sẽ làm với từ điển.

Hai câu hỏi chính mà bạn sẽ tìm cách trả lời trong một vài phần tiếp theo là:

  1. Bạn sẽ sắp xếp một lần và sau đó thực hiện rất nhiều tra cứu?
  2. Bạn sẽ sắp xếp nhiều lần và thực hiện rất ít tra cứu?

Khi bạn đã quyết định những mẫu sử dụng mà bạn sẽ tuân theo cấu trúc dữ liệu của mình, thì bạn có thể sử dụng mô -đun

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
4 để kiểm tra hiệu suất. Các phép đo này có thể thay đổi rất nhiều với hình dạng và kích thước chính xác của dữ liệu đang được kiểm tra.

Trong ví dụ này, bạn sẽ đặt một từ điển từ điển so với danh sách các từ điển để xem chúng khác nhau về hiệu suất như thế nào. Bạn sẽ có thời gian các hoạt động sắp xếp thời gian và các hoạt động tra cứu với dữ liệu mẫu sau:

>>> from collections import OrderedDict
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.index(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
4

Mỗi cấu trúc dữ liệu có cùng một thông tin, ngoại trừ một được cấu trúc như một từ điển từ điển và cái còn lại là danh sách các từ điển. Đầu tiên, bạn sẽ nhận được một số số liệu về hiệu suất sắp xếp hai cấu trúc dữ liệu này.

So sánh hiệu suất của việc sắp xếp

Trong mã sau, bạn sẽ sử dụng

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
4 để so sánh thời gian cần thiết để sắp xếp hai cấu trúc dữ liệu theo thuộc tính
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
55:

>>> from collections import OrderedDict
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.index(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
5

Mã này nhập các cấu trúc dữ liệu mẫu để sắp xếp thuộc tính

>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
55. Có vẻ như bạn không sử dụng nhập khẩu từ
>>> d = {'10': -10, 'ZT21': 14, 'WX21': 12, '2': 15, '5': -3, 'UM': -25}
>>> keyorder = ['ZT21', '10', 'WX21', 'UM', '5', '2']
>>> sorted(d.items(), key=lambda i:keyorder.index(i[0]))
[('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)]
57, nhưng nó cần thiết cho các mẫu này trong không gian tên toàn cầu để bối cảnh
>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
4 có quyền truy cập vào chúng.

Chạy mã cho thử nghiệm này trên dòng lệnh sẽ cung cấp cho bạn một số kết quả thú vị:

>>> from collections import OrderedDict
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.index(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
6

Sắp xếp một danh sách có thể nhanh gần gấp đôi so với quy trình cần thiết để sắp xếp chế độ xem từ điển và sau đó tạo một từ điển được sắp xếp mới. Vì vậy, nếu bạn có kế hoạch sắp xếp dữ liệu của mình rất thường xuyên, thì một danh sách các bộ dữ liệu có thể tốt hơn một từ điển cho bạn.

Một trong những chi phí chính khi sắp xếp từ điển, trái ngược với danh sách, đang xây dựng lại từ điển sau khi sắp xếp nó. Nếu bạn đã loại bỏ hàm tạo

>>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
3 bên ngoài, thì bạn sẽ cắt giảm đáng kể thời gian thực hiện.

Trong phần tiếp theo, bạn sẽ xem xét thời gian để tìm kiếm các giá trị trong một từ điển từ điển so với trong một danh sách các từ điển.

So sánh hiệu suất của tra cứu

Tuy nhiên, nếu bạn có kế hoạch sử dụng từ điển để sắp xếp dữ liệu của mình một lần và sử dụng từ điển đó chủ yếu để tra cứu, thì từ điển chắc chắn sẽ có ý nghĩa hơn một danh sách:

>>> from collections import OrderedDict
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.index(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
7

Mã này làm cho một loạt các tra cứu cho cả danh sách và từ điển. Bạn có thể lưu ý rằng với danh sách, bạn phải viết một chức năng đặc biệt để tra cứu. Chức năng làm cho việc tra cứu danh sách liên quan đến việc đi qua tất cả các yếu tố danh sách một cho đến khi bạn tìm thấy phần tử đích, đó là lý tưởng.

Chạy tập lệnh so sánh này từ dòng lệnh sẽ mang lại kết quả cho thấy rằng tra cứu từ điển nhanh hơn đáng kể:

>>> from collections import OrderedDict
>>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.index(i[0])))
OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
8

Nhanh hơn gần mười tám lần! Đó là cả một bó. Vì vậy, bạn chắc chắn muốn cân nhắc tốc độ rực rỡ của các tra cứu từ điển so với cấu trúc dữ liệu sắp xếp chậm hơn. Hãy nhớ rằng tỷ lệ này có thể thay đổi đáng kể từ hệ thống này sang hệ thống khác, chưa kể đến biến thể có thể đến từ các từ điển hoặc danh sách có kích thước khác nhau.

Tuy nhiên, tra cứu từ điển chắc chắn nhanh hơn, bất kể bạn cắt nó như thế nào. Điều đó nói rằng, nếu bạn chỉ thực hiện tra cứu, thì bạn có thể dễ dàng làm điều đó với một từ điển chưa được phân loại thường xuyên. Tại sao bạn cần một từ điển được sắp xếp trong trường hợp đó? Để lại trường hợp sử dụng của bạn trong các ý kiến!

Bây giờ bạn nên có một ý tưởng tương đối tốt về một số sự đánh đổi giữa hai cách để lưu trữ dữ liệu giá trị khóa của bạn. Kết luận mà bạn có thể đạt được là, hầu hết thời gian, nếu bạn muốn một cấu trúc dữ liệu được sắp xếp, thì có lẽ bạn nên tránh xa từ điển, chủ yếu vì lý do khả năng tương tác ngôn ngữ.

Điều đó nói rằng, hãy thử từ điển sắp xếp đã nói ở trên. Nó sử dụng một số chiến lược khéo léo để vượt qua những hạn chế hiệu suất điển hình.

Bạn có bất kỳ triển khai thú vị hoặc thực hiện của cấu trúc dữ liệu giá trị khóa được sắp xếp không? Chia sẻ chúng trong các ý kiến, cùng với các trường hợp sử dụng của bạn cho một từ điển được sắp xếp!

Sự kết luận

Bạn đã đi từ cách cơ bản nhất để sắp xếp từ điển sang một vài lựa chọn thay thế nâng cao xem xét hiệu suất trong việc sắp xếp các cặp giá trị khóa.

Trong hướng dẫn này, bạn đã::

  • Đã xem xét chức năng
    >>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
    >>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
    OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
    
    1
    >>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
    >>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
    OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
    
    1
    function
  • Phát hiện ra quan điểm từ điểnviews
  • Hiểu làm thế nào từ điển được chọn vào danh sách trong quá trình sắp xếplists during sorting
  • Các khóa sắp xếp được chỉ định để sắp xếp từ điển theo giá trị, khóa hoặc thuộc tính lồng nhausort keys to sort a dictionary by value, key, or nested attribute
  • Đã sử dụng toàn bộ từ điển và trình xây dựng
    >>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
    >>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
    OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
    
    3 để xây dựng lại từ điển của bạncomprehensions and the
    >>> keyorder = {k:v for v,k in enumerate(['ZT21', '10', 'WX21', 'UM', '5', '2'])}
    >>> OrderedDict(sorted(d.items(), key=lambda i:keyorder.get(i[0])))
    OrderedDict([('ZT21', 14), ('10', -10), ('WX21', 12), ('UM', -25), ('5', -3), ('2', 15)])
    
    3 constructor to rebuild your dictionaries
  • Được xem xét liệu một từ điển được sắp xếp là cấu trúc dữ liệu phù hợp cho dữ liệu chính của bạndata structure for your key-value data

Bây giờ bạn đã sẵn sàng để không chỉ sắp xếp từ điển theo bất kỳ tiêu chí nào bạn có thể nghĩ đến, mà còn để đánh giá xem từ điển được sắp xếp có phải là lựa chọn tốt nhất cho bạn hay không.

Chia sẻ các trường hợp sử dụng từ điển được sắp xếp của bạn và so sánh hiệu suất trong các ý kiến ​​dưới đây!

Chúng ta có thể sắp xếp từ điển trong Python không?

Vâng, kể từ Python 3.7, từ điển cũng nhớ thứ tự của các mục được chèn. Do đó, chúng tôi cũng có thể sắp xếp từ điển bằng cách sử dụng hàm Sắp xếp () tích hợp của Python. Cũng giống như với các phép lặp khác, chúng ta có thể sắp xếp từ điển dựa trên các tiêu chí khác nhau tùy thuộc vào đối số chính của hàm Sắp xếp ().we are also able to sort dictionaries using python's built-in sorted() function. Just like with other iterables, we can sort dictionaries based on different criteria depending on the key argument of the sorted() function.

Làm thế nào để bạn sắp xếp một từ điển theo khóa mà không cần sắp xếp trong Python?

Phương thức-4: Từ điển sắp xếp Python bằng khóa bằng cách sử dụng itemgetter () thay vì hàm lambda có một phiên bản có sẵn trong mô-đun toán tử có tên itemgetter ().Đây là các chức năng bậc cao.Biểu thức itemGetter (0) tạo một hàm.Sau đó, chúng ta có thể áp dụng chức năng cho một bộ sưu tập để chọn một đối tượng, như thế này.

Bạn có thể sắp xếp một dict được đặt hàng không?

Dicts không thể được sắp xếp, nhưng bạn có thể xây dựng một danh sách được sắp xếp từ họ., but you can build a sorted list from them.

Làm thế nào để bạn sắp xếp một từ điển theo thứ tự tăng dần trong Python?

Để sắp xếp một từ điển trong Python:..
Tạo một từ điển của các cặp giá trị khóa ..
Quyết định xem bạn muốn sắp xếp theo phím hoặc giá trị ..
Chọn giữa đơn đặt hàng tăng dần và giảm dần ..
Gọi hàm được sắp xếp tích hợp () trên các mục từ điển ..