Python: Why does right shift >> round down and where should it be used?

Question

I've never used the >> and << operators, not because I've never needed them, but because I don't know if I could have used them, or where I should have.

100 >> 3 outputs 12 instead of 12.5. Why is this. Perhaps learning where to best use right shift will answer that implicitly, but I'm curious.

Answer 1

>> and << are the right and left bit shift operators, respectively. You should look at the binary representation of the numbers.

>>> bin(100)
'0b1100100'
>>> bin(12)
'0b1100'

Answer 2

First of all:

Right shift is not divide

Now, we look at what right-shift actually does, and it will become clear.

First, recall that a number is stored in memory as a collection of binary digits. For example, if we have 8 bits of memory, we can store 2 as 00000010 and 5 as 00000101.

Right-shift takes those digits and shifts them to the right - for example, right-shifting our above two digits by one will give 00000001 and 00000010.

Notice that the lowest digit is shifted off the end entirely and has no effect on the final result.

Answer 3

Bit shifting an integer gives another integer. For instance, the number 12 is written in binary as 0b1100. If we bit shift by 1 to the right, we get 0b110 = 6. If we bit shift by 2, we get 0b11 = 3. And lastly, if we bitshift by 3, we get 0b1 = 1 rather than 1.5. This is because the bits that are shifted beyond the register are lost.

One easy way to think of it is bitshifting to the right by N is the same as dividing by 2^N and then truncating the result.

Answer 4

The other answers explain the idea of bitshifting, but here's specifically what happens for 100>>3

100
128 64 32 16 8 4 2 1
  0  1  1  0 0 1 0 0 = 100
100 >> 1
128 64 32 16 8 4 2 1
  0  0  1  1 0 0 1 0  = 50
100 >> 2
128 64 32 16 8 4 2 1
  0  0 0  1  1 0 0 1  = 25
100 >> 3
128 64 32 16 8 4 2 1
  0  0  0  0 1 1 0 0  = 12

You won't often need to use it, unless you need some really quick division by 2, but even then, DON'T USE IT. it makes the code much more complicated then it needs to be, and the speed difference is unnoticeable.

The main time you'd ever need to use it would be if you're working with binary data, and you specifically need to shift the bits around. The only real use I've had for it was reading & writing ID3 tags, which stores size information in 7-bit bytes, like so:

0xxxxxxx 0xxxxxxx 0xxxxxxx 0xxxxxxx.

which would need to be put together like this:

0000xxxx xxxxxxxx xxxxxxxx xxxxxxxx

to give a normal integer in memory.