Ubah hex menjadi biner

Saya memiliki ABC123EFFF.

Saya ingin memiliki 001010101111000001001000111110111111111111 (mis. Repr biner dengan, katakanlah, 42 digit dan nol di depan).

Bagaimana?

Untuk menyelesaikan soal sisi kiri tanpa jejak:

my_hexdata = "1a"

scale = 16 ## equals to hexadecimal

num_of_bits = 8

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

Ini akan memberikan 00011010 bukan versi yang dipangkas.

import binascii

binary_string = binascii.unhexlify(hex_string)

Baca

binascii.unhexlify

Kembalikan data biner yang diwakili oleh string heksadesimal yang ditentukan sebagai parameter.

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

Ubah hex menjadi biner

Saya memiliki ABC123EFFF.

Saya ingin memiliki 001010101111000001001000111110111111111111 (mis. Repr biner dengan, katakanlah, 42 digit dan nol di depan).

Jawaban singkat:

F-string baru di Python 3.6 memungkinkan Anda melakukan ini menggunakan sintaks yang sangat singkat:

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

atau untuk memecahnya dengan semantik:

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

Jawaban panjang:

Apa yang sebenarnya Anda katakan adalah bahwa Anda memiliki nilai dalam representasi heksadesimal, dan Anda ingin merepresentasikan nilai yang setara dalam biner.

Nilai kesetaraan adalah bilangan bulat. Tapi Anda bisa mulai dengan string, dan untuk melihat dalam biner, Anda harus diakhiri dengan string.

Ubah hex menjadi biner, 42 digit dan nol di depan?

Kami memiliki beberapa cara langsung untuk mencapai tujuan ini, tanpa peretasan menggunakan irisan.

Pertama, sebelum kita dapat melakukan manipulasi biner sama sekali, konversikan ke int (saya anggap ini dalam format string, bukan sebagai literal):

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

alternatifnya kita bisa menggunakan literal integer seperti yang dinyatakan dalam bentuk heksadesimal:

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

Sekarang kita perlu mengekspresikan integer kita dalam representasi biner.

Gunakan fungsi builtin, format

Kemudian lolos ke format:

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

Ini menggunakan bahasa mini spesifikasi pemformatan .

Untuk menguraikannya, inilah bentuk tata bahasanya:

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

Untuk membuatnya menjadi spesifikasi untuk kebutuhan kita, kita hanya mengecualikan hal-hal yang tidak kita butuhkan:

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

dan teruskan itu ke format

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

String Formatting (Templating) dengan str.format

Kita bisa menggunakannya dalam string menggunakan str.formatmetode:

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

Atau cukup letakkan spesifikasi langsung di string asli:

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

Pemformatan String dengan f-string baru

Mari kita peragakan f-string baru. Mereka menggunakan aturan pemformatan bahasa mini yang sama:

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

Sekarang mari kita letakkan fungsi ini ke dalam fungsi untuk mendorong penggunaan kembali:

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

Dan sekarang:

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

Ke samping

Jika Anda sebenarnya hanya ingin menyandikan data sebagai string byte dalam memori atau pada disk, Anda dapat menggunakan int.to_bytesmetode ini, yang hanya tersedia di Python 3:

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

Dan karena 42 bit dibagi 8 bit per byte sama dengan 6 byte:

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

>>> bin( 0xABC123EFFF )

'0b1010101111000001001000111110111111111111'

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

Berikut adalah cara yang cukup mentah untuk melakukannya dengan menggunakan bit fiddling untuk menghasilkan string biner.

Sedikit kunci untuk dipahami adalah:

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

Yang akan menghasilkan 0 atau 1 jika bit ke-i dari n disetel.

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

Edit: menggunakan operator ternary "baru" ini:

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

Akan menjadi:

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

(TBH mana yang saya tidak yakin seberapa mudah dibaca)

Ini adalah sedikit sentuhan untuk solusi Glen Maynard, yang menurut saya adalah cara yang tepat untuk melakukannya. Itu hanya menambahkan elemen padding.

    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

Menariknya dari kelas. Keluarkan saja self, jika Anda mengerjakan skrip yang berdiri sendiri.

Gunakan Fungsi built-in format () dan fungsi int () Sederhana dan mudah dimengerti. Ini versi jawaban Aaron yang sedikit disederhanakan

int ()

int(string, base)

format()

format(integer, # of bits)

Contoh

# 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

Lihat juga jawaban ini

Ganti setiap digit hex dengan 4 digit biner yang sesuai:

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

hex -> desimal lalu desimal -> biner

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

Cara lain:

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

Saya menambahkan kalkulasi jumlah bit yang harus diisi ke solusi Onedinkenedi. Inilah fungsi yang dihasilkan:

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

Di mana 16 adalah basis tempat Anda mengonversi (heksadesimal), dan 4 adalah berapa banyak bit yang Anda butuhkan untuk mewakili setiap digit, atau log basis 2 dari skala.

 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

Saya memiliki harapan terpotong pendek yang membantu :-)

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)

pertama saya menggunakan masukan Anda dan menghitungnya untuk mendapatkan setiap simbol. kemudian saya mengubahnya menjadi biner dan memangkas dari posisi ke-3 sampai akhir. Trik untuk mendapatkan 0 adalah dengan menambahkan nilai maksimal dari input -> dalam hal ini selalu 16 :-)

bentuk singkatnya adalah metode bergabung. Nikmati.

# 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 

Versi biner ABC123EFFF sebenarnya adalah 1010101111000001001000111110111111111111

Untuk hampir semua aplikasi, Anda ingin versi biner memiliki panjang kelipatan 4 dengan bantalan awal 0s.

Untuk mendapatkan ini dengan 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

Contoh 1:

>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'

Contoh 2:

>>> hex_to_binary( 0x7123 )
'0111000100100011'

Perhatikan bahwa ini juga berfungsi di Micropython :)

Hanya menggunakan modul Coden ^{(catatan: Saya penulis modul)}

Anda dapat mengonversi haxedecimal ke biner di sana.

1. Instal menggunakan pip

pip install coden

2. Mengubah

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

Kata kunci yang mengubah adalah:

• hex untuk heksadeimal
• bin untuk biner
• int untuk desimal
• _to_ - kata kunci konversi untuk fungsi tersebut

Jadi Anda juga bisa memformat: e. hexadecimal_output = bin_to_hex (bilangan_biner)

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