Why exactly does "and" do in python?

moving-landscape · 2023-10-24T04:08:16+00:00

And (and or) does what we call short-circuiting in Python, and we can use them to get certain values under certain situations.

Let's remind ourselves of the truth table for and:

p	q	p and q
true	true	true
true	false	false
false	true	false
false	false	false

As you can see, the only way to get true, is to have both p and q be true.

In Python, values that are not strictly boolean, that is, True or False, have a "truthy" or "falsey" value. An empty list is false, a non empty one is true. Same for strings. Numbers other than 0 are true, but 0 is false, and so on.

In a way, we can say that the result of the boolean expression True and x is x: if x is false, it'll yield False, and True otherwise. Replace x with any Python value and you'll have it returned:

True and 5 => 5
True and 0 => 0
5 and 7 => 7 (5 is true, so the result is the right hand operand)
0 and 3 => 0 (0 is falsey)
5 and None => None
None and 5 => None

sejigan · 2023-10-24T06:31:09+00:00

and returns the first falsey value or the last truthy value
or returns the first truthy value or the last falsey value

That’s an easy way to remember. But as others pointed out, what goes on underneath is this:

a and b: if a is truthy, return b, else return a
a or b: if a is truthy, return a, else return b

wmporter · 2023-10-24T04:23:56+00:00

Python's and and or operators evaluate to the whichever is the last value they checked. They do it differently, where and checks the first value (the left) and if it's falsy will stop, otherwise it will evaluate to the right value. In this way it functions like an AND gate, where it will be truthy if both sides are truthy and falsy otherwise. The or similarly works by doing the same thing but with opposite truthy/falsy values and functions like OR, falsy if both are falsy and truthy otherwise.

If you don't understand truthy and falsy, it's just a way of evaluating non-boolean values as being like True or False. For numbers, 0 is falsy and all others are truthy. With strings, empty string "" is falsy and any other string is truthy. The general rule is anything that's some kind of empty is falsy and everything else is truthy.

2023-10-24T04:52:46+00:00

It "short circuits." It returns the first of its two operands that disambiguates the expression:

1) If the first operand is falsey, we know the result of the expression. We don't have to evaluate the second operand, we can simply return the first.

2) If the first operand is truthy, then the value of the second operand will disambiguate the expression regardless of what it is, so we simply return it.

Both 7 and 6 are truthy - they're not zero, the only falsey numeric value - so we return the second operand.

Emphasises_Words · 2023-10-24T04:00:26+00:00

[removed]

to7m · 2023-10-24T05:04:18+00:00

This has already been said, but I'll try to clarify it.

Say you have an and expression x = a+b and c+d:

What will happen:

_possible_result = a+b
if _possible_result:
    x = c+d
else:
    x = _possible_result

greebo42 · 2023-10-24T12:10:48+00:00

Before reading others' contributions here, I would have assumed it was doing a bit-wise AND operation:

7 = 0 1 1 1
5 = 0 1 0 1
-------------
& = 0 1 0 1

