Hướng dẫn how do you add a comparator in python? - làm thế nào để bạn thêm một bộ so sánh trong python?

Trong Python 3 không có đối số

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 cho hàm

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

2 (cũng như đối với

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

3).

Theo các tài liệu, chữ ký hiện là

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

4, vì vậy bạn phải sử dụng hàm

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5 để thực hiện một loại tùy chỉnh. Các tài liệu đề xuất:

Sử dụng

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

6 để chuyển đổi hàm CMP kiểu cũ thành chức năng chính.

Đây là một ví dụ:

>>> def compare(x, y):
...     return x[0] - y[0]
... 
>>> data = [(4, None), (3, None), (2, None), (1, None)]
>>> from functools import cmp_to_key
>>> sorted(data, key=cmp_to_key(compare))
[(1, None), (2, None), (3, None), (4, None)]

Tuy nhiên, chức năng của bạn cũng không phù hợp với giao thức chức năng

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 cũ, vì nó trả về

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

8 hoặc

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

9. Đối với tình huống cụ thể của bạn, bạn có thể làm:

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

Sử dụng chức năng

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

0 từ câu trả lời của @Fred Foo.

Trong khoa học máy tính, một thuật toán sắp xếp đặt các yếu tố của một danh sách vào một thứ tự cụ thể. Chúng rất quan trọng vì chúng thường làm giảm sự phức tạp của một vấn đề. Hãy cùng khám phá cách sử dụng các chức năng sắp xếp tùy chỉnh để thực hiện các đơn đặt hàng và so sánh tùy chỉnh trong Python.

Trong bài viết trước của tôi về làm việc với các luồng trong Python, tôi đã giới thiệu ngắn gọn các phương thức sắp xếp với danh sách.sort () và Sắp xếp (). Cả

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

1 và

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

2 đều có tham số chính chỉ định hàm được gọi trên mỗi phần tử danh sách trước khi so sánh.

Trong bài viết này, tôi muốn đi xa hơn về chủ đề sắp xếp và khám phá cách viết một chức năng sắp xếp tùy chỉnh trong Python. Nói cách khác, tôi sẽ giải thích cách sử dụng hàm Lambda tùy chỉnh làm tham số chính.

Nếu bạn không thoải mái với các chức năng Python, bạn nên đọc cách xác định một chức năng trong Python trước khi đi sâu hơn vào bài viết này.

Sắp xếp với chức năng sắp xếp tùy chỉnh trong Python

Đầu tiên, hãy để nói về sự khác biệt giữa

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

3 và

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

2. Về mặt cú pháp,

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

3 là một phương thức thể hiện được thực hiện là

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

6, trong khi

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

2 được sử dụng là

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

8.

Một điều quan trọng cần lưu ý là

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

3 sửa đổi trực tiếp biến ban đầu và do đó, thứ tự ban đầu sẽ bị mất.

Mặt khác,

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

2 giữ một bản sao của biến ban đầu, giúp bạn có thể trở lại thứ tự ban đầu nếu cần. Bởi vì

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

3 không tạo ra bất kỳ bản sao nào của biến ban đầu, nên nó hiệu quả hơn một chút so với

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

2. Tuy nhiên, điều này đến với chi phí thuận tiện.

Cũng cần lưu ý rằng

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

2 sẽ trả về một danh sách; Do đó, bạn phải gán đầu ra cho một biến mới.

Đối với

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

1, nó sửa đổi danh sách tại chỗ và không có giá trị trả về. Cuối cùng nhưng không kém phần quan trọng,

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

1 chỉ có thể hoạt động trong danh sách trong khi

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

2 chấp nhận bất kỳ điều đó.

Ví dụ: ở đây, một so sánh chuỗi không nhạy cảm trường hợp:

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

Lưu ý: Thông thường việc chuyển chức năng Lambda tùy chỉnh như một tham số chính để sắp xếp các đối tượng phức tạp trong Python. It is common to pass a custom lambda function as a key parameter to sort complex objects in Python.

Bây giờ, hãy để nói về các chức năng sắp xếp tùy chỉnh trong Python. Trong Python, chúng ta có thể viết các chức năng sắp xếp tùy chỉnh hoạt động với

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

3 và

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

2.

Giá trị của tham số chính phải là một hàm có một đối số duy nhất và trả về

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5 cho mục đích sắp xếp. Bởi vì hàm chính chỉ được gọi một lần cho mỗi bản ghi đầu vào, đây là một cách hiệu quả để thực hiện phân loại trong Python.

