将十六进制转换为二进制

import binascii


binary_string = binascii.unhexlify(hex_string)

读

Binascii unhelify

返回由指定为参数的十六进制字符串表示的二进制数据。

将每个十六进制数字替换为相应的4个二进制数字:

1 - 0001
2 - 0010
...
a - 1010
b - 1011
...
f - 1111

bin(int("abc123efff", 16))[2:]

这里有一个相当原始的方法，可以使用位小提琴来生成二进制字符串。

要理解的关键点是:

(n & (1 << i)) and 1

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

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

Would become:

1 if n & (1 << i) or 0

(我不确定这是否可读)

另一种方式:

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')

十六进制—— > 十进制然后十进制—— > 二进制

#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))

为了解决左边尾随零的问题:

my_hexdata = "1a"


scale = 16 ## equals to hexadecimal


num_of_bits = 8


bin(int(my_hexdata, scale))[2:].zfill(num_of_bits)

它将给00011010代替修剪版本。

这是对 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, 。

"{0:020b}".format(int('ABC123EFFF', 16))

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

>>> bin( 0xABC123EFFF )

“0b1010101111000001000111111111111111111”

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

我在 Onedinkenedi 的解中加入了需要填充的位数计算，得到的结果如下:

def hextobin(h):
return bin(int(h, 16))[2:].zfill(len(h) * 4)

其中16是基数(十六进制) ，4是表示每个数字所需的位数，或者以2为基数的刻度。

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"""

 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

我有一个短暂的希望: -)

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的诀窍是添加 input-> 的最大值，在本例中始终为16: -)

短的形式是连接的方法。享受。

将十六进制转换为二进制

我有 ABC123EFFF。

我想要001010101111000000100011111111011111111111111111(即二进制 例如，42位数字和前导零)。

简短的回答:

Python 3.6中的新 f-string 允许您使用非常简洁的语法完成这项工作:

>>> 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'

使用新的 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'

# 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

使用内置的 Format ()函数和 < a href = “ https://docs.python.org/3/library/function tions.html # int”rel = “ norefrer”> int ()函数 它简单易懂，是亚伦回答的简化版本

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

参见 这个答案

ABC123EFFF 的二进制版本实际上是1010101111000001000111111101111111111111111

对于几乎所有的应用程序，您都希望二进制版本的长度是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

例子一:

>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'

例二:

>>> hex_to_binary( 0x7123 )
'0111000100100011'

注意，这在 Micropython 中也可以工作:)

只要使用模块 Coden ^{(注意: 我是模块的作者)}

您可以在那里将十六进制转换为二进制。

1. 使用 Pip安装

pip install coden

2. 改变信仰

a_hexadecimal_number = "f1ff"
binary_output = coden.hex_to_bin(a_hexadecimal_number)

转换关键字是:

• 十六进制 表示十六进制
• 对于二进制文件，bin
• Int 表示小数
• _ to _ -函数的转换关键字

所以你也可以格式化: E. 十六进制输出 = bin _ to _ 十六进制(a _ binal _ number)

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

或者，你可以使用“ join”方法:

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