Python sắp xếp nhiều khóa

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

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 nhưng chưa nhận được kết quả như mong đợi. Trong hướng dẫn này, bạn sẽ tìm hiểu 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 hàm
    >>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
    >>> sorted(words)
    ['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
    
    8
  • Tìm hiểu cách nhận các lượt xem từ điển để lặp lại
  • Hiểu cách từ điển được chuyển thành danh sách trong quá trình sắp xếp
  • 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 nhau
  • Xem lại khả năng hiểu từ điển và hàm tạo
    >>> def select_second_character(word):
    ..     return word[1]
    ...
    >>> sorted(words, key=select_second_character)
    ['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
    
    0 để xây dựng lại từ điển của bạn
  • Xem xét các cấu trúc dữ liệu thay thế cho dữ liệu khóa-giá trị của bạn

Đồng thời, bạn cũng sẽ sử dụng mô-đun

>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
1 để định thời gian cho mã của mình và nhận được kết quả rõ ràng để so sánh các phương pháp sắp xếp dữ liệu khóa-giá trị khác nhau. Bạn cũng sẽ cân nhắc, vì nó không phải là một mẫu đặ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à hàm. 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 hàm bậc cao hơn, chẳng hạn như hàm lambda, cũng sẽ hữu ích nhưng không bắt buộc

Tải xuống miễn phí. Nhấp vào đây để tải xuống mã mà bạn sẽ sử dụng để sắp xếp các cặp khóa-giá trị trong hướng dẫn này

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

Khám phá lại thứ tự từ điển trong Python

Trước Python 3. 6, từ điển vốn đã không có thứ tự. Từ điển Python là một triển khai của bảng băm, theo truyền thống là cấu trúc dữ liệu không có thứ tự

Là một tác dụng phụ của việc triển khai 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

Nếu bạn muốn giữ một từ điển có thứ tự dưới dạng 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

>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
2 từ mô-đun
>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
3. 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 khóa-giá trị được sắp xếp 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, 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 cần hiểu khi sắp xếp từ điển là mặc dù chúng bảo toàn thứ tự chèn, nhưng chúng không được coi là một. Từ điển giống như một tập hợp các cặp khóa-giá trị và các bộ này không có thứ tự

Từ điển cũng không có nhiều chức năng sắp xếp lại. Chúng không giống như danh sách, nơi bạn có thể chèn các phần tử vào bất kỳ vị trí nào. Trong phần tiếp theo, bạn sẽ khám phá thêm về hậu quả của giới hạn này

Loại bỏ các quảng cáo

Hiểu ý nghĩa của việc sắp xếp một từ điển

Vì từ điển không có nhiều chức năng sắp xếp lại thứ tự nên khi sắp xếp từ điển ít khi thực hiện tại chỗ. Trên thực tế, không có phương pháp nào để di chuyển các mục trong từ điển một cách rõ ràng

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

>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
4 để xóa một mục khỏi từ điển rồi thêm lại. Xóa và sau đó thêm lại sẽ di chuyển cặp khóa-giá trị đến cuối một cách hiệu quả

Lớp

>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
2 có nhiệm vụ di chuyển một mục đến cuối hoặc đầu, điều này có thể làm cho
>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
2 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à ít nhất là không hiệu quả lắm.

Phương pháp điển hình để sắp xếp từ điển là lấy chế độ xem từ điển, sắp xếp và sau đó chuyển danh sách kết quả trở lại từ điển. Vì vậy, bạn thực sự chuyển từ từ điển sang danh sách và quay 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 lại danh sách thành từ điển

Ghi chú. Từ điển được sắp xếp không phải là một mô hình rất phổ biến. Bạn sẽ khám phá thêm về chủ đề đó

Với những phần sơ bộ đó, bạn sẽ 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ẽ tập hợp các thành phần sắp xếp từ điển để cuối cùng, bạn có thể nắm vững cách sắp xếp từ điển phổ biến nhất

>>>

>>> 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'}

Đừng lo lắng nếu bạn không hiểu các đoạn mã trên—bạn sẽ xem lại tất cả từng bước trong các phần sau. Đồng thời, bạn sẽ học cách sử dụng hàm

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 với các phím sắp xếp, hàm
>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
8 và hàm tạo từ điển

Sử dụng Hàm >>> words = ["aa", "ab", "ac", "ba", "cb", "ca"] >>> sorted(words) ['aa', 'ab', 'ac', 'ba', 'ca', 'cb'] 8

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

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 được tích hợp sẵn. Hàm này nhận một đối số chính, với hai đối số chỉ có từ khóa tùy chọn—một hàm
>>> list(reversed([3, 2, 1]))
[1, 2, 3]
1 và một giá trị boolean
>>> list(reversed([3, 2, 1]))
[1, 2, 3]
2

Để minh họa hành vi của hàm

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 một cách độc lập, hãy kiểm tra việc sử dụng nó trên một 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]

Như bạn có thể thấy, hàm

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 có thể lặp lại, sắp xếp các phần tử có thể so sánh như số theo thứ tự tăng dần và trả về một danh sách mới. Với các chuỗi, nó sắp xếp chúng theo thứ tự bảng chữ cái

>>>

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

Sắp xếp theo thứ tự ưu tiên số hoặc chữ cái là cách phổ biến nhất để sắp xếp các phần tử, nhưng có thể bạn cần kiểm soát nhiều hơn

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

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 sử dụng để sắp xếp các phần tử, bạn có thể chuyển một hàm gọi lại cho tham số
>>> list(reversed([3, 2, 1]))
[1, 2, 3]
1

Hàm gọi lại là một hàm được truyền dưới dạng đối số cho một hàm khác. Đối với

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8, bạn truyền cho nó một hàm hoạt động như một khóa sắp xếp. Hàm
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 sau đó sẽ gọi lại khóa sắp xếp cho mọi phần tử

Trong ví dụ sau, hàm được truyền dưới dạng 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

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 chuyển mọi phần tử của hàm lặp
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people)
[1, 2, 3, 4]
0 cho hàm
>>> list(reversed([3, 2, 1]))
[1, 2, 3]
1 và sử dụng giá trị trả về để so sánh. Sử dụng phím có nghĩa là hàm
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 sẽ so sánh chữ cái thứ hai thay vì so sánh trực tiếp toàn bộ chuỗi

