blocks|key|1453278|text|import+binascii

binary_string+=+binascii.unhexlify(hex_string)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1453279|朗读|unstyled|1453280|binascii.unhexlify|offset|length|1453281|返回由指定为参数的十六进制字符串表示的二进制数据。|1453282|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/binascii.html#binascii.unhexlify^0|0|0|0|I|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|W|8|@]|9|@$I|X|J|Y|1|Z]]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$]]|$1|M|3|-4|5|F|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

<pre><code>import binascii

binary_string = binascii.unhexlify(hex_string)
</code></pre>

Read

<a href="http://docs.python.org/library/binascii.html#binascii.unhexlify" rel="noreferrer">binascii.unhexlify</a>

Return the binary data represented by the hexadecimal string specified as the parameter.

blocks|key|1238539|text|将每个十六进制数字替换为相应的4个二进制数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1238540|1+-+0001
2+-+0010
...
a+-+1010
b+-+1011
...
f+-+1111|code-block|syntax|javascript|1238541|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Replace each hex digit with the corresponding 4 binary digits:

<pre><code>1 - 0001
2 - 0010
...
a - 1010
b - 1011
...
f - 1111
</code></pre>

blocks|key|1238559|text|bin(int("abc123efff",+16))[2:]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1238560|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

blocks|key|1238626|text|这里有一种相当原始的方法，使用位摆动来生成二进制字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1238627|要理解的关键点是：|1238628|(n+&+(1+<<+i))+and+1|code-block|syntax|javascript|1238629|如果设置了n的第i位，则其将产生0或1。|1238630|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|1238631|编辑:使用"new“三元运算符this：|1238632|(n+&+(1+<<+i))+and+1|1238633|会变成：|1238634|1+if+n+&+(1+<<+i)+or+0|1238635|(我不确定它的可读性如何)|1238636|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

Here's a fairly raw way to do it using bit fiddling to generate the binary strings.

The key bit to understand is:

<pre><code>(n & (1 &lt;&lt; i)) and 1</code></pre>

Which will generate either a 0 or 1 if the i'th bit of n is set.

<pre><code>
import binascii

