Сортировка списка Python Sort () – окончательное руководство

Автор оригинала: Chris.

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

Определение и использование: list.sort () Метод сортирует элементы списка на месте восходящей способности. Чтобы настроить поведение сортировки по умолчанию, используйте дополнительный ключ Аргумент, передавая функцию, которая возвращает сопоставимое значение для каждого элемента в списке. С дополнительным логическим Обратный Аргумент, вы можете переключиться с восходящего ( Reverse = false ) до поручения убывания ( Reverse = True ).

Вот краткий обзор пример, который показывает, как использовать аргументы на практике:

# Create an unsorted integer list
lst = [88, 12, 42, 11, 2]

# Sort the list in place (ascending)
lst.sort()
print(lst)
# [2, 11, 12, 42, 88]

# Sort the list (leading number)
lst.sort(key=lambda x: str(x)[0])
print(lst)
# [11, 12, 2, 42, 88]

# Sort the list in place (descending)
lst.sort(reverse=True)
print(lst)
# [88, 42, 12, 11, 2]

В первой строке примера вы создаете список lst Отказ Затем вы разбираетесь в списке один раз, используя поведение сортировки по умолчанию и один раз, используя индивидуальное поведение сортировки только с первой буквой номера. Затем вы поменяете заказ элементов в отсортированном списке, используя Reverse = True аргумент

Код головоломки – попробуйте сами:

Теперь вы знаете основы. Давайте углубим ваше понимание с коротким кодом головоломки – можешь решить это?

# Create an unsorted integer list
lst = [88, 12, 42, 11, 2]

# Sort the list in place (ascending)
lst.sort()
print(lst)

# Sort the list (leading number)
lst.sort(key=lambda x: str(x)[0])
print(lst)

# Sort the list in place (descending)
lst.sort(reverse=True)
print(last)

# What's the output of this code snippet?

Вы также можете решить эту головоломку и отслеживать свои навыки Python на нашем интерактивном приложении Finxter.

Синтаксис : Вы можете вызвать этот метод на каждом объекте списка в Python ( Python Versions 2.x и 3.x ). Вот синтаксис:

list.sort (ключ = нет,)

Аргументы:

Возвращаемое значение: Метод list.sort () Возвращает Нет Независимо от того, на который он называется. Почему? Поскольку он сортирует список на месте и не создает нового списка.

Статьи по Теме:

• Полное руководство списков Python
• Методы списков Python [Обзор]

Ключ сортировки списка Python

list.sort () Метод принимает еще одну функцию как необязательный ключ Аргумент, который позволяет изменять поведение сортировки по умолчанию. Затем ключевая функция затем вызывается в элементе каждого списка и возвращает другое значение, основанное на том, на котором выполняется сортировка. Следовательно, ключевая функция принимает один аргумент ввода (элемент списка) и возвращает одно выходное значение (значение, которое можно сравнить).

Вот пример:

>>> lst = [(1,2), (3,2), (3,3), (1,0), (0,1), (4,2), (1,1), (0,2), (0,0)]
>>> lst.sort()
>>> lst
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (3, 2), (3, 3), (4, 2)]
>>> lst.sort(key=lambda x: x[0])
>>> lst
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (3, 2), (3, 3), (4, 2)]
>>> lst.sort(key=lambda x: x[1])
>>> lst
[(0, 0), (1, 0), (0, 1), (1, 1), (0, 2), (1, 2), (3, 2), (4, 2), (3, 3)]

Вы можете видеть, что в первых двух примерах список сортируется в соответствии с первым значением кортежного кортежа. В третьем примере список сортируется в соответствии со вторым значением кортежа. Вы достигаете этого, определяя ключевую функцию ключ = лямбда х: х [1] это имеет один элемент списка х (кортеж) как аргумент и преобразует его в сопоставимое значение х [1] (второе значение кортежа).

Связанная статья:

• Введение в лямбда функции в Python

Python List Сортировка itemgetter

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

Например, обычно используют itemgetter () Функция из Оператор Модуль для доступа к I-Th Value Reverable:

>>> from operator import itemgetter
>>> customers = [('alice', 1000), ('bob', 100), ('frank', 10)]
>>> customers.sort(key=itemgetter(1))
[('frank', 10), ('bob', 100), ('alice', 1000)]

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

Список Python Сортировать с двумя ключами

Как сортировать список с двумя ключами? Например, у вас есть список кортежей [(1,2), (3,2), (3,3), (1,0), (0,1), (4,2), (1,1), (0,2), 0,0)] И вы хотите сначала разобраться после второго ценности кортежа. Но если есть галстук (например, (1,2) и (3,2) ), вы хотите разобраться после первого значения кортежа. Как вы можете это сделать?

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

