Mọi nhà khoa học máy tính đều thích sắp xếp mọi thứ. Trong bài viết này, tôi sẽ chỉ cho bạn cách bạn có thể sửa đổi hành vi sắp xếp mặc định của Python bằng đối số key
Định nghĩa và cách sử dụng. Để tùy chỉnh hành vi sắp xếp mặc định của phương pháp
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]8 và
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]9, hãy sử dụng đối số
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=lambda x: x[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]0 tùy chọn bằng cách chuyển một hàm trả về một giá trị có thể so sánh được cho từng phần tử trong danh sách
Sắp xếp danh sách Python[] – Hướng dẫn cơ bản
Xem video này trên YouTube
Dưới đây là một ví dụ tổng quan ngắn cho bạn thấy cách sử dụng các đối số trong thực tế
# Create an unsorted integer list lst = [88, 12, 42, 11, 2] # Sort the list in place [ascending] lst.sort[] print[lst] # [2, 11, 12, 42, 88] # Sort the list [leading number] lst.sort[key=lambda x: str[x][0]] print[lst] # [11, 12, 2, 42, 88]
Trong dòng đầu tiên của ví dụ, bạn tạo danh sách
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=lambda x: x[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]1. Sau đó, bạn sắp xếp danh sách một lần bằng cách sử dụng hành vi sắp xếp mặc định và một lần bằng cách sử dụng hành vi sắp xếp tùy chỉnh chỉ với chữ cái đầu tiên của số
Câu đố mật mã — Hãy tự mình thử
Bây giờ bạn đã biết những điều cơ bản. Hãy nâng cao hiểu biết của bạn bằng câu đố mã ngắn—bạn có giải được không?
Bạn cũng có thể giải câu đố này và theo dõi kỹ năng Python của mình trên ứng dụng Finxter tương tác của chúng tôi
cú pháp. Bạn có thể gọi phương thức này trên từng đối tượng danh sách trong Python [Python phiên bản 2. x và 3. x]. Đây là cú pháp
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=lambda x: x[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]2
Tranh luận
Đối số Mô tả_______2_______0[Tùy chọn. Mặc định>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=lambda x: x[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]4. ] Truyền một hàm nhận một đối số và trả về một giá trị có thể so sánh được. Hàm này sau đó được áp dụng cho từng phần tử trong danh sách. Sau đó, phương thức sắp xếp dựa trên kết quả của hàm chính thay vì chính các phần tử.
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=lambda x: x[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]5[Tùy chọn. Mặc định
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=lambda x: x[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]6. ] Thứ tự của các phần tử danh sách. Nếu
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=lambda x: x[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]6, sắp xếp theo thứ tự tăng dần. Nếu
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=lambda x: x[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]8, nó theo thứ tự giảm dần
Những bài viết liên quan
- Phương pháp danh sách Python [Tổng quan]
- Sắp xếp danh sách Python[] – Hướng dẫn cơ bản
- Danh sách Python – Mọi thứ bạn cần biết để bắt đầu
Khóa sắp xếp danh sách Python
Phương thức
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]8 lấy một hàm khác làm đối số tùy chọn
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=lambda x: x[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]0 cho phép bạn sửa đổi hành vi sắp xếp mặc định. Sau đó, hàm khóa được gọi trên từng phần tử danh sách và trả về một giá trị khác dựa trên đó việc sắp xếp được thực hiện. Do đó, hàm khóa nhận một đối số đầu vào [phần tử danh sách] và trả về một giá trị đầu ra [giá trị có thể so sánh được]
Đây là một ví dụ
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]
Bạn có thể thấy rằng trong hai ví dụ đầu tiên, danh sách được sắp xếp theo giá trị bộ đầu tiên trước. Trong ví dụ thứ ba, danh sách được sắp xếp theo giá trị bộ thứ hai trước. Bạn đạt được điều này bằng cách xác định một hàm khóa
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=itemgetter[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]1 lấy một phần tử danh sách
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=itemgetter[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]2 [một bộ] làm đối số và chuyển đổi nó thành một giá trị có thể so sánh được
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=itemgetter[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]3 [giá trị bộ thứ hai]
bài viết liên quan
- Giới thiệu về Hàm Lambda trong Python
Khóa sắp xếp danh sách Python Lambda
Các hàm lambda là các hàm ẩn danh không được xác định trong không gian tên [chúng không có tên]. Ở dạng đơn giản nhất, cú pháp là
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=itemgetter[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]4
Bạn ánh xạ đối số tới kết quả của biểu thức
Bạn có thể sử dụng cú pháp hàm lambda để xác định đối số chính của phương thức
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=itemgetter[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]5 tại chỗ
Đây là một ví dụ
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=lambda x: x[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]
Hàm lambda trả về giá trị bộ thứ hai của mỗi bộ trong danh sách. Đây là cơ sở mà thuật toán sắp xếp căn cứ vào thứ tự của nó
Khóa mặc định sắp xếp danh sách Python
Nếu bạn không xác định đối số khóa cho các phương thức
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]8 hoặc
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]9, thì Python vẫn đang sử dụng hàm khóa. Vì vậy, chức năng phím mặc định là gì?
Hãy suy nghĩ về điều này trong một thời điểm. ý nghĩa của chức năng chính là liên kết một “giá trị” có thể được sử dụng để so sánh. Vì vậy, bạn sẽ có thể thực hiện các thao tác so sánh sau trên các giá trị khóa thu được
Có nghĩa là gì để được so sánh?
OperatorMethod==>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=itemgetter[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]8!=
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=itemgetter[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]9
>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[key=lambda x: [x[1], x[0]]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]0>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[key=lambda x: [x[1], x[0]]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]1>
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[key=lambda x: [x[1], x[0]]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]2>=
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[key=lambda x: [x[1], x[0]]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]3
Nếu bạn triển khai tất cả các phương pháp đó, bạn có thể dễ dàng so sánh hai yếu tố. Tất cả các cấu trúc dữ liệu Python cơ bản đã triển khai chúng. Vì vậy, đừng lo lắng về nó
Hàm khóa mặc định trả về chính phần tử danh sách. Do đó, bản thân các phần tử danh sách là cơ sở của sự so sánh. Các quy trình so sánh được triển khai cho phép Python so sánh từng cặp phần tử danh sách để tìm một chuỗi đã sắp xếp
Danh sách Python Sort Key Itemgetter
Bạn có thể sử dụng bất kỳ chức năng nào làm chức năng chính để chuyển đổi một phần tử thành một phần tử [có thể so sánh] khác
Ví dụ: thường sử dụng hàm
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[key=lambda x: [x[1], x[0]]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]4 từ mô-đun
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[key=lambda x: [x[1], x[0]]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]5 để truy cập giá trị thứ i của một lần lặp
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=itemgetter[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]
Hàm
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[key=lambda x: [x[1], x[0]]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]4 thực hiện chính xác như hàm lambda trong ví dụ trước. nó trả về giá trị bộ dữ liệu thứ hai và sử dụng nó làm cơ sở để so sánh
Danh sách Python Sắp xếp khóa phụ
Làm cách nào để sắp xếp danh sách bằng hai phím? . Nhưng nếu có một sự ràng buộc [e. g.
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[key=lambda x: [x[1], x[0]]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]8 và
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[key=lambda x: [x[1], x[0]]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]9], bạn muốn sắp xếp sau giá trị bộ đầu tiên. Làm thế nào bạn có thể làm điều đó?
Theo mặc định, Python sắp xếp các bộ dữ liệu theo từ điển—giá trị bộ dữ liệu đầu tiên được xem xét trước. Chỉ khi có sự ràng buộc, nó mới nhận giá trị bộ thứ hai, v.v.
Vì vậy, để sắp xếp bằng “hai khóa”, bạn có thể xác định hàm khóa trả về một bộ thay vì chỉ một giá trị bộ đơn lẻ. Đây là một ví dụ
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[key=lambda x: [x[1], x[0]]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]
Giá trị bộ thứ hai được ưu tiên hơn giá trị bộ thứ nhất
Khóa sắp xếp danh sách Python Len
Vấn đề. Đưa ra một danh sách các chuỗi. Làm thế nào bạn có thể sắp xếp chúng theo chiều dài?
Thí dụ. Bạn muốn sắp xếp danh sách các chuỗi
lst = ['aaaa', 'bbb', 'cc', 'd'] lst.sort[key=len] print[lst]0 theo độ dài—bắt đầu bằng chuỗi ngắn nhất. Do đó, kết quả phải là
lst = ['aaaa', 'bbb', 'cc', 'd'] lst.sort[key=len] print[lst]1. Làm thế nào để đạt được điều đó?
Giải pháp. Sử dụng hàm
lst = ['aaaa', 'bbb', 'cc', 'd'] lst.sort[key=len] print[lst]2 làm đối số chính của phương thức
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]8 như thế này.
lst = ['aaaa', 'bbb', 'cc', 'd'] lst.sort[key=len] print[lst]4. Vì hàm
lst = ['aaaa', 'bbb', 'cc', 'd'] lst.sort[key=len] print[lst]2 là hàm tích hợp sẵn của Python nên bạn không cần nhập hoặc xác định bất kỳ thứ gì khác
Đây là giải pháp mã
lst = ['aaaa', 'bbb', 'cc', 'd'] lst.sort[key=len] print[lst]
Đầu ra là danh sách được sắp xếp theo độ dài của chuỗi
['d', 'cc', 'bbb', 'aaaa']
Bạn cũng có thể sử dụng kỹ thuật này để sắp xếp danh sách theo độ dài
Đảo ngược khóa sắp xếp danh sách Python
Để sắp xếp một danh sách theo thứ tự tăng dần có nghĩa là các phần tử được sắp xếp theo thứ tự từ nhỏ đến lớn. Theo mặc định, danh sách Python được sắp xếp theo thứ tự tăng dần
lst_1 = ['Bob', 'Alice', 'Frank'] lst_1.sort[] print[lst_1] # ['Alice', 'Bob', 'Frank'] lst_2 = [10, 8, 11, 2, 1] lst_2.sort[] print[lst_2] # [1, 2, 8, 10, 11]
Tuy nhiên, nếu bạn muốn sắp xếp theo thứ tự giảm dần [từ lớn đến bé] thì có thể sử dụng một trong hai cách sau
- Sử dụng phương thức
lst = ['aaaa', 'bbb', 'cc', 'd'] lst.sort[key=len] print[lst]
6 với đối sốlst = ['aaaa', 'bbb', 'cc', 'd'] lst.sort[key=len] print[lst]
7 - Sử dụng slice
lst = ['aaaa', 'bbb', 'cc', 'd'] lst.sort[key=len] print[lst]
8 để đảo ngược thứ tự của danh sách
Sự khác biệt giữa cả hai phương pháp là phương pháp đầu tiên thay đổi danh sách tại chỗ và phương pháp thứ hai tạo danh sách mới với các phần tử được sắp xếp theo thứ tự giảm dần
Đây là ví dụ
lst_1 = ['Bob', 'Alice', 'Frank'] lst_1.sort[reverse=True] print[lst_1] # ['Frank', 'Bob', 'Alice'] lst_2 = [10, 8, 11, 2, 1] lst_2.sort[] lst_2 = lst_2[::-1] print[lst_2] # [11, 10, 8, 2, 1]
Như bạn thấy, sử dụng đối số
lst = ['aaaa', 'bbb', 'cc', 'd'] lst.sort[key=len] print[lst]7 tốt hơn trong hầu hết các trường hợp
Tuple khóa sắp xếp danh sách Python
Vấn đề. Giả sử bạn có một danh sách các bộ dữ liệu
['d', 'cc', 'bbb', 'aaaa']0 và bạn muốn sắp xếp theo giá trị bộ dữ liệu thứ hai trước. Nhưng nếu có một sự ràng buộc [e. g.
['d', 'cc', 'bbb', 'aaaa']1 và
['d', 'cc', 'bbb', 'aaaa']2], bạn muốn sắp xếp sau giá trị bộ thứ ba. Nếu có một sự ràng buộc khác, bạn muốn sắp xếp sau giá trị bộ đầu tiên. Làm thế nào bạn có thể làm điều đó?
Theo mặc định, Python sắp xếp các bộ dữ liệu theo từ điển, điều đó có nghĩa là giá trị bộ dữ liệu đầu tiên được xem xét trước. Chỉ khi có sự ràng buộc, nó mới nhận giá trị bộ thứ hai, v.v.
Giải pháp. Xác định một hàm chính trả về một bộ thay vì chỉ một giá trị bộ đơn lẻ. Đây là một ví dụ
>>> lst = [[1,1,2], [0,0,1], [0,1,0], [0,1,2], [1,4,0]] >>> lst.sort[] >>> lst [[0, 0, 1], [0, 1, 0], [0, 1, 2], [1, 1, 2], [1, 4, 0]] >>> lst.sort[key=lambda x: [x[1],x[2],x[0]]] >>> lst [[0, 0, 1], [0, 1, 0], [0, 1, 2], [1, 1, 2], [1, 4, 0]]
Giá trị bộ thứ hai được ưu tiên hơn giá trị bộ thứ ba. Và giá trị bộ dữ liệu thứ ba được ưu tiên hơn giá trị bộ dữ liệu đầu tiên
Danh sách Python Sắp xếp theo khóa trong từ điển
Tiếp theo, bạn sẽ học cách sắp xếp danh sách từ điển theo tất cả các biến thể có thể có. [1] Vì vậy, hãy bắt đầu
Python – Cách sắp xếp danh sách từ điển?
Xem video này trên YouTube
Làm cách nào để sắp xếp danh sách từ điển theo giá trị?
Vấn đề. Đưa ra một danh sách các từ điển. Mỗi từ điển bao gồm nhiều cặp [khóa, giá trị]. Bạn muốn sắp xếp chúng theo giá trị của một khóa từ điển cụ thể [thuộc tính]. Làm thế nào để bạn sắp xếp từ điển này?
Ví dụ tối thiểu. Xem xét ví dụ sau khi bạn muốn sắp xếp danh sách từ điển tiền lương theo giá trị của khóa
['d', 'cc', 'bbb', 'aaaa']3
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]0
Đầu ra sẽ như thế này khi mức lương của Alice xác định thứ tự của từ điển
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]1
Giải pháp. Bạn có hai cách chính để thực hiện việc này—cả hai cách đều dựa trên việc xác định chức năng chính của các phương thức sắp xếp của Python. Hàm chính ánh xạ từng thành phần danh sách [trong trường hợp của chúng tôi là từ điển] thành một giá trị duy nhất có thể được sử dụng làm cơ sở so sánh
- Sử dụng hàm lambda làm chức năng chính để sắp xếp danh sách từ điển
- Sử dụng chức năng itemgetter làm chức năng chính để sắp xếp danh sách từ điển
Đây là mã của tùy chọn đầu tiên sử dụng hàm lambda trả về giá trị của khóa
['d', 'cc', 'bbb', 'aaaa']3 từ mỗi từ điển
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]2
Đầu ra là từ điển đã sắp xếp. Lưu ý rằng từ điển đầu tiên có mức lương nhỏ nhất của Alice và từ điển thứ ba có mức lương lớn nhất của Alice
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]3
Tự mình thử
Bạn sẽ tìm hiểu về cách thứ hai bên dưới [nơi bạn sử dụng hàm
['d', 'cc', 'bbb', 'aaaa']5 từ mô-đun
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[key=lambda x: [x[1], x[0]]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]5]
Các bài viết liên quan trên blog Finxter
- Cách sắp xếp danh sách từ điển trong Python [Hướng dẫn đầy đủ]
- Hàm Lambda
- từ điển
Danh sách Python Sắp xếp JSON theo khóa
Vấn đề. Đưa ra một đối tượng JSON dưới dạng danh sách từ điển trong Python. Sắp xếp từ điển theo giá trị của một thuộc tính nhất định
Thí dụ. Giả sử, bạn có một danh sách các đối tượng JSON [e. g. , một từ điển lồng nhau] và bạn muốn chúng sắp xếp theo thuộc tính JSON
['d', 'cc', 'bbb', 'aaaa']7
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]4
Mục tiêu của bạn là kết quả sau
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]5
Các đối tượng JSON được sắp xếp theo giá trị của thuộc tính
['d', 'cc', 'bbb', 'aaaa']7
Giải pháp. Sử dụng hàm khóa để giảm từng đối tượng JSON thành một giá trị duy nhất [
['d', 'cc', 'bbb', 'aaaa']9]. Sau đó sử dụng giá trị này làm cơ sở so sánh khi sắp xếp danh sách. Đây là mã
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]6
Bạn thực hiện ba bước sau
- Đầu tiên, bạn lấy từ điển bên trong với lệnh gọi
lst_1 = ['Bob', 'Alice', 'Frank'] lst_1.sort[] print[lst_1] # ['Alice', 'Bob', 'Frank'] lst_2 = [10, 8, 11, 2, 1] lst_2.sort[] print[lst_2] # [1, 2, 8, 10, 11]
0 cho mỗi phần tử danh sách>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=itemgetter[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]
2 - Thứ hai, bạn lấy giá trị chuỗi của thuộc tính
['d', 'cc', 'bbb', 'aaaa']
7 - Thứ ba, bạn chuyển đổi chuỗi thành số nguyên. Số nguyên này là cơ sở để so sánh và xác định thứ tự của danh sách đã sắp xếp
Cả ba bước đều cần thiết. Quên bất kỳ bước nào trong ba bước và nó sẽ không hoạt động
Các ví dụ về khóa sắp xếp danh sách Python
Chúng ta hãy xem một loạt ví dụ để thảo luận về chức năng chính của phương thức sắp xếp danh sách của Python
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]7
Hãy tự mình thử những ví dụ này trong trình bao tương tác của chúng tôi
Đi đâu từ đây
Phương thức
>>> lst = [[1,2], [3,2], [3,3], [1,0], [0,1], [4,2], [1,1], [0,2], [0,0]] >>> lst.sort[] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[0]] >>> lst [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [3, 2], [3, 3], [4, 2]] >>> lst.sort[key=lambda x: x[1]] >>> lst [[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [3, 2], [4, 2], [3, 3]]8 sắp xếp các phần tử danh sách tại chỗ theo cách tăng dần. Để tùy chỉnh hành vi sắp xếp mặc định, hãy sử dụng đối số
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=lambda x: x[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]0 tùy chọn bằng cách chuyển một hàm trả về giá trị có thể so sánh được cho từng phần tử trong danh sách. Với đối số Boolean
>>> from operator import itemgetter >>> customers = [['alice', 1000], ['bob', 100], ['frank', 10]] >>> customers.sort[key=lambda x: x[1]] [['frank', 10], ['bob', 100], ['alice', 1000]]5 tùy chọn, bạn có thể chuyển từ thứ tự tăng dần [
lst_1 = ['Bob', 'Alice', 'Frank'] lst_1.sort[] print[lst_1] # ['Alice', 'Bob', 'Frank'] lst_2 = [10, 8, 11, 2, 1] lst_2.sort[] print[lst_2] # [1, 2, 8, 10, 11]6] sang thứ tự giảm dần [
lst = ['aaaa', 'bbb', 'cc', 'd'] lst.sort[key=len] print[lst]7]
Nếu bạn tiếp tục vật lộn với những lệnh Python cơ bản đó và bạn cảm thấy bế tắc trong quá trình học tập của mình, thì tôi có thứ này cho bạn. Python One-Liners [Liên kết Amazon]
Trong cuốn sách này, tôi sẽ cung cấp cho bạn tổng quan kỹ lưỡng về các chủ đề khoa học máy tính quan trọng như học máy, biểu thức chính quy, khoa học dữ liệu, NumPy và kiến thức cơ bản về Python—tất cả trong một dòng mã Python
Lấy sách từ Amazon
MÔ TẢ SÁCH CHÍNH THỨC. Python One-Liners sẽ chỉ cho người đọc cách thực hiện các tác vụ hữu ích với một dòng mã Python. Sau phần giới thiệu ngắn gọn về Python, cuốn sách bao gồm các chủ đề nâng cao cần thiết như cắt, hiểu danh sách, phát sóng, hàm lambda, thuật toán, biểu thức chính quy, mạng thần kinh, hồi quy logistic, v.v. Mỗi phần trong số 50 phần của cuốn sách giới thiệu một vấn đề cần giải quyết, hướng dẫn người đọc các kỹ năng cần thiết để giải quyết vấn đề đó, sau đó cung cấp một giải pháp Python ngắn gọn với lời giải thích chi tiết
Chris
Trong khi làm việc với tư cách là một nhà nghiên cứu trong các hệ thống phân tán, Dr. Christian Mayer tìm thấy tình yêu của mình với việc dạy sinh viên khoa học máy tính
Để giúp sinh viên đạt được mức độ thành công Python cao hơn, anh ấy đã thành lập trang web giáo dục lập trình Finxter. com. Ông là tác giả của cuốn sách lập trình nổi tiếng Python One-Liners [NoStarch 2020], đồng tác giả của loạt sách tự xuất bản Coffee Break Python, người đam mê khoa học máy tính, cộng tác viên tự do và chủ sở hữu của một trong 10 blog Python lớn nhất thế giới
Niềm đam mê của anh ấy là viết, đọc và mã hóa. Nhưng niềm đam mê lớn nhất của anh ấy là phục vụ các lập trình viên đầy tham vọng thông qua Finxter và giúp họ nâng cao kỹ năng của mình. Bạn có thể tham gia học viện email miễn phí của anh ấy tại đây