Сортировка на языке Python

Питон

Метод sort является очень важным в языке программирования Python и его нельзя обойти мимо, так как он является фундаментом в вашем дальнейшем изучении Питона. Этот метод очень полезный, имеет кучу особенностей и интересных деталей, которые мы рассмотрим в данной статье.

Назначение и варианты использования

С помощью метода sort() вы можете отсортировать список в:

  • Порядке возрастания
  • Порядке убывания

Этот метод используется для сортировки списка на месте, что означает, что он мутирует его или изменяет непосредственно, не создавая дополнительных копий. Из-за этого вы должны использовать этот метод только в том случае, если:

  1. Вы хотите изменить (отсортировать) список навсегда.
  2. Вам не нужно сохранять исходную версию списка.

Если это соответствует вашим потребностям, то метод .sort () — это именно то, что вы ищете.

Синтаксис и аргументы

Давайте посмотрим, как вы можете вызвать .sort (), чтобы по максимуму использовать его. Это самый простой вызов (без аргументов):

<list>.sort()

Если вы не передаете никаких аргументов, то по умолчанию:

  • Список будет отсортирован в порядке возрастания.
  • Элементы списка будут сравниваться непосредственно с помощью их значений с помощью оператора <.

Например:

>>f = [7, 4, 7, 5, 8, 4, 10]
>>>f.sort()
>>>f
[7, 4, 7, 5, 8, 4, 10] # Разобрались!

Пользовательские Аргументы

Чтобы настроить работу метода sort (), можно передать два необязательных аргумента:

  • key
  • reverse

Давайте посмотрим, как они изменяют поведение этого метода. Здесь мы имеем вызов метода с этими двумя аргументами:

<list>.sort(key=<f>,reverse=<f>)

Прежде чем объяснить, как они работают, я хотел бы объяснить то, что вы, в вызове метода имена параметров должны быть включены перед их соответствующими значениями, например:

key=<f>
reverse=<value>

Это происходит потому, что они являются аргументами только для ключевых слов. Если вы передаете для них пользовательское значение, их имена должны быть указаны в вызове метода, за которым следует знак равенства = и соответствующие им значения, например:

<list>.sort(key=<f>,reverse=<value>)

TypeError: sort() не принимает позиционных аргументов

Reverse

Теперь, когда вы знаете, что такое аргументы только для ключевых слов, давайте обратимся к reverse. Значение reverse может быть как истинным, так и ложным:

  • False означает, что список будет отсортирован в порядке возрастания.
  • True означает, что список будет отсортирован в порядке убывания (обратном).

По умолчанию значение reverse равно False

# Список целых чисел
>>>f = [7, 4, 7, 5, 8, 4, 10]
>>>f.sort()
>>>f
[4, 4,5,7, 7, 8 , 10]
# Список строк
>>>r = [«B», «Q», «W», «E», «R»]
>>>r.sort()
>>>r
[‘B’, ‘E’, ‘R’, ‘Q’, ‘W’]

Как вы можете заметить, список из букв сортируется в алфавитном порядке. Чтобы указать, что reverse-верный, список должен быть отсортирован в порядке убывания (обратного).

# Список целых чисел
>>>f = [7, 4, 7, 5, 8, 4, 10]
>>>f.sort()
>>>f
[10, 9, 8, 7,7, 5,4, ]
# Список строк
>>> c = [«B», «Q», «W», «E», «R»]
>>>r.sort(reverse=True)
>>>r
[‘W’, ‘Q’, ‘R’, ‘E’, ‘B’]

Тут уже, как вы можете заметить, список букв сортируется в обратном порядке из-за метода reverse.

True

Теперь, когда вы знаете, как работать с обратным параметром, давайте посмотрим на параметр key.

Значение key:

None, это означает, что элементы списка будут сравниваться непосредственно. Например, в списке целых чисел сами целые числа могут быть использованы для сравнения. Функция одного аргумента, которая генерирует промежуточное значение для каждого элемента. Это промежуточное значение вычисляется только один раз и используется для сравнения в течение всего процесса сортировки.

Мы используем это, когда не хотим сравнивать элементы напрямую, например, когда мы хотим сравнить строки на основе их длины (промежуточное значение).

Например:

Допустим, мы хотим отсортировать список строк по их длине, от самой короткой строки до самой длинной. Мы можем передать функцию len в качестве значения ключа, например:

>> d = [«ddd», «ee», «r»]
>>>d.sort(key=len)
>>>d
[‘r’, ‘ee’, ‘ddd’]

Совет: Обратите внимание, что мы передаем только имя функции (len) без скобок, потому что мы не вызываем функцию. Это очень важно.

