Expressions and the Arithmetic Operators

An expression is any piece of code that the computer evaluates to a single value. The value 5 is an expression, the variable x is an expression, and 3 * x + 1 is an expression too. When a program runs, it replaces the whole expression with the one value it produces, and an algorithm can then store that value, display it, or test it. This is the idea the CED calls out: expressions evaluate to a value, and algorithms are built out of them.

AP Computer Science Principles uses five arithmetic operators. Four are the ones you already know: + for addition, - for subtraction, * for multiplication, and / for division. The fifth is MOD, which gives the remainder after division. In Python the MOD operator is written %, but the AP exam reference sheet writes it as the word MOD. They mean exactly the same thing.

a = 7
b = 2
print(a + b)
print(a - b)
print(a * b)

a <- 7
b <- 2
DISPLAY(a + b)
DISPLAY(a - b)
DISPLAY(a * b)

Notice that each operator combines two values and produces one new value. Because an expression is always worth a single value, you can nest expressions inside larger expressions: the result of a + b can itself be multiplied, compared, or stored. That composability is what lets a short line of math do real work inside an algorithm.

Order of Operations

When an expression mixes operators, the computer does not simply work left to right. It follows a fixed order of operations, the same precedence you learned in math class:

1. Parentheses first: anything inside ( ) is evaluated before it is used.
2. Then multiplication, division, and MOD (*, /, %), left to right.
3. Then addition and subtraction (+, -), left to right.

print(2 + 3 * 4)
print((2 + 3) * 4)
print(20 - 6 / 2)

DISPLAY(2 + 3 * 4)
DISPLAY((2 + 3) * 4)
DISPLAY(20 - 6 / 2)

The first line prints 14 because 3 * 4 is done before the +. The second line prints 20 because the parentheses force 2 + 3 first. The third line prints 17.0 because 6 / 2 runs before the subtraction. If you ever want a different order, add parentheses, they are the one tool that always overrides precedence.

print(2 + 3 * 4)

MOD: the Remainder Operator

MOD (written % in Python) gives the amount left over after a division. For example 17 % 5 is 2, because 5 goes into 17 three times with 2 left over. The result of a % b is always between 0 and b - 1 for the non-negative values you will meet on the exam, which is exactly why MOD is so useful for cycling and classifying numbers.

n = 47
print(n % 2)    # 1  -> n is odd
print(n % 10)   # 7  -> the last digit

n <- 47
DISPLAY(n MOD 2)    # 1  -> n is odd
DISPLAY(n MOD 10)   # 7  -> the last digit

Three patterns come up constantly, and each is worth memorizing:

• Even or odd: n % 2 is 0 when n is even and 1 when n is odd.
• Last digit: n % 10 gives the ones digit of a whole number, for example 3947 % 10 is 7.
• Wrapping or cycling: n % k keeps a value in the range 0 to k - 1, which is how clocks, calendars, and turn counters loop back around.

n = 8
print(n % 2)

Division Three Ways: / vs // vs %

Division is where Python trips people up, because Python has three different operators and the AP exam cares about the difference between the values they produce.

• / is float division. It always produces a decimal (a float), so 7 / 2 is 3.5 and even 6 / 2 is 3.0, not 3.
• // is integer (floor) division. It divides and then drops the fractional part, so 7 // 2 is 3. This is the AP pseudocode idea of a whole-number quotient.
• % is MOD, the remainder that is left over, so 7 % 2 is 1.

# three ways to "divide" in Python
print(7 / 2)    # float division  -> 3.5
print(7 // 2)   # integer division -> 3
print(7 % 2)    # remainder (MOD)  -> 1

# AP pseudocode has two operators
DISPLAY(7 / 2)     # division -> 3.5
DISPLAY(7 MOD 2)   # remainder -> 1

Together, // and % split a division into its two parts: 7 // 2 is how many whole 2s fit (3) and 7 % 2 is what is left over (1). AP pseudocode writes remainder as MOD and a plain / for division, so when you translate pseudocode to Python you must decide whether the problem wants the decimal answer (/) or the whole-number answer (//).

print(7 / 2)

Key Vocabulary