Maneira pitônica de ignorar o último elemento ao fazer a diferença definida

Digamos que eu tenho dois 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')}

Agora, o que eu quero fazer é encontrar a diferença definida, b \ amas ignorando o último elemento de cada tupla. Então é como fazer algo assim:

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

Saída esperada:

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

Existe alguma maneira óbvia / pitônica de conseguir isso sem ter que iterar manualmente sobre cada conjunto e comparar com cada um tuple[:3]?

Veja como você pode escrever sua própria classe para substituir o comportamento de hash normal de uma 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)

com saída

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

Para modificar a maneira como os conjuntos de tuplas se comportam, precisamos modificar a maneira como as tuplas são hash.

A partir daqui ,

Um objeto é lavável se tiver um valor de hash que nunca seja alterado durante sua vida útil (precisa de um __hash__()método) e poderá ser comparado a outros objetos (precisa de um__eq__() método). Objetos hashable que comparam iguais devem ter o mesmo valor de hash.

A capacidade de Hashability torna um objeto utilizável como chave de dicionário e membro do conjunto, porque essas estruturas de dados usam o valor de hash internamente.

Portanto, para fazer com que o hash ignore o último elemento, precisamos sobrecarregar os métodos dunder __eq__e __hash__adequadamente. Isso não acaba sendo tão difícil, porque tudo o que precisamos fazer é cortar o último elemento e, em seguida, delegar aos métodos apropriados de um método normal.tuple .

Leitura adicional:

• Como tornar um objeto adequadamente lavável?
• https://docs.python.org/3/reference/datamodel.html

Aqui está uma abordagem que define ae bcom listas em vez de conjuntos, pois me parece que a solução mais direta implica a indexação 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')]

Conjuntos funcionam bem. São seus dados que não funcionam corretamente. Se eles parecerem diferentes, mas na verdade forem iguais, defina um tipo de dados que se comporte como você deseja. Em seguida, o conjunto funciona muito bem por conta própria.

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