5 Best Ways to Convert Python Bytes to Human Readable Format

by

💡 Problem Formulation: When working with files or data in Python, it’s common to deal with byte values that aren’t inherently understandable. For instance, you might have 1500 bytes, but you’d prefer to see this represented as something more human-readable, like "1.46 KB". This article explores several methods to translate raw byte counts into a format that’s easier for people to interpret.

Method 1: Using a Custom Function

This method involves creating a custom function that takes the size in bytes and converts it to a human-readable format. The function calculates the appropriate unit (KB, MB, GB, TB, etc.) and formats the size accordingly.

Here’s an example:

def bytes_to_human_readable(num, suffix='B'):
    for unit in ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z']:
        if abs(num) < 1024.0:
            return f"{num:3.1f}{unit}{suffix}"
        num /= 1024.0
    return f"{num:.1f}Yi{suffix}"

# Example usage:
print(bytes_to_human_readable(1500))

1.5KB

This code snippet defines a function bytes_to_human_readable() that converts bytes into a more human-readable format. The function iterates through different size units, dividing the byte value by 1024 until it arrives at a manageable size, then returns a formatted string.

Method 2: Using the humanize Library

Python’s humanize library provides a simple interface to convert byte sizes into a human-readable format. After installing the library, one can use the naturalsize() function for readable output.

Here’s an example:

import humanize

# Example usage:
print(humanize.naturalsize(1500, binary=True))

1.5 KiB

The provided code snippet utilizes the naturalsize() function from the humanize library, which takes a byte value and returns a human-friendly size string. Setting the binary parameter to True specifies that units should be calculated using powers of 1024.

Method 3: Using the hurry.filesize Library

The hurry.filesize library is specifically designed to convert bytes into a human-readable format. After installing the library, you can use different size styles for the output string.

Here’s an example:

from hurry.filesize import size

# Example usage:
print(size(1500))

1K

The size() function from the hurry.filesize library conveniently converts the byte value into a succinct human-readable string. Though not as precise as other methods, it’s straightforward and requires no complex formatting on the user’s part.

Method 4: Using the pyhumansize Library

Similar to hurry.filesize, the pyhumansize library provides functionality for formatting byte sizes. The library offers additional options for precision and unit representation.

Here’s an example:

import pyhumansize

# Example usage:
print(pyhumansize.approximate_size(1500))

1 KB

The approximate_size() function from the pyhumansize library converts bytes into a human-readable string with approximate values. The function also provides flexibility in terms of decimal precision and unit selection.

Bonus One-Liner Method 5: Using String Formatting

For a stripped-down, quick conversion without external libraries or custom functions, Python’s string formatting abilities can be used in a one-liner.

Here’s an example:

print(f'{1500 / (2**10):.2f} KB')

1.46 KB

This one-liner code snippet uses an f-string to format the byte value, dividing it by 2**10 (or 1024) to convert to kilobytes and then formatting the result to two decimal places.

Summary/Discussion

  • Method 1: Custom Function. Strengths: Complete control over formatting and precision. Weaknesses: Requires manual implementation and maintenance.
  • Method 2: humanize Library. Strengths: Easy to use, with human-friendly output. Weaknesses: Requires an external dependency.
  • Method 3: hurry.filesize Library. Strengths: Focused on file size conversion, easy to use. Weaknesses: Less customizability and requires external library.
  • Method 4: pyhumansize Library. Strengths: Offers additional formatting options. Weaknesses: Another external dependency with potentially more features than needed.
  • Method 5: String Formatting. Strengths: Quick and no dependencies required. Weaknesses: Less flexible and not as readable for larger complexities.