2つのリストの違いを取得する


810

Pythonには次のような2つのリストがあります。

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

2番目のリストにはない最初のリストのアイテムを含む3番目のリストを作成する必要があります。例から私は得なければなりません:

temp3 = ['Three', 'Four']

サイクルとチェックなしの高速な方法はありますか?


14
要素は一意に保証されていますか?あなたが持っている場合temp1 = ['One', 'One', 'One']temp2 = ['One']、あなたがしたいです['One', 'One']バック、または[]
Michael Mrozek 2010

@ michael-mrozek彼らはユニークです。
Max Frai 2010

12
要素の順序を保持しますか?
Mark Byers

回答:


1209
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:リストは "-"オペランドをサポートしていません。セットは、しかし、あなたがよく見ると、上記で示されていることを行います。
Godsmith、2014年

1
おかげで、私はset(ListA).symmetric_difference(ListB)を使用することになりました
Drewdin

43
対称差は次のように書くことができます:^(set1 ^ set2)
Bastian

10
回答を編集して、これがtemp1-temp2のみを返すことを指摘してください。..すべての違いを返すために他の人が言ったように、sysmetricの違いを使用する必要があります:list(set(temp1)^ set(temp2))
rkachach

なぜ私は入手できますかTypeError: 'str' object is not callable、私はこの操作を実行するときa = [1,2,2,2,3]b = [2]
d8aninja

476

既存のソリューションはすべて、次のいずれかを提供します。

  • 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

私が提示した方法と順序を維持する方法も、不要なセットを作成する必要がないため、セットの減算よりも(少し)高速です。最初のリストが2番目のリストよりもかなり長い場合、およびハッシュが高価な場合、パフォーマンスの違いはより顕著になります。これを示す2番目のテストを次に示します。

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オブジェクトを操作するとき、私は集合減算を使用していました。特定のtarinfoオブジェクトをアーカイブからの抽出から除外します。新しいリストの作成は高速でしたが、抽出中は非常に低速でした。その理由は、最初は私を避けました。tarinfoオブジェクトのリストを並べ替えると、パフォーマンスが大幅に低下します。リスト内包表記方法に切り替えると、その日が節約できました。
レイトンプソン

@MarkByers-たぶん、これについてまったく新しい質問を書く必要があります。しかし、これはforloopでどのように機能しますか?たとえば、temp1とtemp2が変化し続ける場合、新しい情報をtemp3に追加したいですか?
エイソン

@MarkByers-いいですね。少し考えてみます。しかし、+ 1は優れたソリューションです。
Ason、

@Dejelに同意>>> temp1 = ['One'、 'Two'、 'Three'、 'Four'] >>> temp2 = ['One'、 'Two'、 'Six'] >>> s = set(temp2)>>> temp3 = [xがxでない場合はtemp1のxに対するx] >>> temp3 ['Three'、 'Four']
earlonrails

3
@haccksリストのメンバーシップのチェックはO(n)操作(リスト全体を繰り返す)ですが、セットのメンバーシップのチェックはO(1)であるためです。
Mark Byers、2015年

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

15
回すtemp2前にセットにすると、このビットより効率的になるだろう。
lunaryorn 2010

3
確かに、Ockonalが重複を気にするかどうかに依存します(元の質問には書かれていません)
matt b

2
コメントには、(リスト|タプル)には重複がないとあります。

1
最初は重複についてあなたが正しいと思ったので、私はあなたの答えを賛成しました。しかしitem not in temp2、にitem not in set(temp2)重複があるかどうかに関係なく、常に同じ結果を返しtemp2ます。
arekolek 2016年

5
リスト項目をハッシュ可能にする必要がないことに対する賛成票。
ブレント

23

2つのリスト(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
なぜset(list1).symmetric_difference(set(list2))しないのですか?
2015年

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

Python XOR演算子を使用して実行できます。

  • これにより、各リストの重複が削除されます
  • これにより、temp1とtemp2の違い、およびtemp2とtemp1の違いが表示されます。

set(temp1) ^ set(temp2)

動作しますが、なぜですか?
ZakS

ベストアンサー!
Artsiom Praneuski

なんて答えだ!とてもpythonic !!!! すばらしい
toing_toing

18

最も簡単な方法、

使用セットを()。差(セット())

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を使ってください!

リスト、numpy、パンダを比較したgithubの要点としての完全なノートブックを以下に示します。

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

ここに画像の説明を入力してください


リンクのノートブックとスクリーンショットも更新しました。驚いたことに、内部でハッシュテーブルに切り替えた場合でも、パンダはnumpyよりも低速です。これは、おそらくint64へのアップキャストが原因である可能性があります。
denfromufa 2017

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

私は2つのリストを取り、何をすることができる何かが欲しかっdiffbashありませんが。この質問は、「python diff two list」を検索すると最初に表示され、あまり具体的ではないので、思いついた内容を投稿します。

SequenceMatherfrom difflibを使用すると、2つのリストを比較できますdiff。他のどの答えも違いが発生する位置を教えてくれませんが、これは違います。いくつかの答えは、一方向にのみ違いを与えます。一部は要素を並べ替えます。一部は重複を処理しません。しかし、このソリューションでは、2つのリストの真の違いが得られます。

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ここにビットを含めたいかもしれません。また、これは他のシーケンスを返さず、イテレータを返すことにも注意してください。
Matt Luongo 2012年

7

これCounterが最も単純なケースの答えです。

これは、双方向の差分を行う上記のものよりも短くなります。これは、質問が要求することだけを実行するためです。最初のリストにあるもののリストを生成し、2番目のリストは生成しません。

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

difflistの要素がソートおよび設定されている場合は、単純な方法を使用できます。

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

print list1[len(list2):]

またはネイティブのsetメソッドを使用:

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

私はこれでゲームに遅すぎるのですが、上記のコードのいくつかとこれとのパフォーマンスの比較を行うことができます。最速の候補の2つは、

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

以下に、文字列の2つのリストを比較する簡単で順序を維持する方法をいくつか示します。

コード

を使用した珍しいアプローチ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

はい、それはこれらのアプローチの特徴です。前述のように、これらのソリューションは順序を維持します-リスト間の相対的な順序を想定しています。順不同の解決策は、2つのセットを比較することです。
pylang 2018

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

2つのリストがあるとします

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

上記の2つのリストから、アイテム1、3、5はlist2に存在し、アイテム7、9は存在しないことがわかります。一方、list1には項目1、3、5が存在し、項目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)))

timeitを使用して結果を確認できます

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

チェンジセットのようなものが欲しいなら... 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"

2

リストの和集合から和集合を計算できます:

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

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

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

2

これは1行で解決できます。質問には2つのリスト(temp1とtemp2)が与えられ、3番目のリスト(temp3)でそれらの違いが返されます。

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

1

2つのリスト(内容が何であれ)を区別する簡単な方法を以下に示します。結果は次のようになります。

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

私は、セットへの変換を使用してから、「difference()」関数を使用することを好みます。完全なコードは次のとおりです。

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

アンダーサンディングが最も簡単で、将来、大きなデータで作業する場合、moroverをセットに変換すると、重複が不要な場合に重複が削除されます。それが役に立てば幸い ;-)


-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'より大きいかどうかに関係なく、 'a'から 'b'が減算されると見なされます。リストとセットの場合も同様です。A - BとB - Aの両方の有効な操作することができかかわらず、AとBの長さの、あなただけのA実行するためにAからBの内容を除外する必要が- B.
アブタルハガムデンマークの
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.