Bitwise operation and usage

by

Bitwise operators are operators that work on multi-bit 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 8-bit value shifting left four bits:

bits8 = (bits8 << 4) & 255

With that in mind, another example of bitwise operators is if you have two 4-bit values that you want to pack into an 8-bit one, you can use all three of your operators (left-shift, and and or):

packed_val = ((val1 & 15) << 4) | (val2 & 15)
  • The & 15 operation will make sure that both values only have the lower 4 bits.
  • The << 4 is a 4-bit shift left to move val1 into the top 4 bits of an 8-bit value.
  • The | simply combines these two together.

If val1 is 7 and val2 is 4:

                val1            val2
                ====            ====
 & 15 (and)   xxxx-0111       xxxx-0100  & 15
 << 4 (left)  0111-0000           |
                  |               |
                  +-------+-------+
                          |
| (or)                0111-0100

More Related Contents:

  1. Two’s Complement Binary in Python?
  2. Python: Does Python have a ternary conditional operator?
  3. a pythonic way of doubling consecutive binary bits [closed]
  4. “is” operator behaves unexpectedly with integers
  5. Reading binary file and looping over each byte
  6. and / or operators return value [duplicate]
  7. What exactly does += do?
  8. Converting integer to binary in python
  9. Python: defining my own operators?
  10. How can I obtain the element-wise logical NOT of a pandas Series?
  11. Fast way of counting non-zero bits in positive integer
  12. What does % do to strings in Python?
  13. Python != operation vs “is not”
  14. Why is ” > 0 True in Python 2?
  15. Override Python’s ‘in’ operator?
  16. What is the motivation for the “or” operator to not return a bool?
  17. How can I detect if a file is binary (non-text) in Python?
  18. Modulo operator in Python
  19. Overloading Addition, Subtraction, and Multiplication Operators
  20. Python augmenting multiple variables inline
  21. What is the difference between ‘+=’ and ‘=+’? [duplicate]
  22. Is & faster than % when checking for odd numbers?
  23. Reversing bits of Python integer
  24. Is there a short-hand for nth root of x in Python?
  25. Reading integers from binary file in Python
  26. Binary buffer in Python
  27. How does Python’s bitwise complement operator (~ tilde) work?
  28. Convert int to binary string in Python
  29. Under what circumstances are __rmul__ called?
  30. Why should I use operator.itemgetter(x) instead of [x]?

Leave a Comment