Python: ฉันจะรู้ได้อย่างไรว่าข้อยกเว้นใดที่อาจเกิดขึ้นจากการเรียกใช้เมธอด

มีวิธีใดที่จะทราบได้ (ณ เวลาเข้ารหัส) ซึ่งคาดว่าจะมีข้อยกเว้นใดบ้างเมื่อเรียกใช้งานโค้ด python ฉันจบลงด้วยการจับคลาส Exception พื้นฐาน 90% ของเวลาเนื่องจากฉันไม่รู้ว่าประเภทข้อยกเว้นใดที่อาจถูกโยนทิ้ง (และอย่าบอกให้ฉันอ่านเอกสารประกอบหลายครั้งข้อยกเว้นสามารถแพร่กระจายจากส่วนลึกและหลาย ๆ ครั้งที่เอกสารไม่ได้รับการอัปเดตหรือถูกต้อง) มีเครื่องมือบางอย่างในการตรวจสอบสิ่งนี้หรือไม่? (เช่นการอ่านรหัส python และ libs)?

ฉันเดาว่าวิธีแก้ปัญหาอาจไม่ชัดเจนเพียงเพราะไม่มีกฎการพิมพ์แบบคงที่

ฉันไม่ทราบว่ามีเครื่องมือบางอย่างที่ตรวจสอบข้อยกเว้น แต่คุณสามารถสร้างเครื่องมือของคุณเองที่ตรงกับความต้องการของคุณได้ (โอกาสที่ดีที่จะเล่นด้วยการวิเคราะห์แบบคงที่)

ในความพยายามครั้งแรกคุณสามารถเขียนฟังก์ชันที่สร้าง AST ค้นหาRaiseโหนดทั้งหมดจากนั้นพยายามหารูปแบบทั่วไปของการเพิ่มข้อยกเว้น (เช่นการเรียกตัวสร้างโดยตรง)

ให้xเป็นโปรแกรมต่อไปนี้:

x = '''\
if f(x):
    raise IOError(errno.ENOENT, 'not found')
else:
    e = g(x)
    raise e
'''

สร้าง AST โดยใช้compilerแพ็คเกจ:

tree = compiler.parse(x)

จากนั้นกำหนดRaiseระดับผู้เยี่ยมชม:

class RaiseVisitor(object):
    def __init__(self):
        self.nodes = []
    def visitRaise(self, n):
        self.nodes.append(n)

และเดินตามRaiseโหนดรวบรวม AST :

v = RaiseVisitor()
compiler.walk(tree, v)

>>> print v.nodes
[
    Raise(
        CallFunc(
            Name('IOError'),
            [Getattr(Name('errno'), 'ENOENT'), Const('not found')],
            None, None),
        None, None),
    Raise(Name('e'), None, None),
]

คุณสามารถดำเนินการต่อได้โดยการแก้ไขสัญลักษณ์โดยใช้ตารางสัญลักษณ์ของคอมไพเลอร์วิเคราะห์การอ้างอิงข้อมูล ฯลฯ หรือคุณอาจสรุปได้ว่าCallFunc(Name('IOError'), ...)"ควรหมายถึงการเพิ่มขึ้นอย่างแน่นอนIOError" ซึ่งค่อนข้างใช้ได้สำหรับผลลัพธ์ในทางปฏิบัติที่รวดเร็ว :)

คุณควรจับเฉพาะข้อยกเว้นที่คุณจะจัดการเท่านั้น

การจับข้อยกเว้นทั้งหมดตามประเภทคอนกรีตเป็นเรื่องไร้สาระ คุณควรจับข้อยกเว้นเฉพาะที่คุณทำได้และจะจัดการ สำหรับข้อยกเว้นอื่น ๆ คุณสามารถเขียนการจับทั่วไปที่จับ "ข้อยกเว้นพื้นฐาน" บันทึก (ใช้str()ฟังก์ชัน) และยุติโปรแกรมของคุณ (หรือทำอย่างอื่นที่เหมาะสมในสถานการณ์ที่ขัดข้อง)

หากคุณจัดการข้อยกเว้นทั้งหมดจริงๆและแน่ใจว่าไม่มีข้อใดที่เป็นอันตราย (ตัวอย่างเช่นหากคุณกำลังเรียกใช้โค้ดในสภาพแวดล้อมแบบแซนด์บ็อกซ์) วิธีการจับ BaseException ทั่วไปของคุณจะเหมาะกับเป้าหมาย

คุณอาจสนใจการอ้างอิงข้อยกเว้นภาษาไม่ใช่ข้อมูลอ้างอิงสำหรับไลบรารีที่คุณใช้

หากการอ้างอิงไลบรารีไม่ดีจริง ๆ และไม่ได้โยนข้อยกเว้นของตัวเองซ้ำเมื่อตรวจจับระบบวิธีเดียวที่มีประโยชน์คือเรียกใช้การทดสอบ (อาจเพิ่มลงในชุดทดสอบเพราะหากมีบางสิ่งที่ไม่มีเอกสารอาจมีการเปลี่ยนแปลง!) . ลบไฟล์ที่สำคัญสำหรับรหัสของคุณและตรวจสอบว่ามีข้อยกเว้นอะไรบ้าง จัดหาข้อมูลมากเกินไปและตรวจสอบว่าเกิดข้อผิดพลาดใด

คุณจะต้องเรียกใช้การทดสอบต่อไปเนื่องจากแม้ว่าจะมีวิธีการรับข้อยกเว้นด้วยซอร์สโค้ด แต่ก็ไม่ได้ให้ความคิดใด ๆ ว่าคุณควรจัดการกับสิ่งเหล่านี้อย่างไร บางทีคุณควรจะแสดงข้อความแสดงข้อผิดพลาด "File needful.txt is not found!" เมื่อคุณจับIndexError? การทดสอบเท่านั้นที่สามารถบอกได้

