Hướng dẫn int to binary python

Asked 13 years, 5 months ago

Viewed 1.1m times

Are there any canned Python methods to convert an Integer [or Long] into a binary string in Python?

There are a myriad of dec2bin[] functions out on Google... But I was hoping I could use a built-in function / library.

dreftymac

30.3k26 gold badges115 silver badges177 bronze badges

asked Mar 31, 2009 at 3:04

1

If you're looking for bin[] as an equivalent to hex[], it was added in python 2.6.

Example:

>>> bin[10]
'0b1010'

Akseli Palén

26.2k9 gold badges62 silver badges72 bronze badges

answered Mar 31, 2009 at 3:17

John FouhyJohn Fouhy

39.9k19 gold badges62 silver badges77 bronze badges

5

Python actually does 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] for 42, or 101010.

For a more general philosophy, no language or library will give its user base everything 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 the most 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].

answered Mar 31, 2009 at 3:25

paxdiablopaxdiablo

826k227 gold badges1547 silver badges1915 bronze badges

5

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]

answered Feb 12, 2014 at 15:33

Martin ThomaMartin Thoma

112k148 gold badges568 silver badges873 bronze badges

9

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 on Formatted string literals and Format Specification Mini-Language.

answered Aug 19, 2020 at 10:37

Roman PavelkaRoman Pavelka

3,0041 gold badge9 silver badges26 bronze badges

4

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 as 18446744073709551615, 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[] or bin[].

answered Dec 17, 2013 at 19:39

kctong529kctong529

8488 silver badges10 bronze badges

2

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

print[format[0, '08b']]

answered Nov 13, 2018 at 7:04

grepitgrepit

19.5k6 gold badges98 silver badges79 bronze badges

3

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

>> "{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.

answered Jan 19, 2016 at 21:29

XiangXiang

4014 silver badges4 bronze badges

0

one-liner with lambda:

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

answered Jun 15, 2015 at 2:12

Aziz AltoAziz Alto

17.5k4 gold badges71 silver badges57 bronze badges

2

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

integer = 7
bit_count = 5
print[f'{integer:0{bit_count}b}']

Output:

00111

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

answered Jun 7, 2019 at 20:41

John ForbesJohn Forbes

1,16812 silver badges17 bronze badges

Summary of alternatives:

n=42
assert  "-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 include John Fouhy, Tung Nguyen, mVChr, Martin Thoma. and Martijn Pieters.

1

>>> format[123, 'b']
'1111011'

answered Dec 7, 2018 at 15:17

Sandu UrsuSandu Ursu

1,0811 gold badge16 silver badges26 bronze badges

0

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'

Daniel

3,11313 silver badges33 bronze badges

answered Dec 18, 2018 at 19:32

DeanMDeanM

4,4671 gold badge9 silver badges10 bronze badges

you can do like that :

bin[10][2:]

or :

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

answered Jun 21, 2018 at 22:19

Skiller DzSkiller Dz

87910 silver badges17 bronze badges

1

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

Examples
--------
>>> a = np.array[[[2], [7], [23]], dtype=np.uint8]
>>> a
array[[[ 2],
       [ 7],
       [23]], dtype=uint8]
>>> b = np.unpackbits[a, axis=1]
>>> b
array[[[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]

answered Aug 27, 2015 at 3:39

pitfallpitfall

2,43120 silver badges21 bronze badges

2

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 

answered Oct 18, 2014 at 22:45

Reza AbtinReza Abtin

2053 silver badges7 bronze badges

1

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

>>> bin[37]
'0b100101'
>>> 0b100101
37

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 is sign-magnitude notation, where the first bit represents the negative sign, and the rest is the actual value. In that case, -37 would be 0b1100101 and 37 would be 0b0100101. This looks like what python produces, but just add a 0 or 1 in front for positive / negative numbers.

More common is Two'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 be 0b11011011 and 37 would be 0b00100101.

Python has no easy way to produce these binary representations. You can use numpy 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. The bitstring package can help though.

>>> from bitstring import BitArray
>>> arr = BitArray[int=-37, length=8]
>>> arr.uint
219
>>> arr.int
-37
>>> arr.bin
'11011011'
>>> BitArray[bin='11011011'].int
-37
>>> BitArray[bin='11011011'].uint
219

answered Jun 26, 2020 at 2:49

Dolf AndringaDolf Andringa

1,9031 gold badge19 silver badges34 bronze badges

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

name = 'Bob'
number = 42
f"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

answered Oct 27, 2020 at 13:47

Tim UzlovTim Uzlov

1612 silver badges5 bronze badges

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

answered Mar 31, 2009 at 3:08

Van GaleVan Gale

43.1k9 gold badges68 silver badges80 bronze badges

1

n=input[]
print[bin[n].replace["0b", ""]]

answered Nov 29, 2014 at 12:45

0

def binary[decimal] :
    otherBase = ""
    while decimal != 0 :
        otherBase  =  str[decimal % 2] + otherBase
        decimal    //=  2
    return otherBase

print binary[10]

output:

1010

answered Oct 4, 2014 at 2:07

mukundanmukundan

991 silver badge1 bronze badge

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'

answered Apr 30, 2019 at 9:28

Tom HaleTom Hale

35.2k27 gold badges163 silver badges224 bronze badges

Here is the code I've just implemented. This is not a method but you can use it as a ready-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

answered Mar 15, 2014 at 13:18

quentsquents

1013 silver badges8 bronze badges

0

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 

answered Apr 26, 2014 at 12:42

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

answered Jul 18, 2014 at 14:35

1

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

answered Oct 23, 2015 at 12:53

ergonautergonaut

6,7631 gold badge15 silver badges46 bronze badges

1

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 / HEX

def dec2bin[d]:
    # dec -> bin
    b = bin[d]
    return b

def dec2hex[d]:
    # dec -> hex
    h = hex[d]
    return h

def bin2dec[b]:
    # bin -> dec
    bin_numb="{0:b}".format[b]
    d = eval[bin_numb]
    return d,bin_numb

def bin2hex[b]:
    # bin -> hex
    h = hex[b]
    return h

def hex2dec[h]:
    # hex -> dec
    d = int[h]
    return d

def hex2bin[h]:
    # hex -> bin
    b = bin[h]
    return b


## TESTING NUMBERS
numb_dec = 99
numb_bin = 0b0111 
numb_hex = 0xFF


## CALCULATIONS
res_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]



## PRINTING
print['------- 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']

answered Aug 29, 2017 at 8:11

HKC72HKC72

4621 gold badge8 silver badges18 bronze badges

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

answered Apr 3, 2018 at 16:16

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"]

answered Apr 27, 2017 at 8:53

Advay168Advay168

5486 silver badges9 bronze badges

1

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

import numpy as np
E_mat = np.tile[E,[1,M]]
M_order = pow[2,[M-1-np.array[range[M]]]].T
bindata = 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.

answered May 29, 2018 at 20:22