我有ABC123EFFF。
我想有001010101111000001001000111110111111111111（即二进制再版，与，说，42位和前导零）。
怎么样？
Answer 1:
为了解决左侧尾部零问题：
my_hexdata = "1a"
scale = 16 ## equals to hexadecimal
num_of_bits = 8
bin(int(my_hexdata, scale))[2:].zfill(num_of_bits)
它会给00011010，而不是修剪的版本。
Answer 2:
import binascii
binary_string = binascii.unhexlify(hex_string)
读
binascii.unhexlify
返回由指定为参数的十六进制字符串所表示的二进制数据。
Answer 3:
bin(int("abc123efff", 16))[2:]
Answer 4:
>>> bin( 0xABC123EFFF )
'0b1010101111000001001000111110111111111111'
Answer 5:
十六进制转换为二进制
我有ABC123EFFF。
我想有001010101111000001001000111110111111111111（即二进制再版，与，说，42位和前导零）。
简短的回答：
在Python 3.6新的F-串让你做这个使用非常简洁的语法：
>>> f'{0xABC123EFFF:0>42b}'
'001010101111000001001000111110111111111111'
或打破了语义：
>>> number, pad, rjust, size, kind = 0xABC123EFFF, '0', '>', 42, 'b'
>>> f'{number:{pad}{rjust}{size}{kind}}'
'001010101111000001001000111110111111111111'
长一点的回答：
什么你实际上说的是，你在一个十六进制表示的值，你要代表二进制等效值。
等价的值是一个整数。 但是你可以用字符串开头，并以二进制查看，你必须以字符串结尾。
十六进制转换为二进制，42位和前导零？
我们有几个直接的方式来实现这一目标，而无需使用切片黑客。
首先，在我们可以做任何二进制操作可言，转换为int（我相信这是一个字符串格式，而不是文字）：
>>> integer = int('ABC123EFFF', 16)
>>> integer
737679765503
另外，我们可以用文字的整数十六进制形式表示为：
>>> integer = 0xABC123EFFF
>>> integer
737679765503
现在，我们需要表达一个二进制表示我们的整数。
使用内置函数， format
然后传递给format ：
>>> format(integer, '0>42b')
'001010101111000001001000111110111111111111'
本品采用格式化规范的迷你语言 。
为了打破下来，这里是它的语法形式：
[[fill]align][sign][#][0][width][,][.precision][type]
为了让这个成为我们需要一个规范，我们只是排除我们并不需要的东西：
>>> spec = '{fill}{align}{width}{type}'.format(fill='0', align='>', width=42, type='b')
>>> spec
'0>42b'
，只是传递到格式
>>> bin_representation = format(integer, spec)
>>> bin_representation
'001010101111000001001000111110111111111111'
>>> print(bin_representation)
001010101111000001001000111110111111111111
字符串格式化（模板）与str.format
我们可以通过使用一个字符串str.format方法：
>>> 'here is the binary form: {0:{spec}}'.format(integer, spec=spec)
'here is the binary form: 001010101111000001001000111110111111111111'
或者只是把规范，直接在原来的字符串：
>>> 'here is the binary form: {0:0>42b}'.format(integer)
'here is the binary form: 001010101111000001001000111110111111111111'
String与新的F-字符串格式化
让我们展示新的F-字符串。 它们使用相同的小型的语言格式规则：
>>> integer = 0xABC123EFFF
>>> length = 42
>>> f'{integer:0>{length}b}'
'001010101111000001001000111110111111111111'
现在，让我们把这个功能集成到一个功能，以鼓励可重用性：
def bin_format(integer, length):
return f'{integer:0>{length}b}'
现在：
>>> bin_format(0xABC123EFFF, 42)
'001010101111000001001000111110111111111111'
在旁边
如果你真的只是想将数据编码在内存或磁盘上的字节串，就可以使用int.to_bytes方法，这是只有在Python 3可供选择：
>>> help(int.to_bytes)
to_bytes(...)
int.to_bytes(length, byteorder, *, signed=False) -> bytes
...
而且，由于42个比特由每字节8个比特划分等于6个字节：
>>> integer.to_bytes(6, 'big')
b'\x00\xab\xc1#\xef\xff'
Answer 6:
"{0:020b}".format(int('ABC123EFFF', 16))
Answer 7:
这是一个相当原始的方式使用位摆弄生成二进制字符串来做到这一点。
键位的理解就是：
(n & (1 << i)) and 1如果n的第i个位被设置，这将产生或者是0或1。
import binascii
def byte_to_binary(n):
return ''.join(str((n & (1 << i)) and 1) for i in reversed(range(8)))
def hex_to_binary(h):
return ''.join(byte_to_binary(ord(b)) for b in binascii.unhexlify(h))
print hex_to_binary('abc123efff')
>>> 1010101111000001001000111110111111111111
编辑：使用“新的”三元运算符这样的：
(n & (1 << i)) and 1会成为：
1 if n & (1 << i) or 0（这TBH我不知道那是多么可读）
Answer 8:
这是一个轻微的触摸高达格伦·梅纳德的解决方案，我认为这是做正确的方式。 它只是增加了填充元素。
def hextobin(self, hexval):
'''
Takes a string representation of hex data with
arbitrary length and converts to string representation
of binary. Includes padding 0s
'''
thelen = len(hexval)*4
binval = bin(int(hexval, 16))[2:]
while ((len(binval)) < thelen):
binval = '0' + binval
return binval
拉出来的一类。 就掏出self,如果你在一个独立脚本工作。
Answer 9:
bin(int("abc123efff", 16))[2:]
'1010101111000001001000111110111111111111'
`bin(int("abc123efff", 16))[2:].zfill(50)`
'00000000001010101111000001001000111110111111111111'
（数量50会告诉zfill要完成与零字符串，直到字符串长度为50 ）。
Answer 10:
十六进制 - >十进制小数然后 - >二进制
#decimal to binary
def d2b(n):
bStr = ''
if n < 0: raise ValueError, "must be a positive integer"
if n == 0: return '0'
while n > 0:
bStr = str(n % 2) + bStr
n = n >> 1
return bStr
#hex to binary
def h2b(hex):
return d2b(int(hex,16))
Answer 11:
替换相应的4-二进制数字每个十六进制位：
1 - 0001
2 - 0010
...
a - 1010
b - 1011
...
f - 1111
Answer 12:
其他方式：
import math
def hextobinary(hex_string):
s = int(hex_string, 16)
num_digits = int(math.ceil(math.log(s) / math.log(2)))
digit_lst = ['0'] * num_digits
idx = num_digits
while s > 0:
idx -= 1
if s % 2 == 1: digit_lst[idx] = '1'
s = s / 2
return ''.join(digit_lst)
print hextobinary('abc123efff')
Answer 13:
我添加的比特数的计算，以填补至Onedinkenedi的解决方案。 以下是得到的函数：
def hextobin(h):
return bin(int(h, 16))[2:].zfill(len(h) * 4)
其中16是你从（十六进制）转换基地和4是你需要多少位来表示每个数字，或登录规模的基地2。
Answer 14:
def conversion():
e=raw_input("enter hexadecimal no.:")
e1=("a","b","c","d","e","f")
e2=(10,11,12,13,14,15)
e3=1
e4=len(e)
e5=()
while e3<=e4:
e5=e5+(e[e3-1],)
e3=e3+1
print e5
e6=1
e8=()
while e6<=e4:
e7=e5[e6-1]
if e7=="A":
e7=10
if e7=="B":
e7=11
if e7=="C":
e7=12
if e7=="D":
e7=13
if e7=="E":
e7=14
if e7=="F":
e7=15
else:
e7=int(e7)
e8=e8+(e7,)
e6=e6+1
print e8
e9=1
e10=len(e8)
e11=()
while e9<=e10:
e12=e8[e9-1]
a1=e12
a2=()
a3=1
while a3<=1:
a4=a1%2
a2=a2+(a4,)
a1=a1/2
if a1<2:
if a1==1:
a2=a2+(1,)
if a1==0:
a2=a2+(0,)
a3=a3+1
a5=len(a2)
a6=1
a7=""
a56=a5
while a6<=a5:
a7=a7+str(a2[a56-1])
a6=a6+1
a56=a56-1
if a5<=3:
if a5==1:
a8="000"
a7=a8+a7
if a5==2:
a8="00"
a7=a8+a7
if a5==3:
a8="0"
a7=a8+a7
else:
a7=a7
print a7,
e9=e9+1
Answer 15:
我有一个短剪断希望帮助:-)
input = 'ABC123EFFF'
for index, value in enumerate(input):
print(value)
print(bin(int(value,16)+16)[3:])
string = ''.join([bin(int(x,16)+16)[3:] for y,x in enumerate(input)])
print(string)
首先，我用你的输入和枚举它得到每个符号。 然后我把它转换为二进制和3TH位置的端部修整。 诀窍得到0是添加了输入的最大值 - 在这种情况下，始终为16 :-)>
短形式IST join方法。 请享用。
Answer 16:
a = raw_input('hex number\n')
length = len(a)
ab = bin(int(a, 16))[2:]
while len(ab)<(length * 4):
ab = '0' + ab
print ab
Answer 17:
import binascii
hexa_input = input('Enter hex String to convert to Binary: ')
pad_bits=len(hexa_input)*4
Integer_output=int(hexa_input,16)
Binary_output= bin(Integer_output)[2:]. zfill(pad_bits)
print(Binary_output)
"""zfill(x) i.e. x no of 0 s to be padded left - Integers will overwrite 0 s
starting from right side but remaining 0 s will display till quantity x
[y:] where y is no of output chars which need to destroy starting from left"""
Answer 18:
no=raw_input("Enter your number in hexa decimal :")
def convert(a):
if a=="0":
c="0000"
elif a=="1":
c="0001"
elif a=="2":
c="0010"
elif a=="3":
c="0011"
elif a=="4":
c="0100"
elif a=="5":
c="0101"
elif a=="6":
c="0110"
elif a=="7":
c="0111"
elif a=="8":
c="1000"
elif a=="9":
c="1001"
elif a=="A":
c="1010"
elif a=="B":
c="1011"
elif a=="C":
c="1100"
elif a=="D":
c="1101"
elif a=="E":
c="1110"
elif a=="F":
c="1111"
else:
c="invalid"
return c
a=len(no)
b=0
l=""
while b<a:
l=l+convert(no[b])
b+=1
print l
文章来源: Convert hex to binary
