Splitting a 16 bit int into two 8 bit ints in python

I have to convert a given 16 bit integer into two 8 bit integers, which are then taken and used as output, where they are headed takes the two 8 bit integers and recombines them as 16 bit input (unfortunately out of my control). My solution works, but feels unclean. For the coarse number I am bit shifting the开发者_开发知识库 original number, and for the fine number I am looking at it modulo 256.

So should I be doing floor division for the coarse number, or should I be taking the lowest 8 bits for the fine number (and if so how?)?

Or am I crazy and using two different methods to split the number is not a problem?

def convert(x):
    ''' convert 16 bit int x into two 8 bit ints, coarse and fine.

    '''
    c = x >> 8  # The value of x shifted 8 bits to the right, creating coarse.
    f = x % 256  # The remainder of x / 256, creating fine.
    return c, f

---

I would do

c = (x >> 8) & 0xff
f = x & 0xff

It is safer, see e.g.

>>> (10303 >> 8) & 0xff
40
>>> (1030333333 >> 8) & 0xff
163
>>> (1030333333 >> 8) 
4024739

Since in python you can't control if the number is or not a 16bit, you have to force it into an at most 16-bit value. This is not needed if you're sure to have a 16-bit value, but this way the function is more general and allows you to be interested only in 16-bit values, no matter what the container contains.

---

In python, bit-fiddling doesn't have any particular advantage, so I would go with:

c, f= divmod(your_number, 256)

EDIT: To make your intention even more obvious to the powers-of-two-challenged source viewer (if such a beast exists), you can replace the plain 256 with much more colourful alternatives, like 1<<8, 2**8, 0x100 or 0400 (that is 0o400 for Python 3). The constant folding done by the peephole optimizer since Python 2.5 ensures that any of them is exactly the same like using 256 (I'm obviously talking about the former two alternatives, which are expressions that evaluate to 256; the latter two are the constant 256).

$ python
Python 2.6.4 (r264:75706, Dec  7 2009, 18:45:15)
[GCC 4.4.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import dis
>>> dis.dis(compile("c, f= divmod(your_number, 1<<8)", "", "exec"))
  1           0 LOAD_NAME                0 (divmod)
              3 LOAD_NAME                1 (your_number)
              6 LOAD_CONST               3 (256)
              9 CALL_FUNCTION            2
             12 UNPACK_SEQUENCE          2
             15 STORE_NAME               2 (c)
             18 STORE_NAME               3 (f)
             21 LOAD_CONST               2 (None)
             24 RETURN_VALUE

---

You should be consistent, if the intent of the operations is arithmetical, use modulo and division, if it's just for raw bit manipulation, use shift and mask.

---

You say you're using these numbers as output, which suggests that they're going to be converted into strings at some point down the line. With that in mind, I'd suggest you take a look at the struct module, which is designed for precisely this sort of thing (packing numbers into strings of binary data). As a bonus, you get built-in error checking for the case where x is greater than 65535 (so that if something is horribly wonky in your program, you'll get an exception). For example,

s = struct.pack('>H', x)

is the equivalent of

if x > 65535:
    raise struct.error(...)
c, f = convert(x)
s = chr(c) + chr(f) # big-endian (network) byte ordering

If you need the other byte ordering, you can write

s = struct.pack('<H', x)

If you have a whole bunch of numbers to convert at once, struct.pack can do them in bunches:

x = [10333, 10475, 3021, ...] # for example
s = struct.pack('>' + 'H' * len(x), *x)

---

If you use the two halves of the number in different places, I'd recommend having two separate functions, but if you're going to use them in the same place, one function will work just as well.

There are several correct ways to split the number, so eventually it all comes down to personal preference. Your code will work fine, just so long as you only pass in numbers that are at most 16 bits long. (which probably won't be much of a problem, but you should be aware of it)

---

I would use the bitwise & rather than %. It probably makes little difference these days for short integers, but in the wider view, the & operator is potentially more efficient.

There may be some issue about how % handles negative numbers, but I doubt that that's relevant here.

---

Here is an alternative solution I like:

def convert(x, n_bytes=2, order='big'):
    msb, *lsb = x.to_bytes(n_bytes, byteorder=order)
    return (msb, *lsb)

you can change the number of output bytes by changing n_bytes. There order can be switched by setting order='little'

exmample output

In [51]: convert(0x00)
Out[51]: (0, 0)

In [52]: convert(0xff)
Out[52]: (0, 255)

In [53]: convert(0x01ff)
Out[53]: (1, 255)

In [55]: convert(0x7fff)
Out[55]: (127, 255)

error if value is to big:

In [54]: convert(0xffffff)
---------------------------------------------------------------------------
OverflowError                             Traceback (most recent call last)
Input In [54], in <cell line: 1>()
----> 1 convert(0xffffff)

Input In [48], in convert(x, n_bytes, order)
      1 def convert(x, n_bytes=2, order='big'):
----> 2     msb, *lsb = (x).to_bytes(n_bytes, byteorder=order)
      3     return (msb, *lsb)

OverflowError: int too big to convert