Format integer as binary string (Python recipe) by Antti Kaihola

ActiveState Code (http://code.activestate.com/recipes/219300/)

If you can use a data table, use octal conversion. If you define a table:

asbits = dict([(v[0], v[1:4]) for v in ['0000', '1001',
              '2010', '3011', '4100', '5101','6110','7111']])

Then

bstr_pos = lambda x: ''.join([asbits[ch] for ch in oct(x)]).lstrip('0')

might do the job. But I don't understand why:

def bstr_pos(x) return ''.join([asbits[ch] for ch in oct(x)]).lstrip('0')

is worse.

Binary with fixed length.

def tobin(x, count=8):
        """
        Integer to binary
        Count is number of bits
        """
        return "".join(map(lambda y:str((x>>y)&1), range(count-1, -1, -1)))

binary to decimal oneliner. Inverse of the previous...

def toDecimal(x):
    return sum(map(lambda z: int(x[z]) and 2**(len(x) - z - 1),
                   range(len(x)-1, -1, -1)))

I like bin() from Python 2.6, but it doesn't exist in Python 2.5. So I use this simple but inefficient replacement:

try:
    if bin(0):
        pass
except NameError, ne:
    bin = lambda x: [lambda x:'-'+bin(0-x),
                     lambda x:'0b0',
                     lambda x:'0b'+'01'[x&1],
                     lambda x:'0b'+bin(x>>1)[2:]+'01'[x&1]
                    ][1+(x>1)+(x>0)-(x<0)](x)

note that the list of lambdas [ ... ] can be replaced by a tuple of lambdas ( ... ) in my example

trying to print more than a few hundred bits at once using the recursive version is likely to exceed the maximum recursion depth. so here's a non-recursive version equivalent to the Python 2.6 bin() which should work all the way back to Python 2.3:

try:
    if bin(0): pass
except NameError, ne:
    def bin(x):
        """
        bin(number) -> string

        Stringifies an int or long in base 2.
        """
        if x < 0: return '-' + bin(-x)
        out = []
        while x > 0:
            out.append('01'[x & 1])
            x >>= 1
        if x == 0: out.append('0')
        try: return '0b' + ''.join(reversed(out))
        except NameError, ne2: out.reverse()
        return '0b' + ''.join(out)

and here's a simplified version of the recursive version:

try:
    if bin(0): pass
except NameError, ne:
    bin = lambda x: (
        lambda: '-' + bin(-x),
        lambda: '0b' + '01'[x & 1],
        lambda: bin(x >> 1) + '01'[x & 1]
        )[1 + (x > 1) - (x < 0)]()

sorry, left one line out of place when reformatting for that post:

def bin(x):
    """
    bin(number) -> string

    Stringifies an int or long in base 2.
    """
    if x < 0: return '-' + bin(-x)
    out = []
    if x == 0: out.append('0')
    while x > 0:
        out.append('01'[x & 1])
        x >>= 1
        pass
    try: return '0b' + ''.join(reversed(out))
    except NameError, ne2: out.reverse()
    return '0b' + ''.join(out)

Here's another one: This one is better than most run time computation based methods, thanks to the efficient dictionary look up in Python: http://code.activestate.com/recipes/576847/