Inequality

The != (not equal) operator is a binary comparison operator that evaluates the value inequality of two operands. While it typically evaluates to a boolean (True or False), it does not implicitly coerce its result to a boolean. Instead, it delegates directly to the underlying rich comparison methods of the operands and returns the exact object yielded by those methods.

operand_a != operand_b

Underlying Object Model

In Python’s data model, the != operator maps to the __ne__(self, other) rich comparison dunder (magic) method.

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

    def __ne__(self, other):
        if isinstance(other, CustomObject):
            return self.value != other.value
        return NotImplemented

Directly invoking a.__ne__(b) is not functionally identical to using the != operator. A direct method call bypasses Python’s internal comparison routing and may return the NotImplemented singleton if the left operand does not support comparison with the right operand’s type. The != operator orchestrates a strict delegation and fallback mechanism to resolve the comparison.

Return Value Flexibility

Because Python does not coerce the output of rich comparison operators, != will return whatever object the underlying __ne__ method produces. This architectural decision allows the operator to yield non-boolean types. If a class’s __ne__ method is programmed to return a complex object—such as a vectorized array of booleans or a database query expression—the != operator will return that exact object unmodified.

Evaluation Fallback Chain

When evaluating a != b, the Python interpreter follows a precise sequence to resolve the comparison:

1. Subclass Priority: If the right operand is an instance of a strict subclass of the left operand’s type, Python prioritizes the right operand and calls b.__ne__(a) first. This ensures that subclasses can override the comparison behavior of their parent classes.
2. Left Operand __ne__: If the subclass rule does not apply, Python calls a.__ne__(b).
3. Right Operand __ne__: If the first attempted method returns the NotImplemented singleton, Python delegates to the other operand. It calls b.__ne__(a) (or a.__ne__(b) if the subclass rule triggered step 1).
4. Fallback to Identity: If both __ne__ methods return NotImplemented, Python abandons value-based comparison and falls back to memory identity, effectively returning the boolean result of a is not b.

Delegation to __eq__: If a class does not explicitly override __ne__, it inherits the default object.__ne__ implementation. This default method handles the relationship between equality and inequality by delegating to the object’s __eq__ method and logically inverting the result, provided __eq__ itself does not return NotImplemented.

Cross-Type Comparison Mechanics

Because Python is strongly typed, the != operator does not perform implicit type coercion. Comparing objects of incompatible types generally evaluates to True. Their underlying __ne__ methods return NotImplemented, causing the operator to fall back to an identity comparison (is not), which evaluates to True for distinct objects.

# Evaluates to True. No implicit coercion from string to integer.
1 != "1" 

Numeric Exception: Python’s built-in numeric types (int, float, complex, decimal, fractions) are explicitly designed to interoperate. The != operator evaluates the mathematical equivalence of these types rather than requiring strict type matching.

# Evaluates to False. The mathematical values are equivalent despite differing types.
1 != 1.0 

!= vs is not

It is critical to distinguish != from the is not operator:

• != evaluates value equivalence (orchestrating __ne__ and potentially __eq__ via the object base class).
• is not evaluates memory identity (whether two references point to different objects in memory).

a = [1, 2, 3]
b = [1, 2, 3]

a != b      # False (Values are equivalent)
a is not b  # True (Distinct objects in memory)

Master Python with Deep Grasping Methodology!

Learn More