def byte_to_binary(n):
 return ''.join(str((n & (1 &lt;&lt; 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
</code></pre>

Edit: using the "new" ternary operator this:

<pre><code>(n & (1 &lt;&lt; i)) and 1</code></pre>

Would become:

<pre><code>1 if n & (1 &lt;&lt; i) or 0</code></pre>

(Which TBH I'm not sure how readable that is)

blocks|key|1238652|text|另一种方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1238653|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+%25+2+==+1:+digit_lst[idx]+=+'1'
++++++++s+=+s+/+2
++++return+''.join(digit_lst)

print+hextobinary('abc123efff')|code-block|syntax|javascript|1238654|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another way:

<pre><code>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 &gt; 0:
 idx -= 1
 if s % 2 == 1: digit_lst[idx] = '1'
 s = s / 2
 return ''.join(digit_lst)

print hextobinary('abc123efff')
</code></pre>

blocks|key|1453480|text|十六进制-->十进制，然后是十进制-->二进制|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1453481|#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+%25+2)+%2B+bStr
++++++++n+=+n+>>+1++++
++++return+bStr

#hex+to+binary
def+h2b(hex):
++++return+d2b(int(hex,16))|code-block|syntax|javascript|1453482|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

hex --> decimal then decimal --> binary

<pre><code>#decimal to binary 
def d2b(n):
 bStr = ''
 if n &lt; 0: raise ValueError, "must be a positive integer"
 if n == 0: return '0'
 while n &gt; 0:
 bStr = str(n % 2) + bStr
 n = n &gt;&gt; 1 
 return bStr

#hex to binary
def h2b(hex):
 return d2b(int(hex,16))
</code></pre>

blocks|key|1238782|text|这是对Glen+Maynard的解决方案的轻微补充，我认为这是正确的方法。它只添加了填充元素。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1238783|++++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'+%2B+binval
++++++++return+binval|code-block|syntax|javascript|1238784|把它从课堂上拉出来。如果您正在使用独立脚本，只需去掉self,即可。|offset|length|style|CODE|1238785|entityMap^0|0|0|Q|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This is a slight touch up to Glen Maynard's solution, which I think is the right way to do it. It just adds the padding element.

<pre><code>
 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)) &lt thelen):
 binval = '0' + binval
 return binval

</code></pre>

Pulled it out of a class. Just take out <code>self, </code> if you're working in a stand-alone script.

blocks|key|1453582|text|"{0:020b}".format(int('ABC123EFFF',+16))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1453583|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>"{0:020b}".format(int('ABC123EFFF', 16))
</code></pre>

blocks|key|1453587|text|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%2Bconvert(no[b])
++++b%2B=1
print+l|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1453588|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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&lt;a:
 l=l+convert(no[b])
 b+=1
print l
</code></pre>

blocks|key|1238847|text|>>>+bin(+0xABC123EFFF+)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1238848|‘0b101010111100000100100011111011111111111111111111’|unstyled|1238849|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>&gt;&gt;&gt; bin( 0xABC123EFFF )
</code></pre>

'0b1010101111000001001000111110111111111111'

blocks|key|1238859|text|a+=+raw_input('hex+number\n')
length+=+len(a)
ab+=+bin(int(a,+16))[2:]
while+len(ab)<(length+*+4):
++++ab+=+'0'+%2B+ab
print+ab|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1238860|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>a = raw_input('hex number\n')
length = len(a)
ab = bin(int(a, 16))[2:]
while len(ab)&lt;(length * 4):
 ab = '0' + ab
print ab
</code></pre>

blocks|key|1238908|text|我在Onedinkenedi的解决方案中添加了要填充的位数的计算。下面是生成的函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1238909|def+hextobin(h):
++return+bin(int(h,+16))[2:].zfill(len(h)+*+4)|code-block|syntax|javascript|1238910|其中16是要转换的基数(十六进制)，4是表示每个数字所需的位数，或小数的对数基数2。|1238911|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I added the calculation for the number of bits to fill to Onedinkenedi's solution. Here is the resulting function:

<pre><code>def hextobin(h):
 return bin(int(h, 16))[2:].zfill(len(h) * 4)
</code></pre>

Where 16 is the base you're converting from (hexadecimal), and 4 is how many bits you need to represent each digit, or log base 2 of the scale.

blocks|key|1238927|text|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"""|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1238928|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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"""
</code></pre>

blocks|key|1453821|text|+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%2B(e[e3-1],)
++++++++e3=e3%2B1
++++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%2B(e7,)
++++++++e6=e6%2B1
++++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%252
++++++++++++a2=a2%2B(a4,)
++++++++++++a1=a1/2
++++++++++++if+a1<2:
++++++++++++++++if+a1==1:
++++++++++++++++++++a2=a2%2B(1,)
++++++++++++++++if+a1==0:
++++++++++++++++++++a2=a2%2B(0,)
++++++++++++++++a3=a3%2B1
++++++++a5=len(a2)
++++++++a6=1
++++++++a7=""
++++++++a56=a5
++++++++while+a6<=a5:
++++++++++++a7=a7%2Bstr(a2[a56-1])
++++++++++++a6=a6%2B1
++++++++++++a56=a56-1
++++++++if+a5<=3:
++++++++++++if+a5==1:
++++++++++++++++a8="000"
++++++++++++++++a7=a8%2Ba7
++++++++++++if+a5==2:
++++++++++++++++a8="00"
++++++++++++++++a7=a8%2Ba7
++++++++++++if+a5==3:
++++++++++++++++a8="0"
++++++++++++++++a7=a8%2Ba7
++++++++else:
++++++++++++a7=a7
++++++++print+a7,
++++++++e9=e9%2B1|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1453822|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> 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&lt;=e4:
 e5=e5+(e[e3-1],)
 e3=e3+1
 print e5
 e6=1
 e8=()
 while e6&lt;=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&lt;=e10:
 e12=e8[e9-1]
 a1=e12
 a2=()
 a3=1 
 while a3&lt;=1:
 a4=a1%2
 a2=a2+(a4,)
 a1=a1/2
 if a1&lt;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&lt;=a5:
 a7=a7+str(a2[a56-1])
 a6=a6+1
 a56=a56-1
 if a5&lt;=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
</code></pre>

blocks|key|1238987|text|我有一个简短的希望是有帮助的:-)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1238988|input+=+'ABC123EFFF'
for+index,+value+in+enumerate(input):
++++print(value)
++++print(bin(int(value,16)%2B16)[3:])

string+=+''.join([bin(int(x,16)%2B16)[3:]+for+y,x+in+enumerate(input)])
print(string)|code-block|syntax|javascript|1238989|首先，我使用您的输入并枚举它来获取每个符号。然后我将它转换成二进制，并从第三个位置修剪到最后。获得0的诀窍是将输入->的最大值相加，在本例中始终为16+:-)|1238990|简写形式是join方法。好好享受吧。|1238991|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

