Операція віднімання списку Python

Я хочу зробити щось подібне до цього:

>>> x = [1,2,3,4,5,6,7,8,9,0]  
>>> x  
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]  
>>> y = [1,3,5,7,9]  
>>> y  
[1, 3, 5, 7, 9]  
>>> y - x   # (should return [2,4,6,8,0])

Але це не підтримується списками python Який найкращий спосіб зробити це?

Використовуйте розуміння списку:

[item for item in x if item not in y]

Якщо ви хочете використовувати -синтаксис інфіксації, ви можете просто зробити:

class MyList(list):
    def __init__(self, *args):
        super(MyList, self).__init__(args)

    def __sub__(self, other):
        return self.__class__(*[item for item in self if item not in other])

Ви можете використовувати його так:

x = MyList(1, 2, 3, 4)
y = MyList(2, 5, 2)
z = x - y   

Але якщо вам абсолютно не потрібні властивості списку (наприклад, замовлення), просто використовуйте набори, як рекомендують інші відповіді.

Використовуйте задану різницю

>>> z = list(set(x) - set(y))
>>> z
[0, 8, 2, 4, 6]

Або ви можете просто встановити набір x і y, тому вам не потрібно робити перетворення.

Це операція "встановлення віднімання". Використовуйте для цього встановлену структуру даних.

У Python 2.7:

x = {1,2,3,4,5,6,7,8,9,0}
y = {1,3,5,7,9}
print x - y

Вихід:

>>> print x - y
set([0, 8, 2, 4, 6])

якщо проблеми з дублікатами та замовленнями:

[i for i in a if not i in b or b.remove(i)]

a = [1,2,3,3,3,3,4]
b = [1,3]
result: [2, 3, 3, 3, 4]

У багатьох випадках використання потрібна відповідь:

ys = set(y)
[item for item in x if item not in ys]

Це гібрид між відповіддю aaronasterling в і відповідь quantumSoup в .

Версія aaronasterling робить len(y)порівняння елементів для кожного елемента x, тому це займає квадратичний час. версія використовує набори quantumSoup, так що він робить одну постійного час набору пошуку для кожного елемента в xбуті, так як він перетворює як x іy в наборах, вона втрачає порядок ваших елементів.

Перетворюючи лише yнабір і повторюючи xпорядок, ви отримуєте найкраще з обох світів - лінійного часу та збереження порядку. *

Однак це все ще має проблему з версією QuantumSoup: Це вимагає, щоб ваші елементи були перебірними. Це в значній мірі вбудовано в природу множин. ** Якщо ви намагаєтесь, наприклад, відняти список диктовок з іншого списку диктів, але список для віднімання великий, що ви робите?

Якщо ви можете прикрасити свої цінності таким чином, щоб вони були зручними, це вирішить проблему. Наприклад, з плоским словником, значення якого самі є доступними:

ys = {tuple(item.items()) for item in y}
[item for item in x if tuple(item.items()) not in ys]

Якщо ваші типи трохи складніші (наприклад, часто ви маєте справу з сумісними з JSON значеннями, які є хешбек, або списками або диктантами, значення яких рекурсивно одного типу), ви все одно можете використовувати це рішення. Але деякі типи просто неможливо перетворити на що-небудь доступне.

Якщо ваші предмети не є і їх неможливо зробити хешируемими, але вони порівнянні, ви можете принаймні отримати лінійний час журналу ( O(N*log M)що набагато краще, ніж O(N*M)час рішення списку, але не так добре, як O(N+M)час заданого розчину) шляхом сортування і з допомогою bisect:

ys = sorted(y)
def bisect_contains(seq, item):
    index = bisect.bisect(seq, item)
    return index < len(seq) and seq[index] == item
[item for item in x if bisect_contains(ys, item)]

Якщо ваші предмети не є ні доступними, ні порівняльними, то ви застрягли в квадратичному рішенні.

