Dapatkan perbedaan antara dua daftar

Saya memiliki dua daftar dengan Python, seperti ini:

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

Saya perlu membuat daftar ketiga dengan item dari daftar pertama yang tidak ada di daftar kedua. Dari contoh saya harus mendapatkan:

temp3 = ['Three', 'Four']

Apakah ada cara cepat tanpa siklus dan pemeriksaan?

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

Waspadalah itu

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

di mana Anda mungkin mengharapkan / menginginkannya sama set([1, 3]). Jika Anda ingin set([1, 3])sebagai jawaban, Anda harus menggunakannya set([1, 2]).symmetric_difference(set([2, 3])).

Semua solusi yang ada menawarkan salah satu dari yang berikut:

• Kinerja lebih cepat dari O (n * m).
• Pertahankan urutan daftar input.

Namun sejauh ini tidak ada solusi yang memiliki keduanya. Jika Anda ingin keduanya, coba ini:

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

Uji kinerja

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)

Hasil:

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

Metode yang saya sajikan serta menjaga pesanan juga (sedikit) lebih cepat dari pengurangan yang ditetapkan karena tidak memerlukan konstruksi dari set yang tidak perlu. Perbedaan kinerja akan lebih terlihat jika daftar pertama jauh lebih lama daripada yang kedua dan jika hashing mahal. Inilah tes kedua yang menunjukkan ini:

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

Hasil:

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

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

Perbedaan antara dua daftar (katakanlah list1 dan list2) dapat ditemukan menggunakan fungsi sederhana berikut.

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)

atau

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

Dengan Menggunakan fungsi di atas, perbedaan dapat ditemukan menggunakan diff(temp2, temp1)atau diff(temp1, temp2). Keduanya akan memberikan hasilnya ['Four', 'Three']. Anda tidak perlu khawatir tentang urutan daftar atau daftar mana yang harus diberikan terlebih dahulu.

Referensi dokumen Python

Jika Anda menginginkan perbedaan secara rekursif, saya telah menulis paket untuk python: https://github.com/seperman/deepdiff

Instalasi

Instal dari PyPi:

pip install deepdiff

Contoh penggunaan

Pengimporan

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

Objek yang sama kembali kosong

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

Jenis item telah berubah

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

Nilai suatu barang telah berubah

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

Item ditambahkan dan / atau dihapus

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

Perbedaan string

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

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

Ketik perubahan

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

Daftar perbedaan

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

Daftar perbedaan 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}}}

Daftar perbedaan mengabaikan urutan atau duplikat: (dengan kamus yang sama seperti di atas)

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

Daftar yang berisi kamus:

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

Set:

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

Dinamai Tuples:

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

Objek khusus:

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

Atribut objek ditambahkan:

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

Dapat dilakukan dengan menggunakan operator python XOR.

• Ini akan menghapus duplikat di setiap daftar
• Ini akan menunjukkan perbedaan temp1 dari temp2 dan temp2 dari temp1.

set(temp1) ^ set(temp2)

cara paling sederhana,

gunakan set (). perbedaan (set ())

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

jawabannya adalah set([1])

dapat mencetak sebagai daftar,

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

Jika Anda benar-benar melihat ke kinerja, maka gunakan numpy!

Berikut ini adalah buku catatan lengkap sebagai inti pada github dengan perbandingan antara daftar, numpy, dan panda.

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

saya akan melemparkan karena tidak ada solusi yang menghasilkan tuple:

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

kalau tidak:

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

Seperti jawaban non-tuple lainnya yang menghasilkan arah ini, ia menjaga ketertiban

Aku ingin sesuatu yang akan mengambil dua daftar dan bisa melakukan apa yang diffdi bashlakukan. Karena pertanyaan ini muncul pertama kali ketika Anda mencari "python diff two list" dan tidak terlalu spesifik, saya akan memposting apa yang saya dapatkan.

Menggunakan SequenceMatherdaridifflib Anda dapat membandingkan dua daftar seperti diffhalnya. Tidak ada jawaban lain yang akan memberi tahu Anda posisi di mana perbedaan itu terjadi, tetapi jawaban ini tidak. Beberapa jawaban memberikan perbedaan hanya dalam satu arah. Beberapa menyusun ulang elemen. Beberapa tidak menangani duplikat. Tetapi solusi ini memberi Anda perbedaan nyata antara dua daftar:

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

Output ini:

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

