Python if Statements
Tags: python, programming, tutorial, beginners
Published: 2022-04-24 00:24:09

Programming often involves examining a set of conditions and deciding which action to take based on those conditions. Python’s if statement allows you to examine the current state of a program and respond appropriately to that state.

## A Simple Example

The following short example shows how if tests let you respond to special situations correctly. Imagine you have a list of cars and you want to print out the name of each car. Car names are proper names, so the names of most cars should be printed in title case. However, the value 'bmw' should be printed in all uppercase. The following code loops through a list of car names and looks for the value 'bmw'. Whenever the value is 'bmw', it’s printed in uppercase instead of title case.

```Python
cars = ['audi', 'bmw', 'subaru', 'toyota']

for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())
```

```CMD
Audi
BMW
Subaru
Toyota
```

## Conditional Tests

At the heart of every *if* statement is an expression that can be evaluated as *True* or *False* and is called a *conditional test*. Python uses the values *True* and *False* to decide whether the code in an *if* statement should be executed. If a *conditional test* evaluates to *True*, Python executes the code following the if statement. If the test evaluates to *False*, Python ignores the code following the if statement.

### Checking for Equality

Most conditional tests compare the current value of a variable to a specific value of interest. The simplest conditional test checks whether the value of a variable is equal to the value of interest.

```PowerShell
>>> car = 'bmw'
>>> car == 'bmw'
True
```

Line 1 sets the value of car to 'bmw' using a single equal sign (=). Line 2 checks whether the value of car is 'bmw' using a double equal sign (==). This *equality operator* returns *True* if the values on the left and right side of the operator match, and *False* if they don’t match. The values in this example match, so Python returns True. When the value of car is anything other than 'bmw', this test returns *False*.

```PowerShell
>>> car = 'audi'
>>> car == 'bmw'
False
```

### Equality Case sensitivity

Testing for equality is case sensitive in Python. For example, two values with different capitalization are not considered equal.

```PowerShell
>>> car = 'Audi'
>>> car == 'audi'
False
```

If case matters, this behavior is advantageous. But if case doesn’t matter and instead you just want to test the value of a variable, you can convert the variable’s value to lowercase before doing the comparison.

```PowerShell
>>> car = 'Audi'
>>> car.lower() == 'audi'
True
```

This test would return True no matter how the value 'Audi' is formatted because the test is now case insensitive. The *lower()* method doesn’t change the value that was originally stored in car, so you can do this kind of comparison without affecting the original variable.

```PowerShell
>>> car = 'Audi'
>>> car.lower() == 'audi'
True
>>> car
'Audi'
```

Websites enforce certain rules for the data that users enter in a manner similar to this. For example, a site might use a conditional test like this to ensure that every user has a truly unique username, not just a variation on the capitalization of another person’s username. When someone submits a new username, that new username is converted to lowercase and compared to the lowercase versions of all existing usernames. During this check, a username like 'Ahmed' will be rejected if any variation of 'ahmed' is already in use.

### Checking for Inequality

When you want to determine whether two values are not equal, you can combine an exclamation point and an equal sign (!=). The exclamation point represents *not*, as it does in many programming languages.

```Python
admin_name = 'Ali'

if admin_name != 'Ahmed':
    print("Access Denied")
```

```CMD
Access Denied
```

## Numerical Comparisons

Testing numerical values is pretty straightforward.

| Operator | Meaning |
|:---:|:---:|
| == | Equal |
| != | Not Equal |
| > | Greater Than |
| >= | Grater Than or Equal |
| < | Less Than |
| <= | Less Than or Equal |

``` PowerShell
>>> age = 23
>>> age == 23
True
>>> age != 25
True
>>> age > 25
False
>>> age >= 23
True
>>> age < 25
True
>>> age <= 22
False
```

Each mathematical comparison can be used as part of an *if* statement, which can help you detect the exact conditions of interest.

### Checking Multiple Conditions

You may want to check multiple conditions at the same time. For example, sometimes you might need two conditions to be True to take an action. Other times you might be satisfied with just one condition being True. The keywords *and* and *or* can help you in these situations.

#### Using and to Check Multiple Conditions

