Greater Than

The > (greater than) operator is a strict inequality relational operator that evaluates whether the left operand is strictly greater than the right operand, returning a boolean value (True or False).

left_operand > right_operand

Underlying Implementation

At the object level, the > operator is mapped to the __gt__ magic (dunder) method. Because Python looks up magic methods on the class rather than the instance dictionary, the internal equivalent relies on type(). When the Python interpreter encounters a > b, it executes the following method resolution order:

1. Subclass Priority: If the right operand (b) is an instance of a strict subclass of the left operand’s (a) type, Python prioritizes the subclass’s reflected method and calls type(b).__lt__(b, a).
2. Standard Lookup: Otherwise, Python calls type(a).__gt__(a, b).
3. Reflected Fallback: If the first attempted method returns the NotImplemented singleton (indicating the type does not support comparison with the other type), Python attempts the reverse operation: type(b).__lt__(b, a) (assuming it was not already attempted in step 1).
4. Exception: If both methods return NotImplemented, Python raises a TypeError.

# Internal equivalent of a > b (standard lookup)
type(a).__gt__(a, b)

Evaluation Mechanics by Data Type

The behavior of the > operator depends strictly on the implementation of __gt__ for the types being compared:

• Numeric Types (int, float, Decimal, Fraction): Evaluates the mathematical value. Python handles cross-type numeric comparisons automatically (e.g., comparing an int to a float) without explicit casting.
• Strings (str): Performs a lexicographical comparison based on the Unicode code point values of the characters, evaluated via the built-in ord() function. Comparison proceeds character by character from left to right until a difference is found.
• Sequences (list, tuple): Evaluates lexicographically, element by element, starting at index 0. The comparison terminates at the first unequal pair of elements. If one sequence is an initial subsequence of the other, the longer sequence is considered greater.
• Sets (set, frozenset): Evaluates for a strict superset relationship. set_a > set_b returns True only if set_a contains every element of set_b, and set_a has at least one element not present in set_b (i.e., len(set_a) > len(set_b)).

Operator Chaining

Python supports chaining of relational operators.

a > b > c

At the AST (Abstract Syntax Tree) level, chained comparisons are represented as a single Compare node with multiple operators and comparators, rather than being internally translated into a boolean and operation (BoolOp). While conceptually equivalent to a > b and b > c, chaining evaluates the intermediate operand (b) exactly once. It also implements short-circuit evaluation; if a > b evaluates to False, the subsequent b > c comparison is never evaluated.

Type Compatibility Restrictions

Unlike equality operators (==, !=), which safely fall back to identity comparison for incompatible types (where == evaluates to False and != evaluates to True), the > operator enforces strict type checking. Attempting to compare inherently incompatible types (e.g., a str and an int) will raise a TypeError rather than coercing the types or falling back to object identity (id()).

Master Python with Deep Grasping Methodology!

Learn More