Bytes, Nibbles, and Bits in Python

  • 11/4/2013
  • 3-minute read

Binary

Binary is nothing more than a base 2 numbering system using the numbers 0 and 1.

Bit

A Bit is merely a single number of either 1 and 0 within the binary.

Byte

A Byte consists of 8 bits. A byte containing all 0s will be the integer 0, while a byte containing all 1s will be the integer of 255.

Nibble

A Nibble consits of 4 bits. A nibble containing all 0s will be the iteger 0, while a nibble containing all 1s will be the integer 15 (very useful for hex numbers).

Python code

What I want to do is write a Python class for taking a valid byte (number from 0 - 255) , and get its binary representation. I would also like to get the high nibble and low nibble from that binary.

Constructor

Lets start by making a constructor and verifying we have a valid byte.

class Byte(object):
    """Do cool things with a 8 bit number"""

    def __init__(self, number):
        if not self.__isbyte(number):
            raise Exception('"%s" is not a 8 bit integer' % number)
        self.number = number

    def __isint(self, number):
        """Check if a input is of type int"""
        if type(number) == int:
            return True

    def __isbyte(self, number):
        """Check if a input is a byte, 0 - 255"""
        if self.__isint(number):
            if len(bin(number)[2:]) <= 8:
                return True

Alright, this code will let us define a object and verify it is a 8 bit integer.

Binary Representation

Next lets create the pretty binary representation with leading 0s as padding.

def __format(self, num, size=8):
    """Format a number as binary with leading zeros"""
    return str(bin(num)[2:]).zfill(size)

@property
def binary(self):
    """Return Byte in binary"""
    return self.__format(self.number)

Here I wrote a small helper function for extracting the binary representation from the bin function and stripped the leading 0b. The binary property will return the binary.

High Nibble

Being all bytes are 8 bits, we can be sure a byte will have a high nibble (first 4 bits) , and a low nibble (last 4 bits) .

In order to get our high nibble all we need to do is use the bitwise right shift operator.

def __high_nibble(self):
    """Use Bitwise shift to get high nibble from byte"""
    return self.number >> 4

@property
def high_nibble(self):
    """Return High Nibble in binary"""
    return self.__format(self.__high_nibble(), 4)

Low Nibble

In order to get our low nibble we can use the bitwise AND operator with a mask of 15 (remember 15 is a nibble of all 1s) .

def __low_nibble(self):
    """Use Bitwise AND to get low nibble"""
    return self.number & 0x0F  # 0x0F == 15

@property
def low_nibble(self):
    """Return Low Nibble in binary"""
    return self.__format(self.__low_nibble(), 4)

Code in action

There you have it, lets go ahead and give it a try.

In [1]: myByte = Byte(15)

In [2]: myByte.binary
Out[2]: '00001111'

In [3]: myByte.high_nibble
Out[3]: '0000'

In [4]: myByte.low_nibble
Out[4]: '1111'
DevelopmentPython