You may already know Python’s and operator when applied to two Booleans:

>>> True and False False >>> True and True True

Simple enough. Yet, that’s not the whole story: you can use the `and`

operator even on complex data types such as lists or custom objects. So you may ask (and rightly so):

## What If You Apply the AND Operator To Two Objects?

To understand the output, you have to understand two things:

- How does the
`and`

operator work? - What’s the truth value of any object – such as a list?

Let’s answer those two questions quickly.

**How does the and operator work?**

Let’s start with the official documentation for Boolean operators:

Operation | Definitions |

`x or y` | if x is false, then y, else x |

`x and y` | if x is false, then x, else y |

`not x` | if x is false, then `True` , else `False` |

You must understand the deeper meaning of those definitions: all of them are short-circuit which means that as soon as the condition is fullfilled, they will abort further processing.

In the `x and y`

operation, if the value of `x`

is evaluated to `True`

, Python simply returns the value of `y`

. It doesn’t even look at what the value of `y`

actually *is*. If you’re using Boolean operators `x`

and `y`

, this is expected behavior because if `x`

is `True`

, then the `y`

determines whether `x`

and `y`

is `True`

.

This leads to the interesting behavior: if `x`

and `y`

are objects, the result of the operation `x and y`

will be an object, too! (And not a Boolean value.)

In combination with the next piece of Python knowledge, this leads to an interesting behavior:

**What’s the truth value of any object – such as a list?**

The Python convention is simple: if the object is “empty”, the truth value is `False`

. Otherwise, it’s `True`

. So an empty list, an empty string, or a 0 integer value are all `False`

. Most other values will be `True`

.

Now, you’re equipped with the basics to understand the answer to the following question:

**What If You Apply the AND Operator To Two Objects?**

Say, you’ve got two non-Boolean objects `x`

and `y`

. What’s the result of the operation `x and y`

?

The answer is simple: the result is `y`

if `x`

is non-empty (and, thus, evaluates to `True`

).

**What If You Apply the AND Operator To Two Lists?**

Here’s an example for two list objects:

>>> [1, 2, 3] and [0, 0, 0, 0] [0, 0, 0, 0]

The first argument of the `and`

operation is non-empty and evaluates to `True`

. Therefore, the result of the operation is the second list argument `[0, 0, 0, 0]`

.

But what if the first argument is empty?

>>> [] and [0, 0, 0, 0] []

The result is the first argument (and not a Boolean value `False`

). If you’re in doubt why, consult the above definition again:

`x and y`

: *if x is false, then x, else y*

## Summary

You’ve learned that the `and`

operator returns the first operand if it evaluates to `False`

, otherwise the second operand.

You’ve also learned that you can use the `and`

operator even for non-Boolean types in which case the result will be an object, not a Boolean value.

Finally, you’ve also learned that an empty object usually evaluates to `False`

.

If you find this interesting, feel free to check out my upcoming Python book that shows you hundreds of small Python tricks like this one:

Python One-Liners [No Starch Press]

Get your book!

While working as a researcher in distributed systems, Dr. Christian Mayer found his love for teaching computer science students.

To help students reach higher levels of Python success, he founded the programming education website Finxter.com. He’s author of the popular programming book Python One-Liners (NoStarch 2020), coauthor of the Coffee Break Python series of self-published books, computer science enthusiast, freelancer, and owner of one of the top 10 largest Python blogs worldwide.

His passions are writing, reading, and coding. But his greatest passion is to serve aspiring coders through Finxter and help them to boost their skills. You can join his free email academy here.