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