Các ví dụ và giải thích khác về tham số

>>> list(reversed([3, 2, 1]))
[1, 2, 3]
1 sẽ có trong hướng dẫn khi bạn sử dụng tham số này để sắp xếp từ điển theo giá trị hoặc phần tử lồng nhau

Nếu bạn xem lại kết quả của lần sắp xếp cuối cùng này, bạn có thể nhận thấy hàm

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8. Ba phần tử,
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people)
[1, 2, 3, 4]
5,
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people)
[1, 2, 3, 4]
6 và
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people)
[1, 2, 3, 4]
7, tương đương nhau khi được sắp xếp theo ký tự thứ hai của chúng. Bởi vì chúng bằng nhau nên hàm
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 bảo toàn thứ tự ban đầu của chúng. Python đảm bảo sự ổn định này

Ghi chú. Mỗi danh sách cũng có một phương thức, có cùng chữ ký với hàm

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8. Sự khác biệt chính là phương thức
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people)
[1, 2, 3, 4]
9 sắp xếp danh sách tại chỗ. Ngược lại, hàm
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 trả về một danh sách mới, giữ nguyên danh sách ban đầu

Bạn cũng có thể chuyển

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
3 cho hàm hoặc phương thức sắp xếp để trả về thứ tự đảo ngược. Ngoài ra, bạn có thể sử dụng hàm
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
4 để đảo ngược khả năng lặp lại sau khi sắp xếp

>>>

>>> list(reversed([3, 2, 1]))
[1, 2, 3]

Nếu bạn muốn tìm hiểu sâu hơn về cơ chế sắp xếp trong Python và tìm hiểu cách sắp xếp các loại dữ liệu không phải từ điển, thì hãy xem hướng dẫn về cách sử dụng

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 và
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people)
[1, 2, 3, 4]
9

Vì vậy, làm thế nào về từ điển?

>>>

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

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

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 là lấy các khóa của từ điển, sắp xếp chúng và chỉ trả về một danh sách các khóa. Đó có thể không phải là hành vi bạn có trong tâm trí. Để lưu giữ tất cả thông tin trong từ điển, bạn cần làm quen với chế độ xem từ điển

Loại bỏ các quảng cáo

Lấy khóa, giá trị hoặc cả hai từ từ điển

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 trên từ điển. Gọi

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
9 trên từ điển sẽ cung cấp một lần lặp đại diện cho các cặp khóa-giá trị

>>>

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