Một mẫu phổ biến là sắp xếp các đối tượng phức tạp bằng cách sử dụng một số chỉ số đối tượng là

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5. Ví dụ: chúng ta có thể xác định một đơn đặt hàng tùy chỉnh để sắp xếp danh sách các bộ dữ liệu:

>>> pokemon = [
...    ('Charmander', 'Fire', 52),
...    ('Blastoise', 'Water', 83),
...    ('Beedrill', 'Poison', 90),
... ]
>>> sorted(pokemon, key=lambda x: x[2])   # sort by attack power
[('Charmander', 'Fire', 52),
 ('Blastoise', 'Water', 83),
 ('Beedrill', 'Poison', 90)]

Nó cũng hoạt động cho các đối tượng có thuộc tính tên:

>>> class Pokemon:
...    def __init__(self, name, category, attack):
...        self.name = name
...        self.category = category
...        self.attack = attack
...    def __repr__(self):
...        return repr((self.name, self.category, self.attack))



>>> pokemon_objects = [
...    Pokemon('Beedrill', 'Poison', 90),
...    Pokemon('Charmander', 'Fire', 52),
...    Pokemon('Blastoise', 'Water', 83),
...            ]
>>> sorted(pokemon_objects, key=lambda x: x.attack)   # sort by attack
[('Charmander', 'Fire', 52),
 ('Blastoise', 'Water', 83),
 ('Beedrill', 'Poison', 90)]

Bạn có thể tìm hiểu thêm về các đối tượng tùy chỉnh trong Python trong bài viết Các bước đơn giản để tạo lớp của riêng bạn trong Python.

Biết cách thao tác dữ liệu, viết các chức năng sắp xếp tùy chỉnh trong Python và thực hiện các so sánh tùy chỉnh là những kỹ năng cần thiết để làm chủ. Giới thiệu của chúng tôi về Python cho khoa học dữ liệu là một cách tuyệt vời để chọn bộ kỹ năng theo yêu cầu này.

So sánh tùy chỉnh với chức năng sắp xếp trong Python

Bạn cũng có thể sử dụng

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

2 với bộ so sánh tùy chỉnh làm tham số của nó.

Trong Python 2,

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

2 có thể được triển khai với bộ so sánh tùy chỉnh,

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 hoặc tham số

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5.

Điều quan trọng cần lưu ý là

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 cần phải vượt qua hai tham số (x và y) là các phần của danh sách. Nó sẽ trả về một số với logic sau:

• Nếu nó trả về một số dương: x> y
• Nếu nó trả về 0: x == y
• Nếu nó trả về một số âm: x

Tuy nhiên,

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5 nhận được một tham số, tính toán kết quả và sau đó sử dụng tính toán để sắp xếp và so sánh. Điều này có nghĩa là trong Python 2, bạn có thể sắp xếp một danh sách các số theo giá trị khối của chúng theo hai cách khác nhau:

>>> l = [6, 8, 10, 23, -4, -7]
>>> # The cmp parameter has been removed in Python 3
>>> sorted_l = sorted(l, cmp=lambda x, y: x ** 3 - y ** 3) # Sort with cmp
>>> sorted_l = sorted(l, key=lambda x: x ** 3) # Sort with key
>>> print(sorted_l)
[-7, -4, 6, 8, 10, 23]

Trong Python 3, tham số

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 đã bị xóa, chủ yếu vì hai lý do.

Đầu tiên, mọi thứ được thực hiện với

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 có thể được thực hiện với

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5. Thứ hai,

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5 nhanh hơn

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1. Khi

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 được truyền dưới dạng tham số, thuật toán sắp xếp so sánh các cặp giá trị và hàm so sánh được gọi là nhiều lần cho mỗi mục.

Mặt khác, khóa chỉ thực hiện tính toán một lần. Do đó, sự phức tạp được giảm. Điều này làm cho mã ít bị lỗi, vì cú pháp được đơn giản hóa. .

Nếu bạn quen thuộc với Java hoặc C ++, bạn có thể quen thuộc với

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 hơn

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5. Trên thực tế, trong Python 3, bạn có thể sử dụng

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 với

>>> l = [6, 8, 10, 23, -4, -7]
>>> # The cmp parameter has been removed in Python 3
>>> sorted_l = sorted(l, cmp=lambda x, y: x ** 3 - y ** 3) # Sort with cmp
>>> sorted_l = sorted(l, key=lambda x: x ** 3) # Sort with key
>>> print(sorted_l)
[-7, -4, 6, 8, 10, 23]

6, sẽ chuyển đổi

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 thành

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5. Hãy khám phá điều này nhiều hơn trong phần tiếp theo.

Các chức năng sắp xếp tùy chỉnh trong Python với functools.cmp_to_key (Func)

