Сравнение списков в Python
В этой статье мы рассмотрим различные способы, позволяющие осуществить сравнение списков в Python .
Сравнение списков в Python — возможные методы
Для сравнения можно использовать следующие функции:
- reduce() и map();
- collection.counter();
- sort() вместе с оператором ==;
- set() вместе с оператором ==;
- List Comprehension.
Функции reduce() и map()
Мы можем использовать функцию map() вместе с functools.reduce() для сравнения элементов двух списков. Метод map() принимает в качестве аргументов функцию и коллекцию (список, кортеж, строку и т. д.). Он применяет переданную функцию к каждому элементу перебираемого объекта и возвращает коллекцию.
Метод functools.reduce() применяет переданную функцию к каждому переданному элементу рекурсивным способом.
Метод map() применит переданную функцию к каждому элементу, а reduce() обеспечит ее последовательное применение.
import functools l1 = [10, 20, 30, 40, 50] l2 = [10, 20, 30, 50, 40, 70] l3 = [10, 20, 30, 40, 50] if functools.reduce(lambda x, y : x and y, map(lambda p, q: p == q,l1,l2), True): print ("Списки l1 и l2 одинаковые") else: print ("Списки l1 и l2 не одинаковые") if functools.reduce(lambda x, y : x and y, map(lambda p, q: p == q,l1,l3), True): print ("Списки l1 и l3 одинаковые") else: print ("Списки l1 и l3 не одинаковые") Списки l1 и l2 не одинаковые Списки l1 и l3 одинаковые
Метод collection.counter()
Метод collection.counter() может использоваться для сравнения списков. Функция counter() подсчитывает частоту элементов в списке и сохраняет данные в виде словаря, представленного в формате : . Если два списка имеют одинаковый выходной словарь, то они одинаковы.
Примечание: порядок элементов списка не влияет на результат работы метода counter().
import collections l1 = [10, 20, 30, 40, 50] l2 = [10, 20, 30, 50, 40, 70] l3 = [10, 20, 30, 40, 50] if collections.Counter(l1) == collections.Counter(l2): print ("Списки l1 и l2 одинаковые") else: print ("Списки l1 и l2 неодинаковые") if collections.Counter(l1) == collections.Counter(l3): print ("Списки l1 и l3 одинаковые") else: print ("Списки l1 и l3 неодинаковые") Списки l1 и l2 неодинаковые Списки l1 и l3 одинаковые
Метод sort() и оператор ==
Для сравнения двух списков можно использовать метод sort() вместе с оператором ==. Метод sort() используется для сортировки таким образом, чтобы элементы в двух списках находились на одинаковых позициях.
Примечание: порядок элементов не влияет на результат, поскольку мы будем сортировать списки перед сравнением.
Оператор == используется для сравнения списков элемент за элементом.
import collections l1 = [10, 20, 30, 40, 50] l2 = [10, 20, 30, 50, 40, 70] l3 = [50, 10, 30, 20, 40] l1.sort() l2.sort() l3.sort() if l1 == l3: print ("Списки l1 и l3 одинаковые") else: print ("Списки l1 и l3 неодинаковые") if l1 == l2: print ("Списки l1 и l2 одинаковые") else: print ("Списки l1 и l2 неодинаковые") Списки l1 и l3 одинаковые Списки l1 и l2 неодинаковые
Метод set() и оператор ==
Метод set() управляет элементами отсортированных последовательностей без учета их порядка. Оператор ==используется для сравнения списков поэлементно.
l1 = [10, 20, 30, 40, 50] l3 = [50, 10, 30, 20, 40] a = set(l1) b = set(l3) if a == b: print("Списки l1 и l3 одинаковые") else: print("Списки l1 и l3 не одинаковые") Списки l1 и l3 одинаковые
List Comprehension
List Comprehension можно использовать для сравнения двух списков.
l1 = [10, 20, 30, 40, 50] l3 = [50, 75, 30, 20, 40, 69] res = [x for x in l1 + l3 if x not in l1 or x not in l3] print(res) if not res: print("Списки l1 и l3 одинаковые") else: print("Списки l1 и l3 не одинаковые") В приведенном выше коде мы устанавливаем элемент указателя x на список l1 и l3. Далее мы проверяем, присутствует ли элемент в списках.
[10, 75, 69] Списки l1 и l3 неодинаковые
Заключение
В этой статье мы рассмотрели несколько способов сравнения списков в Python.
Как сравнить два списка в Python
Давайте предположим, что у вас есть два списка, которые содержат одинаковые элементы. Однако эти элементы стоят в разном порядке. Например:
one = [33, 22, 11, 44, 55] two = [22, 11, 44, 55, 33]
Два приведенных выше списка содержат одни и те же элементы, а вот их порядок отличается. Давайте посмотрим, как мы можем удостовериться, что перед нами два одинаковых списка.
- Мы можем использовать метод collections.Counter
- Можно использовать sorted(), если объекты поддаются порядку.
from collections import Counter one = [33, 22, 11, 44, 55] two = [22, 11, 44, 55, 33] print("Эквивалентны ли эти два списка?", Counter(one) == Counter(two)) 'Эквивалентны ли эти два списка?', True
Сравнение и идентичность двух списков в Python
Если нужен список уникальных элементов в объединении двух списков:
result = list(set(lst1 + lst2)) # ['red', 'white', 'green', 'blue']
Симметричная разность двух списков:
result = list(set(lst1) ^ set(lst2)) # ['green', 'blue']
Обычная разность(множество из lst1 не входящее в lst2 ):
result = list(set(lst1) - set(lst2)) # ['green','blue']
Вариант, сохраняющий порядок с меньшим количеством конверсий типов:
result = [x for x in lst1 if x in set(lst2))]
Как сравнить поиндексно значения двух списков?
Имеем два списка:
lit1 = [23, 56, 78, 69] lit2 = [11, 89, 33, 45]
Задача состоит в том, чтобы сравнить эти списки поиндексно, при сравнении меньший элемент вынести в отдельный список result .
Смотрим решение с комментариями к коду:
list1 = [23, 56, 78, 69] list2 = [11, 89, 33, 45] # список для результата result = [] # перебираем элементы списка # в пределах длины первого списка for i in range(len(lst1)): # сравниваем элементы первого списка # с элементами второго списка if lst1[i] lst2[i]: # добавляем в итоговый список `result` # элемент из первого, если он меньше result.append(list1[i]) else: # иначе - добавляем элемент из второго списка result.append(list2[i]) # выводим итоговый список print(result)
Код выше можно записать короче, при помощи выражения-генератора списка или функции map()
result = [min(p) for p in zip(list1, list2)] # или result = list(map(min, zip(l1, l2)))
Вычисление идентичности двух списков в Python.
Задача состоит в том, чтобы проверить, содержат ли два списка точно одинаковые элементы. Это довольно полезная распространенная задача.
Так как оператор == сравнивает списки поиндексно слева направо, то решение состоит в том, чтобы перед сравнением эти списки отсортировать, ведь заранее неизвестно, упорядочены они или нет.
Метод списка list.sort() сортирует его на месте (т.е. не создает новый). Если необходимо сохранить начальную сортировку списков, то для сортировки используйте функцию sorted() , она создаст новый отсортированный список, который можно сравнивать.
lst1 = [5, 3, 1, 2, 4] lst2 = [1, 2, 4, 3, 5] if lst1.sort() == lst2.sort(): print('Списки идентичны') else: print('Списки не идентичны')
- КРАТКИЙ ОБЗОР МАТЕРИАЛА.
- Список Python как аргумент по умолчанию
- Использование списка в качестве стека
- Использование списка в качестве очереди
- Генератор списка list
- Эффективное использование генераторов списков
- Операция присваивания на месте и списки
- Поведение списков Python в разных областях видимости
- Сравнение и идентичность двух списков
- Как получить несколько последних элементов списка
Как сравнивать списки в Python
При программировании или изучении Python вам может понадобиться определить, равны ли два или несколько списков. При сравнении списков вы проверяете, одинаковой ли длины списки и соответствуют ли их элементы. Списки разной длины никогда не бывают равными.
В этом мануале мы разберем, как применять следующие функции Python для сравнения списков:
- Метод sort() или функция sorted() с оператором ==
- Функция set() с оператором ==
- Функции reduce() и map() с оператором ==
- Класс collection.Counter() с оператором ==
- Генератор списков
Метод sort() и функция sorted()
Сравнить списки можно с помощью метода sort() или функции sorted(). Метод sort() сортирует старый список, а функция sorted() возвращает новый. После сортировки равные списки будут иметь одинаковые элементы в одинаковых индексных позициях. Оператор == сравнивает списки поэлементно.
Порядок элементов исходного списка не важен, поскольку списки сортируются перед сравнением.
Примечание: Можно сортировать только списки, в которых элементы имеют одинаковый тип данных.
Пример sort()
В следующем примере показано, как с помощью метода sort() сортировать и сравнивать списки:
l1 = [10, 20, 30, 40, 50] l2 = [20, 30, 50, 40, 70] l3 = [50, 10, 30, 20, 40] l1.sort() l2.sort() l3.sort() if l1 == l2: print ("The lists l1 and l2 are the same") else: print ("The lists l1 and l2 are not the same") if l1 == l3: print ("The lists l1 and l3 are the same") else: print ("The lists l1 and l3 are not the same")
Получим следующий вывод:
The lists l1 and l3 are the same The lists l1 and l2 are not the same
Код предыдущего примера сортирует каждый список, сравнивает l1 с l3 и выводит результат, а затем сравнивает l1 с l2 и выводит результат.
Пример функции sorted()
В следующем примере показано, как с помощью функции sorted() сортировать и сравнить списки:
l1 = [10, 20, 30, 40, 50] l2 = [20, 30, 50, 40, 70] l3 = [50, 10, 30, 20, 40] l1_sorted = sorted(l1) l2_sorted = sorted(l2) l3_sorted = sorted(l3) if l1_sorted == l2_sorted: print ("The lists l1 and l2 are the same") else: print ("The lists l1 and l2 are not the same") if l1_sorted == l3_sorted: print ("The lists l1 and l3 are the same") else: print ("The lists l1 and l3 are not the same")
Вывод будет следующим:
The lists l1 and l3 are the same The lists l1 and l2 are not the same
Код предыдущего примера возвращает отсортированную версию каждого списка, сравнивает l1 с l3 и выводит результат, а затем сравнивает l1 с l2 и выводит результат.
Сравнение списков с помощью функций reduce() и map()
Сравнить элементы двух списков можно с помощью функции map() вместе с функцией functools.reduce(). При их комбинации map() применяет заданную функцию к каждому элементу, а функция reduce() обеспечивает последовательное применение функции.
Функция map() принимает в качестве аргументов функцию и итератор. Затем map() применяет заданную функцию к каждому элементу итерации,а затем возвращает объект map (итератор) в качестве результата.
functools.reduce() в качестве аргументов также принимает функцию и итерируемый объект. Она рекурсивно применяет заданную функцию к каждому элементу итерации. Сначала functools.reduce() применяет функцию к первому и второму элементам и возвращает результат, а затем применяет ее к результату и третьему элементу и так продолжается до тех пор, пока в списке не останется ни одного элемента.
При их комбинации map() применит заданную функцию к каждому элементу, а reduce() обеспечит последовательное применение функции.
Порядок элементов списка важен для reduce() и map(). Списки с одинаковыми элементами в разном порядке не считаются одинаковыми. При необходимости списки можно сначала отсортировать.
В следующем примере показано, как проверить списки на равенство с помощью функций reduce() и map():
import functools l1 = [10, 20, 30, 40, 50] l2 = [20, 30, 50, 40, 70] l3 = [10, 20, 30, 40, 50] if functools.reduce(lambda x, y : x and y, map(lambda p, q: p == q,l1,l2), True): print ("The lists l1 and l2 are the same") else: print ("The lists l1 and l2 are not the same") if functools.reduce(lambda x, y : x and y, map(lambda p, q: p == q,l1,l3), True): print ("The lists l1 and l3 are the same") else: print ("The lists l1 and l3 are not the same")
Получим следующий вывод:
The lists l1 and l2 are not the same The lists l1 and l3 are the same
В предыдущем примере код сравнивает l1 с l2, а затем сравнивает l1 с l3.
Сравнение списков с помощью функции set()
С помощью функции set() можно создать объекты set на основе заданных списков, а затем проверить эти наборы на равенство с помощью оператора ==.
Порядок элементов исходного списка не важен, поскольку оператор == возвращает true, если каждый набор содержит одинаковые элементы в любом порядке.
Примечание. Дублирующиеся элементы списка появляются в наборе только один раз.
Следующий пример демонстрирует, как создавать наборы из списков и сравнивать их:
l1 = [10, 20, 30, 40, 50] l2 = [50, 10, 30, 20, 40] a = set(l1) b = set(l2) if a == b: print("Lists l1 and l2 are equal") else: print("Lists l1 and l2 are not equal")
Lists l1 and l2 are equal Код в предыдущем примере создает наборы a и b из списков l1 и l2, затем сравнивает их и выводит результат.
Сравнение списков с помощью класса collections.Counter()
С помощью класса collections.Counter() можно сравнивать списки. Функция counter() подсчитывает частоту элементов в списке и сохраняет данные в виде словаря в формате value:frequency. Если два списка выдают два одинаковых словаря, можно сделать вывод, что списки одинаковы.
Порядок элементов исходного списка не важен при сравнении с помощью класса Counter.
Следующий пример демонстрирует, как создать объекты Counter из заданных списков и сравнить их:
import collections l1 = [10, 20, 30, 40, 50] l2 = [20, 30, 50, 40, 70] l3 = [50, 20, 30, 40, 10] if collections.Counter(l1) == collections.Counter(l2): print ("The lists l1 and l2 are the same") else: print ("The lists l1 and l2 are not the same") if collections.Counter(l1) == collections.Counter(l3): print ("The lists l1 and l3 are the same") else: print ("The lists l1 and l3 are not the same")
Вывод будет следующим:
The lists l1 and l2 are not the same The lists l1 and l3 are the same
Код в предыдущем примере создаст объекты Counter для списков l1 и l2, сравнит их и выведет результат. Код повторяется для списков l1 и l3.
Сравнение с помощью генератора списков
При сравнении списков с помощью генераторов порядок элементов исходного списка не важен.
Следующий пример показывает, как сравнить списки с помощью генератора:
l1 = [10, 20, 30, 40, 50] l2 = [50, 75, 30, 20, 40] l3 = [50, 20, 30, 40, 10] res = [x for x in l1 + l2 if x not in l1 or x not in l2] print(res) if not res: print("Lists l1 and l2 are equal") else: print("Lists l1 and l2 are not equal") res2 = [x for x in l1 + l3 if x not in l1 or x not in l3] print(res2) if not res2: print("Lists l1 and l3 are equal") else: print("Lists l1 and l3 are not equal")
Код в предыдущем примере устанавливает элемент-указатель x в списки l1 и l2, а затем проверяет, присутствует ли в списках элемент, на который указывает элемент-указатель. Если результат res — пустой список, то можно сделать вывод, что списки равны, поскольку нет элементов, которые присутствуют только в одном из списков.
Вывод будет следующим:
[10, 75] Lists l1 and l2 are not equal
Подводим итоги
В этом мануале мы разобрали несколько разных способов проверки списков на равенство в Python.