Is there a difference between "==" and "is"?

Python's "==" vs. "is": Understanding Equality and Identity

Explore the fundamental differences between Python's == operator for value equality and is operator for object identity, and learn when to use each for robust and predictable code.

In Python, understanding how objects are compared is crucial for writing correct and efficient code. The == operator and the is operator both perform comparisons, but they do so in fundamentally different ways. While == checks for value equality, is checks for object identity. This distinction can lead to subtle bugs if not properly understood.

The == Operator: Value Equality

The == operator, often referred to as the equality operator, compares the values of two objects. It checks if the contents or data represented by the objects are the same. When you use a == b, Python calls the __eq__() method on object a (if implemented) to determine if its value is equivalent to the value of object b. For built-in types like numbers, strings, lists, and dictionaries, this behavior is intuitive. Two strings are equal if they have the same sequence of characters; two lists are equal if they have the same elements in the same order.

list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = [3, 2, 1]

print(f"list1 == list2: {list1 == list2}") # True
print(f"list1 == list3: {list1 == list3}") # False

str1 = "hello"
str2 = "hello"
print(f"str1 == str2: {str1 == str2}") # True

Demonstrating == for lists and strings.

The is Operator: Object Identity

The is operator, on the other hand, compares the identity of two objects. It checks if two variables refer to the exact same object in memory. In essence, a is b is equivalent to id(a) == id(b). The id() function returns the 'identity' of an object, which is guaranteed to be unique and constant for that object during its lifetime. Using is is generally faster than == because it's a direct memory address comparison, not a value-by-value comparison. However, it should only be used when you specifically need to know if two variables point to the identical object.

list1 = [1, 2, 3]
list2 = [1, 2, 3] # A new list object is created
list_alias = list1 # list_alias refers to the same object as list1

print(f"list1 is list2: {list1 is list2}") # False (different objects, same value)
print(f"list1 is list_alias: {list1 is list_alias}") # True (same object)

int1 = 10
int2 = 10
print(f"int1 is int2: {int1 is int2}") # True (due to Python's integer caching for small integers)

Illustrating is for lists and integers. Note Python's optimization for small integers.

When to Use Which Operator

The choice between == and is depends entirely on your intent:

• Use == when you want to compare the values of objects. This is the most common use case for equality checks.
• Use is when you want to compare the identity of objects. This is typically reserved for checking if two variables refer to the exact same instance of an object, or for checking against singletons like None.

The most prominent use case for is is checking if a variable is None. Since None is a singleton (there's only one instance of None in Python), my_variable is None is the idiomatic and recommended way to check for its presence, rather than my_variable == None.

my_object = None

if my_object is None:
    print("my_object is indeed None")

other_object = []
if other_object == None:
    print("This won't print as [] is not None by value")

if other_object is not None:
    print("other_object is not None")

Checking for None using the is operator.

Decision flow for choosing between == and is.