Python id() Function Explained: How Memory Addressing Works

Introduction

Ever wondered how Python keeps track of the variables you create? That’s where Python’s id() function comes in. It gives you a unique number for each object, showing where Python stores it in memory.

Python manages memory automatically, but every object you create has a specific place in memory. Knowing an object’s identity (its memory address) can be helpful when working with mutable vs. immutable data types, debugging tricky issues, or just exploring how Python handles data behind the scenes.

With id(), you can:

• See where an object lives in memory.
• Check if two variables point to the same object or just have the same value.
• Get a deeper understanding of how Python stores and reuses data.

Let’s break it down!

What is Python’s id() Function?

Just imagine id() like a house address for your variables. Just like every house has a unique address, every object (like numbers, strings, or lists) in Python has a unique ID that tells you where it’s stored in memory.

Simple Example

Let’s say you create a number in Python:

x = 42  
print(id(x))  # This shows where 'x' is stored in memory

When you run this, Python will print a number like 140731598312464. That number is where Python is storing x in memory while the program runs.

What’s the Point of id()?

1. It tells you if two variables are actually the same object.
   • Example:

a = 10
b = 10
print(id(a), id(b))  # Both will have the same id

• Since Python optimizes small numbers, a and b share the same memory location.

2. It helps understand how Python stores objects.

• Example:

list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(id(list1), id(list2))  # These will have different ids

• Even though list1 and list2 look the same, Python stores them in different memory locations because they are separate lists.

So, id() is useful when you want to see if two variables are actually referring to the same object or just have the same value but are stored separately.

How Python Manages Memory and Object Identity

Python stores objects in memory using a system called object referencing. Every object you create has a unique identity (its memory location), which you can check using the id() function. But how Python manages this memory depends on whether the object is mutable or immutable.

Immutable vs. Mutable Objects

1. Immutable objects (like numbers, strings, and tuples) cannot be changed after they are created. Instead of modifying them, Python creates a new object in memory when you change their value.
2. Mutable objects (like lists, dictionaries, and sets) can be changed, so Python keeps them in the same memory location but updates their content.

Example: Immutable Objects (Integers)

a = 10  
b = 10  
print(id(a), id(b))  # Same ID, because integers are immutable  

Here, a and b both hold the value 10. Since Python optimizes memory by reusing small integers, a and b point to the same memory location.

Example: Mutable Objects (Lists)

list1 = [1, 2, 3]  
list2 = [1, 2, 3]  
print(id(list1), id(list2))  # Different IDs, because lists are mutable  

Even though list1 and list2 look the same, Python treats them as separate objects because lists are mutable. That’s why their id() values are different—they are stored in different places in memory.

Why Does This Matter?

• If you assign an immutable object (a = 10 and b = 10), Python reuses memory to save space.
• If you create a mutable object (list1 = [1, 2, 3] and list2 = [1, 2, 3]), Python creates separate memory locations to allow modifications.

Understanding this helps when working with functions, references, and memory optimization in Python. Want to see what happens when you modify mutable vs. immutable objects? Let’s explore next!

Must Read

• Mastering Logical Operators in Python: The Ultimate Beginner- Guide
• Mastering Multiple Inputs in Python
• How to Use the input() Function in Python
• How to Use Logical Operators in Python
• How to Format Strings in Python using print() and .format()

Understanding Object Identity with id()

Python optimizes memory by reusing objects whenever possible. This is called object reuse and happens mostly with small integers and interned strings. The goal is to save memory and speed up execution.

Example: Python Reuses Small Integers

Python automatically caches integers in the range -5 to 256. If two variables hold the same number within this range, they will point to the same memory address.

x = 256  
y = 256  
print(id(x), id(y))  # Same ID because Python reuses small integers  

But when you use numbers outside this range, Python creates a new object each time.

x = 257  
y = 257  
print(id(x), id(y))  # Different IDs, because Python doesn’t cache larger numbers  

Example: Python Reuses Certain Strings (String Interning)

Python also interns some strings, meaning it stores them in memory once and reuses them if another variable has the same value. This happens with short strings and identifiers (like variable names).

