Convertir hexadécimal en binaire

J'ai ABC123EFFF.

Je veux avoir 001010101111000001001000111110111111111111 (c'est-à-dire repr. Binaire avec, disons, 42 chiffres et des zéros non significatifs).

Comment?

Pour résoudre le problème du zéro final du côté gauche:

my_hexdata = "1a"

scale = 16 ## equals to hexadecimal

num_of_bits = 8

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

Il donnera 00011010 au lieu de la version découpée.

import binascii

binary_string = binascii.unhexlify(hex_string)

Lis

binascii.unhexlify

Renvoie les données binaires représentées par la chaîne hexadécimale spécifiée comme paramètre.

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

Convertir hexadécimal en binaire

J'ai ABC123EFFF.

Je veux avoir 001010101111000001001000111110111111111111 (c'est-à-dire repr. Binaire avec, disons, 42 chiffres et des zéros non significatifs).

Réponse courte:

Les nouvelles f-strings de Python 3.6 vous permettent de le faire en utilisant une syntaxe très concise:

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

ou pour rompre avec la sémantique:

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

Longue réponse:

Ce que vous dites en fait, c'est que vous avez une valeur dans une représentation hexadécimale et que vous voulez représenter une valeur équivalente en binaire.

La valeur d'équivalence est un entier. Mais vous pouvez commencer par une chaîne, et pour afficher en binaire, vous devez terminer par une chaîne.

Convertir hexadécimal en binaire, 42 chiffres et zéros non significatifs?

Nous avons plusieurs moyens directs pour atteindre cet objectif, sans hacks utilisant des tranches.

Tout d'abord, avant de pouvoir faire une manipulation binaire du tout, convertissez-le en int (je suppose que c'est dans un format de chaîne, pas comme un littéral):

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

alternativement, nous pourrions utiliser un littéral entier exprimé sous forme hexadécimale:

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

Nous devons maintenant exprimer notre entier dans une représentation binaire.

Utilisez la fonction intégrée, format

Passez ensuite à format:

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

Cela utilise le mini-langage de la spécification de formatage .

Pour décomposer cela, voici la forme grammaticale de celui-ci:

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

Pour en faire une spécification pour nos besoins, nous excluons simplement les choses dont nous n'avons pas besoin:

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

et transmettez-le simplement au format

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

Mise en forme de chaîne (création de modèles) avec str.format

Nous pouvons l'utiliser dans une chaîne en utilisant la str.formatméthode:

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

Ou mettez simplement la spécification directement dans la chaîne d'origine:

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

Formatage de chaîne avec les nouvelles chaînes f

Montrons les nouvelles f-strings. Ils utilisent les mêmes règles de formatage en mini-langage:

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

Maintenant, mettons cette fonctionnalité dans une fonction pour encourager la réutilisabilité:

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

Et maintenant:

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

De côté

Si vous vouliez simplement encoder les données sous forme de chaîne d'octets en mémoire ou sur disque, vous pouvez utiliser la int.to_bytesméthode, qui n'est disponible que dans Python 3:

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

Et puisque 42 bits divisés par 8 bits par octet équivalent à 6 octets:

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

>>> bin( 0xABC123EFFF )

«0b1010101111000001001000111110111111111111»

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

Voici une façon assez brute de le faire en utilisant un peu de bidouillage pour générer les chaînes binaires.

Le bit clé à comprendre est:

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

Ce qui générera un 0 ou un 1 si le i'ième bit de n est défini.

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: en utilisant le "nouvel" opérateur ternaire ceci:

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

Deviendrait:

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

(Quel TBH je ne sais pas si c'est lisible)

C'est une légère retouche à la solution de Glen Maynard, qui, à mon avis, est la bonne façon de procéder. Il ajoute simplement l'élément de remplissage.

    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

Je l'ai sorti d'une classe. Supprimez simplement self, si vous travaillez dans un script autonome.

Utiliser la fonction intégrée format () et la fonction int () C'est simple et facile à comprendre. C'est une version un peu simplifiée de la réponse d'Aaron

int ()

int(string, base)

format()

format(integer, # of bits)

Exemple

# 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

Voir aussi cette réponse

Remplacez chaque chiffre hexadécimal par les 4 chiffres binaires correspondants:

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

hex -> décimal puis décimal -> binaire

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

Autrement:

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

J'ai ajouté le calcul du nombre de bits à remplir à la solution Onedinkenedi. Voici la fonction résultante:

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

Où 16 est la base à partir de laquelle vous convertissez (hexadécimal), et 4 est le nombre de bits dont vous avez besoin pour représenter chaque chiffre, ou log base 2 de l'échelle.

 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

J'ai un petit espoir qui aide :-)

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)

J'utilise d'abord votre entrée et l'énumère pour obtenir chaque symbole. puis je le convertis en binaire et coupe de la 3ème position à la fin. L'astuce pour obtenir le 0 est d'ajouter la valeur max de l'entrée -> dans ce cas toujours 16 :-)

la forme courte est la méthode de jointure. Prendre plaisir.

# 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 

La version binaire de ABC123EFFF est en fait 1010101111000001001000111110111111111111

Pour presque toutes les applications, vous voulez que la version binaire ait une longueur qui soit un multiple de 4 avec un remplissage principal de 0.

Pour obtenir cela en 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

Exemple 1:

>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'

Exemple 2:

>>> hex_to_binary( 0x7123 )
'0111000100100011'

Notez que cela fonctionne également dans Micropython :)

Il suffit d'utiliser le module coden ^{(note: je suis l'auteur du module)}

Vous pouvez y convertir haxedecimal en binaire.

1. Installer à l'aide de pip

pip install coden

2. Convertir

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

Les mots-clés de conversion sont:

• hex pour hexadimal
• bin pour binaire
• int pour décimal
• _to_ - le mot-clé de conversion pour la fonction

Vous pouvez donc également formater: 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