What is the difference between using the logical operators
```
and
```

and
```
or
```

in Python?

When using the
```
and
```

logical operator in Python all conditions in the statement need to be
```
True
```

for the entire expression to evaluate to
```
True
```

. If one condition evaluates to
```
False
```

then the entire expression evaluates to
```
False
```

.

When using the
```
or
```

logical operator only one condition in the entire expression needs to evaluate to
```
True
```

for the entire expression to evaluate to
```
True
```

. If all conditions are
```
False
```

then the expression evaluates to
```
False
```

.

Here is a couple of simple examples in the Python REPL:

```
>>> e = 10
>>> f = 100
>>> e > 0 and f > 0
True
>>> e < 0 and f > 0
False
>>> e < 0 or f > 0
True
>>> e < 0 or f < 0
False
```

As you can see from the basic examples above the first expression with
```
e > 0 and f > 0
```

both evaluate to
```
True
```

and because the
```
and
```

operator is used if
**
all conditions
**
are
```
True
```

then the result is
```
True
```

.

For the second expression with
```
e < 0 and f > 0
```

the first condition is
```
False
```

and even though the second condition is
```
True
```

because
**
all conditions
**
are not
```
True
```

the result is
```
False
```

.

With the third expression
```
e < 0 or f > 0
```

only the second condition is
```
True
```

and as
**
only one condition
**
needs to be
```
True
```

then the result of the expression
**
is
**

```
True
```

.
Finally, with the last expression
```
e < 0 or f < 0
```

where all conditions are
```
False
```

this produces a
```
False
```

result as no conditions evaluate to
```
True
```

.

##
Can You Use
```
&&
```

For
```
and
```

?

Python does not recognise the syntax
```
&&
```

which is the equivalent of
```
and
```

in other programming languages such as Javascript.

If you do type the syntax
```
&&
```

in a statement you will get a
```
SyntaxError
```

, as demonstrated below:

```
>>> e > 0 && f < 0
File "<stdin>", line 1
e > 0 && f < 0
^
SyntaxError: invalid syntax
```

With the above error, the REPL terminal is showing you where the error is and the fact it’s invalid syntax.

##
A Shortcut Way To Use
```
and
```

If typing 3 characters each time you want to do
```
and
```

is too tedious for you, then there is 1 mathematical character you could use which is known as the equivalent of
```
and
```

in mathematics – the humble multiplication symbol
```
*
```

.

Another way of writing the same expression instead of using
```
and
```

is to replace the operator with the mathematical symbol for multiplication in Python
```
*
```

.

In mathematics the multiplication operator works in the same manner as the logical operator
```
and
```

.

Why?

A
```
False
```

value in computer languages can numerically be represented as the number
```
0
```

. What happens when you multiply the number
```
0
```

to any other number?

You still get
```
0
```

.

Therefore, the principle behind the multiplication of numbers similarly applies to
```
and
```

conditions as each condition needs to evaluate to a number, any number, bar
```
0
```

.

Otherwise, if there’s one condition in the expression statement that evaluates to
```
0
```

then every multiplication applied will result in
```
0
```

.

And
```
0
```

evaluates to
```
False
```

as a boolean data type.

Using the same example above I’ve replaced the logical operator with the multiplication symbol:

```
>>> e = 1
>>> f = -1
>>> (e > 0) * (f < 0)
1
>>> (e < 0) * (f < 0)
0
```

As you can see from the above code wrapping the conditions in parentheses helps to properly evaluate the expression. However, now the results instead are not boolean but rather numeric: either
```
1
```

or
```
0
```

.

The principle is still the same.

##
Why Not Use
```
||
```

For
```
or
```

?

Similar to the double ampersand for
```
and
```

in Python other languages use
```
||
```

(double pipes) for Python’s equivalent of
```
or
```

.

Using the syntax
```
||
```

for
```
or
```

in an expression will produce a
```
SyntaxError
```

as demonstrated in the following code:

```
>>> e = 10
>>> f = 100
>>> e > 0 || f < 0
File "<stdin>", line 1
e > 0 || f < 0
^
SyntaxError: invalid syntax
```

##
A Shortcut Way Of Using
```
or
```

If writing 2 characters is too much there is a way of using the principle of
```
or
```

by typing just one character: the humble addition symbol
```
+
```

.

Similar to how the logical operator
```
and
```

can be replaced with the multiplication symbol so too can the logical operator
```
or
```

be replaced with the mathematical symbol for addition
```
+
```

.

How does this addition principle work?

As
```
False
```

values are represented numerically as the number zero,
```
True
```

values are represented numerically as
```
1
```

, but any number
**
not
**
```
0
```

is deemed to be
```
True
```

.

Therefore, if all conditions in your expression are
```
False
```

when adding each condition the sum of zero would also be zero. Whereas if there was just one
```
True
```

condition

Here’s an example using the same example above with the
```
or
```

operator replaced with the
```
+
```

operator:

```
>>> e = 10
>>> f = 100
>>> (e > 0) + (f < 0)
1
>>> (e < 0) + (f < 0)
0
```

## Summary

Use the logical operator
```
and
```

when all conditions in your expression need to be satisfied. Use the
```
or
```

logical operator when only one condition in your expression need to be satisfied.

Instead of using the operators
```
and
```

and
```
or
```

you can use the mathematical equivalents
```
*
```

and
```
+
```

respectively.

Finally, Python does not permit the syntax equivalent of
```
and
```

with
```
&&
```

as other languages do. Also, you cannot use
```
||
```

for
```
or
```

as you will also get a
```
SyntaxError
```

.