O que são objetos de exibição de dicionário?

No python 2.7, temos os métodos de visualização de dicionário disponíveis.

Agora, conheço os prós e contras do seguinte:

• dict.items()(e values, keys): retorna uma lista, para que você possa realmente armazenar o resultado e
• dict.iteritems() (e similares): retorna um gerador, para que você possa iterar sobre cada valor gerado um por um.

Para que servem dict.viewitems()(e similares)? Quais são os benefícios deles? Como funciona? Afinal, o que é uma visão?

Eu li que a visualização está sempre refletindo as alterações do dicionário. Mas como se comporta do ponto de vista do desempenho e da memória? Quais são os prós e contras?

As visualizações de dicionário são essencialmente o que seu nome diz: as visualizações são simplesmente como uma janela nas chaves e valores (ou itens) de um dicionário. Aqui está um trecho da documentação oficial do Python 3:

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> keys  # No eggs anymore!
dict_keys(['sausage', 'bacon', 'spam'])

>>> values  # No eggs value (2) anymore!
dict_values([1, 1, 500])

(O equivalente do Python 2 usa dishes.viewkeys()e dishes.viewvalues().)

Este exemplo mostra o caráter dinâmico das visualizações : a visualização de chaves não é uma cópia das chaves em um determinado momento, mas uma janela simples que mostra as chaves; se eles forem alterados, o que você vê através da janela também muda. Esse recurso pode ser útil em algumas circunstâncias (por exemplo, é possível trabalhar com uma exibição nas chaves em várias partes de um programa em vez de recalcular a lista atual de chaves sempre que necessário) - observe que, se as chaves do dicionário forem modificadas ao iterar sobre a exibição, o comportamento do iterador não está bem definido, o que pode levar a erros .

Uma vantagem é que olhar para, digamos, as chaves usa apenas um pequeno e fixo quantidade de memória e requer um pequeno e fixo quantidade de tempo do processador , já que não há criação de uma lista de chaves (Python 2, por outro lado, geralmente cria desnecessariamente uma nova lista, conforme citado por Rajendran T, que leva memória e tempo em uma quantidade proporcional ao comprimento da lista). Para continuar a analogia da janela, se você quiser ver uma paisagem atrás de uma parede, basta fazer uma abertura nela (você constrói uma janela); copiar as chaves em uma lista corresponderia a pintar uma cópia da paisagem na parede - a cópia ocupa tempo, espaço e não se atualiza.

Para resumir, as visualizações são simplesmente ... visualizações (janelas) no seu dicionário, que mostram o conteúdo do dicionário mesmo depois que ele é alterado. Eles oferecem recursos diferentes dos das listas: uma lista de chaves contém uma cópia das chaves do dicionário em um determinado momento, enquanto uma exibição é dinâmica e é muito mais rápida de obter, pois não precisa copiar nenhum dado ( chaves ou valores) para serem criados.

Como você mencionou, dict.items()retorna uma cópia da lista de pares (chave, valor) do dicionário, que é um desperdício e dict.iteritems()retorna um iterador sobre os pares (chave, valor) do dicionário.

Agora, pegue o exemplo a seguir para ver a diferença entre um interator de dict e uma visão de dict

>>> d = {"x":5, "y":3}
>>> iter = d.iteritems()
>>> del d["x"]
>>> for i in iter: print i
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: dictionary changed size during iteration

Considerando que uma visão simplesmente mostra o que está no ditado. Não importa se mudou:

>>> d = {"x":5, "y":3}
>>> v = d.viewitems()
>>> v
dict_items([('y', 3), ('x', 5)])
>>> del d["x"]
>>> v
dict_items([('y', 3)])

Uma visualização é simplesmente a aparência do dicionário agora. Após a exclusão, uma entrada .items()estaria desatualizada e .iteritems()geraria um erro.

Só de ler os documentos, recebo esta impressão:

1. As visualizações são "parecidas com pseudo-conjunto", pois não oferecem suporte à indexação; portanto, o que você pode fazer com elas é testar a associação e iterá-las (porque as chaves são laváveis ​​e exclusivas, as visualizações de chaves e itens são mais " set-like ", pois eles não contêm duplicatas).
2. Você pode armazená-los e usá-los várias vezes, como as versões da lista.
3. Como eles refletem o dicionário subjacente, qualquer alteração no dicionário mudará a exibição e quase certamente mudará a ordem da iteração . Portanto, diferentemente das versões da lista, elas não são "estáveis".
4. Como eles refletem o dicionário subjacente, são quase certamente pequenos objetos proxy; copiar as chaves / valores / itens exigiria que eles assistissem ao dicionário original de alguma forma e o copiassem várias vezes quando ocorrerem mudanças, o que seria uma implementação absurda. Então, eu esperaria muito pouca sobrecarga de memória, mas o acesso seria um pouco mais lento do que diretamente no dicionário.

Então, acho que o principal caso de uso é se você está mantendo um dicionário por perto e repetidamente repetindo suas chaves / itens / valores com modificações no meio. Você poderia apenas usar uma visualização, transformando for k, v in mydict.iteritems():-a for k, v in myview:. Mas se você estiver apenas repetindo o dicionário uma vez, acho que as versões iterativas ainda são preferíveis.

Os métodos de vista retornar uma lista (não uma cópia da lista, em comparação com .keys(), .items()e .values()), por isso é mais leve, mas reflete o conteúdo atual do dicionário.

No Python 3.0 - métodos dict retornam visualizações - por que?

O principal motivo é que, para muitos casos de uso, retornar uma lista completamente desanexada é desnecessário e desperdício. Seria necessário copiar todo o conteúdo (que pode ou não ser muito).

Se você simplesmente deseja iterar sobre as chaves, não será necessário criar uma nova lista. E se você realmente precisar dela como uma lista separada (como uma cópia), poderá facilmente criar essa lista a partir da visualização.

As visualizações permitem acessar a estrutura de dados subjacente, sem copiá-la. Além de dinâmico, em vez de criar uma lista, um dos usos mais úteis é o inteste. Digamos que você queira verificar se um valor está no ditado ou não (seja chave ou valor).

A primeira opção é criar uma lista de chaves usando dict.keys(), isso funciona, mas obviamente consome mais memória. Se o ditado é muito grande? Isso seria um desperdício.

Com viewsvocê pode iterar a estrutura de dados real, sem lista intermediária.

Vamos usar exemplos. Eu tenho um ditado com 1000 teclas de seqüências e dígitos aleatórios e ké a chave que eu quero procurar

large_d = { .. 'NBBDC': '0RMLH', 'E01AS': 'UAZIQ', 'G0SSL': '6117Y', 'LYBZ7': 'VC8JQ' .. }

>>> len(large_d)
1000

# this is one option; It creates the keys() list every time, it's here just for the example
timeit.timeit('k in large_d.keys()', setup='from __main__ import large_d, k', number=1000000)
13.748743600954867


# now let's create the list first; only then check for containment
>>> list_keys = large_d.keys()
>>> timeit.timeit('k in list_keys', setup='from __main__ import large_d, k, list_keys', number=1000000)
8.874809793833492


# this saves us ~5 seconds. Great!
# let's try the views now
>>> timeit.timeit('k in large_d.viewkeys()', setup='from __main__ import large_d, k', number=1000000)
0.08828549011070663

# How about saving another 8.5 seconds?

Como você pode ver, o viewobjeto de iteração dá um enorme impulso ao desempenho, reduzindo a sobrecarga de memória ao mesmo tempo. Você deve usá-los quando precisar executar Setoperações semelhantes.

Nota : Estou executando no Python 2.7