Python

Variables and Memory Management

A structured, from-first-principles guide to how Python variables and memory really work — references, stack vs heap, copying, garbage collection, memory optimization, scope, function argument passing, and real-world DevOps examples.

Read and practice Coding practice Python Roadmap Interview Revision

Python learning path

Explore Variables and Memory Management

← Python Fundamentals

6.1 Introduction to Variables

What a variable really is underneath the syntax, why that matters for memory behavior, and a map of the deeper reference, memory, and scope topics this chapter covers.

6.2 Objects and Variable References

Why a Python variable is a label pointing at an object rather than a box holding a value, what that means for reference assignment, and why shared references to mutable objects are a common source of bugs.

6.3 Memory Management: Stack vs Heap

How CPython splits memory between the call stack (frame references) and the heap (actual object data), and why that split explains reference semantics when passing variables into functions.

6.4 Assignment Operations

Why all assignment in Python is reference assignment, why there's no true separate value-assignment mechanism, and how that plays out differently for mutable versus immutable objects.

6.5 Copying Objects

The difference between assignment, a shallow copy, and a deep copy in Python, when each is appropriate, and how the copy module's copy() and deepcopy() behave differently on nested mutable objects.

6.6 Garbage Collection

How CPython's reference-counting memory manager works, why a supplementary cyclic garbage collector exists for reference cycles, and how to use del and the gc module.

6.7 Memory Optimization

CPython's automatic object-reuse optimizations — string interning and small integer caching — why they exist, and why they're implementation details you should never rely on for correctness.

6.8 Variable Scope

Local, global, and enclosing scope in Python, the global and nonlocal keywords, and the LEGB rule Python uses to resolve any name.

6.9 Lifetime of Variables

When a Python variable's lifetime begins and ends, how the del statement differs from letting a scope exit naturally, and how lifetime connects to garbage collection.

6.10 Variables in Functions

How Python passes arguments into functions, why mutable and immutable arguments behave differently when modified inside a function, and the return-value pattern that follows from it.

6.11 Variables in DevOps

How configuration variables, environment variables, secrets, AWS credentials, and Terraform variables are managed in real DevOps Python scripts, instead of hardcoding environment-specific values.

6.12 Common Mistakes

The most common variable and memory-related bugs in Python — UnboundLocalError, shared mutable objects, variable shadowing, and assuming Python has block scope.

6.13 Best Practices

Practical habits for writing memory-safe, readable Python — meaningful names, avoiding global state, using constants, and memory-efficient coding for long-running scripts.

6.14 Interview Questions

Frequently asked and scenario-based Python interview questions covering references, shallow vs deep copy, UnboundLocalError, the LEGB rule, and reference counting vs garbage collection.

6.15 Hands-on Exercises

Practice programs and mini projects for reinforcing Python variable and memory management concepts — UnboundLocalError, shallow vs deep copy, closures, environment-based configuration, and reference tracing.

Variables and Memory: Chapter Practice

Apply variables and memory with a mini lab and knowledge check.