Итак, чтобы сортировать с «двумя клавишами», вы можете определить ключевую функцию, которая возвращает кортеж, а не только одно значение кортежа. Вот пример:

>>> lst = [(1,2), (3,2), (3,3), (1,0), (0,1), (4,2), (1,1), (0,2), (0,0)]
>>> lst.sort(key=lambda x: (x[1], x[0]))
>>> lst
[(0, 0), (1, 0), (0, 1), (1, 1), (0, 2), (1, 2), (3, 2), (4, 2), (3, 3)]

Второе значение кортежа имеет приоритет над первым значением кортежа.

Список Python Сортировать с несколькими клавишами

Как сортировать Список С несколькими ключами? Например, у вас есть список кортежей [(1,1,2), (0,0,1), (0,1,0), (0,1,2), (1,4,0)] И вы хотите сначала разобраться после второго ценности кортежа. Но если есть галстук (например, (0,1,0) и (1,1,2) ), вы хотите отсортировать после третьего значения кортежей. Если есть еще один галстук, вы хотите сортировать после первого значения кортежа. Как вы можете это сделать?

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

Итак, чтобы сортировать с «двумя клавишами», вы можете определить ключевую функцию, которая возвращает кортеж, а не только одно значение кортежа. Вот пример:

>>> lst = [(1,1,2), (0,0,1), (0,1,0), (0,1,2), (1,4,0)]
>>> lst.sort()
>>> lst
[(0, 0, 1), (0, 1, 0), (0, 1, 2), (1, 1, 2), (1, 4, 0)]
>>> lst.sort(key=lambda x: (x[1],x[2],x[0]))
>>> lst
[(0, 0, 1), (0, 1, 0), (0, 1, 2), (1, 1, 2), (1, 4, 0)]

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

Список Python Сортировать лямбда

Функции лямбда – это анонимные функции, которые не определены в пространстве имен (у них нет имен). В его простейшей форме синтаксис:

лямбда аргумент: выражение.

Вы отображаете аргумент к результату выражения.

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

Вот пример:

>>> from operator import itemgetter
>>> customers = [('alice', 1000), ('bob', 100), ('frank', 10)]
>>> customers.sort(key=lambda x: x[1])
[('frank', 10), ('bob', 100), ('alice', 1000)]

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

Список Python Сортировать со компаратором

В предыдущих примерах вы узнали о ключевом аргументе, который позволяет вам указать для каждого элемента списка, как его следует обрабатывать при сортировке списка. Таким образом, вы можете создать отдельное «значение» для каждого элемента. Сортировать () Затем способ сортирует список на основе этих «значений», а не на основе самих элементов списка.

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

Что значит быть сопоставимым? И как вы делаете свой собственный Пользовательский класс Сопоставимо? Для этого необходимо реализовать ряд методов в определении пользовательского класса ( Источник ):

Если вы реализуете все эти методы, вы можете сравнить два элемента легко. Все основные структуры данных Python реализовали их. Так что не беспокойтесь об этом.

Реализация списка Python Sort

Python’s Сортировка процедуры такие как list.sort () и встроенный отсортировано () Используйте Timsort алгоритм (назван в честь его создателя тима Peters).

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

Алгоритм Timsort использует эту идею, поисшив уже отсортированные подпоследовательности, которые могут быть объединены вместе (эти сортированные подпоследовательности называются «Runs» в исходном алгоритмическом описании Timsort). Если вы можете быстро идентифицировать Run, и вы можете быстро объединить те, которые работает в отсортированной последовательности, вы используете существующую (случайное) упорядоченность данных. Многие наборы данных реальных данных уже поставляются со многими такими сорванными «пробегами».

Таким образом, в то время как алгоритм имеет то же самое наихудшее сложность времени O (n log n), сложность времени в лучшем случае o (n). Во многих практических настройках алгоритм превосходит теоретически аналогичные алгоритмы из-за свойства используя существующее упорядочение данных.

Вы можете глубоко погружаться в алгоритм Timsort здесь Отказ

Python List Сортировать сложность

Algorithm Python’s Timsort Algorithm имеет o (n log n) сложность времени в худшем случае и o (n) лучшее сложность времени, если список уже в значительной степени отсортирован. Это также имеет отличное Результаты тестов – Они превосходят многие из лучших алгоритмов сортировки в мире на реальных входных данных.

Ошибка сортировки списка Python

При использовании 2 общих ошибок есть две общие ошибки list.sort () метод.

Список списка Python возвращает ни одного

