Chuyển đổi hex sang nhị phân

Tôi có ABC123EFFF.

Tôi muốn có 00101010111100000100100011111011111111111111 (tức là đại diện nhị phân với 42 chữ số và số 0 đứng đầu).

Làm sao?

Để giải quyết vấn đề số không dấu bên trái:

my_hexdata = "1a"

scale = 16 ## equals to hexadecimal

num_of_bits = 8

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

Nó sẽ cung cấp cho 00011010 thay vì phiên bản cắt.

import binascii

binary_string = binascii.unhexlify(hex_string)

Đọc

binascii.unhexlify

Trả về dữ liệu nhị phân được đại diện bởi chuỗi thập lục phân được chỉ định làm tham số.

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

Chuyển đổi hex sang nhị phân

Tôi có ABC123EFFF.

Tôi muốn có 00101010111100000100100011111011111111111111 (tức là đại diện nhị phân với 42 chữ số và số 0 đứng đầu).

Câu trả lời ngắn:

Các chuỗi f mới trong Python 3.6 cho phép bạn thực hiện điều này bằng cách sử dụng cú pháp rất ngắn gọn:

>>> f'{0xABC123EFFF:0>42b}'
'001010101111000001001000111110111111111111'

hoặc để chia nhỏ điều đó với ngữ nghĩa:

>>> number, pad, rjust, size, kind = 0xABC123EFFF, '0', '>', 42, 'b'
>>> f'{number:{pad}{rjust}{size}{kind}}'
'001010101111000001001000111110111111111111'

Câu trả lời dài:

Những gì bạn thực sự đang nói là bạn có một giá trị trong biểu diễn hệ thập lục phân và bạn muốn biểu diễn một giá trị tương đương trong hệ nhị phân.

Giá trị của sự tương đương là một số nguyên. Nhưng bạn có thể bắt đầu bằng một chuỗi và để xem ở dạng nhị phân, bạn phải kết thúc bằng một chuỗi.

Chuyển đổi hex sang nhị phân, 42 chữ số và số 0 ở đầu?

Chúng tôi có một số cách trực tiếp để thực hiện mục tiêu này mà không cần sử dụng các lát cắt.

Đầu tiên, trước khi chúng ta có thể thực hiện bất kỳ thao tác nhị phân nào, hãy chuyển đổi thành int (tôi cho rằng đây là định dạng chuỗi, không phải dưới dạng chữ):

>>> integer = int('ABC123EFFF', 16)
>>> integer
737679765503

cách khác, chúng ta có thể sử dụng một chữ số nguyên như được biểu thị ở dạng thập lục phân:

>>> integer = 0xABC123EFFF
>>> integer
737679765503

Bây giờ chúng ta cần biểu diễn số nguyên của chúng ta trong một biểu diễn nhị phân.

Sử dụng chức năng nội trang, format

Sau đó chuyển đến format:

>>> format(integer, '0>42b')
'001010101111000001001000111110111111111111'

Điều này sử dụng ngôn ngữ nhỏ của đặc tả định dạng .

Để chia nhỏ điều đó, đây là dạng ngữ pháp của nó:

