Сравнить два списка python: Как сравнить два списка в Python?

Содержание

сравнение содержимого двух списков python [duplicate]

Лучший способ сделать это — сортировка списков и их сравнение. (Использование Counter не будет работать с объектами, которые не являются хешируемыми.) Это просто для целых чисел:

sorted(a) == sorted(b)

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

sorted(a, key=id) == sorted(b, key==id)

(In Python 2.x вам действительно не нужен параметр key=, потому что вы можете сравнивать любой объект с любым объектом. Порядок произвольный, но стабильный, поэтому он отлично подходит для этой цели, неважно, какой порядок объектов в том числе, что упорядочение одинаково для обоих списков. В Python 3, однако, сравнение объектов разных типов запрещено во многих случаях — например, вы не можете сравнивать строки с целыми числами, поэтому, если у вас будет объекты разных типов, лучше всего использовать идентификатор объекта.)

Если вы хотите сравнить объекты в списке по значению , , с другой стороны, сначала вам нужно определить, что означает «значение» для объектов. Тогда вам понадобится какой-то способ предоставить это как ключ (и для Python 3, как согласованный тип). Один из возможных способов работы для множества произвольных объектов — сортировка по их repr(). Конечно, это может тратить много лишнего времени и блоков памяти repr() для больших списков и т. Д.

sorted(a, key=repr) == sorted(b, key==repr)

Если объекты все ваши собственные типы, вы можете определить __lt__() на них, чтобы объект знал, как сравнивать себя с другими. Затем вы можете просто отсортировать их и не беспокоиться о параметре key=. Конечно, вы также можете определить __hash__() и использовать Counter, который будет быстрее.

Сравнение двух списков-Python — python

Хорошо, у меня есть два списка, Список 1 и Список 2. Я хочу найти все элементы, которые находятся как в списке 1, так и в списке 2, и удалить их из списка 1. Первый способ, которым я думал об этом, — это цикл по Списку 1, а затем цикл по Списку 2, чтобы увидеть, находится ли он в списке 2, но это кажется медленным и неэффективным при масштабировании. Есть ли более эффективный способ сделать это?

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

Я использую python,но мне также интересно с точки зрения общего программирования.

list1 = ['bar','foo','hello','hi']
list2 = ['alpha','bar','hello','xam']

list1 станет ['foo','hi']

python

list

Поделиться

Источник

Sam Creamer

07 февраля 2014 в 20:15

3 Ответа

В python, вы, вероятно, захотите использовать набор:

intersection = set(list1).intersection(list2)

Это вернет set , который разрушает Порядок (среди прочего), но вы всегда можете использовать этот набор для фильтрации list1 позже:

list1 = [x for x in list1 if x not in intersection]

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

set2 = set(list2)
list1 = [x for x in list1 if x not in set2]

Поделиться

mgilson

07 февраля 2014 в 20:16

Используйте set , чтобы получить разницу между ними:

list1 = ['bar','foo','hello','hi']
list2 = ['alpha','bar','hello','xam']

set1 = set(list1)
set2 = set(list2)
set1 - set2

Выходы:

set(['hi', 'foo'])

Как отмечает @chepner, с помощью set.difference, только первый должен быть преобразован в набор

set1.difference(list2)

Если порядок важен, сделайте один из них набором, а другой сравните с ним:

set2 = set(list2)
[x for x in list1 if x not in set2]

Выходы:

['foo', 'hi']

Поделиться

mhlester

07 февраля 2014 в 20:17

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

list1 = ['a', 'b', 'd', 'f', 'k']
list2 = ['c', 'd', 'i']
result = []

i1 = 0
i2 = 0
while i1 < len(list1) and i2 < len(list2):
    # invariants:
    #    list1[i1] not in list2[:i2], and
    #    result == (list1[:i1] with elements of list2[:i2] omitted)
    #
    if list1[i1] < list2[i2]:
        # By assumption, list1[i1] not in list2[:i2],
        # and because list2 is sorted, the true 'if' condition
        # implies that list1[i1] isn't in list2[i2:] either;
        # that is, it isn't in list2 at all.
        result.append(list1[i1])
        i1 += 1
    elif list1[i1] > list2[i2]:
        # can't decide membership of list1[i1] yet;
        # advance to next element of list2 and loop again
        i2 += 1
    else:
        # list1[i1] == list2[i2], so omit this element
        i1 += 1
        i2 += 1

# Add any remaining elements of list1 to tail of result
if i1 < len(list1):
    result.extend(list1[i1:])

print(result)

Результат:
['a', 'b', 'f', 'k']

