Numpy packbits() Function

The NumPy packbits() function which is used to pack the elements of a binary-valued array into bits in a uint8 array. This function compresses an array of binary values i.e 0s and 1s into an array of 8-bit unsigned integers where each bit in the resulting uint8 array represents an element from the input array.

Here in this function we can operate along a specified axis or on the flattened input array. It's particularly useful for reducing memory usage when dealing with large arrays of binary data.

Syntax

Following is the syntax of Numpy packbits() function −

numpy.packbits(a, /, axis=None, bitorder='big')

Parameters

Following are the Parameters of Numpy packbits() function −

• a(array_like): Input array of binary values.
• axis: This parameter is the axis along which to pack bits. If None then the array is flattened.
• bitorder: Bit order in the packed representation either 'big' or 'little'.

Return value

This function returns an array of type uint8 containing the packed bytes.

Example 1

Following is the basic example of Numpy packbits() function in which, packs a 1D array of bits into an array of bytes −

import numpy as np

# Define the input array of bits (0s and 1s)
bits = np.array([1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1], dtype=np.uint8)

# Pack the bits into bytes
packed = np.packbits(bits)
print(packed)    

Below is the output of packbits() function −

[178 229]

Example 2

Packing a 2D array along the default axis in NumPy involves converting the binary values 0s and 1s in each row of the array into a more compact representation such as bytes.

The default axis for the packbits() function is -1 which refers to the last axis typically the columns for a 2D array. Here is the example of it −

import numpy as np

# Define a 2D array of bits
bit_array = np.array([[0, 1, 1, 0, 0, 1, 1, 1], 
                      [1, 0, 1, 1, 0, 0, 0, 0]], dtype=np.uint8)

# Pack the bits into bytes
packed_array = np.packbits(bit_array)

print("Original bit array:\n", bit_array)
print("Packed array:", packed_array)

Following is the output for the above example −

Original bit array:
 [[0 1 1 0 0 1 1 1]
 [1 0 1 1 0 0 0 0]]
Packed array: [103 176]

Example 3

Below is the example which shows how the packbits() function works on a 3D array −

import numpy as np

# Create a 3D array
arr = np.array([[[1, 0, 1], [0, 1, 0]], [[1, 1, 0], [0, 0, 1]], [[1, 1, 0], [0, 0, 1]]])

# Displaying our array
print("Array...")
print(arr)

# Get the datatype
print("Array datatype...", arr.dtype)

# Get the dimensions of the Array
print("Array Dimensions...", arr.ndim)

# Get the shape of the Array
print("Our Array Shape...", arr.shape)

# Get the number of elements of the Array
print("Elements in the Array...", arr.size)

# To pack the elements of a binary-valued array into bits in a uint8 array, use the numpy.packbits() method in Python Numpy
# The result is padded to full bytes by inserting zero bits at the end
res = np.packbits(arr)
print("Result...", res)  

Following is the output for the above example −

Array...
[[[1 0 1]
  [0 1 0]]

 [[1 1 0]
  [0 0 1]]

 [[1 1 0]
  [0 0 1]]]
Array datatype... int64
Array Dimensions... 3
Our Array Shape... (3, 2, 3)
Elements in the Array... 18
Result... [171  28  64]