Now let's define directives, statements and expressions. You already know what all of these are, but we need to make your understanding of them less fuzzy and more concrete.

Directives

import math

Note: code above will display with syntax highlighting once submitted.

import is a directive. Directives don't actually do anything immediately - they're "meta-commands". They tell the Python interpreter something you want it to do, not the program directly. This directive, for example, says "get the math library ready for me to use."

Statements

We've already referred to something like this...

x = 3.0 * 9.0 + 5.0

Note: code above will display with syntax highlighting once submitted.

...as an assignment statement. A statement is an actual command to the computer that actually does something with an actual effect: print output, move a turtle, ask for input, set a value, etc., etc.

In this case, our statement resets the value of the variable x to the value of the statement's right hand side.

Expressions

On that right hand side is the expression 3.0 * 9.0 + 5.0. Expressions are code, but they don't do anything - they are something. They take on, "express", or return values.

The most obvious form is the ordinary arithmetic expression. This works the way you think it does, mostly. In ordinary calculation you'd write or think:

$LaTeX: \text{(3 * 9 + 5) = (27 + 5) = 32}$

This is exactly what the computer does, before taking that final value 32 (32.0, really, if it's a float) and storing it into x. 32.0 is the value that the expression returns, and therefore the value assigned into x.

Now we see why only the right hand side of an assignment can be an expression. The left hand side has to be a variable, otherwise there's nowhere to put the right hand side's results.

Statements and Expressions

So an assignment statement has the form:

And the effect of it is to copy the value of the expression into the variable.

We can think about expressions this way too. They're often simple enough that we don't bother, but:

<expression> + <expression>
<expression> / <expression>
(<expression>)

All of these are forms of arithmetic expression, and you already know exactly what they do.

Substitution Again

Expressions can't go on the left of an assignment, but variables very much can go on the right:

y = x * 2.0

Note: code above will display with syntax highlighting once submitted.

Here, the "x" actually serves as a simple expression that returns its current value (32.0) into the expression on the right hand side. The evaluation completes and y receives the final result of 64.0. This works - very intentionally - exactly like variable substitution in ordinary arithmetic.

Things to Try

Intentionally create an expression complicated enough that you can't understand what it does by looking at it.
Consider: Using intermediate variables, how can you break down that messy expression into smaller, more understandable chunks?
Do that!
In general, keep expressions simple. You should always be able to tell what a line of code does by looking at it.

What Not to Do (Usually)

Statements can also act as expressions. This fact is sometimes useful but mostly just serves to cause trouble.
Avoid using statements as expressions in general.