Làm thế nào để bạn sắp xếp theo tên trong python?

Danh sách Python có một phương thức tích hợp để sửa đổi danh sách tại chỗ. Ngoài ra còn có một chức năng tích hợp để xây dựng danh sách được sắp xếp mới từ một lần lặp

Trong tài liệu này, chúng tôi khám phá các kỹ thuật khác nhau để sắp xếp dữ liệu bằng Python

Khái niệm cơ bản về sắp xếp

Một sắp xếp tăng dần đơn giản là rất dễ dàng. chỉ cần gọi chức năng. Nó trả về một danh sách được sắp xếp mới

>>> sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]

Bạn cũng có thể sử dụng phương pháp. Nó sửa đổi danh sách tại chỗ (và trả về

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
1 để tránh nhầm lẫn). Thông thường, nó kém tiện lợi hơn - nhưng nếu bạn không cần danh sách gốc, nó sẽ hiệu quả hơn một chút

>>> a = [5, 2, 3, 1, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]

Một điểm khác biệt nữa là phương thức này chỉ được định nghĩa cho danh sách. Ngược lại, chức năng chấp nhận bất kỳ iterable

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]

Chức năng chính

Cả hai và có một tham số chính để chỉ định một hàm (hoặc có thể gọi khác) sẽ được gọi trên mỗi phần tử danh sách trước khi thực hiện so sánh

Ví dụ: đây là so sánh chuỗi không phân biệt chữ hoa chữ thường

>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

Giá trị của tham số khóa phải là một hàm (hoặc hàm có thể gọi khác) nhận một đối số duy nhất và trả về một khóa để sử dụng cho mục đích sắp xếp. Kỹ thuật này nhanh vì chức năng chính được gọi chính xác một lần cho mỗi bản ghi đầu vào

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ố của đối tượng làm khóa. Ví dụ

>>> student_tuples = [
..     ('john', 'A', 15),
..     ('jane', 'B', 12),
..     ('dave', 'B', 10),
.. ]
>>> sorted(student_tuples, key=lambda student: student[2])   # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Kỹ thuật tương tự hoạt động cho các đối tượng có thuộc tính được đặt tên. Ví dụ

>>> class Student:
..     def __init__(self, name, grade, age):
..         self.name = name
..         self.grade = grade
..         self.age = age
..     def __repr__(self):
..         return repr((self.name, self.grade, self.age))

>>> student_objects = [
..     Student('john', 'A', 15),
..     Student('jane', 'B', 12),
..     Student('dave', 'B', 10),
.. ]
>>> sorted(student_objects, key=lambda student: student.age)   # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Chức năng mô-đun vận hành

Các mẫu hàm khóa hiển thị ở trên rất phổ biến, vì vậy Python cung cấp các hàm tiện lợi để thực hiện các hàm truy cập dễ dàng và nhanh hơn. Mô-đun có , và một chức năng

Sử dụng các chức năng đó, các ví dụ trên trở nên đơn giản và nhanh hơn

>>> from operator import itemgetter, attrgetter

>>> sorted(student_tuples, key=itemgetter(2))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

>>> sorted(student_objects, key=attrgetter('age'))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Các chức năng mô-đun toán tử cho phép nhiều cấp độ sắp xếp. Ví dụ: để sắp xếp theo lớp rồi theo tuổi

________số 8_______

Tăng dần và giảm dần

Cả hai và chấp nhận tham số đảo ngược với giá trị boolean. Điều này được sử dụng để đánh dấu các loại giảm dần. Ví dụ, để lấy dữ liệu sinh viên theo thứ tự tuổi đảo ngược

