Являются ли вложенные блоки try / кроме в 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"

Я не уверен, являются ли вложенные блоки try / кроме хорошей практики, поэтому другим способом было бы использовать 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")

Или использовать одну из них и одну попытку блока catch, например:

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блоке выполнится успешно, функция вернется, поэтому любой код после всего блока 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

На мой взгляд, это был бы самый Pythonic способ справиться с этим, хотя и потому, что это делает ваш вопрос спорным. Обратите внимание, что это определяет __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

Хороший и простой пример для вложенного try / кроме может быть следующим:

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

[конечно, у нас есть numpy, поэтому нам не нужно создавать эту функцию]

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

Например, в моем коде я изначально написал

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

Я не думаю, что дело в том, чтобы быть питоническим или элегантным. Это вопрос предотвращения исключений настолько, насколько это возможно. Исключения предназначены для обработки ошибок, которые могут возникнуть в коде или событиях, которые вы не можете контролировать. В этом случае вы имеете полный контроль при проверке, является ли элемент атрибутом или в словаре, поэтому избегайте вложенных исключений и придерживайтесь второй попытки.