Tentu saja, jika aplikasi Anda membuat asumsi yang sama dengan jawaban lainnya, Anda akan mendapat manfaat paling banyak dari mereka. Tetapi jika Anda mencari yang benardiff fungsionalitas yang , maka ini adalah satu-satunya cara untuk pergi.

Misalnya, tidak ada jawaban lain yang dapat menangani:

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

Tapi yang ini:

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

Coba ini:

temp3 = set(temp1) - set(temp2)

ini bisa lebih cepat daripada pemahaman daftar Markus:

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

Inilah Counterjawaban untuk kasus paling sederhana.

Ini lebih pendek daripada yang di atas yang melakukan dua arah diffs karena hanya melakukan persis apa yang ditanyakan: menghasilkan daftar apa yang ada di daftar pertama tetapi bukan yang kedua.

from collections import Counter

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

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

Atau, tergantung pada preferensi keterbacaan Anda, itu membuat satu baris yang layak:

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

Keluaran:

['Three', 'Four']

Perhatikan bahwa Anda dapat menghapus list(...)panggilan jika Anda hanya mengulanginya.

Karena solusi ini menggunakan penghitung, ia menangani jumlah dengan benar vs banyak jawaban berbasis set. Misalnya pada input ini:

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

Outputnya adalah:

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

Anda bisa menggunakan metode naif jika elemen-elemen dari diflist diurutkan dan ditetapkan.

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

print list1[len(list2):]

atau dengan metode kumpulan asli:

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)

Solusi naif: 0,0787101593292

Solusi set asli: 0.998837615564

Saya sedikit terlambat dalam permainan untuk ini, tetapi Anda dapat melakukan perbandingan kinerja beberapa kode yang disebutkan di atas dengan ini, dua pesaing tercepat adalah,

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

Saya minta maaf untuk pengkodean tingkat dasar.

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

Berikut adalah beberapa cara sederhana, mempertahankan urutan untuk membedakan dua daftar string.

Kode

Pendekatan yang tidak biasa menggunakan 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']

Ini mengasumsikan kedua daftar berisi string dengan permulaan yang setara. Lihat dokumen untuk detail lebih lanjut. Catatan, ini tidak terlalu cepat dibandingkan dengan operasi yang ditetapkan.

Implementasi langsung menggunakan itertools.zip_longest:

import itertools as it


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

Ini adalah solusi lain:

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

Jika Anda bertemu TypeError: unhashable type: 'list'Anda perlu mengubah daftar atau set menjadi tupel, mis

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

Lihat juga Bagaimana membandingkan daftar daftar / set dengan python?

Katakanlah kita memiliki dua daftar

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

kita dapat melihat dari dua daftar di atas bahwa item 1, 3, 5 ada di list2 dan item 7, 9 tidak. Di sisi lain, item 1, 3, 5 ada di list1 dan item 2, 4 tidak.

Apa solusi terbaik untuk mengembalikan daftar baru yang berisi item 7, 9 dan 2, 4?

Semua jawaban di atas menemukan solusinya, sekarang apa yang paling optimal?

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

melawan

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

Menggunakan timeit kita bisa melihat hasilnya

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

kembali

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

Process finished with exit code 0

versi baris tunggal dari solusi arulmr

def diff(listA, listB):
    return set(listA) - set(listB) | set(listA) -set(listB)

jika Anda menginginkan sesuatu yang lebih seperti setelan perubahan ... bisa menggunakan Penghitung

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"

Kami dapat menghitung persimpangan minus gabungan daftar:

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

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

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

Ini dapat diselesaikan dengan satu baris. Pertanyaan diberikan dua daftar (temp1 dan temp2) mengembalikan perbedaannya dalam daftar ketiga (temp3).

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

Berikut adalah cara sederhana untuk membedakan dua daftar (apa pun isinya), Anda bisa mendapatkan hasilnya seperti yang ditunjukkan di bawah ini:

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

Semoga ini bisa membantu.

Saya lebih suka menggunakan konversi ke set dan kemudian menggunakan fungsi "perbedaan ()". Kode lengkapnya adalah:

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

Keluaran:

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

Ini paling mudah untuk dipahami, dan lebih baik lagi jika Anda bekerja dengan data besar, mengonversinya ke set akan menghapus duplikat jika duplikat tidak diperlukan. Semoga bisa membantu ;-)

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

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

mis. jika list1 = [10, 15, 20, 25, 30, 35, 40]dan list2 = [25, 40, 35]kemudian daftar yang dikembalikan adalahoutput = [10, 20, 30, 15]