Saya perlu membandingkan dua daftar untuk membuat daftar baru dari elemen spesifik yang ditemukan di satu daftar tetapi tidak di daftar lainnya. Sebagai contoh:

main_list=[]
list_1=["a", "b", "c", "d", "e"]
list_2=["a", "f", "c", "m"] 

Saya ingin mengulang list_1 dan menambahkan ke main_list semua elemen dari list_2 yang tidak ditemukan di list_1.

Hasilnya seharusnya:

main_list=["f", "m"]

Bagaimana saya bisa melakukannya dengan python?

TL; DR:
SOLUSI (1)

import numpy as np
main_list = np.setdiff1d(list_2,list_1)
# yields the elements in `list_2` that are NOT in `list_1`

SOLUSI (2) Anda menginginkan daftar yang diurutkan

def setdiff_sorted(array1,array2,assume_unique=False):
    ans = np.setdiff1d(array1,array2,assume_unique).tolist()
    if assume_unique:
        return sorted(ans)
    return ans
main_list = setdiff_sorted(list_2,list_1)

PENJELASAN:
(1) Anda dapat menggunakan NumPy ini setdiff1d( array1, array2, assume_unique= False).

assume_uniquememinta pengguna JIKA array SUDAH UNIK.
Jika False, maka elemen uniknya ditentukan terlebih dahulu.
Jika True, fungsi akan menganggap bahwa elemen tersebut sudah unik DAN fungsi akan melewatkan penentuan elemen unik.

Ini menghasilkan nilai unik array1yang tidak ada di dalamnyaarray2 . assume_uniqueadalah Falsesecara default.

Jika Anda khawatir dengan elemen unik (berdasarkan respons Chinny84 ), maka cukup gunakan (di mana assume_unique=False=> nilai default):

import numpy as np
list_1 = ["a", "b", "c", "d", "e"]
list_2 = ["a", "f", "c", "m"] 
main_list = np.setdiff1d(list_2,list_1)
# yields the elements in `list_2` that are NOT in `list_1`

(2) Bagi mereka yang ingin jawaban diurutkan, saya telah membuat fungsi khusus:

import numpy as np
def setdiff_sorted(array1,array2,assume_unique=False):
    ans = np.setdiff1d(array1,array2,assume_unique).tolist()
    if assume_unique:
        return sorted(ans)
    return ans

Untuk mendapatkan jawabannya, jalankan:

main_list = setdiff_sorted(list_2,list_1)

CATATAN SAMPING:
(a) Solusi 2 (fungsi kustom setdiff_sorted) mengembalikan daftar (dibandingkan dengan array dalam solusi 1).

(b) Jika Anda tidak yakin apakah elemennya unik, cukup gunakan pengaturan default NumPy setdiff1ddi kedua solusi A dan B. Apa yang bisa menjadi contoh komplikasi? Lihat catatan (c).

(c) Hal-hal akan berbeda jika salah satu dari dua daftar tersebut tidak unik.
Katakanlah list_2tidak unik: list2 = ["a", "f", "c", "m", "m"]. Pertahankan list1apa adanya: list_1 = ["a", "b", "c", "d", "e"]
Menyetel nilai default assume_uniquehasil ["f", "m"](di kedua solusi). NAMUN, jika Anda menetapkan assume_unique=True, kedua solusi memberikan ["f", "m", "m"]. Mengapa? Ini karena pengguna MENGANGGAP bahwa elemennya unik). Karenanya, LEBIH BAIK UNTUK DIPERTAHANKANassume_uniqueke nilai defaultnya. Perhatikan bahwa kedua jawaban diurutkan.

pythonnumpy

Anda dapat menggunakan set:

main_list = list(set(list_2) - set(list_1))

Keluaran:

>>> list_1=["a", "b", "c", "d", "e"]
>>> list_2=["a", "f", "c", "m"]
>>> set(list_2) - set(list_1)
set(['m', 'f'])
>>> list(set(list_2) - set(list_1))
['m', 'f']

Sesuai komentar @JonClements, berikut adalah versi yang lebih rapi:

>>> list_1=["a", "b", "c", "d", "e"]
>>> list_2=["a", "f", "c", "m"]
>>> list(set(list_2).difference(list_1))
['m', 'f']

Tidak yakin mengapa penjelasan di atas begitu rumit ketika Anda memiliki metode asli yang tersedia:

main_list = list(set(list_2)-set(list_1))

Gunakan pemahaman daftar seperti ini:

main_list = [item for item in list_2 if item not in list_1]

Keluaran:

>>> list_1 = ["a", "b", "c", "d", "e"]
>>> list_2 = ["a", "f", "c", "m"] 
>>> 
>>> main_list = [item for item in list_2 if item not in list_1]
>>> main_list
['f', 'm']

Edit:

Seperti yang disebutkan dalam komentar di bawah, dengan daftar besar, di atas bukanlah solusi ideal. Jika demikian, opsi yang lebih baik adalah mengonversi list_1menjadi yang setpertama:

set_1 = set(list_1)  # this reduces the lookup time from O(n) to O(1)
main_list = [item for item in list_2 if item not in set_1]

