How to Store Data in Memory in Python: Absolute Beginners Tutorial

Every program needs a way to remember information. When you write a Python script that calculates a total, greets a user by name, or tracks a score in a game, you need to store data somewhere the program can find it again. That somewhere is memory, and the tool Python gives you for labeling data in memory is called a variable.

This tutorial walks through the fundamentals of storing data in Python, starting with variable assignment and working up to how Python manages objects and references in memory. By the end, you will be able to create variables, choose good names for them, identify data types, and understand the relationship between a variable name and the object it points to.

What Is a Variable and Why Does It Matter?

A variable is a name you give to a piece of data so you can use it later. Think of it like a label on a storage container. The label is not the container itself, and it is not the item inside. It is just a way to find what you stored.

In Python, creating a variable is straightforward. You write a name, follow it with the = sign (called the assignment operator), and then provide the value you want to store.

username = "Ada"
score = 100
temperature = 36.6
is_active = True

print(username)     # Ada
print(score)        # 100
print(temperature)  # 36.6
print(is_active)    # True

Each line above creates a variable and assigns it a value. Python does not require you to declare the type of a variable before using it. The interpreter figures out the type based on the value you assign. This behavior is called dynamic typing, and it is one of the features that makes Python approachable for beginners.

You can also reassign a variable to a new value at any time. Python will simply redirect that name to point to a different object in memory.

color = "blue"
print(color)  # blue

color = "green"
print(color)  # green

# The variable can even change type
color = 42
print(color)  # 42

This flexibility is powerful, but it also means you need to keep track of what a variable currently holds. Using descriptive names helps with that.

How Python Stores Data Behind the Scenes

When you write score = 100, two things happen internally. First, Python creates an integer object with the value 100 and places it on a region of memory called the heap. Second, the name score is created as a reference that points to that object's memory address.

This is a crucial distinction: a Python variable is not a box that holds a value. It is a name tag attached to an object that lives somewhere in memory. Understanding this model helps explain several behaviors that confuse beginners.

a = 42
b = a

print(id(a))  # e.g., 140714055169672
print(id(b))  # same number — both point to the same object

print(a is b)  # True — they reference the identical object

When you write b = a, Python does not copy the value 42 into a new location. Instead, both a and b become labels attached to the same integer object. This is memory-efficient, and Python takes it further with a technique called interning: for small integers in the range -5 to 256, Python reuses the same objects instead of creating new ones.

What Happens When You Reassign?

If you later write a = 99, Python creates a new integer object for 99 and points the name a at it. The name b still references the original object 42. If no names reference an object anymore, Python's garbage collector eventually reclaims that memory.

a = 42
b = a
print(a is b)  # True

a = 99
print(a)       # 99
print(b)       # 42 — b still points to the original object
print(a is b)  # False — they now reference different objects

Data Types, Naming Rules, and Common Patterns

Python determines a variable's type automatically based on what you assign to it. You can check the type at any time using the built-in type() function.

x = 10
print(type(x))   # <class 'int'>

x = "hello"
print(type(x))   # <class 'str'>

x = [1, 2, 3]
print(type(x))   # <class 'list'>

Notice that the same variable name x held an integer, then a string, then a list. Python does not lock a variable to a single type. Each time you reassign, the name simply points to a new object of whatever type you provided.

Variable Naming Rules

Python enforces specific rules about what counts as a valid variable name. Breaking these rules results in a SyntaxError before your program even runs.

1. Must start with a letter or underscore. Names like age, _count, and User are valid. Names like 2fast or @handle are not.
2. Can only contain letters, digits, and underscores after the first character. The name score_2 works, but score-2 or score 2 will fail.
3. Case-sensitive. The names Total, total, and TOTAL are three completely different variables.
4. Cannot be a reserved keyword. Python reserves words like if, for, class, return, and import for its own syntax. Attempting to use them as variable names raises an error.

Common Assignment Patterns

Python supports several shorthand patterns for assigning variables that you will encounter frequently.

# Multiple assignment on one line
x, y, z = 10, 20, 30

# Assign the same value to multiple variables
a = b = c = 0

# Swap two variables without a temporary variable
x, y = y, x

# Delete a variable from the namespace
del z
# print(z) would now raise a NameError

The swap pattern x, y = y, x is particularly useful and is something Python handles more elegantly than languages that require a temporary holding variable.

"Namespaces are one honking great idea." — The Zen of Python (PEP 20)

Python Learning Summary Points

1. Variables in Python are references (name tags) that point to objects stored on the heap, not containers that hold values directly.
2. Python is dynamically typed, so you do not declare types in advance, and the same variable can be reassigned to different types.
3. Variable names must start with a letter or underscore, contain only alphanumeric characters and underscores, and must not use reserved keywords.
4. The id() function reveals the memory address of an object, and the is keyword checks whether two variables point to the same object.
5. Python reuses objects for small integers (-5 to 256) and certain strings through interning, making memory usage more efficient.
6. When no variable references an object, Python's garbage collector reclaims that memory automatically.

Understanding how Python stores data in memory is one of the foundational skills that will help you reason about your programs as they grow in complexity. With variables as your building blocks, you can now store, retrieve, and transform data throughout your Python programs.