"языковой агностик" и беспокойство о производительности в значительной степени несовместимы.

большинство современных процессоров имеют инструкцию CLZ, "подсчет ведущих нулей". В GCC вы можете добраться до него с __builtin_clz(x) (который также производит разумный, если не самый быстрый, код для целей, которым не хватает clz). Обратите внимание, что эта CLZ не определена для нуля, поэтому вам понадобится дополнительная ветвь, чтобы поймать этот случай, если это имеет значение в вашем приложении.

в КЕЛЬТЕ ( http://celt-codec.org) CLZ без ветвей, который мы используем для комплиеров, не имеющих CLZ, был написан Тимоти Б. Терриберри:

int ilog(uint32 _v){
  int ret;
  int m;
  ret=!!_v;
  m=!!(_v&0xFFFF0000)<<4;
  _v>>=m;
  ret|=m;
  m=!!(_v&0xFF00)<<3;
  _v>>=m;
  ret|=m;
  m=!!(_v&0xF0)<<2;
  _v>>=m;
  ret|=m;
  m=!!(_v&0xC)<<1;
  _v>>=m;
  ret|=m;
  ret+=!!(_v&0x2);
  return ret;
}

(комментарии указывают, что это было обнаружено быстрее, чем ветвящаяся версия и версия на основе таблицы поиска)

но если производительность настолько важна, вы, вероятно, не должны реализовывать эту часть своего кода в python.

есть страница с большим количеством этих типов трюков и хаков. Это написано для C, но многие из них также должны работать на Python (хотя производительность, очевидно, будет отличаться). Бит, который вы хотите, это здесь и далее.

можно попробовать этой например:

register unsigned int r = 0; // result of log2(v) will go here
for (i = 4; i >= 0; i--) // unroll for speed...
{
  if (v & b[i])
  {
    v >>= S[i];
    r |= S[i];
  } 
}

похоже, что он может быть преобразован в Python довольно легко.

вы можете сделать это за O (lg s) время для целых чисел произвольной длины, используя binsearch.

import sys
def floorlg(n):
    if n < 1:
        return -1
    low=0
    high=sys.getsizeof(n)*8 # not the best upper-bound guesstimate, but...
    while True:
        mid = (low+high)//2
        i = n >> mid
        if i == 1:
            return mid
        if i == 0:
            high = mid-1
        else:
            low = mid+1

для целых чисел фиксированного размера таблица поиска должна быть самым быстрым решением и, вероятно, лучшим в целом.

кажется, что диапазон известен. Предположим, что он поднимается до 1

max_log2=20

поэтому составьте список, который (по сути) отображает целое число в его логарифм базы 2. Следующее сделает трюк:

log2s_table=[0]*((1<<max_log2)+1)
for i in range(max_log2+1):
    log2s_table[1<<i]=i

(это не делает ничего полезного для чисел, которые не являются степенями двух; постановка проблемы предполагает, что их не нужно обрабатывать. Это было бы достаточно легко исправить.)

функция для того чтобы получить логарифм очень прост и может быть легко встроен:

def table(v):
    return log2s_table[v]

я не могу гарантировать, что тестовый код, который я написал, точно такой же, как тот, который используется для получения таймингов примера, но это гораздо быстрее, чем stringcount код:

stringcount: 0.43 s.
table: 0.16 s.

поскольку все значения в таблице меньше 256, я задавался вопросом, будет ли использование строки вместо списка быстрее или, возможно,array.array байтов, но не кости:

string: 0.25 s.
arr: 0.21 s.

С помощью dict сделать поиск является еще одной возможностью, воспользовавшись тем, как проверяются только полномочия двух:

log2s_map=dict([(1<<x,x) for x in range(max_log2+1)])

def map(v):
    return log2s_map[v]

результаты для этого были не так хороши, хотя:

map: 0.20 s.

и просто для удовольствия можно также использовать hex метод на float-объектах, чтобы получить строку, которая включает (в качестве последней части) базовый показатель 2 числа. Это немного медленное извлечение в целом, но если показатель будет только одной цифрой, это можно сделать прямолинейно достаточно:

def floathex(v):
    return ord(float(v).hex()[-1])-48

это чисто хоть для развлечения, как это было uncompetetive-хотя, удивительно, еще быстрее, чем подход побитовые.

таким образом, похоже, что использование списка-это путь.

(этот подход не будет масштабироваться бесконечно, из-за ограниченной памяти, но компенсировать это скорость выполнения не будет зависеть от max_log2 или входные значения, любым способом, который вы заметите при запуске кода python. Относительно памяти потребление, если я правильно помню свои внутренности python, таблица займет около (1<<max_log2)*4 байт, потому что содержимое-это все малые целые числа, которые интерпретатор будет интернировать автоматически. Итак, когда max_log2 это 20, это около 4 МБ.)

это фактически комментарий к тесту производительности, опубликованному mac. Я отправляю это как ответ, чтобы иметь правильное форматирование кода и отступов

mac, не могли бы вы попробовать развернутую реализацию bitseach, предложенную Марком Байерсом? Может быть, это просто доступ к массиву, который замедляет его. Теоретически этот подход должен быть быстрее других.

это будет выглядеть примерно так, хотя я не уверен, подходит ли форматирование для python, но я думаю, вы можете видеть, что он должен делать.

def bitwise(v):
    r = 0;
    if( v > 0xffff ) : v >>= 16; r = 16;
    if( v > 0x00ff ) : v >>=  8; r += 8;
    if( v > 0x000f ) : v >>=  4; r += 4;
    if( v > 0x0003 ) : v >>=  2; r += 2;
    return r + ( v >> 1 );

Если Python акций, отсутствие в Java из unsingned чисел он должен быть что-то вроде этого:

def bitwise(v):
    r = 0;
    if( v & 0xffff0000 ) : v >>>= 16; r = 16;
    if( v > 0x00ff ) : v >>=  8; r += 8;
    if( v > 0x000f ) : v >>=  4; r += 4;
    if( v > 0x0003 ) : v >>=  2; r += 2;
    return r + ( v >> 1 );