Возвращаемое значение list.sort () Метод это Нет , но многие кодера ожидают, что это сортированный список. Поэтому они удивлены, узнав, что их переменные содержат Нет Тип, а не отсортированный список.

>>> lst = [10, 5, 7]
>>> a = lst.sort()
>>> print(a)
None

Однако возвращение Нет имеет идеальный смысл для list.sort () метод. Почему? Поскольку вы вызываете метод в объекте списка, и он изменяет этот объект точного списка. Он не создает нового списка – в памяти не будет нового объекта списка.

>>> print(lst)
[5, 7, 10]

Если вы хотите создать новый объект списка, используйте отсортировано () Встроенная функция Python, как это:

>>> sorted([10, 8, 9])
[8, 9, 10]

Python List Сортировать объект «Nonetype» не является ими

Скажем, вы хотите повторить список в отсортированном порядке. Вы хотите использовать list.sort () Метод для достижения этого.

Этот кодовый фрагмент решит проблему, не так ли?

years = [2008, 1999, 2012, 1988]

for year in years.sort():
    print(year)

Но при запуске кода вы получаете следующее сообщение об ошибке:

Traceback (most recent call last):
  File "C:\Users\xcent\Desktop\code.py", line 3, in 
    for year in years.sort():
TypeError: 'NoneType' object is not iterable

Почему Типеррор происходить?

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

Вот пример:

years = [2008, 1999, 2012, 1988]

for year in sorted(years):
    print(year)

Теперь ожидается результат:

1988
1999
2008
2012

Список Python сортирует по алфавиту/лексикологически

Проблема : Учитывая список строк. Сортируйте список строк в алфавитном порядке!

Пример:

['Frank', 'Alice', 'Bob'] --> ['Alice', 'Bob', 'Frank']

Решение : Используйте list.sort () Способ без аргумента для решения списка в лексикографическом порядке, который является обобщением алфавитного порядка (также относится ко второму, третьему, … символам).

lst = ['Frank', 'Alice', 'Bob']
lst.sort()
print(lst)
# ['Alice', 'Bob', 'Frank']

Попробуй сам:

Список Python сортирует в алфавитном порядке

Вы можете поменять порядок списка, используя обратное ключевое слово. Установить Reverse = false Сортировать по возрастанию и установить Reverse = True сортировать в порядке убывания.

lst = ['Frank', 'Alice', 'Bob']

lst.sort(reverse=False)
print(lst)
# ['Alice', 'Bob', 'Frank']

lst.sort(reverse=True)
print(lst)
# ['Frank', 'Bob', 'Alice']

Список Python сортирует по алфавиту и численно

Проблема : У вас есть список строк. Каждая строка содержит номер. Вы хотите, чтобы количество было численно сортировать (например, поставляется, 100 поступает после 20, а не ранее), но символы, чтобы сортировать в алфавитном порядке (например, 'C' приходит до 'd' ).

Пример :

