Чи є вкладені спробу / крім блоків у python гарною практикою програмування?

Я пишу власний контейнер, який повинен надати доступ до словника всередині за викликами атрибутів. Типове використання контейнера було б таким:

dict_container = DictContainer()
dict_container['foo'] = bar
...
print dict_container.foo

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

def __getattribute__(self, item):
    try:
        return object.__getattribute__(item)
    except AttributeError:
        try:
            return self.dict[item]
        except KeyError:
            print "The object doesn't have such attribute"

Я не впевнений, чи є вкладені спроби / крім блоків хорошою практикою, тому іншим способом було б використання hasattr()та has_key():

def __getattribute__(self, item):
        if hasattr(self, item):
            return object.__getattribute__(item)
        else:
            if self.dict.has_key(item):
                return self.dict[item]
            else:
                raise AttributeError("some customised error")

Або скористатися одним із них та одним блоком спробувати ловити так:

def __getattribute__(self, item):
    if hasattr(self, item):
        return object.__getattribute__(item)
    else:
        try:
            return self.dict[item]
        except KeyError:
            raise AttributeError("some customised error")

Який варіант є найбільш пітонічним та елегантним?

Ваш перший приклад ідеально чудовий. Навіть офіційні документи Python рекомендують цей стиль, відомий як EAFP .

Особисто я вважаю за краще уникати гніздування, коли це не потрібно:

def __getattribute__(self, item):
    try:
        return object.__getattribute__(item)
    except AttributeError:
        pass  # fallback to dict
    try:
        return self.dict[item]
    except KeyError:
        raise AttributeError("The object doesn't have such attribute") from None

PS. has_key()давно застаріло в Python 2. Використовуйте item in self.dictзамість цього.

Хоча в Java справді погана практика використовувати Винятки для контролю потоку (головним чином, тому, що винятки змушують jvm збирати ресурси ( докладніше тут )), у Python у вас є два важливих принципи: Duck Typing та EAFP . Це в основному означає, що вам пропонується спробувати використовувати об’єкт так, як ви думаєте, що він би працював, і керувати, коли речі не такі.

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

Для вашого конкретного прикладу вам насправді не потрібно гніздовати їх. Якщо вираз у tryблоці буде успішним, функція повернеться, тому будь-який код після всього блоку спробу / за винятком блоку буде запущений, лише якщо перша спроба не вдасться. Тож ви можете просто зробити:

def __getattribute__(self, item):
    try:
        return object.__getattribute__(item)
    except AttributeError:
        pass
    # execution only reaches here when try block raised AttributeError
    try:
        return self.dict[item]
    except KeyError:
        print "The object doesn't have such attribute"

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

Між іншим, ви можете подумати про те, чи дійсно ви хочете використовувати __getattribute__замість __getattr__цього. Використання __getattr__спростить речі, оскільки ви будете знати, що нормальний процес пошуку атрибутів вже не вдався.

Будьте обережні - у цьому випадку спочатку finallyторкається НЕ пропущено теж.

def a(z):
    try:
        100/z
    except ZeroDivisionError:
        try:
            print('x')
        finally:
            return 42
    finally:
        return 1


In [1]: a(0)
x
Out[1]: 1

На мою думку, це був би найпітонічніший спосіб вирішити це, хоча і тому, що це робить ваше запитання суперечливим. Зауважте, що це визначає __getattr__()замість того, __getattribute__()що це означає, що це має справу лише з "спеціальними" атрибутами, що зберігаються у внутрішньому словнику.

def __getattr__(self, name):
    """only called when an attribute lookup in the usual places has failed"""
    try:
        return self.my_dict[name]
    except KeyError:
        raise AttributeError("some customized error message")

У Python простіше просити пробачення, ніж дозволу. Не потіть вкладені винятки.

(Крім того, has*майже завжди використовуються винятки під обкладинкою.)

Згідно з документацією , краще обробляти кілька винятків через кортежі чи так:

import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except IOError as e:
    print "I/O error({0}): {1}".format(e.errno, e.strerror)
except ValueError:
    print "Could not convert data to an integer."
except:
    print "Unexpected error:", sys.exc_info()[0]
    raise

Хорошим і простим прикладом для вкладеної спроби / за винятком може бути наступний:

import numpy as np

def divide(x, y):
    try:
        out = x/y
    except:
        try:
            out = np.inf * x / abs(x)
        except:
            out = np.nan
    finally:
        return out

Тепер спробуйте різні комбінації, і ви отримаєте правильний результат:

divide(15, 3)
# 5.0

divide(15, 0)
# inf

divide(-15, 0)
# -inf

divide(0, 0)
# nan

[звичайно, у нас нудні, тому нам не потрібно створювати цю функцію]

Одне, чого мені хотілося б уникати, - це створити новий виняток під час роботи зі старим. Це робить повідомлення про помилки заплутаним для читання.

Наприклад, у своєму коді я спочатку писав

try:
    return tuple.__getitem__(self, i)(key)
except IndexError:
    raise KeyError(key)

І я отримав це повідомлення.

>>> During handling of above exception, another exception occurred.

Я цього хотів:

try:
    return tuple.__getitem__(self, i)(key)
except IndexError:
    pass
raise KeyError(key)

Це не впливає на обробку винятків. У будь-якому блоці коду був би спійманий KeyError. Це лише питання отримання стильових балів.

Якщо спробу-крім-нарешті вкладено всередину, нарешті, блок, результат від "дитина", нарешті, зберігається. Я ще не знайшов офіційного розширення, але наступний фрагмент коду показує цю поведінку в Python 3.6.

def f2():
    try:
        a = 4
        raise SyntaxError
    except SyntaxError as se:
        print('log SE')
        raise se from None
    finally:
        try:
            raise ValueError
        except ValueError as ve:
            a = 5
            print('log VE')
            raise ve from None
        finally:
            return 6       
        return a

In [1]: f2()
log SE
log VE
Out[2]: 6

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