כיצד לטפל בחריגים בפייתון

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

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

כאן נבחן כיצד אתה יכול להתמודד עם חריגים בפייתון.

כיצד עובד טיפול בחריגים בפייתון

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

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

מתי כדאי להשתמש בחריגים בתכנות פיתון?

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

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

במילים אחרות, אתה יכול להשתמש בחריגים ככלי אזהרה להנחות משתמשים כיצד להשתמש בתוכנית שלך.

טיפול בחריגים של פיתון

כדי לטפל בחריגים בפייתון, תחילה עליך לעטוף את הקוד שלך ב- נסה... אלא לַחסוֹם. מדי פעם, ייתכן שיהיה עליך לכלול א סוף כל סוף הצהרה לטיפול בפעולות נוספות, בהתאם לצרכים שלך.

מושג הקידוד של יוצאי דופן של פייתון נראה בדרך כלל כך:

לְנַסוֹת:
"קוד לביצוע"
מלבד:
"הודעת שגיאה"

כפי שצוין קודם, אתה יכול גם להשתמש סוף כל סוף בבלוק חריג. אבל הקוד שאתה כותב בתוך a סוף כל סוף סעיף הוא עצמאי ופועל בין אם יש חריג ובין אם לאו.

בעיקרו של דבר, זה שימושי אם יש לך עוד גוש קוד שאתה רוצה להריץ ברציפות ללא קשר למה שקורה בתוך ה- נסה... אלא לַחסוֹם.

הנה דוגמה:

לְנַסוֹת:
הדפס (9 + 6)
מלבד:
הדפס ("הודעת שגיאה")
סוף כל סוף:
הדפס ("אנא הפעל מחדש")
תְפוּקָה:
15
תפעיל מחדש בבקשה 

בקוד לעיל, תפעיל מחדש בבקשה פועל ברציפות, בין אם יש חריג או לא.

An אַחֵר מצב יכול גם להיות בעקבות מלבד הַצהָרָה:

לְנַסוֹת:
C = 2 + B
מלבד:
הדפס ("צריך להגדיר B")
אַחֵר:
הדפס (u "נוסף בהצלחה! התוצאה היא% s "% (C))
תְפוּקָה: צריך להגדיר את B

עכשיו נסה זאת שוב עם ההגדרה "B":

לְנַסוֹת:
B = 5
C = 2 + B
מלבד:
הדפס ("צריך להגדיר B")
אַחֵר:
הדפס (u "נוסף בהצלחה! התוצאה היא% s "% (C))
תְפוּקָה: נוסף בהצלחה! התוצאה היא 7

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

לְנַסוֹת:
C = 2 + B
למעט שם שגיאה כשגיאה:
הדפס (err, ":", "B צריך להיות מוגדר, בבקשה")
אַחֵר:
הדפס (u "נוסף בהצלחה! התוצאה היא% s "% (C))
תְפוּקָה: השם 'B' אינו מוגדר: צריך להגדיר את B, בבקשה

החריג הנ"ל בודק תחילה אם קיים שם שגיאה בתוך ה לְנַסוֹת לַחסוֹם. לאחר מכן הוא מדפיס את התקן שם שגיאה יוצא מן הכלל ראשון ("השם 'B' אינו מוגדר"). ותומך בזה למעט הכתיבה שלך ("צריך להגדיר את B, בבקשה").

קָשׁוּר: עקרונות תכנות בסיסיים שכל מתכנת חייב לדעת

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

לְנַסוֹת:
B = 5
C = 2 + B
D = לצוף (6)
F = 7/0
למעט שם שגיאה כשגיאה:
הדפס (err, ":", "B צריך להיות מוגדר, בבקשה")
למעט ValueError כ- val:
הדפס (val, ":", "אינך יכול להמיר נתונים אלה")
למעט ZeroDivisionError כ- nullerr:
הדפס (zeroerr, ":", "אתה לא יכול לחלק מספר באפס")
אַחֵר:
הדפס (u "מבצע מוצלח! התוצאות הן:% s,% s ו-% s "% (C, D, F))
תְפוּקָה: חלוקה באפס: אינך יכול לחלק מספר באפס

