Por que o máximo é mais lento do que a classificação?

Descobri que maxé mais lento do que a sortfunção em Python 2 e 3.

Python 2

$ python -m timeit -s 'import random;a=range(10000);random.shuffle(a)' 'a.sort();a[-1]'
1000 loops, best of 3: 239 usec per loop
$ python -m timeit -s 'import random;a=range(10000);random.shuffle(a)' 'max(a)'        
1000 loops, best of 3: 342 usec per loop

Python 3

$ python3 -m timeit -s 'import random;a=list(range(10000));random.shuffle(a)' 'a.sort();a[-1]'
1000 loops, best of 3: 252 usec per loop
$ python3 -m timeit -s 'import random;a=list(range(10000));random.shuffle(a)' 'max(a)'
1000 loops, best of 3: 371 usec per loop

Por que é max ( O(n)) mais lento do que o sortfunction ( O(nlogn))?

Você deve ter muito cuidado ao usar o timeitmódulo em Python.

python -m timeit -s 'import random;a=range(10000);random.shuffle(a)' 'a.sort();a[-1]'

Aqui, o código de inicialização é executado uma vez para produzir uma matriz aleatória a. Em seguida, o resto do código é executado várias vezes. Na primeira vez, ele classifica a matriz, mas a cada duas vezes você chama o método de classificação em uma matriz já classificada. Apenas o tempo mais rápido é retornado, então você está realmente cronometrando quanto tempo leva para o Python classificar um array já classificado.

Parte do algoritmo de classificação do Python é detectar quando o array já está parcial ou completamente classificado. Quando completamente classificado, ele simplesmente tem que fazer uma varredura no array para detectar isso e então para.

Se em vez disso você tentou:

python -m timeit -s 'import random;a=range(100000);random.shuffle(a)' 'sorted(a)[-1]'

então a classificação acontece em cada loop de tempo e você pode ver que o tempo para classificar uma matriz é de fato muito mais longo do que apenas encontrar o valor máximo.

Edit: a resposta de @ skyking explica a parte que deixei sem explicação: a.sort()sabe que está trabalhando em uma lista, então pode acessar diretamente os elementos. max(a)funciona em qualquer iterável arbitrário, portanto, precisa usar a iteração genérica.

Em primeiro lugar, observe que max()usa o protocolo iterador , enquanto list.sort()usa código ad-hoc . Claramente, usar um iterador é uma sobrecarga importante, é por isso que você está observando essa diferença nos tempos.

No entanto, além disso, seus testes não são justos. Você está concorrendo a.sort()na mesma lista mais de uma vez. O algoritmo usado pelo Python é projetado especificamente para ser rápido para dados já (parcialmente) classificados. Seus testes estão dizendo que o algoritmo está fazendo seu trabalho bem.

Estes são testes controlados:

$ python3 -m timeit -s 'import random;a=list(range(10000));random.shuffle(a)' 'max(a[:])'
1000 loops, best of 3: 227 usec per loop
$ python3 -m timeit -s 'import random;a=list(range(10000));random.shuffle(a)' 'a[:].sort()'
100 loops, best of 3: 2.28 msec per loop

Aqui estou sempre criando uma cópia da lista. Como você pode ver, a ordem de magnitude dos resultados é diferente: microssegundos vs milissegundos, como seria de se esperar.

E lembre-se: big-Oh especifica um limite superior! O limite inferior para o algoritmo de classificação do Python é Ω ( n ). Ser O ( n log n ) não implica automaticamente que cada execução leva um tempo proporcional a n log n . Nem mesmo implica que precisa ser mais lento do que um algoritmo O ( n ), mas isso é outra história. O que é importante entender é que, em alguns casos favoráveis, um algoritmo O ( n log n ) pode ser executado em tempo O ( n ) ou menos.

Isto poderia ser porque l.sorté um membro da listenquanto maxé uma função genérica. Isso significa que l.sortpode contar com a representação interna de listwhile maxterá que passar por protocolo iterador genérico.

Isso faz com que a busca de cada elemento l.sortseja mais rápida do que a busca de cada elemento max.

Presumo que, se você usar sorted(a), obterá o resultado mais lento do que max(a).