Почему код Python работает быстрее в функции?

def main():
    for i in xrange(10**8):
        pass
main()

Этот фрагмент кода на Python выполняется (Примечание: синхронизация выполняется с помощью функции времени в BASH в Linux.)

real    0m1.841s
user    0m1.828s
sys     0m0.012s

Тем не менее, если цикл не помещается в функцию,

for i in xrange(10**8):
    pass

тогда он работает намного дольше:

real    0m4.543s
user    0m4.524s
sys     0m0.012s

Почему это?

Вы можете спросить, почему хранить локальные переменные быстрее, чем глобальные. Это деталь реализации CPython.

Помните, что CPython компилируется в байт-код, который запускает интерпретатор. Когда функция компилируется, локальные переменные сохраняются в массиве фиксированного размера ( не a dict), а имена переменных присваиваются индексам. Это возможно, потому что вы не можете динамически добавлять локальные переменные в функцию. Затем извлечение локальной переменной - это буквально поиск указателя в списке и увеличение количества ссылок на PyObjectтривиальное.

Сравните это с глобальным поиском ( LOAD_GLOBAL), который является истинным dictпоиском, включающим хэш и так далее. Кстати, именно поэтому вам нужно указать global i, хотите ли вы, чтобы оно было глобальным: если вы когда-либо назначите переменную внутри области видимости, компилятор выдаст STORE_FASTs для ее доступа, если вы не скажете этого не делать.

Кстати, глобальные поиски все еще довольно оптимизированы. Атрибут поиски foo.barявляются действительно медленный !

Вот небольшая иллюстрация эффективности локальной переменной.

Внутри функции байт-код:

  2           0 SETUP_LOOP              20 (to 23)
              3 LOAD_GLOBAL              0 (xrange)
              6 LOAD_CONST               3 (100000000)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                 6 (to 22)
             16 STORE_FAST               0 (i)

  3          19 JUMP_ABSOLUTE           13
        >>   22 POP_BLOCK           
        >>   23 LOAD_CONST               0 (None)
             26 RETURN_VALUE        

На верхнем уровне байт-код:

  1           0 SETUP_LOOP              20 (to 23)
              3 LOAD_NAME                0 (xrange)
              6 LOAD_CONST               3 (100000000)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                 6 (to 22)
             16 STORE_NAME               1 (i)

  2          19 JUMP_ABSOLUTE           13
        >>   22 POP_BLOCK           
        >>   23 LOAD_CONST               2 (None)
             26 RETURN_VALUE        

Разница в том, что STORE_FASTбыстрее (!), Чем STORE_NAME. Это связано с тем, что в функции iона локальная, но на верхнем уровне она глобальная.

Чтобы проверить байт-код, используйте disмодуль . Я был в состоянии разобрать функцию напрямую, но чтобы разобрать код верхнего уровня, мне пришлось использовать compileвстроенный .

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

Как объясняют другие ответы, функция использует STORE_FASTкод операции в цикле. Вот байт-код для цикла функции:

    >>   13 FOR_ITER                 6 (to 22)   # get next value from iterator
         16 STORE_FAST               0 (x)       # set local variable
         19 JUMP_ABSOLUTE           13           # back to FOR_ITER

Обычно при запуске программы Python выполняет каждый код операции один за другим, отслеживая стек и предварительно формируя другие проверки в кадре стека после выполнения каждого кода операции. Предсказание кода операции означает, что в некоторых случаях Python может перейти непосредственно к следующему коду операции, что позволяет избежать некоторых из этих издержек.

В этом случае каждый раз, когда Python видит FOR_ITER(верхнюю часть цикла), он «предсказывает», какой STORE_FASTследующий код операции он должен выполнить. Затем Python просматривает следующий код операции и, если прогноз был верным, он сразу переходит к STORE_FAST. Это приводит к сжатию двух кодов операций в один код операции.

С другой стороны, STORE_NAMEкод операции используется в цикле на глобальном уровне. Python * не * делает подобные прогнозы, когда видит этот код операции. Вместо этого он должен вернуться к началу цикла оценки, что имеет очевидные последствия для скорости выполнения цикла.

Чтобы дать некоторые технические подробности об этой оптимизации, вот цитата из ceval.cфайла («движок» виртуальной машины Python):

Некоторые коды операций имеют тенденцию приходить парами, что позволяет прогнозировать второй код при запуске первого. Например, GET_ITERчасто сопровождается FOR_ITER. И FOR_ITERчасто сопровождаетсяSTORE_FAST или UNPACK_SEQUENCE.

Проверка прогноза стоит одного высокоскоростного теста переменной регистра с константой. Если спаривание было хорошим, то предикатирование собственной внутренней ветви процессора имеет высокую вероятность успеха, что приводит к почти нулевому переходу на следующий код операции. Успешное предсказание спасает путешествие через цикл eval, включая две его непредсказуемые ветви: HAS_ARGтест и случай переключения. В сочетании с внутренним предсказанием ветвления процессора успех PREDICTприводит к тому, что два кода операции запускаются так, как если бы они были одним новым кодом операции с объединенными телами.

Мы можем видеть в исходном коде для FOR_ITERкода операции именно то, где STORE_FASTсделан прогноз для :

case FOR_ITER:                         // the FOR_ITER opcode case
    v = TOP();
    x = (*v->ob_type->tp_iternext)(v); // x is the next value from iterator
    if (x != NULL) {                     
        PUSH(x);                       // put x on top of the stack
        PREDICT(STORE_FAST);           // predict STORE_FAST will follow - success!
        PREDICT(UNPACK_SEQUENCE);      // this and everything below is skipped
        continue;
    }
    // error-checking and more code for when the iterator ends normally                                     

PREDICTФункция расширяется, if (*next_instr == op) goto PRED_##opто есть мы просто перейти к началу прогнозируемого опкода. В этом случае мы прыгаем здесь:

PREDICTED_WITH_ARG(STORE_FAST);
case STORE_FAST:
    v = POP();                     // pop x back off the stack
    SETLOCAL(oparg, v);            // set it as the new local variable
    goto fast_next_opcode;

Теперь установлена ​​локальная переменная, и следующий код операции готов к выполнению. Python продолжает итерацию до конца, каждый раз делая успешный прогноз.

Вики - странице Python имеет больше информации о том , как работает виртуальная машина CPython в.