Convert string to list of bits and viceversa

Question

I need to convert an ASCII string into a list of bits and vice versa:

str = "Hi" -> [0,1,0,0,1,0,0,0,0,1,1,0,1,0,0,1]

[0,1,0,0,1,0,0,0,0,1,1,0,1,0,0,1] -> "Hi"

I have a function that performs some operation on the string, but requires it to be passed in this format. — Dan
– Dan, Commented Apr 19, 2012 at 23:13

senderle · Accepted Answer · 2017-10-04 13:56:33Z

There are many ways to do this with library functions. But I am partial to the third-party bitarray module.

>>> import bitarray
>>> ba = bitarray.bitarray()

Conversion from strings requires a bit of ceremony. Once upon a time, you could just use fromstring, but that method is now deprecated, since it has to implicitly encode the string into bytes. To avoid the inevitable encoding errors, it's better to pass a bytes object to frombytes. When starting from a string, that means you have to specify an encoding explicitly -- which is good practice anyway.

>>> ba.frombytes('Hi'.encode('utf-8'))
>>> ba
bitarray('0100100001101001')

Conversion to a list is easy. (Also, bitstring objects have a lot of list-like functions already.)

>>> l = ba.tolist()
>>> l
[False, True, False, False, True, False, False, False, 
 False, True, True, False, True, False, False, True]

bitstrings can be created from any iterable:

>>> bitarray.bitarray(l)
bitarray('0100100001101001')

Conversion back to bytes or strings is relatively easy too:

>>> bitarray.bitarray(l).tobytes().decode('utf-8')
'Hi'

And for the sake of sheer entertainment:

>>> def s_to_bitlist(s):
...     ords = (ord(c) for c in s)
...     shifts = (7, 6, 5, 4, 3, 2, 1, 0)
...     return [(o >> shift) & 1 for o in ords for shift in shifts]
... 
>>> def bitlist_to_chars(bl):
...     bi = iter(bl)
...     bytes = zip(*(bi,) * 8)
...     shifts = (7, 6, 5, 4, 3, 2, 1, 0)
...     for byte in bytes:
...         yield chr(sum(bit << s for bit, s in zip(byte, shifts)))
... 
>>> def bitlist_to_s(bl):
...     return ''.join(bitlist_to_chars(bl))
... 
>>> s_to_bitlist('Hi')
[0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1]
>>> bitlist_to_s(s_to_bitlist('Hi'))
'Hi'

Thanks for the great reply, unfortunately my environment doesn't seem to have this module available, so John's answer fits my use case better.

Simon Streicher · Accepted Answer · 2015-01-26 21:17:57Z

31

There are probably faster ways to do this, but using no extra modules:

def tobits(s):
    result = []
    for c in s:
        bits = bin(ord(c))[2:]
        bits = '00000000'[len(bits):] + bits
        result.extend([int(b) for b in bits])
    return result

def frombits(bits):
    chars = []
    for b in range(len(bits) / 8):
        byte = bits[b*8:(b+1)*8]
        chars.append(chr(int(''.join([str(bit) for bit in byte]), 2)))
    return ''.join(chars)

edited Jan 26, 2015 at 21:17

Simon Streicher

2,8561 gold badge28 silver badges33 bronze badges

answered Apr 19, 2012 at 23:10

John Gaines Jr.

11.6k1 gold badge28 silver badges25 bronze badges

2 Comments

Jessy Diamond Exum Over a year ago

Instead of the slicing of the string of 0s, this should work. In [1]: msg = "101" In [2]: msg.zfill(8) Out[2]: '00000101'

Fizz Areh Over a year ago

Using integer division (//) is better when working with integers because it is more precise. It is not much of a problem in this particular example because "bits" list surely will not be big enough for precision errors to occur, but still, a bad habit.

ch3ka · Accepted Answer · 2012-04-19 23:16:00Z

13

not sure why, but here are two ugly oneliners using only builtins:

s = "Hi"
l = map(int, ''.join([bin(ord(i)).lstrip('0b').rjust(8,'0') for i in s]))
s = "".join(chr(int("".join(map(str,l[i:i+8])),2)) for i in range(0,len(l),8))

yields:

>>> l
[0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1]
>>> s
'Hi'

In real world code, use the struct or the bitarray module.

answered Apr 19, 2012 at 23:16

ch3ka

12.2k5 gold badges33 silver badges28 bronze badges

2 Comments

ch3ka Over a year ago

lol, now I know why I should not use "l" as a variable name... never had those problems with my console font :D

ch3ka Over a year ago

you're welcome. But note that I won't use something ugly like this in production code, if I were you ;)

Rik Poggi · Accepted Answer · 2012-04-19 23:06:35Z

6

You could use the built-in bytearray:

>>> for i in bytearray('Hi', 'ascii'):
...     print(i)
... 
72
105

>>> bytearray([72, 105]).decode('ascii')
'Hi'

And bin() to convert to binary.

edited Apr 19, 2012 at 23:06

answered Apr 19, 2012 at 22:56

Rik Poggi

29.5k7 gold badges69 silver badges84 bronze badges

Comments

Community · Accepted Answer · 2017-05-23 12:24:21Z

4

