Как отфильтровать список в python

Отфильтровать список чисел по заданному критерию. Python

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

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

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
filtered_numbers = list(filter(lambda x: x % 3 == 0, numbers))
print(filtered_numbers)

В результате выполнения этого кода в консоль будет выведено:

[3, 6, 9, 12, 15]

Здесь мы создаем список numbers, содержащий числа от 1 до 15. Затем мы применяем функцию filter() к этому списку с помощью лямбда-функции, которая проверяет, делится ли текущий элемент на 3 без остатка. Результатом выполнения функции filter() является итератор, поэтому мы приводим его к списку с помощью функции list(). В итоге в переменной filtered_numbers оказываются только те числа из исходного списка, которые делятся на 3 без остатка.

Переписать другими словами
Написать сочинение по запросу
Или попробуйте другие режимы нейросети.

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

Функция filter() в Python, фильтрует список по условию

Позволяет отфильтровать элементы последовательности по условию

Синтаксис:

filter(func, iterable)

Параметры:

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

Возвращаемое значение:

filter object — отфильтрованная последовательность.

Описание:

Функция filter() отбирает/фильтрует элементы переданного объекта iterable при помощи пользовательской функции func .

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

Если фильтрующая функция func вернёт False , то элемент последовательности iterable не попадёт в результат выполнения функции filter() .
Если фильтрующая функция func вернет None , то считается что требуется применить тождественное действие (item for item in iterable if item) , таким образом все элементы, оцениваемые как False будут отфильтрованы.

Чтобы получить результат из элементов оцененных пользовательской функцией как False , воспользуйтесь itertools.filterfalse() .

Из всего сказанного можно сделать вывод, что для успешного использования функции filter() необходимо в результате каких то вычислений/сравнений над каждым элементом передаваемой последовательности получать True или 1 для элементов которые нужно отобрать и False или 0 для элементов, которые нужно отбросить.

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

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

Примеры фильтрации списков по условию.

Применение лямбда-функции в качестве фильтра.
Применение обычной функции в качестве фильтра.
Удаление ложных значений ( False , None , 0 и ») из списка с помощью filter() .

Применение лямбда-функции в качестве фильтра последовательности.

# имеем числовую последовательность num = [1, 2.0, 3.1, 4, 5, 6, 7.9] # использование операции сравнения # отбираем числа > 4 >>> f = filter(lambda x: x > 4, num) >>> list(f) # [5, 6, 7.9] # использование оператора идентичности `is` # отбираем только целые числа >>> f = filter(lambda x: type(x) is int, num) >>> list(f) # [1, 4, 5, 6] # теперь работаем со списком строк num = ['ноль', '1', '2.0', '3.1', '4', '5', '7.9', 'семь'] # использование встроенных функций или методов # возвращающих 'bool' значения на примере метода 'str.isdigit()' # отбираем строки с записью чисел >>> f = filter(lambda x: x.replace('.', '').isdigit(), num) >>> list(f) # ['1', '2.0', '3.1', '4', '5', '7.9'] # использование оператора вхождения `in` # отбираем строки которые имеют вхождение # символа точки '.' >>> f = filter(lambda x: '.' in x, num) >>> list(f) # ['2.0', '3.1', '7.9']

Применение обычной функции в качестве фильтра последовательности.

num = list(range(0, 27)) # определяем отдельную функцию которая # отбирает четные элементы > 18. def ff(x): if x > 18 and not x % 2: return True else: return False >>> f = filter(ff, num) >>> list(f) # [20, 22, 24, 26]

Удаление ложных значений ( False , None , 0 и ») из списка с помощью filter() .