Jika Anda ingin solusi satu-kapal (mengabaikan impor) yang hanya membutuhkan O(max(n, m))pekerjaan untuk input panjang ndan m, tidak O(n * m)bekerja, Anda dapat melakukannya dengan para itertoolsmodul :

from itertools import filterfalse

main_list = list(filterfalse(set(list_1).__contains__, list_2))

Ini memanfaatkan fungsi fungsional yang mengambil fungsi callback pada konstruksi, yang memungkinkannya membuat callback sekali dan menggunakannya kembali untuk setiap elemen tanpa perlu menyimpannya di suatu tempat (karena filterfalsemenyimpannya secara internal); pemahaman daftar dan ekspresi generator bisa melakukan ini, tapi itu jelek. †

Itu mendapatkan hasil yang sama dalam satu baris seperti:

main_list = [x for x in list_2 if x not in list_1]

dengan kecepatan:

set_1 = set(list_1)
main_list = [x for x in list_2 if x not in set_1]

Tentu saja, jika perbandingan dimaksudkan untuk menjadi posisi, maka:

list_1 = [1, 2, 3]
list_2 = [2, 3, 4]

harus menghasilkan:

main_list = [2, 3, 4]

(karena nilai dalam list_2memiliki kecocokan pada indeks yang sama di list_1), Anda harus menggunakan jawaban Patrick , yang tidak melibatkan lists atau s sementara set(bahkan dengan sets secara kasar O(1), mereka memiliki faktor "konstan" yang lebih tinggi per cek daripada pemeriksaan persamaan sederhana ) dan melibatkan O(min(n, m))pekerjaan, kurang dari jawaban lain, dan jika masalah Anda sensitif terhadap posisi, adalah satu-satunya solusi yang tepat saat elemen yang cocok muncul di offset yang tidak cocok.

†: Cara melakukan hal yang sama dengan pemahaman daftar sebagai satu-liner akan menyalahgunakan perulangan bersarang untuk membuat dan nilai cache di loop "terluar", misalnya:

main_list = [x for set_1 in (set(list_1),) for x in list_2 if x not in set_1]

yang juga memberikan keuntungan kinerja kecil pada Python 3 (karena sekarang set_1dicakup secara lokal dalam kode pemahaman, daripada mencari dari lingkup bersarang untuk setiap pemeriksaan; pada Python 2 itu tidak masalah, karena Python 2 tidak menggunakan penutup untuk daftar pemahaman; mereka beroperasi dalam lingkup yang sama dengan yang mereka gunakan).

main_list=[]
list_1=["a", "b", "c", "d", "e"]
list_2=["a", "f", "c", "m"]

for i in list_2:
    if i not in list_1:
        main_list.append(i)

print(main_list)

keluaran:

['f', 'm']

Saya akan zipmembuat daftar bersama untuk membandingkannya elemen demi elemen.

main_list = [b for a, b in zip(list1, list2) if a!= b]

Saya menggunakan dua metode dan saya menemukan satu metode berguna di atas yang lain. Inilah jawaban saya:

Data masukan saya:

crkmod_mpp = ['M13','M18','M19','M24']
testmod_mpp = ['M13','M14','M15','M16','M17','M18','M19','M20','M21','M22','M23','M24']

Metode 1: np.setdiff1dSaya menyukai pendekatan ini daripada yang lain karena ini mempertahankan posisinya

test= list(np.setdiff1d(testmod_mpp,crkmod_mpp))
print(test)
['M15', 'M16', 'M22', 'M23', 'M20', 'M14', 'M17', 'M21']

Metode2: Meskipun memberikan jawaban yang sama seperti di Metode1 tetapi mengganggu urutan

test = list(set(testmod_mpp).difference(set(crkmod_mpp)))
print(test)
['POA23', 'POA15', 'POA17', 'POA16', 'POA22', 'POA18', 'POA24', 'POA21']

Method1 np.setdiff1dmemenuhi persyaratan saya dengan sempurna. Jawaban ini untuk informasi.

Jika jumlah kejadian harus diperhitungkan, Anda mungkin perlu menggunakan sesuatu seperti collections.Counter:

list_1=["a", "b", "c", "d", "e"]
list_2=["a", "f", "c", "m"] 
from collections import Counter
cnt1 = Counter(list_1)
cnt2 = Counter(list_2)
final = [key for key, counts in cnt2.items() if cnt1.get(key, 0) != counts]

>>> final
['f', 'm']

Seperti yang dijanjikan, ini juga dapat menangani jumlah kemunculan yang berbeda sebagai "perbedaan":

list_1=["a", "b", "c", "d", "e", 'a']
cnt1 = Counter(list_1)
cnt2 = Counter(list_2)
final = [key for key, counts in cnt2.items() if cnt1.get(key, 0) != counts]

>>> final
['a', 'f', 'm']

Dari ser1 hapus item yang ada di ser2.

Memasukkan

ser1 = pd. Seri ([1, 2, 3, 4, 5]) ser2 = pd. Seri ([4, 5, 6, 7, 8])

Larutan

ser1 [~ ser1.isin (ser2)]