Comentários do Blog

Realmente, você parece estar certo:

Código :

>>> l = [1,2,3,4,5,6]
>>> l1 = []
>>> l1.append(1)
>>> l1.append(2)
>>> l1.append(3)
>>> l1.append(4)
>>> l1.append(5)
>>> l1.append(6)
>>> from sys import getsizeof as size
>>> size(l)
60
>>> size(l1)
68
>>> l
[1, 2, 3, 4, 5, 6]
>>> l1
[1, 2, 3, 4, 5, 6]
>>>

Aparentemente, as listas de Python não são implementadas através de ponteiros. São vetores que o interpretador redimensiona conforme o necessário. Logo, os dados estão em regiões contíguas. Se você criar uma lista vazia e for adicionando ítens e medindo o tamanho dela, verá que é alocado mais espaço do que o necessário. Então, não é de se espantar que o tempo de percorrê-las seja baixo.

Muito bacana...
fiquei mesmo surpreso com o [-1::-1] que pode ser muito mais util até que um .reverse() caso se queira pular 2 e inverter ao mesmo tempo.. bastando um [-1::-2]

[CODE]>>> ver
['a', 'e', 'i', 'o', 'u', 'b', 'c', 'd']
>>> ver[::]
['a', 'e', 'i', 'o', 'u', 'b', 'c', 'd']
>>> ver[1::2]
['e', 'o', 'b', 'd']
>>> ver[1::3]
['e', 'u', 'd']
>>> ver[-1::1]
['d']
>>> ver[-1::-1]
['d', 'c', 'b', 'u', 'o', 'i', 'e', 'a'][/CODE]

E ai PEdroArrthurJEdi,

Suas explicações são sempre incríveis. Eu realmente devia ter abordado dessa forma antes de explicar. Mas o meu post na verdade não foi nem pra esclarecer esse tipo de assunto, mas pra fazer uma comparação entre os tempos de busca e espaço em memória. O que mais me chamou a atenção foi o fato da iteração pela lista não ficar tão atrás da busca do dicionário (quando fazemos menos de 700~800 buscas). Eu pessoalmente achei que em 200 buscas já seria mostrado uma grande diferença.

Em conversas com outros usuários, formulei uma nova forma de busca para as listas, em breve estarei postando aqui!

Obrigado pelo comentário e até a próxima.

obrigado por mais esta aula..

dicas de segurança.... muito importante...

E aí, Magnum, tudo na paz?

Tanto as questões da quantidade de memória e do tempo de busca são relativas a natureza das estruturas.

Uma lista é um encadeamento de valores. Assim, para encontrar um valor numa lista, você tem que percorrê-la do início ao fim, tal qual está no seu código. Em relação ao consumo de memória, as listas precisam apenas do espaço necessário para armazenar os valores e um indicador (ponteiro) para a próxima posição.

Os dicionários podem ser implementados através de diferentes abordagens. A que o Python se utiliza é baseado no conceito de tabelas hash.

Uma função hash mapeia um dado de entrada em um valor numérico único. Uma tabela hash é uma estrutura de dados que se utiliza de funções hash para que a busca de dados seja feita de maneira mais rápida. Para isso, as tabelas hash pré-alocam vetores vazios para que sejam utilizados como espaço de armazenamento para as chaves e os dados. Abaixo vai um exemplo de uma tabela hash.

th[0]: null
th[1]: null
th[2]: null
th[3]: null
th[4]: null

Assim, quando uma chave e valor são adicionados, digamos "asd" valor 10, a chave passa por uma função hash para determinar a posição que será inserida. Digamos que h(x) seja a função e que h("asd") = 3. Ao inserir na nossa tabela, ela ficará:

th[0]: null
th[1]: null
th[2]: null
th[3]: [ ("asd", 10) ]
th[4]: null

Para buscar, basta passar a chave "c" para a função h e verificar se ela está presente na posição h(c). Caso sim, retorna o dado. Caso não, retorna nulo. Ou seja, bem mais rápido do que procurar um por um.

A maior quantidade de memória necessária é relativa a pré-alocação dos vetores, arranjos, lista, ou qualquer outra estrutura, para armazenar os dados e as chaves.

obrigado, por mais esta..

show de bola...

valeu por mais esta aula...