What if the element we’re checking isn’t a boolean? What does Python consider True and False?
A false value doesn’t necessarily need to explicitly be a boolean False. For example, these are all considered False:
boolean False null None zero integer 0 zero float 0.0 empty string '' empty list [] empty tuple () empty dict {} empty set set()
Anything else is considered True. Python programs use these definitions of “truthiness” and “falsiness” to check for empty data structures as well as False conditions:
some_list = [] if some_list: print("There's some data in the list some_list") else: print("Hey, the list some_list is empty!")
If what you’re testing is an expression rather than a simple variable, Python evaluates the expression and returns a boolean result. So, if you type:
if color == "red":
Python evaluates color == "red". In our earlier example, we assigned the string "green" to color, so color == "red" is False, and Python moves on to the next test:
elif color == "green":
Notice that the test results returned in the last two examples
represent true and false values. They print as the words True
and False
, but now that we’re using logical tests like
these in earnest, I should be a bit more formal about what these
names really mean.
In Python, as in most programming languages, an integer 0
represents false, and an integer 1
represents true. In
addition, though, Python recognizes any
empty data structure as false and any nonempty data structure
as true. More generally, the notions of true and false are
intrinsic properties of every object in Python—each object
is either true or false, as follows:
Examples of true and false values of objects in Python.
Object | Value |
---|---|
"spam" |
True |
"" |
False |
[1, 2] |
True |
[] |
False |
{'a': 1} |
True |
{} |
False |
1 |
True |
0.0 |
False |
None |
False |
As one application, because objects are true or false
themselves, it’s common to see Python programmers code tests like
if X:
, which, assuming X
is a string, is
the same as if X != '':
. In other words, you can test
the object itself to see if it contains anything, instead of
comparing it to an empty, and therefore false, object of the same
type (more on if
statements in the next chapter).
Python also provides a special object called
None
, which is always considered to be false. It is the only value of a special data type in
Python and typically serves as an empty placeholder (much like a
NULL
pointer in C).
For example, recall that for lists you cannot assign to an
offset unless that offset already exists—the list does not
magically grow if you attempt an out-of-bounds assignment. To
preallocate a 100-item list such that you can add to any of the
100 offsets, you can fill it with None
objects:
>>>L = [None] * 100
>>> >>>L
[None, None, None, None, None, None, None, ... ]
This doesn’t limit the size of the list (it can still grow
and shrink later), but simply presets an initial size to allow
for future index assignments. You could initialize a list with
zeros the same way, of course, but best practice dictates using
None
if the type of the list’s contents is variable
or not yet known.
Keep in mind that None
does not mean
“undefined.” That is, None
is something, not
nothing (despite its name!)—it is a real object and a real piece
of memory that is created and given a built-in name by Python
itself. Watch for other uses of this special object later in the
book; as we’ll learn in
Part IV, it is also the default return value of functions
that don’t exit by running into a return
statement
with a result value.
While we’re on the
topic of truth, also keep in mind that the Python Boolean
type bool
, simply augments the notions of true and false in Python.
The built-in words
True
and False
are just customized versions of the integers 1
and 0
—it’s as if these two words have been
preassigned to 1
and 0
everywhere in
Python. Because of the way this new type is implemented, this is
really just a minor extension to the notions of true and false
already described, designed to make truth values more explicit:
True
and False
are equivalent to 1
and 0
, but they make the programmer’s intent
clearer.True
and False
, instead of as
1
and 0
, to make the type of result
clearer.You are not required to use only Boolean types in logical
statements such as if
; all objects are still
inherently true or false, and all the Boolean concepts mentioned
in this chapter still work as described if you use other types.
Python also provides a bool
built-in function that
can be used to test the Boolean value of an object if you want
to make this explicit (i.e., whether it is true—that is, nonzero
or nonempty):
>>>bool(1)
True >>>bool('spam')
True >>>bool({})
False
In practice, though, you’ll rarely notice the Boolean type
produced by logic tests, because Boolean results are used
automatically by if
statements and other selection
tools. We’ll explore Booleans further when we study logical
statements in
Chapter 12.
The notions of comparison,
equality, and truth values were introduced in
Chapter 9. Because the
if
statement is the first
statement we’ve looked at that actually uses test results, we’ll
expand on some of these ideas here. In particular, Python’s Boolean
operators are a bit different from their counterparts in languages
like C. In Python:
None
are considered false.True
or
False
(custom versions of 1
and 0
).and
and or
operators return a
true or false operand object.The if
statement takes action on truth values, but
Boolean operators are used to combine the results of other tests in
richer ways to produce new truth values. More formally, there are
three Boolean expression operators in Python:
X and Y
- Is true if both
X
andY
are trueX or Y
- Is true if either
X
orY
is truenot X
- Is true if
X
is false (the expression returnsTrue
orFalse
)
Here, X
and Y
may be any truth value, or
any expression that returns a truth value (e.g., an equality test,
range comparison, and so on). Boolean operators are typed out as words
in Python (instead of C’s &&
, ||
, and !
). Also, Boolean
and
and or
operators return a true or false object in Python, not the
values True
or False
. Let’s look at a few
examples to see how this works:
>>>2 < 3, 3 < 2
# Less than: return True or False (1 or 0)
(True, False)
Magnitude comparisons such as these return True
or
False
as their truth results, which, as we learned in
Chapter 5 and
Chapter 9, are really just custom versions of the integers
1
and 0
(they print themselves differently but are
otherwise the same).
On the other hand, the and
and or
operators always return an object—either the object on the left
side of the operator or the object on the right. If we test
their results in if
or other statements, they will be as
expected (remember, every object is inherently true or false), but we
won’t get back a simple True
or False
.
For or
tests, Python evaluates the operand objects
from left to right and returns the first one that is true. Moreover,
Python stops at the first true operand it finds. This is usually
called short-circuit evaluation, as determining a result
short-circuits (terminates) the rest of the expression as soon as the
result is known:
>>>2 or 3, 3 or 2
# Return left operand if true
(2, 3)# Else, return right operand (true or false)
>>>[] or 3
3 >>>[] or {}
{}
In the first line of the preceding example, both operands (2
and 3
) are true (i.e., are nonzero), so Python always
stops and returns the one on the left—it determines the result because
true or
anything is always true. In the other two tests,
the left operand is false (an empty object), so Python simply
evaluates and returns the object on the right—which may happen to have
either a true or a false value when tested.
Python and
operations also stop as soon as the result
is known; however, in this case Python evaluates the operands from
left to right and stops if the left operand is a false object
because it determines the result—false and
anything is
always false:
>>>2 and 3, 3 and 2
# Return left operand if false
(3, 2)# Else, return right operand (true or false)
>>>[] and {}
[] >>>3 and []
[]
Here, both operands are true in the first line, so Python evaluates
both sides and returns the object on the right. In the second test,
the left operand is false ([]
), so Python stops and
returns it as the test result. In the last test, the left side is true
(3
), so Python evaluates and returns the object on the
right—which happens to be a false []
.
The end result of all this is the same as in C and most other
languages—you get a value that is logically true or false if tested in
an if
or while
according to the normal
definitions of or
and and
. However, in
Python Booleans return either the left or the right object,
not a simple integer flag.
This behavior of and
and or
may seem
esoteric at first glance, but see this chapter’s sidebar
“Why You Will Care: Booleans” for examples of how it is sometimes
used to advantage in coding by Python programmers. The next section
also shows a common way to leverage this behavior, and its more
mnemonic replacement in recent versions of
Python.