What a Variable Is

A variable is a named location that holds a value. The name is an abstraction: instead of repeating a raw value everywhere, you refer to it by a memorable name and let the program remember the actual value for you. When the CED says a variable is "an abstraction inside a program that can hold a value," this is exactly what it means (AAP-1.A).

You put a value into a variable with an assignment statement. In Python you use the single equals sign =. In AP pseudocode you use the left arrow <-. Both mean the same thing: take the value on the right, and store it in the variable named on the left (AAP-1.B).

color = "blue"
count = 3
print(count)

color <- "blue"
count <- 3
DISPLAY(count)

After these two assignments, color holds the text "blue" and count holds the number 3. The statement print(count) shows the value stored in count, which is 3. It does not show the letters "count"; the variable name is just a label for the value inside.

Assignment Replaces the Old Value

A variable holds exactly one value at a time. When you assign a new value, the previous value is replaced and is gone. There is no memory of what used to be there; only the most recent assignment survives.

x = 10
x = 25
print(x)

x <- 10
x <- 25
DISPLAY(x)

The first line stores 10 in x. The second line stores 25 in x, overwriting the 10. By the time print(x) runs, the only value x holds is 25, so 25 is displayed. The 10 was thrown away the instant the second assignment happened.

x = 10
x = 25
print(x)

Updating a Variable Using Itself

One of the most useful patterns is updating a variable based on its own current value, like count = count + 1. At first this looks impossible, as if the variable is being defined in terms of itself. The trick is the order of operations: the right side is fully evaluated first, using the current (old) value, and only then is the result stored back into the variable.

count = 5
count = count + 1
print(count)

count <- 5
count <- count + 1
DISPLAY(count)

Here count starts at 5. On the update line, Python first computes the right side count + 1, which uses the current value 5 to get 6. Then it stores that 6 back into count, replacing the 5. So the final value is 6. The variable on the left is not touched until the right side is finished.

x = 4
x = x + 3
print(x)

Tracing Sequential Assignments

When several assignments run one after another, trace them with a variable table: one column per variable, one row per line, and you rewrite a cell only when that line changes it. Always evaluate the right side using the values in the current row before you write the new value.

total = 0
total = total + 10
total = total + 5
print(total)

total <- 0
total <- total + 10
total <- total + 5
DISPLAY(total)

Trace it line by line: total starts at 0. The next line computes 0 + 10 and stores 10. The next computes 10 + 5 and stores 15. So print(total) shows 15.

t = 3
t = t + 4
t = t * 2
print(t)

Swapping Two Variables

Suppose a holds 1 and b holds 9, and you want them to trade values. The natural first attempt, a = b then b = a, does not work. The moment you run a = b, the old value of a is overwritten and lost, so the second line just copies the value back. Both variables end up the same.

The fix is a temporary variable. Save the first value in temp before you overwrite it, then restore it into the second variable:

a = 1
b = 9
temp = a
a = b
b = temp
print(a, b)

a <- 1
b <- 9
temp <- a
a <- b
b <- temp
DISPLAY(a)
DISPLAY(b)

Now temp remembers the original 1 while a is overwritten with 9. Then b is set to temp, which is 1. The result is a real swap: a is 9 and b is 1. Compare that with the broken version that skips the temp holder:

# WRONG: no temp, one value is lost
a = 1
b = 9
a = b
b = a
print(a, b)

# RIGHT: hold the first value in temp
temp <- a
a <- b
b <- temp

Key Vocabulary