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
You can see that this code contains a fair bit of repetition and checking. When we validate each condition separately, we end up with
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.