Python != Operator: Usage and Common Pitfalls
python != operator: Learn how the Python != operator works, how it differs from 'is not', and how to avoid common mistakes when comparing values in real code.

The python != operator compares two values for inequality. It returns True when the values are not equal and False when they are equal. The comparison is based on value equality, not object identity. That distinction matters because Python objects can be equal even when they are different objects in memory.
How the != Operator Evaluates Values
When you write a != b, Python calls the equality comparison and negates the result. For most built-in types, this compares the actual values. Two lists with the same elements in the same order are equal, regardless of whether they are the same list object.
first = [1, 2, 3]
second = [1, 2, 3]
print(first != second) # FalseThe lists are distinct objects, but their contents are identical, so != returns False. This is the behavior most developers expect when comparing data.
The operator works across all built-in types, including numbers, strings, tuples, sets, and dictionaries. For custom classes, the behavior depends on how the class implements __eq__. If a class does not define __eq__, Python falls back to identity comparison, which means two instances are equal only if they are the same object.
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
p1 = Point(1, 2)
p2 = Point(1, 2)
print(p1 != p2) # True, because no __eq__ is definedTo make != compare field values, define __eq__ in the class. When you define __eq__, Python automatically uses its negation for !=.
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __eq__(self, other):
if not isinstance(other, Point):
return NotImplemented
return self.x == other.x and self.y == other.y
p1 = Point(1, 2)
p2 = Point(1, 2)
print(p1 != p2) # False!= vs is not: Value vs Identity
The != operator checks value inequality, while is not checks identity inequality. Two objects can have equal values but different identities. This distinction is critical when comparing against singletons like None.
value = None
print(value != None) # False
print(value is not None) # FalseFor None, both expressions give the same result in this example. But consider a custom object that compares equal to None:
class Weird:
def __eq__(self, other):
return True
w = Weird()
print(w != None) # False, because __eq__ returns True
print(w is not None) # True, because w is not the None objectUsing is not None is the recommended way to check for None because it is explicit about identity and avoids relying on __eq__ implementations. The same applies to other singletons like True, False, and NotImplemented.
Chaining Comparisons with !=
Python allows chaining comparison operators, and != can participate in chains. The expression a != b != c is equivalent to a != b and b != c. It does not compare a and c directly.
a = 1
b = 2
c = 3
print(a != b != c) # True, because 1 != 2 and 2 != 3This behavior can be surprising when you intend to check that all three values are different. The chain only verifies adjacent pairs. To check that all values are distinct, you need an explicit combination:
a = 1
b = 2
c = 1
print(a != b != c) # True, because a != b and b != c, but a == c
print(a != b and a != c and b != c) # FalseUse chained comparisons only when you actually want the transitive pairwise behavior. For a full distinctness check, write out the conditions or use a set when the values are hashable.
Common Mistakes with != in Conditional Logic
A frequent mistake is using != when the intent is to check membership or a range condition. For example, checking that a value is not equal to multiple alternatives with or is verbose and error-prone.
status = "pending"
if status != "active" or status != "completed":
print("not active")This condition is always True because a single value cannot simultaneously equal both strings. The correct approach is to use and or, better, a membership test:
if status not in ("active", "completed"):
print("not active")Another common mistake is comparing floating-point numbers directly with !=. Due to binary representation, values that should be equal may compare as unequal.
a = 0.1 + 0.2
b = 0.3
print(a != b) # True, because 0.1 + 0.2 is 0.30000000000000004When working with floats, compare against a tolerance instead of using != directly, unless you intentionally want to detect exact bit-level differences.
Performance and Runtime Considerations
The != operator itself is cheap. The runtime cost comes from the __eq__ method it invokes. For built-in types, comparisons are implemented in C and are fast. For custom classes, the cost depends on the complexity of __eq__.
If you compare large data structures frequently, the comparison may become a bottleneck. For example, comparing two large lists requires iterating through elements until a mismatch is found. The worst case is when the lists are equal or differ only in the last element.
large_a = list(range(1000000))
large_b = list(range(1000000))
print(large_a != large_b) # False, but it scans the entire listIf performance matters, consider using a hash-based structure like a set or a frozenset for membership checks, or store a hash of the data to avoid full comparisons. However, premature optimization is rarely justified. Measure first, then optimize the specific comparison that shows up in profiling.
Using != with Custom Classes and Data Classes
When defining custom classes, you control how != behaves through __eq__. A common mistake is to define __eq__ without considering the type of the other operand. Returning False for incompatible types can cause unexpected behavior in mixed-type comparisons.
class Money:
def __init__(self, amount):
self.amount = amount
def __eq__(self, other):
if not isinstance(other, Money):
return False
return self.amount == other.amount
m = Money(100)
print(m != 100) # True, because 100 is not a Money instanceThis is often acceptable, but if you want Money(100) == 100 to be meaningful, you need to handle numeric types explicitly. Returning NotImplemented for unknown types lets Python try the reflected operation on the other operand, which is the recommended pattern.
Data classes automatically generate __eq__ based on the fields, so != works as expected without manual implementation.
from dataclasses import dataclass
@dataclass
class Money:
amount: float
currency: str
m1 = Money(100, "USD")
m2 = Money(100, "USD")
print(m1 != m2) # FalseThe generated __eq__ compares each field in order, and != is the negation. This is a convenient way to get value-based inequality without boilerplate.
When != Does Not Work as Expected
Some objects do not support equality comparison in a meaningful way. For example, NumPy arrays return an array of booleans when compared with !=, not a single boolean. Using such an array in an if statement raises an ambiguity error.
import numpy as np
arr = np.array([1, 2, 3])
print(arr != 2) # array([ True, False, True])To get a single boolean, use .any() or .all() depending on the intent:
print((arr != 2).any()) # True if any element is not 2
print((arr != 2).all()) # True if all elements are not 2Similarly, pandas Series and DataFrames produce element-wise comparisons. Always reduce the result to a scalar before using it in a conditional.
Another edge case is objects that define __ne__ explicitly. Python 3 automatically derives __ne__ from __eq__, but if you override __ne__ for some reason, it takes precedence. In practice, you rarely need to define __ne__ separately.
Practical Recommendations for Using !=
Use != when you want to compare values for inequality. Prefer is not when checking against singletons like None. Be explicit about the type of comparison you need.
When comparing floats, use a tolerance or a dedicated function like math.isclose for approximate equality, and invert it if you need inequality.
import math
print(not math.isclose(0.1 + 0.2, 0.3)) # FalseFor custom classes, implement __eq__ carefully and return NotImplemented for unsupported types. Use data classes when you want automatic value equality.
When using libraries that return element-wise comparisons, always reduce the result to a scalar with .any() or .all() before using it in control flow.
Finally, be cautious with chained comparisons. They evaluate pairwise, not as a full distinctness check. Write explicit conditions when you need to compare multiple values against each other.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.