Hex'i ikiliye dönüştür

ABC123EFFF'im ​​var.

001010101111000001001000111110111111111111'e sahip olmak istiyorum (yani, 42 basamaklı ve önde gelen sıfırlarla ikili repr.).

Nasıl?

Sol taraftaki sıfır sorununu çözmek için:

my_hexdata = "1a"

scale = 16 ## equals to hexadecimal

num_of_bits = 8

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

Kesilmiş versiyon yerine 00011010 verecektir.

import binascii

binary_string = binascii.unhexlify(hex_string)

Okuyun

binascii.unhexlify

Parametre olarak belirtilen onaltılık dizeyle temsil edilen ikili verileri döndürür.

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

Hex'i ikiliye dönüştür

ABC123EFFF'im ​​var.

001010101111000001001000111110111111111111'e sahip olmak istiyorum (yani, 42 basamaklı ve önde gelen sıfırlarla ikili repr.).

Kısa cevap:

Python 3.6'daki yeni f dizeleri, bunu çok kısa sözdizimi kullanarak yapmanıza izin verir:

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

veya bunu anlambilimden ayırmak için:

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

Uzun cevap:

Aslında söylediğiniz şey, onaltılık gösterimde bir değere sahip olduğunuz ve ikili olarak eşdeğer bir değeri temsil etmek istediğinizdir.

Eşdeğerlik değeri bir tamsayıdır. Ancak bir dizeyle başlayabilirsiniz ve ikili olarak görüntülemek için bir dizeyle bitirmelisiniz.

Onaltılık ikili, 42 basamaklı ve önde gelen sıfırlara dönüştürülsün mü?

Bu hedefe dilimleri kullanarak kesmeksizin ulaşmak için birkaç doğrudan yolumuz var.

İlk olarak, herhangi bir ikili işlem yapmadan önce, int'e dönüştürün (bunun bir dize biçiminde olduğunu, değişmez değil):

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

alternatif olarak onaltılık biçimde ifade edildiği gibi bir tamsayı hazır değeri kullanabiliriz:

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

Şimdi tamsayımızı ikili gösterimle ifade etmemiz gerekiyor.

Yerleşik işlevi kullanın, format

Ardından şuraya geçin format:

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

Bu, biçimlendirme belirtiminin mini dilini kullanır .

Bunu açıklığa kavuşturmak için, işte gramer formu:

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

Bunu ihtiyaçlarımıza yönelik bir şartname haline getirmek için, ihtiyacımız olmayan şeyleri hariç tutuyoruz:

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

ve sadece biçimlendirmek için iletin

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

Dize Biçimlendirme (Şablonlama) ile str.format

Bunu str.formatmetodu kullanarak bir dizede kullanabiliriz :

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

Veya spesifikasyonu doğrudan orijinal dizeye koyun:

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

Yeni f dizeleriyle dize biçimlendirme

Yeni f dizelerini gösterelim. Aynı mini dil biçimlendirme kurallarını kullanırlar:

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

Şimdi bu işlevi yeniden kullanılabilirliği teşvik edecek bir işleve koyalım:

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

Ve şimdi:

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

Bir yana

Verileri gerçekten bellekte veya diskte bir bayt dizisi olarak kodlamak istiyorsanız int.to_bytes, yalnızca Python 3'te mevcut olan yöntemi kullanabilirsiniz :

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

Ve 42 bit, bayt başına 8 bit'e bölündüğünden, 6 bayta eşittir:

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

>>> bin( 0xABC123EFFF )

'0b1010101111000001001000111110111111111111'

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

İkili dizgeleri oluşturmak için biraz uğraşarak yapmanın oldukça ham bir yolu.

Anlaşılması gereken anahtar nokta şudur:

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

N'nin i'inci biti ayarlanmışsa bu, 0 veya 1 üretecektir.

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

Düzenleme: "yeni" üçlü operatörü kullanarak bu:

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

Olacaktı:

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

(Hangi TBH'nin ne kadar okunabilir olduğundan emin değilim)

Bu, Glen Maynard'ın çözümüne ufak bir dokunuş, bence bunu yapmanın doğru yolu. Yalnızca dolgu öğesini ekler.

    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

Onu bir sınıftan çıkardı. self, Bağımsız bir senaryoda çalışıyorsanız, çıkarın .

Yerleşik format () işlevini ve int () işlevini kullanın Basit ve anlaşılması kolaydır. Aaron cevabının biraz basitleştirilmiş versiyonu

int ()

int(string, base)

biçim()

format(integer, # of bits)

Misal

# 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

Bu yanıta da bakın

Her onaltılık basamağı karşılık gelen 4 ikili basamakla değiştirin:

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

onaltılık -> ondalık sonra ondalık -> ikili

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

Diğer yol:

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

Onedinkenedi'nin çözümüne doldurulacak bit sayısı hesaplamasını ekledim. İşte ortaya çıkan işlev:

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

Burada 16, dönüştürdüğünüz taban (onaltılık) ve 4, her basamağı veya ölçeğin 2 tabanını temsil etmek için kaç bit gerektiğidir.

 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

yardımcı olacak kısa bir umudum var :-)

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)

önce girdinizi kullanıyorum ve her sembolü elde etmek için numaralandırıyorum. sonra onu ikiliye dönüştürürüm ve 3. pozisyondan sonuna kadar kırpırım. 0'ı elde etmenin püf noktası, girişin maksimum değerini eklemektir -> bu durumda her zaman 16 :-)

kısa biçim birleştirme yöntemidir. Zevk almak.

# 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 

ABC123EFFF'in ikili sürümü aslında 1010101111000001001000111110111111111111'dir.

Neredeyse tüm uygulamalar için ikili sürümün uzunluğunun 4'ün katı ve başında 0'ların dolgusu olmasını istersiniz.

Bunu Python'da almak için:

def hex_to_binary( hex_code ):
  bin_code = bin( hex_code )[2:]
  padding = (4-len(bin_code)%4)%4
  return '0'*padding + bin_code

Örnek 1:

>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'

Örnek 2:

>>> hex_to_binary( 0x7123 )
'0111000100100011'

Bunun Micropython'da da çalıştığını unutmayın :)

Sadece modül kodunu kullanın ^(not: modülün yazarıyım ⁾

Orada haxedecimal'i ikiliye dönüştürebilirsiniz.

1. Pip kullanarak kurun

pip install coden

2. Dönüştürmek

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

Dönüştüren Anahtar Kelimeler:

• onaltılık için onaltılık
• ikili için bin
• ondalık sayı için int
• _to_ - işlev için dönüştürücü anahtar sözcük

Böylece şu formatları da yapabilirsiniz: e. hexadecimal_output = bin_to_hex (ikili_sayı)

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