Python sort lambda: sorting - How to sort with lambda in Python

Содержание

Сортировки и лямбда-функции

Параметр key стандартной сортировки

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

Например, пусть дан список строк, содержащих цифры, нужно упорядочить элементы списка, сравнивая
их, как числа, а не как строки. Это можно сделать так:

a = ["10", "20", "30", "1", "2", "3", "111", "112", "222"]
a.sort(key=int)

В качестве параметра передаётся функция int, которая будет использоваться для сравнения элементов,
которое теперь будет выполняться в виде int(a[i]) < int(a[j]). Вместо функции int можно
использовать любую другую функцию, которая принимает один аргумент (элемент массива) и возвращает значение,
например, если вызвать a.sort(key=len), то строки будут упорядочены по длине.

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

def last_digit(n):
    return n % 10

a.sort(key=last_digit)

Параметр key можно использовать вместе с параметром reverse.

Лямбда-функции

В предыдущем примере пришлось создавать отдельную функцию только для того,
чтобы задать порядок сортировки, что захламляет программу ненужными функциями.
В таких случаях нужно использовать лямбда-функции: “одноразовые фукцнии,
которые можно объявлять без использовать слова def, прямо при вызове сортировки.
Лямбда-функция — это функция, которая состоит только из одной строки с инструкцией
return, то есть функция сразу возвращает значение по набору аргументов.
Лямбда-функции объявляются таким образом:

lambda список переменных-аргументов: возвращаемое значение

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

a = [3, 15, 22, 13, 12, 32, 45, 43]
a.sort(key=lambda n: n % 10)

Рассмотрим другой пример. Пусть дан список точек, каждая точка: кортеж из двух чисел.
Например, [(3, -2), (7, 1), (0, 4)]. Этот список нужно отсортировать по возрастанию
расстояния от начала координат до точки. Напишем лямбда-функцию:

a.sort(key=lamda point: point[0] ** 2 + point[1] ** 2)

Элементами списка являются кортежи из двух координат, можно обратиться к этим координатам
по индексам [0] и [1].

Устойчивость сортировки

Вернёмся к примеру сортировки по последней цифре. В приведённом выше примере
упорядоченный список будет таким:

[22, 12, 32, 3, 13, 43, 15, 45]

Этот пример иллюстрирует свойство устойчивости сортировки: функция сортировки не переставлят
элементы, если они равны друг другу. В данном случае функция упорядочивает числа по последней цифре,
а при равной последней цифре сохраняется порядок следования элементов в исходном списке: 22, 12, 32.

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

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

a.sort(key=lambda n: (n % 10, n))

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

a.sort()
a.sort(key=lambda n: n % 10)

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

Функция operator.itemgetter

При сортировке кортежей частой задачей является сортировка
по какому-то одному элементу кортежа. Например, если нужно отсортировать
кортежи по элементу с индексом 1, то можно написать такую лямбда-функцию:

a.sort(key=lambda elem: elem[1])

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

def itemgetter(i):
    return lambda elem: elem[i]

То есть operator.itemgetter(i) — это функция, при вызове которой от числового параметра
создаётся лямдба-функция, которую можно использовать в качестве параметра key. Если вызвать функцию itemgetter
от нескольких параметров, то полученная функция будет возвращать кортеж из элементов с заданными индексами.

сортировка списков методом .sort() с ключом — простыми словами / Хабр

Поводом опубликовать пост стало то, что при детальном изучении списков (массивов) в Python я не смог найти в сети ни одного простого описания метода сортировки элементов с использованием ключа: list.sort(key=…).

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

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

sortList = ['a', 'сс', 'bbb']

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

sortList.sort()

то получим на выходе:

>>> ['a', 'bbb', 'cc']

Однако метод .sort() позволяет нам изменять и принцип, и порядок сортировки.

Для изменения принципа сортировки используется ключевое слово key, которое стало доступным начиная с версии Python 2.4.