Поделиться

BrianO

07 февраля 2014 в 21:36

Слияние списков на python. Сравнение скорости / Хабр

Пусть у нас есть два списка (для простоты из целых чисел), каждый из которых отсортирован. Хотим объединить их в один список, который тоже должен быть отсортирован. Эта задача наверняка всем знакома, используется, например, при сортировке слиянием.

Способов реализации (особенно на python) достаточно много. Давайте разберем некоторые из них и сравним затрачиваемое время на разных входных данных.

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

Входные данные не меняются

Пусть есть два списка list1 и list2.

Начнем с самого простого алгоритма: обозначим метки за i и j и будем брать меньший из list1[i], list2[j] и увеличивать его метку на единицу, пока одна из меток не выйдет за границу списка.

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

Перейдем к коду:

def simple_merge(list1, list2):
    i, j = 0, 0
    res = []
    while i < len(list1) and j < len(list2):
        if list1[i] < list2[j]:
            res.append(list1[i])
            i += 1
        else:
            res.append(list2[j])
            j += 1
    res += list1[i:]
    res += list2[j:] 
    # один из list1[i:] и list2[j:] будет уже пустой, поэтому добавится только нужный остаток
    return res

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

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

def iter_merge(list1, list2):
    result, it1, it2 = [], iter(list1), iter(list2)
    el1 = next(it1, None)
    el2 = next(it2, None)
    while el1 is not None or el2 is not None:
        if el1 is None or (el2 is not None and el2 < el1):
            result.append(el2)
            el2 = next(it2, None)
        else:
            result.append(el1)
            el1 = next(it1, None)
    return result

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

def gen_merge_inner(it1, it2):
    el1 = next(it1, None)
    el2 = next(it2, None)
    while el1 is not None or el2 is not None:
        if el1 is None or (el2 is not None and el2 < el1):
            yield el2
            el2 = next(it2, None)
        else:
            yield el1
            el1 = next(it1, None)

def gen_merge(list1, list2):
    return list(gen_merge_inner(iter(list1), iter(list2))) # из генератора получаем список

Встроенные реализации

Рассмотрим еще несколько способов слияния через встроенные в python функции.

merge из heapq. Как говорит документация, эта функция делает именно то, что мы хотим, и больше: объединяет несколько итерируемых объекта, можно задать ключ, можно сортировать в обратном порядке.
Тогда нам нужно просто импортировать и использовать:
```
from heapq import merge

def heapq_merge(list1, list2):
return list(merge(list1, list2)) # тоже возвращает генератор
```

Counter из collections. Counter умеет считать количество вхождений каждого из элементов, выдавать их в тех количествах, в которых они входят, и еще несколько полезных вещей, которые сейчас не нужны (например, несколько самых часто встречающихся элементов).
Воспользуемся gen_merge_inner для слияния элементов Counter(list1) и Counter(list2):
```
def counter_merge(list1, list2):
return list(gen_merge_inner(Counter(list1).elements(), Counter(list2).elements()))
```

И, наконец, просто сортировка. Объединяем и сортируем заново.
```
def sort_merge(list1, list2):
return sorted(list1 + list2)
```

Если можно менять исходные списки

Предположим, что после слияния старые списки больше не нужны (как обычно и случается). Тогда можно написать еще один способ. Будем как и раньше сравнивать нулевые элементы списков и вызывать pop(0) у списка с меньшим, пока один из списков не закончится.

def pop_merge(list1, list2):
    result = []
    while list1 and list2:
        result.append((list1 if list1[0] < list2[0] else list2).pop(0))
    return result + list1 + list2

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

def reverse_pop_merge(list1, list2):
    result = []
    while list1 and list2:
        result.append((list1 if list1[-1] > list2[-1] else list2).pop(-1))
    return (result + list1[-1::-1] + list2[-1::-1])[-1::-1]

Сравнение

Пора перейти к самому интересному.

Составим список функций, которые будем сравнивать:

simple_merge

iter_merge

gen_merge

heapq_merge

counter_merge

sort_merge

pop_merge

reverse_pop_merge

Будем измерять время работы с помощью модуля timeit. Код можно посмотреть здесь.

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

Тест первый

Проведем общий тест, размеры от до , элементы от до .

Отдельно сравним pop и reverse_pop:

pop_merge тратит колоссально больше времени в общем случае, как и ожидалось.

Не будем учитывать здесь огромный pop_merge, чтобы лучше видеть разницу между другими:

reverse_pop_merge показал себя относительно неплохо по сравнению с ручной реализацией и heapq_merge.

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

