Jak wyjaśnili inni, nie tylko kopiuje referencje, ale także zwiększa liczbę referencji wewnątrz obiektów, a tym samym uzyskuje się dostęp do obiektów, a pamięć podręczna odgrywa rolę.
Tutaj chcę tylko dodać więcej eksperymentów. Nie tyle o shuffled vs unshuffled (gdzie dostęp do jednego elementu może przegapić pamięć podręczną, ale pobierz następujące elementy do pamięci podręcznej, aby zostały trafione). Ale o powtarzających się elementach, gdzie późniejszy dostęp do tego samego elementu może trafić do pamięci podręcznej, ponieważ element nadal znajduje się w pamięci podręcznej.
Testowanie normalnego zakresu:
>>> from timeit import timeit
>>> a = range(10**7)
>>> [timeit(lambda: list(a), number=100) for _ in range(3)]
[5.1915339142808925, 5.1436351868889645, 5.18055115701749]
Lista o tym samym rozmiarze, ale z tylko jednym powtarzanym w kółko elementem, jest szybsza, ponieważ cały czas trafia do pamięci podręcznej:
>>> a = [0] * 10**7
>>> [timeit(lambda: list(a), number=100) for _ in range(3)]
[4.125743135926939, 4.128927210087596, 4.0941229388550795]
I wydaje się, że nie ma znaczenia, jaka to liczba:
>>> a = [1234567] * 10**7
>>> [timeit(lambda: list(a), number=100) for _ in range(3)]
[4.124106479141709, 4.156590225249886, 4.219242600790949]
Co ciekawe, robi się to jeszcze szybciej, gdy zamiast tego powtarzam te same dwa lub cztery elementy:
>>> a = [0, 1] * (10**7 / 2)
>>> [timeit(lambda: list(a), number=100) for _ in range(3)]
[3.130586101607932, 3.1001001764957294, 3.1318465707127814]
>>> a = [0, 1, 2, 3] * (10**7 / 4)
>>> [timeit(lambda: list(a), number=100) for _ in range(3)]
[3.096105435911994, 3.127148431279352, 3.132872673690855]
Myślę, że coś nie lubi tego samego pojedynczego licznika zwiększanego przez cały czas. Może jakieś opóźnienie w rurociągu, ponieważ każdy wzrost musi czekać na wynik poprzedniego wzrostu, ale jest to szalone przypuszczenie.
W każdym razie, próbując tego dla jeszcze większej liczby powtarzających się elementów:
from timeit import timeit
for e in range(26):
n = 2**e
a = range(n) * (2**25 / n)
times = [timeit(lambda: list(a), number=20) for _ in range(3)]
print '%8d ' % n, ' '.join('%.3f' % t for t in times), ' => ', sum(times) / 3
Wynik (pierwsza kolumna to liczba różnych elementów, dla każdego testuję trzy razy, a następnie biorę średnią):
1 2.871 2.828 2.835 => 2.84446732686
2 2.144 2.097 2.157 => 2.13275338734
4 2.129 2.297 2.247 => 2.22436720645
8 2.151 2.174 2.170 => 2.16477771575
16 2.164 2.159 2.167 => 2.16328197911
32 2.102 2.117 2.154 => 2.12437970598
64 2.145 2.133 2.126 => 2.13462250728
128 2.135 2.122 2.137 => 2.13145065221
256 2.136 2.124 2.140 => 2.13336283943
512 2.140 2.188 2.179 => 2.1688431668
1024 2.162 2.158 2.167 => 2.16208440826
2048 2.207 2.176 2.213 => 2.19829998424
4096 2.180 2.196 2.202 => 2.19291917834
8192 2.173 2.215 2.188 => 2.19207065277
16384 2.258 2.232 2.249 => 2.24609975704
32768 2.262 2.251 2.274 => 2.26239771771
65536 2.298 2.264 2.246 => 2.26917420394
131072 2.285 2.266 2.313 => 2.28767871168
262144 2.351 2.333 2.366 => 2.35030805124
524288 2.932 2.816 2.834 => 2.86047313113
1048576 3.312 3.343 3.326 => 3.32721167007
2097152 3.461 3.451 3.547 => 3.48622758473
4194304 3.479 3.503 3.547 => 3.50964316455
8388608 3.733 3.496 3.532 => 3.58716466865
16777216 3.583 3.522 3.569 => 3.55790996695
33554432 3.550 3.556 3.512 => 3.53952594744
Czyli od około 2,8 sekundy dla pojedynczego (powtarzanego) elementu spada do około 2,2 sekundy dla 2, 4, 8, 16, ... różnych elementów i pozostaje na około 2,2 sekundy do setek tysięcy. Myślę, że to używa mojej pamięci podręcznej L2 (4 × 256 KB, mam i7-6700 ).
Następnie po kilku krokach czas dochodzi do 3,5 sekundy. Myślę, że to używa kombinacji mojej pamięci podręcznej L2 i mojej pamięci podręcznej L3 (8 MB), dopóki to również nie zostanie „wyczerpane”.
Pod koniec wydaje mi się, że pozostaje to około 3,5 sekundy, ponieważ moje pamięci podręczne nie pomagają już z powtarzającymi się elementami.