【python】特殊メソッド __lt__ , __gt__ はどのように使い分けるのか。

Question

python __it__と__gt__の使い分けについて

classの特殊メソッド　lt　と　gt　の使い分けについて、それぞれが>演算子と<演算子の役割を示し、インスタンスの比較ができるようになることは理解したのですが、それぞれの使い分けについて理解ができません。

__gt__を使った比較演算

class Comparison:
    def __init__(self,x):
        self.x = x

    def __gt__(self,other):
        if self.x < other.x:
            return True
        elif self.x == other.x:
            return None
        else:
            return False
         
y1 = Comparison(22)
y2 = Comparison(21)

print(y1 > y2)
#>>False

疑問

__gt__でself.xとother.xを比較し、結果を「True , False , None」で返すようにしていますが、比較演算子”>”の向きを変えれば逆の結果が帰って来ますし、例外も発生しないため__lt__とどのように使い分けるのか疑問を持っています。

また私が今勉強に使っている参考書では、同じclass内に__gt__と__lt__を同時に定義しており、中身は">"の向きを変えただけの全く同じものだったので、両方定義する理由があるのであれば知りたいと思い質問させていただきました。
下記に記載させていただきます。

疑問に持った参考書内のコード抜粋

 def __init__(self, v, s):
        """suit + value are ints"""
        self.value = v
        self.suit = s

    def __lt__(self, c2):
        if self.value < c2.value:
            return True
        if self.value == c2.value:
            if self.suit < c2.suit:
                return True
            else:
                return False
        return False

    def __gt__(self, c2):
        if self.value > c2.value:
            return True
        if self.value == c2.value:
            if self.suit > c2.suit:
                return True
            else:
                return False
        return False

#__lt__と__gt__が全く同じ役割を示しているように
#見えるため、同時に定義する理由が不明です。

    def __repr__(self):
        v = self.values[self.value] +\
            " of " + \
            self.suits[self.suit]
        return v

Comments

[quickquip]

本文で書式がついて困る時は `__gt__`とバッククォートでくくるとよいですよ。
https://teratail.com/help#about-markdown

Answer 1

両方定義する理由があるのであれば知りたいと思い質問させていただきました。

a > bとb < aのどちらか片方でしか使えない、なんてクラスを作っても、知って使うとしてもうっかり逆向きで書いてしまって動かないトラブルを生む、ましてやライブラリとして他人に使ってもらうには不便で不合理なものとなってしまいます。

Comments

[maisumakun]

> 中身は">"の向きを変えただけの全く同じものだったので

むしろ、向きによってまったく動作の違うクラスを作るほうが混乱します。

[maisumakun]

比較は対称的でなければなりません。 つまり、以下の式の結果は同じでなければなりません

https://docs.python.org/ja/3/reference/expressions.html#value-comparisons

不等号を使ったDSLを組み立てるのでもない限り、この通りに両方実装しておきましょう。

[rkymjr1991]

ありがとうございます。両方実装しなかった場合にトラブルが生まれる可能性があるのであれば、両方実装しておいてまず間違いはなさそうですね。
初歩的な質問に快くご回答いただきありがとうございました。

Answer 2

回答ではありません

速度の話があったので測ってみました。

import timeit
  
class Hoge:
    def __init__(self, v):
        self.value = v

class HogeWithLt(Hoge):
    def __init__(self, v):
        super().__init__(v)
    def __lt__(self, right):
        return self.value < right.value

class HogeWithGt(Hoge):
    def __init__(self, v):
        super().__init__(v)
    def __gt__(self, right):
        return self.value > right.value

class HogeWithLtAndGt(Hoge):
    def __init__(self, v):
        super().__init__(v)
    def __lt__(self, right):
        return self.value < right.value
    def __gt__(self, right):
        return self.value > right.value

for cls in ('HogeWithLt', 'HogeWithGt', 'HogeWithLtAndGt'):
    print(f'[{cls}]')
    print(timeit.repeat(f'v1 < v2', f'v1={cls}(1);v2={cls}(2)', number=10000000, globals=globals()))
    print(timeit.repeat(f'v2 > v1', f'v1={cls}(1);v2={cls}(2)', number=10000000, globals=globals()))