['alice 100', 'alice 20', 'bob 99'] --> ['alice 20', 'alice 100', 'bob 99'

Наивное решение (не работает): Используйте list.sort () Метод сортировки списка в алфавитном порядке:

lst = ['alice 100', 'alice 20', 'bob 99']
lst.sort()
print(lst)
# ['alice 100', 'alice 20', 'bob 99']

Потому что номер 100 наступает до 20 в алфавитном порядке, строка «Алиса 100» размещается до «Алиса 20» Отказ

Решение : Я нашел это Код на Stackoverflow, который красиво демонстрирует, как отсортировать буквенно-цифровой:

import re 

def sorted_nicely(l): 
    """ Sort the given iterable in the way that humans expect.""" 
    convert = lambda text: int(text) if text.isdigit() else text 
    alphanum_key = lambda key: [convert(c) for c in re.split('([0-9]+)', key)] 
    l.sort(key = alphanum_key)

lst = ['alice 100', 'alice 20', 'bob 99']
sorted_nicely(lst)
print(lst)
# ['alice 20', 'alice 100', 'bob 99']

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

Список сортировки Python с буквами и цифрами

Смотрите предыдущий раздел Список Python сортирует в алфавитном порядке Отказ

Сортировка списка Python

Проблема с по умолчанием list.sort () или Сортировано (список) Метод заключается в том, что они считают капитализацию. Таким образом, это может привести к странным сортировке, как это:

lst = ['ab', 'Ac', 'ad']
lst.sort()
print(lst)
# ['Ac', 'ab', 'ad']

Интуитивно, вы ожидаете, что строка 'ab' произойти до «AC» , верно?

Чтобы игнорировать капитализацию, вы можете просто позвонить в x.lower () Способ на каждом элементе х перед сортировкой списка.

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

lst = ['ab', 'Ac', 'ad']
lst.sort(key=lambda x: x.lower())
print(lst)
# ['ab', 'Ac', 'ad']

Если вам нравятся одноклассники, вам понравится моя новая книга «Python One-Listers» с Nostarch Press (Amazon Link ) Отказ

Список Python Сортировка на месте

Если вы позвоните list.sort () Способ, вы сортируете список объект на месте. Другими словами, вы не создаете новый список с теми же элементами в отсортированном порядке. Нет! Вы сортируете существующий список. Таким образом, все переменные, которые также указывают на этот список в памяти, увидят измененный список.

Вот пример, который точно показывает, что:

lst_1 = ['Bob', 'Alice', 'Frank']
lst_2 = lst_1

lst_1.sort()
print(lst_2)
# ['Alice', 'Bob', 'Frank']

В коде вы можете увидеть, что сортировка видима для переменной lst_2 это указывает на тот же объект в памяти.

Если вы хотите сортировать список, но верните новый объект (без изменения объекта старого списка), вам нужно взять встроенный Python отсортировано () Метод:

lst_1 = ['Bob', 'Alice', 'Frank']
lst_2 = sorted(lst_1)

print(lst_1)
# ['Bob', 'Alice', 'Frank']

print(lst_2)
# ['Alice', 'Bob', 'Frank']

Теперь оба списка указывают на отдельные объекты списка в памяти. Таким образом, изменение порядка элементов видна только в список lst_2 Отказ

Сортировка списка Python по возрастанию против нисходящего (обратное)

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

lst_1 = ['Bob', 'Alice', 'Frank']
lst_1.sort()
print(lst_1)
# ['Alice', 'Bob', 'Frank']


lst_2 = [10, 8, 11, 2, 1]
lst_2.sort()
print(lst_2)
# [1, 2, 8, 10, 11]

Однако, если вы хотите разобраться в порядке убывания (от большого до небольшого), вы можете использовать любой из следующих двух методов:

• Используйте list.sort (Reverse = True) Метод с Reverse = True аргумент
• Используйте нарезку Список [:: - 1] Чтобы изменить порядок списка.

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

Вот пример:

lst_1 = ['Bob', 'Alice', 'Frank']
lst_1.sort(reverse=True)
print(lst_1)
# ['Frank', 'Bob', 'Alice']


lst_2 = [10, 8, 11, 2, 1]
lst_2.sort()
lst_2 = lst_2[::-1]
print(lst_2)
# [11, 10, 8, 2, 1]

Как вы видите, используя Reverse = True Аргумент красивее в большинстве случаев.

Индекс сортировки списка Python (Argsort)

Что, если вы хотите сортировать список, но вы хотите иметь только индексы отсортированных элементов?

Проблема : Скажи, у вас есть список [«Боб», «Алиса», «Карл»] И вы заинтересованы в отсортированных индексах [1, 0, 2] Отказ

Решение : Существует много чистых питонов в Интернете, но простейшее и эффективное решение – это «стоять на плечах гигантов» и использовать Numpy Library – в частности, np.argsort () метод.

Вот как:

import numpy as np

lst = ['Bob', 'Alice', 'Carl']
sorted_indices = np.argsort(lst)
print(sorted_indices)
# [1 0 2]

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

Связанная статья:

• Введение в Numpy

Python сортирует список строк

Как вы можете сортировать список строк? Нет никакой разницы – просто используйте нормальный list.sort () метод. Если вам нужно сортировать буквенно-цифровой способ, то используйте подсказки выше (см. Раздел Список Python Сортировать по алфавиту ).

Вот минимальный пример:

lst = ['Bob', 'Alice', 'Carl']
lst.sort()
print(lst)
# ['Alice', 'Bob', 'Carl']

Python сортирует список поплавков

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

lst = [101.0, 20.9, 13.4, 106.4]
lst.sort()
print(lst)
# [13.4, 20.9, 101.0, 106.4]

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

Тем не менее, что, если у вас есть список поплавков, данных в виде строковых значений? Это может привести к неожиданному поведению:

lst = ['101.0', '20.9', '13.4', '106.4']
lst.sort()
print(lst)
# ['101.0', '106.4', '13.4', '20.9']

Список «Сортировка» выглядит странно. Проблема в том, что строки сортируются в алфавитном порядке, не численно. Письмо '1' приходит до письма '2' в алфавите Unicode. Вот почему номер '101.0' приходит до '20 .9 ' – Если последний является меньшим числовым значением.

Если вы хотите сортировать список численно, вы должны преобразовать все значения списка на плавает первый. Самый простой способ сделать это – использовать поплавок () Встроенная функция преобразования Python в качестве ключевого аргумента lst.sort () метод.

lst = ['101.0', '20.9', '13.4', '106.4']
lst.sort(key=float)
print(lst)
# ['13.4', '20.9', '101.0', '106.4']

Таким образом, вы сохраняете тип строкового типа, потому что значения списка на самом деле не изменяются. Но вы связываете новое «ценность» к каждому элементу списка через функцию ключа – соответствующее значение поплавкового элемента строкового элемента.

Python сортирует список кортежей

Проблема : Скажем, у вас есть список кортежей [(1,1,2), (0,0,1), (0,1,0), (0,1,2), (1,4,0)] И вы хотите сначала разобраться после второго ценности кортежа. Но если есть галстук (например, (0,1,0) и (1,1,2) ), вы хотите отсортировать после третьего значения кортежей. Если есть еще один галстук, вы хотите сортировать после первого значения кортежа. Как вы можете это сделать?

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

Решение : Определите функцию ключевой функции, которая возвращает кортеж, а не только одно значение кортежа. Вот пример:

>>> lst = [(1,1,2), (0,0,1), (0,1,0), (0,1,2), (1,4,0)]
>>> lst.sort()
>>> lst
[(0, 0, 1), (0, 1, 0), (0, 1, 2), (1, 1, 2), (1, 4, 0)]
>>> lst.sort(key=lambda x: (x[1],x[2],x[0]))
>>> lst
[(0, 0, 1), (0, 1, 0), (0, 1, 2), (1, 1, 2), (1, 4, 0)]

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

Python сортирует список словарей

Далее вы собираетесь учиться Как сортировать список словарей во всех возможных вариациях. [ 1 ] Так что давайте начнем!

Как сортировать список Словари По стоимости?

Проблема : Учитывая список словарей. Каждый словарь состоит из нескольких (ключ, стоимости) пар. Вы хотите отсортировать их по значению определенного ключа словаря ( атрибут ). Как вы сортируете этот словарь?

Минимальный пример : Рассмотрим следующий пример, где вы хотите отсортировать список складских наплат по значению ключа «Алиса» Отказ

salaries = [{'Alice': 100000, 'Bob': 24000},
            {'Alice': 121000, 'Bob': 48000},
            {'Alice': 12000, 'Bob': 66000}]

sorted_salaries = # ... Sorting Magic Here ...

print(sorted_salaries)

Вывод должен выглядеть так, где зарплата Алисы определяет порядок словарей:

[{'Alice': 12000, 'Bob': 66000},
{'Alice': 100000, 'Bob': 24000},
{'Alice': 121000, 'Bob': 48000}]

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

• Используйте функцию лямбда в качестве функции ключа, чтобы сортировать список словарей.
• Используйте функцию itemGetter в качестве функции ключа, чтобы сортировать список словарей.

Вот код первого варианта, используя функцию лямбда, которая возвращает значение ключа «Алиса» из каждого словаря:

# Create the dictionary of Bob's and Alice's salary data
salaries = [{'Alice': 100000, 'Bob': 24000},
            {'Alice': 121000, 'Bob': 48000},
            {'Alice': 12000, 'Bob': 66000}]

# Use the sorted() function with key argument to create a new dic.
# Each dictionary list element is "reduced" to the value stored for key 'Alice'
sorted_salaries = sorted(salaries, key=lambda d: d['Alice'])

# Print everything to the shell
print(sorted_salaries)

Вывод – это сортированный словарь. Обратите внимание, что первый словарь имеет самую маленькую зарплату Алисы, а третий словарь имеет наибольшую зарплату Алисы.

[{'Alice': 12000, 'Bob': 66000},
 {'Alice': 100000, 'Bob': 24000},
 {'Alice': 121000, 'Bob': 48000}]

Попробуй сам:

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

Сопутствующие статьи на блоге Finxter:

• Как сортировать список словарей в Python [полное руководство]
• Лямбда функции
• Словари

Синтеровка списка Python Удалить дубликаты (сортировка + уникальные)

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

Сложность времени выполнения : Скажи, у вас есть список [1, 10, 3, 2, 3, 1, 11, 10] Отказ Если вы пройдете на каждый элемент и проверьте, существует ли этот элемент в другом положении, сложность выполнения является O (N²) для N элементов. Но если вы сначала сортируете список, сложность выполнения является только O (n log n) для сортировки. Перейти через сортированный список [1, 1, 2, 3, 3, 10, 10, 11] Еще раз находить последующие дубликаты только O (N), поэтому общая сложность выполнения отсортированного дубликата обнаружения является O (n log n).

Решение : Рассмотрим следующий код.

lst = [1, 10, 3, 2, 3, 1, 11, 10]
lst.sort()

index = 0
while index < len(lst) - 1:
    if lst[index] == lst[index+1]:
        lst.pop(index)
    index = index + 1

print(lst)
# [1, 2, 3, 10, 11]

Обсуждение : Мы отслеживаем текущий индекс, который идет слева направо по списку и удаляет элемент, если его преемник в списке является дубликатом. Таким образом, вы удалите все дубликаты из отсортированного списка.

Альтернативы : Вы также можете преобразовать список в Установить и обратно в список для удаления дубликатов. Это имеет сложность выполнения только O (N) и, следовательно, более эффективно.

lst = [1, 10, 3, 2, 3, 1, 11, 10]
dup_free = list(set(lst))
print(dup_free)
# [1, 2, 3, 10, 11]

Python List QuickSort.

Quicksort – это не только популярный вопрос во многих кодовых интервью – спросил Google, Facebook и Amazon – но и практичный алгоритм сортировки, который быстро, кратко и читается. Из-за своей красоты вы не найдете много классов «вступления к алгоритмам», которые не обсуждают алгоритм Quicksort.

QuickSort сортирует список, рекурсивно разделяя большую проблему (сортируя список) в меньшие проблемы (сортировка двух меньших списков) и объединение решений от меньших проблем таким образом, чтобы она решала большую проблему. Чтобы решить каждую меньшую проблему, та же самая стратегия используется рекурсивно: меньшие проблемы делятся на даже меньшие подпруты, решающие отдельно и объединенные. В связи с этой стратегией Quicksort принадлежит к классу алгоритмов «разделить и завоевать». Давайте погрузиться глубже в алгоритм Quicksort:

Основная идея QuickSort состоит в том, чтобы выбрать элемент поворота, а затем размещать все элементы, которые больше или равны, чем элемент поворота вправо и все элементы, которые меньше, чем элемент поворота влево. Теперь вы разделили большую проблему сортировки списка на две меньшие подпруты: сортировка права и левой раздел списка. То, что вы делаете сейчас, это рекурсивно повторить эту процедуру, пока вы не получите список нулевых элементов. Этот список уже отсортирован, поэтому рекурсион завершается.

На следующем рисунке показан алгоритм Quicksort в действии:

Фигура : Алгоритм QuickSort выбирает элемент поворота, разбивает список в (i) несортированным подсредством со всеми элементами, меньшими или равными, чем Pivot, и (ii) несортированным подсудистом со всеми элементами, которые больше, чем у пивота. Далее алгоритм Quicksort рекурсивно называется двумя несортированными сублистами, чтобы сортировать их. Как только сублисты содержат максимально один элемент, они отсортированы по определению – заканчивается рекурсион. На каждом уровне рекурсии три сублисты (слева, поворот, справа) объединяются до того, как результирующий список передан на более высокий уровень рекурсиона.

Вот реализация одноклассника Python из моего нового Python One-listers Book (Amazon Link).

## The Data
unsorted = [33, 2, 3, 45, 6, 54, 33]


## The One-Liner
q = lambda l: q([x for x in l[1:] if x <= l[0]]) + [l[0]] + q([x for x in l if x > l[0]]) if l else []

 
## The Result
print(q(unsorted))

Если вам нужно пояснение, проверьте мою более глубокую статью в блоге об этой реализации Anly Liner Quicksort:

Статьи по Теме:

• Самое короткое внедрение Quicksort в Python

Список Python Sort Len

Проблема : Учитывая список строк. Как вы можете отсортировать их по длине?

Пример : Вы хотите сортировать свой список строк [«AAAA», «BBB», «CC», «D»] по длине, начиная с кратчайшей строки. Таким образом, результат должен быть [«D», «CC», «BBB», «AAAA»] Отказ Как это добиться?

Решение : Используйте Лен () Функция как ключевой аргумент list.sort () Метод такой: list.sort (Key = Len) Отказ Как Лен () Функция – это встроенная функция Python, вам не нужно импортировать или определять что-либо еще.

Вот решение кода:

lst = ['aaaa', 'bbb', 'cc', 'd']
lst.sort(key=len)
print(lst)

Вывод – это список, отсортированный по длине строки:

['d', 'cc', 'bbb', 'aaaa']

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

Срок службы списка Python

Проблема : Учитывая перечисленный список (индекс, стоимость) пар. Как вы можете отсортировать список по значению?

Пример : У вас есть список [«Алиса», «Боб», «Энн» , ‘Откровенный’]. Перечисленный список Список (перечисление («Алиса», «Боб», «Энн», «Фрэнк»])) == [(0, «Алиса»), (1, «Боб»), (2, «Энн»), (3, «Фрэнк»)]] Отказ Как вы можете отсортировать это по значению.

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