Phương thức

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
9 trả về chỉ đọc, đóng vai trò như một cửa sổ vào từ điển. Chế độ xem này không phải là bản sao hay danh sách—nó là chế độ lặp lại chỉ đọc thực sự được liên kết với từ điển mà nó được tạo ra từ đó

>>>

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

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

Ghi chú. Bạn có thể sử dụng

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> view = people.items()
>>> people[2] = "Elvis"
>>> view
dict_items([(3, 'Jim'), (2, 'Elvis'), (4, 'Jane'), (1, 'Jill')])
2 để chỉ xem các giá trị và
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> view = people.items()
>>> people[2] = "Elvis"
>>> view
dict_items([(3, 'Jim'), (2, 'Elvis'), (4, 'Jane'), (1, 'Jill')])
3 để xem giá trị chỉ với các khóa

Điều quan trọng là bạn có thể sử dụng hàm

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 với chế độ xem từ điển. Bạn gọi phương thức
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
9 và sử dụng kết quả làm đối số cho hàm
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8. Sử dụng
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
9 giữ tất cả thông tin từ từ điển

>>>

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

Ví dụ này dẫn đến một danh sách các bộ được sắp xếp, với mỗi bộ đại diện cho một cặp khóa-giá trị của từ điển

Nếu bạn muốn kết thúc với một từ điển được sắp xếp theo giá trị, thì bạn vẫn gặp hai vấn đề. Hành vi mặc định dường như vẫn sắp xếp theo khóa chứ không phải giá trị. Vấn đề khác là bạn kết thúc với một danh sách các bộ dữ liệu, không phải từ điển. Đầu tiên, bạn sẽ tìm ra cách sắp xếp theo giá trị

Hiểu cách Python sắp xếp các bộ dữ liệu

Khi sử dụng phương thức

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
9 trên một từ điển và đưa nó vào hàm
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8, bạn đang chuyển vào một bộ dữ liệu có thể lặp lại và hàm
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 so sánh trực tiếp toàn bộ bộ dữ liệu

Khi so sánh các bộ dữ liệu, Python hoạt động rất giống như nó đang sắp xếp các chuỗi theo thứ tự bảng chữ cái. Đó là, nó sắp xếp chúng theo từ điển

Sắp xếp theo từ điển có nghĩa là nếu bạn có hai bộ dữ liệu,

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
1 và
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
2, thì bạn bắt đầu bằng cách so sánh mục đầu tiên của mỗi bộ dữ liệu. Mục đầu tiên là
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
3 trong cả hai trường hợp, bằng nhau. Phần tử thứ hai,
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
4, cũng giống hệt nhau trong cả hai trường hợp. Các phần tử thứ ba lần lượt là
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
5 và
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
6. Vì
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
6 nhỏ hơn
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
5, bạn đã tìm thấy mục nào nhỏ hơn mục kia

Vì vậy, để sắp xếp các bộ dữ liệu

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
1 và
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
2 theo từ điển, bạn sẽ chuyển thứ tự của chúng thành
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
2 và
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
1

Do hành vi sắp xếp từ điển của Python cho các bộ dữ liệu, sử dụng phương thức

>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> people.items()
dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])
9 với hàm
>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 sẽ luôn sắp xếp theo khóa trừ khi bạn sử dụng thêm thứ gì đó

Sử dụng Tham số >>> list(reversed([3, 2, 1])) [1, 2, 3] 1 và Hàm Lambda

Ví dụ: nếu bạn muốn sắp xếp theo giá trị, thì bạn phải chỉ định khóa sắp xếp. Khóa sắp xếp là một cách để trích xuất một giá trị có thể so sánh. Ví dụ: nếu bạn có một chồng sách, thì bạn có thể sử dụng họ của tác giả làm khóa sắp xếp. Với hàm

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8, bạn có thể chỉ định khóa sắp xếp bằng cách chuyển hàm gọi lại dưới dạng đối số
>>> list(reversed([3, 2, 1]))
[1, 2, 3]
1

Ghi chú. Đối số

>>> list(reversed([3, 2, 1]))
[1, 2, 3]
1 không liên quan gì đến khóa từ điển

Để xem một phím sắp xếp đang hoạt động, hãy xem ví dụ này, ví dụ này tương tự như ví dụ bạn đã thấy trong

>>>

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

>>> # Sort key
>>> def value_getter(item):
..     return item[1]
...