$ python3 --version
Python 3.8.10
$ python3 sample.py
[HogeWithLt]
[1.3253876060189214, 1.35883577002096, 1.4073622680152766, 1.36936645701644, 1.31191633301205]
[2.016354927996872, 2.013986409001518, 2.0291321120166685, 2.0595013450074475, 2.0382606999774]
[HogeWithGt]
[2.0358829490141943, 2.075015729002189, 2.076373985997634, 1.9962386050028726, 2.053162529016845]
[1.328342495020479, 1.3259293310111389, 1.3575235510070343, 1.3413178710034117, 1.316727269004332]
[HogeWithLtAndGt]
[1.3144145520054735, 1.316202103975229, 1.3855247679748572, 1.3094538759905845, 1.3577031239983626]
[1.3365965629927814, 1.3250991759996396, 1.3101062320056371, 1.3281135029974394, 1.3213003540004138]
$ 

私の環境だと両方定義した方が割と速いようですね。

---

ついでにpypyでも測ってみました。

$ pypy3 -V
Python 3.6.9 (7.3.1+dfsg-4, Apr 22 2020, 05:15:29)
[PyPy 7.3.1 with GCC 9.3.0]
$ pypy3 sample.py
[HogeWithLt]
[0.013435224012937397, 0.01156763598555699, 0.011592883995035663, 0.011952064000070095, 0.011544334003701806, 0.01208959097857587, 0.01161127700470388]
[0.013763035996817052, 0.011804156994912773, 0.011587033019168302, 0.012147278001066297, 0.011602851998759434, 0.011594195995712653, 0.011793879006290808]
[HogeWithGt]
[0.013169176992960274, 0.01172563000000082, 0.01144949599984102, 0.01157167399651371, 0.011531008000019938, 0.011383701988961548, 0.011427515011746436]
[0.016236709023360163, 0.01355474698357284, 0.02249747299356386, 0.011509436997584999, 0.02142298500984907, 0.01737112400587648, 0.011405222991015762]
[HogeWithLtAndGt]
[0.01291838800534606, 0.011729608988389373, 0.011620064004091546, 0.011509778996696696, 0.011812743992777541, 0.01150153300841339, 0.01154042498092167]
[0.01317515701521188, 0.012265279976418242, 0.011791975004598498, 0.01159220200497657, 0.011521228996571153, 0.011551906995009631, 0.011629011016339064]
$

流石に有意な差はなさそうです。

Comments

[dameo]

回答じゃないと大きく書いてますよ。ただの補足です。

Answer 3

まずサンプルのコードはサンプルであってそれだけを見て考えることに意味はありません。
包丁の説明書にトマトを切っている図しか載っていないからといってトマトしか切れないのか? と言っているようなものです。

---

(otnさんの回答への付記です)

質問の上のコード

class Comparison:
    def __init__(self,x):
        self.x = x

    def __gt__(self,other):
        if self.x < other.x:
            return True
        elif self.x == other.x:
            return None
        else:
            return False

で、

y1 = Comparison(22)
y2 = Comparison(21)

print(y1 > y2)  # => False
print(y1 < y2)  # => True

と、「__lt__が定義されていなくてもy1 < y2ができる」ことに気づいていましたか。

同じクラス間での比較を考えている限りはどちらか一方だけで十分です。(__lt__や__gt__がNotImplementedをraiseするクラスからの派生である限りにおいては)

---

__lt__や__gt__の両方を実装する必要が生じるのは、手を入れられない既存のクラスとの比較をしたい時です。

有理数のクラス(MyFractionとしましょう)を自前で作った時、intと比較したくなります。
__lt__だけだと、MyFraction(7, 3) < 3は動きますが3 < MyFraction(7, 3)は動きません。
前者はMyFraction(7, 3).__lt__(3)に解釈されて期待通り動きますが、後者は(3).__lt__(MyFraction(7, 3))と解釈されてNotImplementedがraiseされ、次にMyFraction(7, 3).__gt__(3)が試されてまたNotImplementedがraiseされるからです。

