What is the difference between "is" and "==" in Python?

Question

Jayant Kumar · Accepted Answer

Table of Contents
Introduction
In Python, is and == are two operators used for comparison, but they serve different purposes. The is operator checks for identity, meaning it evaluates whether two variables refer to the same object in memory. On the other hand, the == operator checks for equality, meaning it evaluates whether the values of two variables are the same. Understanding the difference between these operators is crucial for effective coding and debugging. This article explores their differences, providing practical examples to illustrate their usage.
Key Differences Between is and ==
1. Purpose and Function

**is**: The is operator is used to compare the identities of two objects. It returns True if both operands refer to the same object in memory, and False otherwise. This operator is used for checking object identity.
**==**: The == operator is used to compare the values of two objects. It returns True if the values of the operands are equal, regardless of whether they are the same object in memory. This operator is used for checking value equality.

Example:
# Using is to check identity
a = [1, 2, 3]
b = a  # b is the same object as a
c = [1, 2, 3]  # c is a new object with the same value as a

print(a is b)  # Output: True (a and b refer to the same object)
print(a is c)  # Output: False (a and c refer to different objects)

# Using == to check equality
print(a == b)  # Output: True (a and b have the same value)
print(a == c)  # Output: True (a and c have the same value)

2. Use Cases

**is**: Typically used for checking if two variables point to the same object, such as when checking for None, or comparing singleton objects.
**==**: Used for checking if the values of two variables are equivalent, regardless of whether they are distinct objects.

Example:
# Using is to compare with None
x = None
print(x is None)  # Output: True

# Using == to compare values
y = [1, 2, 3]
print(y == [1, 2, 3])  # Output: True (lists have the same values)

3. Behavior with Immutable vs. Mutable Objects

**is**: For immutable objects (e.g., integers, strings), Python may cache objects and reuse them, so is might return True even if the variables are distinct. For mutable objects (e.g., lists, dictionaries), is checks if the variables refer to the exact same object.
**==**: For both immutable and mutable objects, == checks if the values are equal.

Example:
# Immutable objects
x = 256
y = 256
print(x is y)  # Output: True (small integers are cached and reused)

x = 257
y = 257
print(x is y)  # Output: False (larger integers are not cached)

# Mutable objects
a = [1, 2, 3]
b = [1, 2, 3]
print(a is b)  # Output: False (different objects in memory)
print(a == b)  # Output: True (same values)

# Strings (immutable)
s1 = "hello"
s2 = "hello"
print(s1 is s2)  # Output: True (strings are interned)
print(s1 == s2)  # Output: True (same value)

Practical Examples
Example : Checking Object Identity
# Two variables pointing to the same object
x = {'key': 'value'}
y = x
print(x is y)  # Output: True

# Two variables pointing to different objects with the same value
z = {'key': 'value'}
print(x is z)  # Output: False

Example : Comparing Valuesn
# Comparing lists with the same values
list1 = [10, 20, 30]
list2 = [10, 20, 30]
print(list1 == list2)  # Output: True

# Checking if lists are the same object
print(list1 is list2)  # Output: False

Conclusion
The is and == operators in Python serve different purposes. The is operator checks for object identity, meaning whether two variables reference the same object in memory. The == operator checks for value equality, meaning whether the values of two variables are the same, regardless of whether they are distinct objects. Understanding these differences is essential for accurate comparisons and effective Python programming.

What is the difference between "is" and "==" in Python?

Table of Contents

Introduction

Key Differences Between `is` and `==`

1. Purpose and Function

Example:

2. Use Cases

Example:

3. Behavior with Immutable vs. Mutable Objects

Example:

Practical Examples

Example : Checking Object Identity

Example : Comparing Valuesn

Conclusion

Similar Questions