Эквивалент команды Setdiff R в Python [дубликат]

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

exec('my command', $output, $return);

547
задан denfromufa 29 April 2017 в 13:12
поделиться

25 ответов

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])).

804
ответ дан cvipul 17 August 2018 в 08:56
поделиться
  • 1
    я не знал, что вы могли бы вычесть такие списки – Drewdin 8 October 2014 в 01:50
  • 2
    @Drewdin: списки не поддерживают & quot; - & quot; операнд. Наборы, однако, делают, и то, что показано выше, если вы внимательно присмотритесь. – Godsmith 14 October 2014 в 22:21
  • 3
    спасибо, я закончил использование set (ListA) .symmetric_difference (ListB) – Drewdin 15 October 2014 в 13:07
  • 4
    симметричная разность может быть записана с помощью: ^ (set1 ^ set2) – Bastian 1 October 2015 в 18:18
  • 5
    Не могли бы вы отредактировать свой ответ и указать, что это возвращает temp1-temp2? .. Как и другие, для того, чтобы вернуть все различия, вам нужно использовать системную разницу: list (set (temp1) ^ set (temp2)) – rkachach 16 February 2016 в 17:00

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

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

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

12
ответ дан aaronasterling 17 August 2018 в 08:56
поделиться

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

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])
3
ответ дан Alex Jacob 17 August 2018 в 08:56
поделиться

Мне нужно что-то, что займет два списка и может сделать то, что diff в bash. Поскольку этот вопрос появляется сначала, когда вы ищете «python diff two lists» и не очень специфичен, я опубликую то, что я придумал.

Используя SequenceMather из 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]
7
ответ дан arekolek 17 August 2018 в 08:56
поделиться

Различие между двумя списками (например, 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 doc

15
ответ дан arulmr 17 August 2018 в 08:56
поделиться
  • 1
    Почему бы не установить (list1) .symmetric_difference (set (list2))? – swietyy 4 March 2015 в 17:49

Если вы столкнулись с TypeError: unhashable type: 'list', вам нужно повернуть списки или наборы в кортежи, например

set(map(tuple, list_of_lists1)).symmetric_difference(set(map(tuple, list_of_lists2)))

См. также . Как сравнить список списков / наборов в python?

4
ответ дан Community 17 August 2018 в 08:56
поделиться

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

Вот полный блокнот как сущность на github со сравнением между списком, numpy и pandas.

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

14
ответ дан denfromufa 17 August 2018 в 08:56
поделиться
  • 1
    Это заслуживает лучшего ответа! Браво! Сэкономил мне сотни часов! – whyisyoung 5 March 2017 в 07:45
  • 2
    За 1 млн. элементы панды могут быть еще быстрее! – denfromufa 5 March 2017 в 15:50
  • 3
    Существует разница в выходе обоих подходов. В идеале они должны были возвращать одни и те же выходные наборы. np показывает длину 28571, а метод подсчета списка показывает длину как 9524. – ghosts 28 April 2017 в 01:13
  • 4
    @ghosts, что отличная добыча! Я исправил свой ответ – denfromufa 28 April 2017 в 21:27
  • 5
    Я обновил ноутбук по ссылке, а также скриншот. Удивительно панды медленнее, чем numpy даже при переключении на hashtable внутри. Отчасти это может быть связано с повышением до Int64. – denfromufa 29 April 2017 в 07:06

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

temp3 = list(set(temp1).difference(set(temp2)))
2
ответ дан fgaim 17 August 2018 в 08:56
поделиться

Попробуйте следующее:

temp3 = set(temp1) - set(temp2)
8
ответ дан Maciej Kucharz 17 August 2018 в 08:56
поделиться

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

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
3
ответ дан manhgd 17 August 2018 в 08:56
поделиться

Существующие решения предлагают либо одну, либо другую:

  • Быстрее, чем 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
388
ответ дан Mark Byers 17 August 2018 в 08:56
поделиться
  • 1
    Дополнительная поддержка этого ответа: Пробег в прецеденте, где сохранение порядка списка было важно для производительности. При работе с объектами tarinfo или zipinfo я использовал функцию set subtraction. Чтобы исключить из архива некоторые объекты tarinfo. Создание нового списка было быстрым, но очень медленным во время извлечения. Сначала причина уклонилась от меня. Оказывается, переупорядочение списка объектов tarinfo вызвало огромный штраф за производительность. Переключение на метод распознавания списка сохранил день. – Ray Thompson 13 December 2011 в 02:26
  • 2
    @MarkByers - возможно, я должен написать совершенно новый вопрос для этого. Но как это будет работать в ловушке? Например, если мои temp1 и temp2 продолжают меняться .. и я хочу добавить новую информацию в temp3? – Ason 9 August 2012 в 18:57
  • 3
    @Ason: Я думаю, вы должны создать новый вопрос. Вам нужно сделать вопрос более ясным. – Mark Byers 9 August 2012 в 19:18
  • 4
    он не будет работать, если в списке2 больше элементов, чем в списке1 – Dejell 5 December 2013 в 16:39
  • 5
    @haccks Поскольку проверка членства в списке - это операция O (n) (итерация по всему списку), но проверка принадлежности к набору - O (1). – Mark Byers 5 November 2015 в 17:57
temp3 = [item for item in temp1 if item not in temp2]
49
ответ дан matt b 17 August 2018 в 08:56
поделиться
  • 1
    Превращение temp2 в набор раньше сделало бы это немного более эффективным. – lunaryorn 11 August 2010 в 20:47
  • 2
    Правда, зависит, если Ockonal заботится о дубликатах или нет (оригинальный вопрос не говорит) – matt b 11 August 2010 в 20:47
  • 3
    Комментарий говорит, что (список | кортежи) не имеет дубликатов. – user 11 August 2010 в 20:52
  • 4
    Я поддержал ваш ответ, потому что сначала подумал, что вы правильно относились к дубликатам. Но item not in temp2 и item not in set(temp2) всегда будут возвращать одни и те же результаты, независимо от того, есть ли дубликаты или нет в temp2. – arekolek 7 March 2016 в 23:42
  • 5
    Проголосовать за то, чтобы не требовать хеширования элементов списка. – Brent 11 September 2017 в 15:19

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

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

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

Out: set(['Four', 'Five', 'Three']) 
2
ответ дан Mohammad Etemaddar 17 August 2018 в 08:56
поделиться

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

использовать комплект (). разница (комплект ())

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)))
10
ответ дан Mohideen ibn Mohammed 17 August 2018 в 08:56
поделиться
(list(set(a)-set(b))+list(set(b)-set(a)))
-1
ответ дан nadhem 17 August 2018 в 08:56
поделиться
  • 1
    В дополнение к предоставлению ответа, можете ли вы дать объяснение тому, как это работает / относится к этой конкретной проблеме? Ответы и решения велики, но подробные руководства и объяснения бесконечно лучше. – Busse 6 July 2017 в 17:15

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

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"
3
ответ дан Nick Franceschina 17 August 2018 в 08:56
поделиться

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

