A Comprehensive Guide to Using Python `bytes` Types with Examples

In Python, the `bytes` type is a fundamental data structure that represents a sequence of byte. Bytes are essential for handling binary data, such as images, files, network packets, and more. Understanding how to use `bytes` is crucial for working with low-level data and ensuring the integrity of data transmission. In this guide, we will delve into the `bytes` type, its properties, methods, and provide practical examples to showcase its usage.

Table of Contents

1. What is Byte?

A byte is a fundamental unit of digital information storage and processing.

It represents a group of 8 binary digits (bits), each of which can be either 0 or 1.
A byte is the smallest addressable unit of memory in most computer architectures and is used to encode characters, numbers, and other types of data.
Here are some key points to understand about bytes:

1.1 Size.

A byte consists of 8 bits, and it can represent 256 different values (2^8).
```
00000000 
......
......
11111111
```
These values range from 0 (00000000) to 255(11111111), which covers the entire spectrum of possibilities for 8 binary digits.

1.2 Representation.

Bytes are often represented using hexadecimal notation, where each hexadecimal digit corresponds to 4 bits (half a byte).

For example, the byte with the binary value `01011010` would be represented as `5A` in hexadecimal.

1.3. Usage.

Bytes are used to store a variety of data types, including characters (letters, numbers, symbols), binary data (images, files), and numerical values.
In computer systems, multiple bytes are combined to store larger data structures like integers, floating-point numbers, and more complex data.

1.4 Text Encoding.

Bytes are the basis for encoding characters in different character encoding schemes, such as ASCII, UTF-8, GB2312, and UTF-16.

These encodings assign unique byte sequences to characters, allowing computers to represent and process text.

text1 = 'Python 太好用了'
print('text1 = ', text1) # Output: text1 = Python 太好用了
data1 = text1.encode('gb2312')
print('encode text1 use gb2312 charset = ', data1) # Output: encode text1 use gb2312 charset = b'Python \xcc\xab\xba\xc3\xd3\xc3\xc1\xcb'

data2 = text1.encode('utf-8')
print('encode text1 use utf-8 charset = ', data2) # Output: encode text1 use utf-8 charset = b'Python \xe5\xa4\xaa\xe5\xa5\xbd\xe7\x94\xa8\xe4\xba\x86'

1.5. Memory.

Bytes are the building blocks of computer memory.

Memory addresses are typically aligned to byte boundaries, meaning that the smallest addressable unit of memory is one byte.
This makes bytes essential for data storage and manipulation within a computer’s memory.

1.6. Data Integrity.

Bytes are essential for ensuring data integrity, especially when dealing with binary data.

For example, checksums and hashes are often calculated based on bytes to verify the integrity of files during transfers or storage.

2. What is Python bytes Type?

In Python, `bytes` is a built-in data type that represents a sequence of byte.
Bytes are commonly used to represent binary data, such as images, files, network packets, and other forms of raw data.

Here are some key characteristics of the `bytes` data type:
Immutable: Once a `bytes` object is created, its content cannot be changed. This immutability is important for maintaining data integrity, especially when dealing with low-level data.
Sequence-Like: `bytes` objects behave like sequences, which means you can iterate over them, access individual bytes using indexing, and use slicing to extract portions of the data.

ASCII-Compatible: `bytes` objects can hold a wide range of binary data, including ASCII-encoded text. This compatibility makes them useful for handling various types of data.
Encoding and Decoding: You can convert between `bytes` and `str` (string) objects using encoding and decoding methods. For example, you can convert a `bytes` object to a string using the `.decode()` method and convert a string to a `bytes` object using the `.encode()` method.

3. Creating `bytes` Objects.

To create a `bytes` object, you can use the built-in `bytes()` constructor or by using the `b` prefix before a string.

Here are two ways to create `bytes` objects:

Using the `bytes()` constructor:

data1 = bytes([65, 66, 67, 68]) # Creates a bytes object from a list of integers
print('bytes([65, 66, 67, 68]): ', data1) # Output: bytes([65, 66, 67, 68]):  b'ABCD'

Using the `b` prefix:

data2 = b'Hello, world!' # Creates a bytes object from a string
print("b'Hello, world!': ", data2) # Output: b'Hello, world!':  b'Hello, world!'

