209

I'm trying to convert an integer to binary using the bin() function in Python. However, it always removes the leading zeros, which I actually need, such that the result is always 8-bit:

Example:

bin(1) -> 0b1

# What I would like:
bin(1) -> 0b00000001

Is there a way of doing this?

martineau
  • 112,593
  • 23
  • 157
  • 280
Niels Sønderbæk
  • 3,239
  • 4
  • 28
  • 43
  • See also: [Python int to binary?](http://stackoverflow.com/q/699866/562769), especially [my answer](http://stackoverflow.com/a/21732313/562769) with the n-bit representation. Not exactly the same, but I came to this question searching my answer... – Martin Thoma Apr 10 '16 at 20:20

10 Answers10

295

Use the format() function:

>>> format(14, '#010b')
'0b00001110'

The format() function simply formats the input following the Format Specification mini language. The # makes the format include the 0b prefix, and the 010 size formats the output to fit in 10 characters width, with 0 padding; 2 characters for the 0b prefix, the other 8 for the binary digits.

This is the most compact and direct option.

If you are putting the result in a larger string, use an formatted string literal (3.6+) or use str.format() and put the second argument for the format() function after the colon of the placeholder {:..}:

>>> value = 14
>>> f'The produced output, in binary, is: {value:#010b}'
'The produced output, in binary, is: 0b00001110'
>>> 'The produced output, in binary, is: {:#010b}'.format(value)
'The produced output, in binary, is: 0b00001110'

As it happens, even for just formatting a single value (so without putting the result in a larger string), using a formatted string literal is faster than using format():

>>> import timeit
>>> timeit.timeit("f_(v, '#010b')", "v = 14; f_ = format")  # use a local for performance
0.40298633499332936
>>> timeit.timeit("f'{v:#010b}'", "v = 14")
0.2850222919951193

But I'd use that only if performance in a tight loop matters, as format(...) communicates the intent better.

If you did not want the 0b prefix, simply drop the # and adjust the length of the field:

>>> format(14, '08b')
'00001110'
Martijn Pieters
  • 963,270
  • 265
  • 3,804
  • 3,187
  • 4
    Exactly what I was looking for, this formatting is really helpful to me. I have started learning bit manipulation and I was googling for bit formatting for numbers in Python. Found this. Thank you. – kratostoical Dec 17 '17 at 13:23
  • Works nice. Can get a bit bulky though. `format(192,'08b')+'.'+format(0,'08b')+'.'+format(2,'08b')+'.'+format(33,'08b')` `11000000.00000000.00000010.00100001` – voices May 11 '19 at 17:34
  • @tjt263: That's why I explicitly state that *If you are putting the result in a larger string, use an formatted string literal (3.6+) or use `str.format()` and put the second argument for the format() function after the colon of the placeholder `{:..}`:* – Martijn Pieters May 11 '19 at 19:32
  • 2
    @tjt263: e.g. use `f"{192:08b}.{0:08b}.{2:08b}.{33:08b}"`. – Martijn Pieters May 11 '19 at 19:33
  • Very nice. I never would have known that's what you meant from explanation alone. But now I've seen your example, I'll probably never forget it. Cheers. – voices May 11 '19 at 20:04
139
>>> '{:08b}'.format(1)
'00000001'

See: Format Specification Mini-Language

Note for Python 2.6 or older, you cannot omit the positional argument identifier before :, so use

>>> '{0:08b}'.format(1)
'00000001'
Josselin
  • 2,393
  • 2
  • 24
  • 33
bwbrowning
  • 5,562
  • 7
  • 30
  • 36
  • 3
    There is no need to use `str.format()` here when `format()` will do. You are missing the `0b` prefix. – Martijn Pieters Jun 04 '13 at 19:55
  • 2
    @MartijnPieters, `str.format` is more flexible than `format()` because it will allow you to do multiple variables at once. I keep forgetting that the `format` function even exists. Admittedly it's perfectly adequate in this case. – Mark Ransom Jun 04 '13 at 22:18
  • 1
    @MarkRansom: Exactly, when you are only using `str.format()` with just one `{}` element, no other text, you are *not* using string templating, you are formatting *one value*. In that case just use `format()`. :-) – Martijn Pieters Jun 04 '13 at 22:19
  • This does not work anymore: print("TCP: Option: Data: {:08b}".format(option_data)) TypeError: unsupported format string passed to tuple.__format__ – wheeler Mar 10 '21 at 03:43
42