Тест второй, сравнимые размеры

Размеры будут принадлежать отрезку , а увеличиваем, начиная с . Шаг .

Как уже можно видеть pop_merge при небольшом размере списков еще ведет себя как heapq_merge, а дальше обгоняет всех.

Тест третий, один маленький, второй большой

Размер первого равен , размер второго .

В самом начале (на очень маленьких списках) reverse_pop_merge обгоняет всех, кроме sort_merge, но на чуть больших все выходит на стандартные позиции.

Тест четвертый, много повторных

Размеры фиксированы, а количество элементов увеличивается на , начиная с .

Как видно, на достаточно малых количествах counter_merge оказывается быстрее reverse_pop_merge и heapq_merge, но потом он отстает.

Итоги

Абсолютным победителем оказался sort_merge! Гораздо быстрее просто отсортировать список заново, чем использовать вроде бы линейные от длины списков функции.

На втором месте в подавляющем большинстве случаев идет gen_merge, за ним следует iter_merge.

Остальные методы используют еще больше времени, но некоторые в каких-то крайних случаях достигают результатов 2-3 мест.

P.S.

Код, тесты, jupyter notebook c графиками можно найти на gitlab.

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

Сравнения двух больших списков в Python

у меня есть один список, который содержит около 400 слов. И еще один список списков, в котором каждый список содержит около 150 000 слов. В этом списке 20 таких списков.

теперь я хочу посмотреть, сколько из этих 400 слов появляется во всех этих 150 000 слов списка. Я также хочу знать слово из этого 400 слов, сколько раз в списке 150k слов, какие из этих слов встречаются больше всего, сколько раз и т. д.

единственное решение, о котором я могу думать, — это решение полиномиального времени. Это очень плохое решение и будет ад много медленным:

for one_list in list_of_150kwords:
    for key in 400_words:
        for word in one_list:
            if key == word:
                # count this word
                # do other stuff

Это очень некрасивое и плохое решение, но я не могу придумать ничего лучшего. Я попробовал то же самое с NumPy, преобразовав эти списки в массивы NumPy:

list_of_150kwords = numpy.array(list_of_150kwords)
...

но я все еще нахожу его очень медленным. Есть другое решение? Или любая библиотека?

4 ответов

Это звучит как хорошая возможность для использования set:

set_of_150kwords = set(list_of_150kwords)
one_set = set(one_list)

len(one_set & set_of_150kwords) # set intersection is &
=> number of elements common to both sets

согласно теории множеств, пересечение двух множеств дает элементы, которые отображаются в и наборы, то это простой вопрос, принимая его длину. Для второй части (какое из этих слов встречается чаще всего, сколько раз и т. д.) Создать Counter С list_of_150kwords, который скажет вам, сколько раз каждое слово появляется в списке. И набор перекрестков скажет вам которые являются общими словами, решающими оба ваших требования.

автор: Óscar López

from collections import Counter

search_data = [
    ["list", "of", "150k", "words"],
    ["another", "list", "of", "150k", "words"],
    ["yet", "another", "list", "of", "150k", "words"]
    # ... 17 more of these
]

search_words = ["four", "hundred", "words", "to", "search", "for"]

def word_finder(words_to_find):
    lookfor = set(word.lower() for word in words_to_find)
    def get_word_count(text):
        return Counter(word for word in (wd.lower() for wd in text) if word in lookfor)
    return get_word_count

def get_words_in_common(counters):
    # Maybe use c.viewkeys() instead of set(c)? Which is faster?
    return reduce(operator.and_, (set(c) for c in counters))

def main():
    wordcount = word_finder(search_words)
    counters = [wordcount(wordlst) for wordlst in search_data]
    common_to_all = get_words_in_common(counters)
    print(common_to_all)

if __name__=="__main__":
    main()

автор: Hugh Bothwell

это канонический пример места, где Trie будет полезно. Вам нужно создать Trie для каждого из ваших списков 150K. Затем вы можете проверить, существует ли данное слово в списке в O (W) времени. где W-максимальная длина слова.

затем вы можете просмотреть список из 400 слов и проверить, находится ли каждая работа в списке слов 150K.

учитывая, что L т. е. количество списков 150K намного меньше 150K, а W намного меньше 150K никакое соединение набора никогда не будет так быстро, как сравнение Trie.

конечная сложность выполнения:

N = 400 //Size of small list
W = 10 // Max word Length
M = 150K // Max size of the 150K lists
P = 4 // Number of 150K lists

P * M // To construct Trie
N * P * W // To find each word in the 150k lists
MP + NPW // Total complexit