>>> sorted(student_tuples, key=itemgetter(2), reverse=True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

>>> sorted(student_objects, key=attrgetter('age'), reverse=True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

Sắp xếp Ổn định và Sắp xếp Phức tạp

Sắp xếp được đảm bảo là. Điều đó có nghĩa là khi nhiều bản ghi có cùng khóa, thứ tự ban đầu của chúng được giữ nguyên

>>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
>>> sorted(data, key=itemgetter(0))
[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]

Lưu ý cách hai bản ghi cho màu xanh da trời giữ nguyên thứ tự ban đầu của chúng để chắc chắn rằng

>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
3 đứng trước
>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
4

Thuộc tính tuyệt vời này cho phép bạn xây dựng các sắp xếp phức tạp trong một loạt các bước sắp xếp. Ví dụ: để sắp xếp dữ liệu học sinh theo lớp giảm dần rồi tuổi tăng dần, hãy thực hiện sắp xếp theo tuổi trước rồi sắp xếp lại bằng cách sử dụng lớp

>>> a = [5, 2, 3, 1, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]
0

Điều này có thể được trừu tượng hóa thành một hàm bao bọc có thể lấy một danh sách và bộ dữ liệu của trường và sắp xếp chúng theo nhiều lượt

>>> a = [5, 2, 3, 1, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]
1

Thuật toán Timsort được sử dụng trong Python thực hiện nhiều loại một cách hiệu quả vì nó có thể tận dụng mọi thứ tự đã có trong tập dữ liệu

Trang trí-Sắp xếp-Không trang trí

Thành ngữ này được gọi là Trang trí-Sắp xếp-Không trang trí sau ba bước của nó

  • Đầu tiên, danh sách ban đầu được trang trí bằng các giá trị mới kiểm soát thứ tự sắp xếp

  • Thứ hai, danh sách trang trí được sắp xếp

  • Cuối cùng, phần trang trí được loại bỏ, tạo danh sách chỉ chứa các giá trị ban đầu theo thứ tự mới

Ví dụ: để sắp xếp dữ liệu sinh viên theo lớp bằng cách sử dụng phương pháp DSU

>>> a = [5, 2, 3, 1, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]
2

Thành ngữ này hoạt động vì các bộ dữ liệu được so sánh theo từ điển;

Trong mọi trường hợp, không nhất thiết phải đưa chỉ mục i vào danh sách được trang trí, nhưng việc đưa chỉ mục này vào sẽ mang lại hai lợi ích

  • Sắp xếp ổn định – nếu hai mục có cùng khóa, thứ tự của chúng sẽ được giữ nguyên trong danh sách đã sắp xếp

  • Các mục ban đầu không cần phải so sánh được vì thứ tự của các bộ được trang trí sẽ được xác định bởi nhiều nhất hai mục đầu tiên. Vì vậy, ví dụ, danh sách ban đầu có thể chứa các số phức không thể sắp xếp trực tiếp

Một tên khác cho thành ngữ này là biến đổi Schwartzian, sau Randal L. Schwartz, người đã phổ biến nó cho các lập trình viên Perl

Giờ đây, việc sắp xếp Python cung cấp các hàm khóa, kỹ thuật này thường không cần thiết

Hàm so sánh

Không giống như các hàm chính trả về giá trị tuyệt đối để sắp xếp, hàm so sánh tính toán thứ tự tương đối cho hai đầu vào

Ví dụ: thang cân bằng so sánh hai mẫu đưa ra thứ tự tương đối. nhẹ hơn, bằng hoặc nặng hơn. Tương tự như vậy, một hàm so sánh chẳng hạn như

>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
5 sẽ trả về giá trị âm cho giá trị nhỏ hơn, 0 nếu giá trị đầu vào bằng nhau hoặc giá trị dương cho giá trị lớn hơn

Thường gặp hàm so sánh khi dịch thuật toán từ ngôn ngữ khác. Ngoài ra, một số thư viện cung cấp các chức năng so sánh như một phần của API của họ. Ví dụ, là một chức năng so sánh

Để phù hợp với những tình huống đó, Python cung cấp hàm so sánh để có thể sử dụng nó như một hàm chính

>>> a = [5, 2, 3, 1, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]
3

Vụn vặt

  • Để sắp xếp nhận biết ngôn ngữ, hãy sử dụng cho chức năng chính hoặc cho chức năng so sánh. Điều này là cần thiết vì thứ tự sắp xếp “theo bảng chữ cái” có thể khác nhau giữa các nền văn hóa ngay cả khi bảng chữ cái bên dưới giống nhau

  • Tham số đảo ngược vẫn duy trì tính ổn định sắp xếp (để các bản ghi có khóa bằng nhau giữ nguyên thứ tự ban đầu). Thật thú vị, hiệu ứng đó có thể được mô phỏng mà không cần tham số bằng cách sử dụng hàm dựng sẵn hai lần

    >>> a = [5, 2, 3, 1, 4]
    >>> a.sort()
    >>> a
    [1, 2, 3, 4, 5]
    
    4

  • Các thói quen sắp xếp sử dụng

    >>> student_tuples = [
    ..     ('john', 'A', 15),
    ..     ('jane', 'B', 12),
    ..     ('dave', 'B', 10),
    .. ]
    >>> sorted(student_tuples, key=lambda student: student[2])   # sort by age
    [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
    
    1 khi so sánh giữa hai đối tượng. Vì vậy, thật dễ dàng để thêm một thứ tự sắp xếp tiêu chuẩn vào một lớp bằng cách định nghĩa một phương thức
    >>> student_tuples = [
    ..     ('john', 'A', 15),
    ..     ('jane', 'B', 12),
    ..     ('dave', 'B', 10),
    .. ]
    >>> sorted(student_tuples, key=lambda student: student[2])   # sort by age
    [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
    
    2

    >>> a = [5, 2, 3, 1, 4]
    >>> a.sort()
    >>> a
    [1, 2, 3, 4, 5]
    
    5

    Tuy nhiên, lưu ý rằng

    >>> student_tuples = [
    ..     ('john', 'A', 15),
    ..     ('jane', 'B', 12),
    ..     ('dave', 'B', 10),
    .. ]
    >>> sorted(student_tuples, key=lambda student: student[2])   # sort by age
    [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
    
    1 có thể quay lại sử dụng
    >>> student_tuples = [
    ..     ('john', 'A', 15),
    ..     ('jane', 'B', 12),
    ..     ('dave', 'B', 10),
    .. ]
    >>> sorted(student_tuples, key=lambda student: student[2])   # sort by age
    [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
    
    4 nếu
    >>> student_tuples = [
    ..     ('john', 'A', 15),
    ..     ('jane', 'B', 12),
    ..     ('dave', 'B', 10),
    .. ]
    >>> sorted(student_tuples, key=lambda student: student[2])   # sort by age
    [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
    
    2 không được triển khai (xem )

  • Các chức năng chính không cần phụ thuộc trực tiếp vào các đối tượng được sắp xếp. Một chức năng chính cũng có thể truy cập các tài nguyên bên ngoài. Chẳng hạn, nếu điểm của sinh viên được lưu trữ trong từ điển, chúng có thể được sử dụng để sắp xếp danh sách tên sinh viên riêng biệt