Предположим, нам хотелось бы отсортировать наш список двумя способами: 1. в алфавитном порядке; 2. по длине строки. Первый способ, впрочем, уже работает как сортировка по умолчанию, однако мы можем добиться таких же результатов и с помощью параметра key:

sortList = ['a', 'cc', 'bbb']

# Создаем «внешнюю» функцию, которая будет сортировать список в алфавитном порядке:

def sortByAlphabet(inputStr):

return inputStr[0] # Ключом является первый символ в каждой строке, сортируем по нему

# Вторая функция, сортирующая список по длине строки:

def sortByLength(inputStr):

return len(inputStr) # Ключом является длина каждой строки, сортируем по длине

print u’Исходный список: ‘, sortList # >>> [‘a’, ‘cc’, ‘bbb’]

sortList.sort(key=sortByAlphabet) # Каждый элемент массива передается в качестве параметра функции

print u’Отсортировано в алфавитном порядке: ‘, sortList # >>> [‘a’, ‘bbb’, ‘cc’]

sortList.sort(key=sortByLength) # Каждый элемент массива передается в качестве параметра функции

print u’Отсортировано по длине строки: ‘, sortList # >>> [‘a’, ‘cc’, ‘bbb’]

# Теперь отсортируем по длине строки, но в обратном порядке:

sortList.sort(key=sortByLength, reverse=True) # В обратном порядке

print u’Отсортировано по длине строки, в обратном порядке: ‘, sortList # >>> [‘bbb’, ‘cc’, ‘a’]

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

newList = sorted(sortList)

— либо такой же вариант, но с параметром key (аналогично описанному выше):

newList = sorted(sortList, key=sortByLength)

У метода .sorted() есть и другие параметры, но мне они показались не настолько запутанными для самостоятельного разбора.

синтаксис, аргументы и много примеров ~ PythonRu

В этой статье вы узнаете о том, что такое лямбда-функции в Python. На самом деле, если вы знаете, что такое функции и умеете с ними работать, то знаете и что такое лямбда.

Лямбда-функция в Python — это просто функция Python. Но это некий особенный тип с ограниченными возможностями. Если есть желание погрузиться глубже и узнать больше, то эта статья целиком посвящена lambda.

Что такое лямбда в Python?

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

Для этого потребуется немного поменять направление мышление. Как вы знаете, все в Python является объектом.

Например, когда мы запускаем эту простейшую строку кода

x = 5

Создается объект Python типа int, который сохраняет значение 5. x же является символом, который ссылается на объект.

Теперь проверим тип x и адрес, на которой он ссылается. Это можно сделать с помощью встроенных функций type и id.

>>> type(x)
<class 'int'>
>>> id(x)
4308964832

В итоге x ссылается на объект типа int, а расположен он по адресу, который вернула функция id.

Подписывайтесь на телеграм каналы

Просто и понятно.

А что происходит при определении вот такой функции:

>>> def f(x):
...     return x * x
...

Повторим упражнение и узнаем type и id объекта f.

>>> def f(x):
...     return x * x
...
>>> type(f)
<class 'function'>
>>> id(f)
4316798080

Оказывается, в Python есть класс function, а только что определенная функция f — это его экземпляр. Так же как x был экземпляром класса integer. Другими словами, о функциях можно думать как о переменных. Разница лишь в том, что переменные хранят данные, а функции — код.

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

Рассмотрим простой пример, где функция f передается другой функции.

def f(x):
    return x * x

def modify_list(L, fn):
    for idx, v in enumerate(L):
        L[idx] = fn(v)

L = [1, 3, 2]
modify_list(L, f)
print(L)

Попробуйте разобраться самостоятельно с тем, что делает этот код, прежде чем читать дальше.

Итак, modify_list — это функция, которая принимает список L и функцию fn в качестве аргументов. Затем она перебирает список элемент за элементом и применяет функцию к каждому из них.

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

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

Теперь, когда с основами разобрались, стоит перейти к лямбда. Лямбда в Python — это просто еще один способ определения функции. Вот базовый синтаксис лямбда-функции в Python:

lambda arguments: expression

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

>>> f = lambda x: x * x
>>> type(f)
<class 'function'>