>>> lst = [0, 1, False, 2, '', 3, 'a', 's', 34] >>> list(filter(None, lst)) # [1, 2, 3, 'a', 's', 34]

ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
Функция abs(), абсолютное значение числа
Функция all(), все элементы True
Функция any(), хотя бы один элемент True
Функция ascii(), преобразует строку в ASCII
Функция bin(), число в двоичную строку
Класс bool(), логическое значение объекта
Функция breakpoint(), отладчик кода
Класс bytearray(), преобразует в массив байтов
Класс bytes(), преобразует в строку байтов
Функция callable(), проверяет можно ли вызвать объект
Функция chr(), число в символ Юникода
Класс classmethod, делает функцию методом класса
Функция compile() компилирует блок кода Python
Класс complex(), преобразует в комплексное число
Функция delattr(), удаляет атрибут объекта
Класс dict() создает словарь
Функция dir(), все атрибуты объекта
Функция divmod(), делит числа с остатком
Функция enumerate(), счетчик элементов последовательности
Функция eval(), выполняет строку-выражение с кодом
Функция exec(), выполняет блок кода
Функция filter(), фильтрует список по условию
Класс float(), преобразует в вещественное число
Функция format(), форматирует значение переменной
Класс frozenset(), преобразует в неизменяемое множество
Функция getattr(), значение атрибута по имени
Функция globals(), переменные глобальной области
Функция hasattr(), наличие атрибута объекта
Функция hash(), хэш-значение объекта
Функция help(), справка по любому объекту
Функция hex(), число в шестнадцатеричную строку
Функция id(), идентификатор объекта
Функция input(), ввод данных с клавиатуры
Класс int(), преобразует в тип int
Функция isinstance(), принадлежность экземпляра к классу
Функция issubclass(), проверяет наследование класса
Функция iter(), создает итератор
Функция len(), количество элементов объекта
Класс list(), преобразовывает в список
Функция locals(), переменные локальной области
Функция map(), обработка последовательности без цикла
Функция max(), максимальное значение элемента
Класс memoryview(), ссылка на буфер обмена
Функция min(), минимальное значение элемента
Функция next(), следующий элемент итератора
Класс object(), возвращает безликий объект
Функция oct(), число в восьмеричную строку
Функция open(), открывает файл на чтение/запись
Функция ord(), число символа Unicode
Функция pow(), возводит число в степень
Функция print(), печатает объект
Класс property(), метод класса как свойство
Класс range(), генерирует арифметические последовательности
Функция repr(), описание объекта
Функция reversed(), разворачивает последовательность
Функция round(), округляет число
Класс set(), создает или преобразовывает в множество
Функция setattr(), создает атрибут объекта
Класс slice(), шаблон среза
Функция sorted(), выполняет сортировку
Декоратор staticmethod(), метод класса в статический метод
Класс str(), преобразует объект в строку
Функция sum(), сумма последовательности
Функция super(), доступ к унаследованным методам
Класс tuple(), создает или преобразует в кортеж
Класс type(), возвращает тип объекта
Функция vars(), словарь переменных объекта
Функция zip(), объединить элементы в список кортежей
Функция __import__(), находит и импортирует модуль
Функция aiter(), создает асинхронный итератор
Функция anext(), следующий элемент асинхронного итератора

Python: List (Списки)

Список – это структура данных, которая содержит упорядоченный набор элементов, т.е. хранит последовательность элементов. Изменяемые списки создаются через квадратные скобки. Элементы могут повторяться и меняться. Доступ к отдельному элементу тоже через квадратные скобки. Отсчёт с 0.

Узнать все методы списка можно через команду.

 help(list)

Рассмотрим некоторые примеры.

 cats = ["Барсик", "Мурзик", "Васька"] print(cats) # все элементы списка print(cats[1]) # один указанный элемент numbers = [0, 1, 2, 3, 4, 5] print(numbers) print(numbers[4]) // список из строки mylist = list('Барсик') print(mylist)

В списке могут быть разные типы. Поместим в список числа и строки.

 mix = ["one", 3, "two", "three", 9, 3] print(mix[1]) print(mix[2])

Можно создать пустой список.

 empty = [] print(empty) # []

В качестве индекса можно указать отрицательные значения. Так индекс -1 вернёт последний элемент списка, -2 предпоследний и т.д.

 numbers = [0, 1, 2, 3, 4, 5] print(numbers[-1]) #5 print(numbers[-2]) #4 print(numbers[-3]) #3

Развернуть список можно через reverse().

 reversed = [1, 2, 3, 4, 4] reversed.reverse() print (reversed) # [4, 4, 3, 2, 1] kitten = list("Барсик") kitten.reverse() print(kitten) # ['к', 'и', 'с', 'р', 'а', 'Б']

Сортировать можно через sort().

 mylist = [8, 2, 11, 4, 3] mylist.sort() print (mylist)

Можем заменить существующие элементы списка.

 numbers = [0, 1, 2, 3, 4, 5] numbers[0] = 10 numbers[5] = 22 print(numbers[-1]) print(numbers[0])

Добавить новый элемент в конец списка можно через append().

 numbers = [0, 1, 2, 3, 4, 5] numbers.append(99) print(numbers[-1])

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

 numbers = [0, 1, 2, 3, 4, 5] numbers = [0, 1, 2, 3, 4, 5] numbers.insert(1, 33) print(numbers[1]) print(numbers) # [0, 33, 1, 2, 3, 4, 5]

Удалить элемент по указанному индексу можно через remove().

 numbers = [0, 1, 2, 3, 4, 5] numbers.remove(5) print(numbers) # [0, 1, 2, 3, 4]

