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