Получить разницу между двумя списками


812

У меня есть два списка в Python, как эти:

temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two']

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

temp3 = ['Three', 'Four']

Есть ли быстрые способы без циклов и проверки?


14
Элементы гарантированы уникальны? Если у вас есть, temp1 = ['One', 'One', 'One']и temp2 = ['One']вы хотите ['One', 'One']вернуться, или []?
Майкл Мрозек

@ Майкл-Мрозек они уникальны.
Макс Фрай

12
Вы хотите сохранить порядок элементов?
Марк Байерс

Ответы:


1211
In [5]: list(set(temp1) - set(temp2))
Out[5]: ['Four', 'Three']

Остерегайтесь этого

In [5]: set([1, 2]) - set([2, 3])
Out[5]: set([1]) 

где вы могли бы ожидать / хотите, чтобы оно равнялось set([1, 3]). Если вы хотите в set([1, 3])качестве ответа, вам нужно использовать set([1, 2]).symmetric_difference(set([2, 3])).


27
@Drewdin: списки не поддерживают операнд "-". Наборы, однако, делают и то, что продемонстрировано выше, если присмотреться.
Кузнец

1
спасибо, я закончил тем, что использовал set (ListA) .symmetric_difference (ListB)
Drewdin

43
Симметричная разница может быть записана с помощью: ^ (set1 ^ set2)
Бастиан

10
Пожалуйста, не могли бы вы отредактировать свой ответ и указать, что он возвращает только temp1-temp2? .. Как сказал другой, чтобы вернуть все различия, вы должны использовать системную разницу: список (set (temp1) ^ set (temp2))
rkachach

Почему я получаю, TypeError: 'str' object is not callableкогда я выполняю эту операцию a = [1,2,2,2,3]иb = [2]
d8aninja

478

Все существующие решения предлагают одно или другое из:

  • Быстрее чем O (n * m) производительность.
  • Сохранить порядок ввода списка.

Но до сих пор ни одно решение не имеет обоих. Если вы хотите оба, попробуйте это:

s = set(temp2)
temp3 = [x for x in temp1 if x not in s]

Тест производительности

import timeit
init = 'temp1 = list(range(100)); temp2 = [i * 2 for i in range(50)]'
print timeit.timeit('list(set(temp1) - set(temp2))', init, number = 100000)
print timeit.timeit('s = set(temp2);[x for x in temp1 if x not in s]', init, number = 100000)
print timeit.timeit('[item for item in temp1 if item not in temp2]', init, number = 100000)

Результаты:

4.34620224079 # ars' answer
4.2770634955  # This answer
30.7715615392 # matt b's answer

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

init = '''
temp1 = [str(i) for i in range(100000)]
temp2 = [str(i * 2) for i in range(50)]
'''

Результаты:

11.3836875916 # ars' answer
3.63890368748 # this answer (3 times faster!)
37.7445402279 # matt b's answer

2
Дополнительная поддержка для этого ответа: наткнулся на случай использования, где сохранение порядка списка было важно для производительности. При работе с объектами tarinfo или zipinfo я использовал set вычитание. Для исключения определенных объектов tarinfo из архива. Создание нового списка было быстрым, но очень медленным во время извлечения. Сначала причина уклонилась от меня. Оказывается, переупорядочивание списка объектов tarinfo привело к огромному снижению производительности. Переключение на метод понимания списка спасло день.
Рэй Томпсон

@MarkByers - возможно, мне следует написать совершенно новый вопрос для этого. Но как это будет работать в замкнутом круге? Например, если мои temp1 и temp2 продолжают меняться .. и я хочу добавить новую информацию в temp3?
Ason

@MarkByers - звучит хорошо. Я продолжу думать об этом немного. но +1 за отличное решение.
Ason

Я согласен с @Dejel >>> temp1 = ['One', 'Two', 'Three', 'Four'] >>> temp2 = ['One', 'Two', 'Six'] >>> s = set (temp2) >>> temp3 = [x для x в temp1, если x не в s] >>> temp3 ['Three', 'Four']
earlonrails

