The Python Boolean Type

00:00 It wasn’t until 2002 that the Boolean class was added, and if you’re interested in knowing what the thought process was when adding the class, check out PEP 285.

00:12 One of the main reasons why the Boolean class was added was to standardize the process of deciding when a condition is either true or false. Remember, a lot of your code is all about making decisions and then taking the appropriate action.

00:27 The Boolean class is implemented as a subclass of the integer class, and so it inherits all of the mathematical operations that exist in the integer class.

00:38 The constructor function to the Boolean class is called bool(), and bool() can therefore be used to transform an object to a Boolean data type.

00:48 Of course, unless the object that you’re trying to transform is a Python built-in object, your class has to define a way to transform the object into a Boolean type.

00:59 We’ll discuss this in a future lesson.

01:03 There are only two possible values of an instance of the Boolean data type—either True or False. True and False are also keywords, which means that you can’t use them as variable names or identifier names in your programs. When typecasted into integer objects, True evaluates to 1 and False evaluates to 0.

01:26 So since the Boolean class is a subclass of the integer class, you can do things like this.

01:33 Now, this may not seem all that useful, but we’ll look at an example where you may actually want to take advantage of this. All right, let’s take a look at some examples.

01:44 Let’s start by taking a look at the help() documentation for the Boolean class.

01:49 The constructor to the Boolean class is called bool() and if the input to the Boolean constructor is x and x has a value or evaluates to a value of True, then the constructor returns True and otherwise it’s going to return False. In an upcoming lesson, we’ll talk about how Python decides when an object should evaluate to True and when it should evaluate to False.

02:15 The two built-in constants True and False are the only two instances of the Boolean class, and the Boolean class is a subclass of the integer class.

02:26 Now, since the Boolean class is a subclass of the integer class, it inherits all of the mathematical operations that exist in the integer class. Now, in addition to these operators, the two most important operators that are particular to the Boolean class are and and or, and we’ll talk about these in-depth later on in a video.

02:49 Now, for good measure, let’s verify that the Boolean class is indeed a subclass of the integer class. So is Boolean a subclass of int? And we get True.

03:00 Let’s also verify that True and False are instances of the Boolean class. So is True an instance of bool?

03:07 We get True. And is False an instance of bool? And we also get True. Now, even though that True evaluates to the integer 1 when typecast into an integer, the integer 1 is not an instance of the Boolean class, so we get False in this case.

03:25 And if we try the same thing with the 0 integer, we’re also going to get False.

03:31 Let’s verify that True and False are built-in keywords, so let’s import the keyword module. The keyword module contains a list of all of the keywords in Python.

03:43 The list is called kwlist, or keyword list.

03:49 And at the very top of this list, along with the None keyword, is False and True.

03:58 Let’s now see an example that demonstrates how True and False behave when they’re integers. If you go ahead and typecast True as an integer, you’re going to get 1. And then if you do the same thing for False, you’re going to get the integer 0. So that means, for example, if you were to say what’s True plus True plus, let’s say, False and then maybe you want to add one more True, you’re going to get 3, right?

04:26 So True + True + False + True is 3. This may not seem all that useful, but you can actually take advantage of this when you want to determine the number of occurrences of a Boolean condition in a list. Let me show you an example.

04:43 So, here’s your problem. You have a list of integers—say, stored in a list called codes, and maybe these integers represent some sort of code—and you want to know how many of these integers are divisible by, say, 3.

04:58 Let’s write down a few more and let’s introduce a new variable, N. So N = 3. So again, the problem is how many of these integers are divisible by 3?

05:11 Why don’t you use a list comprehension? You loop over the integers of the codes list, apply the modulo operator (%), and whenever you get a 0, you know that you have a multiple of 3.

05:23 Start off by writing [for c in codes],

05:28 and you want to apply the modulo operator to c,

05:35 and you know that you’re going to get an integer, and whenever you get 0, you have a multiple of 3. So use the equality operator (==). This is a Boolean operator, which we’ll discuss later on in a future lesson. But for the moment, what this will do is whenever we get a 0, then that’s a multiple of 3, and so this comparison operator, this equality operator, will return True exactly when we have a multiple of 3. I’m certain you’ve probably used this operator before, but we’ll talk about it later on in a future lesson.

06:10 So, what happens when you run this? Well, you get a list of True and False values, or a Boolean list. And you know that when you sum up Booleans, True evaluates to 1 and False evaluates to 0. So if you go ahead and sum this list, you’re going to get 4.

06:29 So this tells you that four of those integers are divisible by 3 or a multiple of 3. And in this case, you can see them exactly.

06:36 It’s the integer one in the list, the third one, the fourth, and the fifth one. So, this is a nice, clean way of determining how many occurrences of some sort of Boolean expression—in this case, how many of the integers are a multiple of 3—using the fact that True evaluates to 1 and False evaluates to 0 and then summing up this list of these True and False values.

07:03 All right! Well, that ends the first lesson on the Boolean data type built into Python. In the next lesson, we’ll take a look at the Boolean operators, and in particular, we’ll focus on the operators not, and, and or that are built into Python and are by far the most widely-used operators.