автор: Usman Ismail

В Python, как сравнить два списка и получить все индексы матчей?

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

list1 = ['AS144','401M','31TP01']

list2 = ['HDE342','114','M9553','AS144','AS144','401M']

затем я бы перебрал list1 по сравнению с list2 и вывел:
[0,0,0,1,1,0] , [3,4] или etc для первого итерация
[0,0,0,0,0,1] , [6] второй
и [0,0,0,0,0,0] или [] третий

изменить:
Извините за путаницу. Я хотел бы получить результаты таким образом, чтобы я мог использовать их следующим образом — у меня есть третий список, который позволяет вызвать list3, и я хотел бы получить значения из этого списка в индексах, которые выходят. т. е. list3[previousindexoutput]=list of cooresponding values

def findInstances(list1, list2):
    """For each item in list1,
    return a list of offsets to its occurences in list2
    """

    for i in list1:
        yield [pos for pos,j in enumerate(list2) if i==j]

list1 = ['AS144','401M','31TP01']
list2 = ['HDE342','114','M9553','AS144','AS144','401M']

res = list(findInstances(list1, list2))

результаты

[[3, 4], [5], []]

автор: Hugh Bothwell

Это должно делать то, что вы хотите, и его можно легко превратить в генератор:

>>> [[i for i in range(len(list2)) if item1 == list2[i]] for item1 in list1]
[[3, 4], [5], []]

вот версия с немного другой формат:

>>> [(i, j) for i in range(len(list1)) for j in range(len(list2)) if list1[i] == list2[j]]
[(0, 3), (0, 4), (1, 5)]

автор: Andrew Clark

Как сравнить элементы списка в Python — python

Здесь у меня есть два списка :

list1 = ['2C535EB58F19B58' , '7B89D9071EB531B143594FF909BAC846' , '0509']

list2 = ['1641AB0C9C5B8867' , '0098968C' , '509']

Мне нужно сравнить элементы внутри list2 с элементами list1.

Я хочу, чтобы результат был , после сравнения :

так как 509 присутствует в 0509.

Как я могу добиться таким образом ? Может ли regex помочь мне в этом ?

python

list

Поделиться

Источник

Ebin Davis

26 сентября 2018 в 07:29

5 Ответов

Попробовать это:
Здесь мы проверяем, является ли элемент в list2 подстрокой элемента в list1.

list1 = ['2C535EB58F19B58' , '7B89D9071EB531B143594FF909BAC846' , '0509']

list2 = ['1641AB0C9C5B8867' , '0098968C' , '509']

for i, j in zip(list1, list2):
    if j in i:
        print(j)

Один лайнер, который будет добавлять в список:

print( [j for i, j in zip(list1, list2) if j in i])

Могли бы быть более простые и лучшие ответы. Если это поможет,вы можете выбрать его.

Поделиться

PROTOCOL

26 сентября 2018 в 07:46

Вы можете сделать что-то вроде этого:

common_elements = []
for x in list1:
    for y in list2:
        if y in x:
            common_elements.append(y)

common_elements будет содержать необходимые элементы.

Поделиться

Rishabh Agrahari

26 сентября 2018 в 07:34

Как уже предлагалось BearBrown в комментарии, есть простой способ достичь своей цели. Нет никаких причин думать о регулярных выражениях вообще (оператор in-достаточно мощный).

[x for x in list2 if any(y for y in list1 if x in y)]

Здесь вы ищете каждую строку x в list2, если это подстрока любой строки y в list1 и, наконец, сохраните каждую соответствующую подстроку x в новом списке.

Поделиться

colidyre

26 сентября 2018 в 08:03

for x in list2:
    for y in list1:
        if x in y:
            print x #or whatever

вложенные for-loops, я думаю, что это простой способ, но я уверен, что есть лучший

Поделиться

Loois95

26 сентября 2018 в 08:25

-1

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

Самый простой способ решить вашу проблему будет

[y for y in list2 if any(y in x for x in list1)]

Поделиться

R3m

26 сентября 2018 в 07:34

Как сравнить два списка в Python

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

Сравнение — это метод проверки элементов данных списка на предмет равенства с элементы данных другого списка.

Методы сравнения двух списков в Python

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

Функции reduce () и map ()
Коллекция.Функция counter ()
Функция Python sort () вместе с оператором ==
Функция Python set () вместе с оператором ==
Функция difference ()

1. Python reduce () и функции map ()

Мы можем использовать функцию Python 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]

