Bitwise operator & in Python

Question

Recently I was solving one of the very basic problems on conditionals from Hackerrank.

The problem was:

If n is odd, print Weird
If n is even and in the inclusive range of 2 to 5 print Not Weird
If n is even and in the inclusive range of 6 to 20 print Weird
If n is even and greater than 20, print Not Weird

So i wrote the following code

if(n % 2 == 0 & n >=6 & n <= 20 ):
    print("Weird")
elif(n % 2 == 0 & n <= 2 & n >= 5): 
     print("Not Weird")
elif( n % 2 != 0):
     print("Weird")
else:
     print("Not Weird")

It didn't work at first. I figured out that i had to use "and" instead of "&".
But, I am not convinced why did this happen..
for n = 12, all 3 conditions of the first if condition are true. so true & true & true should also be true, right?

this photo shows the code snippet with some print messages

I am very intrigued to know the reason behind this behaviour, please guide! (may be something very minor but please don't mind :) )

Does this answer your question? [Logical vs bitwise](https://stackoverflow.com/questions/8418295/logical-vs-bitwise) — ChrisGPT was on strike, May 25 '20 at 18:15
it returns True if you do (n % 2 == 0) & (n >=6) & (n <= 20), so it is probably related to the order in which the elements are evaluated in the if-statement — Gal, May 25 '20 at 18:15
Does this answer your question? [chained AND condition gives ambiguous result](https://stackoverflow.com/q/37401219/354577) — ChrisGPT was on strike, May 25 '20 at 18:17
Does this answer your question? [chained AND condition gives ambiguous result](https://stackoverflow.com/questions/37401219/chained-and-condition-gives-ambiguous-result) — Mohd, May 25 '20 at 18:18
The second dupe I suggested is probably better. `&` and `and` have different precedence. — ChrisGPT was on strike, May 25 '20 at 18:18

score 0 · Answer 1 · answered May 25 '20 at 18:31

for n = 12, all 3 conditions of the first if condition are true.

>>> n = 12
>>> n % 2 == 0 & n >= 6 & n <= 20
False

The second condition is false (and the conditions aren't what you think they are, because bitwise operators are similar to other numeric operators [+, -, %, etc] in that they have higher precedence than comparison operators).

Let's break this down a little:

>>> n % 2
0
>>> 0 & n
0
>>> 6 & n
4
>>> 0 == 0 >= 4 <= 20
False

The expression is false because of the 0 & n >= 6 & n condition. 0 isn't greater than 4!

oh i see that's what happened! thanks for breaking it down so clearly! — sachin, May 26 '20 at 05:22

score 0 · Answer 2 · answered May 25 '20 at 18:38

It may not be immediately obvious from the grammar, but binary arithmetic operations bind tighter than binary bitwise operations. So your comparison is the same as

>>> if(n % 2 == (0 & n) >= (6 & n) <= 20 ):
...     print("Weird")
... 
>>>

Your "true & true &true" case is

>>> if((n % 2 == 0) & (n >=6) & (n <= 20) ):
...     print('Weird')
... 
Weird

But that only works because python True and False evaluate to 1 and 0. A bitwise operation only works because of this underlying representation.

score 0 · Accepted Answer · answered May 25 '20 at 19:06

Every time you have this kind of doubts, you can use the dis module, in your case I make a lambda function to evaluate the process:

func = lambda x: x % 2 == 0 & x >= 6 & x <= 20

this gives us the follow disassmbled code:

              0 LOAD_FAST                0 (x)
              2 LOAD_CONST               1 (2)
              4 BINARY_MODULO
              6 LOAD_CONST               2 (0)
              8 LOAD_FAST                0 (x)
             10 BINARY_AND
             12 DUP_TOP
             14 ROT_THREE
             16 COMPARE_OP               2 (==)
             18 JUMP_IF_FALSE_OR_POP    40
             20 LOAD_CONST               3 (6)
             22 LOAD_FAST                0 (x)
             24 BINARY_AND
             26 DUP_TOP
             28 ROT_THREE
             30 COMPARE_OP               5 (>=)
             32 JUMP_IF_FALSE_OR_POP    40
             34 LOAD_CONST               4 (20)
             36 COMPARE_OP               1 (<=)
             38 RETURN_VALUE
        >>   40 ROT_TWO
             42 POP_TOP
             44 RETURN_VALUE

explained is just:

Get var x value
Get const 2 value
Get modulo comparison between 2 and x, the answer is 0 when you use 12 as the param value.
Get const 0 value
Get var x value
Get Binary and comparison between 0 and x, naturally, a bitwise operation between any value (eg: b'1100') and b'0000' will return 0.
Next, values are stored in TOP and compared with == operator. This means as other answers said (x % 2) == (0 & x) at this time, with x being 12, the translated operation is 0 == 0 (True).
With the == result check if is False (in that case, jump to row 40 of bytecode) else, remove the result (POP) from TOS (Top of stack)
Get const 6 value
Get var x value
Another and comparison, this time between 6 (b'0110') and 12 (x = b'1100') with a result of 4 (b'0100')
The last result is stored in TOP and compared with >= operator with the last stored value (0 >= 4 as said in other answers).
Response from 0 >= 4 is then, evaluated in the next instruction, False causes than the code skip directly to the instruction 40 (Return False) without even test the last case.

Of course, this is the bytecode explanation of how python works, the short answer is the 0 & n >= 6 & n thing, with this in mind, we can assume than every number different from 0, will return False to this evaluation, because a bitwise operation between b'0110' will always be greater than 0.

TL;DR

Bitwise operators are evaluated before Boolean operators.

References

https://docs.python.org/3.8/library/dis.html Dis module reference.

thanks for the explanation, this will be useful for clearing any other doubts in future!! — sachin, May 26 '20 at 05:21

Bitwise operator & in Python

3 Answers3

TL;DR

References