5 Best Ways to Convert a Python List of Bits to Bytes

by

💡 Problem Formulation: In Python, developers often need to convert a list of bits (0s and 1s) into a bytes object for operations like binary file I/O or network communication. For instance, given the input [1, 1, 0, 1, 0, 0, 1, 1], the desired output is the bytes object b'\xd3', which represents the binary sequence 11010011.

Method 1: Using the bytes Constructor and int Function

This method involves using the bytes constructor in combination with the int function to convert a list of bits to a byte string. The int function is passed a string of bits and base 2 to convert into an integer, and the result is passed to the bytes constructor.

Here’s an example:

bits_list = [1, 1, 0, 1, 0, 0, 1, 1]
bits_string = ''.join(str(bit) for bit in bits_list)
byte_result = bytes([int(bits_string, 2)])
print(byte_result)

Output: b'\xd3'

This snippet first transforms the list into a string of bits, then converts that string into an integer with base 2, and lastly, converts this integer to a bytes object using the bytes constructor.

Method 2: Using bytearray and Left Shift Operation

With the bytearray method, we start by initializing an empty byte array. Then, we iterate over the bits list, shifting the bits into the correct position using a left shift operation and combining them into a byte.

Here’s an example:

bits_list = [1, 1, 0, 1, 0, 0, 1, 1]
byte_result = bytearray()
accumulator = 0
for i, bit in enumerate(bits_list):
    accumulator |= bit << (7 - i)
byte_result.append(accumulator)
print(byte_result)

Output: bytearray(b'\xd3')

This code blocks build a byte by shifting each bit to its correct position and then performing a bitwise OR operation with an accumulator. Finally, it appends the result to a bytearray.

Method 3: Using functools.reduce

The functools.reduce function is a powerful Python standard library tool that can be used to apply an operation cumulatively to the items of an iterable. In this case, we use it to combine the bits into a single byte.

Here’s an example:

from functools import reduce

bits_list = [1, 1, 0, 1, 0, 0, 1, 1]
byte_result = reduce(lambda x, y: (x << 1) | y, bits_list)
print(bytes([byte_result]))

Output: b'\xd3'

This snippet uses reduce to shift the accumulated bits left and then perform a bitwise OR with the next bit in the list. The result is then converted to a byte using the bytes constructor.

Method 4: Using Binary String Formatting and int Function

This method formats the bits list as a binary string with the format function and then converts it to an integer before turning it into a bytes object.

Here’s an example:

bits_list = [1, 1, 0, 1, 0, 0, 1, 1]
bit_string = format(int(''.join(map(str,bits_list)), 2), '08b')
byte_result = int(bit_string, 2).to_bytes(1, byteorder='big')
print(byte_result)

Output: b'\xd3'

Here, the list of bits is joined into a string and then turned into an integer. We use string formatting to ensure that we have a full byte (8 bits) if necessary, and finally, convert it to bytes with the proper byte order using the to_bytes method.

Bonus One-Liner Method 5: Using int.to_bytes Method

For a quick one-liner, the to_bytes method on integers can be used to directly convert a list of bits to a bytes object, assuming the list represents an entire number of bytes.

Here’s an example:

bits_list = [1, 1, 0, 1, 0, 0, 1, 1]
byte_result = int(''.join(map(str, bits_list)), 2).to_bytes((len(bits_list) + 7) // 8, byteorder='big')
print(byte_result)

Output: b'\xd3'

This succinct line combines several steps: generating a string of binary digits from the list, converting to an integer, and then to a bytes object with the correct length and byte order.

Summary/Discussion

  • Method 1: Using bytes Constructor and int Function. Strengths: Straightforward and easy to understand. Weaknesses: Requires several transformation steps.
  • Method 2: Using bytearray and Left Shift Operation. Strengths: Efficient for large lists of bits. Weaknesses: Slightly more complex due to manual bit manipulation.
  • Method 3: Using functools.reduce. Strengths: Elegant functional programming approach. Weaknesses: Can be less readable to those unfamiliar with reduce and lambda functions.
  • Method 4: Using Binary String Formatting and int Function. Strengths: Utilizes strings formatting advantages. Weaknesses: Involves multiple conversions and formatting steps.
  • Method 5: Using int.to_bytes One-Liner. Strengths: Compact and efficient. Weaknesses: Could be less readable due to its compact nature.