I am using

bin(1)[2:].zfill(8)

will print 

'00000001'
rekinyz
  • 6,217
  • 2
  • 27
  • 28
9

You can use the string formatting mini language:

def binary(num, pre='0b', length=8, spacer=0):
    return '{0}{{:{1}>{2}}}'.format(pre, spacer, length).format(bin(num)[2:])

Demo:

print binary(1)

Output:

'0b00000001'

EDIT: based on @Martijn Pieters idea

def binary(num, length=8):
    return format(num, '#0{}b'.format(length + 2))
Peter Varo
  • 11,000
  • 7
  • 50
  • 69
  • 2
    The same formatting language can be used to include the prefix for you. Use `#`. There is also `format()`, which saves you having to do a full string template. – Martijn Pieters Jun 04 '13 at 19:57
9

When using Python >= 3.6, the cleanest way is to use f-strings with string formatting:

>>> var = 23
>>> f"{var:#010b}"
'0b00010111'

Explanation:

  • var the variable to format
  • : everything after this is the format specifier
  • # use the alternative form (adds the 0b prefix)
  • 0 pad with zeros
  • 10 pad to a total length off 10 (this includes the 2 chars for 0b)
  • b use binary representation for the number
ruohola
  • 19,113
  • 6
  • 51
  • 82
  • 1
    No, it is not the cleanest, *not unless you do more with the string than just a single placeholder*. Otherwise `format(var, "#010b")` communicates *intent* much better. It is, however, the fastest option. But you know that already, right, because I already cover *all of what you posted* in my answer. – Martijn Pieters Feb 28 '20 at 02:05
4

I like python f-string formatting for a little more complex things like using a parameter in format:

>>> x = 5
>>> n = 8
>>> print(f"{x:0{n}b}")
00000101

Here I print variable x with following formatting: I want it to be left-filled with 0 to have length = n, in b (binary) format. See Format Specification Mini-Language from previous answers for more.

Rustam A.
  • 695
  • 6
  • 15
3

Sometimes you just want a simple one liner:

binary = ''.join(['{0:08b}'.format(ord(x)) for x in input])

Python 3

Mark
  • 546
  • 8
  • 12
  • 2
    Note that the `[ ]` shouldn't be needed - `join()` accepts a generator expression. `''.join('{0:08b}'.format(ord(x)) for x in input)` – Christoph Burschka Dec 02 '17 at 13:39
  • 2
    @ChristophBurschka note that because `str.join()` needs to make two passes, a generator input is first converted to a list before joining. This takes a bit of a toll on performance and do it’s actually *better* here to pass in a list comprehension rather than a generator expression. It’s one if them exceptions to the rule. – Martijn Pieters Feb 28 '20 at 02:01
-1

You can use something like this 

("{:0%db}"%length).format(num)
Muds
  • 3,886
  • 5
  • 27
  • 47
Adam
  • 7
  • 1
  • 2
    Please at least use code block for your code snippet. And if you really want it to be a good answer, then also add some comments on why this solution is solving OP question. – β.εηοιτ.βε Mar 31 '15 at 16:18
  • You don’t need to use a different string formatting style just to add a variable width. Just add another placeholder: `"{:0{l}b}".format(num, l=length)` – Martijn Pieters Feb 28 '20 at 01:59
-3

You can use zfill:

print str(1).zfill(2) 
print str(10).zfill(2) 
print str(100).zfill(2)

prints:

01
10
100

I like this solution, as it helps not only when outputting the number, but when you need to assign it to a variable... e.g. - x = str(datetime.date.today().month).zfill(2) will return x as '02' for the month of feb.

Anshul Garg
  • 193
  • 1
  • 2
  • 13
  • 1
    problem with zfill is it treats the binary string like a string and adds the zeros before the binary 'b' indicator... eg `bin(14)` gives ` '0b1110' ` and `bin(14).zfill(8)` gives ` '000b1110' ` not ` '0b00001110' ` which is whats desired – Shaun Aug 09 '17 at 20:31
-3

you can use rjust string method of python syntax: string.rjust(length, fillchar) fillchar is optional

and for your Question you acn write like this 

'0b'+ '1'.rjust(8,'0)

so it wil be '0b00000001'

Jaydeep Mahajan
  • 1
  • There is a syntax error. But more importantly, it doesn't answer the question at all, which is about converting an `int` to its textual binary representation; you don't even start with an `int`. – Thierry Lathuille May 30 '20 at 18:13