i have a short snipped hope that helps :-)

<pre><code>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)
</code></pre>

first i use your input and enumerate it to get each symbol. then i convert it to binary and trim from 3th position to the end. The trick to get the 0 is to add the max value of the input -> in this case always 16 :-) 

the short form ist the join method. Enjoy.

blocks|key|1453891|text|#+Python+Program+-+Convert+Hexadecimal+to+Binary
hexdec+=+input("Enter+Hexadecimal+string:+")
print(hexdec,"+in+Binary+=+",+end="")++++#+end+is+by+default+"\n"+which+prints+a+new+line
for+_hex+in+hexdec:
++++dec+=+int(_hex,+16)++++#+16+means+base-16+wich+is+hexadecimal
++++print(bin(dec)[2:].rjust(4,"0"),+end="")++++#+the+[2:]+skips+0b,+and+the+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1453892|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code># Python Program - Convert Hexadecimal to Binary
hexdec = input("Enter Hexadecimal string: ")
print(hexdec," in Binary = ", end="") # end is by default "\n" which prints a new line
for _hex in hexdec:
 dec = int(_hex, 16) # 16 means base-16 wich is hexadecimal
 print(bin(dec)[2:].rjust(4,"0"), end="") # the [2:] skips 0b, and the 
</code></pre>

blocks|key|1239030|text|ABC123EFFF的二进制版本实际上是10101011110000010010001111101111111111111111111111|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1239031|对于几乎所有的应用程序，您都希望二进制版本的长度是4的倍数，前导填充为0。|1239032|要在Python中获得以下内容：|1239033|def+hex_to_binary(+hex_code+):
++bin_code+=+bin(+hex_code+)[2:]
++padding+=+(4-len(bin_code)%254)%254
++return+'0'*padding+%2B+bin_code|code-block|syntax|javascript|1239034|示例1：|1239035|>>>+hex_to_binary(+0xABC123EFFF+)
'1010101111000001001000111110111111111111'|1239036|示例2：|1239037|>>>+hex_to_binary(+0x7123+)
'0111000100100011'|1239038|请注意，这也适用于Micropython+:)|1239039|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|11|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|13|8|@]|9|@]|A|$I|J]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

The binary version of ABC123EFFF is actually 1010101111000001001000111110111111111111

For almost all applications you want the binary version to have a length that is a multiple of 4 with leading padding of 0s.

To get this in Python:

<pre><code>def hex_to_binary( hex_code ):
 bin_code = bin( hex_code )[2:]
 padding = (4-len(bin_code)%4)%4
 return '0'*padding + bin_code
</code></pre>

Example 1:

<pre><code>&gt;&gt;&gt; hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'
</code></pre>

Example 2:

<pre><code>&gt;&gt;&gt; hex_to_binary( 0x7123 )
'0111000100100011'
</code></pre>

Note that this also works in Micropython :)

