Зачем использовать dict.keys?

Недавно я написал код, который выглядел примерно так:

# dct is a dictionary
if "key" in dct.keys():

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

if "key" in dct:

Это открытие заставило меня задуматься, и я начал запускать некоторые тесты, чтобы увидеть, может ли быть сценарий, когда я должен использовать метод keys словаря. Мой вывод, однако, нет, не существует.

Если мне нужны ключи в списке, я могу сделать:

keys_list = list(dct)

Если я хочу перебирать ключи, я могу сделать:

for key in dct:
    ...

Наконец, если я хочу проверить, находится ли ключ в dct, я могу использовать in, как я уже говорил выше.

Подсчитано, мой вопрос: я что-то упустил? Может ли быть когда-нибудь сценарий, когда я должен использовать метод keys?... или это просто метод останова из более ранней установки Python, который следует игнорировать?

Ответ 1

На Python 3 используйте dct.keys(), чтобы получить объект просмотра словаря, который позволяет выполнять операции только с ключами:

>>> for sharedkey in dct1.keys() & dct2.keys():  # intersection of two dictionaries
...     print(dct1[sharedkey], dct2[sharedkey])

В Python 2 для этого вы должны использовать dct.viewkeys().

В Python 2, dct.keys() возвращает список, копию ключей в словаре. Это может быть передано вокруг отдельного объекта, который можно манипулировать по своему усмотрению, включая удаление элементов, не затрагивающих самого словаря; однако вы можете создать тот же список с list(dct), который работает как в Python 2, так и в 3.

Вы действительно не хотите ни одного из них для тестирования итераций или членства; всегда используйте for key in dct и key in dct для них соответственно.

Ответ 2

Источник: PEP 234, PEP 3106

Python 2 относительно бесполезный метод dict.keys существует по историческим причинам. Первоначально, dicts не были итерируемыми. На самом деле не было такого понятия, как итератор; итерации над последовательностями, обработанных вызовом __getitem__, методом доступа к элементу, с увеличением целочисленных индексов до тех пор, пока не будет поднят IndexError. Чтобы перебрать ключи dict, вам нужно вызвать метод keys, чтобы получить явный список ключей и перебрать их.

Когда итераторы вошли, dicts стал повторяемым, потому что было удобнее, быстрее и все вокруг лучше сказать

for key in d:

чем

for key in d.keys()

Это имело побочный эффект, заключающийся в том, что сделать d.keys() совершенно излишним; list(d) и iter(d) теперь сделали все d.keys() в более чистом, более общем виде. Они не могли избавиться от keys, хотя, так как много кода уже называли его.

(В это время dicts также получил метод __contains__, поэтому вы могли бы сказать key in d вместо d.has_key(key). Это было короче и красиво симметрично с for key in d; симметрия также объясняется тем, почему итерация по dict дает ключи вместо пар (ключ, значение).)

В Python 3, вдохновленном Framework Java Collections Framework, были изменены методы , values и items dicts. Вместо того, чтобы возвращать списки, они возвращают представления оригинального dict. Представления ключей и элементов будут поддерживать операции типа типа, и все представления будут обертки вокруг базового dict, отражающие любые изменения в dict. Это сделало keys полезным снова.

Ответ 3

Предполагая, что вы не используете Python 3, list(dct) эквивалентен dct.keys(). Какой из них вы используете, это вопрос личных предпочтений. Я лично считаю, что dct.keys() немного яснее, но каждому свой.

В любом случае нет сценария, в котором вам "нужно" использовать dct.keys() как таковой.

В Python 3, dct.keys() возвращает "объект представления словаря", поэтому, если вам нужно удержать нематериализованный вид ключей (что может быть полезно для огромных словарей) вне контекста контура for, вам нужно использовать dct.keys().