Identity Operator in Python

The identity operator in Python is used to compare the memory location of two objects. It checks whether two variables refer to the same object in memory. 

Many beginners confuse it with equality operators, but identity operators focus on object identity, not the content comparison.

The solution lies in understanding their core difference. In this tutorial we’ll look at what is identity operator in Python with example, with real identity operator examples to guide you. 

With the help of real identity operator examples, you’ll improve your Python coding skills and write more efficient code.

“Enhance your Python skills further with our Data Science and Machine Learning courses from top universities — take the next step in your learning journey!”

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: 

TrueFalse

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. 

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: 

FalseTrue

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: 

TrueFalse

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: 

TrueFalse 

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: 

TrueFalse

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: 

TrueFalse

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?

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