เครื่องมือที่ถูกต้องในการแก้ปัญหานี้คือ unittests หากคุณมีข้อยกเว้นที่ยกขึ้นโดยรหัสจริงที่ Unittests ไม่ได้เพิ่มขึ้นคุณจะต้องมีการรวมกันมากขึ้น

พิจารณาสิ่งนี้

def f(duck):
    try:
        duck.quack()
    except ??? could be anything

เป็ดสามารถเป็นวัตถุใดก็ได้

เห็นได้ชัดว่าคุณสามารถมีAttributeErrorif duck ไม่มี quack TypeErrorถ้าเป็ดมี quack แต่เรียกไม่ได้ คุณไม่รู้ว่าอะไรduck.quack()จะเพิ่มขึ้นแม้จะเป็นDuckErrorหรือบางอย่าง

ตอนนี้สมมติว่าคุณมีรหัสเช่นนี้

arr[i] = get_something_from_database()

หากIndexErrorคุณไม่ทราบว่ามันมาจาก arr [i] หรือจากส่วนลึกของฟังก์ชันฐานข้อมูล โดยปกติแล้วมันจะไม่สำคัญมากนักเมื่อเกิดข้อยกเว้น แต่มีบางอย่างผิดพลาดและสิ่งที่คุณต้องการให้เกิดขึ้นไม่ได้

เทคนิคที่มีประโยชน์คือการจับและอาจปรับข้อยกเว้นเช่นนี้ใหม่

except Exception as e
    #inspect e, decide what to do
    raise

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

def apl(f,arg):
   return f(arg)

ตอนนี้aplสามารถเพิ่มข้อยกเว้นใด ๆ ที่fเพิ่มขึ้น แม้ว่าในไลบรารีหลักจะมีฟังก์ชันไม่มากนัก แต่สิ่งใดก็ตามที่ใช้การทำความเข้าใจรายการกับตัวกรองแบบกำหนดเองแผนที่การลดและอื่น ๆ จะได้รับผลกระทบ

เอกสารประกอบและตัววิเคราะห์แหล่งที่มาเป็นแหล่งข้อมูลที่ "จริงจัง" เพียงแหล่งเดียวที่นี่ เพียงจำไว้ว่าพวกเขาทำอะไรไม่ได้

ฉันพบสิ่งนี้เมื่อใช้ซ็อกเก็ตฉันต้องการค้นหาเงื่อนไขข้อผิดพลาดทั้งหมดที่ฉันจะพบ (แทนที่จะพยายามสร้างข้อผิดพลาดและคิดว่าซ็อกเก็ตใดที่ฉันต้องการรายการที่กระชับ ในที่สุดฉันก็ได้ grep'ing "/usr/lib64/python2.4/test/test_socket.py" สำหรับ "เพิ่ม":

$ grep raise test_socket.py
Any exceptions raised by the clients during their tests
        raise TypeError, "test_func must be a callable function"
    raise NotImplementedError, "clientSetUp must be implemented."
    def raise_error(*args, **kwargs):
        raise socket.error
    def raise_herror(*args, **kwargs):
        raise socket.herror
    def raise_gaierror(*args, **kwargs):
        raise socket.gaierror
    self.failUnlessRaises(socket.error, raise_error,
    self.failUnlessRaises(socket.error, raise_herror,
    self.failUnlessRaises(socket.error, raise_gaierror,
        raise socket.error
    # Check that setting it to an invalid value raises ValueError
    # Check that setting it to an invalid type raises TypeError
    def raise_timeout(*args, **kwargs):
    self.failUnlessRaises(socket.timeout, raise_timeout,
    def raise_timeout(*args, **kwargs):
    self.failUnlessRaises(socket.timeout, raise_timeout,

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

มีสองวิธีที่ฉันพบข้อมูล อันแรกรันโค้ดใน iPython ซึ่งจะแสดงประเภทข้อยกเว้น

n = 2
str = 'me '
str + 2
TypeError: unsupported operand type(s) for +: 'int' and 'str'

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

try:
   so something
except Exception as err:
   print "Some message"
   print err.__class__
   print err
   exit(1)

โดยปกติคุณจะต้องจับข้อยกเว้นเพียงไม่กี่บรรทัดของโค้ด คุณคงไม่ต้องการใส่mainฟังก์ชันทั้งหมดลงในtry exceptอนุประโยค สำหรับทุกๆสองสามบรรทัดตอนนี้คุณควรจะ (หรือตรวจสอบได้ง่ายๆ) ว่าจะมีข้อยกเว้นประเภทใดบ้าง

เอกสารมีรายการข้อยกเว้นในตัวโดยละเอียด อย่าพยายามยกเว้นข้อยกเว้นที่คุณไม่คาดคิดพวกเขาอาจได้รับการจัดการ / คาดหวังในรหัสการโทร

แก้ไข : สิ่งที่อาจถูกโยนขึ้นอยู่กับสิ่งที่คุณทำอย่างชัดเจน! การเข้าถึงองค์ประกอบแบบสุ่มของลำดับ: IndexErrorองค์ประกอบสุ่มของคำสั่ง: KeyErrorฯลฯ

เพียงแค่พยายามเรียกใช้สองสามบรรทัดใน IDLE และทำให้เกิดข้อยกเว้น แต่ unittest จะเป็นทางออกที่ดีกว่าโดยธรรมชาติ