Converting hex to binary in the form of string

Question

This code returns a string of binary in 4-digit forms for a given hex in the form of string

def str_bin_in_4digits(aString):
    retStr = ''
    for i in aString:
        retStr = retStr+"{0:04b}".format(int(i, 16))+" "
    return retStr.strip()

for example,

>>> str_bin_in_4digits("20AC")
0010 0000 1010 1100

The code works as expected and my concern is could it be more elegant, like faster or less memory consumption?

Answer 1

Review

You don't have a lot of code here to review, so this will necessarily be short.

• PEP-8: The Style Guide for Python Code recommends:
  • snake_case for functions, variables, and parameters. So aString should be a_string, and retVal should be ret_val.
• Better parameter names
  • What is aString? "Hello World" is a string, but we can't use it, because you are actually expecting a hexadecimal string. Perhaps hex_string would be a better parameter name.
  • Similarly, binary_string would be more descriptive than retStr.
• A '''docstring''' would be useful for the function.
• Type hints would also be useful.

Alternate Implementation

Doing things character-by-character is inefficient. It is usually much faster to let Python do the work itself with its efficient, optimized, native code functions.

Python strings formatting supports adding a comma separator between thousand groups.

>>> f"{123456789:,d}"
'123,456,789'

It also supports adding underscores between groups of 4 digits when using the binary or hexadecimal format codes:

>>> f"{548151468:_x}"
'20ac_20ac'
>>> f"{0x20AC:_b}"
'10_0000_1010_1100'

That is most of the way to what you're looking for. Just need to turn underscores to spaces, with .replace(...) and fill with leading zeros by adding the width and 0-fill flag to the format string.

>>> f"{0x20AC:019_b}".replace('_', ' ')
'0010 0000 1010 1100'

A function using this technique could look like:

def str_bin_in_4digits(hex_string: str) -> str:
    """
    Turn a hex string into a binary string.
    In the output string, binary digits are space separated in groups of 4.

    >>> str_bin_in_4digits('20AC')
    '0010 0000 1010 1100'
    """

    value = int(hex_string, 16)
    width = len(hex_string) * 5 - 1
    bin_string = f"{value:0{width}_b}"
    return bin_string.replace('_', ' ')

if __name__ == '__main__':
    import doctest
    doctest.testmod(verbose=True)

Depending on your definition of elegant, you can one-line this:

def str_bin_in_4digits(hex_string: str) -> str:
    """
    Turn a hex string into a binary string.
    In the output string, binary digits are space separated in groups of 4.

    >>> str_bin_in_4digits('20AC')
    '0010 0000 1010 1100'
    """

    return f"{int(hex_string,16):0{len(hex_string)*5-1}_b}".replace('_', ' ')

Answer 2

The problem is to take a hex string and convert it to the equivalent binary string. Each character in the input string maps to a one or more characters in the output string, e.g., '0' -> '0000', ... 'A' -> '1010', ... 'F' -> '1111'. This is a perfect fit for string.translate()

table = ''.maketrans({'0':'0000 ', '1':'0001 ', '2':'0010 ', '3':'0011 ',
                      '4':'0100 ', '5':'0101 ', '6':'0110 ', '7':'0111 ',
                      '8':'1000 ', '9':'1001 ', 'A':'1010 ', 'B':'1011 ',
                      'C':'1100 ', 'D':'1101 ', 'E':'1110 ', 'F':'1111 '})


def str_bin_in_4digits(hex_string):
    return hex_string.upper().translate(table)

It's 6-7 times faster.

Answer 3

I don't know if there is faster or less memory consumption method but you can write it more elegant using list

def str_bin_in_4digits(aString):

    data = []

    for i in aString:
        data.append( "{0:04b}".format(int(i, 16)) )

    retStr = " ".join(data)

    return retStr  # doesn't need strip()

and then you could write it also as list comprehension

def str_bin_in_4digits(aString):

    data = ["{0:04b}".format(int(i, 16)) for i in aString]
    retStr = " ".join(data)

    return retStr  # doesn't need strip()

and then you could even reduce to one line

def str_bin_in_4digits(aString):

    return " ".join(["{0:04b}".format(int(i, 16)) for i in aString])

Maybe even using list comprehension it can be little faster but for small string you may not see it.

Now you have to only choose version which is the most readable for you.

---

Problem is that you have 4-bits values (single hex char).

For full 8-bits you could convert from hex to bytes using

 bytes_data = bytes.fromhex('0A 0B 0C')

 bytes_data = bytes.fromhex('0A0B0C')

and later you could again use list comprehension - using f-string it could even shorter

 data = [f'{x:04b}' for x in bytes_data]

But with with 8-bits you would have to split it to 4-bits using something like this

bytes_data[0] >> 4,  bytes_data[0] & 0x0f