To check whether two conditions are both *True* simultaneously, use the keyword *and* to combine the two conditional tests; if each test passes, the overall expression evaluates to *True*. If either test fails or if both tests fail, the expression evaluates to *False*.

```PowerShell
>>> age_0 = 22
>>> age_1 = 18
>>> age_0 >= 21 and age_1 >= 21
False
>>> age_1 = 22
>>> age_0 >= 21 and age_1 >= 21
True
```

To improve readability, you can use parentheses around the individual tests, but they are not required.

```PowerShell
(age_0 >= 21) and (age_1 >= 21)
```

#### Using or to Check Multiple Conditions

The keyword *or* allows you to check multiple conditions as well, but it passes when either or both of the individual tests pass. An or expression fails only when both individual tests fail.

```PowerShell
>>> age_0 = 22
>>> age_1 = 18
>>> age_0 >= 21 or age_1 >= 21
True
>>> age_0 = 18
>>> age_0 >= 21 or age_1 >= 21
False
```

## Checking Whether a Value Is in a List

Sometimes it’s important to check whether a list contains a certain value before taking an action. For example, you might want to check whether a new username already exists in a list of current usernames before completing someone’s registration on a website. In a mapping project, you might want to check whether a submitted location already exists in a list of known locations. To find out whether a particular value is already in a list, use the keyword *in*.

```PowerShell
>>> users = ['Ahmed', 'Ali', 'Mohammed']
>>> 'Omar' in users
False
>>> 'Ali' in users
True
```

The keyword *in* tells Python to check for the existence of 'Omar' and 'Ali' in the list users. This technique is quite powerful because you can create a list of essential values, and then easily check whether the value you’re testing matches one of the values in the list.

## Checking Whether a Value Is Not in a List

Other times, it’s important to know if a value does not appear in a list. You can use the keyword *not* in this situation. For example, consider a list of users who are banned from commenting in a forum. You can check whether a user has been banned before allowing that person to submit a comment.

```Python
banned_users = ['Hossam', 'Khalid', 'Omar']
user = 'Mohammed'

if user not in banned_users:
    print(f"{user.title()}, You can post a comment if you wish.")
```

```CMD
Mohammed, You can post a comment if you wish.
```

## Boolean Expressions

As you learn more about programming, you’ll hear the term *Boolean expression* at some point. A *Boolean expression* is just another name for a *conditional test*. A *Boolean value* is either *True* or *False*, just like the value of a conditional expression after it has been evaluated.

Boolean values are often used to keep track of certain conditions, such as whether a game is running or whether a user can edit certain content on a website.

```PowerShell
game_active = True
can_edit = False
```

Boolean values provide an efficient way to track the state of a program or a particular condition that is important in your program.

---

## if Statements

When you understand conditional tests, you can start writing if statements. Several different kinds of if statements exist, and your choice of which to use depends on the number of conditions you need to test.

### Simple if Statements

The simplest kind of if statement has one test and one action.

```PowerShell
if conditional_test:
    do something
```

You can put any conditional test in the first line and just about any action in the indented block following the test. If the conditional test evaluates to True, Python executes the code following the if statement. If the test evaluates to False, Python ignores the code following the if statement.

```Python
age = 19
if age >= 18:
    print("You are old enough to vote!")
    print("Have you registered to vote yet?")
```

```CMD
You are old enough to vote!
Have you registered to vote yet?
```

If the value of age is less than 18, this program would produce no output.

### if-else Statements

Often, you’ll want to take one action when a conditional test passes and a different action in all other cases. Python’s *if-else* syntax makes this possible. An *if-else* block is similar to a simple if statement, but the else statement allows you to define an action or set of actions that are executed when the conditional test fails.

```Python
age = 17
if age >= 18:
    print("You are old enough to vote!")
    print("Have you registered to vote yet?")
else:
    print("Sorry, you are too young to vote.")
    print("Please register to vote as soon as you turn 18!")
```

```CMD
Sorry, you are too young to vote.
Please register to vote as soon as you turn 18!
```

This code works because it has only two possible situations to evaluate: a person is either old enough to vote or not old enough to vote. The if-else structure works well in situations in which you want Python to always execute one of two possible actions. In a simple if-else chain like this, one of the two actions will always be executed.

### The if-elif-else Chain

