Pythonische Methode zum Ignorieren des letzten Elements bei der Einstellung der Differenz

Nehmen wir an, ich habe zwei set()s:

a = {('1', '2', '3', 'a'), ('1', '2', '4', 'a'), ('1', '2', '5', 'b')}
b = {('1', '2', '3', 'b'), ('1', '2', '4', 'b'), ('1', '2', '6', 'b')}

Was ich jetzt tun möchte, ist, den eingestellten Unterschied zu finden, b \ aaber das letzte Element aus jedem Tupel zu ignorieren. Es ist also so, als würde man so etwas machen:

a = {('1', '2', '3'), ('1', '2', '4'), ('1', '2', '5')}
b = {('1', '2', '3'), ('1', '2', '4'), ('1', '2', '6')}

In[1]: b - a
Out[1]: {('1', '2', '6')}

Erwartete Ausgabe:

b \ a = {('1', '2', '6', 'b')}

Gibt es eine offensichtliche / pythonische Möglichkeit, dies zu erreichen, ohne jeden Satz manuell durchlaufen und mit jedem vergleichen zu müssen tuple[:3]?

So können Sie Ihre eigene Klasse schreiben, um das normale Hashing-Verhalten eines Tupels zu überschreiben:

a_data = [('1', '2', '3', 'a'), ('1', '2', '4', 'a'), ('1', '2', '5', 'b')]
b_data = [('1', '2', '3', 'b'), ('1', '2', '4', 'b'), ('1', '2', '6', 'b')]

class HashableIgnoresLastElement(tuple):
    def __eq__(self, other):
        return self[:-1] == other[:-1]

    def __hash__(self):
        return hash(self[:-1])

a = set(map(HashableIgnoresLastElement, a_data))
b = set(map(HashableIgnoresLastElement, b_data))

print(b - a)

mit Ausgabe

{('1', '2', '6', 'b')}

Um das Verhalten von Tupelgruppen zu ändern, müssen wir das Hashing von Tupeln ändern.

Von hier ,

Ein Objekt ist hashbar, wenn es einen Hashwert hat, der sich während seiner Lebensdauer nie ändert (es benötigt eine __hash__()Methode) und mit anderen Objekten verglichen werden kann (es benötigt eine __eq__()Methode). Hashbare Objekte, die gleich sind, müssen denselben Hashwert haben.

Durch die Hashability kann ein Objekt als Wörterbuchschlüssel und als festgelegtes Element verwendet werden, da diese Datenstrukturen den Hashwert intern verwenden.

Also, um das Hashing ignoriert das letzte Element zu machen, müssen wir die dunder Methoden überlasten __eq__und __hash__angemessen. Dies ist nicht so schwierig, da wir nur das letzte Element abschneiden und dann an die entsprechenden Methoden eines Normalen delegieren müssen tuple.

Weiterführende Literatur:

• Wie mache ich ein Objekt richtig hashbar?
• https://docs.python.org/3/reference/datamodel.html

Hier ist ein Ansatz, der Listen anstelle von Mengen definiert aund bverwendet, da mir die einfachste Lösung die Indizierung impliziert b:

a = [('1', '2', '3', 'a'), ('1', '2', '4', 'a'), ('1', '2', '5', 'b')]
b = [('1', '2', '3', 'b'), ('1', '2', '4', 'b'), ('1', '2', '6', 'b')]

# reconstruct the sets of tuples removing the last elements
a_ = {tuple(t) for *t, _ in a}
b_ = [tuple(t) for *t, _ in b]

# index b based on whether an element in a_
[b[ix] for ix, j in enumerate(b_) if j not in a_]
# [('1', '2', '6', 'b')]

Sets funktionieren gut. Es sind Ihre Daten, die nicht richtig funktionieren. Wenn sie unterschiedlich aussehen, aber tatsächlich gleich sind, definieren Sie einen Datentyp, der sich wie gewünscht verhält. Dann funktioniert das Set von alleine großartig.

class thing:
    def __init__(self, a, b, c, d):
        self.a, self.b, self.c, self.d = a, b, c, d

    def __repr__(self):
        return (str((self.a, self.b, self.c, self.d)))

    def __hash__(self):
        return hash((self.a, self.b, self.c))

    def __eq__(self, other):
        return self.a == other.a and self.b == other.b and self.c == other.c       

a = {thing('1', '2', '3', 'a'), thing('1', '2', '4', 'a'), thing('1', '2', '5', 'b')}
b = {thing('1', '2', '3', 'b'), thing('1', '2', '4', 'b'), thing('1', '2', '6', 'b')}
print (b - a)

{('1', '2', '6', 'b')}