Python Internals

To write efficient and bug-free Python code, it helps to understand how Python works under the hood. Let’s explore Python’s memory model, object references, and memory management.

Mutability vs. Immutability

Every variable in Python is a reference pointing to an object in memory. Objects are divided into two main categories:

1. Mutable Objects

A mutable object can be changed after it is created. Examples include:

Lists (list)
Dictionaries (dict)
Sets (set)

# Modifying a list in-place (same memory address)
numbers = [1, 2, 3]
print(id(numbers))     # e.g., 4398114048

numbers.append(4)
print(numbers)         # [1, 2, 3, 4]
print(id(numbers))     # 4398114048 (Address did not change!)

2. Immutable Objects

An immutable object cannot be changed after it is created. If you try to modify it, Python creates a new object at a new memory address. Examples include:

Integers (int), Floats (float)
Strings (str)
Tuples (tuple)
Booleans (bool)

# Modifying a string creates a new string object
name = "Alice"
print(id(name))        # e.g., 4398201904

name += " Smith"
print(id(name))        # e.g., 4398205424 (Different address!)

Precaution: Since tuples are immutable, you cannot change their elements. However, if a tuple contains a mutable object (like a list), the list elements can be modified!

my_tuple = (1, [2, 3])
my_tuple[1].append(4)  # This is allowed! Tuple now: (1, [2, 3, 4])

Everything is an Object

In Python, everything is a first-class object. This includes integers, strings, functions, modules, and even classes themselves. An object in Python contains three things:

A Value: The data itself (e.g., "Hello").
A Type: Defines what the object can do (e.g., <class 'str'>).
An Identity: A unique integer representing its memory address (retrieved via id()).

# Even a function is an object and can be assigned to a variable!
def greet():
    return "Hello!"

func_reference = greet
print(func_reference())   # Hello!
print(type(greet))        # <class 'function'>

Identity (`id()`) vs. Equality (`==`)

Understanding the difference between == and is is a common source of confusion:

Equality (==): Compares the values of the objects (uses the __eq__ method).
Identity (is): Compares the memory addresses of the objects (checks if both variables point to the exact same object in memory).

list_a = [1, 2, 3]
list_b = [1, 2, 3]

# 1. Values are equal
print(list_a == list_b)  # True

# 2. Identities are NOT equal (they are different objects in memory)
print(list_a is list_b)  # False
print(id(list_a) == id(list_b)) # False

Caching Nuance (Integer Caching): Python caches small integers (from -5 to 256) and small strings in memory for optimization.

x = 100
y = 100
print(x is y)  # True (due to CPython caching!)

a = 300
b = 300
print(a is b)  # False (different objects in memory)

Reference Counting

Python manages memory automatically using garbage collection. The primary mechanism used is Reference Counting.

Every object in memory keeps track of how many variables are referencing it.
When you assign an object to a variable, its reference count increases by 1.
When a variable goes out of scope or is deleted, the reference count decreases by 1.
When the reference count drops to 0, the object is destroyed, and the memory is reclaimed.

import sys

# Create a list object (Ref count = 1)
a = [1, 2, 3]

# Create another reference (Ref count = 2)
b = a

# sys.getrefcount() adds 1 temporary reference during call
print(sys.getrefcount(a))  # Output: 3

Circular References: If Object A references Object B, and Object B references Object A, their reference counts can never drop to 0 even if they are unreachable. Python uses an auxiliary Generational Garbage Collector to detect and destroy these circular references.

Practice & Exercises

To reinforce what you’ve learned in this section (Mutability, object types/identities, caching optimizations, and reference counting), practice with these interactive notebooks:

Follow-Along Practice

Practice defining mutable and immutable objects, tracking id values, appending mutable sub-items inside tuples, comparing equal values vs identities, and tracking reference counts.💻 VS Code | 🚀 Colab | 📥 Download

Practice Exercises

Test your knowledge with hands-on exercises on extending mutable lists, editing nested tuple elements, evaluating dictionary identities, and verifying small integer cache limits.💻 VS Code | 🚀 Colab | 📥 Download

What’s next?

Now that you understand Python’s internal memory structures, let’s learn how functions are treated as objects, closures, and writing custom decorators!

Advanced Functions

Master lambdas, closures, and decorators

Advanced Concepts

Pydantic

Mutability vs. Immutability

1. Mutable Objects

2. Immutable Objects

Everything is an Object

Identity (`id()`) vs. Equality (`==`)

Reference Counting

Practice & Exercises

Follow-Along Practice

Practice Exercises

What’s next?

Advanced Functions

​Mutability vs. Immutability

​1. Mutable Objects

​2. Immutable Objects

​Everything is an Object

​Identity (id()) vs. Equality (==)

​Reference Counting

​Practice & Exercises

Follow-Along Practice

Practice Exercises

​What’s next?

Advanced Functions

Mutability vs. Immutability

1. Mutable Objects

2. Immutable Objects

Everything is an Object

Identity (`id()`) vs. Equality (`==`)

Reference Counting

Practice & Exercises

What’s next?