Variables and Values

Start with the smallest useful assignment

Here is a complete example:

customer_name = "Maya"
item_count = 3

print(customer_name)
print(item_count)

Maya
3

Python evaluates "Maya", then binds the name customer_name to that string object. It evaluates 3, then binds item_count to that integer object. Later, print(item_count) asks Python to look up the current object associated with the name.

Reassignment changes the binding

Programs change state. A cart can gain an item, a status can move from pending to shipped, and a running total can increase. Python handles this by letting a name be assigned again.

item_count = 3
item_count = item_count + 1
print(item_count)

4

The second line is often confusing if you read it like school algebra. Python does not ask whether item_count equals itself plus one. It first reads the current value of item_count, calculates 3 + 1, gets 4, then rebinds item_count to the integer object 4.

A realistic example: order state

status = "pending"
print(status)

status = "paid"
print(status)

pending
paid

The name stayed the same; the value it refers to changed. That is useful when a variable represents the current state of something.

Choose names that explain the job

Python will accept many legal names, but readable code needs more than legal syntax. Compare x = 3 with retry_count = 3. The second name tells another reader what the value means.

x = 3
y = 19.99
z = False

item_count = 3
cart_total = 19.99
is_paid = False

Python variable names can contain letters, digits, and underscores, but they cannot begin with a digit. Names are case-sensitive, so total and Total are different names. For ordinary variables, Python code usually follows snake_case: lowercase words separated by underscores.

Using a name before binding it raises NameError

If Python cannot find a binding for a name, it cannot guess what value you intended.

print(order_total)

NameError: name 'order_total' is not defined

This error is often simpler than it first appears. Check whether the assignment runs before the use, whether you misspelled the name, and whether the value lives inside a function scope that is not available where you are trying to read it.

Common typo

item_count = 3
print(items_count)

item_count = 3
print(item_count)

Python can bind several names in one statement

Python supports multiple assignment:

customer_name, item_count = "Maya", 3
print(customer_name)
print(item_count)

Maya
3

The expressions on the right are evaluated before the target names are assigned. That is why this compact swap works:

left = "A"
right = "B"
left, right = right, left
print(left, right)

B A

This is useful Python syntax, but do not compress assignments merely to look clever. Separate lines are often better when each value has a different meaning or deserves its own explanation.

The important trap: assignment does not copy mutable data

This is the point where the simple “variable is a box” analogy begins to break down. Two names can refer to the same mutable object. A list is mutable, which means its contents can change after creation.

items = ["book", "pen"]
backup = items

backup.append("notebook")

print(items)
print(backup)

['book', 'pen', 'notebook']
['book', 'pen', 'notebook']

Why did items change? Because backup = items did not create another list. It created another name pointing to the existing list. The official Python tutorial describes this directly: simple assignment never copies data.

If you need a separate list, make a copy deliberately

items = ["book", "pen"]
backup = items.copy()

backup.append("notebook")

print(items)
print(backup)

['book', 'pen']
['book', 'pen', 'notebook']

A name can later refer to an object of another type

Python is dynamically typed. The object has a type; the variable name itself is not permanently declared as one type.

value = 10
print(type(value).__name__)

value = "ten"
print(type(value).__name__)

int
str

Python allows this, but frequent unrelated type changes can make code harder to understand. A name should usually keep one clear meaning. If customer_id begins as an integer identifier and later becomes a full customer dictionary, the name is no longer communicating a stable contract.

Predict before you run it

count = 2
old_count = count
count = count + 1
print(count)
print(old_count)

Now compare that with the list aliasing example above. That contrast—rebinding a name versus mutating a shared object—is one of the most useful mental models you can build early in Python.

Quick recap

• A Python variable is a name bound to an object.
• Assignment evaluates the right-hand side, then binds the target name.
• Reassignment changes what a name refers to; it does not rewrite the old object.
• Using an unbound name raises NameError.
• Simple assignment does not copy mutable data; two names can refer to the same list.

Try it yourself

1. Create product_name, unit_price, and quantity. Print a sentence that uses all three values.
2. Start retry_count at 0, add one twice using reassignment, and predict the final value before running the code.
3. Create a list called primary. Assign secondary = primary, append through secondary, and explain why primary changes. Then repeat with primary.copy().
4. Create an intentional NameError, read the traceback, and fix the spelling or ordering mistake that caused it.