Как найти сравнить списки

A quick performance test showing Lutz’s solution is the best:

import time

def speed_test(func):
    def wrapper(*args, **kwargs):
        t1 = time.time()
        for x in xrange(5000):
            results = func(*args, **kwargs)
        t2 = time.time()
        print '%s took %0.3f ms' % (func.func_name, (t2-t1)*1000.0)
        return results
    return wrapper

@speed_test
def compare_bitwise(x, y):
    set_x = frozenset(x)
    set_y = frozenset(y)
    return set_x & set_y

@speed_test
def compare_listcomp(x, y):
    return [i for i, j in zip(x, y) if i == j]

@speed_test
def compare_intersect(x, y):
    return frozenset(x).intersection(y)

# Comparing short lists
a = [1, 2, 3, 4, 5]
b = [9, 8, 7, 6, 5]
compare_bitwise(a, b)
compare_listcomp(a, b)
compare_intersect(a, b)

# Comparing longer lists
import random
a = random.sample(xrange(100000), 10000)
b = random.sample(xrange(100000), 10000)
compare_bitwise(a, b)
compare_listcomp(a, b)
compare_intersect(a, b)

These are the results on my machine:

# Short list:
compare_bitwise took 10.145 ms
compare_listcomp took 11.157 ms
compare_intersect took 7.461 ms

# Long list:
compare_bitwise took 11203.709 ms
compare_listcomp took 17361.736 ms
compare_intersect took 6833.768 ms

Obviously, any artificial performance test should be taken with a grain of salt, but since the set().intersection() answer is at least as fast as the other solutions, and also the most readable, it should be the standard solution for this common problem.

Источник

Сравнение списков

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

*Результат выводится прямо в браузер. Огромные списки могут отправить его в нокаут.

Твитнуть

Поделиться

Плюсануть

Поделиться

Отправить

Линкануть

Вотсапнуть

Источник

Все таки Python динамичен и выразителен. Этого у него не отнять.

Там некоторые логические и арифметические операторы перегружены для множеств.

Вот Ваш однострочник:

result=list(set(Ans) & set(Word))

Это даст пересечение обоих списков:

['red', 'white']

Если нужен список уникальных элементов в объединении двух списков:

['red', 'white', 'green', 'blue']

result = list(set(Ans + Word))

Симметричная разность: 

['green','blue']

result=list(set(Ans) ^ set(Word))

Обычная разность(Множество из Ans не входящее в Word):

['green','blue']

result=list(set(Ans) - set(Word))

Вариант, сохраняющий порядок с меньшим количеством конверсий типов:

sbuf = set(Word)
result = [x for x in Ans if x in sbuf)]

Источник

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

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

Самый простой способ сравнения списков — это сравнение на равенство. Python позволяет сравнивать списки напрямую с помощью оператора ==.

list1 = [1, 2, 3]
list2 = [1, 2, 3]

if list1 == list2:
    print("Списки равны")
else:
    print("Списки не равны")

В этом случае, Python сравнит каждый элемент списка list1 с соответствующим элементом списка list2. Если все элементы равны, то списки считаются равными.

Сравнение списков на идентичность

Иногда важно узнать, являются ли два списка не просто равными, но и идентичными — то есть, являются ли они одним и тем же объектом. Для этого в Python есть оператор is.

list1 = [1, 2, 3]
list2 = list1  # list2 теперь ссылается на тот же объект, что и list1

if list1 is list2:
    print("Списки идентичны")
else:
    print("Списки не идентичны")

Сравнение списков по содержанию

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

list1 = [1, 2, 3]
list2 = [3, 2, 1]

if sorted(list1) == sorted(list2):
    print("Списки содержат одни и те же элементы")
else:
    print("Списки содержат разные элементы")

Сравнение списков по длине

Другой частый случай — сравнение списков по длине. Для этого в Python есть встроенная функция len().

list1 = [1, 2, 3]
list2 = [4, 5, 6, 7]

if len(list1) == len(list2):
    print("Списки имеют одинаковую длину")
else:
    print("Списки имеют разную длину")

Использование set для сравнения

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

list1 = [1, 2, 3, 3, 2, 1]
list2 = [1, 2, 3]

if set(list1) == set(list2):
    print("Списки содержат одни и те же уникальные элементы")
else:
    print("Списки содержат разные уникальные элементы")

Использование встроенной функции cmp()

В Python 2.x для сравнения списков можно было использовать функцию cmp(). Эта функция сравнивала списки поэлементно и возвращала -1, если первый список меньше второго, 0 — если списки равны, и 1 — если первый список больше второго. Однако в Python 3.x эта функция была удалена. Если вам нужно реализовать аналогичное поведение, вы можете воспользоваться функцией zip().

list1 = [1, 2, 3]
list2 = [1, 2, 4]

for a, b in zip(list1, list2):
    if a < b:
        print("Первый список меньше второго")
        break
    elif a > b:
        print("Первый список больше второго")
        break
else:
    if len(list1) < len(list2):
        print("Первый список меньше второго")
    elif len(list1) > len(list2):
        print("Первый список больше второго")
    else:
        print("Списки равны")

Заключение

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

Существуют и другие методы сравнения списков, например, с помощью библиотеки numpy или использованием циклов и условий, но основные принципы остаются теми же. Выбирайте тот метод, который наиболее подходит для вашей задачи, и помните, что Python — это инструмент, который должен помогать вам, а не усложнять работу.

Источник

3 февраля, 2023 11:42 дп
2 710 views
| Комментариев нет

Development, VPS

При программировании или изучении 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.

Сравнение с помощью генератора списков

Читайте также: Генераторы списков в Python 3

При сравнении списков с помощью генераторов порядок элементов исходного списка не важен.

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

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.

Tags: Python

Источник

Понравилась статья? Поделить с друзьями:
  • Как можно найти массу зная объем
  • Как найти владельца зем участка
  • Как найти объем краски
  • Как найти хорошего мастера по ремонту квартиры
  • Как найти свою мантру по дате рождения