Обратите внимание на разницу между непосредственным сравнением элементов и сравнением их длины (Используя значение по умолчанию key (None), мы бы отсортировали строки по алфавиту (слева), но теперь мы сортируем их по длине (справа).

Что происходит за кулисами? Каждый элемент передается в качестве аргумента функции len (), а значение, возвращаемое этим вызовом функции, используется для выполнения сравнений в процессе сортировки. В результате получается список с другим критерием сортировки, которым является длина.

Вот еще один пример:

Другим интересным примером является сортировка списка строк, как если бы все они были написаны строчными буквами (например, делая «Аа» эквивалентным «аа»). Согласно лексикографическому порядку, заглавные буквы стоят перед строчными:

>> «E» < «e»

Таким образом, строка «Оля» будет стоять перед «Ольга» в отсортированном списке, даже если их строчные версии будут находиться в противоположном порядке:

>> «Оля» < «Ольга»
True
>>> «оля» < «ольга»
False

Чтобы избежать различия между заглавными и строчными буквами, мы можем передать функцию str.lower в качестве ключа. Это приведет к созданию строчной версии строк, которые будут использоваться для сравнения:

>> e = [«Оля», «ольга», «Аня», «Соня»]
>>>e.sort(key=str.lower)
>>> e
[«Аня», «ольга», «Оля», «Соня»]

Обратите внимание, что теперь «ольга» стоит перед «Ольга» в отсортированном списке, что именно то, что мы хотели.

Совет: если бы мы использовали процесс сортировки по умолчанию, все строки, начинающиеся с заглавной буквы, шли бы перед всеми строками, начинающимися со строчной буквы:

>> e = [«Оля», «ольга», «Аня», «Соня»]
>>>e.sort(key=str.lower)
>>> e
[«Аня», «Оля», «Соня», «ольга»]

Вот пример использования Объектно-ориентированного программирования (ООП). Если у нас есть этот очень простой класс Python:

>>class user:
def __init__(self, age):
self.age = age

И мы создаем четыре экземпляра:

>>user1 = Пользователь(68)
>>>user2 = Пользователь(24)
>>>user3 = Пользователь(14)
>>>user4 = Пользователь(36)

Мы можем составить список ссылок на них:

>>users= [user1, user2, user3, user4]

Затем, если мы определим функцию, чтобы получить возраст этих экземпляров:

>>defget_age(user):
returnuser.age.

Мы можем отсортировать список по их возрасту, передав функцию get_age в качестве аргумента:

>>userss.sort(key=get_age)

Это последняя, отсортированная версия списка. Мы используем цикл for для печати возраста экземпляров в том порядке, в котором они появляются в списке:

>>>for user in users:
print(user.age)

14
24
36
68

Именно то, что мы хотели – теперь список отсортирован в порядке возрастания в зависимости от возраста экземпляров.

Совет: Вместо определения функции get_age мы могли бы использовать лямбда-функцию для получения возраста каждого экземпляра, например:

>>users.sort(key=lambda x: x.age)

Лямбда-функции-это небольшие и простые анонимные функции, а это значит, что у них нет имени. Они очень полезны, когда мы хотим использовать их только в определенных местах в течение очень короткого периода времени.

Передача обоих аргументов

Потрясающе! Теперь вы знаете, как настроить функциональность метода sort (). Но вы можете поднять свои навыки на совершенно новый уровень, объединив эффект ключа и обратного в одном вызове метода:

>> f = [«D», «d», «E», «e», «T», «t»]
>>>f.sort(key=str.lower, reverse=True)
>>>f
[‘T’, ‘t’, ‘E’, ‘e’, ‘D’, ‘d’]

Сортируйте список в обратном порядке, как если бы все строки были в нижнем регистре.

Порядок аргументов только для ключевых слов не имеет значения. Поскольку мы указываем имена аргументов, мы уже знаем, какое значение соответствует какому параметру, поэтому мы можем включить либо ключ, либо реверс первым в список, и эффект будет точно таким же.

Итак, этот вызов метода:

<list>.sort(key=<f>,reverse=<f>)

Эквивалентно:

<list>.sort(reverse=<value>,key=<f>)

Это пример:

>> a = [«Tt», «b», «e», «g», «D»]
>>>a.sort(key=str.lower, reverse=True)
>>>а
[‘Tt’, ‘b’, ‘e’, ‘D’, ‘g’]

Если мы изменим порядок аргументов, то получим точно такой же результат:

>> a = [«Tt», «e», «b», «D», «g»]
>>>a.sort(reverse=True, key=str.lower)
>>>а
[‘Tt’, ‘g’, ‘e’, ‘D’, ‘b’]

Заключение

Метод sort() позволяет сортировать список в порядке возрастания или убывания. Он принимает два аргумента только для ключевых слов: key и reverse. reverse определяет, сортируется ли список в порядке возрастания или убывания. key — это функция, которая генерирует промежуточное значение для каждого элемента, и это значение используется для сравнения в процессе сортировки.

Метод sort() изменяет список, вызывая постоянные изменения. Вы должны быть очень осторожны и использовать его только в том случае, если вам не нужна оригинальная версия списка. Надеемся, что вам понравилась статья и она оказалась полезной. Теперь вы можете работать с методом sort() в своих проектах Python.

Оцените статью
Образовательный портал WELCOME4U.RU
Добавить комментарий

Adblock
detector