>>> sorted(people.items(), key=value_getter)
[(2, 'Jack'), (4, 'Jane'), (1, 'Jill'), (3, 'Jim')]

>>> # Or with a lambda function
>>> sorted(people.items(), key=lambda item: item[1])
[(2, 'Jack'), (4, 'Jane'), (1, 'Jill'), (3, 'Jim')]

Trong ví dụ này, bạn thử hai cách truyền tham số

>>> list(reversed([3, 2, 1]))
[1, 2, 3]
1. Tham số
>>> list(reversed([3, 2, 1]))
[1, 2, 3]
1 chấp nhận chức năng gọi lại. Hàm có thể là định danh hàm thông thường hoặc hàm lambda. Hàm lambda trong ví dụ này chính xác tương đương với hàm
>>> 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]
02

Ghi chú. Hàm lambda còn được gọi là hàm ẩn danh vì chúng không có tên. Các hàm lambda là tiêu chuẩn cho các hàm mà bạn chỉ sử dụng một lần trong mã của mình

Các hàm lambda không mang lại lợi ích gì ngoài việc làm cho mọi thứ gọn gàng hơn, loại bỏ nhu cầu xác định riêng một hàm. Họ giữ mọi thứ độc đáo trên cùng một dòng

>>> 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]
0

Đối với các hàm getter cơ bản như hàm trong ví dụ, lambdas có thể hữu ích. Nhưng lambdas có thể làm cho mã của bạn khó đọc hơn đối với bất kỳ thứ gì phức tạp hơn, vì vậy hãy cẩn thận khi sử dụng chúng

Lambdas cũng chỉ có thể chứa chính xác một , làm cho bất kỳ câu lệnh nhiều dòng nào như câu lệnh

>>> 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]
03 hoặc
>>> 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]
04 vượt quá giới hạn. Ví dụ, bạn có thể giải quyết vấn đề này bằng cách sử dụng khả năng hiểu và biểu thức
>>> 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]
03, nhưng những biểu thức đó có thể tạo ra những dòng chữ dài dòng và khó hiểu

Hàm gọi lại

>>> list(reversed([3, 2, 1]))
[1, 2, 3]
1 sẽ nhận từng phần tử của iterable mà nó sắp xếp. Công việc của hàm gọi lại là trả về thứ gì đó có thể so sánh được, chẳng hạn như một số hoặc một chuỗi. Trong ví dụ này, bạn đặt tên hàm là
>>> 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]
02 bởi vì tất cả những gì nó làm là lấy giá trị từ một bộ khóa-giá trị

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

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 với các bộ dữ liệu là sắp xếp theo thứ tự từ điển, nên tham số
>>> list(reversed([3, 2, 1]))
[1, 2, 3]
1 cho phép bạn chọn một giá trị từ phần tử mà nó đang so sánh

Trong phần tiếp theo, bạn sẽ sử dụng 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

Loại bỏ các quảng cáo

Chọn giá trị lồng nhau bằng khóa sắp xếp

Bạn cũng có thể đi xa hơn và sử dụng phím 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

>>> 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]
1

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

>>> 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]
10

Một phần khiến cho việc sắp xếp theo kỹ năng kết hợp trở nên khó khăn là các khó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]
11 và
>>> 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]
12 không có trong từ điển
>>> 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]
10 dành cho tất cả mọi người. Từ điển
>>> 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]
10 cũng được lồng vào nhau. Bạn sử dụng để đọc các phím và cung cấp
>>> 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]
16 làm giá trị mặc định được sử dụng cho các kỹ năng còn thiếu

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

>>> list(reversed([3, 2, 1]))
[1, 2, 3]
2 vì bạn muốn các kỹ năng Python hàng đầu xuất hiện trước

Ghi chú. Bạn đã không sử dụng hàm lambda trong ví dụ này. Mặc dù có thể, nhưng nó sẽ tạo ra một dòng mã dài có khả năng khó hiểu

>>> 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]
2

Một hàm lambda chỉ có thể chứa một biểu thức, vì vậy bạn lặp lại tra cứu đầy đủ trong từ điển phụ

>>> 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]
10 lồng nhau. Điều này làm tăng đáng kể chiều dài dòng

Hàm lambda cũng yêu cầu nhiều chỉ số dấu ngoặc vuông (_______17_______19), khiến nó khó đọc hơn mức cần thiết. Sử dụng lambda trong ví dụ này chỉ tiết kiệm một vài dòng mã và sự khác biệt về hiệu suất là không đáng kể. Vì vậy, trong những trường hợp này, việc sử dụng hàm bình thường sẽ hợp lý hơn