3
@haccks Поскольку проверка членства в списке является операцией O (n) (повторяется по всему списку), но проверка принадлежности набора является O (1).
Марк Байерс

86
temp3 = [item for item in temp1 if item not in temp2]

15
Превращение temp2в набор раньше сделало бы это немного более эффективным.
lunaryorn

3
Правда, зависит, заботится ли Ockonal о дубликатах или нет (оригинальный вопрос не говорит)
Мэтт

2
Комментарий говорит, что (списки | кортежи) не имеют дубликатов.

1
Я проголосовал за ваш ответ, потому что сначала думал, что вы правы насчет дубликатов. Но item not in temp2и item not in set(temp2)всегда будет возвращать одинаковые результаты, независимо от того, есть ли дубликаты или нет temp2.
Ареколек

5
Голосуйте за то, чтобы не требовать, чтобы элементы списка были хэшируемыми.
Брент

23

Разницу между двумя списками (скажем, list1 и list2) можно найти с помощью следующей простой функции.

def diff(list1, list2):
    c = set(list1).union(set(list2))  # or c = set(list1) | set(list2)
    d = set(list1).intersection(set(list2))  # or d = set(list1) & set(list2)
    return list(c - d)

или

def diff(list1, list2):
    return list(set(list1).symmetric_difference(set(list2)))  # or return list(set(list1) ^ set(list2))

Используя вышеуказанную функцию, разницу можно найти с помощью diff(temp2, temp1)или diff(temp1, temp2). Оба дадут результат ['Four', 'Three']. Вам не нужно беспокоиться о порядке списка или о том, какой список нужно дать первым.

Ссылка на документ Python


7
Почему бы не установить (list1) .symmetric_difference (set (list2))?
swietyy

20

Если вы хотите рекурсивное различие, я написал пакет для Python: https://github.com/seperman/deepdiff

Установка

Установить из PyPi:

pip install deepdiff

Пример использования

Импорт

>>> from deepdiff import DeepDiff
>>> from pprint import pprint
>>> from __future__ import print_function # In case running on Python 2

Тот же объект возвращает пустой

>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = t1
>>> print(DeepDiff(t1, t2))
{}

Тип предмета изменился

>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = {1:1, 2:"2", 3:3}
>>> pprint(DeepDiff(t1, t2), indent=2)
{ 'type_changes': { 'root[2]': { 'newtype': <class 'str'>,
                                 'newvalue': '2',
                                 'oldtype': <class 'int'>,
                                 'oldvalue': 2}}}

Стоимость предмета изменилась

>>> t1 = {1:1, 2:2, 3:3}
>>> t2 = {1:1, 2:4, 3:3}
>>> pprint(DeepDiff(t1, t2), indent=2)
{'values_changed': {'root[2]': {'newvalue': 4, 'oldvalue': 2}}}

Товар добавлен и / или удален

>>> t1 = {1:1, 2:2, 3:3, 4:4}
>>> t2 = {1:1, 2:4, 3:3, 5:5, 6:6}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff)
{'dic_item_added': ['root[5]', 'root[6]'],
 'dic_item_removed': ['root[4]'],
 'values_changed': {'root[2]': {'newvalue': 4, 'oldvalue': 2}}}

Разница строк

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world"}}
>>> t2 = {1:1, 2:4, 3:3, 4:{"a":"hello", "b":"world!"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'values_changed': { 'root[2]': {'newvalue': 4, 'oldvalue': 2},
                      "root[4]['b']": { 'newvalue': 'world!',
                                        'oldvalue': 'world'}}}

Разница строк 2

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world!\nGoodbye!\n1\n2\nEnd"}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world\n1\n2\nEnd"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'values_changed': { "root[4]['b']": { 'diff': '--- \n'
                                                '+++ \n'
                                                '@@ -1,5 +1,4 @@\n'
                                                '-world!\n'
                                                '-Goodbye!\n'
                                                '+world\n'
                                                ' 1\n'
                                                ' 2\n'
                                                ' End',
                                        'newvalue': 'world\n1\n2\nEnd',
                                        'oldvalue': 'world!\n'
                                                    'Goodbye!\n'
                                                    '1\n'
                                                    '2\n'
                                                    'End'}}}

