In this lesson, we'll learn how to create programs that generate different outcomes based on user input!

Conditionals & Control Flow

The boolean operator `or` returns `True` when at least one expression on either side of `or` is true. For example:

* `1 < 2 or 2 > 3` is `True`;
* `1 > 2 or 2 > 3` is `False`.

The boolean operator `and` returns `True` when the expressions on both sides of `and` are true. For instance:

* `1 < 2 and 2 < 3` is `True`.
* `1 < 2 and 2 > 3` is `False`.

Just like in real life, sometimes we'd like our code to be able to make decisions.

The Python programs we've written so far have had one-track minds: they can add two numbers or `print` something, but they don't have the ability to pick one of these outcomes over the other.

**Control flow** gives us this ability to choose among outcomes based on what else is happening in the program.

Go With the Flow

`elif` is short for "else if." It means exactly what it sounds like: "otherwise, if the following expression is true, do this!"

```py
if 8 > 9:
  print "I don't get printed!"
elif 8 < 9:
  print "I get printed!"
else:
  print "I also don't get printed!"
```

In the example above, the `elif` statement is only checked if the original `if` statement is `False`.

I Got 99 Problems, But a Switch Ain't One

Great work! We're almost done with boolean operators.

```py
# Make me false
bool_one = (2 <= 2) and "Alpha" == "Bravo"
```

Mix 'n' Match

The `else` statement complements the `if` statement. An `if`/`else` pair says: "If this expression is true, run this indented code block; otherwise, run this code after the else statement."

Unlike `if`, `else` doesn't depend on an expression. For example:

```py
if 8 > 9:
  print "I don't get printed!"
else:
  print "I get printed!"
```

Else Problems, I Feel Bad for You, Son...

Let's get some practice with `if` statements. Remember, the syntax looks like this:

```py
if some_function():
  # block line one
  # block line two
  # et cetera
```

Looking at the example above, in the event that `some_function()` returns `True`, then the indented block of code after it will be executed. In the event that it returns `False`, then the indented block will be skipped.

Also, make sure you notice the colons at the end of the `if` statement. We've added them for you, but they're important.

If You're Having...

Tables of the possible input and output for the AND, OR, and NOT operators. 

**Boolean operators** compare statements and result in boolean values. There are three boolean operators:

1. `and`, which checks if both the statements are `True`;
2. `or`, which checks if at least one of the statements is `True`;
3. `not`, which gives the opposite of the statement.

We'll go through the operators one by one.

To Be and/or Not to Be

Boolean operators aren't just evaluated from left to right. Just like with arithmetic operators, there's an order of operations for boolean operators:

1. `not` is evaluated first;
2. `and` is evaluated next;
3. `or` is evaluated last.

For example, `True or not False and False` returns `True`. If this isn't clear, look at the Hint.

Parentheses `()` ensure your expressions are evaluated in the order you want. Anything in parentheses is evaluated as its own unit.

This and That (or This, But Not That!)

Comparisons result in either True or False, which are booleans as we learned before in <a href="https://www.codecademy.com/courses/learn-python/lessons/python-syntax/exercises/booleans" target="_blank">this exercise</a>.

```py
# Make me true!
bool_one = 3 < 5
```

Let's switch it up: we'll give the boolean, and you'll write the expression, just like the example above.

How the Tables Have Turned

Excellent! It looks like you're comfortable with basic expressions and comparators.

But what about *extreme* expressions and comparators?

Compare... Closelier!

`if` is a conditional statement that executes some specified code after checking if its expression is `True`.

Here's an example of `if` statement syntax:

```py
if 8 < 9:
  print "Eight is less than nine!"
```

In this example, `8 < 9` is the checked expression and `print "Eight is less than nine!"` is the specified code.

Pay attention to the indentation before the `print` statement. This space, called _white space_, is how Python knows we are entering a new _block_ of code. Python accepts many different kinds of indentation to indicate blocks. In this lesson, we use four spaces but elsewhere you might encounter two-space indentation or tabs (which Python will see as different from spaces). 

If the indentation from one line to the next is different and there is no command (like `if`) that indicates an incoming block then Python will raise an `IndentationError`. These errors could mean, for example, that one line had two spaces but the next one had three. Python tries to indicate where this error happened by printing the line of code it couldn't parse and using a `^` to point to where the indentation was different from what it expected.

Conditional Statement Syntax 

Let's start with the simplest aspect of control flow: **comparators**. There are six:

**Equal to** (`==`)

```py
>>> 2 == 2
True
>>> 2 == 5
False
```

**Not equal to** (`!=`)

```py
>>> 2 != 5
True
>>> 2 != 2
False
```

**Less than** (`<`)

```py
>>> 2 < 5
True
>>> 5 < 2
False
```

**Less than or equal to** (`<=`)

```py
>>> 2 <= 2
True
>>> 5 <= 2
False 
```

**Greater than** (`>`)

```py
>>> 5 > 2
True
>>> 2 > 5
False
```

**Greater than or equal to** (`>=`)

```py
>>> 5 >= 5
True
>>> 2 >= 5
False
```

Comparators check if a value is (or is not) equal to, greater than (or equal to), or less than (or equal to) another value.

Note that `==` compares whether two things are equal, and `=` assigns a value to a variable.

Compare Closely!

Really great work! Here's what you've learned in this unit:

**Comparators**

```py
3 < 4
5 >= 5
10 == 10
12 != 13
```

**Boolean operators**

```py
True or False 
(3 < 4) and (5 >= 5)
this() and not that()
```

**Conditional statements**

```py
if this_might_be_true():
  print "This really is true."
elif that_might_be_true():
  print "That is true."
else:
  print "None of the above."
```

Let's get to the grand finale.

The Big If

The boolean operator `not` returns `True` for false statements and `False` for true statements.

For example:

* `not False` will evaluate to `True`, while `not 41 > 40` will return `False`.