Bạn đã sử dụng thành công hàm bậc cao làm 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 đề cần giải quyết—chuyển đổi danh sách mà

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 mang lại thành 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

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
8 là nó trả về một danh sách, không phải từ điển. Có một số cách để chuyển đổi 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 vòng lặp

>>> 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]
04 và điền từ điển vào mỗi lần lặp

>>>

>>> 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

Phương pháp này cho phép bạn kiểm soát tuyệt đối và 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 sử dụng thay thế

>>>

>>> 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]
4

Đẹp và gọn đó. Bạn cũng có thể sử dụng a , 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 hoán đổi khóa và giá trị chẳng hạn. Trong phần hiểu sau, bạn trao đổi các khóa và giá trị

>>>

>>> 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]
5

Tùy thuộc vào mức độ hiểu biết của bạn hoặc nhóm của bạn, điều này có thể khó đọc hơn so với việc chỉ sử dụng vòng lặp

>>> 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]
04 bình thường

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

Bây giờ bạn có thể sắp xếp từ điển của mình, bạn có thể muốn 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 đã sắp xếp hay không hoặc liệu có cấu trúc dữ liệu thay thế nào cho dữ liệu khóa-giá trị hay không

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

Trong phần này, bạn sẽ xem nhanh 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 bản thân về cách bạn sẽ sử dụng dữ liệu khóa-giá trị của mình

Ghi chú. Nếu bạn quyết định chọn bộ sưu tập theo yêu cầu, hãy xem gói Hộp đựng đã phân loại, bao gồm mộ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]
24

Bạn sẽ tận dụng mô-đun để có được một số số liệu để làm việc với. Điều quan trọng cần lưu ý là để đưa ra bất kỳ kết luận chắc chắn nào về hiệu suất, bạn cần thử nghiệm trên nhiều phần cứng khác nhau, với nhiều loại và kích cỡ mẫu khác nhau

Cuối cùng, lưu ý rằng bạn sẽ không đi vào chi tiết về cách sử dụng

>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
1. Để biết điều đó, hãy xem hướng dẫn về bộ định thời Python. Tuy nhiên, bạn sẽ có một số ví dụ để thử

Loại bỏ các quảng cáo

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 phím sắp xếp mà bạn đã sử dụng cho đến nay không hoạt động nhiều lắm. Tất cả chức năng làm là lấy một giá trị từ một tuple. Tạo hàm getter là một mẫu 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 giá trị nhanh hơn các hàm thông thường

Hàm này có thể tạo ra các phiên bản hiệu quả cao của hàm getter

Bạn chuyển một đối 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]
27, thường là vị trí khóa hoặc chỉ mục mà bạn muốn chọn. Hàm
>>> 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]
27 sau đó sẽ trả về một đối tượng getter mà bạn gọi như một hàm

Đúng vậy, đó là một hàm trả về một hàm. Sử dụng hàm

>>> 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]
27 là một ví dụ khác về cách làm việc với các hàm bậc cao hơn

Đối tượng getter 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]
27 sẽ gọi phương thức
>>> 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]
32 trên mục được truyền cho nó. Khi một cái gì đó thực hiện cuộc gọi đến
>>> 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]
32, nó cần chuyển vào khóa hoặc chỉ mục của những gì cần nhận. Đối số được sử dụng cho
>>> 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]
32 chính là đối số mà bạn đã chuyển cho
>>> 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]
27

>>>

>>> 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]
6

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

Bạn tạo getter đầu tiên bằng cách chuyển

>>> 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]
16 làm đối số cho
>>> 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]
27. Khi getter kết quả nhận được bộ dữ liệu, nó trả về mục đầu tiên trong bộ dữ liệu—giá trị tại chỉ mục
>>> 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]
16. Nếu bạn gọi
>>> 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]
27 với đối số là
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
3, thì nó sẽ nhận giá trị ở vị trí chỉ mục
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
3

Bạn có thể sử dụng itemgetter này làm khóa cho hàm

>>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
>>> sorted(words)
['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
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]
7

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

