Recipes That Compute a Value

An expression is a math phrase the computer works out to a single value. You do not just read it left to right. Times and divide go before plus and minus, so in 2 + 3 4 the computer does 3 4 first to get 12, then adds 2 for 14. If you want a different order, put parentheses around the part that should go first: (2 + 3) * 4 is 20 instead.

An expression combines values and operators into one computed value. Beyond + and - you get , /, and three more: // (floor division, which drops the remainder), % (the remainder itself), and (power). They do not all run left to right. Precedence ranks them: first, then , /, //, %, then + and -. Within one rank, work left to right. Parentheses beat every rank — whatever sits inside them is computed first. So 2 + 3 4 is 14, but (2 + 3) 4 is 20.

An expression evaluates to a single value that carries a type. Operators have a precedence and an associativity. In Python, * binds tightest and groups right to left; then unary minus; then , /, //, %; then + and -, each grouping left to right. Parentheses force any grouping you want. Type travels through the operators: true division / always gives a float, so 6 / 2 is 3.0, while // floors the result and % returns the remainder. Reading an expression means finding the one grouping the rules force, then reducing it step by step to a single typed value.

Numbers and signs make a little puzzle: 2 + 3. Work it out and you get one number, 5. Some signs go first. Times always comes before plus.

When the puzzle is done, the whole thing becomes one number. The computer keeps that one number and uses it next.

Picture an expression as a tree: operands at the leaves, operators at the internal nodes. Precedence and associativity are precisely the rules that decide which tree a flat line of text denotes, and evaluation is a post-order traversal — reduce each subtree to a value, then apply the operator above it. Operand types propagate upward: mixing int and float promotes to float, / yields a float even for whole operands, and // and % follow floor semantics. Once you see the tree, the apparent ambiguity of 2 + 3 * 4 disappears: the grammar admits exactly one parse, and that parse fixes the value.

Precedence and associativity are surface-syntax conventions that let a linear string denote a unique abstract syntax tree; without them the grammar would be ambiguous. Evaluation is then the denotation of that tree under an interpretation of the operator symbols — a compositional map from subterms to values. Two facts matter early: operators are overloaded, their behaviour selected by operand types at run time, and some are partial — division by zero denotes nothing and raises rather than returning a value. 'Follow the order of operations' is the informal name for computing the denotation of the one parse tree the precedence rules force.