Modo pitonico di ignorare l'ultimo elemento quando si fa la differenza impostata

Diciamo che ho due 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')}

Ora, quello che voglio fare è trovare la differenza impostata b \ ama ignorando l'ultimo elemento di ogni tupla. Quindi è proprio come fare qualcosa del genere:

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

Uscita prevista:

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

Esiste un modo ovvio / pitonico per raggiungere questo obiettivo senza dover iterare manualmente su ogni set e verificare con ciascuno di essi tuple[:3]?

Ecco come potresti scrivere la tua classe per sovrascrivere il normale comportamento di hash di una tupla:

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)

con uscita

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

Per modificare il modo in cui si comportano le serie di tuple, dobbiamo modificare il modo in cui le tuple vengono hash.

Da qui ,

Un oggetto è hash se ha un valore hash che non cambia mai durante la sua vita (ha bisogno di un __hash__()metodo) e può essere paragonato ad altri oggetti (ha bisogno di un __eq__()metodo). Gli oggetti hash che si equivalgono devono avere lo stesso valore hash.

La hashability rende un oggetto utilizzabile come chiave di dizionario e membro set, poiché queste strutture di dati utilizzano internamente il valore di hash.

Quindi, per fare in modo che l'hash ignori l'ultimo elemento, dobbiamo sovraccaricare i metodi del dunder __eq__e in modo __hash__appropriato. Questo non finisce per essere così difficile perché tutto ciò che dobbiamo fare è tagliare l'ultimo elemento e quindi delegare ai metodi appropriati di un normale tuple.

Ulteriori letture:

• Come rendere un oggetto opportunamente cancellabile?
• https://docs.python.org/3/reference/datamodel.html

Ecco un approccio che definisce ae bcon liste piuttosto che insiemi, poiché mi sembra che la soluzione più semplice implichi l'indicizzazione 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')]

Imposta funziona bene. Sono i tuoi dati che non funzionano correttamente. Se sembrano diversi ma in realtà sono uguali, allora definisci un tipo di dati che si comporti come desideri. Quindi il set funziona alla grande da solo.

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