Метод pop() также позволяет удалить элемент по индексу, но при этом возвращает значение удалённого элемента. Если индекс не указан, то удаляется последний элемент.

 numbers = [6, 3, 9, 5, 1, 5] poped = numbers.pop(2) print(poped) # 9 poped = numbers.pop() print(poped) # 5

Есть ещё способ удаления по индексу через инструкцию del.

Когда удаляется элемент с индексом 1, элемент, имевший индекс 2, становится элементом с индексом 1, элемент, имевший индекс 3, приобретает индекс 2 и так далее. Соответственно, количество индексов при удалении элемента уменьшается.

Можно запускать команду del numbers[1] снова и снова, удаляя по одному элементу списка. Главное, это вовремя остановиться, чтобы не получить ошибку при удалении несуществующего индекса.

Длину списка можно узнать через len().

 numbers = [6, 8, 2, 5, 1, 5] print(len(numbers)) # 6

Узнать количество одинаковых элементов в списке можно через count().

 kitten = list('котёнок') print(kitten.count('к')) # 2

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

 oneList = [6, 8, 2, 5, 1, 5] secondList = [0, 1, 4] oneList.extend(secondList) print(oneList) # [6, 8, 2, 5, 1, 5, 0, 1, 4]

Два списка можно сложить и получить третий список.

 firstList = [6, 8, 2, 5, 1, 5] secondList = [0, 1, 4] bigList = firstList + secondList print(bigList) # [6, 8, 2, 5, 1, 5, 0, 1, 4]

Пройтись по всем элементам списка можно через цикл for.

 numbers = [1, 2, 3] for element in numbers: print(element)

Фильтрация списка через filter() с лямбдой

Мы можем фильтровать элементы списка по заданному условию, используя класс filter и лямбда-выражения.

Допустим, у нас есть список чисел от 1 до 10 и мы хотим оставить числа меньше 5. Применяем к списку функцию filter(), в котором указываем лямбда-выражение — берётся каждый элемент списка и проверяется условие. Если число меньше 5, то условие выполняется и число попадает в объект класса filter. Затем мы создаём новый список, куда помещаем созданный объект и на выходе получаем финальный результат — отфильтрованный список.

 sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] filterObj = filter(lambda x: x < 5, sourceList) print(type(filterObj)) # filteredList = list(filterObj) print(filteredList) # [1, 2, 3, 4]

Существует другой громоздкий вариант через цикл for, который не стал приводить здесь.

Вместо лямбда-выражения можно использовать именную функцию. Создадим именную функцию под именем isGreater и зададим условие - числа должны быть больше 5.

 def isGreater(x): return x > 5 sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] filteredList = list(filter(isGreater, sourceList)) print(str(filteredList))

Проекция на список через map() с лямбдой

Если нужно пройтись по всем элементам списка и что-то с ним сделать, то подойдёт функция map(). Допустим, мы хотим увеличить значение каждого элемента на заданную величину.

 sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] mapObj = map(lambda x: x + 9, sourceList) print(type(mapObj)) # mappedList = list(mapObj) print(mappedList) # [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Вырезка последовательности

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

 item[START:STOP:STEP]

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

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

 sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] print(sourceList[1:4]) # со второго до четвёртого print(sourceList[5:]) # с шестого элемента до конца print(sourceList[1:-1]) # со второго до предпоследнего print(sourceList[:]) # все элементы 
[2, 3, 4] [6, 7, 8, 9, 10] [2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Можно указать шаг вырезки в третьем аргументе (по умолчанию шаг вырезки равен 1):

 sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] print(sourceList[1:8:2]) # [2, 4, 6, 8]

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

 sourceList = [1, 2, 3, 4, 5] sourceList[1:3] = [7, 7, 7] # добавим три новых элемента вместо второго и третьего элемента print(sourceList) # [1, 7, 7, 7, 4, 5] del sourceList[:-3] # удаляем первые элементы списка до третьего элемента с конца print(sourceList) # [7, 4, 5]

Всё о сортировке в Python: исчерпывающий гайд

Сортировка в Python выполняется с помощью sorted() и list.sort(). Разбираем на примерах, как это работает.

Сортировка в Python выполняется функцией sorted() , если это итерируемые объекты, и методом list.sort() , если это список. Рассмотрим подробнее, как это работало в старых версиях и как работает сейчас.

Примечание Вы читаете улучшенную версию некогда выпущенной нами статьи.

Разработка на Python с нуля: роадмап программиста

Основы сортировки

Так как отсортировать список Python? Для сортировки по возрастанию достаточно вызвать функцию сортировки Python sorted() , которая вернёт новый отсортированный список:

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

