Cross-version portability in Python

Question

This question offers two approaches to computing bit length of an int:

All versions: len(bin(x))-2
2.7+: x.bit_length()

I need my code to work with 2.6+, so I cannot use the second solution.

Is this the best I can do?

import sys
if sys.hexversion < 0x02070000
    def bitlen(x): return len(bin(x))-2
else:
    def bitlen(x): return x.bit_length()

The alternative is

try: 
    (1).bit_length()
    def bitlen(x): return x.bit_length()
except AttributeError:
    def bitlen(x): return len(bin(x))-2

jonrsharpe · Accepted Answer · 2015-03-18T16:55:48.017

1

I would probably write it as:

def bitlen(x): 
    """The bit length of the integer x."""
    try:
        return x.bit_length()
    except AttributeError:  # I guess!
        return len(bit(x)) - 2

This removes the need for an explicit version check. If you want to factor the check out of the function, perhaps:

if hasattr(1, 'bit_length'):
    bitlen = lambda x: x.bit_length()
else:
    bitlen = lambda x: len(bit(x)) - 2

edited Mar 18 '15 at 16:55

answered Mar 18 '15 at 16:48

jonrsharpe

115,751
26
228
437

1

the problem with this approach is that the check is done on each invocation – sds Mar 18 '15 at 16:49
1

@sds *is* that a problem? – jonrsharpe Mar 18 '15 at 16:50
this is definitely an aesthetic problem for me; it could also be a performance issue. – sds Mar 18 '15 at 16:53
@sds updated with an alternative; testing with `timeit` suggests that the `bit_length` version is faster, so I'd go with that where possible. – jonrsharpe Mar 18 '15 at 16:56
thanks, any reason to use `lambda` instead of `def` (IOW, is there a problem with non-top-level `def`?) – sds Mar 18 '15 at 16:57
@sds just an aesthetic objection to the one-line `def` form; I would either use a `lambda` or spread the function over two lines. – jonrsharpe Mar 18 '15 at 16:58

score 0 · Answer 2 · answered Mar 18 '15 at 17:07

0

This would work on 2.6 and below as well as above.

def bitlen(int_type):
    length = 0
    while (int_type):
        int_type >>= 1
        length += 1
    return(length)
# and then
bitlen(0b10000) # --> 5

Check out, https://wiki.python.org/moin/BitManipulation, for further reading

answered Mar 18 '15 at 17:07

George Padolsey

13
9

Although portable, this is pretty slow; it takes four times as long as the `len` version and seven times as long as using `bit_length`. – jonrsharpe Mar 18 '15 at 17:10
Yes, though I thought to add it in just for plain portablitity :) – George Padolsey Mar 18 '15 at 17:11

Cross-version portability in Python

2 Answers2