Python struct reverse unpack

I'm trying to unpack structure as shown below in this way to get '0123456789'

b"\x10\x32\x54\x76\x98"

Maybe there is other way then writing own function to do so ?

Thanks

I think it's easier to debug if you use your own function. However, if you want a one line command to turn this into a string you can do like so:

X = b"\x10\x32\x54\x76\x98"

tmp = "".join([hex(i)[:1:-1].zfill(2) for i in X])

print(tmp)

>>> 0123456789

Basically it turns each byte to hexadecimal (which handles splitting methods), so we split them to read them backward without "0x".

Finally we join them using an empty string separator.

EDIT

As pointed by Alain T. I updated the code and added the zfill() method to force the string length of each byte to 2 to avoid missing integers like in the example:
b"\x10\x32\x05\x76\x98".

You could get an integer mathematically using reduce:

from functools import reduce
X = b"\x10\x32\x45\x76\x98"
d = reduce(lambda r,b:r*100+b%16*10+b//16,X,0)
print(d)
# 123546789

Or, without libraries using sum() and a comprehension:

d = sum( (d%16*10+d//16)*100**i for i,d in enumerate(X[::-1]))
print(d)
# 123546789

If you need it to be a string, with leading zero, you can use the format method

d = ("{:02x}"*len(X)).format(*X[::-1])[::-1]
print(d)
0123546789

or the join function and a comprehension:

d = "".join(f"{d%16}{d//16}" for b in X)
print(d)
0123546789

For a string output, without leading zeros, you can swap the nibles of each byte before converting them to an integer and then use the hex representation of that integer (this is the fastest string conversion):

d = hex(int.from_bytes((b%16*16+b//16 for b in X),"big"))[2:]
print(d)
123546789

Performance comparisons:

tests = {
"reduce    ": lambda : reduce(lambda r,b:r*100+b%16*10+b//16,X,0),
"from_bytes": lambda : hex(int.from_bytes((b%16*16+b//16 for b in X),"big"))[2:],
"format    ": lambda : ("{:02x}"*len(X)).format(*X[::-1])[::-1],
"join      ": lambda : "".join(f"{d%16}{d//16}" for d in X),
"sum       ": lambda : sum( (d%16*10+d//16)*100**i for i,d in enumerate(X[::-1])),
}
from timeit import timeit
for name,fn in tests.items():
print(name,fn(),timeit(fn,number=1000000))
reduce    	123546789	1.1987413900000001
from_bytes	123546789	1.245261141
format    	0123546789	1.517380332
join      	0123546789	1.8026392529999997
sum       	123546789	2.1293131119999993

Here's yet another way to do this just using f-strings and a little bit of arithmetic:

X = b"\x10\x32\x54\x76\x98"
for b in X:
print(f'{b%16}{b//16}', end='')

Output:

0123456789

Note:

If you need a single string then just build it within the loop instead of printing