Python __gt__() Magic Method

Short summary:

• To customize the behavior of the greather than operator x > y, override the __gt__() dunder method in your class definition.
• Python internally calls x.__gt__(y) to obtain a return value when comparing two objects using x > y.
• The return value can be any data type because any value can automatically converted to a Boolean by using the bool() built-in function.
• If the __gt__() method is not defined, Python will raise a TypeError.

Syntax

__gt__(self, other)

To use the greater than operator on custom objects, define the __gt__() “dunder” magic method that takes two arguments: self and other. You can then use attributes of the custom objects to determine if one is greater than the other.

The method should return a Boolean True or False — however, this is not required because every object can be automatically converted to a Boolean value using the built-in bool() function.

Let’s have a look at an example next.

Example

In the following code, you compare two persons with each other by using the age attribute as a decision criterion:

class Person:
    def __init__(self, age):
        self.age = age

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



alice = Person(18)
bob = Person(17)
carl = Person(18)

print(alice > bob)
# True

print(alice > carl)
# False

print(bob > alice)
# False

For example, because Alice’s age is 18 years and Bob’s 17 years, the expression alice > bob evaluates to True.

Background Video

Python Greater Than

Default Implementation of __gt__

The __gt__() dunder method doesn’t have a default implementation. If you try to compare objects using the greater than operator >, Python will simply raise a TypeError.

class Person:
    def __init__(self, age):
        self.age = age


alice = Person(18)
bob = Person(17)
carl = Person(18)

print(alice > bob)

Traceback (most recent call last):
  File "C:\Users\...\code.py", line 10, in <module>
    print(alice > bob)
TypeError: '>' not supported between instances of 'Person' and 'Person'

TypeError: ‘>’ not supported between instances of ‘…’ and ‘…’

If you get the TypeError: '>' not supported between instances of '...' and '...', you try to compare two objects using the greater than operator x > y for which the __gt__() magic method is not defined.

class Finxter:
    pass


x = Finxter()
y = Finxter()

x > y    # Python will raise an error!

Output:

Traceback (most recent call last):
  File "C:\...\code.py", line 8, in <module>
    x > y    # Python will raise an error!
TypeError: '>' not supported between instances of 'Finxter' and 'Finxter'

To fix the error, simply define the __gt__(self, other) method in your class definition and return any object that will then be converted to a Boolean True or False.

class Finxter:
    def __gt__(self, other):
        return 42


x = Finxter()
y = Finxter()

x > y    # Now it works!
# 42

Commutativity of Greater Than >

The output of x > y and y > x may be different because the former calls x.__gt__(y) and the latter calls y.__gt__(x). If x and y have different definitions of the dunder method __gt__(), the operation becomes non-commutative.

You can see this in the following example:

class Person:
    def __gt__(self, other):
        return False


class Human:
    def __gt__(self, other):
        return True


alice = Person()
bob = Human()


print(alice > bob)
# False

print(bob > alice)
# True

Programming Humor

💡 Programming is 10% science, 20% ingenuity, and 70% getting the ingenuity to work with the science.

~~~

• Question: Why do Java programmers wear glasses?
• Answer: Because they cannot C# …!

Feel free to check out our blog article with more coding jokes. 😉