Сколько циклов процессора занимает одно добавление?

Вы синхронизируете вызов функции (test()), цикл for и вызов range(). Добавление не рассчитано по времени.

def test(n):
    for i in range(n):
        1 + 1

import dis
dis.dis(test)

Вот байтовый код для вашей тестовой функции (не включает вызов test()):

  2           0 SETUP_LOOP              24 (to 27)
              3 LOAD_GLOBAL              0 (range)
              6 LOAD_FAST                0 (n)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                10 (to 26)
             16 STORE_FAST               1 (i)

  3          19 LOAD_CONST               2 (2)   **** 
             22 POP_TOP             
             23 JUMP_ABSOLUTE           13
        >>   26 POP_BLOCK           
        >>   27 LOAD_CONST               0 (None)
             30 RETURN_VALUE        

**** Обратите внимание, добавление выполняется во время компиляции. Довольно много других языков и их компиляторов будут делать это, включая C. Однако стандарты редко определяют, когда на самом деле выполняется 1 + 1, поэтому это часто зависит от реализации.

ИЗМЕНИТЬ:

Ваш вызов функции timeit может быть таким:

    t = timeit("x += 1", setup="x = 1", number=100000)

Мы можем создать фиктивную функцию для проверки операции:

def myfunc(x):
    x += 1

import dis
dis.dis(myfunc)

Внесение этого изменения дает:

1 additions takes 0.008976
2 additions takes 0.007419
4 additions takes 0.007282
8 additions takes 0.007693
16 additions takes 0.007026
32 additions takes 0.007793
64 additions takes 0.010168
128 additions takes 0.008124
256 additions takes 0.009064
512 additions takes 0.007256
1 addition takes -0.001557
1 addition takes -0.000068
1 addition takes 0.000103
1 addition takes -0.000083
1 addition takes 0.000048
1 addition takes 0.000074
1 addition takes -0.000032
1 addition takes 0.000007

 26           0 LOAD_FAST                0 (x)
              3 LOAD_CONST               1 (1)
              6 INPLACE_ADD
              7 STORE_FAST               0 (x)
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE

Обратите внимание, что x += 1 — это INPLACE_ADD, в отличие от x = x + 1, который является BINARY_ADD. Поэтому вам нужно решить, какой OPCode вы хотите измерить.

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

В частности, функция dis.dis берет фрагмент скомпилированного кода Python и возвращает байтовый код, как этот фрагмент интерпретируется. В случае 1 + 1:

In [1]: import dis

In [2]: def add1and1():
    return 1 + 1

In [3]: dis.dis(add1and1)
  2           0 LOAD_CONST               2 (2)
              3 RETURN_VALUE 

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

In [1]: import dis

In [2]: def add(x, y):
    return x + y

In [3]: dis.dis(add)
      2           0 LOAD_FAST                0 (x)
              3 LOAD_FAST                1 (y)
              6 BINARY_ADD          
              7 RETURN_VALUE          

Таким образом, инструкция байт-кода, которая вас действительно интересует, это BINARY_ADD. Если вы хотите узнать об этом больше, вы можете найти соответствующий раздел в файле ceval.c интерпретатора CPython (здесь):

TARGET(BINARY_ADD) {
    PyObject *right = POP();
    PyObject *left = TOP();
    PyObject *sum;
    if (PyUnicode_CheckExact(left) &&
             PyUnicode_CheckExact(right)) {
        sum = unicode_concatenate(left, right, f, next_instr);
        /* unicode_concatenate consumed the ref to v */
    }
    else {
        sum = PyNumber_Add(left, right);
        Py_DECREF(left);
    }
    Py_DECREF(right);
    SET_TOP(sum);
    if (sum == NULL)
        goto error;
    DISPATCH();
}

Так что здесь происходит больше, чем вы могли изначально ожидать. У нас есть:

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

2. фактический вызов PyNumber_Add там, где можно было ожидать чего-то большего, вроде left + right

Оба эти момента объясняются динамической природой Python; поскольку Python не знает тип x или y до тех пор, пока вы не вызовете add, проверка типа выполняется во время выполнения, а не во время компиляции. Чтобы обойти это, в динамических языках можно провести разумную оптимизацию (см. V8 для JavaScript или PyPy для Python), но, вообще говоря, это цена, которую вы платите за гибкость интерпретируемого языка с динамической типизацией.