# Bytes, Nibbles, and Bits in Python

## 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'