Pytoniczny sposób ignorowania ostatniego elementu podczas ustawiania różnicy

Powiedzmy, że mam dwa 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')}

Teraz chcę znaleźć ustaloną różnicę, b \ aale ignorując ostatni element z każdej krotki. To tak, jakby zrobić coś takiego:

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

Oczekiwany wynik:

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

Czy istnieje jakiś oczywisty / pytonowy sposób na osiągnięcie tego bez konieczności ręcznego iterowania każdego zestawu i sprawdzania każdego z nich tuple[:3]?

Oto, w jaki sposób możesz napisać własną klasę, aby zastąpić normalne zachowanie mieszania krotki:

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)

z wyjściem

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

Aby zmodyfikować sposób działania zestawów krotek, musimy zmodyfikować sposób mieszania krotek.

Od tutaj ,

Obiekt jest haszowalny, jeśli ma wartość skrótu, która nigdy się nie zmienia w trakcie jego życia (potrzebuje __hash__()metody), i można go porównać do innych obiektów (potrzebuje __eq__()metody). Obiekty haszujące, które porównują równe, muszą mieć tę samą wartość skrótu.

Hashability sprawia, że ​​obiekt nadaje się do użycia jako klucz słownika i element członkowski, ponieważ te struktury danych wewnętrznie używają wartości skrótu.

Tak więc w celu uczynienia mieszania zignorować ostatni element, musimy przeciążać metody Dunder __eq__i __hash__odpowiednio. Nie jest to wcale takie trudne, ponieważ wszystko, co musimy zrobić, to odciąć ostatni element, a następnie przekazać odpowiednie metody normalne tuple.

Dalsza lektura:

• Jak sprawić, by obiekt był odpowiednio mieszalny?
• https://docs.python.org/3/reference/datamodel.html

Oto jeden sposób definiowania ai bwykazy zamiast zestawów, ponieważ wydaje mi się, że najbardziej proste rozwiązanie do przodu zakłada indeksowanie 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')]

Zestawy działają dobrze. Twoje dane nie działają poprawnie. Jeśli wyglądają inaczej, ale w rzeczywistości są takie same, zdefiniuj typ danych, który zachowuje się tak, jak chcesz. Następnie zestaw działa sam świetnie.

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