# Boolean Values

The Boolean values in Python are `True`

and `False`

, typically used to control if-statements and while-loops.

# Boolean And Or Not

The Python "bool" type (short for "boolean") has only two values - `True`

and `False`

.
Expressions yielding a bool value like `a > 10`

, can be combined with **and** **or** **not**, like following (printing 'yay' if a is in the range 0..100 inclusive):

if a >= 0 and a <= 100:
print('yay')

Python is unique in using the plain words like "and" for this. many languages use "&&" for and, "||" for or.

*a* and *b*

→ True if both are True

*a* or *b*

→ True if one or the other or both are True

`not `*a*

→ Inverts True/False

## Boolean Precedence

There is "precedence" between and/or/not, analogous to arithmetic precedence, where "*" has higher precedence than "+".

Precedence order: `not`

is highest precedence, followed by `and`

, followed by `or`

. Mnemonic: `not`

is like unary minus e.g. '-6', `and`

is like * mutliplication, `or`

is like + addition.

Q: what does the following do:

if a < 6 and b < 6 or c < 6:

The `and`

goes first (higher precedence), so the above is equivalent to the following form with parenthesis added to show the order the comparisons are evaluated:

if (a < 6 and b < 6) or c < 6:

To force the `or`

to go first, put in parenthesis like this:

if a < 6 and (b < 6 or c < 6):

If you are unsure, you can always add parenthesis to an expression to force the order you want.

## Boolean Short-Circuit

Suppose you have an int i, and you want to check if the char at that index is alphabetic .. but only if i is valid. You can write that this way...

if i < len(s) and s[i].isalpha():...

This works because the boolean evaluation goes left to right, stopping ("short-circuiting") as soon as it can. So in the example above, if `i < len(s)`

is False (i.e. i is large), the whole expression evaluates to False. In particular the `s[i].isalpha()`

is **not evaluated**. Attempting to evaluate it would be an error, since i is too large, creating an IndexError.

Writing the `i<len(s)`

test to the left of the `s[i]`

in effect protects it, and this is a common programming pattern. Most computer languages use short circuiting in the their boolean expressions like this.