在 Python 中找到大于或等于 n 的最小 2 次方

Question

在 Python 中返回大于或等于给定非负整数的最小 2 次幂的最简单函数是什么？

例如，大于或等于 6 的 2 的最小次方是 8。

Answer 1

让我们测试一下：

import collections
import math
import timeit

def power_bit_length(x):
    return 2**(x-1).bit_length()

def shift_bit_length(x):
    return 1<<(x-1).bit_length()

def power_log(x):
    return 2**(math.ceil(math.log(x, 2)))

def test(f):
    collections.deque((f(i) for i in range(1, 1000001)), maxlen=0)

def timetest(f):
    print('{}: {}'.format(timeit.timeit(lambda: test(f), number=10),
                          f.__name__))

timetest(power_bit_length)
timetest(shift_bit_length)
timetest(power_log)

我使用range(1, 1000001)而不是range(1000000)的原因是power_log版本将在0上失败。 我在较大范围内使用少量代表而不是在小范围内使用大量代表的原因是因为我预计不同版本在不同领域会有不同的表现。 （如果您希望用巨大的千位数字调用它，当然，您需要一个使用这些数字的测试。）

使用 Apple Python 2.7.2：

4.38817000389: power_bit_length
3.69475698471: shift_bit_length
7.91623902321: power_log

使用 Python.org Python 3.3.0：

6.566169916652143: power_bit_length
3.098236607853323: shift_bit_length
9.982460380066186: power_log

使用 pypy 1.9.0/2.7.2：

2.8580930233: power_bit_length
2.49524712563: shift_bit_length
3.4371240139: power_log

我相信这表明2**是这里缓慢的部分； 使用bit_length而不是log确实可以加快速度，但是使用1<<而不是2**更为重要。

另外，我认为它更清楚。 OP 的版本要求您进行心理上下文切换，从对数切换到位，然后再切换回指数。 要么一直保留在位中 ( shift_bit_length )，要么保留在对数和指数中 ( power_log )。

Answer 2

总是返回2**(x - 1).bit_length()是不正确的，因为虽然它对 x=1 返回 1，但对 x=0 返回非单调的 2。 一个对 x=0 单调安全的简单修复是：

def next_power_of_2(x):  
    return 1 if x == 0 else 2**(x - 1).bit_length()

示例输出：

>>> print(', '.join(f'{x}:{next_power_of_2(x)}' for x in range(10)))
0:1, 1:1, 2:2, 3:4, 4:4, 5:8, 6:8, 7:8, 8:8, 9:16

可以迂腐地争论说 x=0 应该返回 0（而不是 1），因为2**float('-inf') == 0 。

Answer 3

这对你有用吗：

import math

def next_power_of_2(x):
    return 1 if x == 0 else 2**math.ceil(math.log2(x))

请注意， math.log2在 Python 3 中可用，但在 Python 2 中不可用。使用它代替math.log可避免后者在 2**29 及以后出现数值问题。

示例输出：

>>> print(', '.join(f'{x}:{next_power_of_2(x)}' for x in range(10)))
0:1, 1:1, 2:2, 3:4, 4:4, 5:8, 6:8, 7:8, 8:8, 9:16

可以迂腐地争论说 x=0 应该返回 0（而不是 1），因为2**float('-inf') == 0 。

Answer 4

我们可以使用位操作按如下方式执行此操作：

def next_power_of_2(n):
    if n == 0:
        return 1
    if n & (n - 1) == 0:
        return n
    while n & (n - 1) > 0:
        n &= (n - 1)
    return n << 1

示例输出：

>>> print(', '.join(f'{x}:{next_power_of_2(x)}' for x in range(10)))
0:1, 1:1, 2:2, 3:4, 4:4, 5:8, 6:8, 7:8, 8:8, 9:16

如需进一步阅读，请参阅此资源。

Answer 5

嗯，我知道这个问题很老，我的回答也很简单，但我真的很惊讶这么久都没人把它贴在这里，所以我会把它作为答案贴出来。

最简单的解决方案真的很简单，不需要导入任何库，如果你使用while语句，你可以在一个循环中完成！

所以逻辑很简单，创建一个值为1的变量，当变量的值小于number时，将变量乘以2！

代码：

i = 1
while i < n: i *=2

n = 1、63、64、255、256、1000、4095 的返回值：

2, 64, 64, 256, 256, 1024, 4096

这可以很容易地修改以计算下一个到许多其他基地的电力壁橱：

def nextpower(num, base):
  i = 1
  while i < num: i *= base
  return i

Answer 6

v+=(v==0);
v--;
v|=v>>1;
v|=v>>2;
v|=v>>4;
v|=v>>8;
v|=v>>16;
v++;

对于 16 位整数。