Python'daki yuvalanmış try / hariç bloklar iyi bir programlama uygulaması mıdır?

Öznitelik çağrıları ile içeride bir sözlüğe erişmesi gereken kendi kapsayıcımı yazıyorum. Kabın tipik kullanımı şöyle olacaktır:

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

Bunun gibi bir şey yazmanın aptalca olabileceğini biliyorum, ama sağlamam gereken işlevsellik bu. Bunu şu şekilde uygulamayı düşünüyordum:

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"

Yuvalanmış try / hariç blokların iyi bir uygulama olup olmadığından emin değilim, bu yüzden başka bir yol kullanmak hasattr()ve 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")

Veya bunlardan birini kullanmak ve biri böyle yakalamak için blok deneyin:

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")

Hangi seçenek en pitonik ve zariftir?

İlk örneğiniz gayet iyi. Resmi Python belgeleri bile EAFP olarak bilinen bu stili tavsiye ediyor .

Şahsen, gerekli olmadığında iç içe geçmekten kaçınmayı tercih ederim:

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'de uzun zamandır kullanımdan kaldırıldı item in self.dict. Bunun yerine kullanın .

Java'da akış denetimi için İstisnalar kullanmak kötü bir uygulamadır (esas olarak istisnalar jvm'yi kaynakları toplamaya zorlar ( daha fazla burada )), Python'da 2 önemli prensibiniz vardır: Ördek Yazma ve EAFP . Bu temel olarak, bir nesneyi işe yarayacağını düşündüğünüz şekilde kullanmaya ve işlerin böyle olmadığında işlem yapmaya teşvik edeceğiniz anlamına gelir.

Özetle, tek sorun kodunuzun çok fazla girintili olması olacaktır. Eğer böyle hissediyorsanız, lqc'nin önerdiği yuvaları basitleştirmeye çalışın

Özel örneğiniz için, onları iç içe yerleştirmeniz gerekmez. tryBloktaki ifade başarılı olursa, işlev geri döner, bu nedenle tüm try / hariç blokundan sonraki tüm kodlar yalnızca ilk deneme başarısız olursa çalıştırılır. Böylece şunları yapabilirsiniz:

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"

Onları yuvalamak kötü değil, ama onu düz bırakmak gibi hissediyorum, yapıyı daha net hale getiriyor: sırayla bir dizi şeyi deniyorsunuz ve işe yarayan ilkini geri veriyorsunuz.

Bu arada, burada kullanmak __getattribute__yerine gerçekten kullanmak isteyip istemediğinizi düşünmek isteyebilirsiniz __getattr__. Kullanmak __getattr__işleri basitleştirecektir, çünkü normal özellik arama işleminin zaten başarısız olduğunu bilirsiniz.

Sadece dikkatli olun - bu durumda önce finallydokunulur AMA da atlanır.

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

Benim düşünceme göre bu, bununla başa çıkmanın en Pythonic yolu olurdu, ancak sorunuzu tartışıyor. Bunun, __getattr__()bunun yerine __getattribute__()yalnızca dahili sözlükte tutulan "özel" niteliklerle uğraşması gerektiği anlamına geldiğini unutmayın.

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'da affetmeyi istemekten izin almak daha kolaydır. İç içe kural dışı durum işleme terlemeyin.

(Ayrıca, has*neredeyse her zaman kapak altında istisnalar kullanır.)

Belgelere göre , tuples veya bunun gibi çoklu istisnaları ele almak daha iyidir:

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

Yuvalanmış try / hariç için iyi ve basit bir örnek aşağıdakiler olabilir:

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

Şimdi çeşitli kombinasyonları deneyin ve doğru sonucu elde edersiniz:

divide(15, 3)
# 5.0

divide(15, 0)
# inf

divide(-15, 0)
# -inf

divide(0, 0)
# nan

[tabii ki numpy'miz var, bu yüzden bu işlevi yaratmamıza gerek yok]

Kaçınmaktan hoşlandığım bir şey, eskisini tutarken yeni bir istisna oluşturmaktır. Hata mesajlarının okunmasını kafa karıştırıcı hale getirir.

Örneğin, kodumda, başlangıçta yazdım

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

Ve bu mesajı aldım.

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

İstediğim şuydu:

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

İstisnaların nasıl ele alınacağını etkilemez. Her iki kod bloğunda da bir KeyError yakalanmış olurdu. Bu sadece stil puanı alma meselesidir.

Sonunda try-haricinde nihayet bloğun içinde yuvalanmışsa, "child" sonucu nihayet korunur. Henüz resmi açıklama bulamadım, ancak aşağıdaki kod snippet'i Python 3.6'da bu davranışı gösterir.

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

Bunun pitonik veya zarif olma meselesi olduğunu sanmıyorum. Bu, istisnaları olabildiğince önleme meselesidir. İstisnalar, denetiminiz olmayan kod veya olaylarda oluşabilecek hataları işlemek içindir. Bu durumda, bir öğenin bir özellik veya sözlükte olup olmadığını kontrol ederken tam kontrole sahip olursunuz, bu nedenle iç içe geçmiş istisnalardan kaçının ve ikinci denemenize sadık kalın.