Почему подготовка переменной с помощью numpy.zeros работает быстрее, чем добавление внутри цикла?

Question

вопрос возникает здесь: добавление двоичного массива

Используя numpy, чтобы сгенерировать двоичный массив n-ширины для определенного числа:

def int_to_array(n,width):
    v=np.zeros(64,np.uint8)
    i,u,total=0,n,0
    while(u):
      if i%width == 0 : total += width  
      u,v[i],i = u//2,u%2,i+1
    return v[:total][::-1].reshape(-1,width)

В нескольких ответах указывалось, что np.zeros намного быстрее, чем даже [0]*64.

Для того, чтобы обойтись без NumPy:

def int_a(n,width):
    i, u, res = 0, n, [] 
    while u or i%width:
        if not i%width:res.insert(0,[])
        u, i, v = u//2, i+1, u%2
        res[0].insert(0,v)
    return res

может быть list.insert кажется функцией определения скорости, поэтому

def int_b(n,width):
    i, u, res = 0, n, [] 
    while u or i%width:
        if not i%width : res.append([])
        u, i, v = u//2, i+1, u%2
        res[-1].append(v)
    return [r[::-1] for r in res][::-1]

timeit для каждой функции:

>>> timeit.timeit('int_a(295289042101659,6)','from __main__ import int_a', number = 100000)
2.891591438350612
>>> timeit.timeit('int_b(295289042101659,6)','from __main__ import int_b', number = 100000)
2.254217379469006
>>> timeit.timeit('int_to_array(295289042101659,6)','from __main__ import int_to_array', number = 100000)
2.1489055592011823

Мой вопрос:
1. Будет ли импорт numpy.zeros работать быстрее - даже если мне нужно всего лишь несколько повторяющихся функций?

2. Разница произошла от адаптации цикла или индексации памяти?