- [Instructor] We can use
an IF statement to control

that a particular block
of code only executes

when the condition evaluates to true.

But what if we wanna do something else

only when the condition
evaluates to false?

Well, we can add another
IF statement and try

and construct a condition
that's the exact opposite

of the original condition.

That's a bit annoying

and sometimes the opposite
condition isn't obvious

or it's super long.

To save us the trouble,

Python instead lets us use an else branch.

We can stick an else branch
onto the end of any IF statement

and any instructions indented
inside the else branch

only execute if the corresponding
IF statements condition

evaluates to false.

That makes the IF branch

and the else branch mutually
exclusive based on the answer

to the condition,

the computer decides which
of the two paths to take.

The Python syntax for an else branch

is just the keyword else

followed by a colon.

Again, we use indentation
to tell the computer

which lines of code are
inside the else branch.

An else branch must always
follow an IF branch.

Otherwise, what are we
taking the opposite of?

Let's trace that execution path.

If the condition evaluates
to true as normal,

the computer goes on to
execute any instructions

indented inside that IF branch.

When it's done, execution
jumps to the next line of code

that's indented outside
of the conditional.

If the condition evaluates to false,

the computer skips the
rest of the IF branch

and jumps to the else branch.

Then it executes any lines
of code that are indented

inside the else branch.

When it's done, it just
continues execution

with the next line of code indented

outside of the conditional.

Note that this execution path

with an else branch is
different from this,

where we just have that
instruction indented outside

of the IF statement.

Here if the condition evaluates to true,

we print mobile layout,

then we jump outside of the conditional

and print desktop layout.

If the condition evaluates to false,

we skip the IF branch, jump
outside of the conditional

and print desktop layout.

Because the instruction is not indented

it's independent of the
conditional`, it always executes.

However, if we indent this instruction

inside an else branch instead,

we only print desktop
layout if the condition

evaluates to false.

If the condition evaluates to true,

we print mobile layout
and skip the else branch.

What if we have more than two cases

like a mobile tablet and a desktop layout?

We could try to construct three

mutually exclusive conditions
or we can take advantage

of a shortcut and use the elif branch.

The elif or else IF branch

allows us to chain multiple
conditions together.

Starting with the IF branch,

the computer evaluates
each condition in order

until it finds one that evaluates to true,

then it chooses that branch to execute.

Note that order matters here

because the computer will
stop checking other branches

as soon as it finds one
that evaluates to true.

If instead I put this condition first,

the IF branch would
capture any screen widths

that are smaller than 760.

That means that if I have a mobile screen

that's say 300 pixels,
it will get captured

by this first case and
print tablet layout.

The computer only ever chooses one branch.

It doesn't print mobile layout.

Even though that condition
would have evaluated to true.

We can attach as many
elif branches as we want

to any if branch and
then we can optionally

add an else branch at the end.

So we can see what the computer's doing

let's trace each possible execution path.

If the first condition evaluates to true,

then the computer chooses that branch

and it executes any instructions
indented inside of it.

Then it jumps to the next line of code

outside of the conditional.

If the first condition evaluates to false,

then the computer goes on
to check the next condition.

If the second condition evaluates to true,

then the computer chooses this branch

and executes any instructions
indented inside of it.

Then it jumps to the next line of code

outside of the conditional.

If the computer checks
the first condition,

finds that it evaluates to false,

then checks the second condition,

also finds that it evaluates to false,

then it moves on to the else branch else.

Else branches don't have a condition,

so if the computer
reaches it, it just runs.

So we execute the instructions indented

inside the else branch

and then we jump to the next line of code

outside of the conditional.

So if you have multiple related
conditions in your program,

it's generally better to use
a chain conditional with elif

and else branches instead
of several independent

single branch conditionals.

Chain conditionals make
programs easier to read

because it makes the relationship

between conditions obvious.

It reduces bugs because
we as the programmer

don't have to worry about
making sure all our conditions

are mutually exclusive and
cover all possible cases

and it saves the computer some work.

With independent conditions

that computer doesn't
know they're related,

so it'll evaluate every single
one, even if it's impossible

for multiple of them to be true.

With chain conditionals,

we give the computer the hint

that these are all mutually exclusive,

so it knows it can stop evaluating

as soon as it finds a branch
that evaluates to true.