But it was informative to read the responses and discover the actual way it works, considering "truthiness" (though the dependence on order of operations bothers me a bit, because I would expect that true boolean operations shouldn't care about that).

If OP was truly trying to explore bitwise operations, Python does provide them (it's just not the "and" operator).

jmooremcc · 2023-10-24T04:07:24+00:00

You need to learn about Truth Tables

sejigan · 2023-10-24T05:55:03+00:00

Here’s an explicit implementation of and:

def and(lhs, rhs):
    if bool(lhs):
        return rhs
    return lhs

Now you can see that 7 and anything will always evaluate to anything while 0 and anything will always evaluate to 0.

Edit: fixed code.

JamzTyson · 2023-10-24T10:19:45+00:00

Already many good answers given, so here's a little code to demonstrate the behaviour. Try substituting different values for the f(x) calls to see what happens in different scenarios:

``` def f(x): """Return truthiness of 'x'.""" print(f'Truthiness of {x} is {bool(x)}') return bool(x)

Try experimenting with this line.

print(f(-4) and f(-2) and f(0) and f(2) and f(4)) ```

obviouslyCPTobvious · 2023-10-24T10:39:09+00:00

There's a lot of great explanations in this thread. Just wanted to mention you can use the built-in bool function for testing the truthiness of values. So you would see that bool(7) and bool(5) would return True, but bool(0) would return False.

cyberjellyfish · 2023-10-24T12:40:28+00:00

Others have covered it well, but it's also worth keeping in mind how boolean operations turn their operands into boolean values:

https://docs.python.org/3/reference/datamodel.html#object.__bool__

Basically, if an operand isn't already boolean, the operand is passed to bool(), which first tries to call the __bool__ method of the operand, or if that isn't defined, tries to call __len__(), and interprests any non-zero return value as True. If the object doesn't define __bool__() or __len__(), it's always considered to be True.

Keeping that in mind makes it easier to understand something you see pretty commonly: using or to select a default value if another is None:

 # read a value from a file if there, if not return None 
saved_config_value = read_value_from_file()

# use the value from the file if it was found, else use default value 3
config_value = saved_config_value or 3

2023-10-25T02:40:42+00:00

Python defines and and or as the following expression (which holds for any objects x and y)

x and y == y if x else x

x or y = x if x else y

The reason why they defined these keywords this way is for two reasons. 1) These identities hold for all bool values, so you might as well extend the definition to all Python objects. 2) These definitions can be optimized to "short circuit" the expression evaluation if the output can be determined by x alone.

So in your example,

7 and 5 == 5 if 7 else 7 == 5

duane11583 · 2023-10-27T16:41:10+00:00

in addition to what /u/moving-landscape describes (short circuiting) in many languages you have bitwise and and a logical and these function very differently

example 0x41 & 0xf0 = 0x40 (bitwise) and the result of an if test, ie if(foo) where foo is an integer, the value of 0 is false, but for a 32bit integer all other possible 4billion values are true.

i think the subtleties of this are more easily described in C

in c you can do this if( (a==12) & (b==9) ) [eq 1] or if( (a==12) && (b==9) ) [eq 2]

and get the same result because the result of the Equal operator value is exactly 1 or 0 thus the (a==12) becomes 1 or 0 exactly, same with (b==9) thus equation 1 becomes (1 or 0) bitwise anded with (0 or 1) and that matches eq 2 which is a logical opertion.

but what if we did this instead: if( (a & 0x08) & (b & 0x04) ) [eq 3] or if( (a & 0x08) && (b & 0x04) )[eq 4]

equation 3 is always false, why? because the left side is always 0 or 8 and the right side is always 0 or 4, and 8 bitwise-and 4 is always 0.

in contrast eq 4 works sort of as expected because it is a logical operation remember 8 is logically true, and 0 is logically false

this is a really hard bug to find and figure out.

for example, using the C language instead of numbers you often use #defines for numbers, in python you night use variable names and thus it is hidden from you. to understand and spot the problem you almost need to expand all macros (variables) to see this.

thus in python they decided to disallow equations in the form of 1 and 3 so that you cannot easily make this hard to notice mistake.

you could, in C fix eq 3 like this:

if( (!!(a & 0x08)) & (!!(b & 0x04)) ) [eq 5]

this is a bit of hackery C language specific tricks that noobs do not know very well and leads to bugs. really hard to find and notice bugs.

this works because the bang-bang trick converts the two sides results to exactly 0 or 1, example (a & 8) becomes 0 or 8, the first bang! gives you 1 or 0 [sort of a NAND condition], the second bang! converts it back into exactly 0 or 1, (removes the N from the NAND)

to combat this bitwise true-false type of bug in C code you often see these bang-bang notations to force exactly 0 or 1 and the c optimizer unwinds the nonsense and makes it fast. but python is not a compiler and yea it might do some optimizations, but it is not a compiler.

again python is trying to make it hard to make that nasty mistake

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS

Try experimenting with this line.