# Python Bitwise AND Operator &

Python’s bitwise AND operator `x & y` performs logical AND on each bit position on the binary representations of integers `x` and `y`. Thus, each output bit is 1 if both input bits at the same position are 1, otherwise, it’s 0. For example, the integer expression 4 & 3 is translated to binaries 0100 & 0011 which results in 0000 because all four input bit positions are different.

In this example, you apply the bitwise AND operator to two integers 32 and 16:

```>>> 32 & 16
0```

The expression `32 & 16` operates on the bit representations `"010000"` (decimal 32) and `"001000"` (decimal 16) and performs bitwise AND. As all i-th bit positions are different, the result is 0:

Similarly, let’s have a look at a slightly modified example to showcase the bitwise AND operator:

```>>> 31 & 15
15```

You can see this in the following visualization:

The decimal representation of the bit sequence `"01111"` is 15.

## Python Bitwise & Operator Example

Here’s the result of the bitwise AND operator `x & y` when applied to a couple of example integer operands `x` and `y`:

You can see those examples in the following Python script:

```>>> 0 & 1
0
>>> 0 & 3
0
>>> 3 & 5
1
>>> 33 & 129
1
>>> 15 & 7
7
>>> 14 & 7
6```

Next, you’ll learn how to use the operator on negative integers. But first, you need to understand how negative integers are represented in the first place. This will boost your computer science skills, so keep reading! ?β?

## Representing Negative Integers in Binaries

Python uses so-called complementary binaries to represent negative integers. The first bit of a complementary binary is the sign (0: positive, 1: negative). All remaining bits encode the number. You write a negative number -x as the bit pattern for (x-1) and flip all bits from 1 to 0 and from 0 to 1 (complement).

Here are two simple examples:

• To represent `x = -1` using 8 bits you first calculate `(1-1) = 0` and then flip all bits to calculate `"11111111"`.
• To represent `x = -10` using 8 bits you first calculate `(10-1) = 9` which is `"00001001"` in binary format. Then, you complement all bits to determine the negative (complementary) binary `"11110110"`.

Let’s use this knowledge in a couple of examples to showcase the working of the bitwise AND operator on negative integers:

## Python Bitwise AND & – Examples on Negative Integers

Here’s the result of the bitwise and operator `x & y` when applied to a couple of negative integer operands `x` and `y`:

You can see those examples in the following script:

```>>> 0 & -1
0
>>> 0 & -3
0
>>> -3 & -5
-7```

## Python Bitwise versus Logical AND: “and” vs “&”

Python’s `and`” operator performs a logical AND operation that returns `True` if both operands are `True`. Python’s “`&`” symbol is a bitwise operator that works on the bit representations of the operands and performs a bit by bit operation. So, “`and`” tests whether both operands are logically `True` whereas “`&`” performs bitwise AND operation on the operands.

When considering only a single bit, semantically, such as when comparing Booleans, the operators are the same:

```>>> True and True
True
>>> True & True
True```

However, the difference becomes apparent if you use integer operands:

```>>> 32 and 16
16
>>> 32 & 16
0```

The first expression `32 and 16` determines that the integer value 32 results in a Boolean `True`, so it returns the second operand 16 as it performs the short-circuiting optimization.

The second expression 32 & 16 operates on the bit representations 10000 (decimal 32) and 01000 (decimal 16) and performs bit-wise AND. As all i-th bit positions are different, the result is 0:

Similarly, let’s have a look at another example to showcase the bitwise and operator:

```>>> 31 & 15
15```

You can see this in the following visualization:

The decimal representation of the bit sequence 01111 is 15.

To enable the bitwise AND operator on your custom object, use Python’s operator overloading functionality. Overloading works through what is called magic methods or dunder methods (for “double-underscore methods”). For the bitwise AND operator, the magic method is the `__and__(self, other)` method. It should return a new custom object that is the result of the bitwise operation.

Here’s a short overview of the Bitwise operators’ magic methods:

Here’s an example of how to accomplish these bitwise operators on a custom class `Data`. We marked this respective operator in the code:

```class Data:

def __init__(self, data):
self.data = data

def __and__(self, other):
return Data(self.data & other.data)

def __or__(self, other):
return Data(self.data | other.data)

def __xor__(self, other):
return Data(self.data ^ other.data)

def __invert__(self):
return Data(~self.data)

def __lshift__(self, other):
return Data(self.data << other.data)

def __rshift__(self, other):
return Data(self.data >> other.data)

x = 2
y = 3
print('Operands: \n', 'x =', x, '\n', 'y =', y)
print()
print('Bitwise AND: ', x & y)
print('Bitwise OR: ', x | y)
print('Bitwise XOR: ', x ^ y)
print('Bitwise NOT: ', ~x)
print('Bitwise LEFT-SHIFT: ', x << y)
print('Bitwise RIGHT-SHIFT: ', x >> y)
```

The output is:

```Operands:
x = 2
y = 3

Bitwise AND:  2
Bitwise OR:  3
Bitwise XOR:  1
Bitwise NOT:  -3
Bitwise LEFT-SHIFT:  16
Bitwise RIGHT-SHIFT:  0```

## Bitwise Operators

Bitwise operators perform operations on the binary (bit) representation of integers. The following table gives a short overview of all existing bitwise operators. Note that we also provide the binary representation `100` for the decimal integer `4`, and `101` for the decimal integer `5` as a comment in the right column.