Summary  
This chapter covers CPython’s memory optimizations for reusing small integer objects (–5 to 256) and automatically or manually interning strings, explains how these affect object identity vs value equality comparisons, and shows when to use `is` versus `==`.  

General domain of usage  
Memory optimization in large-scale data processing (e.g., interning repeated column names in big datasets)

CPython pre-allocates certain objects and reuses them instead of creating new ones. Two of the most impactful optimizations are the **small integer cache** and **string interning**. Understanding them prevents subtle bugs and explains surprising `is` comparison results.

Watch this video to learn how CPython optimizes memory usage using the small integer cache and string interning. You'll see why integers from -5 to 256 are always the same object, how string interning works for identifier-like strings, and why using `is` and `==` can produce different results. The video uses clear code examples to show these optimizations in action and explains how they impact both memory and performance in Python applications.

- video metadata (use this info when making a video) --
Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 10 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally.
If code is longer than 8 lines, move code output  blocks to second column.

## The Small Integer Cache

CPython pre-allocates integer objects for values in the range **-5 to 256** at interpreter startup. Any time your code uses one of these values, it gets a reference to the cached object – no new allocation happens.

# Demonstrating the small integer cache
transaction_a = 100
transaction_b = 100
print(transaction_a is transaction_b)   # True – same cached object

large_a = 1000
large_b = 1000
print(large_a is large_b)              # False – two separate objects

`is` checks object identity (same memory address), not equality. Outside the cached range, two variables holding the same integer value point to different objects.

import sys

# Verifying that small integers share identity
cached_value = 42
another_ref = 42
print(sys.getrefcount(cached_value))   # High – many things reference 42

large_value = 1000
another_large = 1000
print(large_value is another_large)    # False – different objects
print(large_value == another_large)    # True – same value

Always use `==` to compare values. Use `is` only to check identity (e.g., `is None`, `is True`, `is False`).

## String Interning

CPython automatically interns string literals that look like valid Python identifiers – strings containing only letters, digits, and underscores. Interned strings share a single object in memory.

# Automatic interning of identifier-like strings
department_a = "engineering"
department_b = "engineering"
print(department_a is department_b)    # True – interned automatically

# Strings with spaces are not automatically interned
label_a = "Q1 Revenue"
label_b = "Q1 Revenue"
print(label_a is label_b)             # False – not interned (contains space)
print(label_a == label_b)             # True – values are equal

## Manual Interning with `sys.intern()`

You can force interning of any string using `sys.intern()`. This is useful when the same string is repeated thousands of times – for example, column names in a large dataset:

import sys

# Interning repeated column names to save memory
column_names_raw = ["revenue", "cost", "revenue", "profit", "cost", "revenue"]

# Without interning – potentially multiple objects per unique string
without_intern = column_names_raw

# With interning – guaranteed single object per unique string
with_intern = [sys.intern(name) for name in column_names_raw]

# Verifying identity after interning
print(with_intern[0] is with_intern[2])   # True – same interned object
print(with_intern[1] is with_intern[4])   # True – same interned object

In a dataset with millions of rows and a small set of repeated string values, interning can reduce memory usage significantly.

Which comparison operator should always be used to check if two variables hold the same value?

Master the skills needed to understand Python's memory management internals and performance optimization techniques. This course is designed for intermediate and advanced Python developers who want to understand how Python handles memory, write memory-efficient code, detect and fix memory leaks, and optimize performance in real-world applications.

Explore the essentials of Python's memory management, including reference counting, garbage collection, and memory allocation strategies.

Get hands-on experience with practical techniques for writing memory-efficient Python code, including specialized data structures and tools for controlling object lifecycle.

Master the skills needed to profile memory usage and detect memory leaks in Python applications.

Explore the essentials of advanced memory and performance optimization patterns, including object interning, memory inspection tools, and the GIL's impact on memory access.

Small Integer Cache and String Interning

The Small Integer Cache

String Interning

Manual Interning with `sys.intern()`

Integer Cache vs String Interning

Small Integer Cache and String Interning

The Small Integer Cache

String Interning

Manual Interning with sys.intern()

Integer Cache vs String Interning

Manual Interning with `sys.intern()`