Существуют ли консервированные методы Python для преобразования целого (или длинного) в двоичную строку в Python?
В Google существует множество функций dec2bin(). Но я надеялся, что смогу использовать встроенную функцию/библиотеку.
Python int в двоичную строку?
Ответ 1
Метод строкового формата Python может принимать спецификацию формата.
>>> "{0:b}".format(37)
'100101'
Ответ 2
Если вы ищете bin() как эквивалент hex(), он был добавлен в python 2.6.
Пример:
>>> bin(10)
'0b1010'
Ответ 3
Для этого у Python действительно есть что-то уже построенное, возможность делать такие операции, как '{0:b}'.format(42), который даст вам бит-шаблон (в строке) для 42 или 101010.
Для более общей философии ни один язык или библиотека не даст своей базе пользователей все, что они желают. Если вы работаете в среде, которая не обеспечивает именно то, что вам нужно, вы должны собирать фрагменты кода по мере развития, чтобы вы никогда не должны были писать одно и то же дважды. Например, например:
def int_to_bin_string(i):
if i == 0:
return "0"
s = ''
while i:
if i & 1 == 1:
s = "1" + s
else:
s = "0" + s
i //= 2
return s
который будет строить вашу двоичную строку на основе десятичного значения, предполагая, что Python уже не имеет более простого способа.
Общая идея состоит в том, чтобы использовать код (в порядке предпочтения):
- языка или встроенных библиотек.
- сторонних библиотек с подходящими лицензиями.
- вашей собственной коллекции.
- что-то новое вам нужно написать (и сохранить в вашей собственной коллекции позже).
Ответ 4
В качестве справки:
def toBinary(n):
return ''.join(str(1 & int(n) >> i) for i in range(64)[::-1])
Эта функция может преобразовать положительное целое число, равное 18446744073709551615, представленное как строка '1111111111111111111111111111111111111111111111111111111111111111'.
Он может быть изменен, чтобы обслуживать гораздо большее целое число, хотя это может быть не так удобно, как "{0:b}".format() или bin().
Ответ 5
Если вы хотите текстовое представление без 0b-префикса, вы можете использовать это:
get_bin = lambda x: format(x, 'b')
print(get_bin(3))
>>> '11'
print(get_bin(-3))
>>> '-11'
Если вам требуется n-разрядное представление:
get_bin = lambda x, n: format(x, 'b').zfill(n)
>>> get_bin(12, 32)
'00000000000000000000000000001100'
>>> get_bin(-12, 32)
'-00000000000000000000000000001100'
В качестве альтернативы, если вы предпочитаете иметь функцию:
def get_bin(x, n=0):
"""
Get the binary representation of x.
Parameters
----------
x : int
n : int
Minimum number of digits. If x needs less digits in binary, the rest
is filled with zeros.
Returns
-------
str
"""
return format(x, 'b').zfill(n)
Ответ 6
однострочный с lambda:
>>> binary = lambda n: '' if n==0 else binary(n/2) + str(n%2)
Тест:
>>> binary(5)
'101'
РЕДАКТИРОВАТЬ:
но затем:(
t1 = time()
for i in range(1000000):
binary(i)
t2 = time()
print(t2 - t1)
# 6.57236599922
по сравнению с
t1 = time()
for i in range(1000000):
'{0:b}'.format(i)
t2 = time()
print(t2 - t1)
# 0.68017411232
Ответ 7
Простым способом сделать это является использование формата строки, см. эту страницу.
>> "{0:b}".format(10)
'1010'
И если вы хотите иметь фиксированную длину двоичной строки, вы можете использовать это:
>> "{0:{fill}8b}".format(10, fill='0')
'00001010'
Если требуется два дополнения, то можно использовать следующую строку:
'{0:{fill}{width}b}'.format((x + 2**n) % 2**n, fill='0', width=n)
где n - ширина двоичной строки.
Ответ 8
Сводка альтернатив:
n=42
assert "-101010" == format(-n, 'b')
assert "-101010" == "{0:b}".format(-n)
assert "-101010" == (lambda x: x >= 0 and str(bin(x))[2:] or "-" + str(bin(x))[3:])(-n)
assert "0b101010" == bin(n)
assert "101010" == bin(n)[2:] # But this won't work for negative numbers.
Авторы включают John Fouhy, Тунг Нгуен, mVChr, Мартин Тома. и Martijn Pieters.
Ответ 9
Это для Python 3 и держит ведущие нули!
print(format(0, '08b'))
Ответ 10
Используя пакет numpy pack/unpackbits, они являются вашими лучшими друзьями.
Examples
--------
>>> a = np.array([[2], [7], [23]], dtype=np.uint8)
>>> a
array([[ 2],
[ 7],
[23]], dtype=uint8)
>>> b = np.unpackbits(a, axis=1)
>>> b
array([[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 1, 1],
[0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)
Ответ 11
Если я не понимаю, что вы подразумеваете под бинарной строкой, я думаю, что модуль, который вы ищете, struct
Ответ 12
def binary(decimal) :
otherBase = ""
while decimal != 0 :
otherBase = str(decimal % 2) + otherBase
decimal //= 2
return otherBase
print binary(10)
выход:
1010
Ответ 13
Еще одно решение с другим алгоритмом, используя побитовые операторы.
def int2bin(val):
res=''
while val>0:
res += str(val&1)
val=val>>1 # val=val/2
return res[::-1] # reverse the string
Более быстрая версия без изменения строки.
def int2bin(val):
res=''
while val>0:
res = chr((val&1) + 0x30) + res
val=val>>1
return res
Ответ 14
Вот код, который я только что реализовал. Это не метод, но вы можете использовать его в качестве готовой к использованию функции!
def inttobinary(number):
if number == 0:
return str(0)
result =""
while (number != 0):
remainder = number%2
number = number/2
result += str(remainder)
return result[::-1] # to invert the string
Ответ 15
здесь простое решение, использующее функцию divmod(), которая возвращает напоминание и результат деления без дроби.
def dectobin(number):
bin = ''
while (number >= 1):
number, rem = divmod(number, 2)
bin = bin + str(rem)
return bin
Ответ 16
n=input()
print(bin(n).replace("0b", ""))
Ответ 17
Калькулятор со всеми необходимыми функциями для DEC, BIN, HEX: (сделано и протестировано с Python 3.5)
Вы можете изменить входные тестовые номера и получить преобразованные.
# CONVERTER: DEC / BIN / HEX
def dec2bin(d):
# dec -> bin
b = bin(d)
return b
def dec2hex(d):
# dec -> hex
h = hex(d)
return h
def bin2dec(b):
# bin -> dec
bin_numb="{0:b}".format(b)
d = eval(bin_numb)
return d,bin_numb
def bin2hex(b):
# bin -> hex
h = hex(b)
return h
def hex2dec(h):
# hex -> dec
d = int(h)
return d
def hex2bin(h):
# hex -> bin
b = bin(h)
return b
## TESTING NUMBERS
numb_dec = 99
numb_bin = 0b0111
numb_hex = 0xFF
## CALCULATIONS
res_dec2bin = dec2bin(numb_dec)
res_dec2hex = dec2hex(numb_dec)
res_bin2dec,bin_numb = bin2dec(numb_bin)
res_bin2hex = bin2hex(numb_bin)
res_hex2dec = hex2dec(numb_hex)
res_hex2bin = hex2bin(numb_hex)
## PRINTING
print('------- DECIMAL to BIN / HEX -------\n')
print('decimal:',numb_dec,'\nbin: ',res_dec2bin,'\nhex: ',res_dec2hex,'\n')
print('------- BINARY to DEC / HEX -------\n')
print('binary: ',bin_numb,'\ndec: ',numb_bin,'\nhex: ',res_bin2hex,'\n')
print('----- HEXADECIMAL to BIN / HEX -----\n')
print('hexadec:',hex(numb_hex),'\nbin: ',res_hex2bin,'\ndec: ',res_hex2dec,'\n')
Ответ 18
Для тех из нас, кому необходимо преобразовать целые числа со знаком (диапазон -2 ** (цифры -1) в 2 ** (цифры -1) -1) в 2 дополнения двоичных строк, это работает:
def int2bin(integer, digits):
if integer >= 0:
return bin(integer)[2:].zfill(digits)
else:
return bin(2**digits + integer)[2:]
Это производит:
>>> int2bin(10, 8)
'00001010'
>>> int2bin(-10, 8)
'11110110'
>>> int2bin(-128, 8)
'10000000'
>>> int2bin(127, 8)
'01111111'
Ответ 19
Несколько аналогичное решение
def to_bin(dec):
flag = True
bin_str = ''
while flag:
remainder = dec % 2
quotient = dec / 2
if quotient == 0:
flag = False
bin_str += str(remainder)
dec = quotient
bin_str = bin_str[::-1] # reverse the string
return bin_str
Ответ 20
Здесь еще один способ, использующий регулярную математику, отсутствие циклов, только рекурсию. (Тривиальный случай 0 ничего не возвращает).
def toBin(num):
if num == 0:
return ""
return toBin(num//2) + str(num%2)
print ([(toBin(i)) for i in range(10)])
['', '1', '10', '11', '100', '101', '110', '111', '1000', '1001']
Ответ 21
Для вычисления двоичных чисел:
print("Binary is {0:>08b}".format(16))
Чтобы вычислить десятичное число Хекса числа:
print("Hexa Decimal is {0:>0x}".format(15))
Вычислить все двоичные файлы no до 16 ::
for i in range(17):
print("{0:>2}: binary is {0:>08b}".format(i))
Для вычисления шестнадцатеричного десятичного значения до 17
for i in range(17):
print("{0:>2}: Hexa Decimal is {0:>0x}".format(i))
##as 2 digit is enogh for hexa decimal representation of a number
Ответ 22
Если вы готовы отказаться от "чистого" Python, но получите много огневой мощи, есть Sage - пример здесь:
sage: a = 15
sage: a.binary()
'1111'
Вы заметите, что он возвращается в виде строки, поэтому для использования в качестве номера вы хотите сделать что-то вроде
sage: eval('0b'+b)
15
Ответ 23
try:
while True:
p = ""
a = input()
while a != 0:
l = a % 2
b = a - l
a = b / 2
p = str(l) + p
print(p)
except:
print ("write 1 number")
Ответ 24
Я нашел метод с использованием операции матрицы для преобразования десятичного в двоичный.
import numpy as np
E_mat = np.tile(E,[1,M])
M_order = pow(2,(M-1-np.array(range(M)))).T
bindata = np.remainder(np.floor(E_mat /M_order).astype(np.int),2)
E - вводимые десятичные данные, M - двоичные порядки. bindata - это выходные двоичные данные, которые находятся в формате 1 по M двоичной матрице.
Ответ 25
вы можете сделать так:
bin(10)[2:]
или:
f = str(bin(10))
c = []
c.append("".join(map(int, f[2:])))
print c
Ответ 26
>>> format(123, 'b')
'1111011'
Ответ 27
Вдоль аналогичной линии с Юсуфом Язичи ответьте
def intToBin(n):
if(n < 0):
print "Sorry, invalid input."
elif(n == 0):
print n
else:
result = ""
while(n != 0):
result += str(n%2)
n /= 2
print result[::-1]
Я скорректировал его так, чтобы единственная переменная, которая была мутирована, была результатом (и n, конечно).
Если вам нужно использовать эту функцию в другом месте (т.е. иметь результат, используемый другим модулем), рассмотрите следующую настройку:
def intToBin(n):
if(n < 0):
return -1
elif(n == 0):
return str(n)
else:
result = ""
while(n != 0):
result += str(n%2)
n /= 2
return result[::-1]
Итак, -1 будет вашим дозорным значением, указывающим, что преобразование не выполнено. (Предполагается, что вы конвертируете ТОЛЬКО положительные числа, независимо от того, являются ли они целыми или длинными).
Ответ 28
Здесь простой двоично-десятичный преобразователь, который непрерывно петли
t = 1
while t > 0:
binaryNumber = input("Enter a binary No.")
convertedNumber = int(binaryNumber, 2)
print(convertedNumber)
print("")
Ответ 29
Это мой ответ, он работает хорошо..!
def binary(value) :
binary_value = ''
while value !=1 :
binary_value += str(value%2)
value = value//2
return '1'+binary_value[::-1]
Ответ 30
numpy.binary_repr(num, width=None)
Примеры из документации по ссылке выше:
>>> np.binary_repr(3) '11' >>> np.binary_repr(-3) '-11' >>> np.binary_repr(3, width=4) '0011'Дополнение twos возвращается, когда введенное число отрицательно и указана ширина:
>>> np.binary_repr(-3, width=3) '101' >>> np.binary_repr(-3, width=5) '11101'