>>> 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]
27 với
>>> 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]
16 làm đối số. Vì nó hoạt động trên mỗi bộ từ biến
>>> 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]
45, nên nó lấy phần tử đầu tiên từ mỗi bộ. Sau đó, ví dụ minh họa việc khởi tạo mộ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]
46 với
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
3 làm đối số, chọn mục thứ hai trong bộ dữ liệu

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

>>> 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]
27 với
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
4 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
>>> people = {3: "Jim", 2: "Jack", 4: "Jane", 1: "Jill"}
>>> sorted(people.items())
[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]
4, dẫn đến một kết quả là
>>> 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]
51

Bạn có thể sử dụng hàm được tạo bởi

>>> 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]
27 thay cho các hàm getter mà bạn đã sử dụng cho đến bây giờ

>>>

>>> 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

Hàm

>>> 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]
27 tạo ra một hàm có tác dụng chính xác giống như hàm
>>> 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]
02 từ các phần trước. Lý do chính khiến bạn muốn sử dụng hàm 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]
27 là vì nó hiệu quả hơn. Trong phần tiếp theo, bạn sẽ bắt đầu đưa ra một số con số về mức độ hiệu quả của nó

Đo lường hiệu suất khi sử dụng >>> 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] 27

Vì vậy, bạn kết thúc với một chức năng hoạt động giống như phiên bản gốc

>>> 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]
02 từ các phần trước, ngoại trừ phiên bản được trả về 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]
27 hiệu quả hơn. Bạn có thể sử dụng mô-đun
>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
1 để so sánh hiệu suất của chúng

>>> 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

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

>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
1 để so sánh các quy trình sắp xếp của hàm 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]
27 và hàm lambda

Chạy tập lệnh này từ trình bao sẽ cho bạn kết quả tương tự như kết quả bên dưới

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

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

Hãy nhớ rằng khi định thời gian thực thi mã, thời gian có thể khác nhau đá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 giữa các hệ thống

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

>>> 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]
27 tốt hơn từ quan điểm hiệu suất. Ngoài ra, nó là một phần của thư viện chuẩn Python, vì vậy không mất phí khi sử dụng nó

Ghi chú. Sự khác biệt giữa việc sử dụng lambda và chức năng bình thường làm khóa sắp xếp là không đáng kể trong thử nghiệm này

Bạn có muốn so sánh hiệu suất của một số thao tác mà bạn chưa đề cập ở đây không?

Giờ đây, bạn có thể tăng 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 bạn nên lùi lại một bước và cân nhắc xem việc sử dụng từ điển đã sắp xếp làm cấu trúc dữ liệu ưa thích của mình có phải là lựa chọn tốt nhất hay không. Rốt cuộc, một từ điển được sắp xếp không phải là một mẫu rất phổ biến

Tiếp theo, 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 đã sắp xếp của mình và liệu đó 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 không

Loại bỏ các quảng cáo

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

Nếu bạn đang xem xét việc tạo cấu trúc dữ liệu khóa-giá trị được sắp xếp, thì có một vài điều bạn có thể muốn xem xét

Nếu bạn sắp thêm dữ liệu vào từ điển và bạn muốn dữ liệu đó được sắp xếp, thì tốt hơn hết bạn nên sử dụng cấu trúc như danh sách bộ dữ liệu hoặc danh sách từ điển

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

Danh sách từ điển là mẫu phổ biến nhất vì khả năng tương thích giữa các ngôn ngữ của nó, được gọi là khả năng tương tác ngôn ngữ

Chẳng hạn, khả năng tương tác ngôn ngữ đặc biệt phù hợp nếu bạn tạo HTTP REST API. Cung cấp dữ liệu của bạn trên Internet có thể có nghĩa là tuần tự hóa dữ liệu đó trong JSON

Nếu ai đó sử dụng JavaScript để sử dụng dữ liệu JSON từ API REST, thì cấu trúc dữ liệu tương đương sẽ là một đối tượng. Vấn đề là các đối tượng JavaScript không được sắp xếp theo thứ tự, do đó, thứ tự sẽ bị xáo trộn

Hành vi xáo trộn này sẽ đúng với nhiều ngôn ngữ và các đối tượng thậm chí còn được xác định trong đặc tả JSON dưới dạng cấu trúc dữ liệu không có thứ tự. Vì vậy, nếu bạn cẩn thận đặt hàng từ điển của mình trước khi tuần tự hóa thành JSON, thì sẽ không có vấn đề gì khi nó xâm nhập vào hầu hết các môi trường khác

