Ubah hex menjadi biner


106

Saya memiliki ABC123EFFF.

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

Bagaimana?

Jawaban:


106

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.


4
Perhitungan jumlah bit adalah len(my_hexdata) * log2(scale).
Edd

4
Tidak memberikan nol di depan jika string hex dimulai dengan 00.
Naga

@Dragon myhex = '1A' bin (int (myhex, 16)) [2:]. Zfill (8) >>> '00011010' zhex = '00' bin (int (zhex, 16)) [2:]. zfill (8) >>> '00000000' Tampaknya ini berfungsi bahkan ketika string hex adalah '00'.
DeanM

58
import binascii

binary_string = binascii.unhexlify(hex_string)

Baca

binascii.unhexlify

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


17
Ini mengembalikan "biner" seperti pada byte sebenarnya, tetapi tidak mengubahnya menjadi representasi yang dapat dicetak sebagai "0" dan "1".
Matt Good

docs.python.org/library/binascii.html memiliki subjudul Konversi antara biner dan ASCII. Bukankah itu berarti mengembalikan string?
pavium

Ya, ini mengembalikan string yang berisi byte yang diwakili, misalnya >>> unhexlify ("ab") "\ xab"
Matt Good

9
Ada ide bagaimana mengembalikan "001010100"?
David 天宇 Wong

1
Saya tidak tahu mengapa ini dipilih karena tidak menjawab permintaan OP yang sebenarnya - lihat salah satu posting lain untuk mendapatkan jawaban
David Glance

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

7
Jika inputnya adalah "1a" ini menghasilkan "11010", bukan "00011010" yang mungkin atau mungkin tidak sesuai dengan keinginan Anda.
Matt Good

4
Cukup masuk akal untuk membutuhkan angka nol di depan (dan tidak membutuhkannya). Anda mungkin ingin byte nol 0x00 menjadi delapan bit nol misalnya - ini penting untuk beberapa aplikasi. Juga OP memiliki nol di depan dalam contohnya (tapi saya menduga itu hanya acak dalam kasus ini!)
Scott Griffiths

42

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'

31
>>> bin( 0xABC123EFFF )

'0b1010101111000001001000111110111111111111'


2
Tidak memberikan nol di depan jika string hex dimulai dengan 00.
Naga

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

3
Tidak memberikan nol di depan jika string hex dimulai dengan 00.
Naga

10

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)


1
Saya tahu ini sudah tua, tapi apa sebenarnya maksud dari "dan 1"?
Goodies

Ini untuk masa lalu python sebelum operator terner. (N & (1 << i)) akan mengembalikan nol atau sesuatu selain nol. Kami hanya ingin satu atau nol, sehingga "dan 1" ada untuk memastikannya.
John Montgomery

Skrip ini bekerja paling baik bagi saya untuk mengonversi kunci pribadi kripto dalam hex menjadi biner untuk tujuan pengujian. Adakah yang tahu bagaimana membagi string biner menjadi potongan 8 bit dan mencetaknya? mis 01111001 11111110.
Edison

5

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.


5

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


3

Ganti setiap digit hex dengan 4 digit biner yang sesuai:

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

2
Atau ganti setiap pasangan digit hex dengan 8 digit biner yang sesuai, atau ganti setiap triplet digit hex dengan 12 digit biner yang sesuai ... atau ganti setiap 10 digit hex, dengan 40 digit biner yang sesuai - Ups! kembali ke tempat kita mulai!
pavium

2

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

1

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

Ini gagal jika hex_string disetel ke 'f0'
mikemaccana

1

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.


0
 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

0

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.


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

0

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


0

Hanya menggunakan modul Coden (catatan: Saya penulis modul)

Anda dapat mengonversi haxedecimal ke biner di sana.

  1. Instal menggunakan pip
pip install coden
  1. 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)


0

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

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

7
Dimana deskripsi / penjelasannya?
Sufian

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

-7
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
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.