Вот решение кода:

lst = ['Alice', 'Bob', 'Ann', 'Frank']
en_lst = list(enumerate(lst))
en_lst.sort(key=lambda x: x[1])
print(en_lst)

Выход – это список, отсортированный по значению перечисленного списка.

[(0, 'Alice'), (2, 'Ann'), (1, 'Bob'), (3, 'Frank')]

Python List Сортировка Zip

Проблема : Как сортировать Zains Список по значению?

Пример : Учитывая два списка [5, 7, 9] и [«Алиса», «Боб», «Энн»] Отказ Молни им вместе, чтобы получить [(5, «Алиса»), (7, «Боб»), (9, «ANN»)] Отказ Как сортировать этот список по значению (I.E., второе значение кортежа).

Решение : Опять же, решение является вариантом проблемы: как сортировать список кортежей по второму значению кортежа? Вы можете сделать это, используя клавишный аргумент с простой функцией Lambda, которая возвращает второе значение кортежа в качестве основы для сравнения.

Вот решение кода:

a = [5, 7, 9]
b = ['Alice', 'Bob', 'Ann']
zipped = list(zip(a, b))
# [(5, 'Alice'), (7, 'Bob'), (9, 'Ann')]
zipped.sort(key=lambda x: x[1])
print(zipped)