>>> 
>>> print (ddiff['values_changed']["root[4]['b']"]["diff"])
--- 
+++ 
@@ -1,5 +1,4 @@
-world!
-Goodbye!
+world
 1
 2
 End

Изменение типа

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":"world\n\n\nEnd"}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'type_changes': { "root[4]['b']": { 'newtype': <class 'str'>,
                                      'newvalue': 'world\n\n\nEnd',
                                      'oldtype': <class 'list'>,
                                      'oldvalue': [1, 2, 3]}}}

Разница в списке

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3, 4]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{'iterable_item_removed': {"root[4]['b'][2]": 3, "root[4]['b'][3]": 4}}

Разница в списке 2:

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'iterable_item_added': {"root[4]['b'][3]": 3},
  'values_changed': { "root[4]['b'][1]": {'newvalue': 3, 'oldvalue': 2},
                      "root[4]['b'][2]": {'newvalue': 2, 'oldvalue': 3}}}

Разница в списке, игнорирующая порядок или дубликаты: (с теми же словарями, что и выше)

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
>>> ddiff = DeepDiff(t1, t2, ignore_order=True)
>>> print (ddiff)
{}

Список, содержащий словарь:

>>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, {1:1, 2:2}]}}
>>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, {1:3}]}}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (ddiff, indent = 2)
{ 'dic_item_removed': ["root[4]['b'][2][2]"],
  'values_changed': {"root[4]['b'][2][1]": {'newvalue': 3, 'oldvalue': 1}}}

Наборы:

>>> t1 = {1, 2, 8}
>>> t2 = {1, 2, 3, 5}
>>> ddiff = DeepDiff(t1, t2)
>>> pprint (DeepDiff(t1, t2))
{'set_item_added': ['root[3]', 'root[5]'], 'set_item_removed': ['root[8]']}

Именованные кортежи:

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> t1 = Point(x=11, y=22)
>>> t2 = Point(x=11, y=23)
>>> pprint (DeepDiff(t1, t2))
{'values_changed': {'root.y': {'newvalue': 23, 'oldvalue': 22}}}

Пользовательские объекты:

>>> class ClassA(object):
...     a = 1
...     def __init__(self, b):
...         self.b = b
... 
>>> t1 = ClassA(1)
>>> t2 = ClassA(2)
>>> 
>>> pprint(DeepDiff(t1, t2))
{'values_changed': {'root.b': {'newvalue': 2, 'oldvalue': 1}}}

Добавлен атрибут объекта:

>>> t2.c = "new attribute"
>>> pprint(DeepDiff(t1, t2))
{'attribute_added': ['root.c'],
 'values_changed': {'root.b': {'newvalue': 2, 'oldvalue': 1}}}

20

Может быть сделано с помощью оператора XOR python.

  • Это удалит дубликаты в каждом списке
  • Это покажет отличие temp1 от temp2 и temp2 от temp1.

set(temp1) ^ set(temp2)

работает, но почему?
ЗакС

лучший ответ!
Артем Праневский

какой ответ! так питонно !!!! удивительно
toing_toing

18

самый простой способ,

используйте set (). разность (set ())

list_a = [1,2,3]
list_b = [2,3]
print set(list_a).difference(set(list_b))

ответ set([1])

можно распечатать в виде списка,

print list(set(list_a).difference(set(list_b)))

14

Если вы действительно смотрите на производительность, используйте numpy!

Вот полная тетрадь в виде github со сравнением между list, numpy и pandas.

https://gist.github.com/denfromufa/2821ff59b02e9482be15d27f2bbd4451