intの__lt__メソッドをいじることはできないので、ここでMyFractionに__gt__が必要になる理由が生じます。

Answer 4

他の方とちょっと違う意見なので。

pythonでは、書式として、中置記法の2項演算子(+とか×とか)が使えます。クラスで定義したオブジェクトに対してもそれらの演算子を使って処理をさせることができますが、それらの動作を定義するときに特殊なメソッド(特殊メソッド)で定義することにしています。「+」演算を定義するのは __add__メソッド、「×」を定義するのは__mul__メソッドのように前後に__がついたメソッドです。

ということで、「python __lt__と__gt__の使い分け」ということではなく、そもそも、クラスの定義でそのクラスのインスタンスで「<」や「>」の演算を実行できるようにするには両方定義する必要があるのです。
これが基本です。

ただ、pythonでは「<」と「>」は逆の機能を持つ演算なので、便利機能として、他の方が説明しているように片方が無ければ、一方で補完するようになっているのです。 これはあくまで便利機能なので、 本質ではありません。

Answer 5

比較演算子”>”の向きを変えれば逆の結果が帰って来ますし、例外も発生しないため__lt__とどのように使い分けるのか疑問を持っています。

__lt__や__gt__は、あらかじめNotImplementedを返すように定義されていますので、
y1 > y2で呼び出されるy1.__gt__(y2)はFalseを返すのに対して、
y1 < y2で呼び出されるy1.__lt__(y2)はNotImplementedを返します。

演算子でNotImplementedが返った場合、<と>のように反射の関係にある演算子がある場合、右項のクラスの対のメソッドを左項を引数にして呼び出し、NotImplemented以外の値が返ったらその値を結果とします。
つまり、y1 < y2に対してはy1.__lt__(y2)の呼び出しの後、y2.__gt__(y1)が呼び出されてTrueを返すので、__lt__を定義しなくても期待通りの結果になります。

__lt__を適切に定義した方がわずかに速くなると思いますが、メンテを考えると片方で良い気がします。

参考：https://docs.python.org/ja/3/library/constants.html

二項演算の (あるいはインプレースの) メソッドが NotImplemented を返した場合、インタープリタはもう一方の型で定義された対の演算で代用を試みます (あるいは演算によっては他の代替手段も試みます)。試行された演算全てが NotImplemented を返した場合、インタープリタは適切な例外を送出します。

Answer 6

object.__gt__(self, other)

There are no swapped-argument versions of these methods (to be used when the left argument does not support the operation but the right argument does); rather, lt() and gt() are each other’s reflection, __le__() and __ge__() are each other’s reflection, and __eq__() and __ne__() are their own reflection.

つまり、__gt__() メソッドのみが実装されている場合に __lt__() メソッドが呼び出されると、self と other を入れ替えて、other.__gt__(self) が実行されることになります。もちろん、other が self と同じ型(type)であることが前提となります。

Comments

[rkymjr1991]

回答ありがとうございます。
呼び出されるメソッドは不等号の向きで決まっているのですね。
selfとotherが入れ替わった場合に、大きなコードになれば何かしら問題が発生する可能性もありそうなので、基本的に両方実装する認識で勉強を進めていこうと思います。
初歩的な質問に快くご回答いただきありがとうございました。

[otn]

左右同じ型限定なら問題は起きそうにないですが、左右が異なる型に対して適用すると、よく設計しないと混乱するかもです。
でも、継承関係に無い異なる型同士で不等号を定義したいと思うことは普通はないと思います。
猫クラスに、< の右辺が犬クラスなら真、ネズミクラスなら偽と定義するとか？

[otn]

他の方の会頭にある通り、既存のクラスとの比較を行いたい場合は、両方定義要ですね。
まあ、今回の質問は、「片方の定義で事足りるのに何故両方定義するのか？」だと思うので、
同じ方同士のように片方で事足りる場合は片方で良いと思います。