Convertir hexadécimal en binaire


107

J'ai ABC123EFFF.

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

Comment?

Réponses:


106

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.


4
Le calcul du nombre de bits est len(my_hexdata) * log2(scale).
Edd

4
Ne fournit pas de zéros non significatifs si la chaîne hexadécimale commence par 00.
Dragon

@Dragon myhex = '1A' bin (int (myhex, 16)) [2:]. Zfill (8) >>> '00011010' zhex = '00' bin (int (zhex, 16)) [2:]. zfill (8) >>> '00000000' Il semble que cela fonctionne même lorsque la chaîne hexadécimale est '00'.
DeanM

59
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.


17
Cela renvoie «binaire» comme dans les octets réels, mais il ne le convertit pas en une représentation imprimable comme «0» et «1».
Matt Good

docs.python.org/library/binascii.html est sous-titré Convertir entre binaire et ASCII. Cela ne signifie-t-il pas qu'il renvoie une chaîne?
pavium

Oui, il renvoie une chaîne contenant les octets représentés, par exemple >>> unhexlify ("ab") "\ xab"
Matt Good

9
Une idée comment retourner "001010100"?
David 天宇 Wong

1
Je ne sais pas pourquoi cela a été voté car il ne répond pas à la demande réelle du PO - voir les autres messages pour une réponse
David Glance

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

7
Si l'entrée est "1a", cela donne "11010", et non "00011010" qui peut ou non être ce que vous voulez.
Matt Good

4
Il est tout à fait raisonnable d'avoir besoin des zéros de tête (et de ne pas en avoir besoin). Vous voudrez peut-être que l'octet nul 0x00 soit huit bits zéro par exemple - c'est important pour certaines applications. De plus, l'OP a un zéro non significatif dans son exemple (mais je suppose que c'est juste aléatoire dans ce cas!)
Scott Griffiths

42

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'

31
>>> bin( 0xABC123EFFF )

«0b1010101111000001001000111110111111111111»


2
Ne fournit pas de zéros non significatifs si la chaîne hexadécimale commence par 00.
Dragon

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

3
Ne fournit pas de zéros non significatifs si la chaîne hexadécimale commence par 00.
Dragon

10

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)


1
Je sais que c'est vieux, mais quel est exactement le point du "et 1"?
Goodies

C'est pour les vieux jours de python avant l'opérateur ternaire. Le (n & (1 << i)) renverra soit zéro, soit quelque chose d'autre que zéro. Nous voulons seulement un un ou un zéro, de sorte que «et 1» est là pour garantir cela.
John Montgomery

Ce script a fonctionné le mieux pour moi pour convertir une clé privée crypto en hexadécimal en binaire à des fins de test. Est-ce que quelqu'un sait comment diviser la chaîne binaire en morceaux de 8 bits et l'imprimer? ie 01111001 11111110.
Edison

5

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.


5

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


3

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

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

2
Ou remplacez chaque paire de chiffres hexadécimaux par les 8 chiffres binaires correspondants, ou remplacez chaque triplet de chiffres hexadécimaux par les 12 chiffres binaires correspondants ... ou remplacez chaque 10 chiffres hexadécimaux par les 40 chiffres binaires correspondants - Oups! retour là où nous avons commencé!
pavium

2

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

1

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

Cela échoue si hex_string est défini sur 'f0'
mikemaccana

1

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.


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

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.


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

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


0

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


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
Où est la description / l'explication?
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
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.