חריגות ב-Python: try, except, else, finally ו-raise

שגיאות הן פשוט ערכים עם גישה רעה

כשמשהו משתבש ב-Python (חילוק באפס, קריאה של קובץ חסר, פענוח של מספר לא תקין), סביבת הריצה יוצרת אובייקט חריגה (exception) ומתחילה לפרק את מחסנית הקריאות עד שמשהו תופס אותה. אם שום דבר לא תופס, התוכנית מסתיימת ומדפיסה traceback.

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

הצורה הבסיסית

text = input("Type a number: ")

try:
    number = int(text)
    print(f"Doubled: {number * 2}")
except ValueError:
    print(f"That wasn't a valid number: {text!r}")

• try: פותח את בלוק הקוד המסוכן.
• except ValueError: תופס את החריגה הספציפית הזו אם היא נזרקת בתוך ה-try.
• אם לא נזרקת חריגה, מדלגים על ה-except לגמרי.

הריצו את הקטע עם 42: זה עובד. הריצו אותו עם hello: המטפל רץ.

תפיסת חריגות ספציפיות

ל-Python יש היררכיה של סוגי חריגות. כמה מהן תפגשו הרבה:

• ValueError: ערך היה שגוי בדרך כלשהי (int("abc"), ארגומנטים מחוץ לטווח).
• TypeError: נעשה שימוש ב_טיפוס_ הלא נכון ("hi" + 3).
• KeyError: מפתח לא נמצא ב-dict.
• IndexError: אינדקס ברצף היה מחוץ לטווח.
• FileNotFoundError: קובץ לא קיים.
• ZeroDivisionError: ניסיון לחלק באפס.
• AttributeError: לאובייקט אין את התכונה המבוקשת.

תפסו את החריגה הספציפית שאתם יודעים לטפל בה:

data = {"count": 5}

try:
    print(data["missing"])
except KeyError:
    print("Key not found - using a default.")

אפשר לתפוס כמה חריגות בפסקה אחת על ידי העברת tuple:

try:
    value = int(input("Number? "))
    result = 10 / value
except (ValueError, ZeroDivisionError) as e:
    print(f"Got bad input: {e}")

שימו לב ל-as e. הוא קושר את אובייקט החריגה ל-e, כדי שתוכלו לבדוק את ההודעה או התכונות שלו.

הימנעו מתפיסה של הכל

except: חשוף תופס ממש כל דבר, כולל KeyboardInterrupt (ה-Ctrl-C שלכם) ויציאות ברמת המערכת. אל תשתמשו בו.

except Exception: קצת יותר טוב, אבל עדיין מסוכן: הוא בולע באגים שלא צפיתם ומסתיר את המקור האמיתי של הבעיות:

# אל תעשו את זה בלי סיבה ממש טובה.
try:
    do_something()
except Exception:
    pass

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

else ו-finally

להצהרת try יש עוד שתי פסקאות אופציונליות:

• else רץ אם בלוק ה-try הסתיים בלי לזרוק חריגה.
• finally רץ לא משנה מה: עם חריגה או בלי.

def parse_line(line):
    try:
        key, value = line.strip().split("=", 1)
    except ValueError:
        print(f"Couldn't parse: {line!r}")
        return None
    else:
        print(f"Parsed: {key} = {value}")
        return (key.strip(), value.strip())
    finally:
        print("Done with this line.")

parse_line("host = localhost")
parse_line("missing equals sign")

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

זריקת חריגות בעצמכם

השתמשו ב-raise כדי לאותת על שגיאה בקוד שלכם:

def discount(price, percent):
    if percent < 0 or percent > 100:
        raise ValueError(f"Percent must be 0–100, got {percent}")
    return price * (1 - percent / 100)

print(discount(100, 20))

try:
    discount(100, 150)
except ValueError as e:
    print(f"Caught: {e}")

בחרו סוג חריגה שמתאים למה שהשתבש. פנו קודם לחריגות המובנות, ValueError, TypeError, FileNotFoundError, לפני שאתם מגדירים מחלקה משלכם.

הגדרת חריגה משלכם

כשהחריגות המובנות לא מבטאות את המשמעות, הגדירו חריגה מותאמת אישית:

class PaymentDeclined(Exception):
    """Raised when a payment provider declines the transaction."""

def charge(amount):
    # דמיינו שזה מתקשר עם ספק תשלומים.
    if amount > 1000:
        raise PaymentDeclined(f"Declined for ${amount}")
    print(f"Charged ${amount}")

try:
    charge(1500)
except PaymentDeclined as e:
    print("Payment failed:", e)

רשו מ-Exception (או מחריגה מובנית ספציפית יותר) ותנו למחלקה docstring. בדרך כלל זה כל מה שצריך. חריגות מותאמות אישית מאפשרות לקוד הקורא לתפוס רק את השגיאה שמשמעותית לתחום שלו.

raise ... from ...: חריגות משורשרות

כשחריגה אחת גורמת לאחרת, שמרו על השרשרת:

class ConfigError(Exception):
    pass

def load_config(path):
    try:
        with open(path) as f:
            return f.read()
    except FileNotFoundError as e:
        raise ConfigError(f"Missing config at {path}") from e

try:
    load_config("nonexistent.cfg")
except ConfigError as e:
    print("Top-level:", e)
    print("Caused by:", e.__cause__)

ה-from e מצרף את השגיאה המקורית. כשה-traceback מודפס, Python מציגה את שתיהן: את ה-ConfigError שעלתה למעלה ואת ה-FileNotFoundError שגרמה לה. שובל כזה שווה זהב בזמן דיבוג.

Context Managers: הדרך הנקייה יותר לנקות

finally זה בסדר, אבל למשאבים כמו קבצים, context manager (מה ש-with משתמש בו) עדיף כמעט תמיד:

# גרסה עם finally
f = open("data.txt")
try:
    data = f.read()
finally:
    f.close()

# גרסה עם with
with open("data.txt") as f:
    data = f.read()

שתי הגרסאות בטוחות. הצורה עם with קצרה יותר ופועלת אוטומטית. פנו ל-finally רק כשאתם עושים משהו שהספרייה הסטנדרטית עוד לא עוטפת ב-context manager.

מתי לא לתפוס

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

try:
    do_work()
except Exception:
    pass  # מתעלמים מהכל בשקט

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

לסיכום

• try/except מאפשרים לטפל בשגיאות שאפשר להתאושש מהן.
• תפסו חריגות ספציפיות, לא Exception באופן גורף.
• raise מאותת על שגיאות בקוד שלכם.
• בלוקים של with מחליפים את רוב הניקוי עם finally.
• כשיש ספק, תנו לחריגה להמשיך הלאה.

בהמשך: סיור בשגיאות הספציפיות ש-Python זורקת הכי הרבה, KeyError, ValueError, ModuleNotFoundError ועוד כמה, יחד עם הרגלי הדיבוג שמתקנים אותן מהר.