Для сортировки списка Python также можно использовать метод списков list.sort() , который изменяет исходный список (и возвращает None во избежание путаницы). Обычно Python sort list не так удобен, как использование sorted() , но если вам не нужен исходный список, то так будет немного эффективнее:

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

Прим.перев. В Python вернуть None и не вернуть ничего — одно и то же.

Ещё одно отличие заключается в том, что метод list.sort() определён только для списков, в то время как функция sorted Python работает со всеми итерируемыми объектами. Грубо говоря, функция sort Python сортирует список и сохраняет его в отсортированном виде, в то время как функция sorted Питон создаёт новый отсортированный список без изменения исходного.

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

Прим.перев. При итерировании по словарю Python возвращает его ключи. Если вам нужны их значения или пары «ключ-значение», используйте методы dict.values() и dict.items() соответственно.

Рассмотрим основные функции сортировки Python.

Функции-ключи

С версии Python 2.4 у list.sort() и sorted() появился параметр key для указания функции, которая будет вызываться на каждом элементе до сравнения. Вот регистронезависимое сравнение строк:

>>> sorted("This is a test string from Andrew".split(), key=str.lower) ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

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

Всё о сортировке в Python: исчерпывающий гайд 1

Часто можно встретить код, где сложный объект сортируется по одному из его индексов. Например:

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

Тот же метод работает для объектов с именованными атрибутами:

>>> 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)) def weighted_grade(self): return 'CBA'.index(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)]

Функции модуля operator

Показанные выше примеры функций-ключей встречаются настолько часто, что Python предлагает удобные функции, чтобы сделать всё проще и быстрее. Модуль operator содержит функции itemgetter() , attrgetter() и, начиная с Python 2.6, methodcaller() . С ними всё ещё проще:

>>> from operator import itemgetter, attrgetter, methodcaller >>> 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)]

Функции operator дают возможность использовать множественные уровни сортировки массива Python. Отсортируем учеников сначала по оценке, а затем по возрасту:

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

Используем функцию methodcaller() для сортировки учеников по взвешенной оценке:

>>> [(student.name, student.weighted_grade()) for student in student_objects] [('john', 0.13333333333333333), ('jane', 0.08333333333333333), ('dave', 0.1)] >>> sorted(student_objects, key=methodcaller('weighted_grade')) [('jane', 'B', 12), ('dave', 'B', 10), ('john', 'A', 15)]

Сортировка по возрастанию и сортировка по убыванию в Python

list.sort() и sorted() есть параметр reverse , принимающий boolean-значение. Он нужен для обозначения сортировки по убыванию. Отсортируем учеников по убыванию возраста:

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

Стабильность сортировки и сложные сортировки в Python

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

