Identity Operator in Python: is vs == Explained with Examples

Why does a == b return True, but a is b sometimes return False in Python?

That’s where the identity operator in Python comes into play.

The identity operator in Python is used to check whether two variables point to the same memory location—not just if their values match. Python provides two identity operators: is and is not. These are especially useful when comparing objects, handling None, or working with mutable vs immutable types.

In this guide, you’ll learn how the identity operator in Python differs from the equality operator ==, when to use is over ==, and how identity checks behave with numbers, strings, lists, and custom objects. We'll also cover common mistakes that often show up in interviews or bug reports.

By the end, you’ll clearly understand how and when to use the identity operator in Python. Want to apply this in real-world coding? Check out our Data Science Courses and Machine Learning Courses for deeper hands-on experience.

Types of Identity Operators in Python

In Python, there are two main identity operators used to compare objects: is and is not.

Let's dive into each of them with identity operator examples and see how they work in practice.

1. is Operator

The is operator checks if two variables refer to the same object in memory. It returns True if both variables point to the same object, otherwise it returns False.

Let’s see an example of how the is operator works:

a = [1, 2, 3]  # Creating a list
b = a           # Assigning b to reference the same list as a
c = [1, 2, 3]   # Creating a new list with same content 
print(a is b)  # Output: True
print(a is c)  # Output: False 

Output:

True

False

Explanation:

• a is b returns True because both a and b refer to the same object in memory.
• a is c returns False because even though a and c contain the same values, they are two different objects in memory.

If you're already diving into topics like model performance or regression diagnostics, now might be a great time to formalize your journey with an advanced AI & ML program designed for practical, project-based learning.

• Masters in Artificial Intelligence and Machine Learning - IIITB Program
• Masters in Data Science Degree
• Master’s Degree in Artificial Intelligence and Data Science

2. is not Operator

The is not operator is the opposite of the is operator. It returns True if two variables do not refer to the same object in memory, and False if they do.

Here’s how you can use the is not operator:

a = [10, 20, 30]
b = a
c = [10, 20, 30] 
print(a is not b)  # Output: False
print(a is not c)  # Output: True 

Output:

False

True

Explanation:

• a is not b returns False because both a and b are referring to the same object.
• a is not c returns True because a and c are two different objects in memory, even though they hold the same data.

When to Use Identity Operators

• Use is when you want to confirm that two variables refer to the exact same object.
• Use is not when you want to check that two variables do not refer to the same object.

“Start your coding journey with our complimentary Python courses designed just for you — dive into Python programming fundamentals, explore key Python libraries, and engage with practical case studies!”

Types of Membership Operators in Python

In Python, membership operators are used to test if a value or variable is present in a sequence, such as a list, string, tuple, or dictionary. The two primary membership operators in Python are in and not in. These operators are simple yet powerful tools for checking membership and are widely used in various programming tasks.

Let’s explore these two operators in more detail.

1. in Operator

The in operator checks if a specified value exists in a sequence (such as a list, tuple, string, or dictionary). It returns True if the value is found, and False if it is not.

Here’s an example of how the in operator works:

fruits = ["apple", "orange", "strawberry"] 
# Check if "orange" is in the list
result = "orange" in fruits
print(result)  # Output: True
# Check if "banana" is in the list
result = "banana" in fruits
print(result)  # Output: False 

Output:

True

False

Explanation:

• "orange" in fruits returns True because "orange" is an element in the fruits list.
• "banana" in fruits returns False because "banana" is not in the list.
• The in operator is widely used to check if a specific item exists in any collection (list, tuple, string, etc.).

2. not in Operator

The not in operator is the opposite of in. It checks if a specified value does not exist in a sequence. It returns True if the value is absent, and False if it is present.

Let’s see how the not in operator works:

fruits = ["apple", "banana", "cherry"] 
# Check if "orange" is not in the list
result = "orange" not in fruits
print(result)  # Output: True 
# Check if "banana" is not in the list
result = "banana" not in fruits
print(result)  # Output: False 

Output:

True

False

Explanation:

• "orange" not in fruits returns True because "orange" is not in the list.
• "banana" not in fruits returns False because "banana" is an element in the list.
• The not in operator is used when you want to confirm the absence of a value in a collection.

Why Use Membership Operators?

• Efficient Lookup: Membership operators allow you to quickly check if an item is part of a collection, saving you time and effort compared to manually iterating through the collection.
• Simplifying Code: Using in and not in makes your code cleaner and more readable compared to using loops or conditional statements.
• Versatile: You can use these operators with many different data structures, including lists, tuples, strings, and dictionaries.

The operators.contains() Method

In Python, you can also use the contains() method to check if a particular item exists within a container, like a list, tuple, or dictionary. This method is commonly used in various scenarios to check for membership, but it differs from identity operators like is and is not. While the identity operators check object identity, contains() checks if an object is present within a collection.

Here’s an example of how you can use the contains() method in Python:

import operator 
# Defining a list
numbers = [1, 2, 3, 4, 5] 
# Checking if 3 is in the list
result = operator.contains(numbers, 3)
print(result)  # Output: True 
# Checking if 10 is in the list
result = operator.contains(numbers, 10)
print(result)  # Output: False 

Output:

True

False

Explanation:

• operator.contains(numbers, 3) returns True because 3 is an element in the list numbers.
• operator.contains(numbers, 10) returns False because 10 is not an element in the list numbers.

The contains() method, as seen in identity operator examples, works as a more general-purpose operator for checking membership in containers.

When to Use contains() Method

