Двоичный набор двоичных файлов в Python?

Не знаете, как получить то, что вы хотите, используя стандартную библиотеку lib. Есть несколько скриптов и пакетов, которые будут делать конверсию для вас.

Я просто хотел отметить «почему», и почему он не хромой.

bin () не возвращает двоичные биты. он преобразует число в двоичную строку. ведущий «0b» сообщает интерпретатору, что вы имеете дело с двоичным числом, в соответствии с определением языка python. таким образом вы можете напрямую работать с двоичными числами, например

 >>> 0b01 1 >>> 0b10 2 >>> 0b11 3 >>> 0b01 + 0b10 3 

это не хромает. замечательно.

http://docs.python.org/library/functions.html#bin

бен (х)

Преобразование целочисленного числа в двоичную строку.

http://docs.python.org/reference/lexical_analysis.html#integers

Целочисленные и длинные целочисленные литералы описываются следующими лексическими определениями:

bininteger :: = "0" ("b" | "B") bindigit +

bindigit :: = "0" | "1"

Он лучше всего работает, если вы предоставляете маску. Таким образом вы указываете, как далеко подписать расширение.

 >>> bin(-27 & 0b1111111111111111) '0b1111111111100101' 

Или, возможно, в более общем плане:

 def bindigits(n, bits): s = bin(n & int("1"*bits, 2))[2:] return ("{0:0>%s}" % (bits)).format(s) >>> print bindigits(-31337, 24) 111111111000010110010111 

В базовой теории фактическая ширина числа зависит от размера хранилища. Если это 32-битное число, то отрицательное число имеет 1 в MSB набора из 32. Если это 64-битное значение, то для отображения будет 64 бита.

Но в Python целая точность ограничивается только ограничениями вашего оборудования. На моем компьютере это действительно работает , но он потребляет 9 ГБ оперативной памяти только для хранения значения x . Все выше, и я получаю MemoryError. Если бы у меня было больше ОЗУ, я мог бы хранить большие числа.

 >>> x = 1 << (1 << 36) 

Итак, имея в виду, какое двоичное число представляет -1 ? Как показывает предыдущий пример, Python способен интерпретировать буквально миллионы (и даже миллиарды) бит точности. В дополнении 2 бит знака продолжается до упора влево, но в Python нет заранее определенного количества бит; есть столько, сколько вам нужно.

Но тогда вы сталкиваетесь с двусмысленностью: двоичный 1 представляет 1 или -1 ? Ну, это может быть так. Имеет ли 111 7 или -1 ? Опять же, это может быть и то. Таким образом, 111111111 представляет 511 , или -1 … ну, оба, в зависимости от вашей точности.

Python нуждается в способе представления этих чисел в двоичном формате, так что нет никакой двусмысленности их значения. Префикс 0b просто говорит, что «это число в двоичном формате». Точно так же, как 0x означает «это число в шестнадцатеричном формате». Итак, если я скажу 0b1111 , как узнать, хочет ли пользователь -1 или 15? Существует два варианта:

Вариант A: бит знака
Вы можете объявить, что все числа подписаны, а самый левый бит – знаковый бит. Это означает, что 0b1 равно -1, а 0b01 равно 1. Это также означает, что 0b111 также равно -1, а 0b0111 равно 7. В конце концов, это, вероятно, более запутанно, чем полезно, особенно потому, что большая часть двоичной арифметики в любом случае будет беззнаковой, и люди чаще сталкиваются с ошибками, случайно отмечая число как отрицательное, потому что они не включают явный бит знака.

Вариант B: индикация знака
С помощью этой опции двоичные числа представлены без знака, а отрицательные числа имеют префикс «-», как и в десятичном. Это (а) более согласовано с десятичной, (б) более совместимо с тем, как бинарные значения, скорее всего, будут использоваться. Вы теряете возможность указывать отрицательное число с помощью представления его двух дополнений, но помните, что дополнение двух является деталью реализации хранилища , а не правильной индикацией самого базового значения. Это не должно быть то, что пользователь должен понять.

