I was profiling Erlang's lists:reverse Built in Function (BIF) to see how well it scales with the size of the input. More specifically, I tried:

1> X = lists:seq(1, 1000000).
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,
 23,24,25,26,27,28,29|...]

2> timer:tc(lists, reverse, [X]).
{57737,
 [1000000,999999,999998,999997,999996,999995,999994,999993,
  999992,999991,999990,999989,999988,999987,999986,999985,
  999984,999983,999982,999981,999980,999979,999978,999977,
  999976,999975,999974|...]}

3> timer:tc(lists, reverse, [X]).
{46896,
 [1000000,999999,999998,999997,999996,999995,999994,999993,
  999992,999991,999990,999989,999988,999987,999986,999985,
  999984,999983,999982,999981,999980,999979,999978,999977,
  999976,999975,999974|...]}

4> Y = lists:seq(1, 10000000).
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,
 23,24,25,26,27,28,29|...]

5> timer:tc(lists, reverse, [Y]).
{434079,
 [10000000,9999999,9999998,9999997,9999996,9999995,9999994,
  9999993,9999992,9999991,9999990,9999989,9999988,9999987,
  9999986,9999985,9999984,9999983,9999982,9999981,9999980,
  9999979,9999978,9999977,9999976,9999975,9999974|...]}

6> timer:tc(lists, reverse, [Y]).
{214173,
 [10000000,9999999,9999998,9999997,9999996,9999995,9999994,
  9999993,9999992,9999991,9999990,9999989,9999988,9999987,
  9999986,9999985,9999984,9999983,9999982,9999981,9999980,
  9999979,9999978,9999977,9999976,9999975,9999974|...]}

Ok, so far it seems like the reverse BIF scales in approximately linear time with respect to the input (e.g. multiply the size of the input by 10 and the size of time taken also increases by a factor of 10). In pure Erlang that would make sense since we would use something like tail recursion to reverse the list. I guess that even as a BIF implemented in C, the algorithm for reversing seems a list to be the same (maybe because of the way lists are just represented in Erlang?).
Now I wanted to compare this with something another language - perhaps another dynamically typed language that I already use. So I tried a similar thing in Python - taking care to, very explicitly, use actual lists instead of generators which I anticipate would affect the performance of Python positively in this test, giving it an unfair advantage.

import time

ms_conv_factor = 10**6

def profile(func, *args):
    start = time.time()
    func(args)
    end = time.time()
    elapsed_seconds = end - start
    print(elapsed_seconds * ms_conv_factor, flush=True)

x = list([i for i in range(0, 1000000)])
y = list([i for i in range(0, 10000000)])
z = list([i for i in range(0, 100000000)])

def f(m):
    return m[::-1]

def g(m):
    return reversed(m)

if __name__ == "__main__":
    print("All done loading the lists, starting now.", flush=True)
    print("f:")
    profile(f, x)
    profile(f, y)
    print("")
    profile(f, x)
    profile(f, y)
    print("")
    profile(f, z)

    print("")

    print("g:")
    profile(g, x)
    profile(g, y)
    print("")
    profile(g, x)
    profile(g, y)
    print("")
    profile(g, z)

This seems to suggest that after the function has been loaded and run once, the length of the input makes no difference and the reversal times are incredibly fast - in the range of ~0.7µs.
Exact result:

All done loading the lists, starting now.
f:
1.430511474609375
0.7152557373046875

0.7152557373046875
0.2384185791015625

0.476837158203125

g:
1.9073486328125
0.7152557373046875

0.2384185791015625
0.2384185791015625

0.476837158203125

My first, naive, guess was that python might be able to recognize the reverse construct and create something like a reverse iterator and return that (Python can work with references right? Maybe it was using some kind of optimization here). But I don't think that theory makes sense since the original list and the returned list are not the same (changing one shouldn't change the other).
So my question(s) here is(are):

• Is my profiling technique here flawed? Have I written the tests in a way that favor one language over the other?
• What is the difference in implementation of lists and their reversal in Erlang vs Python that make this situation (of Python being WAY faster) possible?

Thanks for your time (in advance).