Ghi chú. Đăng nhập một chuỗi các cặp khóa-giá trị được sắp xếp theo thứ tự có thể không chỉ phù hợp để tuần tự hóa các từ điển Python thành JSON. Hãy tưởng tượng bạn có những người trong nhóm của bạn đã quen với các ngôn ngữ khác. Một từ điển có thứ tự có thể là một khái niệm xa lạ đối với họ, vì vậy bạn có thể cần phải nói rõ ràng rằng bạn đã tạo một cấu trúc dữ liệu có thứ tự

Một cách để rõ ràng về việc có một từ điển được sắp xếp theo thứ tự trong Python là sử dụng tên thích hợp là

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

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

>>> 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]
64,
>>> 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]
65 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 thứ tự bị lẫn lộn vì bất kỳ lý do gì, thì sẽ luôn có một cách rõ ràng để sắp xếp nó

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

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

>>> 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]
65, rõ ràng là ___17_______67 phải ở vị trí đầu tiên trong dòng. Rõ ràng về thứ tự dự định của bạn rất phù hợp với câu ngạn ngữ cũ của Python về rõ ràng tốt hơn là ẩn ý, ​​từ Zen of Python

Tuy nhiên, sự đánh đổi về hiệu suất khi sử dụng danh sách từ điển so với từ điển của từ điển là gì?

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 yếu tố cần cân nhắc—chẳng hạn như có thể bạn sẽ làm việc với các tập dữ liệu lớn—thì bạn nên cân nhắc cẩn thận những gì mình sẽ làm với từ điển

Hai câu hỏi chính bạn sẽ tìm cách trả lời trong 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 nhiều lần tra cứu chứ?
  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 các kiể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

>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
1 để 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ẽ so sánh một từ điển của các từ điển với một danh sách các từ điển để xem chúng khác nhau như thế nào về hiệu suất. Bạn sẽ tính thời gian cho các thao tác sắp xếp và thao tác tra cứu với dữ liệu mẫu sau

Dữ liệu mẫuHiển thị/Ẩn

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

Mỗi cấu trúc dữ liệu đều có thông tin giống nhau, ngoại trừ một cấu trúc là từ điển của từ điển và cấu trúc còn lại là danh sách 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

Loại bỏ các quảng cáo

So sánh hiệu suất sắp xếp

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

>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
1 để 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
>>> 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]
70

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

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

>>> 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]
70. Có vẻ như bạn không sử dụng dữ liệu nhập 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]
72, nhưng các mẫu này cần phải ở trong không gian tên chung để ngữ cảnh
>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
1 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ị

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

Việc sắp xếp một danh sách có thể nhanh gấp đôi so với quy trình cần thiết để sắp xếp một 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 dành cho bạn

Ghi chú. Không có nhiều kết luận chắc chắn có thể được rút ra từ một tập dữ liệu như thế này. Ngoài ra, kết quả có thể rất khác nhau với dữ liệu có kích thước hoặc hình dạng khác nhau

Những ví dụ này là cách để bạn nhúng ngón chân vào mô-đun

>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
1 và bắt đầu xem cách thức và lý do bạn có thể sử dụng nó. Điều này sẽ cung cấp cho bạn một số công cụ cần thiết để đánh giá cấu trúc dữ liệu của bạn, nhằm giúp bạn quyết định cấu trúc dữ liệu nào sẽ giải quyết cho các cặp khóa-giá trị của mình

Nếu bạn cần hiệu suất cao hơn, hãy tiếp tục và tính thời gian cho các cấu trúc dữ liệu cụ thể của bạn. Điều đó nói rằng, hãy cẩn thận với việc tối ưu hóa sớm

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, là 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