str1 = "hello"  
str2 = "hello"  
print(id(str1), id(str2))  # Same ID (Python reuses the string)  

However, if you create a long or complex string, Python may not reuse it:

str1 = "hello world!"  
str2 = "hello world!"  
print(id(str1), id(str2))  # May have different IDs  

Why Does This Happen?

• Small integers (-5 to 256) are reused because they are common in programs.
• Short and simple strings are cached to improve performance.
• Mutable objects (like lists) are never reused, since modifying one would accidentally change all references.

Understanding when Python reuses objects can help you write more efficient code and avoid unexpected behavior when working with mutable and immutable objects.

How id() Helps in Debugging and Memory Optimization

The id() function is useful for debugging when dealing with references and memory usage in Python. It helps you understand whether two variables point to the same object or different copies. This is especially important when working with mutable objects like lists and dictionaries.

Example: Identifying Aliasing in Lists

In Python, when you assign one list to another, both variables point to the same object in memory. This is called aliasing.

list_a = [1, 2, 3]  
list_b = list_a  # list_b now refers to the same object as list_a  
print(id(list_a), id(list_b))  # Same ID (both are the same object)  

Since list_a and list_b are the same object, any change to list_b also affects list_a:

list_b.append(4)  
print(list_a)  # [1, 2, 3, 4] (modification reflects in both)  

This can cause unexpected bugs, especially if you intended to create a separate copy of the list.

How Copying an Object Creates a New Memory Address

To avoid aliasing, you can create an independent copy of a list using copy.deepcopy(). This ensures that the new list has a separate memory address.

import copy  
list_c = copy.deepcopy(list_a)  
print(id(list_a), id(list_c))  # Different IDs (list_c is a new object)  

Now, modifying list_c won’t affect list_a:

list_c.append(5)  
print(list_a)  # [1, 2, 3, 4] (unchanged)  
print(list_c)  # [1, 2, 3, 4, 5] (modified independently)  

Why This Matters for Performance

Using id() helps you:

• Detect accidental aliasing (when two variables unintentionally refer to the same object).
• Optimize memory usage by reusing objects when possible.
• Ensure correct object copying when needed.

By understanding object identity and memory management, you can write more efficient and bug-free Python code!

Key Takeaways

• id() returns an object’s memory address during its lifetime in Python.
• Immutable objects (like integers, strings, and tuples) may share memory if they have the same value, thanks to Python’s optimization techniques.
• Mutable objects (like lists, dictionaries, and sets) always get unique memory addresses, even if they contain identical values.
• id() is a powerful tool for debugging, helping you track object references, aliasing issues, and memory allocation in Python.

Understanding how Python manages memory can improve your code efficiency and help you avoid tricky bugs!

Conclusion

Python’s id() function is a simple but powerful tool that helps you understand how objects are stored in memory. By checking an object’s unique identifier, you can detect aliasing issues, optimize memory usage, and debug unexpected behavior—especially when working with mutable and immutable objects.

Knowing when Python reuses objects (like small integers and strings) and when it creates new ones (like lists and dictionaries) can make your code more efficient and bug-free. The next time you run into a reference issue, try using id()—it might just save you hours of debugging!

FAQs

External Resources

If you want to explore more about Python’s id() function and memory management, check out these helpful resources:

• 📖 Official Python Documentation – id() Function
  Learn how id() works directly from Python’s official documentation.

About The Author

Emmimal Alexander

Emmimal Alexander is an AI & Machine Learning Expert, passionate educator, and the author of “Neural Networks and Deep Learning with Python.” As the founder of EmiTechLogic, she’s on a mission to make complex tech topics accessible, engaging, and empowering for learners at every level.

With deep expertise in Python, HTML, JavaScript, and CSS, Emmimal brings a strong coding foundation to her tutorials and educational resources. Her work focuses on blending theoretical understanding with real-world application—so readers not only learn how things work, but also why they matter.

Through EmiTechLogic, she creates hands-on guides, detailed breakdowns, and project-based learning content that bridges the gap between academic concepts and practical implementation. Whether you’re exploring AI for the first time or fine-tuning your neural networks, you’re in the right place.

See author's posts