Conceptos básicos de clasificación de Python

Conceptos básicos de clasificación de Python

Los más utilizados para ordenar en Python son list.sort() y sorted().

Uso básico

Python tiene funciones integradas sortedpara ordenar listas. Por ejemplo:

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

[1, 2, 3, 4, 5]

sortedHay un reverseparámetro cuyo valor predeterminado es Falsey el orden predeterminado es ascendente. Orden descendente si se establece en True:

sorted([5, 2, 3, 1, 4], reverse=True)

[5, 4, 3, 2, 1]

Si el objeto ordenado es una lista, también puedes usar la lista misma sort:

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

[1, 2, 3, 4, 5]

sortTambién hay reverseparámetros:

my_nums = [5, 2, 3, 1, 4]
my_nums.sort(reverse=True)
my_nums

[5, 4, 3, 2, 1]

Como se puede ver en el ejemplo anterior:

• sortSólo se puede utilizar con listas, sortedno sólo con listas, sino también con otros iterables.
• sortmutará la lista en sí, sortedno el iterable en sí, pero devolverá una nueva lista.

Entonces, ¿qué es un "objeto iterable"?
Para explicarlo claramente, no basta con terminar en tres o cinco oraciones, en pocas palabras, podemos entenderlo como un objeto que puede tomar valores en un bucle, como string, tuple, dictionary, sets, listetc.
Echemos un vistazo a un ejemplo:

my_string = '52314'
sorted(my_string)

['1', '2', '3', '4', '5']

# 字典是对 key 进行排序
my_dict = {
    
    'd': 5, 'b': 2, 'c':3, 'a': 4}
sorted(my_dict)

['a', 'b', 'c', 'd']

función de la tecla

list.sort()y sortedambos tienen una función clave cuya función es la misma. Llamada como parámetro, esta función se aplicará a cada objeto que deba ordenarse antes de ordenar.
Por ejemplo, en el ejemplo anterior, el diccionario ordena las claves, entonces, ¿cómo ordenar las claves según el valor?

my_dict = {
    
    'd': 5, 'b': 2, 'c':3, 'a': 4}
sorted(my_dict, key=lambda x : my_dict[x])

['b', 'c', 'a', 'd']

Más ejemplos de la documentación oficial de Python:

student_tuples = [
    ('john', 'A', 15),
    ('jane', 'B', 12),
    ('dave', 'B', 10),
]
sorted(student_tuples, key=lambda student: student[2])   # 根据年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

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)   # 根据年龄排序

[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

función del módulo operador

itemgetter()Las funciones , attrgetter()y en el módulo operador methodcaller()pueden simplificar y acelerar el uso de la función clave anterior.
Por ejemplo:

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

Clasificación compleja

El siguiente ejemplo muestra cómo invertir el orden de varios valores condicionales:

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

Todos los ejemplos anteriores están en orden ascendente, entonces, ¿qué pasa si hay orden ascendente y descendente?
Veamos el ejemplo oficial:

s = sorted(student_objects, key=attrgetter('age'))     # 先根据第二条件值年龄排序
sorted(s, key=attrgetter('grade'), reverse=True)       # 然后根据第一条件值排序，使用降序

[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

El contenido anterior se puede resumir en una función:

def multisort(xs, specs):
    for key, reverse in reversed(specs):
        xs.sort(key=attrgetter(key), reverse=reverse)
    return xs

multisort(list(student_objects), (('grade', True), ('age', False)))

[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

cambios de función

Las definiciones de funciones de Python 3 y Python 2 son diferentes y cmplos parámetros se eliminan.
Echemos un vistazo a la definición. La siguiente es la definición en Python 2.7.6:

>>> help(list.sort)
Help on method_descriptor:

sort(...)
    L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
    cmp(x, y) -> -1, 0, 1

>>> help(sorted)
Help on built-in function sorted in module __builtin__:

sorted(...)
    sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

Aquí está la definición en Python 3.9.12:

>>> help(list.sort)

Help on method_descriptor:

sort(self, /, *, key=None, reverse=False)
    Sort the list in ascending order and return None.
    
    The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
    order of two equal elements is maintained).
    
    If a key function is given, apply it once to each list item and sort them,
    ascending or descending, according to their function values.
    
    The reverse flag can be set to sort in descending order.

>>> help(sorted)

Help on built-in function sorted in module builtins:

sorted(iterable, /, *, key=None, reverse=False)
    Return a new list containing all items from the iterable in ascending order.
    
    A custom key function can be supplied to customize the sort order, and the
    reverse flag can be set to request the result in descending order.