`if key in dict` проти` try / Osim` - яка читабельніша ідіома?

У мене питання про ідіоми та читабельність, і, здається, у цьому конкретному випадку існує сутичка філософії Python:

Я хочу побудувати словник A зі словника B. Якщо певний ключ не існує в B, тоді нічого не робіть і продовжуйте далі.

Який шлях кращий?

try:
    A["blah"] = B["blah"]
except KeyError:
    pass

або

if "blah" in B:
    A["blah"] = B["blah"]

"Зробити і попросити прощення" проти "простоти та явності".

Що краще і чому?

Винятки не є умовними.

Умовна версія зрозуміліша. Це природно: це прямолінійне регулювання потоку, для чого розроблені умовні роботи, а не винятки.

Версія винятку в основному використовується як оптимізація при виконанні цих пошуків у циклі: для деяких алгоритмів це дозволяє виключити тести з внутрішніх циклів. Тут він не має такої вигоди. Вона має ту невелику перевагу, що дозволяє уникнути необхідності повторювати "blah"двічі, але якщо ви робите багато з них, ви, мабуть, move_keyвсе одно маєте допоміжну функцію.

Загалом, я настійно рекомендую дотримуватися умовної версії за замовчуванням, якщо у вас немає конкретної причини цього не робити. Звичайні способи - це очевидний спосіб зробити це, що зазвичай є настійною рекомендацією віддавати перевагу одному рішенню перед іншим.

Існує також третій спосіб, який дозволяє уникнути як винятків, так і подвійного пошуку, що може бути важливим, якщо пошук дорогий:

value = B.get("blah", None)
if value is not None: 
    A["blah"] = value

Якщо ви очікуєте, що словник міститиме Noneзначення, ви можете використати ще езотеричні константи, наприклад NotImplemented, Ellipsisабо створити нову:

MyConst = object()
def update_key(A, B, key):
    value = B.get(key, MyConst)
    if value is not MyConst: 
        A[key] = value

У будь-якому випадку, використання update()є для мене найбільш читабельним варіантом:

a.update((k, b[k]) for k in ("foo", "bar", "blah") if k in b)

З мого розуміння, ви хочете оновити dict A ключовими парами значень з dict B

update є кращим вибором.

A.update(B)

Приклад:

>>> A = {'a':1, 'b': 2, 'c':3}
>>> B = {'d': 2, 'b':5, 'c': 4}
>>> A.update(B)
>>> A
{'a': 1, 'c': 4, 'b': 5, 'd': 2}
>>> 

Пряма цитата з вікі продуктивності Python:

За винятком вперше, кожного разу, коли слово бачиться, якщо тест тесту не вдається. Якщо ви рахуєте велику кількість слів, багато з них, ймовірно, траплятимуться кілька разів. У ситуації, коли ініціалізація значення відбуватиметься лише один раз, а збільшення цього значення відбуватиметься багато разів, дешевше використовувати оператор try.

Отже, здається, що обидва варіанти життєздатні залежно від ситуації. Щоб отримати докладнішу інформацію, ви можете переглянути це посилання: Спробуй-крім-продуктивності

Я думаю, загальне правило тут, як A["blah"]правило, буде існувати, якщо так, спробуйте, за винятком, це добре, якщо ні, то використовуйтеif "blah" in b:

Я думаю, що "спробувати" дешево в часі, але "крім" дорожче.

Я думаю, другий приклад - це те, на що вам слід піти, якщо цей код не має сенсу:

try:
    A["foo"] = B["foo"]
    A["bar"] = B["bar"]
    A["baz"] = B["baz"]
except KeyError:
    pass

Майте на увазі, що код перерветься, як тільки з’явиться ключ, якого немає B. Якщо цей код має сенс, то вам слід скористатися методом винятку, інакше - методом тесту. На мій погляд, оскільки він коротший і чітко виражає намір, його набагато легше читати, ніж метод винятку.

Звичайно, люди, які кажуть вам використовувати, updateє правильними. Якщо ви використовуєте версію Python, яка підтримує розуміння словника, я б настійно віддав перевагу такому коду:

updateset = {'foo', 'bar', 'baz'}
A.update({k: B[k] for k in updateset if k in B})

Правилом інших мов є резервування винятків для виняткових умов, тобто помилок, які не трапляються під час регулярного використання. Не знаю, як це правило застосовується до Python, оскільки StopIteration не повинно існувати за цим правилом.

Особисто я схиляюся до другого методу (але з використанням has_key):

if B.has_key("blah"):
  A["blah"] = B["blah"]

Таким чином, кожна операція присвоєння складає лише два рядки (замість 4 із спробою / винятком), і будь-які винятки, які виникають, будуть справжніми помилками або речами, які ви пропустили (замість того, щоб просто намагатися отримати доступ до ключів, яких немає) .

Як виявляється (див. Коментарі до вашого запитання), has_keyзастарілий - тому, мабуть, краще писати як

if "blah" in B:
  A["blah"] = B["blah"]

Починаючи Python 3.8та вводячи вирази присвоєння (PEP 572) ( :=оператор), ми можемо захопити значення умови dictB.get('hello', None)у змінну value, щоб обидва перевірити, чи не є воно None(як dict.get('hello', None)повертає або пов'язане значення, або None), а потім використовувати його в тілі умова:

# dictB = {'hello': 5, 'world': 42}
# dictA = {}
if value := dictB.get('hello', None):
  dictA["hello"] = value
# dictA is now {'hello': 5}

Хоча акцент на прийнятій відповіді на принципі "дивись перед тим, як стрибнути" може застосовуватися до більшості мов, першим підходом може бути більш пітонічний, заснований на принципах пітона. Не кажучи вже про те, що це законний стиль кодування в python. Важливо, переконайтесь, що ви використовуєте спробу, окрім блоку, у правильному контексті та дотримуєтесь найкращих практик. Напр. робити занадто багато речей у блоці try, вловлювати дуже широкий виняток, або ще гірше - оголене за винятком застереження тощо.

Простіше просити прощення, ніж дозволу. (EAFP)

Див. Посилання на документи python тут .

Крім того, цей блог від Brett, одного з основних розробників, торкається більшої частини цього стисло.

Дивіться ще SO обговорення тут :