Вот выход из отсортированного списка на молнии:

[(5, 'Alice'), (9, 'Ann'), (7, 'Bob')]

Срок службы Python, кроме первого элемента

Проблема : Как сортировать список, кроме первого элемента? Первый элемент должен оставаться в первой позиции.

Пример : Учитывая список [99, 3, 8, 1, 12] Отказ После сортировки вы хотите почти отсортированный список [99, 1, 3, 8, 12] Отказ Только первый элемент игнорируется процедурой сортировки.

Решение : Вы используете отсортировано (считать) Функция для возврата нового списка. Как сортировать, вы используете все элементы исходного списка, кроме первого. Нарезка помогает вам вырезать этот сублистский. Тогда вы используете Список конкатенации Чтобы склеить сортированный подсудист и первый элемент списка.

Вот решение кода:

lst = [99, 3, 8, 1, 12]
lst_2 = lst[:1] + sorted(lst[1:])
print(lst_2)

Вот выход из отсортированного списка на молнии:

[99, 1, 3, 8, 12]

Сортировка списка Python Sort

Проблема : Сортировать файл в алфавитном порядке, строка по линии.

Пример : Скажем, у вас есть следующий файл "chat.txt" который содержит некоторые временные метки сообщений в чате.

2014-05-12: hi
2020-07-13: Python is great
2020-07-12: Is Python great?
2014-06-01: how are you?

