Python's string format method can take a format spec.

>>> "{0:b}".format(37)'100101'

Format spec docs for Python 2

Format spec docs for Python 3

If you're looking forbin() as an equivalent tohex(), it was added in python 2.6.

Example:

>>> bin(10)'0b1010'

I am surprised there is no mention of a nice way to accomplish this using formatting strings that are supported in Python 3.6 and higher. TLDR:

>>> number = 1>>> f'0b{number:08b}''0b00000001'

Longer story

This is functionality of formatting strings available from Python 3.6:

>>> x, y, z = 1, 2, 3>>> f'{x} {y} {2*z}''1 2 6'

You can request binary as well:

>>> f'{z:b}''11'

Specify the width:

>>> f'{z:8b}''      11'

Request zero padding:

f'{z:08b}''00000011'

And add common prefix to signify binary number:

>>> f'0b{z:08b}''0b00000011'

You can also let Python add the prefix for you but I do not like it so much as the version above because you have to take the prefix into width consideration:

>>> f'{z:#010b}''0b00000011'

More info is available in official documentation onFormatted string literals andFormat Specification Mini-Language.

Python actuallydoes have something already built in for this, the ability to do operations such as'{0:b}'.format(42), which will give you the bit pattern (in a string) for42, or101010.

For a more general philosophy, no language or library will give its user baseeverything that they desire. If you're working in an environment that doesn't provide exactly what you need, you should be collecting snippets of code as you develop to ensure you never have to write the same thing twice. Such as, for example, the pseudo-code:

define intToBinString, receiving intVal:    if intVal is equal to zero:        return "0"    set strVal to ""    while intVal is greater than zero:        if intVal is odd:            prefix "1" to strVal        else:            prefix "0" to strVal        divide intVal by two, rounding down    return strVal

which will construct your binary string based on the decimal value. Just keep in mind that's a generic bit of pseudo-code which may not be themost efficient way of doing it though, with the iterations you seem to be proposing, it won't make much difference. It's really just meant as a guideline on how it could be done.

The general idea is to use code from (in order of preference):

• the language or built-in libraries.
• third-party libraries with suitable licenses.
• your own collection.
• something new you need to write (and save in your own collection for later).

If you want a textual representation without the 0b-prefix, you could use this:

get_bin = lambda x: format(x, 'b')print(get_bin(3))>>> '11'print(get_bin(-3))>>> '-11'

When you want a n-bit representation:

get_bin = lambda x, n: format(x, 'b').zfill(n)>>> get_bin(12, 32)'00000000000000000000000000001100'>>> get_bin(-12, 32)'-00000000000000000000000000001100'

Alternatively, if you prefer having a function:

def get_bin(x, n=0):    """    Get the binary representation of x.    Parameters    ----------    x : int    n : int        Minimum number of digits. If x needs less digits in binary, the rest        is filled with zeros.    Returns    -------    str    """    return format(x, 'b').zfill(n)

As a reference:

def toBinary(n):    return ''.join(str(1 & int(n) >> i) for i in range(64)[::-1])

This function can convert a positive integer as large as18446744073709551615, represented as string'1111111111111111111111111111111111111111111111111111111111111111'.

It can be modified to serve a much larger integer, though it may not be as handy as"{0:b}".format() orbin().

This is for python 3 and it keeps the leading zeros !

print(format(0, '08b'))

A simple way to do that is to use string format, see thispage.

>> "{0:b}".format(10)'1010'

And if you want to have a fixed length of the binary string, you can use this:

>> "{0:{fill}8b}".format(10, fill='0')'00001010'

If two's complement is required, then the following line can be used:

'{0:{fill}{width}b}'.format((x + 2**n) % 2**n, fill='0', width=n)

where n is the width of the binary string.

one-liner withlambda:

>>> binary = lambda n: '' if n==0 else binary(n/2) + str(n%2)

test:

>>> binary(5)'101'

EDIT:

but then :(

t1 = time()for i in range(1000000):     binary(i)t2 = time()print(t2 - t1)# 6.57236599922

in compare to

t1 = time()for i in range(1000000):    '{0:b}'.format(i)t2 = time()print(t2 - t1)# 0.68017411232

As the preceding answers mostly used format(),here is an f-string implementation.

integer = 7bit_count = 5print(f'{integer:0{bit_count}b}')

Output:

00111

For convenience here is the python docs link for formatted string literals:https://docs.python.org/3/reference/lexical_analysis.html#f-strings.

Summary of alternatives:

n=42assert  "-101010" == format(-n, 'b')assert  "-101010" == "{0:b}".format(-n)assert  "-101010" == (lambda x: x >= 0 and str(bin(x))[2:] or "-" + str(bin(x))[3:])(-n)assert "0b101010" == bin(n)assert   "101010" == bin(n)[2:]   # But this won't work for negative numbers.

Contributors includeJohn Fouhy,Tung Nguyen,mVChr,Martin Thoma. and Martijn Pieters.

>>> format(123, 'b')'1111011'

For those of us who need to convert signed integers (range -2**(digits-1) to 2**(digits-1)-1) to 2's complement binary strings, this works:

def int2bin(integer, digits):    if integer >= 0:        return bin(integer)[2:].zfill(digits)    else:        return bin(2**digits + integer)[2:]

This produces:

>>> int2bin(10, 8)'00001010'>>> int2bin(-10, 8)'11110110'>>> int2bin(-128, 8)'10000000'>>> int2bin(127, 8)'01111111'

you can do like that :

bin(10)[2:]

or :

f = str(bin(10))c = []c.append("".join(map(int, f[2:])))print c

Using numpy pack/unpackbits, they are your best friends.

Examples-------->>> a = np.array([[2], [7], [23]], dtype=np.uint8)>>> aarray([[ 2],       [ 7],       [23]], dtype=uint8)>>> b = np.unpackbits(a, axis=1)>>> barray([[0, 0, 0, 0, 0, 0, 1, 0],       [0, 0, 0, 0, 0, 1, 1, 1],       [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)

The accepted answer didn't address negative numbers, which I'll cover.In addition to the answers above, you can also just use thebin andhex functions. And in the opposite direction, use binary notation:

>>> bin(37)'0b100101'>>> 0b10010137

But with negative numbers, things get a bit more complicated. The question doesn't specify how you want to handle negative numbers.

Python just adds a negative sign so the result for -37 would be this:

>>> bin(-37)'-0b100101'

In computer/hardware binary data, negative signs don't exist. All we have is 1's and 0's. So if you're reading or producing binary streams of data to be processed by other software/hardware, you need to first know the notation being used.

One notation issign-magnitude notation, where the first bit represents the negative sign, and the rest is the actual value. In that case, -37 would be0b1100101 and 37 would be0b0100101. This looks like what python produces, but just add a 0 or 1 in front for positive / negative numbers.

More common isTwo's complement notation, which seems more complicated and the result is very different from python's string formatting. You can read the details in the link, but with an 8bit signed integer -37 would be0b11011011 and 37 would be0b00100101.

Python has no easy way to produce these binary representations. You can usenumpy to turn Two's complement binary values into python integers:

>>> import numpy as np>>> np.int8(0b11011011)-37>>> np.uint8(0b11011011)219>>> np.uint8(0b00100101)37>>> np.int8(0b00100101)37

But I don't know an easy way to do the opposite with builtin functions. Thebitstring package can help though.

>>> from bitstring import BitArray>>> arr = BitArray(int=-37, length=8)>>> arr.uint219>>> arr.int-37>>> arr.bin'11011011'>>> BitArray(bin='11011011').int-37>>> BitArray(bin='11011011').uint219

Python 3.6 added a new string formatting approach called formatted string literals or “f-strings”.Example:

name = 'Bob'number = 42f"Hello, {name}, your number is {number:>08b}"

Output will be 'Hello, Bob, your number is 00001010!'

A discussion of this question can be found here -Here

Yet another solution with another algorithm, by using bitwise operators.

def int2bin(val):    res=''    while val>0:        res += str(val&1)        val=val>>1     # val=val/2     return res[::-1]   # reverse the string

A faster version without reversing the string.

def int2bin(val):   res=''   while val>0:       res = chr((val&1) + 0x30) + res       val=val>>1       return res

numpy.binary_repr(num, width=None)

Examples from the documentation link above:

>>> np.binary_repr(3)'11'>>> np.binary_repr(-3)'-11'>>> np.binary_repr(3, width=4)'0011'

The two’s complement is returned when the input number is negative and width is specified:

>>> np.binary_repr(-3, width=3)'101'>>> np.binary_repr(-3, width=5)'11101'

n=input()print(bin(n).replace("0b", ""))

def binary(decimal) :    otherBase = ""    while decimal != 0 :        otherBase  =  str(decimal % 2) + otherBase        decimal    //=  2    return otherBaseprint binary(10)

output:

1010

Here is the code I've just implemented. This is not amethod but you can use it as aready-to-use function!

def inttobinary(number):  if number == 0:    return str(0)  result =""  while (number != 0):      remainder = number%2      number = number/2      result += str(remainder)  return result[::-1] # to invert the string

Calculator with all neccessary functions for DEC,BIN,HEX:(made and tested with Python 3.5)

You can change the input test numbers and get the converted ones.

# CONVERTER: DEC / BIN / HEXdef dec2bin(d):    # dec -> bin    b = bin(d)    return bdef dec2hex(d):    # dec -> hex    h = hex(d)    return hdef bin2dec(b):    # bin -> dec    bin_numb="{0:b}".format(b)    d = eval(bin_numb)    return d,bin_numbdef bin2hex(b):    # bin -> hex    h = hex(b)    return hdef hex2dec(h):    # hex -> dec    d = int(h)    return ddef hex2bin(h):    # hex -> bin    b = bin(h)    return b## TESTING NUMBERSnumb_dec = 99numb_bin = 0b0111 numb_hex = 0xFF## CALCULATIONSres_dec2bin = dec2bin(numb_dec)res_dec2hex = dec2hex(numb_dec)res_bin2dec,bin_numb = bin2dec(numb_bin)res_bin2hex = bin2hex(numb_bin)res_hex2dec = hex2dec(numb_hex)res_hex2bin = hex2bin(numb_hex)## PRINTINGprint('------- DECIMAL to BIN / HEX -------\n')print('decimal:',numb_dec,'\nbin:    ',res_dec2bin,'\nhex:    ',res_dec2hex,'\n')print('------- BINARY to DEC / HEX -------\n')print('binary: ',bin_numb,'\ndec:    ',numb_bin,'\nhex:    ',res_bin2hex,'\n')print('----- HEXADECIMAL to BIN / HEX -----\n')print('hexadec:',hex(numb_hex),'\nbin:    ',res_hex2bin,'\ndec:    ',res_hex2dec,'\n')

Unless I'm misunderstanding what you mean by binary string I think the module you are looking for isstruct

Somewhat similar solution

def to_bin(dec):    flag = True    bin_str = ''    while flag:        remainder = dec % 2        quotient = dec / 2        if quotient == 0:            flag = False        bin_str += str(remainder)        dec = quotient    bin_str = bin_str[::-1] # reverse the string    return bin_str

here is simple solution using the divmod() fucntion which returns the reminder and the result of a division without the fraction.

def dectobin(number):    bin = ''    while (number >= 1):        number, rem = divmod(number, 2)        bin = bin + str(rem)    return bin

Here's yet another way using regular math, no loops, only recursion. (Trivial case 0 returns nothing).

def toBin(num):  if num == 0:    return ""  return toBin(num//2) + str(num%2)print ([(toBin(i)) for i in range(10)])['', '1', '10', '11', '100', '101', '110', '111', '1000', '1001']

To calculate binary of numbers:

print("Binary is {0:>08b}".format(16))

To calculate the Hexa decimal of a number:

print("Hexa Decimal is {0:>0x}".format(15))

To Calculate all the binary no till 16::

for i in range(17):   print("{0:>2}: binary is {0:>08b}".format(i))

To calculate Hexa decimal no till 17

 for i in range(17):    print("{0:>2}: Hexa Decimal is {0:>0x}".format(i))##as 2 digit is enogh for hexa decimal representation of a number

try:    while True:        p = ""        a = input()        while a != 0:            l = a % 2            b = a - l            a = b / 2            p = str(l) + p        print(p)except:    print ("write 1 number")

I found a method using matrix operation to convert decimal to binary.

import numpy as npE_mat = np.tile(E,[1,M])M_order = pow(2,(M-1-np.array(range(M)))).Tbindata = np.remainder(np.floor(E_mat /M_order).astype(np.int),2)

Eis input decimal data,M is the binary orders.bindata is output binary data, which is in a format of 1 by M binary matrix.

• python
• binary
• string.format