введите описание изображения здесь


я обновил блокнот по ссылке, а также на скриншоте. Удивительно, но pandas медленнее, чем numpy даже при внутреннем переключении на хеш-таблицу. Частично это может быть связано с обновлением до int64.
Денфромуфа

13

я добавлю, так как ни одно из настоящих решений не дает кортеж:

temp3 = tuple(set(temp1) - set(temp2))

альтернативно:

#edited using @Mark Byers idea. If you accept this one as answer, just accept his instead.
temp3 = tuple(x for x in temp1 if x not in set(temp2))

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


11

Я хотел что бы принять два списка и может делать то , что diffв bashделает. Так как этот вопрос всплывает первым при поиске «python diff два списка» и не очень конкретен, я опубликую то, что придумал.

Используя SequenceMatherfrom difflibвы можете сравнить два списка, как это diffделает. Ни один из других ответов не скажет вам положение, в котором происходит различие, но этот ответ делает. Некоторые ответы дают разницу только в одном направлении. Некоторые переупорядочивают элементы. Некоторые не обрабатывают дубликаты. Но это решение дает вам истинную разницу между двумя списками:

a = 'A quick fox jumps the lazy dog'.split()
b = 'A quick brown mouse jumps over the dog'.split()

from difflib import SequenceMatcher

for tag, i, j, k, l in SequenceMatcher(None, a, b).get_opcodes():
  if tag == 'equal': print('both have', a[i:j])
  if tag in ('delete', 'replace'): print('  1st has', a[i:j])
  if tag in ('insert', 'replace'): print('  2nd has', b[k:l])

Это выводит:

both have ['A', 'quick']
  1st has ['fox']
  2nd has ['brown', 'mouse']
both have ['jumps']
  2nd has ['over']
both have ['the']
  1st has ['lazy']
both have ['dog']

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

Например, ни один из других ответов не может обработать:

a = [1,2,3,4,5]
b = [5,4,3,2,1]

Но этот делает:

  2nd has [5, 4, 3, 2]
both have [1]
  1st has [2, 3, 4, 5]


10

это может быть даже быстрее, чем понимание списка Марка:

list(itertools.filterfalse(set(temp2).__contains__, temp1))

7
Могу включить from itertools import filterfalseсюда немного. Также обратите внимание, что это не возвращает последовательность, как другие, это возвращает итератор.
Мэтт Луонго

7

Вот Counterответ для простейшего случая.

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

from collections import Counter

lst1 = ['One', 'Two', 'Three', 'Four']
lst2 = ['One', 'Two']

c1 = Counter(lst1)
c2 = Counter(lst2)
diff = list((c1 - c2).elements())

В качестве альтернативы, в зависимости от ваших предпочтений читабельности, это делает для достойной однострочной:

diff = list((Counter(lst1) - Counter(lst2)).elements())

Вывод:

['Three', 'Four']

Обратите внимание, что вы можете удалить list(...)вызов, если вы просто перебираете его.

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

lst1 = ['One', 'Two', 'Two', 'Two', 'Three', 'Three', 'Four']
lst2 = ['One', 'Two']

Выход:

['Two', 'Two', 'Three', 'Three', 'Four']

5

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

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

print list1[len(list2):]

или с собственными методами набора:

subset=set(list1).difference(list2)

print subset

import timeit
init = 'temp1 = list(range(100)); temp2 = [i * 2 for i in range(50)]'
print "Naive solution: ", timeit.timeit('temp1[len(temp2):]', init, number = 100000)
print "Native set solution: ", timeit.timeit('set(temp1).difference(temp2)', init, number = 100000)

Наивное решение: 0.0787101593292

Решение для собственного набора: 0.998837615564


5

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

list(set(x).symmetric_difference(set(y)))
list(set(x) ^ set(y))

Я прошу прощения за элементарный уровень кодирования.

import time
import random
from itertools import filterfalse

