Есть ли способ получить массив двоичных чисел без предварительного преобразования его в строку?

• Использование строк для двоичных данных — не лучшая идея, поскольку каждый символ в строке обычно занимает более одного байта.

Понимание списка: (@Mark в комментарии)

• Поскольку у вас, похоже, не так много операций, для сохранения битов подойдет список списков:

ascii = list("ABCD".encode('ascii'))
res = [[(byte >> (7 - i)) & 1 for i in range(8)] for byte in ascii]
print(res)

Принты

[[0, 1, 0, 0, 0, 0, 0, 1], 
[0, 1, 0, 0, 0, 0, 1, 0], 
[0, 1, 0, 0, 0, 0, 1, 1], 
[0, 1, 0, 0, 0, 1, 0, 0]]

• Вы можете использовать numpy.array() и сохранить биты, если у вас было много операций:

import numpy as np

ascii = list("ABCD".encode('ascii'))
res = []

for byte in ascii:
    for i in range(8):
        bit = (byte >> (7 - i)) & 1
        res.append(bit)

print(np.array(res, dtype=bool))

Принты

[Ложь, правда, ложь, ложь, ложь, ложь, ложь, правда, ложь, правда, ложь. Ложь Ложь Ложь Верно Ложь Ложь Верно Ложь Ложь Ложь Ложь Правда, правда, ложь, правда, ложь, ложь, ложь, правда, ложь, ложь]

Комментарии

Разве Numpy не является излишним просто преобразовать 1 и 0 в True и ЛОЖЬ? Почему бы и нет: res.append(bool(bit)) или даже просто оставить их целыми числами? от @Марк

• Каждый элемент в списке Python является объектом.

• Массивы Numpy используют один тип элемента и не используют какой-либо тип динамически, как это делает список Python. Это делает массивы Numpy более эффективными для задач с интенсивными вычислениями.

• Если бы мы имели дело с 10 миллионами операций, это было бы перебором. Но поскольку вопрос касается битовых манипуляций, размер данных может быть большим, а количество операций — большим, поэтому массивы Numpy являются эффективным выбором.

Голый бенчмарк

import time, sys, numpy

data = list(range(100000000))
L = list(data)
arr = numpy.array(data)
start = time.time()
list_mult = [x * 2 for x in L]
end = time.time()
print(f"List: {end - start} seconds")

start = time.time()
arr_mult = arr * 2
end = time.time()
print(f"Array: {end - start} seconds")

Принты

List: 12.309393882751465 seconds 
Array: 2.8275811672210693 seconds

Примечание

(byte >> (7 - i)) & 1:

i = 0: (65 >> (7 - 0)) & 1 → (65 >> 7) & 1 → 00000000 & 1 → 0
i = 1: (65 >> (7 - 1)) & 1 → (65 >> 6) & 1 → 00000001 & 1 → 0
i = 2: (65 >> (7 - 2)) & 1 → (65 >> 5) & 1 → 00000010 & 1 → 1
i = 3: (65 >> (7 - 3)) & 1 → (65 >> 4) & 1 → 00000100 & 1 → 0
i = 4: (65 >> (7 - 4)) & 1 → (65 >> 3) & 1 → 00001000 & 1 → 0
i = 5: (65 >> (7 - 5)) & 1 → (65 >> 2) & 1 → 00010000 & 1 → 0
i = 6: (65 >> (7 - 6)) & 1 → (65 >> 1) & 1 → 00100000 & 1 → 0
i = 7: (65 >> (7 - 7)) & 1 → (65 >> 0) & 1 → 01000001 & 1 → 1

[False  True False False False False False  True  # 'A' -> 01000001
 False  True  True False False False False False  # 'B' -> 01000010
 False  True  True  True False False False False  # 'C' -> 01000011
 False  True  True  True False False  True False] # 'D' -> 01000100

Обратите внимание, что побитовое & между любым битом и 1 возвращает сам бит, который эффективно отфильтровывает все остальные биты:

0 & 1 → 0
1 & 1 → 1