def text_to_bits(text):
    """
    >>> text_to_bits("Hi")
    [0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1]
    """
    bits = bin(int.from_bytes(text.encode(), 'big'))[2:]
    return list(map(int, bits.zfill(8 * ((len(bits) + 7) // 8))))

def text_from_bits(bits):
    """
    >>> text_from_bits([0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1])
    'Hi'
    """
    n = int(''.join(map(str, bits)), 2)
    return n.to_bytes((n.bit_length() + 7) // 8, 'big').decode()

See also, Convert Binary to ASCII and vice versa (Python).

edited May 23, 2017 at 12:24

CommunityBot

11 silver badge

answered Jan 27, 2015 at 9:34

jfs

417k210 gold badges1k silver badges1.7k bronze badges

Comments

Damotorie · Accepted Answer · 2017-01-27 11:19:02Z

1

def to_bin(string):
    res = ''
    for char in string:
        tmp = bin(ord(char))[2:]
        tmp = '%08d' %int(tmp)
        res += tmp
    return res

def to_str(string):
    res = ''
    for idx in range(len(string)/8):
        tmp = chr(int(string[idx*8:(idx+1)*8], 2))
        res += tmp
    return res

These function is really simple.
It doesn't use third party module.

answered Jan 27, 2017 at 11:19

Damotorie

5969 silver badges30 bronze badges

Comments

d0c_s4vage · Accepted Answer · 2015-06-16 03:55:18Z

0

A few speed comparisons. Each of these were run using

python -m timeit "code"

or

cat <<-EOF | python -m timeit
    code
EOF

if multiline.

Bits to Byte

A: 100000000 loops, best of 3: 0.00838 usec per loop

res = 0
for idx,x in enumerate([0,0,1,0,1,0,0,1]):
    res |= (x << idx)

B: 100000000 loops, best of 3: 0.00838 usec per loop

int(''.join(map(str, [0,0,1,0,1,0,0,1])), 2)

Byte to Bits

A: 100000000 loops, best of 3: 0.00836 usec per loop

[(41 >> x) & 1 for x in range(7, -1, -1)]

B: 100000 loops, best of 3: 2.07 usec per loop

map(int, bin(41)[2:])

answered Jun 16, 2015 at 3:55

d0c_s4vage

4,0776 gold badges27 silver badges32 bronze badges

Comments

Solomon Ucko · Accepted Answer · 2017-08-18 14:33:59Z

import math

class BitList:
    def __init__(self, value):
        if isinstance(value, str):
            value = sum([bytearray(value, "utf-8")[-i - 1] << (8*i) for i in range(len(bytearray(value, "utf-8")))])
        try:
            self.value = sum([value[-i - 1] << i for i in range(len(value))])
        except Exception:
            self.value = value

    def __getitem__(self, index):
        if isinstance(index, slice):
            if index.step != None and index.step != 1:
                return list(self)[index]
            else:
                start = index.start if index.start else 0
                stop = index.stop if index.stop != None else len(self)

                return BitList(math.floor((self.value % (2 ** (len(self) - start))) >> (len(self) - stop)))
        else:
            return bool(self[index:index + 1].value)

    def __len__(self):
        return math.ceil(math.log2(self.value + 1))

    def __str__(self):
        return self.value

    def __repr__(self):
        return "BitList(" + str(self.value) + ")"

    def __iter__(self):
        yield from [self[i] for i in range(len(self))]

Then you can initialize BitList with a number or a list (of numbers or booleans), then you can get its value, get positional items, get slices, and convert it to a list. Note: Cannot currently set items, but when I add that I will edit this post.

I made this my self, then went looking for how to convert a string (or a file) into a list of bits, then figured that out from another answer.

Lil Taco · Accepted Answer · 2017-08-27 16:15:24Z

0

This might work, but it does not work if you ask PEP 8 (long line, complex)

tobits = lambda x: "".join(map(lambda y:'00000000'[len(bin(ord(y))[2:]):]+bin(ord(y))[2:],x))
frombits = lambda x: ''.join([chr(int(str(y), 2)) for y in [x[y:y+8] for y in range(0,len(x),8)]])

These are used like normal functions.

answered Aug 27, 2017 at 16:15

Lil Taco

5531 gold badge5 silver badges9 bronze badges

Comments

antonagestam · Accepted Answer · 2017-09-05 21:17:38Z

0

Because I like generators, I'll post my version here:

def bits(s):
    for c in s:
        yield from (int(bit) for bit in bin(ord(c))[2:].zfill(8))


def from_bits(b):
    for i in range(0, len(b), 8): 
        yield chr(int(''.join(str(bit) for bit in b[i:i + 8]), 2)) 


print(list(bits('Hi')))
[0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1]
print(''.join(from_bits([0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1])))
Hi

edited Sep 5, 2017 at 21:17

answered Sep 5, 2017 at 21:03

antonagestam

4,8393 gold badges34 silver badges47 bronze badges

Comments

Onur A. · Accepted Answer · 2019-03-02 15:56:16Z

-1

If you have bits in a list then you simply convert it into str and then to a number. Number will behave like a bit string and then bitwise operation can be applied. For example :

int(str([1,0,0,1]) | int(str([1,0,1,1])

edited Mar 2, 2019 at 15:56

Onur A.

3,0273 gold badges24 silver badges37 bronze badges

answered Mar 2, 2019 at 15:19

Dhiraj Jaiswal

1

Collectives™ on Stack Overflow

Convert string to list of bits and viceversa

11 Answers 11

1 Comment

2 Comments

2 Comments

Comments

Comments

Comments

Bits to Byte

Byte to Bits

Comments

Comments

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

11 Answers 11

1 Comment

2 Comments

2 Comments

Comments

Comments

Comments

Bits to Byte

Byte to Bits

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related