SequenceMatcher Difflib - Индивидуальное равенство

Question

Я пытаюсь создать вложенный или рекурсивный эффект с помощью SequenceMatcher.

Конечной целью является сравнение двух последовательностей, оба могут содержать экземпляры разных типов.

Например, последовательности могут быть:

l1 = [1, "Foo", "Bar", 3] 
l2 = [1, "Fo", "Bak", 2] 

Обычно SequenceMatcher будет идентифицировать только [1] в качестве общей подпоследовательности для l1 и l2.

Я хотел бы SequnceMatcher быть применен дважды для струнных экземпляров, так что "Foo" и "Fo" будут считаться равными, а также "Bar" и "Bak", а самый длинный общий суб-последовательность будет иметь длину 3 [1, Foo/Fo, Bar/Bak]. То есть, я бы хотел, чтобы SequenceMatcher был более прощающим при сравнении членов строки.

То, что я пытался делать это написать оболочку для встроенного ул класса:

from difflib import SequenceMatcher 
class myString: 
    def __init__(self, string): 
     self.string = string 
    def __hash__(self): 
     return hash(self.string) 
    def __eq__(self, other): 
     return SequenceMatcher(a=self.string, b=self.string).ratio() > 0.5 

Edit: возможно, более элегантный способ:

class myString(str): 
    def __eq__(self, other): 
     return SequenceMatcher(a=self, b=other).ratio() > 0.5 

Делая это, следующее стало возможным:

>>> Foo = myString("Foo") 
>>> Fo = myString("Fo") 
>>> Bar = myString("Bar") 
>>> Bak = myString("Bak") 
>>> l1 = [1, Foo, Bar, 3] 
>>> l2 = [1, Fo, Bak, 2] 
>>> SequenceMatcher(a=l1, b=l2).ratio() 
0.75 

Таким образом, очевидно, что это работает, но у меня плохое предчувствие перекрывая хэш функция. Когда используется хэш? Где он может вернуться и укусить меня?

документация состояния

SequenceMatcher годов следующие:

Это гибкий класс для сравнения пар последовательностей любого типа, до тех пор, как элементы последовательности являются hashable.

И по определению hashable элементы, необходимые для выполнения следующих требований:

Hashable объекты, которые сравнивают равно должны иметь одинаковое значение хеш-функции.

Кроме того, мне нужно, чтобы переопределить CMP, а?

Мне бы хотелось услышать о других решениях, которые приходят на ум.

Спасибо.

Answer 1

Ваше решение неплохое - вы также можете рассмотреть возможность повторного использования SequenceMatcher для рекурсивного применения, когда элементы последовательности сами являются итерабельными, с некоторой пользовательской логикой. Это было бы болью. Если вы хотите только это подмножество функций SequenceMatcher, написать собственный инструмент сравнения не может быть и плохой идеей.

Переопределение __hash__ сделать "Foo" и "Fo" равным вызовет столкновения в словарях (хеш-таблицах) и тому подобное. Если вас буквально интересуют только первые 2 символа и устанавливаются с использованием SequenceMatcher, возвращение cls.super(self[2:]) может быть путем.

Все, что сказал, лучший выбор - это, возможно, одноразовый инструмент. Я могу набросать основы чего-то подобного, если вам интересно. Вам просто нужно знать, каковы ограничения в обстоятельствах (всегда ли начинается подпоследовательность первого элемента, такого рода вещи).