Pythonic способ игнорирования последнего элемента при выполнении разницы между наборами

Допустим, у меня есть два set()с:

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

Теперь я хочу найти разницу в множестве, b \ aно проигнорировать последний элемент из каждого кортежа. Так что это как делать что-то вроде этого:

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

Ожидаемый результат:

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

Есть ли какой-нибудь очевидный / питонный способ достижения этого без необходимости вручную перебирать каждый набор и сверяться с каждым tuple[:3]?

Вот как вы можете написать свой собственный класс для переопределения нормального поведения хэширования кортежа:

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)

с выходом

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

Чтобы изменить поведение наборов кортежей, мы должны изменить способ хэширования кортежей.

Из здесь ,

Объект является хэшируемым, если он имеет хеш-значение, которое никогда не изменяется в течение срока его службы (ему нужен __hash__()метод), и его можно сравнить с другими объектами (ему нужен __eq__()метод). Хэшируемые объекты, которые сравниваются равными, должны иметь одинаковое хеш-значение.

Hashability делает объект пригодным для использования в качестве ключа словаря и члена набора, потому что эти структуры данных используют значение хеша внутри.

Таким образом, чтобы хэширование игнорировало последний элемент, мы должны перегрузить методы dunder __eq__и __hash__соответственно. Это не так сложно, потому что все, что нам нужно сделать, это отрезать последний элемент и затем делегировать его соответствующим методам нормали tuple.

Дальнейшее чтение:

• Как сделать объект правильно хешируемым?
• https://docs.python.org/3/reference/datamodel.html

Вот один подход определения aи bсо списками , а не комплекты, так как мне кажется , что наиболее прямым решение предполагает индексацию 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')]

Наборы работают нормально. Это ваши данные, которые не работают правильно. Если они выглядят по-разному, но на самом деле они одинаковы, тогда определите тип данных, который ведет себя так, как вы хотите. Тогда набор прекрасно работает сам по себе.

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