blocks|key|1453952|text|HEX_TO_BINARY_CONVERSION_TABLE+=+{
++++++++++++++++++++++++++++++'0':+'0000',

++++++++++++++++++++++++++++++'1':+'0001',

++++++++++++++++++++++++++++++'2':+'0010',

++++++++++++++++++++++++++++++'3':+'0011',

++++++++++++++++++++++++++++++'4':+'0100',

++++++++++++++++++++++++++++++'5':+'0101',

++++++++++++++++++++++++++++++'6':+'0110',

++++++++++++++++++++++++++++++'7':+'0111',

++++++++++++++++++++++++++++++'8':+'1000',

++++++++++++++++++++++++++++++'9':+'1001',

++++++++++++++++++++++++++++++'a':+'1010',

++++++++++++++++++++++++++++++'b':+'1011',

++++++++++++++++++++++++++++++'c':+'1100',

++++++++++++++++++++++++++++++'d':+'1101',

++++++++++++++++++++++++++++++'e':+'1110',

++++++++++++++++++++++++++++++'f':+'1111'}

def+hex_to_binary(hex_string):
++++binary_string+=+""
++++for+character+in+hex_string:
++++++++binary_string+%2B=+HEX_TO_BINARY_CONVERSION_TABLE[character]
++++return+binary_string|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1453953|当我给hex_to_binary("123ade")计时|unstyled|offset|length|style|CODE|1453954|++%25timeit+hex_to_binary("123ade")|1453955|结果如下：|1453956|+316+ns+±+2.52+ns+per+loop|1453957|或者，您可以使用"join“方法：|1453958|def+hex_to_binary_join(hex_string):
++++hex_array=[]
++++for+character+in+hex_string:
++++++++hex_array.append(HEX_TO_BINARY_CONVERSION_TABLE[character])
++++return+"".join(hex_array)|1453959|我也计时了：|1453960|++++%25timeit+hex_to_binary_join("123ade")
+++++++397+ns+±+4.64+ns+per+loop+|1453961|entityMap^0|0|3|N|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|11|8|@$G|12|H|13|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$B|C]]|$1|Q|3|R|5|F|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$B|C]]|$1|U|3|V|5|F|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$B|C]]|$1|Y|3|-4|5|F|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

<pre><code>HEX_TO_BINARY_CONVERSION_TABLE = {
 '0': '0000',

 '1': '0001',

 '2': '0010',

 '3': '0011',

 '4': '0100',

 '5': '0101',

 '6': '0110',

 '7': '0111',

 '8': '1000',

 '9': '1001',

 'a': '1010',

 'b': '1011',

 'c': '1100',

 'd': '1101',

 'e': '1110',

 'f': '1111'}

def hex_to_binary(hex_string):
 binary_string = &quot;&quot;
 for character in hex_string:
 binary_string += HEX_TO_BINARY_CONVERSION_TABLE[character]
 return binary_string
</code></pre>
when I time <code>hex_to_binary(&quot;123ade&quot;)</code>
<pre><code> %timeit hex_to_binary(&quot;123ade&quot;)
</code></pre>
here is the result:
<pre><code> 316 ns ± 2.52 ns per loop
</code></pre>
Alternatively, you could use &quot;join&quot; method:
<pre><code>def hex_to_binary_join(hex_string):
 hex_array=[]
 for character in hex_string:
 hex_array.append(HEX_TO_BINARY_CONVERSION_TABLE[character])
 return &quot;&quot;.join(hex_array)
</code></pre>
I timed this too:
<pre><code> %timeit hex_to_binary_join(&quot;123ade&quot;)
 397 ns ± 4.64 ns per loop 
</code></pre>

I have ABC123EFFF.

I want to have 001010101111000001001000111110111111111111 (i.e. binary repr. with, say, 42 digits and leading zeroes).

How?

Convert hex to binary

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我有ABC123EFFF。我想拥有00101010111100000100100011111011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

问将十六进制转换为二进制
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将十六进制转换为二进制EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将十六进制转换为二进制
EN