Эта функция получает в качестве параметра целое число и должна возвращать список, представляющий одно и то же значение, выраженное в двоичном виде, как список бит, где первый элемент в списке является самым значительным (крайним) битом.
Моя функция в настоящее время выводит '1011' для номера 11, мне нужно [1,0,1,1] вместо этого.
Например,
>>> convert_to_binary(11)
[1,0,1,1]
def trans(x):
if x == 0: return [0]
bit = []
while x:
bit.append(x % 2)
x >>= 1
return bit[::-1]
Просто для удовольствия - решение как рекурсивный однострочный:
def tobin(x):
return tobin(x/2) + [x%2] if x > 1 else [x]
Могу ли я предложить следующее:
def tobin(x,s):
return [(x>>k)&1 for k in range(0,s)]
это, вероятно, самый быстрый способ, и мне кажется, что это довольно ясно. bin слишком медленный, когда производительность имеет значение.
веселит
Это сделает это. Нет смысла перекладывать свою собственную функцию, если есть встроенный.
def binary(x):
return [int(i) for i in bin(x)[2:]]
Функция bin() преобразуется в строку в двоичном формате. Полоска 0b и вы установите.
Вы можете сначала использовать функцию формата, чтобы получить двоичную строку, такую как ваша текущая функция. Например, в следующем фрагменте создается двоичная строка из 8 бит, соответствующая целому числу 58.
>>>u = format(58, "08b")
'00111010'
Теперь перетащите строку, чтобы преобразовать каждый бит в int, чтобы получить нужный вам список битов, закодированных как целые числа.
>>>[int(d) for d in u]
[0, 0, 1, 1, 1, 0, 1, 0]
Вот код, который я сделал для колледжа. Нажмите Здесь для видеоролика youtube кода.! https://www.youtube.com/watch?v=SGTZzJ5H-CE
__author__ = 'Derek'
print('Int to binary')
intStr = input('Give me an int: ')
myInt = int(intStr)
binStr = ''
while myInt > 0:
binStr = str(myInt % 2) + binStr
myInt //= 2
print('The binary of', intStr, 'is', binStr)
print('\nBinary to int')
binStr = input('Give me a binary string: ')
temp = binStr
newInt = 0
power = 0
while len(temp) > 0: # While the length of the array if greater than zero keep looping through
bit = int(temp[-1]) # bit is were you temporally store the converted binary number before adding it to the total
newInt = newInt + bit * 2 ** power # newInt is the total, Each time it loops it adds bit to newInt.
temp = temp[:-1] # this moves you to the next item in the string.
power += 1 # adds one to the power each time.
print("The binary number " + binStr, 'as an integer is', newInt)
В большинстве случаев вы хотите, чтобы ваш двоичный номер был определенной длиной. Например, вы хотите, чтобы 1 было 8 двоичных цифр длиной [0,0,0,0,0,0,0,1]. Я сам использую это:
def convert_to_binary(num, length=8):
binary_string_list = list(format(num, '0{}b'.format(length)))
return [int(digit) for digit in binary_string_list]
Не самый эффективный, но по крайней мере он обеспечивает простой концептуальный способ его понимания...
1) Пол разделить все числа на два раза, пока не достигнете 1
2) Идти в обратном порядке, создавайте биты этого массива чисел, если он четный, добавьте 0, если он нечетный, добавьте 1.
Вот буквальная реализация этого:
def intToBin(n):
nums = [n]
while n > 1:
n = n // 2
nums.append(n)
bits = []
for i in nums:
bits.append(str(0 if i%2 == 0 else 1))
bits.reverse()
print ''.join(bits)
Здесь версия, которая лучше использует память:
def intToBin(n):
bits = []
bits.append(str(0 if n%2 == 0 else 1))
while n > 1:
n = n // 2
bits.append(str(0 if n%2 == 0 else 1))
bits.reverse()
return ''.join(bits)
Вы можете использовать numpy пакет и получить очень быстрое решение:
python -m timeit -s "import numpy as np; x=np.array([8], dtype=np.uint8)" "np.unpackbits(x)"
1000000 loops, best of 3: 0.65 usec per loop
python -m timeit "[int(x) for x in list('{0:0b}'.format(8))]"
100000 loops, best of 3: 3.68 usec per loop
unpackbits обрабатывает только входы типа uint8, но вы все равно можете использовать np.view:
python -m timeit -s "import numpy as np; x=np.array([124567], dtype=np.uint64).view(np.uint8)" "np.unpackbits(x)"
1000000 loops, best of 3: 0.697 usec per loop
Не пифонический путь... но все еще работает:
def get_binary_list_from_decimal(integer, bits):
'''Return a list of 0 and 1 representing a decimal type integer.
Keyword arguments:
integer -- decimal type number.
bits -- number of bits to represent the integer.
Usage example:
#Convert 3 to a binary list
get_binary_list_from_decimal(3, 4)
#Return will be [0, 0, 1, 1]
'''
#Validate bits parameter.
if 2**bits <= integer:
raise ValueError("Error: Number of bits is not sufficient to \
represent the integer. Increase bits parameter.")
#Initialise binary list
binary_list = []
remainder = integer
for i in range(bits-1, -1, -1):
#If current bit value is less than or equal to the remainder of
#the integer then bit value is 1.
if 2**i <= remainder:
binary_list.append(1)
#Subtract the current bit value from the integer.
remainder = remainder - 2**i
else:
binary_list.append(0)
return binary_list
Пример использования:
get_binary_list_from_decimal(1, 3)
#Return will be [0, 0, 1]
def nToKBit(n, K=64):
output = [0]*K
def loop(n, i):
if n == 0:
return output
output[-i] = n & 1
return loop(n >> 1, i+1)
return loop(n, 1)
Преобразование десятичного числа в двоичное зависит от того, как вы собираетесь использовать% и //
def getbin(num):
if (num==0):
k=[0]
return k
else:
s = []
while(num):
s.append(num%2)
num=num//2
return s
Просто делимся функцией, которая обрабатывает массив целых:
def to_binary_string(x):
length = len(bin(max(x))[2:])
for i in x:
b = bin(i)[2:].zfill(length)
yield [int(n) for n in b]
Тестовое задание:
x1 = to_binary_string([1, 2, 3])
x2 = to_binary_string([1, 2, 3, 4])
print(list(x1)) # [[0, 1], [1, 0], [1, 1]]
print(list(x2)) # [[0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0]]
# dec2bin.py
# FB - 201012057
import math
def dec2bin(f):
if f >= 1:
g = int(math.log(f, 2))
else:
g = -1
h = g + 1
ig = math.pow(2, g)
st = ""
while f > 0 or ig >= 1:
if f < 1:
if len(st[h:]) >= 10: # 10 fractional digits max
break
if f >= ig:
st += "1"
f -= ig
else:
st += "0"
ig /= 2
st = st[:h] + "." + st[h:]
return st
# MAIN
while True:
f = float(raw_input("Enter decimal number >0: "))
if f <= 0: break
print "Binary #: ", dec2bin(f)
print "bin(int(f)): ", bin(int(f)) # for comparison