We've already seen the usual math operators: +, -, *, /, %, **; as well as the abs( x ) and pow( x , y ) functions. There are several other operators available to us. Principally, these are for manipulating the individual bits of an integer value.

The unary ~ operator flops all the bits in a plain or long integer. 1's become 0's and 0's become 1's. Since most hardware uses a technique called 2's complement, this is mathematically equivalent to adding 1 and switching the number's sign.

>>> 
print ~0x12345678

-305419897

There are binary bit manipulation operators, also. These perform simple Boolean operations on all bits of the integer at once.

The binary & operator returns a 1-bit if the two input bits are both 1.

>>> 
print 0&0, 1&0, 1&1, 0&1

0 0 1 0

Here's the same kind of example, combining sequences of bits. This takes a bit of conversion to base 2 to understand what's going on.

>>> 
print 3&5

1

The number 3, in base 2, is 0011. The number 5 is 0101. Let's match up the bits from left to right:

 0 0 1 1
& 0 1 0 1
 -------
 0 0 0 1

The binary ^ operator returns a 1-bit if one of the two inputs are 1 but not both. This is sometimes called the exclusive or.

>>> 
print 3^5

6

Let's look at the individual bits

 0 0 1 1
^ 0 1 0 1
 -------
 0 1 1 0

Which is the binary representation of the number 6.

The binary | operator returns a 1-bit if either of the two inputs is 1. This is sometimes called the inclusive or. Sometimes this is written and/or .

>>> 
print 3|5

7
>>>

Let's look at the individual bits.

 0 0 1 1
| 0 1 0 1
 -------
 0 1 1 1

Which is the binary representation of the number 7.

There are also bit shifting operations. These are mathematically equivalent to multiplying and dividing by powers of two. Often, machine hardware can execute these operations faster than the equivalent multiply or divide.

The << is the left-shift operator. The left argument is the bit pattern to be shifted, the right argument is the number of bits.

>>> 
print 0xA << 2

40

0xA is hexadecimal; the bits are 1-0-1-0. This is 10 in decimal. When we shift this two bits to the left, it's like multiplying by 4. We get bits of 1-0-1-0-0-0. This is 40 in decimal.

The >> is the right-shift operator. The left argument is the bit pattern to be shifted, the right argument is the number of bits. Python always behaves as though it is running on a 2's complement computer. The left-most bit is always the sign bit, so sign bits are shifted in.

>>> 
print 80 >> 3

10

The number 80, with bits of 1-0-1-0-0-0-0, shifted right 3 bits, yields bits of 1-0-1-0, which is 10 in decimal.

There are some other operators available, but, strictly speaking, they're not arithmetic operators, they're logic operations. We'll return to them in Chapter 7, Truth, Comparison and Conditional Processing .