>>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)] >>> sorted(data, key=itemgetter(0)) [('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]

Обратите внимание, что две записи с 'blue' сохранили начальный порядок. Это свойство позволяет составлять сложные сортировки путём постепенных сортировок. Далее мы сортируем данные учеников сначала по возрасту в порядке возрастания, а затем по оценкам в убывающем порядке, чтобы получить данные, отсортированные в первую очередь по оценке и во вторую — по возрасту:

>>> s = sorted(student_objects, key=attrgetter('age')) # сортируем по вторичному ключу >>> sorted(s, key=attrgetter('grade'), reverse=True) # по первичному [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

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

Декорируем-сортируем-раздекорируем

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

Вот так можно отсортировать данные учеников по оценке:

>>> decorated = [(student.grade, i, student) for i, student in enumerate(student_objects)] >>> decorated.sort() >>> [student for grade, i, student in decorated] # раздекорируем [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

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

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

Сортировка стабильна — если у двух элементов одинаковый ключ, то их порядок не изменится.
У исходных элементов не обязательно должна быть возможность сравнения, так как порядок декорированных кортежей будет определяться максимум по первым двум элементам. Например, исходный список может содержать комплексные числа, которые нельзя сравнивать напрямую.

Ещё эта идиома называется преобразованием Шварца в честь Рэндела Шварца, который популяризировал её среди Perl-программистов.

Для больших списков и версий Python ниже 2.4, «декорируем-сортируем-раздекорируем» будет оптимальным способом сортировки. Для версий 2.4+ ту же функциональность предоставляют функции-ключи.

Использование параметра cmp

Все версии Python 2.x поддерживали параметр cmp для обработки пользовательских функций сравнения. В Python 3.0 от этого параметра полностью избавились. В Python 2.x в sort() можно было передать функцию, которая использовалась бы для сравнения элементов. Она должна принимать два аргумента и возвращать отрицательное значение для случая «меньше чем», положительное — для «больше чем» и ноль, если они равны:

>>> def numeric_compare(x, y): return x - y >>> sorted([5, 2, 4, 1, 3], cmp=numeric_compare) [1, 2, 3, 4, 5]

Можно сравнивать в обратном порядке:

>>> def reverse_numeric(x, y): return y - x >>> sorted([5, 2, 4, 1, 3], cmp=reverse_numeric) [5, 4, 3, 2, 1]

При портировании кода с версии 2.x на 3.x может возникнуть ситуация, когда нужно преобразовать пользовательскую функцию для сравнения в функцию-ключ. Следующая обёртка упрощает эту задачу по Python:

def cmp_to_key(mycmp): 'Перевести cmp=функция в key=функция' class K(object): def __init__(self, obj, *args): self.obj = obj def __lt__(self, other): return mycmp(self.obj, other.obj) < 0 def __gt__(self, other): return mycmp(self.obj, other.obj) >0 def __eq__(self, other): return mycmp(self.obj, other.obj) == 0 def __le__(self, other): return mycmp(self.obj, other.obj) = 0 def __ne__(self, other): return mycmp(self.obj, other.obj) != 0 return K

Чтобы произвести преобразование, оберните старую функцию:

>>> sorted([5, 2, 4, 1, 3], key=cmp_to_key(reverse_numeric)) [5, 4, 3, 2, 1]

В Python 2.7 функция cmp_to_key() была добавлена в модуль functools.

Поддержание порядка сортировки

В стандартной библиотеке Python нет модулей, аналогичных типам данных C++ вроде set и map . Python делегирует эти задачи сторонним библиотекам, доступным в Python Package Index: они используют различные методы для сохранения типов list , dict и set в отсортированном порядке. Поддержание порядка с помощью специальной структуры данных может помочь избежать очень медленного поведения (квадратичного времени выполнения) при наивном подходе с редактированием и постоянной пересортировкой данных. Вот некоторые из модулей, реализующих эти типы данных:

SortedContainers — реализация сортированных типов list , dict и set на чистом Python, по скорости не уступает реализациям на C. Тестирование включает 100% покрытие кода и многие часы стресс-тестирования. В документации можно найти полный справочник по API, сравнение производительности и руководства по внесению своего вклада.
rbtree — быстрая реализация на C для типов dict и set . Реализация использует структуру данных, известную как красно-чёрное дерево.
treap — сортированный dict . В реализации используется Декартово дерево, а производительность улучшена с помощью Cython.
bintrees — несколько реализаций типов dict и set на основе деревьев на C. Самые быстрые основаны на АВЛ и красно-чёрных деревьях. Расширяет общепринятый API для предоставления операций множеств для словарей.
banyan — быстрая реализация dict и set на C.
skiplistcollections — реализация на чистом Python, основанная на списках с пропусками, предлагает ограниченный API для типов dict и set .
blist — предоставляет сортированные типы list , dict и set , основанные на типе данных «blist», реализация на Б-деревьях. Написано на Python и C.

Прочее

Для сортировки с учётом языка используйте locale.strxfrm() в качестве ключевой функции или locale.strcoll() в качестве функции сравнения. Параметр reverse всё ещё сохраняет стабильность сортировки. Этот эффект можно сымитировать без параметра, использовав встроенную функцию reversed() дважды:

>>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)] >>> assert sorted(data, reverse=True) == list(reversed(sorted(reversed(data))))

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

>>> Student.__eq__ = lambda self, other: self.age == other.age >>> Student.__ne__ = lambda self, other: self.age != other.age >>> Student.__lt__ = lambda self, other: self.age < other.age >>> Student.__le__ = lambda self, other: self.age >> Student.__gt__ = lambda self, other: self.age > other.age >>> Student.__ge__ = lambda self, other: self.age >= other.age >>> sorted(student_objects) [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Для типов, сравнение которых работает обычным образом, рекомендуется определять все 6 операторов. Декоратор классов functools.total_ordering упрощает их реализацию. Функциям-ключам не нужен доступ к внутренним данным сортируемых объектов. Они также могут осуществлять доступ к внешним ресурсам. Например, если оценки ученика хранятся в словаре, их можно использовать для сортировки отдельного списка с именами учеников:

>>> students = ['dave', 'john', 'jane'] >>> newgrades = >>> sorted(students, key=newgrades.__getitem__) ['jane', 'dave', 'john']

Надеемся, теория по Python list sort и соответствующие задачи по Питону с разбором были для вас полезны. Вас также может заинтересовать статьи:

Хочу научиться программировать на Python. С чего начать?
Хочу научиться программировать на Python: инструкция для продолжающих