Вы хотите следующий отсортированный файл/строка:

2014-05-12: hi
2014-06-01: how are you?
2020-07-12: Is Python great?
2020-07-13: Python is great

Как вы можете отсортировать этот файл в Python?

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

Вот код:

lines = [line for line in open('chat.txt')]
lines.sort()
print(lines)

Вывод – это следующий отсортированный список:

['2014-05-12: hi\n', 
'2014-06-01: how are you?', 
'2020-07-12: Is Python great?\n', 
'2020-07-13: Python is great\n']

Если вы хотите сохранить результаты в другом файле, вы можете просто Напишите это в новом файле Отказ Если вам не нужны персонажи Training Whitespace, вы можете позвонить полоса () нравится:

lines = [line.strip() for line in open('chat.txt')]

Python List Сортировать VS сортируется

Какая разница между список .sorted () метод Списки Python и то отсортировано () Встроенная функция? Учитывая список …

• Метод list.sort () сортирует данный список на месте. Это не создает новый список.
• Встроенная функция Python отсортировано () Создает новый объект списка с отсортированными элементами.

Возвращаемое значение list.sort () Метод это Нет Но многие кодера ожидают, что это сортированный список. Поэтому они удивлены, узнав, что их переменные содержат Нет Тип, а не отсортированный список.

>>> lst = [10, 5, 7]
>>> a = lst.sort()
>>> print(a)
None

Однако возвращение Нет имеет идеальный смысл для list.sort () метод. Почему? Поскольку вы вызываете метод в объекте списка, и он изменяет этот объект точного списка. Он не создает нового списка – в памяти не будет нового объекта списка.

