Understanding id(), type(), isInstance(), and == in Python

Python is an incredibly flexible and robust programming language that finds extensive usage across a wide range of applications. In this tutorial, we will delve into four fundamental concepts: id(), type(), isinstance(), and ==. Familiarizing yourself with these concepts will provide you with a profound comprehension of Python’s object-oriented nature, as well as how objects are compared and distinguished.


The id() function in Python is used to obtain a unique identifier for an object. It returns an integer value that represents the memory address where the object is stored. This identifier remains constant throughout the lifetime of the object.

The syntax for id() is:


Here, object is the object whose identifier you want to retrieve.

The id() function is particularly useful when you want to determine if two variables refer to the same object in memory. If two objects have the same id(), it means they occupy the same memory location and, therefore, are the same object.

x = 10
y = x

print(id(x)) # Output: 140721109813984
print(id(y)) # Output: 140721109813984

In the above example, both x and y have the same id() value, indicating that they refer to the same memory location. Thus, any changes made to x will also affect y because they point to the same object.

Properties of the id() in Python

  1. Unique: The id() function returns a unique identifier for an object, which represents the memory address where the object is stored.
  2. Constant: The id() value remains constant during the lifetime of an object. As long as the object exists, its id() value will remain the same.
  3. Memory Address: The id() value represents the memory address where the object is stored in the computer’s memory.
  4. Object Comparison: The id() function is often used to compare objects and determine if they refer to the same memory location. If two objects have the same id(), they are the same object.
  5. Lifetime Dependency: The id() value is unique only during the lifetime of an object. Once the object is destroyed or garbage collected, the id() value may be reassigned to a different object.
  6. Not Suitable for Equality Checks: Although id() can help identify the uniqueness of an object, it is not recommended for equality checks or determining object equivalence. For equality comparisons, it is better to use the == operator or other comparison functions.

Remember that the id() function is primarily used for low-level operations or debugging purposes. In most cases, you would not need to explicitly use id() in your everyday programming tasks.


The type() function allows us to determine the type or class of an object. It returns the type of the object as a class object.

Syntax: type(object)


x = 10
print(type(x)) # Output:<class ‘int’>

y = “Hello”
print(type(y)) # Output:<class ‘str’>

my_list = [1, 2, 3]
print(type(my_list)) # Output:<class ‘list’>

Main points to understand about the type() function:

  • Type Identification: The type() function allows you to identify the specific type or class of an object. It returns a class object that represents the type of the given object.
  • Class Objects: The type() function returns class objects that represent the types of objects in Python. Each object in Python belongs to a specific class, which defines its behavior and attributes.
  • Built-in and User-defined Types: The type() function can be used to determine both built-in types provided by Python (e.g., int, float, str) and user-defined types (e.g., classes created by the programmer).
  • Dynamic Typing: Python is a dynamically typed language, which means the type of an object can change during runtime. The type() function allows you to inspect the current type of an object at any point in the program.
  • Helpful for Conditional Execution: The type() function can be used to perform conditional execution based on the type of an object. It allows you to make decisions or perform specific operations depending on the type of data you are dealing with.


The isinstance() function is used to check if an object is an instance of a specified class or any of its subclasses. It returns True if the object is an instance; otherwise, it returns False.

Syntax: isinstance(object, classinfo)

class Person:

p = Person()
print(isinstance(p, Person)) # Output: True

x = 10
print(isinstance(x, int)) # Output: True

y = “Hello”
print(isinstance(y, str)) # Output: True

In the above example, isinstance() verifies whether the objects p, x, and y are instances of the specified classes.

== (Equality Operator):

The == operator is used to compare the equality of two objects or values. It returns True if the objects have the same value, and False otherwise.


x = 10
y = 5 + 5
print(x == y) # Output: True

s1 = “Hello”
s2 = “World”
print(s1 == s2) # Output: False


x = 5
y = 10

print(x == y) # Output: False

name1 = “Alice”
name2 = “Alice”

print(name1 == name2) # Output: True

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

print(list1 == list2) # Output: True

Remember that the == operator checks for value equality. If you want to compare object identities or memory addresses, you can use the is operator or the id() function.


In this tutorial, we explored four important concepts in Python: id(), type(), isinstance(), and ==. We learned how id() provides a unique identifier for an object, type() determines the type of an object, isinstance() checks if an object is an instance of a specific class, and == allows us to compare the equality of objects. Understanding these concepts is crucial for effective Python programming, enabling you to work with objects, classes, and comparisons efficiently.

Remember to experiment with these concepts in your own code to gain a deeper understanding of their functionality and application. Happy coding!