Hướng dẫn how do you use the sort function in python 3? - làm cách nào để bạn sử dụng hàm sắp xếp trong python 3?

Tác giả

Andrew Dalke và Raymond Hettinger

Phóng thích

0.1

Danh sách Python có phương thức

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
0 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
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
1 xây dựng một danh sách được sắp xếp mới từ một điều đáng tin cậy.

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.

Sắp xếp những điều cơ bản

Một loại tăng dần đơn giản là rất dễ dàng: chỉ cần gọi hàm

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
1. 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

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
0. 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]
4 để tránh nhầm lẫn). Thông thường, nó ít thuận tiện hơn
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
1 - nhưng nếu bạn không cần danh sách ban đầu, thì nó lại 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 khác là phương pháp

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
0 chỉ được xác định cho danh sách. Ngược lại, hàm
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
1 chấp nhận bất kỳ điều gì có thể.

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

Chức năng chính¶

Cả

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
0 và
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
1 đều có tham số chính để chỉ định hàm (hoặc có thể gọi khác) để được gọi trên mỗi phần tử danh sách trước khi so sánh.

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

>>> 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 có thể gọi khác) có 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ì hàm 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ố đối tượng là các 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 với cá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 chức năng khóa được hiển thị ở trên là rất phổ biến, do đó, Python cung cấp các chức năng tiện lợi để làm cho các chức năng của người truy cập dễ dàng và nhanh hơn. Mô -đun

>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
0 có hàm
>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
1,
>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
2 và hàm
>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
3.

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 cấp độ sau đó theo tuổi:

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

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

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

Cả

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
0 và
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
1 đều chấp nhận tham số ngược với giá trị boolean. Điều này được sử dụng để gắn cờ các loại giảm dần. Ví dụ: để lấy dữ liệu của học sinh theo thứ tự tuổi 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 sự ổn định và các loại phức tạp

Các loại được đảm bảo là ổn định. Điều đó có nghĩa là khi nhiều bản ghi có cùng một khóa, thứ tự ban đầu của chúng được bảo tồ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 Blue giữ lại thứ tự ban đầu của họ để

>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
6 được đảm bảo trước
>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
7.

Khách sạn tuyệt vời này cho phép bạn xây dựng các loại 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 bằng cấp giảm dần và sau đó tăng dần tuổi, hãy sắp xếp tuổi trước và sau đó sắp xếp lại bằng cấ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 trình bao bọc có thể lấy một danh sách và bộ dữ liệu của trường và đặt hàng để sắp xếp chúng trên nhiều đường chuyền.

>>> 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 hiệu quả vì nó có thể tận dụng bất kỳ thứ tự nào đã có trong bộ dữ liệu.

Cách cũ sử dụng trang trí-sort-undecigniat

Idiom này được gọi là trang trí-dort-undeconation sau ba bước của nó:

  • Đầu tiên, danh sách ban đầu được trang trí với 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, các trang trí được loại bỏ, tạo một 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 của học sinh theo cấ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 từ vựng; Các mục đầu tiên được so sánh; Nếu chúng giống nhau thì các mục thứ hai được so sánh, v.v.

Không cần thiết hoàn toàn cần thiết trong tất cả các trường hợp để đưa Chỉ số I vào danh sách được trang trí, nhưng bao gồm cả nó mang lại hai lợi ích:

  • Sắp xếp ổn định - nếu hai mục có cùng một khóa, đơn đặt hàng của chúng sẽ được bảo tồn trong danh sách được sắp xếp.

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

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

Bây giờ việc sắp xếp Python cung cấp các chức năng chính, kỹ thuật này không cần thiết.

Cách cũ sử dụng tham số CMP

Nhiều cấu trúc được đưa ra trong howto này giả định Python 2.4 trở lên. Trước đó, không có

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
1 tích hợp và
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
0 không đưa ra các đối số từ khóa. Thay vào đó, tất cả các phiên bản PY2.x đã hỗ trợ tham số CMP để xử lý các hàm so sánh được người dùng chỉ định.