functools.cmp_to_key (FUNC) được sử dụng để chuyển đổi hàm so sánh kiểu cũ thành hàm chính. Nó có sẵn trong Python 2.7, Python 3.2 và sau đó.

Theo tài liệu Python 3, hàm so sánh là bất kỳ khả năng gọi nào chấp nhận hai đối số, so sánh chúng và trả về một số âm cho ít hơn, bằng không về bình đẳng hoặc số dương cho lớn hơn. Hàm

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5 là một hàm có thể gọi được chấp nhận một đối số và trả về một giá trị khác sẽ được sử dụng làm loại

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5.

Trước Python 2.4, không có Sắp xếp () và list.sort () & nbsp; Không có đối số từ khóa. Thay vào đó, Python 2 đã hỗ trợ tham số

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 để xử lý các hàm so sánh do người dùng chỉ định.

Khi chuyển mã từ Python 2 sang Python 3, bạn có thể phải chuyển đổi hàm từ

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 thành

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5. Trong Python 3,

>>> l = [6, 8, 10, 23, -4, -7]
>>> # The cmp parameter has been removed in Python 3
>>> sorted_l = sorted(l, cmp=lambda x, y: x ** 3 - y ** 3) # Sort with cmp
>>> sorted_l = sorted(l, key=lambda x: x ** 3) # Sort with key
>>> print(sorted_l)
[-7, -4, 6, 8, 10, 23]

6 đã được giới thiệu để tạo điều kiện cho quá trình này.

Chúng tôi sẽ sử dụng

>>> l = [6, 8, 10, 23, -4, -7]
>>> # The cmp parameter has been removed in Python 3
>>> sorted_l = sorted(l, cmp=lambda x, y: x ** 3 - y ** 3) # Sort with cmp
>>> sorted_l = sorted(l, key=lambda x: x ** 3) # Sort with key
>>> print(sorted_l)
[-7, -4, 6, 8, 10, 23]

6 với các chức năng chấp nhận các chức năng chính như

>>> sorted("LearnPython.com is awesome to learn about custom sort functions in Python".split(), key=str.lower)
['about', 'awesome', 'custom', 'functions', 'in', 'is'
 'Learn', 'LearnPython.com', 'Python', 'sort', 'to']

2 hoặc

>>> import functools

>>> l = [6, 8, 10, 23, -4, -7]

>>> def compare(x, y):
...    return x ** 3 - y ** 3

>>> sorted_l = sorted(l, key=functools.cmp_to_key(compare))
>>> print(sorted_l)
[-7, -4, 6, 8, 10, 23]

7, mà tôi đã nói trong bài viết trước của tôi. Sử dụng ví dụ trước của chúng tôi để sắp xếp các số theo giá trị khối của chúng, bạn có thể viết hàm

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 tùy chỉnh như sau:

>>> import functools

>>> l = [6, 8, 10, 23, -4, -7]

>>> def compare(x, y):
...    return x ** 3 - y ** 3

>>> sorted_l = sorted(l, key=functools.cmp_to_key(compare))
>>> print(sorted_l)
[-7, -4, 6, 8, 10, 23]

Đôi khi, sử dụng khóa có thể ít rõ ràng hơn

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1. Trong trường hợp này, có thể tốt hơn là sử dụng

>>> l = [6, 8, 10, 23, -4, -7]
>>> # The cmp parameter has been removed in Python 3
>>> sorted_l = sorted(l, cmp=lambda x, y: x ** 3 - y ** 3) # Sort with cmp
>>> sorted_l = sorted(l, key=lambda x: x ** 3) # Sort with key
>>> print(sorted_l)
[-7, -4, 6, 8, 10, 23]

6, vì nó có thể dễ đọc và trực quan hơn.

Ví dụ, trong năm ngoái, Matur Matura (một kỳ thi Ba Lan tương tự như A, Abitur hoặc Baccalauréat), phần CNTT tùy chọn có một bài tập bao gồm điều này:

Cặp (Số1, Word1) nhỏ hơn cặp (Số 2, Word2) IF:smaller than pair (number2, word2) if:

• Số1

Or:

• Number1 == number2 và word1 nhỏ hơn bảng chữ cái so với word2.

Ví dụ, cặp (1, BBBB) nhỏ hơn cặp (2, AAA), nhưng cặp (3, AAA) nhỏ hơn cặp (3, AB).

Nói cách khác, chúng tôi muốn cặp được sắp xếp theo thứ tự tăng dần trên phần tử thứ nhất và phần tử thứ hai.

