Byte Array in Python

Question

How can I represent a byte array (like in Java with byte[]) in Python? I'll need to send it over the wire with gevent.

byte key[] = {0x13, 0x00, 0x00, 0x00, 0x08, 0x00};

Dietrich Epp · Accepted Answer · 2011-09-11T18:51:54.907

95

In Python 3, we use the bytes object, also known as str in Python 2.

# Python 3
key = bytes([0x13, 0x00, 0x00, 0x00, 0x08, 0x00])

# Python 2
key = ''.join(chr(x) for x in [0x13, 0x00, 0x00, 0x00, 0x08, 0x00])

I find it more convenient to use the base64 module...

# Python 3
key = base64.b16decode(b'130000000800')

# Python 2
key = base64.b16decode('130000000800')

You can also use literals...

# Python 3
key = b'\x13\0\0\0\x08\0'

# Python 2
key = '\x13\0\0\0\x08\0'

edited Sep 11 '11 at 18:51

answered Sep 11 '11 at 18:50

Dietrich Epp

205,541
37
345
415

9

For the record, instead of `base64.b16decode(x)`, you can use, simply, `x.decode("hex")`. It lets you get by with one less import, at least. :) – Dolda2000 Nov 15 '12 at 15:51
`bytes.fromhex('130000000800')` in Python 3. – Mark Tolonen Jun 29 '22 at 11:04

Scott Griffiths · Answer 2 · 2011-09-12T08:06:19.310

36

Just use a bytearray (Python 2.6 and later) which represents a mutable sequence of bytes

>>> key = bytearray([0x13, 0x00, 0x00, 0x00, 0x08, 0x00])
>>> key
bytearray(b'\x13\x00\x00\x00\x08\x00')

Indexing get and sets the individual bytes

>>> key[0]
19
>>> key[1]=0xff
>>> key
bytearray(b'\x13\xff\x00\x00\x08\x00')

and if you need it as a str (or bytes in Python 3), it's as simple as

>>> bytes(key)
'\x13\xff\x00\x00\x08\x00'

edited Sep 12 '11 at 08:06

answered Sep 11 '11 at 19:06

Scott Griffiths

21,438
8
55
85

Not so simple with 3.x; `fubar = str(key); print(len(key), len(fubar))` produces `6 38`. In any case (1) "string" is very vague terminology (2) if he wants mutability, he can mutate his original **list** – John Machin Sep 11 '11 at 22:09
@John: Good point about `str` working differently for `bytearray` in Python 3 - fixed. I mentioned mutability mainly to distinguish it from `bytes`, but the point is also that you don't need to have an intermediate step of having your data in a `list` at all. – Scott Griffiths Sep 12 '11 at 08:14
2

It's a fair chance that what the OP really needs is something like `struct.pack(" – John Machin Sep 12 '11 at 08:52

score 6 · Answer 3 · answered Jul 11 '15 at 16:27

An alternative that also has the added benefit of easily logging its output:

hexs = "13 00 00 00 08 00"
logging.debug(hexs)
key = bytearray.fromhex(hexs)

allows you to do easy substitutions like so:

hexs = "13 00 00 00 08 {:02X}".format(someByte)
logging.debug(hexs)
key = bytearray.fromhex(hexs)

SingleNegationElimination · Answer 4 · 2011-09-11T21:55:53.080

3

Dietrich's answer is probably just the thing you need for what you describe, sending bytes, but a closer analogue to the code you've provided for example would be using the bytearray type.

>>> key = bytearray([0x13, 0x00, 0x00, 0x00, 0x08, 0x00])
>>> bytes(key)
b'\x13\x00\x00\x00\x08\x00'
>>>

edited Sep 11 '11 at 21:55

answered Sep 11 '11 at 18:58

SingleNegationElimination

151,563
33
264
304

1

Fine for Python 2.5 or earlier, but the built-in `bytearray` is really the way to go if you want, er, a byte array. – Scott Griffiths Sep 11 '11 at 19:09
@TokenMacGuy: Your answer needs another 2 edits: (1) mentions the array module (2) `bytearray('b', ...)` doesn't work. Or you could just delete it. – John Machin Sep 11 '11 at 21:52
2

@John: thanks, fixed. In the future, just go right ahead and make the edits yourself. – SingleNegationElimination Sep 11 '11 at 21:56

Byte Array in Python

4 Answers4

Linked