если functools.reduce (лямбда x, y: x и y, map (lambda p, q: p == q, l1, l2), True):
    print ("Списки l1 и l2 одинаковы")
еще:
    print ("Списки l1 и l2 не совпадают")

если functools.reduce (lambda x, y: x and y, map (lambda p, q: p == q, l1, l3), True):
    print ("Списки l1 и l3 одинаковы")
еще:
    print ("Списки l1 и l3 не совпадают")

Выход:

Списки l1 и l2 не совпадают
Списки l1 и l3 совпадают

2. Метод Python collection.counter ()

Метод collection.counter () можно использовать для эффективного сравнения списков. Функция counter () подсчитывает частоту элементов в списке и сохраняет данные в виде словаря в формате <значение>: <частота> .

Если два списка имеют одинаковые выходные данные словаря, мы можем сделать вывод, что списки совпадают.

Примечание: Порядок в списке не влияет на метод counter ().

Пример:

импортные коллекции


l1 = [10, 20, 30, 40, 50]
l2 = [10, 20, 30, 50, 40, 70]
l3 = [10, 20, 30, 40, 50]

если collections.Counter (l1) == collections.Counter (l2):
    print ("Списки l1 и l2 одинаковы")
еще:
    print ("Списки l1 и l2 не совпадают")

если коллекции.Счетчик (l1) == сборники. Счетчик (l3):
    print ("Списки l1 и l3 одинаковы")
еще:
    print ("Списки l1 и l3 не совпадают")

Выход:

Списки l1 и l2 не совпадают
Списки l1 и l3 совпадают

3. Метод Python sort () и оператор == для сравнения списков

Мы можем объединить метод sort () Python с оператором == для сравнения двух списков.

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

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

Далее, оператор == используется для сравнения списка элемент за элементом.

Пример:

импортные коллекции


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

если l1 == l3:
    print ("Списки l1 и l3 одинаковы")
еще:
    print ("Списки l1 и l3 не совпадают")


если l1 == l2:
    print ("Списки l1 и l2 одинаковы")
еще:
    print ("Списки l1 и l2 не совпадают")

Выход:

Списки l1 и l3 совпадают
Списки l1 и l2 не совпадают

4.Метод Python set () и оператор == для сравнения двух списков

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

Далее, оператор == используется для поэлементного сравнения элементов данных списка.

Пример:

l1 = [10, 20, 30, 40, 50]
l3 = [50, 10, 30, 20, 40]

а = набор (l1)
b = установить (l3)

если a == b:
    print («Списки l1 и l3 равны»)
еще:
    print («Списки l1 и l3 не равны»)

Выход:

Списки l1 и l3 равны

5.Пользовательское понимание списка Python для сравнения двух списков

Мы можем использовать понимание списка Python для сравнения двух списков.

Пример:

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]

печать (разрешение)
если не res:
    print («Списки l1 и l3 равны»)
еще:
    print («Списки l1 и l3 не равны»)

В приведенном выше коде мы устанавливаем элемент указателя «x» на список l1 и l3. Далее мы проверяем, присутствует ли в списках элемент, на который указывает элемент-указатель.

Выход:

[10, 75, 69]
Списки l1 и l3 не равны

Заключение

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

сравнить два списка в python и распечатать разницу

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

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

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

python — как сравнить два списка с разным порядком?

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

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

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

Загрузка…

About Me

Dashy

Сравнить два списка python: Как сравнить два списка в Python?

сравнение содержимого двух списков python [duplicate]

Сравнение двух списков-Python — python

3 Ответа

Похожие вопросы:

Слияние списков на python. Сравнение скорости / Хабр

Входные данные не меняются

Встроенные реализации

Если можно менять исходные списки

Сравнение

Тест первый

Тест второй, сравнимые размеры

Тест третий, один маленький, второй большой

Тест четвертый, много повторных

Итоги

P.S.

Сравнения двух больших списков в Python

4 ответов

В Python, как сравнить два списка и получить все индексы матчей?

Как сравнить элементы списка в Python — python

5 Ответов

Похожие вопросы:

Как сравнить два списка в Python

Методы сравнения двух списков в Python

1. Python reduce () и функции map ()

2. Метод Python collection.counter ()

3. Метод Python sort () и оператор == для сравнения списков

4.Метод Python set () и оператор == для сравнения двух списков

5.Пользовательское понимание списка Python для сравнения двух списков

Заключение

сравнить два списка в python и распечатать разницу

python — как сравнить два списка с разным порядком?

Добавить комментарий Отменить ответ

Апрель 2024
Пн	Вт	Ср	Чт	Пт	Сб	Вс
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30