Consider this code:
x = 1 # 0001
x << 2 # Shift left 2 bits: 0100
# Result: 4
x  2 # Bitwise OR: 0011
# Result: 3
x & 1 # Bitwise AND: 0001
# Result: 1
I can understand the arithmetic operators in Python (and other languages), but I never understood 'bitwise' operators quite well. In the above example (from a Python book), I understand the leftshift but not the other two.
Also, what are bitwise operators actually used for? I'd appreciate some examples.
Bitwise operators are operators that work on multibit values, but conceptually one bit at a time.
AND
is 1 only if both of its inputs are 1, otherwise it's 0.OR
is 1 if one or both of its inputs are 1, otherwise it's 0.XOR
is 1 only if exactly one of its inputs are 1, otherwise it's 0.NOT
is 1 only if its input is 0, otherwise it's 0.These can often be best shown as truth tables. Input possibilities are on the top and left, the resultant bit is one of the four (two in the case of NOT since it only has one input) values shown at the intersection of the inputs.
AND  0 1 OR  0 1 XOR  0 1 NOT  0 1
+ + + +
0  0 0 0  0 1 0  0 1  1 0
1  0 1 1  1 1 1  1 0
One example is if you only want the lower 4 bits of an integer, you AND it with 15 (binary 1111) so:
201: 1100 1001
AND 15: 0000 1111

IS 9 0000 1001
The zero bits in 15 in that case effectively act as a filter, forcing the bits in the result to be zero as well.
In addition, >>
and <<
are often included as bitwise operators, and they "shift" a value respectively right and left by a certain number of bits, throwing away bits that roll of the end you're shifting towards, and feeding in zero bits at the other end.
So, for example:
1001 0101 >> 2 gives 0010 0101
1111 1111 << 4 gives 1111 0000
Note that the left shift in Python is unusual in that it's not using a fixed width where bits are discarded  while many languages use a fixed width based on the data type, Python simply expands the width to cater for extra bits. In order to get the discarding behaviour in Python, you can follow a left shift with a bitwise and
such as in an 8bit value shifting left four bits:
bits8 = (bits8 << 4) & 255
With that in mind, another example of bitwise operators is if you have two 4bit values that you want to pack into an 8bit one, you can use all three of your operators (leftshift
, and
and or
):
packed_val = ((val1 & 15) << 4)  (val2 & 15)
& 15
operation will make sure that both values only have the lower 4 bits.<< 4
is a 4bit shift left to move val1
into the top 4 bits of an 8bit value.
simply combines these two together.If val1
is 7 and val2
is 4:
val1 val2
==== ====
& 15 (and) xxxx0111 xxxx0100 & 15
<< 4 (left) 01110000 
 
+++

 (or) 01110100
One typical usage:

is used to set a certain bit to 1
&
is used to test or clear a certain bit
Set a bit (where n is the bit number, and 0 is the least significant bit):
unsigned char a = (1 << n);
Clear a bit:
unsigned char b &= ~(1 << n);
Toggle a bit:
unsigned char c ^= (1 << n);
Test a bit:
unsigned char e = d & (1 << n);
Take the case of your list for example:
x  2
is used to set bit 1 of x
to 1
x & 1
is used to test if bit 0 of x
is 1 or 0