Что такое объекты словарного представления?

В Python 2.7 мы получили доступные методы просмотра словаря .

Теперь я знаю плюсы и минусы следующего:

• dict.items()(и values, keys): возвращает список, так что вы можете сохранить результат, и
• dict.iteritems() (и тому подобное): возвращает генератор, поэтому вы можете перебирать каждое сгенерированное значение одно за другим.

Для чего dict.viewitems()(и тому подобное)? Каковы их преимущества? Как это работает? Что такое вид в конце концов?

Я прочитал, что представление всегда отражает изменения из словаря. Но как это ведет себя с точки зрения перфокарты и памяти? Какие плюсы и минусы?

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

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

>>> 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 "в том, что они не содержат дубликатов).
2. Вы можете хранить их и использовать их несколько раз, как список версий.
3. Поскольку они отражают базовый словарь, любое изменение в словаре изменит представление и почти наверняка изменит порядок итерации . Таким образом, в отличие от списка версий, они не являются "стабильными".
4. Поскольку они отражают основной словарь, они почти наверняка являются небольшими прокси-объектами; Копирование ключей / значений / элементов потребовало бы, чтобы они каким-то образом смотрели исходный словарь и копировали его несколько раз, когда происходят изменения, что было бы абсурдной реализацией. Так что я ожидал бы очень небольшую нагрузку на память, но доступ был бы немного медленнее, чем непосредственно к словарю.

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

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

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

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

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

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

Первый вариант - создать список ключей dict.keys(), это работает, но, очевидно, потребляет больше памяти. Если диктат очень большой? Это было бы расточительно.

С viewsего помощью можно итерацию фактической структуры данных, без промежуточного списка.

Давайте использовать примеры. У меня есть диктат с 1000 ключами случайных строк и цифр, и kэто ключ, который я хочу найти

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?

Как вы можете видеть, повторяющиеся viewобъекты значительно повышают производительность, уменьшая при этом нагрузку на память. Вы должны использовать их, когда вам нужно выполнить Setаналогичные операции.

Примечание : я работаю на Python 2.7