将十六进制转换为二进制
Posted
技术标签:
【中文标题】将十六进制转换为二进制【英文标题】：Convert hex to binary 【发布时间】：2010-11-28 08:53:42 【问题描述】：我有 ABC123EFFF。
我想要 001010101111000001001000111110111111111111（即二进制表示，例如，42 位数字和前导零）。
怎么做？
【问题讨论】：
我有ABC123EFFF -- ABC123EFFF 是字符串或数字（即0xABC123EFFF）？
如果它是一个字符串，我几年前在网上找到的这个 lambda 可能会有所帮助： binary = lambda x: "".join(reversed( [i+j for i,j in zip( *[ ["0:04b".format(int(c,16)) for c in reversed("0"+x)][n::2] for n in [1,0] ] ) ] )) 二进制("ABC123EFFF") '1010101111000001001000111110111111111111' 也适用于前导零。
【参考方案1】：
用于解决左侧尾随零问题：
my_hexdata = "1a"
scale = 16 ## equals to hexadecimal
num_of_bits = 8
bin(int(my_hexdata, scale))[2:].zfill(num_of_bits)
它将给出 00011010 而不是修剪后的版本。
【讨论】：
计算位数为len(my_hexdata) * log2(scale)。
如果十六进制字符串以 00 开头，则不提供前导零。
@Dragon myhex = '1A' bin(int(myhex, 16))[2:].zfill(8) >>> '00011010' zhex = '00' bin(int(zhex, 16))[2:].zfill(8) >>> '00000000' 看起来即使十六进制字符串为 '00' 也有效。
@DeanM 当您有前导零时，这不起作用。例如，当您使用 zhex='0048' 时，您会得到 01001000 而不是 0000000001001000。这个answer 对我有用。【参考方案2】：
import binascii
binary_string = binascii.unhexlify(hex_string)
阅读
binascii.unhexlify
返回指定为参数的十六进制字符串表示的二进制数据。
【讨论】：
这会返回实际字节中的“二进制”，但不会将其转换为“0”和“1”的可打印表示。 docs.python.org/library/binascii.html 的字幕是在二进制和 ASCII 之间转换。这不是说它返回一个字符串吗？ 是的，它返回一个包含所表示的字节的字符串，例如>>> unhexlify("ab") "\xab" 知道如何返回“001010100”吗？ 我不知道为什么这被投票了，因为它没有回答 OP 的实际请求 - 请参阅任何其他帖子以获得答案【参考方案3】：将十六进制转换为二进制
我有 ABC123EFFF。
我想要 001010101111000001001000111110111111111111（即二进制 代表。例如，42 位数字和前导零）。
简答：
Python 3.6 中的新 f 字符串允许您使用非常简洁的语法来执行此操作：
>>> f'0xABC123EFFF:0>42b'
'001010101111000001001000111110111111111111'
或者用语义分解它：
>>> number, pad, rjust, size, kind = 0xABC123EFFF, '0', '>', 42, 'b'
>>> f'number:padrjustsizekind'
'001010101111000001001000111110111111111111'
长答案：
你实际上是在说你有一个十六进制表示的值，你想用二进制表示一个等效的值。
等价的值是一个整数。但你可以以字符串开头，而要以二进制形式查看，则必须以字符串结尾。
将十六进制转换为二进制、42 位数字和前导零？
我们有几种直接的方法来实现这一目标，而无需使用切片进行破解。
首先，在我们进行任何二进制操作之前，先转换为 int（我认为这是字符串格式，而不是文字）：
>>> integer = int('ABC123EFFF', 16)
>>> integer
737679765503
或者，我们可以使用以十六进制形式表示的整数文字：
>>> integer = 0xABC123EFFF
>>> integer
737679765503
现在我们需要用二进制表示来表示我们的整数。
使用内置函数format
然后传给format:
>>> format(integer, '0>42b')
'001010101111000001001000111110111111111111'
这使用格式规范的mini-language。
为了分解，这里是它的语法形式：
[[fill]align][sign][#][0][width][,][.precision][type]
为了使其成为满足我们需求的规范，我们只是排除了我们不需要的东西：
>>> spec = 'fillalignwidthtype'.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'
或者直接把spec直接放在原字符串里：
>>> 'here is the binary form: 0:0>42b'.format(integer)
'here is the binary form: 001010101111000001001000111110111111111111'
使用新的 f 字符串格式化字符串
让我们演示一下新的 f 弦。它们使用相同的迷你语言格式规则：
>>> integer = 0xABC123EFFF
>>> length = 42
>>> f'integer:0>lengthb'
'001010101111000001001000111110111111111111'
现在让我们将此功能放入一个函数中以鼓励可重用性：
def bin_format(integer, length):
return f'integer:0>lengthb'
现在：
>>> 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'
【讨论】：
【参考方案4】：bin(int("abc123efff", 16))[2:]
【讨论】：
如果输入是“1a”，则给出“11010”，而不是“00011010”，这可能是也可能不是您想要的。 需要前导零（并且不需要它们）是非常合理的。例如，您可能希望空字节 0x00 为 8 个零位 - 这对于某些应用程序很重要。 OP 在他的例子中也有一个前导零（但我怀疑在这种情况下这只是随机的！）【参考方案5】：>>> bin( 0xABC123EFFF )
'0b1010101111000001001000111110111111111111'
【讨论】：
如果十六进制字符串以 00 开头，则不提供前导零。【参考方案6】：使用内置的format() function 和int() function 它简单易懂。这是Aaron answer的一点简化版
int()
int(string, base)
格式（）
format(integer, # of bits)
示例
# w/o 0b prefix
>> format(int("ABC123EFFF", 16), "040b")
1010101111000001001000111110111111111111
# with 0b prefix
>> format(int("ABC123EFFF", 16), "#042b")
0b1010101111000001001000111110111111111111
# w/o 0b prefix + 64bit
>> format(int("ABC123EFFF", 16), "064b")
0000000000000000000000001010101111000001001000111110111111111111
另见this answer
【讨论】：
【参考方案7】："0:020b".format(int('ABC123EFFF', 16))
【讨论】：
如果十六进制字符串以 00 开头，则不提供前导零。【参考方案8】：这是一种相当原始的方法，使用位摆弄来生成二进制字符串。
要理解的关键点是：
(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 的可读性）
【讨论】：
我知道这是旧的，但“和 1”到底有什么意义？ 这是在三元运算符之前的python的旧时代。 (n & (1 这个脚本最适合我将十六进制的加密私钥转换为二进制以进行测试。有谁知道如何将二进制字符串拆分为 8 位块并打印出来？即0111100111111110。【参考方案9】：
这与 Glen Maynard 的解决方案略有不同，我认为这是正确的做法。它只是添加了填充元素。
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, 。
【讨论】：
【参考方案10】：我将要填充的位数的计算添加到 Onedinkenedi 的解决方案中。这是生成的函数：
def hextobin(h):
return bin(int(h, 16))[2:].zfill(len(h) * 4)
其中 16 是要转换的基数（十六进制），4 是表示每个数字所需的位数，或以 2 为基数。
【讨论】：
【参考方案11】：将每个十六进制数字替换为对应的 4 个二进制数字：
1 - 0001
2 - 0010
...
a - 1010
b - 1011
...
f - 1111
【讨论】：
或者将每对十六进制数字替换为对应的8个二进制数字，或者将每一个十六进制数字的三元组替换为对应的12个二进制数字……或者将每10个十六进制数字替换为对应的40个二进制数字数字 - 哎呀！回到我们开始的地方！【参考方案12】：十六进制 --> 十进制然后十进制 --> 二进制
#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))
【讨论】：
【参考方案13】：另一种方式：
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')
【讨论】：
如果 hex_string 设置为 'f0' 会失败【参考方案14】：# 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
【讨论】：
【参考方案15】：ABC123EFFF的二进制版本其实是1010101111000001001000111110111111111111
对于几乎所有应用程序，您都希望二进制版本的长度为 4 的倍数，前导填充为 0。
要在 Python 中得到这个：
def hex_to_binary( hex_code ):
bin_code = bin( hex_code )[2:]
padding = (4-len(bin_code)%4)%4
return '0'*padding + bin_code
示例 1：
>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'
示例 2：
>>> hex_to_binary( 0x7123 )
'0111000100100011'
请注意，这也适用于 Micropython :)
【讨论】：
不错。对于十六进制字符串而不是十六进制值： bin_code = bin(int(hex_code, 0))[2:] 我想你的意思是bin_code = bin(int(hex_code, 16))[2:]
是的，没错。为了澄清我的答案：如果十六进制字符串以“0x”为前缀，则 base 0 有效【参考方案16】：
只需使用模块coden （注意：我是模块的作者）
您可以在那里将十六进制转换为二进制。
-
使用pip安装
pip install coden
-
转换
a_hexadecimal_number = "f1ff"
binary_output = coden.hex_to_bin(a_hexadecimal_number)
转换关键字是：
hex 表示十六进制 bin 用于二进制 int 表示十进制 _to_ - 函数的转换关键字所以你也可以格式化： e. hexadecimal_output = bin_to_hex(a_binary_number)
【讨论】：
【参考方案17】： 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
【讨论】：
【参考方案18】：我有一个简短的希望可以帮助:-)
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)
首先我使用您的输入并枚举它以获取每个符号。然后我将其转换为二进制并从第 3 个位置修剪到末尾。获得 0 的技巧是添加输入的最大值 -> 在这种情况下总是 16 :-)
简写是join方法。享受吧。
【讨论】：
【参考方案19】：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
【讨论】：
描述/解释在哪里？【参考方案20】：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"""
【讨论】：
【参考方案21】：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 += HEX_TO_BINARY_CONVERSION_TABLE[character]
return binary_string
当我计时hex_to_binary("123ade")
%timeit hex_to_binary("123ade")
结果如下：
316 ns ± 2.52 ns per loop
或者，您可以使用“加入”方法：
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)
我也计时了：
%timeit hex_to_binary_join("123ade")
397 ns ± 4.64 ns per loop
【讨论】：
不要使用字符串连接。return "".join(HEX_TO_BINARY_CONVERSION_TABLE[c] for c in hex_string)【参考方案22】：
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
【讨论】：
以上是关于将十六进制转换为二进制的主要内容，如果未能解决你的问题，请参考以下文章