Digital Information

Decimal (Base 10)

• The everyday number system we use.
• Digits: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
• Example: 123

Binary (Base 2)

• Used by computers to represent data.
• Digits: 0, 1
• Example: 1101
• To represent binary numbers in Python, use the 0b prefix.

Octal (Base 8)

• Sometimes used in older systems.
• Digits: 0, 1, 2, 3, 4, 5, 6, 7
• Example: 17
• To represent octal numbers in Python, use the 0o prefix.

Hexadecimal (Base 16)

• Commonly used in computer programming, especially for representing colors and memory addresses.
• Digits: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F
• Example: A3
• To represent hexadecimal numbers in Python, use the 0x prefix.

## NUMBER SYSTEM EXAMPLES ##
# Print command displays all types in decimal
decimal_number = 42
print(decimal_number)

binary_number = 0b1101
print(binary_number) # Prints in de

octal_number = 0o17
print(octal_number)

hexadecimal_number = 0xA3
print(hexadecimal_number)

print(bin(decimal_number)) # Convert Decimal to Binary with bin()

print(oct(decimal_number)) # Convert Decimal to Binary with oct()

print(hex(decimal_number)) # Convert Decimal to Binary with hex()

42
13
15
163
0b101010
0o52
0x2a

Common Python Encodings:

ASCII

• A 7-bit encoding standard for English characters.
• Limited to 128 characters, making it unsuitable for many languages.

UTF-8

• A variable-length encoding scheme that can represent all characters in the Unicode standard.
• Widely used due to its efficiency and compatibility with ASCII.

UTF-16

• A fixed-width 16-bit encoding scheme for Unicode characters.
• More efficient for languages with a large character set, but less efficient for English text.

Latin-1

• An 8-bit encoding scheme for Western European languages.
• Limited to 256 characters.

## ENCODING & DECODING EXAMPLES ##
text = "Hello, world!"
encoded_text = text.encode('utf-8')  # Encodes the text in UTF-8
print(encoded_text)

decoded_text = encoded_text.decode('utf-8')
print(decoded_text)

b'Hello, world!'
Hello, World!

This Python code generates an ASCII table, displaying each character, its decimal, octal, hexadecimal, and binary representations.

## ASCII TABLE ##
print("CHR\tDEC\tOCT\tHEX\tBIN")
for i in range(0,256):
	print(f"{chr(i)}\t{i}\t{oct(i)}\t{hex(i)}\t{bin(i)}")

Color Formatting

There exist many ways to represent colors with computers but the most common two are RGB and HEX. It is important to note that the HEX format is just an encoding of the the RGB values, not an entierly different format such as HSV.

• RGB: Stands for Red, Green, Blue. It's a color model that uses three values, each ranging from 0 to 255, to represent a color.
• Hexadecimal: A 6-digit hexadecimal number, where each pair of digits represents the intensity of Red, Green, and Blue, respectively.

## RGB/HEX CONVERSIONS ##
def rgb_to_hex(r, g, b):
  hex_color = "#"
  for color_value in (r, g, b):
    hex_value = hex(color_value)[2:]
    hex_color += hex_value.zfill(2)
  return hex_color

def hex_to_rgb(hex_string):
	r = int(hex_string[1:3], 16)
	g = int(hex_string[3:5], 16)
	b = int(hex_string[5:], 16)
	return (r, g, b)

rgb_color = (102, 51, 153)
hex_color = rgb_to_hex(*rgb_color)
print(hex_color)

hex_color = "#663399"
rgb_color = hex_to_rgb(hex_color)
print(rgb_color)

#663399
(102, 51, 153)

Leveraging PIL

Python Imaging Library (PIL) is a popular Python library for opening, manipulating, and saving images. It provides a user-friendly interface to perform various image processing tasks. Here are some common image manipulation techniques you can achieve with PIL.

Note: All these examples require we import PIL.

from PIL import Image

Opening and saving

img = Image.open('open_file_path.jpg') # Open the image
img.show()  # Display the image
img.save('save_file_path.jpg') # Save the image

Resizing

resized_img = img.resize((200, 200))

Cropping

cropped_img = img.crop((100, 100, 300, 300))  # (left, top, right, bottom)

Rotating

rotated_img = img.rotate(90)

## BLACK & WHITE IMAGE FILTER ##
from PIL import Image

FILE_PATH = "ric_n_morty_2024.png"
img = Image.open(FILE_PATH)

pxls = img.load()
for y in range(img.height):
	for x in range(img.width):
		pxl = img.getpixel((x, y))
		grey = (pxl[0]+pxl[1]+pxl[2])//3
		pxls[x,y] = (grey,grey,grey)
		
img.show()
img.save("mod_"+FILE_PATH)

Lossless Compression

• This method reduces file size without losing any of the original data.
• It works by identifying patterns in the data and replacing them with shorter codes.
• Common lossless compression algorithms include:
  • Huffman Coding: Assigns shorter codes to more frequent symbols and longer codes to less frequent ones.
  • Lempel-Ziv-Welch (LZW): Replaces repeated sequences of data with shorter codes.

Lossy Compression

• This method reduces file size by discarding some of the original data.
• It's suitable for data types like images and audio, where a slight loss in quality is often imperceptible.
• Common lossy compression algorithms include:
  • JPEG: Reduces the color depth and spatial resolution of images.
  • MP3: Reduces the number of audio samples and discards inaudible frequencies.

Types of Cryptography:

Key Considerations:

• Key Strength: A strong key is essential for secure encryption.
• Algorithm Choice: Select a robust and secure cryptographic algorithm.
• Implementation Security: Avoid common vulnerabilities like weak key generation, insecure random number generation, and implementation errors.
• Secure Key Storage and Distribution: Protect keys from unauthorized access.

Fernet is a symmetric encryption scheme built on top of AES with a 128-bit key. It is a good choice for general-purpose encryption tasks.

## FERNET ENCRYPTION/DECRYPTION EXAMPLE ##
from cryptography.fernet import Fernet

def encrypt(msg, key):
    cipher = Fernet(key)
    ciphertext = cipher.encrypt(msg.encode())
    return ciphertext   

def decrypt(enc_msg, key):
    cipher = Fernet(key)
    plaintext = cipher.decrypt(enc_msg)
    return plaintext.decode()

message = "Hello, World!"

# Generate a key
key = Fernet.generate_key()
print("Key:\n", key)

# Encrypt the message
ciphertext = encrypt(message, key)
print("Encrypted Message:\n", ciphertext)

# Decrypt the message
decrypted_message = decrypt(ciphertext, key)
print("Decrypted Message:\n", decrypted_message)