>>> print(lst)
[5, 7, 10]

Если вы хотите создать новый объект списка, используйте отсортировано () Встроенная функция Python, как это:

>>> sorted([10, 8, 9])
[8, 9, 10]

Сложность указателя списка Python

Для простоты вот питон эквивалентен реализации с некоторыми основными упрощениями, которые не изменяют общую сложность:

def index(value, lst):
    for i, el in enumerate(lst):
        if el==value:
            return i
    raise Exception('ValueError')

print(index(42, [1, 2, 42, 99]))
# 2

print(index("Alice", [1, 2, 3]))
'''
Traceback (most recent call last):
  File "C:UsersxcentDesktopcode.py", line 10, in 
    print(index("Alice", [1, 2, 3]))
  File "C:UsersxcentDesktopcode.py", line 5, in index
    raise Exception('ValueError')
Exception: ValueError
'''

Я знаю, что это не идеальная репликация вышеуказанного кода C ++. Но этого достаточно, чтобы увидеть вычислительное (выполнение) сложность list.index (значение) метод.

Индекс () Метод имеет линейную сложность выполнения в количестве элементов списка. Для N Элементы, сложность времени выполнения – O (n) Поскольку в худшем случае вам нужно повторить каждый элемент в списке, чтобы найти, что элемент не появляется в нем.

Давайте проверим сложность выполнения практически для разных размеров списка с краткосрочной программой.

Вы можете увидеть участок времени сложности Индекс () Метод растущего размера списка здесь:

На рисунке показано, как прошедшее время нахождения элемента последнего списка в списке. Этот эксперимент повторяется для растущего количества элементов. Время выполнения растет линейным до количества элементов.

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

import matplotlib.pyplot as plt
import time

y = []
for i in [100000 * j for j in range(10,100)]:
    lst = list(range(i))
    t0 = time.time()
    x = lst.count(-99)
    t1 = time.time()
    y.append(t1-t0)


plt.plot(y)
plt.xlabel("List elements (10**5)")
plt.ylabel("Time (sec)")
plt.show()

Статьи по Теме:

• Методы списка Python – простой обзор
• Как начать изучать Python?

Python List Сортировка () Безопасная резьба

У вас есть несколько потоков, которые одновременно получают доступ к вашему списку? Тогда вы должны быть уверены, что операции списка (например, сортировка () ) на самом деле резьба безопасна Отказ

Другими словами: вы можете позвонить в Сортировать () Операция в двух потоках в том же списке одновременно? (И вы можете быть уверены, что результат является значимым?)

Ответ да (если вы используете Mokef Cpython внедрение). Причина – Питона Блокировка глобального интерпретатора Это гарантирует, что в настоящее время поток работает над своим кодом, сначала завершит текущую базовую операцию Python, как определено реализацией Cpython. Только если оно завершится с помощью этой операции, сможет получить следующий поток для доступа к вычислительному ресурсу. Это обеспечивается сложной схемой блокировки в результате реализации CPYPHON.

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

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

Куда пойти отсюда?

То list.sort () Метод сортирует элементы списка на месте восходящей способности. Чтобы настроить поведение сортировки по умолчанию, используйте дополнительный ключ Аргумент, передавая функцию, которая возвращает сопоставимое значение для каждого элемента в списке. С дополнительным логическим задний ход аргумент, вы можете переключиться с возрастания ( Reverse = false. ) до по порядку убывания ( Reverse = True ).

Если вы продолжаете бороться с теми основными командами Python, и вы чувствуете застрявшие в своем прогрессе обучения, у меня есть что-то для вас: Python One-listers (Amazon Link).

В книге я дам вам тщательный обзор темы критических компьютерных наук, таких как машинное обучение, регулярное выражение, наука о данных, Numpy и Python Basics – все в одной линейке кода Python!

Получите книгу от Amazon!

Официальная книга Описание: Python One-Listers покажет читателям, как выполнить полезные задачи с одной строкой кода Python. Следуя краткому переподготовку Python, книга охватывает важные продвинутые темы, такие как нарезка, понимание списка, вещание, функции лямбда, алгоритмы, регулярные выражения, нейронные сети, логистические регрессии и др .. Каждая из 50 секций книг вводит проблему для решения, проходит читателя через навыки, необходимые для решения этой проблемы, затем предоставляет краткое однонаправленное решение Python с подробным объяснением.

Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.

Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python One-listers (Nostarch 2020), Coauthor of Кофе-брейк Python Серия самооставленных книг, энтузиаста компьютерных наук, Фрилансера и владелец одного из лучших 10 крупнейших Питон блоги по всему миру.

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