Often, you’ll need to test more than two possible situations, and to evaluate these you can use Python’s *if-elif-else* syntax. Python executes only one block in an *if-elif-else* chain. It runs each conditional test in order until one passes. When a test passes, the code following that test is executed and Python skips the rest of the tests.

Many real-world situations involve more than two possible conditions. For example, consider an amusement park that charges different rates for different age groups:

* Admission for anyone under age 4 is free.
* Admission for anyone between the ages of 4 and 18 is $25.
* Admission for anyone age 18 or older is $40.

How can we use an if statement to determine a person’s admission rate?

```Python
age = 12

if age < 4:
    print("Your admission cost is $0.")
elif age < 18:
    print("Your admission cost is $25.")
else:
    print("Your admission cost is $40.")
```

```CMD
Your admission cost is $25.
```

The *if* test tests whether a person is under 4 years old. If the test passes, an appropriate message is printed and Python skips the rest of the tests. The *elif* line is really another if test, which runs only if the previous test failed. At this point in the chain, we know the person is at least 4 years old because the first test failed. If the person is under 18, an appropriate message is printed and Python skips the *else* block. If both the if and *elif* tests fail, Python runs the code in the *else* block.

In this example the first test evaluates to False, so its code block is not executed. However, the second test evaluates to True (12 is less than 18) so its code is executed. The output is one sentence, informing the user of the admission cost.

Any age greater than 17 would cause the first two tests to fail. In these situations, the else block would be executed and the admission price would be $40.

Rather than printing the admission price within the *if-elif-else* block, it would be more concise to set just the price inside the *if-elif-else* chain and then have a simple *print()* call that runs after the chain has been evaluated.

```Python
age = 12

if age < 4:
    price = 0
elif age < 18:
    price = 25
else:
    price = 40

print(f"Your admission cost is ${price}.")
```

### Using Multiple elif Blocks

You can use as many *elif* blocks in your code as you like. For example, if the amusement park were to implement a discount for seniors, you could add one more conditional test to the code to determine whether someone qualified for the senior discount. Let’s say that anyone 65 or older pays half the regular admission, or $20.

```Python
age = 12

if age < 4:
    price = 0
elif age < 18:
    price = 25
elif age < 65:
    price = 40
else:
    price = 20

print(f"Your admission cost is ${price}.")
```

### Omitting the else Block

Python does not require an *else* block at the end of an *if-elif* chain. Sometimes an *else* block is useful; sometimes it is clearer to use an additional *elif* statement that catches the specific condition of interest.

```Python
age = 12

if age < 4:
    price = 0
elif age < 18:
    price = 25
elif age < 65:
    price = 40
elif age >= 65:
    price = 20

print(f"Your admission cost is ${price}.")
```

The extra *elif* block assigns a price of $20 when the person is 65 or older, which is a bit clearer than the general else block. With this change, every block of code must pass a specific test in order to be executed.

The *else* block is a catchall statement. It matches any condition that wasn’t matched by a specific *if* or *elif* test, and that can sometimes include invalid or even malicious data. If you have a specific final condition you are testing for, consider using a final *elif* block and omit the *else* block. As a result, you’ll gain extra confidence that your code will run only under the correct conditions.

### Testing Multiple Conditions

The *if-elif-else* chain is powerful, but it’s only appropriate to use when you just need one test to pass. As soon as Python finds one test that passes, it skips the rest of the tests. This behavior is beneficial, because it’s efficient and allows you to test for one specific condition.

However, sometimes it’s important to check all of the conditions of interest. In this case, you should use a series of simple *if* statements with no *elif* or *else* blocks. This technique makes sense when more than one condition could be True, and you want to act on every condition that is True.

Let’s reconsider a pizzeria example. If someone requests a two-topping pizza, you’ll need to be sure to include both toppings on their pizza.

```Python
requested_toppings = ['mushrooms', 'extra cheese']

if 'mushrooms' in requested_toppings:
    print("Adding mushrooms.")
if 'pepperoni' in requested_toppings:
    print("Adding pepperoni.")
if 'extra cheese' in requested_toppings:
    print("Adding extra cheese.")

print("\nFinished making your pizza!")
```

```CMD
Adding mushrooms.
Adding extra cheese.

Finished making your pizza!
```

This code would not work properly if we used an *if-elif-else* block, because the code would stop running after only one test passes.

