Custo da função len ()

Qual é o custo da len()função para built-ins do Python? (lista / tupla / string / dicionário)

É O (1) (tempo constante, não dependendo do comprimento real do elemento - muito rápido) em todos os tipos que você mencionou, mais sete outros como array.array.

Chamar len () nesses tipos de dados é O (1) no CPython , a implementação mais comum da linguagem Python. Aqui está um link para uma tabela que fornece a complexidade algorítmica de muitas funções diferentes no CPython:

Página Wiki do TimeComplexity Python

Todos esses objetos mantêm o controle de seu próprio comprimento. O tempo para extrair o comprimento é pequeno (O (1) em notação O-grande) e consiste principalmente em [descrição aproximada, escrita em termos de Python, não em termos de C]: procure "len" em um dicionário e envie-o para o A função built_in len que procurará o __len__método do objeto e chamará isso ... tudo o que precisa fazer éreturn self.length

As medições abaixo fornecem evidências de len()O (1) para estruturas de dados frequentemente usadas.

Uma observação referente a timeit: Quando o -ssinalizador é usado e duas cadeias são passadas para timeita primeira, é executada apenas uma vez e não é cronometrada.

Lista:

$ python -m timeit -s "l = range(10);" "len(l)"
10000000 loops, best of 3: 0.0677 usec per loop

$ python -m timeit -s "l = range(1000000);" "len(l)"
10000000 loops, best of 3: 0.0688 usec per loop

Tupla:

$ python -m timeit -s "t = (1,)*10;" "len(t)"
10000000 loops, best of 3: 0.0712 usec per loop

$ python -m timeit -s "t = (1,)*1000000;" "len(t)"
10000000 loops, best of 3: 0.0699 usec per loop

Corda:

$ python -m timeit -s "s = '1'*10;" "len(s)"
10000000 loops, best of 3: 0.0713 usec per loop

$ python -m timeit -s "s = '1'*1000000;" "len(s)"
10000000 loops, best of 3: 0.0686 usec per loop

Dicionário (compreensão de dicionário disponível em 2.7+):

$ python -mtimeit -s"d = {i:j for i,j in enumerate(range(10))};" "len(d)"
10000000 loops, best of 3: 0.0711 usec per loop

$ python -mtimeit -s"d = {i:j for i,j in enumerate(range(1000000))};" "len(d)"
10000000 loops, best of 3: 0.0727 usec per loop

Matriz:

$ python -mtimeit -s"import array;a=array.array('i',range(10));" "len(a)"
10000000 loops, best of 3: 0.0682 usec per loop

$ python -mtimeit -s"import array;a=array.array('i',range(1000000));" "len(a)"
10000000 loops, best of 3: 0.0753 usec per loop

Conjunto (compreensão do conjunto disponível em 2.7+):

$ python -mtimeit -s"s = {i for i in range(10)};" "len(s)"
10000000 loops, best of 3: 0.0754 usec per loop

$ python -mtimeit -s"s = {i for i in range(1000000)};" "len(s)"
10000000 loops, best of 3: 0.0713 usec per loop

Deque:

$ python -mtimeit -s"from collections import deque;d=deque(range(10));" "len(d)"
100000000 loops, best of 3: 0.0163 usec per loop

$ python -mtimeit -s"from collections import deque;d=deque(range(1000000));" "len(d)"
100000000 loops, best of 3: 0.0163 usec per loop

len é um O (1) porque, na sua RAM, as listas são armazenadas como tabelas (séries de endereços contíguos). Para saber quando a tabela para, o computador precisa de duas coisas: comprimento e ponto de partida. É por isso que len () é O (1), o computador armazena o valor e, portanto, só precisa procurá-lo.

Eu estive pensando em len () em Python depende do tamanho da lista, então eu sempre armazeno o comprimento em uma variável se eu usar várias vezes. Mas hoje, durante a depuração, notei o atributo __len__ no objeto list, então len () deve apenas buscá-lo, o que torna a complexidade O (1). Então, pesquisei no Google se alguém já perguntou e me deparei com este post.