Но возникает вопрос: а зачем нужны лямбда-функции, если их можно объявлять традиционным образом? Но на самом деле, они полезны лишь в том случае, когда нужна одноразовая функция. Такие функции еще называют анонимными. И, как вы увидите дальше, есть масса ситуаций, где они оказываются нужны.

Лямбда с несколькими аргументами

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

>>> f = lambda x: x * x
>>> f(5)
25

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

>>> f = lambda x, y: x * y
>>> f(5, 2)
10

Отлично! А как насчет лямбда-функции без аргументов?

Лямбда-функция без аргументов

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

>>> f = lambda: True
>>> f()
True

Несколько лямбда-функций

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

Ответ однозначен: нет.

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

Примеры лямбда-функций

Теперь рассмотрим самые распространенные примеры использования лямбда-функций.

Лямбда-функция и map

Распространенная операция со списками в Python — применение операции к каждому элементу.

map() — это встроенная функция Python, принимающая в качестве аргумента функцию и последовательность. Она работает так, что применяет переданную функцию к каждому элементу.

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

>>> L = [1, 2, 3, 4]
>>> list(map(lambda x: x**2, L))
[1, 4, 9, 16]

Обратите внимание на то, что в Python3 функция map возвращает объект Map, а в Python2 — список.

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

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

Лямбда-функция и filter

filter() — это еще одна встроенная функция, которая фильтрует последовательность итерируемого объекта.

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

Если возвращаемое значение — True, элемент остается. В противном случае — отклоняется. Определим, например, простую функцию, которая возвращает True для четных чисел и False — для нечетных:

def even_fn(x):
  if x % 2 == 0:
    return True
  return False

print(list(filter(even_fn, [1, 3, 2, 5, 20, 21])))

С лямбда-функциями это все можно сделать максимально сжато. Код выше можно преобразовать в такой, написанный в одну строку.

print(list(filter(lambda x: x % 2 == 0, [1, 3, 2, 5, 20, 21])))

И в этом сила лямбда-функций.

Лямбда-функция и сортировка списков

Сортировка списка — базовая операция в Python. Если речь идет о списке чисел или строк, то процесс максимально простой. Подойдут встроенные функции sort и sorted.

Но иногда имеется список кастомных объектов, сортировать которые нужно на основе значений одного из полей. В таком случае можно передать параметр key в sort или sorted. Он и будет являться функцией.

Функция применяется ко всем элементам объекта, а возвращаемое значение — то, на основе чего выполнится сортировка. Рассмотрим пример. Есть класс Employee.

class Employee:
    def __init__(self, name, age):
        self.name = name
        self.age = age

Теперь создадим экземпляры этого класса и добавим их в список.

Alex = Employee('Alex', 20)
Amanda = Employee('Amanda', 30)
David = Employee('David', 15)
L = [Alex, Amanda, David]

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

L.sort(key=lambda x: x.age)
print([item.name for item in L])

Лямбда-выражение было использовано в качестве параметра key вместо отдельного ее определения и затем передачи в функцию sort.

Пара слов о выражениях и инструкциях

Как уже упоминалось, лямбда могут иметь только одно выражение (expression) в теле.

Обратите внимание, что речь идет не об инструкции (statement).

Выражение и инструкции — две разные вещи, в которых часто путаются. В программировании инструкцией является строка кода, выполняющая что-то, но не генерирующая значение.

Например, инструкция if или циклы for и while являются примерами инструкций. Заменить инструкцию на значение попросту невозможно.

А вот выражения — это значения. Запросто можно заменить все выражения в программе на значения, и программа продолжит работать корректно.

Например:

3 + 5 — выражение со значением 8
10 > 5 — выражение со значением True
True and (5 < 3) — выражение со значением False

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

сортировка списков методом .sort() с ключом — простыми словами / Habr

sortList = ['a', 'сс', 'bbb']

sortList.sort()

то получим на выходе:

>>> ['a', 'bbb', 'cc']

Однако метод .sort() позволяет нам изменять и принцип, и порядок сортировки.

