When evaluating conditions using if statements, it is often helpful to be able to do multiple comparisons at one time, to limit the number of if statements used in our code. This will allow us to write cleaner and more concise code, that is easier to read. Logical operators, or Boolean operators, are logical tools that will allow us to combine conditions together.

To start, we will take a look at what comparisons we are able to do in Python, and what actually happens when we do these comparisons. In Python, there are six comparison operators that are typically seen in if statements. These comparison operators are:

- Less than (<)
- Less than or equal (<=)
- Greater than (>)
- Greater than or equal (>=)
- Equal (==)
- Does not equal (!=)

When we use one of these operators, the result can be one of two values. It will either be true if the condition is satisfied, or false otherwise. If we want do multiple comparisons at one time, we need to understand how our computer interprets true and false values. When our computer encounters true and false, it assigns them numeric values of 1 and 0 respectively. From here, our computer applies a set of logic based on math, known as Boolean Algebra. Boolean Algebra sets out the rules of what results to expect when combining comparison operators. It is heavily used in electronics, circuits, and it is the basis of modern computation. Boolean Algebra contains a lot of theorems and ideas that are useful for working with binary numbers, however for this article we will focus on three that are most commonly used.

The first operation we will discuss *and*. The

You can see that this code contains a fair bit of repetition and checking. When we validate each condition separately, we end up with *and *operator, we can combine the two checks into one single check to simplify the code.

Using the *and*
operator results in shorter code, and only one if statement. This means that our
code is not only easier to read, but also more efficient. To understand why
this code is equivalent to the code without the *and* operator, we can chart the results of using *and* based on the result of the
condition.

From this table, you can see that the only cases where the *and *operator gives a true result is when
both of the conditions being checked gives a true result. It is important to
note that this rule is true for more than two conditions as well.

The *or *operator
allows us to check if at least one condition is true. If at least one of the
conditions we are checking is true, then the result of the *or* operator will be true. Let’s look at another example to see
exactly how this works. Suppose we ask the user to input the weather, and we
want to decide if they should wear a jacket. We will output that the user
should wear a jacket if the temperature is below 10 degrees, or if it is
raining. If we use just if statements to
solve this problem, we would get the code below.

Similar to the *and* operation example, you can see that this situation leads to code repetition, which is not ideal. Instead of having an else if, we can combine the two checks into a single condition, using the *or* operator.

The *or* operator
allows us to remove one of our condition checks, again resulting in shorter and
more efficient code. In general, if we have two conditions, we can outline the
results of the *or* operator.

As you can see, the only time *or* is false is if all of the conditions involved are false. Like *and*, the *or *operator will have the same result with more than two conditions
as well.

The final operation that I will discuss is the *not* operator. The *not* operator simply negates the result of the current condition.
This means that if the operation gave a true result, the *not* of the operation would be false. If the result were false, the *not* would make it true. The *not* operator is helpful in situations where
it is easier to check for the opposite operation and negate the result. For
example, suppose we wanted to ask the user to input a forecast for the weather,
and determine if they did not enter “rain”. We can do this with a *not* operator as follows.

In general, the outcome of the *not *statement acts on one condition, as follows.

These three operators are some of the basic logical operators that exist in Python. They are used frequently, as they allow for clean and efficient code. By understanding these operators, you will be able to solve many complex problems in simple and elegant ways.

## One Reply to “Understanding Python Logical Operators”