מה זה טיפול בחריגות (Exception Handling)?

תוכנית ששואלת אנשים בני כמה הם תקבל במוקדם או במאוחר "twenty" במקום 20. המרת הטקסט הזה היא שגיאת זמן ריצה: int("twenty") זורק ValueError, ובלי תוכנית פעולה לזה התוכנית נעצרת. טיפול בחריגות הוא תוכנית הפעולה הזו. מסמנים את הקוד שעלול להיכשל, וכותבים את הקוד שירוץ אם הוא אכן נכשל.

answers = ["34", "twenty", "19"]

for text in answers:
    try:
        age = int(text)
        print("Next year you will be", age + 1)
    except ValueError:
        print("Not a number:", text)

print("Done")

Next year you will be 35
Not a number: twenty
Next year you will be 20
Done

התשובה הלא תקינה מדווחת, והלולאה ממשיכה לתשובה הבאה. בלי ה-try, התוכנית הייתה מדפיסה שורה אחת ואז traceback.

איך טיפול בחריגות עובד

1. הקוד שבתוך try רץ כרגיל.
2. פעולה נכשלת, וסביבת הריצה זורקת חריגה: אובייקט עם סוג (ValueError) והודעה (invalid literal for int() with base 10: 'twenty').
3. בלוק ה-try נעצר בשורה הזו. שאר השורות שלו מדולגות, ולכן "Next year you will be" לא מודפס עבור "twenty".
4. סביבת הריצה משווה את סוג החריגה לכל פסקת except, מלמעלה למטה, ומריצה את הראשונה שמתאימה.
5. אחרי שהמטפל מסיים, התוכנית ממשיכה מהשורה הראשונה שאחרי כל פקודת ה-try.
6. אם אף פסקה לא מתאימה, החריגה יוצאת מהפונקציה הנוכחית והחיפוש ממשיך בפונקציה שקראה לה, ואז בזו שקראה לה. לזה קוראים פריסת מחסנית הקריאות (unwinding). אם החיפוש מגיע לראש התוכנית בלי התאמה, התוכנית מסתיימת עם traceback.

שלב 6 אומר שהמטפל לא חייב להיות בפונקציה שבה השגיאה קורית. כאן הכשל נמצא שתי קריאות לעומק, והמטפל שלמטה עדיין תופס אותו:

def parse_price(text):
    print("parsing", text)
    return float(text)

def total(prices):
    result = 0
    for p in prices:
        result += parse_price(p)
    return result

try:
    print(total(["4.50", "free", "3.20"]))
except ValueError as error:
    print("Could not add the prices:", error)

parsing 4.50
parsing free
Could not add the prices: could not convert string to float: 'free'

float("free") נכשל בתוך parse_price. לא ל-parse_price ולא ל-total היה מטפל, ולכן שתיהן ננטשו, ו-"3.20" אף פעם לא נותח. זו בחירת התכנון העיקרית שטיפול בחריגות נותן לכם: לטפל בשגיאה במקום שבו יודעים מה לעשות איתה, ולרוב זה רחוק מהמקום שבו היא קרתה.

try, except, else ו-finally

לפקודת try של Python יש עוד שני חלקים אופציונליים. else רץ רק כשבלוק ה-try הסתיים בלי חריגה. finally רץ בכל מקרה: אחרי הצלחה, אחרי חריגה שטופלה, ואפילו כשהפונקציה חוזרת מתוך ה-try.

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("b was zero")
        return None
    else:
        print("no error")
        return result
    finally:
        print("finally runs either way")

print(divide(6, 3))
print(divide(6, 0))

no error
finally runs either way
2.0
b was zero
finally runs either way
None

finally הוא המקום לניקוי: סגירת קובץ, שחרור נעילה, סגירת חיבור למסד נתונים. ב-Python, פקודת with עושה את הניקוי הזה לקבצים אוטומטית, והיא הבחירה הרגילה עבורם.

זריקת חריגות משלכם

חריגות לא נועדו רק לשגיאות שהשפה מזהה. כשפונקציה שלכם מקבלת קלט שהיא לא יכולה לעבוד איתו, היא יכולה לזרוק חריגה כדי לסרב, ומי שקרא לה מחליט מה קורה הלאה. הגדרה של מחלקת חריגה קטנה נותנת לשגיאה שם שמתאר אותה.

class InsufficientFunds(Exception):
    pass

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFunds(f"cannot take {amount}, balance is {balance}")
    return balance - amount

print(withdraw(100, 30))

try:
    withdraw(100, 250)
except InsufficientFunds as error:
    print("Refused:", error)

70
Refused: cannot take 250, balance is 100

Python משתמשת ב-raise. Java, C++ ו-JavaScript משתמשות ב-throw לאותה מטרה.

טיפול בחריגות בשפות אחרות

אותה דוגמת ניתוח ב-Java נראית כך:

try {
    int age = Integer.parseInt("twenty");
    System.out.println(age + 1);
} catch (NumberFormatException e) {
    System.out.println("Not a number: " + e.getMessage());
} finally {
    System.out.println("done");
}

Java מחלקת חריגות לשתי קבוצות. חריגות מסוג checked, כמו IOException, מתארות בעיות שמחוץ לשליטת התוכנית, והקומפיילר מסרב לבנות קוד שלא תופס אותן וגם לא מצהיר עליהן. חריגות מסוג unchecked, תת מחלקות של RuntimeException כמו NullPointerException, מעידות בדרך כלל על באג, והקומפיילר לא מחייב לטפל בהן.

טעויות נפוצות

• לתפוס הכול. except: ריק ב-Python תופס גם את KeyboardInterrupt, כך ש-Ctrl+C מפסיק לעבוד, ו-except Exception: תופס באגים שמעולם לא תכננתם. תפסו את הסוג הספציפי שאתם יודעים לטפל בו.
• לבלוע את השגיאה. except ValueError: pass מסתיר את הבעיה. לכל הפחות, הדפיסו או רשמו ביומן מה השתבש.
• בלוק try גדול מדי. עטפו רק את השורות שיכולות לזרוק את החריגה שאתם תופסים, כדי ששגיאה לא קשורה לא תטופל בטעות.
• לתפוס באגים במקום לתקן אותם. IndexError מלולאה שרצה צעד אחד יותר מדי הוא טעות בקוד. טיפול בו משאיר את הקוד השגוי בחיים.
• לצפות ש-catch יעצור קריסה ב-C או ב-C++. Segmentation fault הוא אות (signal) ממערכת ההפעלה, לא חריגה, וב-Linux וב-macOS catch (...) של C++ אף פעם לא רואה אותו.

לאן ממשיכים מכאן

השגיאות שטיפול בחריגות מגיב אליהן מתוארות בעמוד על שגיאת זמן ריצה, והקריסה שהוא לא יכול לתפוס בעמוד על segmentation fault. לתחביר המלא, קראו את המדריכים לחריגות ב-Python, לtry ו-catch ב-Java, לחריגות ב-C++ ולtry ו-catch ב-JavaScript. קורס Java וקורס Python מתרגלים את הנושא בתרגילים אמיתיים.