Python Object Internals Tutorial – How Objects Work in Memory, Attributes, and Identity

Python Object Internals

In Python, everything is an object—numbers, strings, functions, classes, and even modules.

But what happens behind the scenes when you create an object?

Python manages objects using an internal system involving:

• Memory allocation
• Object identity
• Attribute storage
• Reference counting
• Garbage collection

Understanding object internals helps you write more efficient and professional Python code.

---

What is a Python Object?

A Python object is a block of memory that contains:

• Type (what kind of object it is)
• Value (data stored)
• Reference count (how many references point to it)

---

1. Object Identity (id())

Every object has a unique identity.

x = 10
y = 10

print(id(x))
print(id(y))

---

Important Note

Small integers and strings may share memory due to optimization.

---

2. Object Type (type())

Every object has a type.

x = "Python"

print(type(x))

Output

<class 'str'>

---

3. Object Memory Model

Python stores objects in memory and manages them automatically.

Concept:

Variable → Reference → Object (Memory)

---

4. Reference Counting

Python keeps track of how many references point to an object.

import sys

x = []
print(sys.getrefcount(x))

---

When Reference Count Becomes 0

The object is deleted automatically.

---

5. Garbage Collection

Python automatically cleans unused objects.

It handles:

• Circular references
• Memory cleanup
• Resource management

import gc

gc.collect()

---

6. Object Attributes (dict)

Objects store attributes in a dictionary called __dict__.

class Person:
    def __init__(self):
        self.name = "John"

p = Person()

print(p.__dict__)

Output

{'name': 'John'}

---

7. Dynamic Attribute Assignment

Python allows adding attributes at runtime.

class Car:
    pass

c = Car()
c.brand = "Toyota"

print(c.brand)

---

8. slots Optimization

Using __slots__ reduces memory usage.

class Person:
    __slots__ = ["name", "age"]

    def __init__(self, name, age):
        self.name = name
        self.age = age

---

Benefits of slots

• Less memory usage
• Faster attribute access
• Prevents dynamic attribute creation

---

9. Object Comparison (== vs is)

Value Comparison

a = [1, 2]
b = [1, 2]

print(a == b)

Output

True

---

Identity Comparison

print(a is b)

Output

False

---

10. Interning Optimization

Python reuses immutable objects like small integers.

a = 256
b = 256

print(a is b)

---

11. Object Lifecycle

1. Creation
2. Initialization
3. Usage
4. Deletion (Garbage collection)

---

12. del Method

Called when an object is destroyed.

class Demo:
    def __del__(self):
        print("Object destroyed")

d = Demo()
del d

---

13. Object Introspection

Python allows inspecting objects at runtime.

Example

x = 10

print(dir(x))

---

14. Built-in Object Functions

Function	Purpose
id()	Object identity
type()	Object type
dir()	Attributes list
vars()	dict access
isinstance()	Type checking

---

15. vars() Function

class Test:
    def __init__(self):
        self.x = 10

t = Test()

print(vars(t))

---

16. Memory Efficiency in Python

Python uses:

• Object pooling
• Reference counting
• Garbage collection
• Interning optimization

---

Real-World Applications

Object internals are important in:

• Framework development
• Memory optimization
• Large-scale applications
• Machine learning systems
• Game engines
• Performance tuning

---

Advantages of Understanding Object Internals

• Better debugging
• Efficient memory usage
• Cleaner architecture
• Faster applications
• Advanced Python mastery

---

Common Mistakes

Misusing is instead of ==

a = [1, 2]
b = [1, 2]

print(a is b)  # Wrong for value comparison

---

Modifying dict incorrectly

Avoid direct manipulation unless necessary.

---

Best Practices

• Use == for value comparison
• Use is for identity checks
• Prefer __slots__ for memory-heavy applications
• Avoid unnecessary dynamic attributes
• Use introspection tools carefully

---

Summary

Python object internals include identity, memory management, attributes, reference counting, and garbage collection. Understanding these concepts helps developers write more efficient and optimized Python programs.

---

Conclusion

Python objects are powerful and flexible because of their internal architecture. By understanding how objects work behind the scenes, you can build faster, cleaner, and more professional applications while avoiding common memory and performance issues.