In summary, if you want only one block of code to run, use an *if-elif-else* chain. If more than one block of code needs to run, use a series of independent *if* statements.

---

## Using if Statements with Lists

You can do some interesting work when you combine *lists* and *if* statements. You can watch for special values that need to be treated differently than other values in the *list*. You can manage changing conditions efficiently, such as the availability of certain items in a restaurant throughout a shift. You can also begin to prove that your code works as you expect it to in all possible situations.

### Checking for Special Items

We began with a simple example that showed how to handle a special value like 'bmw', which needed to be printed in a different format than other values in the list. Now that we have a basic understanding of *conditional tests* and *if* statements, let’s take a closer look at how we can watch for special values in a *list* and handle those values appropriately.

Let’s continue with the pizzeria example. The pizzeria displays a message whenever a topping is added to your pizza, as it’s being made. The code for this action can be written very efficiently by making a *list* of toppings the customer has requested and using a loop to announce each topping as it’s added to the pizza.

```Python
requested_toppings = ['mushrooms', 'green peppers', 'extra cheese']

for requested_topping in requested_toppings:
    print(f"Adding {requested_topping}.")

print("\nFinished making your pizza!")
```

The output is straightforward because this code is just a simple for loop.

```CMD
Adding mushrooms.
Adding green peppers.
Adding extra cheese.

Finished making your pizza!
```

But what if the pizzeria runs out of green peppers? An *if* statement inside the for loop can handle this situation appropriately.

```Python
requested_toppings = ['mushrooms', 'green peppers', 'extra cheese']

for requested_topping in requested_toppings:
    if requested_topping == 'green peppers':
        print("Sorry, we are out of green peppers right now.")
    else:
        print(f"Adding {requested_topping}.")

print("\nFinished making your pizza!")
```

This time we check each requested item before adding it to the pizza. The code checks to see if the person requested green peppers. If so, we display a message informing them why they can’t have green peppers.
The else block ensures that all other toppings will be added to the pizza.

The output shows that each requested topping is handled appropriately.

```CMD
Adding mushrooms.
Sorry, we are out of green peppers right now.
Adding extra cheese.

Finished making your pizza!
```

### Checking That a List Is Not Empty

We’ve made a simple assumption about every list we’ve worked with so far; we’ve assumed that each list has at least one item in it. Soon we’ll let users provide the information that’s stored in a list, so we won’t be able to assume that a list has any items in it each time a loop is run. In this situation, it’s useful to check whether a *list* is empty before running a *for* loop.

As an example, let’s check whether the list of requested toppings is empty before building the pizza. If the list is empty, we’ll prompt the user and make sure they want a plain pizza. If the list is not empty, we’ll build the pizza just as we did in the previous examples.

```Python
requested_toppings = []

if requested_toppings:
    for requested_topping in requested_toppings:
    print(f"Adding {requested_topping}.")
    print("\nFinished making your pizza!")
else:
    print("Are you sure you want a plain pizza?")
```

This time we start out with an empty *list* of requested toppings. Instead of jumping right into a *for* loop, we do a quick check. When the name of a list is used in an if statement, Python returns True if the list contains at least one item; an empty list evaluates to False. If *requested_toppings* passes the conditional test, we run the same for loop we used in the previous example. If the conditional test fails, we print a message asking the customer if they really want a plain pizza with no toppings.

The list is empty in this case, so the output asks if the user really wants a plain pizza.

```CMD
Are you sure you want a plain pizza?
```

If the list is not empty, the output will show each requested topping being added to the pizza.

### Using Multiple Lists

```Python
available_toppings = ['mushrooms', 'olives', 'green peppers',
'pepperoni', 'pineapple', 'extra cheese']

requested_toppings = ['mushrooms', 'french fries', 'extra cheese']

for requested_topping in requested_toppings:
    if requested_topping in available_toppings:
        print(f"Adding {requested_topping}.")
    else:
        print(f"Sorry, we don't have {requested_topping}.")

print("\nFinished making your pizza!")
```

```CMD
Adding mushrooms.
Sorry, we don't have french fries.
Adding extra cheese.

Finished making your pizza!
```

In just a few lines of code, we’ve managed a real-world situation pretty effectively!