• Membership Testing: If you want to check whether an item exists in a collection (like a list, tuple, or dictionary), using operator.contains() allows you to do so in a more explicit and controlled manner than in.
• Complex Code Scenarios: If you need to handle operator overloading or want a more readable alternative to in in certain situations, contains() can be useful.

Comparison with in Operator

Let’s take a look at how operator.contains() compares with the built-in in operator:

numbers = [1, 2, 3, 4, 5] 
# Check if 3 is in the list
print(3 in numbers)  # Output: True 
# Check if 10 is in the list
print(10 in numbers)  # Output: False 

Output:

True

False

Explanation:

• Both operator.contains(numbers, 3) and 3 in numbers return True because 3 exists in the list.
• Similarly, both return False for the number 10 since it doesn’t exist in the list.

Is There a Difference Between == and is?

In Python, == and is are both used to compare objects, but they have distinct purposes.

Below is a detailed comparison in tabular form to help you understand the difference between == and is.

Example 1: Using == and is with Integers

a = 1000
b = 1000 
# Using '=='
print(a == b)  # Output: True
# Using 'is'
print(a is b)  # Output: False

Explanation:

• The == operator returns True because the values of a and b are the same (both are 1000).
• The is operator returns False because a and b are two different objects in memory, even though they have the same value. Python may store integers in different memory locations depending on the range and memory optimization.

Example 2: Using == and is with Strings

a = "hello"
b = "hello"
# Using '=='
print(a == b)  # Output: True
# Using 'is'
print(a is b)  # Output: True

Explanation:

• The == operator returns True because the values of a and b are the same (both are the string "hello").
• The is operator returns True because Python optimizes memory usage for small immutable objects like strings. Both a and b may point to the same memory location.

Example 3: Using == and is with Lists

a = [1, 2, 3]
b = [1, 2, 3]
# Using '=='
print(a == b)  # Output: True
# Using 'is'
print(a is b)  # Output: False

Explanation:

• The == operator returns True because the values (the list contents) of a and b are identical.
• The is operator returns False because a and b are two distinct objects in memory, even though they contain the same values. Lists are mutable, so Python doesn’t automatically reuse memory for them.

Also Read: What Is Mutable And Immutable In Python?

MCQs on Identity Operator in Python

1. Which of the following is an identity operator in Python?

a) ==

b) !=

c) is

d) in

2. What does the is operator check?

a) Value equality

b) Reference identity

c) Data type

d) Index position

3. What is the result of this code?

a = [1, 2]  
b = a  
print(a is b)  

a) `True`

b) `False`

c) `None`

d) `Error`

4. What is the difference between `is` and `==` in Python?

a) `is` compares values, `==` compares references

b) `==` is for identity

c) `is` compares identity, `==` compares values

d) No difference

5. What does `is not` return when two variables refer to different objects?

a) `False`

b) `True`

c) `None`

d) `Error`

6. Which expression checks if two variables refer to the same object?

a) `a == b`

b) `id(a) == id(b)`

c) `type(a) == type(b)`

d) `a in b`

7. What is the result of this code?

x = 256  
y = 256  
print(x is y)  

a) `True`

b) `False`

c) `Depends on interpreter`

d) `None`

8. Which objects are most likely to share the same memory reference in Python?

a) Large integers

b) Lists

c) Immutable small integers and strings

d) User-defined classes

9. A developer writes `if a is b:` but wants to check if two lists have the same contents. What is the correct replacement?

a) `if a == b:`

b) `if a in b:`

c) `if id(a) == id(b):`

d) `if a is not None:`

10. You're debugging an `is` condition that fails even though the contents match. What's likely the issue?

a) Data types don’t match

b) Variables refer to different objects

c) Memory is locked

d) Syntax error in loop

11. A student uses `x is None` to check for null. Why is this preferred over `x == None`?

a) `is` is faster and more accurate for identity comparison

b) `==` crashes

c) `is` checks type

d) Python syntax forces this

FAQs

1. What is identity operator in Python with example?

The identity operator in Python is used to compare if two variables point to the same object in memory. For example, a is b checks if a and b refer to the same object.

2. Can you provide some identity operator examples?

Yes! In the example a = [1, 2, 3] and b = a, a is b returns True because both variables refer to the same object in memory.

3. What is the difference between is and == in Python?

== checks if the values of two objects are equal, while is checks if they are the same object in memory. Use is for identity and == for equality.

4. When should I use is in Python?

Use is when you want to check if two variables refer to the same object in memory, not just if their values are equal.

5. What happens when I use is with immutable objects like strings?

For small immutable objects, Python optimizes memory, so is may return True even if the variables are distinct. It's safer to use == for comparing values.

6. Can I use is for comparing lists or dictionaries in Python?

No, use == to compare the contents of lists or dictionaries. is only checks if two variables point to the same object, not if their contents are identical.

7. What does a is not b do in Python?

The is not operator checks if two variables do not refer to the same object in memory. It returns True if they are different objects.

8. Can the identity operator be used for comparing functions in Python?

Yes, the identity operator works for functions. Use is to check if two function references point to the same function object in memory.

9. How do I compare values if not using identity operators?

You can use the equality operator == to compare values, or != to check if they are different, which is not related to their memory location.

10. What happens if I compare two objects with is and they have the same value?

Even if two objects have the same value, is will return False unless they point to the same memory location. This is an important distinction in identity operator examples.

11. Why is it important to understand the identity operator in Python?

Understanding what is identity operator in Python with example helps avoid mistakes when comparing objects and allows you to manage memory and references more effectively in your programs.

Take our Free Quiz on Python

Answer quick questions and assess your Python knowledge

Start Quiz