Ytukyg

In theory, and and or come straight from boolean logic (and therefore operate on two booleans to produce a boolean), while & and | apply the boolean and/or to the individual bits of integers. There are a lot lot of questions here on how the latter work exactly.

Here are practical differences that potentially affect your results:

1. 
   and and or short-circuiting, i.e. True or sys.exit(1) will not exit, because for a certain value (True or ..., False and ...) of the first operand, the second one wouldn't change the result = does not need to be evaluated. But | and & don't short-circuit - True | sys.exit(1) throws you outta the REPL.


2. (Only applies to some? languages with operator overloading, including Python:) & and | are regular operators and can be overloaded - and and or are forged into the language (although at least in Python, the special method for coercion to boolean may have side effects).


3. (only applies to a few languages [see KennyTM's comment]:) and and or return (always? never really understand this, nor did I need it) the value of an operand instead of True or False. This doesn't change the meaning of boolean expressions in conditions - 1 or True is 1, but 1 is true, too. But it was once used to emulate a conditional operator (cond ? true_val : false_val in C syntax, true_val if cond else false_val in Python since a few years). For & and |, the result type depends on how the operands overload the respective special methods (True & False is False, 99 & 7 is 3, for sets it's unions/intersection...).

But even when e.g. a_boolean & another_boolean would work identically, the right solution is using and - simply because and and or are associated with boolean expression and condition while & and | stand for bit twiddling.

Here's a further difference, which had me puzzled for a while just now: because & (and other bitwise operators) have a higher precedence than and (and other boolean operators) the following expressions evaluate to different values:

0 < 1 & 0 < 2

versus

0 < 1 and 0 < 2

To wit, the first yields False as it is equivalent to 0 < (1 & 0) < 2, hence 0 < 0 < 2, hence 0 < 0 and 0 < 2.

If you are trying to do element-wise boolean operations in numpy, the answer is somewhat different. You can use & and | for element-wise boolean operations, but and and or will return value error.

To be on the safe side, you can use the numpy logic functions.

np.array([True, False, True]) | np.array([True, False, False])

# array([ True, False,  True], dtype=bool)



np.array([True, False, True]) or np.array([True, False, False])

# ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()



np.logical_or(np.array([True, False, True]), np.array([True, False, False]))

# array([ True, False,  True], dtype=bool)

Boolean operation are logical operations.

Bitwise operations are operations on binary bits.

Bitwise operations:

>>> k = 1

>>> z = 3

>>> k & z  

1

>>> k | z  

3

The operations:

And & 1 if both bits are 1, 0 otherwise

Or  | 1 if either bit is 1

Xor ^ 1 if the bits are different, 0 if they're the same

Not ~ Flip each bit

Some of the uses of bitwise operations:

1) Setting and Clearing Bits

Boolean operations:

>>> k = True

>>> z = False

>>> k & z  # and

False

>>> k | z  # or

True

>>> 

The hint is in the name:

• Boolean operators are for performing logical operations (truth testing common in programming and formal logic)


• Bitwise operators are for "bit-twiddling" (low level manipulation of bits in byte and numeric data types)

While it is possible and indeed sometimes desirable (typically for efficiency reasons) to perform logical operations with bitwise operators, you should generally avoid them for such purposes to prevent subtle bugs and unwanted side effects.

If you need to manipulate bits, then the bitwise operators are purpose built. The fun book: Hackers Delight contains some cool and genuinely useful examples of what can be achieved with bit-twiddling.

The general rule is to use the appropriate operator for the existing operands. Use boolean (logical) operators with boolean operands, and bitwise operators with (wider) integral operands (note: False is equivalent to 0, and True to 1). The only "tricky" scenario is applying boolean operators to non boolean operands.
Let's take a simple example, as described in [SO]: Python - Differences between 'and' and '&' [duplicate]: 5 & 7 vs. 5 and 7.

For the bitwise and (&), things are pretty straightforward:

5     = 0b101

7     = 0b111

-----------------

5 & 7 = 0b101 = 5

For the logical and, here's what [Python 3]: Boolean operations states (emphasis is mine):

(Note that neither and nor or restrict the value and type they return to False and True, but rather return the last evaluated argument.

Example:

>>> 5 and 7

7

>>> 7 and 5

5

Of course, the same applies for | vs. or.

Boolean 'and' vs. Bitwise '&':

Pseudo-code/Python helped me understand the difference between these:

def boolAnd(A, B):

    # boolean 'and' returns either A or B

    if A == False:

        return A

    else:

        return B



def bitwiseAnd(A , B):

    # binary representation (e.g. 9 is '1001', 1 is '0001', etc.)



    binA = binary(A)

    binB = binary(B)







    # perform boolean 'and' on each pair of binaries in (A, B)

    # then return the result:

    # equivalent to: return ''.join([x*y for (x,y) in zip(binA, binB)])



    # assuming binA and binB are the same length

    result = 

    for i in range(len(binA)):

      compar = boolAnd(binA[i], binB[i]) 

      result.append(compar)



    # we want to return a string of 1s and 0s, not a list



    return ''.join(result)