Представления словаря - это, по сути, их название: представления - это просто окно с ключами и значениями (или элементами) словаря. Вот выдержка из официальной документации для 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
В то время как вид просто показывает вам, что в диктанте. Это не волнует, если это изменилось:
Представление - это просто то, как словарь выглядит сейчас. После удаления запись
.items()
была бы устаревшей и.iteritems()
выкинула бы ошибку.источник
viewitems()
это действительно правильно (items()
правильно дает представление в Python 3 ).Просто прочитав документы, я получаю такое впечатление:
Поэтому я предполагаю, что ключевой вариант использования - это если вы держите словарь и многократно перебираете его ключи / элементы / значения с изменениями между ними. Вы можете просто использовать вместо этого представление, превращаясь
for k, v in mydict.iteritems():
вfor k, v in myview:
. Но если вы просто перебираете словарь один раз, я думаю, что iter-версии все еще предпочтительнее.источник
iteritems()
). Так в чем же смысл этих взглядов? Когда я счастлив иметь их?.values()
, но это включает в себя создание всей копии в виде списка, что может быть дорого. Есть,.itervalues()
но вы не можете использовать их более одного раза, поэтому он не будет работать с каждой функцией. Представления не требуют дорогой копии, но они все же более полезны в качестве отдельного значения, чем итератор. Но они все еще не предназначены для одновременной итерации и модификации (там вы действительно хотите получить копию).Методы вид возвращает список (не копию списка, по сравнению с
.keys()
,.items()
а.values()
), так что это более легкий, но отражает текущее содержимое словаря.Из Python 3.0 - методы dict возвращают представления - почему?
источник
Представления позволяют получить доступ к базовой структуре данных, не копируя ее. Помимо того, что он динамичен, а не создает список, одним из наиболее полезных примеров является
in
тестирование. Скажем, вы хотите проверить, есть ли значение в dict или нет (будь то ключ или значение).Первый вариант - создать список ключей
dict.keys()
, это работает, но, очевидно, потребляет больше памяти. Если диктат очень большой? Это было бы расточительно.С
views
его помощью можно итерацию фактической структуры данных, без промежуточного списка.Давайте использовать примеры. У меня есть диктат с 1000 ключами случайных строк и цифр, и
k
это ключ, который я хочу найтиКак вы можете видеть, повторяющиеся
view
объекты значительно повышают производительность, уменьшая при этом нагрузку на память. Вы должны использовать их, когда вам нужно выполнитьSet
аналогичные операции.Примечание : я работаю на Python 2.7
источник
.keys()
возвращает представление по умолчанию. Может быть, хочу дважды проверить этоk
является ли один из ключей словаряlarge_d
предназначенным для выполненияk in large_d
, в Python, который, вероятно, по существу так же быстр, как использование представления (другими словами,k in large_d.keys()
это не Pythonic и его следует избегать - как естьk in large_d.viewkeys()
).k in large_d
на самом деле значительно быстрее, чемk in large_d.viewkeys()
, так что этого, вероятно, следует избегать, но это имеет смысл дляk in large_d.viewvalues()
.