# 1 - performance (time taken)
# 2 - correctness (answer - 1,4,5,6)
# set performance
performance = 1
numberoftests = 7

def answer(x,y,z):
    if z == 0:
        start = time.clock()
        lists = (str(list(set(x)-set(y))+list(set(y)-set(y))))
        times = ("1 = " + str(time.clock() - start))
        return (lists,times)

    elif z == 1:
        start = time.clock()
        lists = (str(list(set(x).symmetric_difference(set(y)))))
        times = ("2 = " + str(time.clock() - start))
        return (lists,times)

    elif z == 2:
        start = time.clock()
        lists = (str(list(set(x) ^ set(y))))
        times = ("3 = " + str(time.clock() - start))
        return (lists,times)

    elif z == 3:
        start = time.clock()
        lists = (filterfalse(set(y).__contains__, x))
        times = ("4 = " + str(time.clock() - start))
        return (lists,times)

    elif z == 4:
        start = time.clock()
        lists = (tuple(set(x) - set(y)))
        times = ("5 = " + str(time.clock() - start))
        return (lists,times)

    elif z == 5:
        start = time.clock()
        lists = ([tt for tt in x if tt not in y])
        times = ("6 = " + str(time.clock() - start))
        return (lists,times)

    else:    
        start = time.clock()
        Xarray = [iDa for iDa in x if iDa not in y]
        Yarray = [iDb for iDb in y if iDb not in x]
        lists = (str(Xarray + Yarray))
        times = ("7 = " + str(time.clock() - start))
        return (lists,times)

n = numberoftests

if performance == 2:
    a = [1,2,3,4,5]
    b = [3,2,6]
    for c in range(0,n):
        d = answer(a,b,c)
        print(d[0])

elif performance == 1:
    for tests in range(0,10):
        print("Test Number" + str(tests + 1))
        a = random.sample(range(1, 900000), 9999)
        b = random.sample(range(1, 900000), 9999)
        for c in range(0,n):
            #if c not in (1,4,5,6):
            d = answer(a,b,c)
            print(d[1])

5

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

Код

Необычный подход с использованием pathlib:

import pathlib


temp1 = ["One", "Two", "Three", "Four"]
temp2 = ["One", "Two"]

p = pathlib.Path(*temp1)
r = p.relative_to(*temp2)
list(r.parts)
# ['Three', 'Four']

Это предполагает, что оба списка содержат строки с эквивалентными началами. Смотрите документы для более подробной информации. Обратите внимание, что это не особенно быстро по сравнению с операциями над множествами.


Простая реализация с использованием itertools.zip_longest:

import itertools as it


[x for x, y in it.zip_longest(temp1, temp2) if x != y]
# ['Three', 'Four']

1
Решение itertools работает только тогда , когда элементы temp1и temp2линии хорошо. Если вы, например, перевернете элементы в temp2или вставите какое-то другое значение в начало temp2, listcomp просто вернет те же элементы, что и вtemp1
KenHBS

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

4

Это еще одно решение:

def diff(a, b):
    xa = [i for i in set(a) if i not in b]
    xb = [i for i in set(b) if i not in a]
    return xa + xb


4

Допустим, у нас есть два списка

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

Из приведенных выше двух списков видно, что пункты 1, 3, 5 существуют в списке list2, а пункты 7, 9 - нет. С другой стороны, пункты 1, 3, 5 существуют в списке 1, а пункты 2, 4 - нет.

Как лучше всего вернуть новый список, содержащий пункты 7, 9 и 2, 4?

Все ответы, приведенные выше, находят решение, а теперь самое оптимальное?

def difference(list1, list2):
    new_list = []
    for i in list1:
        if i not in list2:
            new_list.append(i)

    for j in list2:
        if j not in list1:
            new_list.append(j)
    return new_list

против

def sym_diff(list1, list2):
    return list(set(list1).symmetric_difference(set(list2)))

Используя время, мы можем увидеть результаты