sortList = ['a', 'cc', 'bbb']

print u’Исходный список: ‘, sortList # >>> [‘a’, ‘cc’, ‘bbb’]

newList = sorted(sortList)

— либо такой же вариант, но с параметром key (аналогично описанному выше):

newList = sorted(sortList, key=sortByLength)

Лямбда-ключ

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

Переполнение стека

Около
Продукты
Для команд

Переполнение стека
Общественные вопросы и ответы
Переполнение стека для команд
Где разработчики и технологи делятся частными знаниями с коллегами
Вакансии
Программирование и связанные с ним технические возможности карьерного роста
Талант
Нанимайте технических специалистов и создавайте свой бренд работодателя
Реклама
Обратитесь к разработчикам и технологам со всего мира
О компании

Сортировка КАК — документация Python 3.8.6

Автор: Эндрю Далке и Раймонд Хеттингер
Выпуск: 0,1

Списки Python имеют встроенный метод list.sort () , который изменяет список
на месте. Также имеется встроенная функция sorted () , которая создает новый
отсортированный список из итерируемого.

В этом документе мы исследуем различные методы сортировки данных с помощью Python.

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

Простая сортировка по возрастанию очень проста: достаточно вызвать функцию sorted () . Это
возвращает новый отсортированный список:

 >>> отсортировано ([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]

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

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

Другое отличие состоит в том, что метод list.sort () определен только для
списки. Напротив, функция sorted () принимает любую итерацию.

 >>> отсортировано ({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]

Основные функции

И list.sort (), и sorted () имеют параметр key для указания
функция, вызываемая для каждого элемента списка перед сравнением.

Например, здесь сравнение строк без учета регистра:

 >>> sorted ("Это тестовая строка от Эндрю" .split (), key = str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

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

Распространенным шаблоном является сортировка сложных объектов с использованием некоторых индексов объекта.
как ключи.Например:

 >>> student_tuples = [
... ('john', 'A', 15),
... ('Джейн', 'B', 12),
... ('Дэйв', 'B', 10),
...]
>>> sorted (student_tuples, key = lambda student: student [2]) # сортировать по возрасту
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

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

 >>> класс Студент:
... def __init __ (я, имя, класс, возраст):
... self.name = имя
... себя.оценка = оценка
... self.age = возраст
... def __repr __ (сам):
... вернуть repr ((self.name, self.grade, self.age))

 >>> student_objects = [
... Студент ('john', 'A', 15),
... Студентка ('Джейн', 'B', 12),
... Студент ('dave', 'B', 10),
...]
>>> sorted (student_objects, key = lambda student: student.age) # сортировать по возрасту
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Функции модуля оператора

Шаблоны ключевых функций, показанные выше, очень распространены, поэтому Python предоставляет
удобные функции для упрощения и ускорения дополнительных функций.В
оператор модуль имеет itemgetter () ,
attrgetter () и функция methodcaller () .

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

 >>> из оператора import itemgetter, attrgetter

 >>> отсортировано (наборы учеников, ключ = itemgetter (2))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

 >>> отсортировано (объекты-ученики, ключ = attrgetter ('возраст'))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

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

 >>> отсортировано (наборы учеников, ключ = itemgetter (1,2))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

 >>> отсортировано (объекты-ученики, ключ = attrgetter ('оценка', 'возраст'))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

По возрастанию и по убыванию

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

 >>> отсортировано (наборы учеников, ключ = itemgetter (2), обратный = True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

Лямбда-сортировка в Python 3

Переполнение стека

Около
Продукты
Для команд

Переполнение стека
Общественные вопросы и ответы
Переполнение стека для команд
Где разработчики и технологи делятся частными знаниями с коллегами
Вакансии
Программирование и связанные с ним технические возможности карьерного роста
Талант
Нанимайте технических специалистов и создавайте свой бренд работодателя
Реклама
Обратитесь к разработчикам и технологам со всего мира
О компании

Загрузка…

Авторизоваться
зарегистрироваться
текущее сообщество
- Переполнение стека
  Помогите
  болтать
- Переполнение мета-стека

Как отсортировать список кортежей по 2-му элементу с помощью лямбда-функции или компаратора — thispointer.com

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

Предположим, у нас есть список кортежей, то есть слов и их частота,

 # Список кортежей, т.е. слово и его частота
wordFreq = [('the', 34), ('at', 23), ('should', 1), ('from', 3)]

Теперь, если мы напрямую вызовем метод sort () в этом списке i.е.

 ''
По умолчанию функция sort () сортирует список кортежей по первому элементу кортежа.
'' '
wordFreq.sort ()

Затем он отсортирует его по первому элементу кортежа, т.е.

 [('at', 23), ('from', 3), ('should', 1), ('the', 34)]

Но если мы хотим отсортировать его, используя второй элемент кортежа, то есть счетчик частоты, то есть

 ('should', 1)
('от', 3)
('в', 23)
('the', 34)

Посмотрим, как это сделать,

Сортировка списка кортежей по 2-му элементу кортежа с помощью лямбда-функции

Для сортировки списка кортежей по 2-му элементу или i-му элементу нам нужно передать наш настраиваемый компаратор i.е. ключевая функция в sort (),

 wordFreq.sort (key = KeyFunction ())

Что такое ключевая функция?

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

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

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

 '' '
Сортировка списка кортежа по 2-му элементу кортежа, используя лямбда-функцию в качестве ключевой функции
'' '
wordFreq.sort (key = lambda elem: elem [1])

Теперь содержимое списков будет таким:

 [('следует', 1), ('от', 3), ('в', 23), ('the', 34)]

Сортировка списка кортежей по 2-му элементу кортежа с использованием пользовательской функции в качестве компаратора

Сначала определите функцию, которая принимает кортеж и возвращает из него второй элемент i.е.

 компаратор def (tupleElem):
    вернуть tupleElem [1]

Теперь используйте эту функцию в качестве ключевой при сортировке списка кортежей, т.е.

 '' '
Сортировка списка кортежа по 2-му элементу кортежа с помощью пользовательской функции или компаратора
'' '
wordFreq.sort (ключ = компаратор)

Он отсортирует список по 2-му элементу кортежа, т.е.

 [('должен', 1), ('от', 3), ('в', 23), ('the', 34)]

Полный пример выглядит следующим образом:

 def компаратор (tupleElem):
    вернуть tupleElem [1]

def main ():

    # Список кортежей i.е. слово и его частота
    wordFreq = [('the', 34), ('at', 23), ('should', 1), ('from', 3)]

    # Распечатать список кортежей
    печать (wordFreq)

    print ("Список сортировки кортежа по первому элементу кортежа")
    
    '' '
    По умолчанию функция sort () сортирует список кортежей по первому элементу кортежа.
    '' '
    wordFreq.sort ()
    
    печать (wordFreq)
    
    print ("Список сортировки кортежа по 2-му элементу кортежа")
        
    '' '
    Сортировка списка кортежа по 2-му элементу кортежа, используя лямбда-функцию в качестве ключевой функции
    '' '
    wordFreq.sort (key = lambda elem: elem [1])
    
    печать (wordFreq)
    
    '' '
    Сортировка списка кортежа по 2-му элементу кортежа с помощью пользовательской функции или компаратора
    '' '
    wordFreq.sort (ключ = компаратор)
    
    # Распечатать список кортежей
    печать (wordFreq)
    
    
если __name__ == '__main__':
    главный()

Вывод:

 [('the', 34), ('at', 23), ('should', 1), ('from', 3)]
Сортировка списка кортежа по первому элементу кортежа
[('at', 23), ('from', 3), ('should', 1), ('the', 34)]
Сортировка списка кортежа по 2-му элементу кортежа
[('должен', 1), ('от', 3), ('в', 23), ('в', 34)]
[('должен', 1), ('от', 3), ('в', 23), ('в', 34)]

About Me

Dashy

Python sort lambda: sorting — How to sort with lambda in Python