Что представляют собой объекты просмотра словаря Python?

Словарные представления – это, по сути, то, что говорит их имя: представления – это просто окно на клавишах и значениях (или элементах) словаря. Вот выдержка из официальной документации для 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]) 

(В эквиваленте Python 2 используются dishes.viewkeys() и dishes.viewvalues() .)

В этом примере показан динамический характер представлений : представление ключей не является копией ключей в данный момент времени, а просто простым окном, которое показывает вам ключи; если они изменены, то то, что вы видите через окно, тоже меняется. Эта функция может быть полезна в некоторых случаях (например, можно работать с представлением ключей в нескольких частях программы, а не пересчитывать текущий список ключей каждый раз, когда они необходимы).

Одно из преимуществ заключается в том, что, глядя на, скажем, клавиши используют только небольшой и фиксированный объем памяти и требуют небольшого и фиксированного количества процессорного времени , поскольку нет создания списка ключей (Python 2, с другой стороны, часто излишне создает новый список, который цитируется Rajendran T, который занимает память и время в размере, пропорциональном длине списка). Чтобы продолжить аналогию с окном, если вы хотите увидеть пейзаж за стеной, вы просто открываете его (вы строите окно); копирование ключей в список соответствовало бы, вместо того, чтобы покрасить копию ландшафта на стене – копия занимает время, пространство и не обновляется сама.

Подводя итог, виды – это просто … виды (окна) на вашем словаре, которые показывают содержание словаря даже после его изменения. Они предлагают функции, которые отличаются от списков: список ключей содержит копию ключей словаря в данный момент времени, в то время как представление является динамическим и намного быстрее получать, поскольку ему не нужно копировать какие-либо данные ( ключи или значения) для создания.

Как вы упомянули, dict.items() возвращает копию списка dict.items() ключ, значение) словаря, который является расточительным, и dict.iteritems() возвращает итератор по парам словаря (ключ, значение).

Теперь рассмотрим следующий пример, чтобы увидеть разницу между интерпретатором dict и взглядом 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 

В то время как представление просто показывает вам, что находится в dict. Его не волнует, если оно изменилось:

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

Представление – это просто то, что теперь выглядит в словаре. После удаления записи .items() было бы устаревшим, а .iteritems() вызвало бы ошибку.

Просто прочитав документы, я получаю такое впечатление:

1. Представления «псевдо-set-like» в том смысле, что они не поддерживают индексирование, поэтому вы можете сделать с ними тест для членства и перебора по ним (поскольку ключи являются хешируемыми и уникальными, представления ключей и элементов больше « set-like ", поскольку они не содержат дубликатов).
2. Вы можете хранить их и использовать их несколько раз, например, версии списка.
3. Поскольку они отражают основной словарь, любое изменение в словаре изменит представление и почти наверняка изменит порядок итерации . Поэтому, в отличие от версий списка, они не «стабильны».
4. Поскольку они отражают базовый словарь, они почти наверняка представляют собой небольшие прокси-объекты; копирование ключей / значений / элементов потребует, чтобы они как-то смотрели оригинальный словарь и копировали его несколько раз, когда происходят изменения, что было бы абсурдной реализацией. Поэтому я ожидал бы очень небольших издержек памяти, но доступ был бы немного медленнее, чем непосредственно в словаре.

Поэтому я предполагаю, что ключевое слово usecase – это если вы держите словарь вокруг и многократно повторяете его ключи / элементы / значения с изменениями между ними. Вместо этого вы можете просто использовать представление, поворачивая for k, v in mydict.iteritems(): в for k, v in myview: Но если вы просто повторяете словарь, я думаю, что итерационные версии предпочтительнее.

Методы представления возвращают список (а не копию списка по сравнению с .keys() , .items() и .values() ), поэтому он более легкий, но отражает текущее содержимое словаря.

Из Python 3.0 – методы dict возвращают представления – почему?

Основная причина заключается в том, что для многих случаев использования возврат полностью отстраненного списка является ненужным и расточительным. Это потребует копирования всего содержимого (что может или многие не будут много).

Если вы просто хотите итерации по клавишам, то создание нового списка не требуется. И если вам действительно нужно это как отдельный список (в виде копии), вы можете легко создать этот список из представления.