> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Python Less Than Or Equal To The `<=` (less than or equal to) operator is a relational comparison operator that evaluates whether the left operand is strictly less than or equivalent in value to the right operand. It returns a boolean value (`True` or `False`) based on the evaluation. ```python theme={"dark"} left_operand <= right_operand ``` ## Underlying Comparison Machinery When the `<=` operator is invoked, Python relies on a specific dispatching mechanism rather than a simple method call. For the expression `a <= b`, the evaluation follows strict rules: 1. **Subclass Priority:** If the right operand `b` is an instance of a strict subclass of the left operand `a`'s type, Python prioritizes the right operand's reflected method and calls `b.__ge__(a)` first. 2. **Standard Dispatch:** If the subclass rule does not apply, Python calls the left operand's rich comparison method: `a.__le__(b)`. 3. **Fallback Mechanism:** If the initially called method returns the `NotImplemented` singleton (indicating the operation is unsupported for the given types), Python falls back to the other operand's corresponding method (`b.__ge__(a)` or `a.__le__(b)`). 4. **TypeError:** If both `__le__()` and `__ge__()` return `NotImplemented`, the comparison machinery terminates and raises a `TypeError`. Because of this machinery, the operator expression `a <= b` is not functionally equivalent to the direct method call `a.__le__(b)`. Directly invoking `a.__le__(b)` bypasses Python's fallback and subclass rules. If the comparison is unsupported, the direct call literally returns the `NotImplemented` singleton rather than attempting a reverse comparison or raising a `TypeError` for the operation. Furthermore, evaluating the `NotImplemented` singleton directly in a boolean context raises a `TypeError` in modern Python (3.12+). ## Evaluation Mechanics by Data Type * **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`). * **Sequence Types (`str`, `list`, `tuple`):** Performs lexicographical comparison. Python compares the sequences element by element from left to right. For strings, this is based on the Unicode code point values of individual characters (via the `ord()` function). The comparison stops at the first unequal element. If all evaluated elements are equal but one sequence is shorter, the shorter sequence is considered less than the longer one. * **Sets (`set`, `frozenset`):** In the context of sets, the `<=` operator evaluates the subset relationship. `A <= B` returns `True` if all elements of set `A` exist within set `B`. * **Incompatible Types:** Using `<=` between types that do not define a comparison relationship (e.g., `int` and `str`, or `dict` and `dict`) results in a `TypeError` because the underlying dunder methods return `NotImplemented`. ## Operator Chaining Python supports chaining the `<=` operator with other relational operators to form compound boolean expressions. ```python theme={"dark"} # The middle operand 'b' is evaluated exactly once a <= b <= c ``` Chained comparisons utilize short-circuit evaluation. If `a <= b` evaluates to `False`, the expression immediately returns `False`, and `c` is never evaluated. Crucially, unlike the explicitly expanded expression `(a <= b) and (b <= c)`, the chained form evaluates the middle operand (`b`) **only once**. This prevents duplicate execution and unintended side effects if `b` is a function call or a complex expression.

Tired of Poor Python Skills? Fix That With Deep Grasping! Learn More