-
- [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.