I have ABC123EFFF.

I want to have 001010101111000001001000111110111111111111 (i.e. binary repr. with, say, 42 digits and leading zeroes).

How?

For solving the left-side trailing zero problem:

``````my_hexdata = "1a"

scale = 16 ## equals to hexadecimal

num_of_bits = 8

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

It will give 00011010 instead of the trimmed version.

``````import binascii

binary_string = binascii.unhexlify(hex_string)
``````

binascii.unhexlify

Return the binary data represented by the hexadecimal string specified as the parameter.

## Convert hex to binary

I have ABC123EFFF.

I want to have 001010101111000001001000111110111111111111 (i.e. binary
repr. with, say, 42 digits and leading zeroes).

The new f-strings in Python 3.6 allow you to do this using very terse syntax:

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

or to break that up with the semantics:

``````>>> number, pad, rjust, size, kind = 0xABC123EFFF, '0', '>', 42, 'b'
'001010101111000001001000111110111111111111'
``````

What you are actually saying is that you have a value in a hexadecimal representation, and you want to represent an equivalent value in binary.

The value of equivalence is an integer. But you may begin with a string, and to view in binary, you must end with a string.

## Convert hex to binary, 42 digits and leading zeros?

We have several direct ways to accomplish this goal, without hacks using slices.

First, before we can do any binary manipulation at all, convert to int (I presume this is in a string format, not as a literal):

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

alternatively we could use an integer literal as expressed in hexadecimal form:

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

Now we need to express our integer in a binary representation.

## Use the builtin function, `format`

Then pass to `format`:

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

This uses the formatting specification’s mini-language.

To break that down, here’s the grammar form of it:

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

To make that into a specification for our needs, we just exclude the things we don’t need:

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

and just pass that to format

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

## String Formatting (Templating) with `str.format`

We can use that in a string using `str.format` method:

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

Or just put the spec directly in the original string:

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

## String Formatting with the new f-strings

Let’s demonstrate the new f-strings. They use the same mini-language formatting rules:

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

Now let’s put this functionality into a function to encourage reusability:

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

And now:

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

## Aside

If you actually just wanted to encode the data as a string of bytes in memory or on disk, you can use the `int.to_bytes` method, which is only available in Python 3:

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

And since 42 bits divided by 8 bits per byte equals 6 bytes:

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

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

``````>>> bin( 0xABC123EFFF )
``````

‘0b1010101111000001001000111110111111111111’

Use Built-in format() function and int() function
It’s simple and easy to understand. It’s little bit simplified version of Aaron answer

int()

``````int(string, base)
``````

format()

``````format(integer, # of bits)
``````

Example

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

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

Here’s a fairly raw way to do it using bit fiddling to generate the binary strings.

The key bit to understand is:

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

Which will generate either a 0 or 1 if the i’th bit of n is set.

``````
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: using the “new” ternary operator this:

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

Would become:

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

(Which TBH I’m not sure how readable that is)

This is a slight touch up to Glen Maynard’s solution, which I think is the right way to do it. It just adds the padding element.

``````
def hextobin(self, hexval):
'''
Takes a string representation of hex data with
arbitrary length and converts to string representation
'''
thelen = len(hexval)*4
binval = bin(int(hexval, 16))[2:]
while ((len(binval)) &lt thelen):
binval="0" + binval
return binval

``````

Pulled it out of a class. Just take out `self, ` if you’re working in a stand-alone script.

I added the calculation for the number of bits to fill to Onedinkenedi’s solution. Here is the resulting function:

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

Where 16 is the base you’re converting from (hexadecimal), and 4 is how many bits you need to represent each digit, or log base 2 of the scale.

Replace each hex digit with the corresponding 4 binary digits:

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

hex –> decimal then decimal –> binary

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

Another way:

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

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

The binary version of ABC123EFFF is actually 1010101111000001001000111110111111111111

For almost all applications you want the binary version to have a length that is a multiple of 4 with leading padding of 0s.

To get this in Python:

``````def hex_to_binary( hex_code ):
bin_code = bin( hex_code )[2:]
``````

Example 1:

``````>>> hex_to_binary( 0xABC123EFFF )
'1010101111000001001000111110111111111111'
``````

Example 2:

``````>>> hex_to_binary( 0x7123 )
'0111000100100011'
``````

Note that this also works in Micropython ðŸ™‚

Just use the module coden (note: I am the author of the module)

You can convert haxedecimal to binary there.

1. Install using pip
``````pip install coden
``````
1. Convert
``````a_hexadecimal_number = "f1ff"
``````

The converting Keywords are:

• bin for binary
• int for decimal
• _to_ – the converting keyword for the function

So you can also format:

`````` def conversion():
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
``````

i have a short snipped hope that helps ðŸ™‚

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

first i use your input and enumerate it to get each symbol. then i convert it to binary and trim from 3th position to the end. The trick to get the 0 is to add the max value of the input -> in this case always 16 ðŸ™‚

the short form ist the join method. Enjoy.

``````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: ')
Integer_output=int(hexa_input,16)
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"""
``````

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

when I time `hex_to_binary("123ade")`

``````  %timeit hex_to_binary("123ade")
``````

here is the result:

`````` 316 ns Â± 2.52 ns per loop
``````

Alternatively, you could use “join” method:

``````def hex_to_binary_join(hex_string):
hex_array=[]
for character in hex_string:
hex_array.append(HEX_TO_BINARY_CONVERSION_TABLE[character])
return "".join(hex_array)
``````

I timed this too:

``````    %timeit hex_to_binary_join("123ade")
397 ns Â± 4.64 ns per loop
``````

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