מה אם החלוקה תקפה? למשל, החלפה F = 7/0 בקוד לעיל עם F = 7/5 נותן:

תְפוּקָה: המבצע הצליח! התוצאות הן: 7, 6.0 ו- 1.4

חריגים שהוגדרו על ידי משתמשים בפייתון

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

עם זאת, כל יוצא מן הכלל המוגדר על ידי המשתמש (באופן ישיר או עקיף) עדיין מגיע מהמשובץ יוצא מן הכלל מחלקה של פייתון.

קוד הדוגמה שלמטה מתייחס לבסיס יוצא מן הכלל ישירות על ידי התקשרות RuntimeError מזה:

class connectionError (RuntimeError):
def __init __ (עצמי, ערך):
self.value = ערך
לְנַסוֹת:
העלאת connectionError ("שם מארח רע")
למעט חיבור שגיאה כשגיאה:
הדפס (שגיאת ערך)
תְפוּקָה: שם מארח רע

ציין זאת בעיית חיבור, במקרה זה, הוא מחלקה המוגדרת על ידי המשתמש, שתוכל להעלות בכל עת שתזדקק לה בתוכנית שלך.

קָשׁוּר: המדריך למתחילים לביטויים רגולריים עם פיתון

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

שגיאות בכיתה (חריג):
לַעֲבוֹר
מחלקה ששFiveError (שגיאות):
def __init __ (עצמי, ערך, הודעה):
self.value = ערך
self.message = הודעה
לְנַסוֹת:
העלה sixFiveError (6-5, "לא ניתן להסיע את המצע הזה")
למעט sixFiveError כמו e:
הדפס ("הייתה שגיאה:", למשל. הודעה)
תְפוּקָה: הייתה שגיאה: לא ניתן להשתמש במצע זה

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

# התקשר תחילה לשיעורי החריגים הבסיסיים:
שגיאות בכיתה (חריג):
לַעֲבוֹר
# הבא, הפיק חריג משלך ממעמד הבסיס:
class FloatError (שגיאות):
def __init __ (עצמי, ערך, הודעה):
self.value = ערך
self.message = הודעה
# צור פונקציה כדי להוסיף שני צפים:
def addTwoFloat (a, b):
אם (סוג (א) וסוג (ב))! = צף:
העלה את FloatError (a + b, "המספרים חייבים לצוף כדי להוסיף")
אַחֵר:
הדפס (a + b)
addTwoFloat (4, 7)
תְפוּקָה: __העיקר __. FloatError: (11, 'המספרים חייבים להיות צפים כדי להוסיף')

כי עכשיו הגדרת א FloatError בכיתה, פייתון מעלה את זה אם אתה מנסה להוסיף שני מילוליות שאינן צפות באמצעות addtwoFloat פוּנקצִיָה.

אתה יכול להדפיס את FloatError בכיתה באותו קובץ פייתון שבו יצרת אותו כדי לראות מה קורה:

הדפס (FloatError)
תְפוּקָה:

FloatErrorעם זאת, אינו יוצא מהכלל מובנה של פייתון. אתה יכול לאמת זאת על ידי התקשרות FloatError בקובץ פיתון חדש אחר שבו לא יצרת מחלקה זו:

הדפס (FloatError)
תְפוּקָה: NameError: השם 'FloatError' אינו מוגדר

אתה מקבל שם שגיאה מכיוון שפייתון אינו מכיר בכך כחריג סטנדרטי.

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

הפוך את תוכניות הפיתון שלך לידידותיות יותר למעט חריגים

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

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

כיצד לפתור באגים בקוד הפייתון שלך

הצטיידו בידע למעוך כל באג פיתון בדרככם.

קרא הבא

על הסופר