_{* Зауважте, що ви могли також зробити це за допомогою пари OrderedSetоб'єктів, для яких ви можете знайти рецепти та сторонні модулі. Але я думаю, що це простіше.}

_{** Причина, що шукає пошуки - це постійний час, полягає в тому, що все, що потрібно зробити, - це хеш-значення і подивитися, чи є запис для цього хешу. Якщо він не може хеш-значення, це не працюватиме.}

Пошук значень у наборах швидше, ніж пошук у списках:

[item for item in x if item not in set(y)]

Я вважаю, що це буде дещо кращим, ніж:

[item for item in x if item not in y]

Обидва зберігають порядок списків.

Якщо списки дозволяють повторювати елементи, ви можете використовувати Counter з колекцій:

from collections import Counter
result = list((Counter(x)-Counter(y)).elements())

Якщо вам потрібно зберегти порядок елементів з x:

result = [ v for c in [Counter(y)] for v in x if not c[v] or c.subtract([v]) ]

Інші рішення мають одну з декількох проблем:

1. Вони не зберігають порядок, або
2. Вони не видаляють точну кількість елементів, наприклад, для x = [1, 2, 2, 2]і y = [2, 2]перетворюються yв a set, а також видаляють всі відповідні елементи ( [1]лише залишившись ) або видаляючи один з кожного унікального елемента (залишаючи [1, 2, 2]), коли правильною поведінкою було б видалення 2двічі, залишаючи [1, 2], або
3. Вони роблять O(m * n)роботу, де оптимальне рішення може зробити O(m + n)роботу

Ален був на правильному шляху,Counter щоб вирішити №2 та №3, але це рішення втратить замовлення. Рішення, що зберігає порядок (видалення перших nкопій кожного значення для nповторень у listзначеннях для видалення):

from collections import Counter

x = [1,2,3,4,3,2,1]  
y = [1,2,2]  
remaining = Counter(y)

out = []
for val in x:
    if remaining[val]:
        remaining[val] -= 1
    else:
        out.append(val)
# out is now [3, 4, 3, 1], having removed the first 1 and both 2s.

Спробуйте в Інтернеті!

Щоб видалити останні копії кожного елемента, просто змініть forцикл на for val in reversed(x):та додайте out.reverse()відразу після виходу з forциклу.

Побудова Counterє O(n)з точки зору yтривалості, ітерація x- O(n)з точки зору xтривалості, а Counterтестування та мутація членства є O(1), поки list.appendамортизується O(1)(дана інформація appendможе бути O(n), але для багатьох appendс загальна величина середнього величини O O(1)менше, ніж менша та менша. з них вимагає перерозподілу), тому загальна виконана робота - це O(m + n).

Ви також можете протестувати, щоб визначити, чи були елементи, yякі не були видалені з xдопомогою тестування:

remaining = +remaining  # Removes all keys with zero counts from Counter
if remaining:
    # remaining contained elements with non-zero counts

Спробуйте це.

def subtract_lists(a, b):
    """ Subtracts two lists. Throws ValueError if b contains items not in a """
    # Terminate if b is empty, otherwise remove b[0] from a and recurse
    return a if len(b) == 0 else [a[:i] + subtract_lists(a[i+1:], b[1:]) 
                                  for i in [a.index(b[0])]][0]

>>> x = [1,2,3,4,5,6,7,8,9,0]
>>> y = [1,3,5,7,9]
>>> subtract_lists(x,y)
[2, 4, 6, 8, 0]
>>> x = [1,2,3,4,5,6,7,8,9,0,9]
>>> subtract_lists(x,y)
[2, 4, 6, 8, 0, 9]     #9 is only deleted once
>>>

Я думаю, що найпростіший спосіб досягти цього, використовуючи set ().

>>> x = [1,2,3,4,5,6,7,8,9,0]  
>>> y = [1,3,5,7,9]  
>>> list(set(x)- set(y))
[0, 2, 4, 6, 8]

Відповідь надається @aaronasterling виглядає добре, однак, він не сумісний з інтерфейсом за замовчуванням списку: x = MyList(1, 2, 3, 4)проти x = MyList([1, 2, 3, 4]). Таким чином, наведений нижче код може використовуватися як більш зручний список пітонів:

class MyList(list):
    def __init__(self, *args):
        super(MyList, self).__init__(*args)

    def __sub__(self, other):
        return self.__class__([item for item in self if item not in other])

Приклад:

x = MyList([1, 2, 3, 4])
y = MyList([2, 5, 2])
z = x - y

Я думаю, що це швидше:

In [1]: a = [1,2,3,4,5]

In [2]: b = [2,3,4,5]

In [3]: c = set(a) ^ set(b)

In [4]: c
Out[4]: {1}

Цей приклад віднімає два списки:

# List of pairs of points
list = []
list.append([(602, 336), (624, 365)])
list.append([(635, 336), (654, 365)])
list.append([(642, 342), (648, 358)])
list.append([(644, 344), (646, 356)])
list.append([(653, 337), (671, 365)])
list.append([(728, 13), (739, 32)])
list.append([(756, 59), (767, 79)])

itens_to_remove = []
itens_to_remove.append([(642, 342), (648, 358)])
itens_to_remove.append([(644, 344), (646, 356)])

print("Initial List Size: ", len(list))

for a in itens_to_remove:
    for b in list:
        if a == b :
            list.remove(b)

print("Final List Size: ", len(list))