Блог

Я пытаюсь отсортировать список строк таким образом, чтобы использовать специальное сравнение. Я пытаюсь использовать functools.total_ordering , но я не уверен, правильно ли он заполняет неопределенные сравнения.

Два, которые я определяю ( > и==), работают так, как ожидалось, но > В частности, я печатаю все три и получаю это a > b и a < b . Как это возможно? Я бы подумал, что total_ordering будет просто определять < как not > and not == . Результат моего < теста-это то, что вы получили бы при регулярном сравнении str, что заставляет меня поверить, что total_ordering ничего не делает.

Возможно, проблема в том, что я наследую str, который уже __lt__ реализован? Если да, то есть ли решение этой проблемы?

 from functools import total_ordering

@total_ordering
class SortableStr(str):

    def __gt__(self, other):
        return self other > other self

    #Is this necessary? Or will default to inherited class?
    def __eq__(self, other):
        return str(self) == str(other)

def main():

    a = SortableStr("99")
    b = SortableStr("994")

    print(a > b)
    print(a == b)
    print(a < b)

if __name__ == "__main__":
    main()
 

выход:

 True
False
True
 

Вы правы в том, что встроенные str операторы сравнения вмешиваются в ваш код. Из документов

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

Таким образом, он предоставляет только те, которые еще не определены. В вашем случае тот факт, что некоторые из них определены в родительском классе, невозможно обнаружить total_ordering .

Теперь мы можем углубиться в исходный код и найти точную проверку

 roots = {op for op in _convert if getattr(cls, op, None) is not getattr(object, op, None)}
 

Таким образом, он проверяет, равны ли значения значениям, определенным в корневом объекте object . Мы можем это сделать

 @total_ordering
class SortableStr(str):

    __lt__ = object.__lt__
    __le__ = object.__le__
    __ge__ = object.__ge__

    def __gt__(self, other):
        return self other > other self

    #Is this necessary? Or will default to inherited class?
    def __eq__(self, other):
        return str(self) == str(other)
 

Теперь total_ordering увидим, что __lt__ , __le__ , и __ge__ равны «исходным» object значениям и перепишем их, по желанию.

Все это, как говорится, я бы сказал, что это плохое использование наследования. Вы нарушаете замену Лискова, по крайней мере, в том, что смешанные сравнения между str и SortableStr , мягко говоря, приведут к нелогичным результатам.

Моя более общая рекомендация состоит в том, чтобы отдать предпочтение композиции, а не наследованию, и вместо определения вещи, которая «является» специализированной строкой, рассмотрите возможность определения типа, который «содержит» строку и имеет специализированное поведение.

 @total_ordering
class SortableStr:

    def __init__(self, value):
        self.value = value

    def __gt__(self, other):
        return self.value   other.value > other.value   self.value

    def __eq__(self, other):
        return self.value == other.value
 

Там не требуется никакой магии. Теперь SortableStr("99") это допустимый объект, который не является строкой, но демонстрирует желаемое поведение.

Не уверен, правильно ли это , но, взглянув на документацию functools.total_ordering , я понял, что это бросается в глаза:

Учитывая класс, определяющий один или несколько методов упорядочения с расширенным сравнением, этот декоратор класса предоставляет все остальное.

Акцент мой. Ваш класс наследуется __lt__ от str , поэтому он не будет повторно реализован, total_ordering так как он не отсутствует. Это мое лучшее предположение.