4. Properties of `bytes` Objects.

4.1 Immutable Nature.

One important characteristic of `bytes` objects is their immutability.
Once a `bytes` object is created, its content cannot be changed.
Any attempt to modify the content will result in a `TypeError`.

This immutability is valuable for data integrity and safety.

If you change the code like below that change the bytes object element.

data1 = bytes([65, 66, 67, 68]) # Creates a bytes object from a list of integers
print('bytes([65, 66, 67, 68]): ', data1)

data1[0] = 89
print('data1: ', data1)

Then it will throw the below error when you run it.

    data1[0] = 89
    ~~~~~^^^
TypeError: 'bytes' object does not support item assignment

4.2 Sequence-Like Behavior.

`bytes` objects behave like sequences, which means you can iterate over them, access individual bytes using indexing, and utilize common sequence operations such as slicing.

Accessing Individual Bytes: You can access individual bytes within a `bytes` object using indexing:

data1 = bytes([65, 66, 67, 68]) # Creates a bytes object from a list of integers

print('data1[0]: ', data1[0]) # Output: 65 


data2 = b'Hello, world!' # Creates a bytes object from a string
   
print('data2[0]: ', data2[0])# Output: 72 (ASCII code for 'H')

Iterate the bytes object.

def iterate_bytes_object():

    data1 = b'Hello Python'

    size = len(data1)

    for i in range(size):

        print(data1[i])

    

if __name__ == "__main__":

    iterate_bytes_object()


# Below is the above code output.
72
101
108
108
111
32
80
121
116
104
111
110

Slicing: Slicing allows you to extract a portion of a `bytes` object:

def slicing_bytes_object():

    data = b'Python is amazing!'
    substring = data[0:6]
    print(substring) # Output: b'Python'

if __name__ == "__main__":

    slicing_bytes_object()

Converting bytes object to `str`: You can convert a `bytes` object to a string using the `decode()` method:

def convert_bytes_to_string():

    data = b'Hello, world!'
    print(data) # Output: b'Hello, world!'
    text = data.decode('utf-8')
    print(text) # Output: Hello, world!    

if __name__ == "__main__":

    convert_bytes_to_string()

Converting to `bytes` from `str`: Converting a string to a `bytes` object can be achieved using the `encode()` method:

def convert_string_to_bytes():

    text = 'Python is great!'
    print('text = ', text) # Output: Python is great!
    data = text.encode('utf-8')
    print('data = ', data) # Output: b'Python is great!'

    text1 = 'Python 太好用了'
    print('text1 = ', text1) # 
    data1 = text1.encode('gb2312')
    print('data1 = ', data1) # 

    text2 = data1.decode('gb2312')
    print('text2 = ', text2)


if __name__ == "__main__":

    convert_string_to_bytes()

# Below is the above python code output.
text =  Python is great!
data =  b'Python is great!'
text1 =  Python 太好用了
data1 =  b'Python \xcc\xab\xba\xc3\xd3\xc3\xc1\xcb'
text2 =  Python 太好用了

Concatenation: You can concatenate `bytes` objects using the `+` operator:

def concatenate_bytes_object():
    data1 = b'Hello, '
    data2 = b'World'
    #data2 = 'world!'
    combined = data1 + data2
    print(combined) # Output: b'Hello, world!'

if __name__ == "__main__":

    concatenate_bytes_object()

But if you want to concatenate string and bytes object, it will throw the TypeError: can’t concat str to bytes.

5. Practical Examples.

5.1 Reading Binary Files.

The below python source code will read an image file binary content, and print it on the console.

def read_binary_image_file():

    image_file_path = '/Users/songzhao/Desktop/food-recipes.jpeg'

    with open(image_file_path, 'rb') as file:

        image_data = file.read()

        print(image_data)

if __name__ == "__main__":

    read_binary_image_file()

6. Conclusion.

The `bytes` type in Python is a powerful tool for working with binary data, ensuring data integrity, and handling low-level operations.
Its immutability and sequence-like behavior make it a versatile choice for various tasks, such as reading binary files, network communication, and more.
By understanding the creation, manipulation, and conversion of `bytes` objects, you can confidently tackle a wide range of binary data-related challenges.