Trong PY3.0, tham số CMP đã bị xóa hoàn toàn (như là một phần của nỗ lực lớn hơn để đơn giản hóa và thống nhất ngôn ngữ, loại bỏ xung đột giữa các so sánh phong phú và phương pháp ma thuật

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

Trong PY2.x, sắp xếp cho phép một chức năng tùy chọn có thể được gọi để thực hiện các so sánh. Hàm đó sẽ mất hai đối số để được so sánh và sau đó trả về giá trị âm cho ít hơn, trả về số 0 nếu chúng bằng nhau hoặc trả về giá trị dương cho lớn hơn. Ví dụ, chúng ta có thể làm:

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

Hoặc bạn có thể đảo ngược thứ tự so sánh với:

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

Khi chuyển mã từ Python 2.x đến 3.x, tình huống có thể phát sinh khi bạn có người dùng cung cấp chức năng so sánh và bạn cần chuyển đổi nó thành một chức năng chính. Bao bọc sau đây làm cho điều đó dễ dàng làm:

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

Để chuyển đổi thành chức năng chính, chỉ cần bọc hàm so sánh cũ:

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

Trong Python 3.2, hàm

>>> 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êm vào mô -đun
>>> 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 trong thư viện tiêu chuẩn.

ODD và kết thúc

  • Để sắp xếp nhận thức địa phương, hãy 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)]
    
    3 cho chức năng chính hoặ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)]
    
    4 cho hàm so sánh.

  • Tham số ngược vẫn duy trì sự ổn định sắp xếp (để các bản ghi có các khóa bằng nhau giữ lại 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

    >>> 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)]
    
    5 tích hợp hai lần:

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

  • 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)]
    
    6 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 xác định 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)]
    
    7:

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

    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)]
    
    6 có thể quay trở lại bằng cách 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)]
    
    9 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)]
    
    7 không được thực hiện (xem
    >>> 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)]
    
    1).

  • Các chức năng chính không cần phải 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 các lớp học sinh được lưu trữ trong từ điển, chúng có thể được sử dụng để sắp xếp một danh sách riêng các tên sinh viên:

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

Làm thế nào để bạn sử dụng chức năng sắp xếp trong Python?

Hàm python sort () hàm Sắp xếp () Trả về một danh sách được sắp xếp của đối tượng có thể lặp lại được chỉ định. Bạn có thể chỉ định thứ tự tăng dần hoặc giảm dần. Chuỗi được sắp xếp theo thứ tự bảng chữ cái, và các số được sắp xếp bằng số. Lưu ý: Bạn không thể sắp xếp một danh sách chứa cả giá trị chuỗi và giá trị số.The sorted() function returns a sorted list of the specified iterable object. You can specify ascending or descending order. Strings are sorted alphabetically, and numbers are sorted numerically. Note: You cannot sort a list that contains BOTH string values AND numeric values.

Làm thế nào để bạn sử dụng chức năng sắp xếp?

Chức năng sắp xếp Excel..
Bản tóm tắt.Hàm sắp xếp Excel sắp xếp các nội dung của một phạm vi hoặc mảng theo thứ tự tăng dần hoặc giảm dần.....
Phân loại phạm vi hoặc mảng ..
Mảng được sắp xếp ..
= Sort (mảng, [sort_index], [sort_order], [by_col]).
Mảng - phạm vi hoặc mảng để sắp xếp.Sort_index - [Tùy chọn] Chỉ mục cột để sử dụng để sắp xếp.....
Excel 2021 ..

Phương thức loại () là gì?

Phương thức Sắp xếp () sắp xếp các phần tử của một mảng tại chỗ và trả về tham chiếu đến cùng một mảng, hiện được sắp xếp.Thứ tự sắp xếp mặc định là tăng dần, được xây dựng khi chuyển đổi các yếu tố thành các chuỗi, sau đó so sánh các chuỗi các giá trị đơn vị mã UTF-16 của chúng.sorts the elements of an array in place and returns the reference to the same array, now sorted. The default sort order is ascending, built upon converting the elements into strings, then comparing their sequences of UTF-16 code units values.

Có một chức năng sắp xếp trong Python?

Danh sách Python có một phương thức Danh sách tích hợp.Sort () sửa đổi danh sách tại chỗ.Ngoài ra còn có một hàm tích hợp được sắp xếp () xây dựng một danh sách được sắp xếp mới từ một điều đáng tin cậy.. There is also a sorted() built-in function that builds a new sorted list from an iterable.