ลอง / ยกเว้นบล็อกในหลามเป็นแบบฝึกหัดการเขียนโปรแกรมที่ดีหรือไม่

ฉันกำลังเขียนคอนเทนเนอร์ของตัวเองซึ่งจำเป็นต้องให้สิทธิ์การเข้าถึงพจนานุกรมภายในด้วยการเรียกแอตทริบิวต์ การใช้งานทั่วไปของคอนเทนเนอร์จะเป็นเช่นนี้:

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

หรือใช้หนึ่งในนั้นและลองใช้ catch block ดังนี้:

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

ตัวเลือกแบบไหนที่ไพเราะและสง่างามที่สุด?

ตัวอย่างแรกของคุณดีมาก แม้ทางการเอกสารหลามแนะนำรูปแบบนี้เป็นที่รู้จักกันเป็น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 ในการรวบรวมทรัพยากร ( เพิ่มเติมได้ที่นี่ )) ในหลามคุณมี 2 หลักการสำคัญ: พิมพ์ดีดเป็ดและ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

ในความคิดของฉันนี้จะเป็นวิธีที่ 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*มักใช้ข้อยกเว้นภายใต้ฝาครอบอยู่เสมอ)

ตามเอกสารมันจะดีกว่าที่จะจัดการข้อยกเว้นหลายอย่างผ่าน tuples หรือเช่นนี้

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 จะได้รับการติด นี่เป็นเพียงปัญหาของการได้รับคะแนนสไตล์

หากการลองแบบยกเว้นข้อสุดท้ายถูกบล็อกไว้ภายในบล็อกสุดท้ายผลลัพธ์จาก "child" จะถูกเก็บรักษาไว้ในที่สุด ฉันยังไม่พบการหมดอายุอย่างเป็นทางการ แต่ข้อมูลโค้ดต่อไปนี้แสดงพฤติกรรมนี้ใน 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

ฉันไม่คิดว่ามันเป็นเรื่องของการไพ ธ อนหรือความสง่างาม มันเป็นเรื่องของการป้องกันข้อยกเว้นให้มากที่สุด ข้อยกเว้นมีขึ้นเพื่อจัดการข้อผิดพลาดที่อาจเกิดขึ้นในรหัสหรือเหตุการณ์ที่คุณไม่สามารถควบคุมได้ ในกรณีนี้คุณสามารถควบคุมได้อย่างเต็มที่เมื่อตรวจสอบว่ารายการนั้นเป็นแอททริบิวต์หรือในพจนานุกรมดังนั้นหลีกเลี่ยงข้อยกเว้นซ้อนและยึดติดกับความพยายามครั้งที่สองของคุณ