В конце концов, вариант B имеет наибольший смысл. Там меньше путаницы, и пользователю не требуется понимать детали хранения.

Чтобы правильно интерпретировать двоичную последовательность как дополнение к двум, требуется длина, связанная с последовательностью. Когда вы работаете с низкоуровневыми типами, которые напрямую соответствуют регистрам CPU, существует неявная длина. Поскольку целые числа Python могут иметь произвольную длину, на самом деле нет внутреннего формата дополнений. Поскольку число, не связанное с числом, не существует, невозможно отличить положительное и отрицательное числа. Чтобы удалить двусмысленность, bin () содержит знак минуса при форматировании отрицательного числа.

Тип произвольной длины Python на самом деле использует внутренний формат знаковой величины. Логические операции (смещение битов и т. Д.) Предназначены для имитации формата дополнений двух. Это типично для библиотек с высокой точностью.

Я не совсем уверен, что вы в конечном итоге хотите сделать, но вы можете посмотреть на пакет bitarray .

 def tobin(data, width): data_str = bin(data & (2**width-1))[2:].zfill(width) return data_str 

Используйте ломтики, чтобы избавиться от нежелательных «0b».

bin(5)[2:] '101'

или если вы хотите цифры,

tuple ( bin(5)[2:] ) ('1', '0', '1')

или даже

map( int, tuple( bin(5)[2:] ) ) [1, 0, 1]

Для положительных чисел просто используйте:

 bin(x)[2:].zfill(4) 

Для отрицательных чисел это немного другое:

 bin((eval("0b"+str(int(bin(x)[3:].zfill(4).replace("0","2").replace("1","0").replace("2","1"))))+eval("0b1")))[2:].zfill(4) 

В целом сценарий так выглядит:

 def binary(number): if number < 0: return bin((eval("0b"+str(int(bin(number)[3:].zfill(4).replace("0","2").replace("1","0").replace("2","1"))))+eval("0b1")))[2:].zfill(4) return bin(number)[2:].zfill(4) x=input() print binary(x) 

 tobin = lambda x, count=8: "".join(map(lambda y:str((x>>y)&1), range(count-1, -1, -1))) 

например

 tobin(5) # => '00000101' tobin(5, 4) # => '0101' tobin(-5, 4) # => '1011' 

Или как четкие функции:

 # Returns bit y of x (10 base). ie # bit 2 of 5 is 1 # bit 1 of 5 is 0 # bit 0 of 5 is 1 def getBit(y, x): return str((x>>y)&1) # Returns the first `count` bits of base 10 integer `x` def tobin(x, count=8): shift = range(count-1, -1, -1) bits = map(lambda y: getBit(y, x), shift) return "".join(bits) 

(Адаптировано из комментария WJ Ван де Лаана )

Модификация очень полезного ответа tylerl, который обеспечивает расширение знака для положительных чисел, а также отрицательный (без проверки ошибок).

 def to2sCompStr(num, bitWidth): num &= (2 << bitWidth-1)-1 # mask formatStr = '{:0'+str(bitWidth)+'b}' ret = formatStr.format(int(num)) return ret 

Пример:

 In [11]: to2sCompStr(-24, 18) Out[11]: '111111111111101000' In [12]: to2sCompStr(24, 18) Out[12]: '000000000000011000' 

Надеюсь, это решает вашу проблему `

 num = input("Enter number : ") bin_num=bin(num) binary = '0' + binary_num[2:] print binary 

Вот немного более читаемая версия ответа Tylerl , например, скажем, вы хотите, чтобы -2 в своем 8-битном отрицательном представлении «двух дополнений»:

 bin(-2 & (2**8-1)) 

2 ** 8 обозначает девятый бит (256), вычитает 1 к нему, и все предыдущие бит установлены на один (255)

для 8 и 16 бит масок вы можете заменить (2 ** 8-1) на 0xff или 0xffff. После этой точки шестнадцатеричная версия становится менее прочитанной.

Если это неясно, здесь есть регулярная функция:

 def twosComplement (value, bitLength) : return bin(value & (2**bitLength - 1))