16 진수를 바이너리로 변환

ABC123EFFF가 있습니다.

001010101111000001001000111110111111111111 (즉, 42 자리 숫자와 선행 0이있는 이진 표현)을 갖고 싶습니다.

어떻게?

왼쪽 후행 0 문제를 해결하려면 :

my_hexdata = "1a"

scale = 16 ## equals to hexadecimal

num_of_bits = 8

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

트림 된 버전 대신 00011010을 제공합니다.

import binascii

binary_string = binascii.unhexlify(hex_string)

읽다

binascii.unhexlify

매개 변수로 지정된 16 진 문자열로 표시되는 이진 데이터를 리턴합니다.

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

16 진수를 바이너리로 변환

ABC123EFFF가 있습니다.

001010101111000001001000111110111111111111 (즉, 42 자리 숫자와 선행 0이있는 이진 표현)을 갖고 싶습니다.

짧은 답변:

Python 3.6의 새로운 f- 문자열을 사용하면 매우 간결한 구문을 사용하여이를 수행 할 수 있습니다.

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

또는 의미론으로 나누려면 :

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

긴 대답 :

실제로 말하는 것은 16 진법으로 표현 된 값이 있고, 이진법으로 동등한 값을 표현하고 싶다는 것입니다.

동등성 값은 정수입니다. 그러나 문자열로 시작할 수 있으며 바이너리로 보려면 문자열로 끝나야합니다.

16 진수를 이진수, 42 자리 및 선행 0으로 변환 하시겠습니까?

슬라이스를 사용하는 해킹없이이 목표를 달성하는 몇 가지 직접적인 방법이 있습니다.

먼저 이진 조작을 전혀 수행하기 전에 int로 변환하십시오 (이는 리터럴이 아닌 문자열 형식이라고 가정합니다).

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

또는 16 진수 형식으로 표현 된 정수 리터럴을 사용할 수 있습니다.

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

이제 정수를 이진 표현으로 표현해야합니다.

내장 기능을 사용하십시오. format

그런 다음 다음으로 전달하십시오 format.

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

이것은 형식 지정 사양의 미니 언어를 사용 합니다.

이를 분석하기 위해 여기에 문법 형식이 있습니다.

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

그것을 우리의 필요에 맞는 사양으로 만들기 위해 우리는 필요하지 않은 것은 제외합니다.

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

형식에 전달하십시오.

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

문자열 서식 (템플 레이팅) str.format

str.format메서드를 사용하여 문자열에서 사용할 수 있습니다 .

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

또는 원래 문자열에 직접 사양을 입력하십시오.

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

새로운 f- 문자열로 문자열 형식화

새로운 f- 문자열을 시연 해 보겠습니다. 동일한 미니 언어 서식 규칙을 사용합니다.

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

이제 재사용을 장려하기 위해이 기능을 함수에 넣어 보겠습니다.

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

그리고 지금:

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

곁에

실제로 데이터를 메모리 또는 디스크의 바이트 문자열로 인코딩하려는 경우 int.to_bytesPython 3에서만 사용할 수 있는 메서드를 사용할 수 있습니다 .

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

42 비트를 바이트 당 8 비트로 나누면 6 바이트가됩니다.

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

>>> bin( 0xABC123EFFF )

'0b1010101111000001001000111110111111111111'

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

이진 문자열을 생성하기 위해 비트 조작을 사용하는 매우 원시적 인 방법이 있습니다.

이해해야 할 핵심 사항은 다음과 같습니다.

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

n의 i 번째 비트가 설정되면 0 또는 1을 생성합니다.

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

편집 : "새로운"삼항 연산자 사용 :

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

될 것 :

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

(어떤 TBH인지 얼마나 읽을 수 있는지 잘 모르겠습니다)

이것은 Glen Maynard의 솔루션에 대한 약간의 수정이며, 이것이 올바른 방법이라고 생각합니다. 패딩 요소 만 추가합니다.

    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

수업에서 빼냈어요. self, 독립 실행 형 스크립트로 작업 하는 경우 꺼내십시오 .

내장 된 format () 함수 및 int () 함수 사용 간단하고 이해하기 쉽습니다. Aaron 답변 의 약간 단순화 된 버전입니다.

int ()

int(string, base)

체재()

format(integer, # of bits)

예

# 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

이 답변 참조

각 16 진수를 해당하는 4 자리 이진수로 바꿉니다.

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

16 진수-> 10 진수 다음 10 진수-> 2 진수

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

또 다른 방법:

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의 솔루션에 채울 비트 수에 대한 계산을 추가했습니다. 결과 함수는 다음과 같습니다.

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

여기서 16은 변환 할 기준 (16 진수)이고 4는 각 숫자를 나타내는 데 필요한 비트 수 또는 척도의 밑이 2입니다.

 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

나는 도움이되는 짧은 희망을 가지고 있습니다 :-)

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)

먼저 입력을 사용하고 열거하여 각 기호를 얻습니다. 그런 다음 바이너리로 변환하고 세 번째 위치에서 끝까지 트리밍합니다. 0을 얻는 트릭은 입력의 최대 값을 추가하는 것입니다->이 경우 항상 16 :-)

약식은 조인 방법입니다. 즐겨.

# 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의 바이너리 버전은 실제로 1010101111000001001000111110111111111111입니다.

거의 모든 응용 프로그램의 경우 바이너리 버전의 길이가 4의 배수이고 선행 패딩이 0 인 것을 원합니다.

이것을 파이썬으로 얻으려면 :

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

예 1 :

>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'

예 2 :

>>> hex_to_binary( 0x7123 )
'0111000100100011'

이것은 Micropython에서도 작동합니다. :)

모듈 코드를 사용하십시오. ^{(참고 : 나는 모듈의 작성자입니다).}

haxedecimal을 바이너리로 변환 할 수 있습니다.

1. pip를 사용하여 설치

pip install coden

2. 변하게 하다

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

변환하는 키워드는 다음과 같습니다.

• 16 진수의 경우 16 진수
• 바이너리 용 bin
• INT 10 진수
• _to_- 함수에 대한 변환 키워드

따라서 형식을 지정할 수도 있습니다. 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