Метод массива списка сортировки Python - восходящий и по убыванию объясняется примерами

Автор оригинала: Estefania Cassingena Navone.

Если вы хотите узнать, как работать с Сортировать () Метод в ваших проектах Python, тогда эта статья для вас. Этот метод очень мощный, и вы можете настроить его, чтобы соответствовать вашим потребностям, поэтому давайте посмотрим, как он работает подробно.

Ты выучишь:

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

Вы готовы? Давайте начнем! ⭐.

🔹 Цель и использование случаев

С Сортировать () Способ, вы можете отсортировать список в либо:

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

Этот метод используется для сортировки списка на месте, что означает, что это Мутации Это или изменяет его непосредственно без создания дополнительных копий, поэтому помните:

Вы узнаете больше о мутации в этой статье (обещаю!), Но на данный момент очень важно, чтобы вы знали, что Сортировать () Метод изменяет список, поэтому его оригинальная версия потеряна.

Из-за этого вы должны использовать только этот метод, если:

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

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

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

Давайте посмотрим, как вы можете позвонить .sort () воспользоваться его полной властью.

Это самый простой вызов (без аргументов):

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

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

Например:

>>> b = [6, 3, 8, 2, 7, 3, 9]
>>> b.sort()
>>> b
[2, 3, 3, 6, 7, 8, 9] # Sorted!

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

Настроить, как Сортировать () Способ работает, вы можете пройти два дополнительных аргумента:

Ключ
Обеспечить регресс

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

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

ключ =
Reverse = <значение>

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

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

TypeError: sort() takes no positional arguments

Обеспечить регресс

Теперь, когда вы знаете, какие аргументы только ключевых слов, давайте начнем с Обратный Отказ

Значение Обратный может быть либо Правда или Ложь :

Ложь означает, что список будет отсортирован в порядке возрастания.
Правда означает, что список будет отсортирован в убывании (обратный) порядок.

💡 Совет: По умолчанию его значение – Ложь – Если вы не передадите никакие аргументы для этого параметра, список отсортирован в порядке возрастания.

Здесь у нас есть несколько примеров:

# List of Integers
>>> b = [6, 3, 8, 2, 7, 3, 9]
>>> b.sort()
>>> b
[2, 3, 3, 6, 7, 8, 9]

# List of Strings
>>> c = ["A", "Z", "D", "T", "U"]
>>> c.sort()
>>> c
['A', 'D', 'T', 'U', 'Z']

💡 Совет: Если элементы списка являются строки, они сортируются в алфавитном порядке.

# List of Integers
>>> b = [6, 3, 8, 2, 7, 3, 9]
>>> b.sort(reverse=True)
>>> b
[9, 8, 7, 6, 3, 3, 2]

# List of Strings
>>> c = ["A", "Z", "D", "T", "U"]
>>> c.sort(reverse=True)
>>> c
['Z', 'U', 'T', 'D', 'A']

💡 Совет: Обратите внимание, как список отсортирован в порядке убывания, если Обратный это Правда Отказ

Ключ

Теперь, когда вы знаете, как работать с Обратный Параметр, давайте посмотрим ключ параметр.

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

Значение ключ это либо:

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

💡 Совет: По умолчанию значение ключ это Нет Таким образом, элементы сравниваются напрямую.

Например:

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

>>> d = ["aaa", "bb", "c"]
>>> d.sort(key=len)
>>> d
['c', 'bb', 'aaa']

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

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

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

Это приводит к списку с различными критериями сортировки: длина.

Здесь у нас есть еще один пример:

Еще одним интересным примером является сортировка списка строк, как если бы они все были написаны в строчных буквах (например, создавая «AA», эквивалентную «АА»).

Согласно лексикографическому заказу, заглавные буквы приходят до строчных букв:

>>> "E" < "e"
True

Так что строка "Эмма" придет до «Эмили» В отсортированном списке, даже если их строчные версии будут в противоположном порядке:

>>> "Emma" < "emily"
True
>>> "emma" < "emily"
False

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

>>> e = ["Emma", "emily", "Amy", "Jason"]
>>> e.sort(key=str.lower)
>>> e
['Amy', 'emily', 'Emma', 'Jason']

Обратите внимание, что сейчас «Эмили» приходит до "Эмма" В сортировке, который именно то, что мы хотели.

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

>>> e = ["Emma", "emily", "Amy", "Jason"]
>>> e.sort()
>>> e
['Amy', 'Emma', 'Jason', 'emily']

Вот пример с использованием объектно-ориентированного программирования (OOP):

Если у нас есть этот очень простой класс Python:

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

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

>>> client1 = Client(67)
>>> client2 = Client(23)
>>> client3 = Client(13)
>>> client4 = Client(35)

Мы можем сделать список, который ссылается на них:

>>> clients = [client1, client2, client3, client4]

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

>>> def get_age(client):
	return client.age

Мы можем отсортировать список, исходя из их возраста, передавая Get_age Функция аргумент:

>>> clients.sort(key=get_age)

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

>>> for client in clients:
	print(client.age)

	
13
23
35
67

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

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

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

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

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

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

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

>>> f = ["A", "a", "B", "b", "C", "c"]
>>> f.sort(key=str.lower, reverse=True)
>>> f
['C', 'c', 'B', 'b', 'A', 'a']

Это различные комбинации аргументов и их эффект:

Порядок аргументов только ключевых слов не имеет значения

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

Так что этот метод вызова:

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

Это пример:

>>> a = ["Zz", "c", "y", "o", "F"]
>>> a.sort(key=str.lower, reverse=True)
>>> a
['Zz', 'y', 'o', 'F', 'c']

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

>>> a = ["Zz", "c", "y", "o", "F"]
>>> a.sort(reverse=True, key=str.lower)
>>> a
['Zz', 'y', 'o', 'F', 'c']

🔹 возвращаемое значение

Теперь давайте немного поговорим о возвращенном значении этого метода. Сортировать () Метод возвращает Нет – Это делает не Верните отсортированную версию списка, как мы могли бы интуитивно ожидать.

Согласно Документация Python :

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

Это пример возвращаемого значения Сортировать () :

>>> nums = [6.5, 2.4, 7.3, 3.5, 2.6, 7.4]

# Assign the return value to this variable:
>>> val = nums.sort()

# Check the return value:
>>> print(val)
None

Видеть? Нет был возвращен по телефону.

💡 Совет: Очень важно не путать Сортировать () Метод с отсортировано () Функция, которая является функцией, которая работает очень похожи, но не Измените исходный список. Вместо этого отсортировано () Создает и возвращает новую копию списка, уже отсортирован.

Это пример, который мы можем использовать для их сравнения:

# The sort() method returns None
>>> nums = [6.5, 2.4, 7.3, 3.5, 2.6, 7.4]
>>> val = nums.sort()
>>> print(val)
None

# sorted() returns a new sorted copy of the original list
>>> nums = [6.5, 2.4, 7.3, 3.5, 2.6, 7.4]
>>> val = sorted(nums)
>>> val
[2.4, 2.6, 3.5, 6.5, 7.3, 7.4]

# But it doesn't modify the original list
>>> nums
[6.5, 2.4, 7.3, 3.5, 2.6, 7.4]

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

🔸 метод сортировки () выполняет стабильную сортировку

Теперь давайте немного поговорим о характеристиках сортировочного алгоритма, используемого Сортировать () Отказ

Этот метод выполняет стабильный сорт, потому что он работает с реализацией Timsort , очень эффективный и стабильный алгоритм сортировки.

Согласно Документация Python :

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

Давайте посмотрим, что я имею в виду с этим. Пожалуйста, посмотрите на этот пример в течение нескольких мгновений:

>>> d = ["BB", "AA", "CC", "A", "B", "AAA", "BBB"]
>>> d.sort(key=len)
>>> d
['A', 'B', 'BB', 'AA', 'CC', 'AAA', 'BBB']

Мы сравниваем элементы на основе их Длина Потому что мы прошли Лен Функция как аргумент для ключ Отказ

Мы видим, что есть три элемента с длиной 2: "BB" , "АА" и "CC" в этой последовательности.

Теперь обратите внимание, что эти три элемента находятся в одном относительном порядке в финальном отсортированном списке:

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

💡 Совет: То же самое произошло с «А» и "Б" (длина 1) и "ААА" и "BBB" (длина 3), их первоначальный порядок относительно друг друга сохранился.

Теперь вы знаете, как Сортировать () Метод работает, поэтому давайте погрузимся в мутацию и как это может повлиять на вашу программу.

🔹 Мутация и риски

Как и обещал, давайте посмотрим, как процесс мутации работает за кулисами:

Когда вы определяете список в Python, как это:

a = [1, 2, 3, 4]

Вы создаете объект в определенном месте памяти. Это местоположение называется «адресом памяти» объекта, представленного уникальным целым числом, называемым ID Отказ

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

Вы можете получить доступ к идентификатору списка, используя ID () Функция, передавая список в качестве аргумента:

>>> a = [1, 2, 3, 4]
>>> id(a)
60501512

Когда ты Мутате Список, вы меняете его непосредственно в память. Вы можете спросить, почему это так рискованно?

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

Вот почему вы должны быть очень осторожны с методами, которые вызывают мутацию.

В частности, Сортировать () Метод Мутации список. Это пример своего эффекта:

Вот пример:

# Define a list
>>> a = [7, 3, 5, 1]

# Check its id
>>> id(a)
67091624

# Sort the list using .sort()
>>> a.sort()

# Check its id (it's the same, so the list is the same object in memory)
>>> id(a)
67091624

# Now the list is sorted. It has been mutated!
>>> a
[1, 3, 5, 7]

Список был мутирован после звонка .sort () Отказ

Каждая отдельная строка кода, которая работает со списком А После того, как мутация произошла, будет использовать новую, отсортированную версию списка. Если это было не то, что вы предполагаете, вы не понимаете, что другие части вашей программы работают с новой версией списка.

Вот еще один пример рисков мутации в рамках функции:

# List 
>>> a = [7, 3, 5, 1]

# Function that prints the elements of the list in ascending order.
>>> def print_sorted(x):
	x.sort()
	for elem in x:
		print(elem)

# Call the function passing 'a' as argument	
>>> print_sorted(a)
1
3
5
7

# Oops! The original list was mutated.
>>> a
[1, 3, 5, 7]

Список А Это было передано как аргумент мутировал, даже если это не то, что вы предполагали, когда вы изначально написали функцию.

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

🔸 Сводка метода сортировки ()

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

Я действительно надеюсь, что вам понравилась моя статья и обнаружила, что это полезно. Теперь вы можете работать с Сортировать () Метод в ваших проектах Python. Проверьте мои онлайн-курсы Отказ Следуй за мной на Twitter Отказ ⭐️.