t1 = timeit.Timer("difference(list1, list2)", "from __main__ import difference, 
list1, list2")
t2 = timeit.Timer("sym_diff(list1, list2)", "from __main__ import sym_diff, 
list1, list2")

print('Using two for loops', t1.timeit(number=100000), 'Milliseconds')
print('Using two for loops', t2.timeit(number=100000), 'Milliseconds')

возвращается

[7, 9, 2, 4]
Using two for loops 0.11572412995155901 Milliseconds
Using symmetric_difference 0.11285737506113946 Milliseconds

Process finished with exit code 0


3

если вы хотите что-то более похожее на набор изменений ... может использовать счетчик

from collections import Counter

def diff(a, b):
  """ more verbose than needs to be, for clarity """
  ca, cb = Counter(a), Counter(b)
  to_add = cb - ca
  to_remove = ca - cb
  changes = Counter(to_add)
  changes.subtract(to_remove)
  return changes

lista = ['one', 'three', 'four', 'four', 'one']
listb = ['one', 'two', 'three']

In [127]: diff(lista, listb)
Out[127]: Counter({'two': 1, 'one': -1, 'four': -2})
# in order to go from lista to list b, you need to add a "two", remove a "one", and remove two "four"s

In [128]: diff(listb, lista)
Out[128]: Counter({'four': 2, 'one': 1, 'two': -1})
# in order to go from listb to lista, you must add two "four"s, add a "one", and remove a "two"

2

Мы можем вычислить пересечение минус объединение списков:

temp1 = ['One', 'Two', 'Three', 'Four']
temp2 = ['One', 'Two', 'Five']

set(temp1+temp2)-(set(temp1)&set(temp2))

Out: set(['Four', 'Five', 'Three']) 

2

Это можно решить одной строкой. Вопрос задается двумя списками (temp1 и temp2), возвращающими их разницу в третьем списке (temp3).

temp3 = list(set(temp1).difference(set(temp2)))

1

Вот простой способ различить два списка (независимо от содержимого), вы можете получить результат, как показано ниже:

>>> from sets import Set
>>>
>>> l1 = ['xvda', False, 'xvdbb', 12, 'xvdbc']
>>> l2 = ['xvda', 'xvdbb', 'xvdbc', 'xvdbd', None]
>>>
>>> Set(l1).symmetric_difference(Set(l2))
Set([False, 'xvdbd', None, 12])

Надеюсь, это будет полезно.


0

Я предпочитаю использовать преобразование в наборы, а затем использовать функцию "разности ()". Полный код:

temp1 = ['One', 'Two', 'Three', 'Four'  ]                   
temp2 = ['One', 'Two']
set1 = set(temp1)
set2 = set(temp2)
set3 = set1.difference(set2)
temp3 = list(set3)
print(temp3)

Вывод:

>>>print(temp3)
['Three', 'Four']

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


-1
(list(set(a)-set(b))+list(set(b)-set(a)))

3
В дополнение к предоставлению ответа, можете ли вы дать объяснение того, как это работает / относится к этой конкретной проблеме? Ответы и решения хороши, но подробные руководства и объяснения бесконечно лучше.
Busse

-1
def diffList(list1, list2):     # returns the difference between two lists.
    if len(list1) > len(list2):
        return (list(set(list1) - set(list2)))
    else:
        return (list(set(list2) - set(list1)))

например, если list1 = [10, 15, 20, 25, 30, 35, 40]и list2 = [25, 40, 35]тогда возвращенный список будетoutput = [10, 20, 30, 15]


Вы не можете сделать это для разницы операций. Даже в случае целых чисел, если вы приказываете функции выполнять «a - b», она должна вычитать «b» только из «a», независимо от того, больше ли «b», чем «a», или иначе. Похожий случай со списком и множествами. A - B и B - A оба могут быть допустимыми операциями независимо от длины A и B, вам просто нужно исключить содержимое B из A для выполнения A - B.
Абу Талха Датский
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.