Do đó, chúng tôi hy vọng các cặp sẽ được trả lại theo thứ tự sau: & nbsp; (1, BBBB), (2, AAA), (3, AAA), (3, AB).(1, bbbb), (2, aaa), (3, aaa), (3, ab).

Dưới đây là chức năng

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 tùy chỉnh để giải quyết vấn đề này:

from functools import cmp_to_key

def compare(pair1, pair2):
	number1, word1 = pair1
	number2, word2 = pair2
	if number1 == number2:
		if word1 < word2:
			return -1
		else:
			return 1
	if number1 < number2:
		return -1
	else:
		return 1

compare_key = cmp_to_key(compare)

Nhưng ngay cả trong trường hợp này, chúng ta có thể giải quyết vấn đề với

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5 bằng cách sắp xếp một danh sách các bộ dữ liệu:

>>> # List of tuples
>>> l = [(3, 'aaa'), (1, 'bbbb'), (3, 'ab'), (2, 'aaa')]

>>> # Sort with key on first and second element of each tuple
>>> sorted(l, key = lambda x: (x[0], x[1])) 
[(1, 'bbbb'), (2, 'aaa'), (3, 'aaa'), (3, 'ab')]

Chúng ta cũng có thể cố gắng làm cho vấn đề trở nên khó khăn hơn bằng cách sắp xếp yếu tố đầu tiên theo thứ tự giảm dần và phần thứ hai theo thứ tự tăng dần. Một lần nữa, chúng ta có thể giải quyết nó bằng

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5:

>>> # Sort number in descending order and word in ascending order
>>> sorted(l, key = lambda x: (-x[0], x[1]))
[(3, 'aaa'), (3, 'ab'), (2, 'aaa'), (1, 'bbbb')]

Giả sử chúng ta xoay chuyển vấn đề theo cách khác, với yếu tố đầu tiên theo thứ tự tăng dần và thứ hai theo thứ tự giảm dần. Trong trường hợp này, việc vượt qua tham số

from functools import cmp_to_key

def compare(pair1, pair2):
	number1, word1 = pair1
	number2, word2 = pair2
	if number1 == number2:
		if word1 < word2:
			return -1
		else:
			return 1
	if number1 < number2:
		return -1
	else:
		return 1

compare_key = cmp_to_key(compare)

4 là

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

8 sẽ giải quyết nó.

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

0

Thật khó khăn khi tìm thấy một trường hợp mà

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 không thể được thay thế bằng

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5. Bởi vì hiệu suất

>>> l = [6, 8, 10, 23, -4, -7]
>>> # The cmp parameter has been removed in Python 3
>>> sorted_l = sorted(l, cmp=lambda x, y: x ** 3 - y ** 3) # Sort with cmp
>>> sorted_l = sorted(l, key=lambda x: x ** 3) # Sort with key
>>> print(sorted_l)
[-7, -4, 6, 8, 10, 23]

6 rất chậm so với

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

5, nên nó chỉ nên được sử dụng như là phương sách cuối cùng để thực hiện chức năng sắp xếp tùy chỉnh trong Python.

Nếu bạn muốn biết thêm về các chức năng ánh xạ, hãy xem bài viết của tôi trên Filter (), map () và giảm ().

Đóng suy nghĩ về các chức năng sắp xếp tùy chỉnh trong Python

Trong bài viết này, chúng tôi đã khám phá cách thực hiện các chức năng sắp xếp và so sánh tùy chỉnh trong Python. Chúng tôi đã học được một chút lịch sử Python và cố gắng hiểu các lựa chọn được thực hiện với

>>> your_key = cmp_to_key(make_comparator(cmpValue))
>>> sorted(data, key=your_key)
[(1, None), (2, None), (3, None), (4, None)]

1 và chìa khóa giữa Python 2 và 3 để thực hiện các chức năng sắp xếp tùy chỉnh trong Python.

Để hiểu rõ hơn các khái niệm được giải thích trong các bài viết này, luôn luôn là một ý tưởng tốt để chơi với đoạn mã và xây dựng các ví dụ của riêng bạn.

Cuối cùng, nếu bạn muốn tìm hiểu thêm về thao tác dữ liệu trong Python, hãy thoải mái kiểm tra bài viết tuyệt vời của Yigit, về cách lọc hàng và chọn các cột trong khung dữ liệu Python với gấu trúc.

Và nếu bạn muốn đưa mọi thứ lên một tầm cao mới, hãy thử bài hát Python for Data Science của chúng tôi. Học hỏi!

Python có một bộ so sánh không?

Làm thế nào để bạn sử dụng các bộ so sánh trong Python?

Làm cách nào để tạo ra một bộ so sánh tùy chỉnh trong Python?

Hàm so sánh trong Python là gì?