Pre-Allocated Lists in Python(rednafi.github.io)

  In [4]: length = 10000

  In [5]:   %%timeit
   ...:   #preallocating list
   ...:   pre = [None] \* length
   ...:   for i in range(length):
   ...:       pre[i] = i
   ...: 
  346 µs ± 10.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

  In [6]: %%timeit
   ...: pre = np.empty(length, dtype=int)
   ...: for i in range(length):
   ...:     pre[i] = i
   ...:

  688 µs ± 20.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

  >>> timeit.timeit('''a = [i for i in range(400000)]''', number=10); timeit.timeit('''
  l = [None] * 400000
  for i in range(len(l)):
      l[i] = i
  ''', number=10)
  0.17413130006752908
  0.1694186998065561

  length = 10_000
  def func(i):
    """simplest function"""
    return i


  %%timeit
  #preallocating list
  pre = [None] * length
  for i in range(length):
      pre[i] = i

  %%timeit
  #comprehension
  comp = [i for i in range(length)]

  %%timeit
  #preallocating list with function
  pre_func = [None] * length
  for i in range(length):
      pre_func[i] = func(i)

  %%timeit
  #comprehension with function
  comp_func = [func(i) for i in range(length)]

  %%timeit
  #just appending
  append = []
  for i in range(length):
      append.append(i)

  %%timeit
  #preallocating list with enumerate
  pre = [None] \* length
  for i, v  in enumerate(range(length)):
      pre[i] = v

  %%timeit
  #preallocating list, avoiding enumerate
  pre = [None] * length
  for i, v  in zip(range(length), range(length)): #silly, but pretend the second one is actual data
      pre[i] = v

  I just tried using map with list, and it was the fastest way to call a function, but still slower than all of the ways that didn't call a function.   Again, I'm surprised it was faster than a comprehension, I thought they were effectively the same thing. 

  %%timeit
  #map with range
  map_func = list(map(func, range(length)))