[[fill]align][sign][#][0][width][,][.precision][type]

Để biến điều đó thành đặc điểm kỹ thuật cho nhu cầu của mình, chúng tôi chỉ loại trừ những thứ chúng tôi không cần:

>>> spec = '{fill}{align}{width}{type}'.format(fill='0', align='>', width=42, type='b')
>>> spec
'0>42b'

và chỉ cần chuyển nó sang định dạng

>>> bin_representation = format(integer, spec)
>>> bin_representation
'001010101111000001001000111110111111111111'
>>> print(bin_representation)
001010101111000001001000111110111111111111

Định dạng chuỗi (Templating) với str.format

Chúng ta có thể sử dụng nó trong một chuỗi bằng str.formatphương thức:

>>> 'here is the binary form: {0:{spec}}'.format(integer, spec=spec)
'here is the binary form: 001010101111000001001000111110111111111111'

Hoặc chỉ cần đặt thông số kỹ thuật trực tiếp trong chuỗi gốc:

>>> 'here is the binary form: {0:0>42b}'.format(integer)
'here is the binary form: 001010101111000001001000111110111111111111'

Định dạng chuỗi với f-string mới

Hãy chứng minh các chuỗi f mới. Chúng sử dụng cùng các quy tắc định dạng ngôn ngữ nhỏ:

>>> integer = 0xABC123EFFF
>>> length = 42
>>> f'{integer:0>{length}b}'
'001010101111000001001000111110111111111111'

Bây giờ hãy đặt chức năng này thành một chức năng để khuyến khích khả năng tái sử dụng:

def bin_format(integer, length):
    return f'{integer:0>{length}b}'

Và bây giờ:

>>> bin_format(0xABC123EFFF, 42)
'001010101111000001001000111110111111111111'    

Qua một bên

Nếu bạn thực sự chỉ muốn mã hóa dữ liệu dưới dạng chuỗi byte trong bộ nhớ hoặc trên đĩa, bạn có thể sử dụng int.to_bytesphương pháp này, chỉ có sẵn trong Python 3:

>>> help(int.to_bytes)
to_bytes(...)
    int.to_bytes(length, byteorder, *, signed=False) -> bytes
...

Và vì 42 bit chia cho 8 bit mỗi byte bằng 6 byte:

>>> integer.to_bytes(6, 'big')
b'\x00\xab\xc1#\xef\xff'

>>> bin( 0xABC123EFFF )

'0b1010101111000001001000111110111111111111'

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

Đây là một cách khá thô để làm điều đó bằng cách sử dụng bit fiddling để tạo các chuỗi nhị phân.

Điều quan trọng cần hiểu là:

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

Điều này sẽ tạo ra 0 hoặc 1 nếu bit thứ i của n được đặt.

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

Chỉnh sửa: sử dụng toán tử bậc ba "mới" sau:

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

Sẽ trở thành:

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

(TBH nào tôi không chắc nó có thể đọc được)

Đây là một chút liên quan đến giải pháp của Glen Maynard, mà tôi nghĩ là cách làm đúng. Nó chỉ thêm phần tử đệm.

    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

Kéo nó ra khỏi một lớp học. Chỉ lấy ra self, nếu bạn đang làm việc trong một kịch bản độc lập.

Sử dụng Hàm format () và hàm int () có sẵn Nó đơn giản và dễ hiểu. Đó là phiên bản đơn giản hóa một chút của câu trả lời Aaron

int ()

int(string, base)

định dạng()

format(integer, # of bits)

Thí dụ

# 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

Xem thêm câu trả lời này

Thay thế mỗi chữ số hex bằng 4 chữ số nhị phân tương ứng:

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

hex -> thập phân rồi thập phân -> nhị phân

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

Cách khác:

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

Tôi đã thêm phép tính cho số bit cần điền vào giải pháp của Onedinkenedi. Đây là hàm kết quả:

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

Trong đó 16 là cơ số bạn đang chuyển đổi từ (hệ thập lục phân) và 4 là số bit bạn cần để đại diện cho mỗi chữ số hoặc log cơ số 2 của thang đo.

 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

tôi có một hy vọng ngắn gọn là sẽ giúp :-)

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)

đầu tiên tôi sử dụng đầu vào của bạn và liệt kê nó để lấy từng ký hiệu. sau đó tôi chuyển đổi nó thành nhị phân và cắt từ vị trí thứ 3 đến cuối. Mẹo để nhận được 0 là thêm giá trị tối đa của đầu vào -> trong trường hợp này luôn là 16 :-)

dạng rút gọn là phương thức nối. Thưởng thức.

# 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 

Phiên bản nhị phân của ABC123EFFF thực tế là 1010101111000001001000111110111111111111

Đối với hầu hết các ứng dụng, bạn muốn phiên bản nhị phân có độ dài là bội số của 4 với phần đệm ở đầu là các số 0.

Để có được điều này bằng 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

Ví dụ 1:

>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'

Ví dụ 2:

>>> hex_to_binary( 0x7123 )
'0111000100100011'

Lưu ý rằng điều này cũng hoạt động trong Micropython :)

Chỉ cần sử dụng coden mô-đun ^{(lưu ý: Tôi là tác giả của mô-đun)}

Bạn có thể chuyển đổi haxedecimal sang nhị phân ở đó.

1. Cài đặt bằng pip

pip install coden

2. Đổi

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

Các Từ khoá chuyển đổi là:

• hex cho hệ thập lục phân
• bin cho nhị phân
• int cho số thập phân
• _to_ - từ khóa chuyển đổi cho hàm

Vì vậy, bạn cũng có thể định dạng: e. hexadecimal_output = bin_to_hex (a_binary_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

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

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

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