Код

Необычный подход с использованием 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']

Это предполагает, что оба списка содержат строки с эквивалентными началами. Подробнее см. docs . Обратите внимание, что это не особенно быстро по сравнению с заданными операциями.


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

import itertools as it


[x for x, y in it.zip_longest(temp1, temp2) if x != y]
# ['Three', 'Three', 'Four']
9
ответ дан pylang 17 August 2018 в 08:56
поделиться
  • 1
    Возможно, вы захотите включить бит from itertools import filterfalse здесь. Также обратите внимание, что это не возвращает последовательность, как остальные, она возвращает итератор. – Matt Luongo 17 January 2012 в 18:16
  • 2
  • 3

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

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

Надеюсь, это поможет.

-1
ответ дан S.K. Venkat 17 August 2018 в 08:56
поделиться

Если вы хотите разницу рекурсивно, я написал пакет для 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}}}
16
ответ дан Seperman 17 August 2018 в 08:56
поделиться

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

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

4
ответ дан soundcorner 17 August 2018 в 08:56
поделиться

однолинейная версия решения arulmr

def diff(listA, listB):
    return set(listA) - set(listB) | set(listA) -set(listB)
3
ответ дан sreemanth pulagam 17 August 2018 в 08:56
поделиться

Вот ответ 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(...), если вы просто выполняете итерацию по нему.

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

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

Выход:

['Two', 'Two', 'Three', 'Three', 'Four']
4
ответ дан Taylor Edmiston 17 August 2018 в 08:56
поделиться

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

  • Это приведет к удалению дубликатов в каждом списке
  • . Это покажет разницу темп 1 от temp2 и temp2 от temp1.

set(temp1) ^ set(temp2)
11
ответ дан Vikram S 17 August 2018 в 08:56
поделиться
  • 1
    привет, я пробовал ваш. но я получил обратный ответ. temp1 = ['1','2','3'], temp2 =['2','3','4'] , answer : ['3','2'] почему? – JessieB 13 June 2017 в 06:01
9
ответ дан pylang 6 September 2018 в 06:40
поделиться
0
ответ дан Carson 29 October 2018 в 13:26
поделиться
Другие вопросы по тегам:

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