How to convert a lists of integers to a string of the individual bytes?

Question

I'm trying to print a list of bytes to a file in hex (or decimal, doesn't really make a difference for the sake of the question I believe). I'm baffled by how hard this appears to be in Python?

Based on what I found here (and on other SO questions), I already managed to do this:

>>> b
[12345, 6789, 7643, 1, 2]
>>> ' '.join(format(v, '02x') for v in b)
'3039 1a85 1ddb 01 02'

Now... this is already a good start, but... for larger numbers the individual bytes are grouped and attached to each other. This should not happen. There should be a space between them, just like is the case with the two last numbers.

Of course, I could just do some string manipulation afterwards and insert some spaces, but... that sounds like a very hacky way, and I refuse to believe there isn't a cleaner way to do this.

So, what I want is this:

'30 39 1a 85 1d db 00 01 00 02'

How can I do this?

Answer 1

There's probably a better (simpler) way but this seems to work:

def pair(s):
    for i in range(0, len(s), 2):
        yield s[i:i+2]

def ashex(n):
    yield from pair(f'0000{n:02x}'[-4:])

int_list = [12345, 6789, 7643, 1, 2]

r = []

for n in int_list:
    r.extend(list(ashex(n)))

print(' '.join(r))

Output:

30 39 1a 85 1d db 00 01 00 02

Answer 2

Okay, so this is a bit cobbled together but should do what you want:

from textwrap import wrap

int_list = [12345, 6789, 7643, 1, 2]  # here's your list of ints

# convert all the values to hex, and then join them together as a string,
# using slicing ([2:]) to strip off the '0x' hexadecimal prefix from each
# (zfill is used to pad smaller values with zeros as needed, e.g. 01 and 02)
byte_string = ''.join([hex(n)[2:].zfill(2) for n in int_list])
# => '30391a851ddb0102'

# use the 'wrap' method from the textwrap module to group the bytes into
# groups of 2, then 'join' the resulting list with spaces in between
new_bytes = ' '.join(wrap((byte_string), 2))
# => '30 39 1a 85 1d db 01 02'

It's probably worth mentioning that wrap is hardly the only way to group characters in a string (or elements of an iterable, for that matter). There are plenty of other options given in this answer if you're curious!

In case you're wondering why you have to bother with wrap (or something similar) rather than just joining the elements of the first list comprehension with whitespace, here's what happens:

byte_string = ' '.join([hex(n)[2:].zfill(2) for n in ll])
# => '3039 1a85 1ddb 01 02'

Close, but not quite right!

Answer 3

So, you want to create a hexdump-like output. Given your example inputs/outputs, it sounds like you want the big-endian, 16-bit length bytes from the integers in your list. The key is to use int.to_bytes. Here is a function that first creates a list of bytes from the integers, then iterates over the individual bytes, formatting them as requested:

def hexdump(
    data: list[int], length=2, byteorder: str = "big", fmt: str = "02x", sep: str = " "
) -> str:
    bytes_data = (i.to_bytes(length=length, byteorder=byteorder) for i in data)
    return sep.join([f"{b:{fmt}}" for bs in bytes_data for b in bs])

Here are some examples of it in use:

In [2]: data = [12345, 6789, 7643, 1, 2]

In [3]: hexdump(data)
Out[3]: '30 39 1a 85 1d db 00 01 00 02'

In [4]: hexdump(data, length=4, fmt='04x')
Out[4]: '0000 0000 0030 0039 0000 0000 001a 0085 0000 0000 001d 00db 0000 0000 0000 0001 0000 0000 0000 0002'

In [5]: hexdump(data, sep="|")
Out[5]: '30|39|1a|85|1d|db|00|01|00|02'

Answer 4

Another solution, using re:

import re

b = [768955, 12345, 6789, 7643, 1, 2]

out = " ".join(
    c
    for s in map("{:x}".format, b)
    for c in re.findall("..", f"{s:0>{len(s) + len(s) % 2}}")
)
print(out)

Prints:

0b bb bb 30 39 1a 85 1d db 01 02

Answer 5

You can take advantage of zip to give you the characters 2-at-a-time. A running list is extended with the pairs, joined by "space", and returned.

def converter(data:list):
    out = []
    #max number of hexadecimal places to the next full byte
    places = (max(data).bit_length()+7)//8*2
    
    for num in data:
        byt = f'{num:0{places}x}'
        
        #get characters in pairs
        pairs = zip(byt[::2], byt[1::2]) 
        
        #combine and store pairs
        out.extend(''.join(pair) for pair in pairs)      
            
    return ' '.join(out)
    
print(converter([12345, 6789, 7643, 1, 2])) #30 39 1a 85 1d db 00 01 00 02