- [Instructor] We can use Boolean expressions
to ask questions in our programs,
but how can we branch control flow based on the answer?
To do that, we need conditionals.
Conditionals form the basis of selection.
They allow the computer to decide
which code to run depending on whether the answer
to a specific question or condition is true or false.
The first piece of a conditional is the IF statement.
We start an IF statement with the keyword If.
Then we add our condition,
which can be any boolean expression.
We always end this line with a colon
because an IF statement comes in two parts.
This first part, which is the condition
and the second part, which is the instructions to run
if that condition evaluates to true.
In Python, we indicate those instructions using indentation.
Any lines of code immediately following that condition
that are indented one level in
are considered inside that IF statement,
if the condition evaluates to true,
the computer will go on to execute all of the instructions
indented inside the IF statement in order.
When it's done, it'll go on to execute
the rest of the program as normal.
If the condition evaluates to false,
the computer will skip all the lines of code
that are indented inside of that IF statement.
Instead, it'll jump directly to the next line of code
that's outside of the IF statement.
That means the first line of code
that is indented at the same level
as that initial if.
Let's try an example.
Here we have the Boolean expression,
num_orders equals equals 10, which asks the question,
is this the customer's 10th order?
We can then use this Boolean value in our IF statement.
We'll indent one print function call
inside of the IF statement and one outside.
The one inside will only execute if it is the 10th order,
that is if the variable is 10th order
contains the Boolean value True.
We can also write this without the variable
where we just inline that whole Boolean expression
in the IF statement.
Let's trace how the computer executes this.
It starts with the first line
and assigns a value 10 to the variable num_orders.
Then it hits this IF statement,
so first it evaluates the Boolean expression.
10 is equal to 10, so this evaluates to true.
Because it's true,
the computer will execute the lines of code
indented inside of the IF statement.
First, it'll print, "Your order is free!"
And then it'll assign the value zero
to the variable num_orders.
Then it just keeps moving through
the rest of the program in order,
so it'll print the value of num_orders, which is now zero.
Now let's say instead num_orders
was originally set to three.
When the computer executes this program,
it'll assign the value three to num_orders,
evaluate the Boolean expression.
Three is not equal to 10, so this is false,
and then because it's false,
we'll skip the lines of code indented
inside the IF statement.
It'll jump to the next line of code outside,
which is print num_orders, so it'll print three.
Note that if we didn't indent the line of code
num_orders equal zero, it would be considered
outside of the IF statement, so in the false case,
num_orders would be set to zero,
and then it would print zero.
In the true case, we would print, "Your order is free."
Then we would set num_orders to zero,
and then we would print zero.
You can write IF statements with any Boolean expressions
as conditions, and you can put any
and as many instructions as you want inside of them.
With this conditional, I could make sure
to only ask the follow-up question,
chicken or tofu, if the user ordered pad Thai,
because if they order the papaya salad,
that question doesn't make sense.
Note that in most IDEs we indent using the tab key.
Our standard lines of code
should line up directly with the left margin.
That is, there should be no spaces or indents before them.
Lines of code indented inside of an IF statement
should be one tab key over.
Getting the indentation right is crucial
because this is the only way we can tell the computer
which lines of code are inside the IF statement
and which are outside.
We need to be careful here though
because now our control flow branches.
If the user orders pad Thai, this program works fine,
but if the user orders something else, we get a name error.
The variable protein is only defined
inside the IF statement.
If the condition is false,
this assignment statement doesn't execute,
so the computer doesn't know a variable protein.
To fix this, we either need to make sure
we're only accessing the variable protein
inside the IF statement where we're guaranteed it exists,
or we need to initialize the variable protein
before the IF statement,
which guarantees that it's always defined.
It's common in situations like this
to initialize the variable
to an empty or placeholder value
like the empty string or no protein.
Now there's no error on either possible path.
If the order is equal to pad Thai or if it's not.
Now that our control flow branches, when we run a program,
we're only testing one
of perhaps many possible passive execution through the code.
Just because it works for one case
doesn't mean it works for the other,
and it's up to us to test for that.
Otherwise, it'll be our users who suffer
when they're the first ones to find the bug.