>>> def select_second_character(word):
..     return word[1]
...
>>> sorted(words, key=select_second_character)
['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
0 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 cần thiết để tra cứu các giá trị trong từ điển của từ điển so với trong danh sách từ điển

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

Tuy nhiên, nếu bạn dự định 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ì một từ điển chắc chắn sẽ có ý nghĩa hơn một danh sách

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

Mã này thực hiện một loạt tra cứu cho cả danh sách và từ điển. Bạn sẽ lưu ý rằng với danh sách, bạn phải viết một hàm đặc biệt để thực hiện tra cứu. Chức năng thực hiện tra cứu danh sách liên quan đến việc duyệt qua từng phần tử danh sách cho đến khi bạn tìm thấy phần tử đích, điều này không 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 việc tra cứu từ điển nhanh hơn đáng kể

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

Gần mười tám lần nhanh hơn. Đó là cả một đống. Vì vậy, bạn chắc chắn muốn cân nhắc tốc độ tra cứu từ điển nhanh chóng so với việc sắp xếp chậm hơn của cấu trúc dữ liệu. 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 sự thay đổi 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ỉ 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 sắp xếp thông thường. Tại sao bạn cần một từ điển được sắp xếp trong trường hợp đó?

Ghi chú. Bạn có thể thử và tối ưu hóa tra cứu danh sách, chẳng hạn bằng cách triển khai thuật toán tìm kiếm nhị phân để cắt giảm thời gian tra cứu danh sách. Tuy nhiên, mọi lợi ích sẽ chỉ trở nên đáng chú ý ở quy mô danh sách đáng kể

Với kích thước danh sách giống như kích thước được kiểm tra ở đây, việc sử dụng tìm kiếm nhị phân với mô-đun

>>> 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]
76 chậm hơn đáng kể so với vòng lặp
>>> 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]
04 thông thường

Bây giờ, bạ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 khóa-giá trị của mình. 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 có 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 được sắp xếp ở trên của Grant Jenks. Nó sử dụng một số chiến lược khéo léo để khắc phục những hạn chế về hiệu suất điển hình

Bạn có bất kỳ triển khai thú vị hoặc hiệu suất nào của cấu trúc dữ liệu khóa-giá trị được sắp xếp không?

Loại bỏ các quảng cáo

Phần kết luận

Bạn đã chuyển 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 khóa-giá trị

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

  • Đã xem lại chức năng
    >>> words = ["aa", "ab", "ac", "ba", "cb", "ca"]
    >>> sorted(words)
    ['aa', 'ab', 'ac', 'ba', 'ca', 'cb']
    
    8
  • Chế độ xem từ điển đã khám phá
  • Hiểu cách từ điển được chuyển thành danh sách trong quá trình sắp xếp
  • Các phím 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 nhau
  • Đã sử dụng khả năng hiểu từ điển và hàm tạo
    >>> def select_second_character(word):
    ..     return word[1]
    ...
    >>> sorted(words, key=select_second_character)
    ['aa', 'ba', 'ca', 'ab', 'cb', 'ac']
    
    0 để xây dựng lại từ điển của bạn
  • Cân nhắc liệu từ điển đã sắp xếp có phải là cấu trúc dữ liệu phù hợp cho dữ liệu khóa-giá trị của bạn hay không

Giờ đây, bạn không chỉ sẵn sàng sắp xếp từ điển theo bất kỳ tiêu chí nào mà bạn có thể nghĩ đến mà còn để đánh giá xem từ điển đã 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 nhận xét bên dưới

Tải xuống miễn phí. Nhấp vào đây để tải xuống mã mà bạn sẽ sử dụng để sắp xếp các cặp khóa-giá trị trong hướng dẫn này

Đánh dấu là đã hoàn thành

🐍 Thủ thuật Python 💌

Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python

Python sắp xếp nhiều khóa

Gửi cho tôi thủ thuật Python »

Giới thiệu về Ian Currie

Python sắp xếp nhiều khóa
Python sắp xếp nhiều khóa

Ian là một mọt sách Python, người sử dụng nó cho mọi thứ, từ mày mò đến giúp mọi người và công ty quản lý công việc hàng ngày cũng như phát triển doanh nghiệp của họ

» Thông tin thêm về Ian


Mỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là

Python sắp xếp nhiều khóa

Aldren

Python sắp xếp nhiều khóa

Bartosz

Python sắp xếp nhiều khóa

Geir Arne

Python sắp xếp nhiều khóa

kate

Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Chuyên gia Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bạn nghĩ sao?

Đánh giá bài viết này

Tweet Chia sẻ Chia sẻ Email

Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?

Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi

Bạn có thể sắp xếp () một tuple không?

Sử dụng sắp xếp() . Hàm này sắp xếp danh sách tại chỗ và trả về Không. We can sort a tuple by converting it to a list first and then apply this function. This function sorts the list in place and returns None.

Sắp xếp trong Python có hiệu quả không?

Thuật toán Timsort được sử dụng trong Python thực hiện nhiều cách sắp xếp một cách hiệu quả vì thuật toán này có thể tận dụng bất kỳ thứ tự nào đã có trong tập dữ liệu.