כיצד ליצור חריגות מותאמות אישית ב- Python

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

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

למה אתה צריך חריגות מותאמות אישית?

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

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

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

כיצד להגדיר חריגות מותאמות אישית

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

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

הנה שיעור חריג מותאם אישית, MyCustomError:

classMyCustomError(Exception):
def__init__(self, message=None):
 self.message = message
 super().__init__(message)

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

כיצד להעלות חריגות מותאמות אישית

כדי להעלות שגיאה, השתמש ב- הַעֲלָאָה מילת מפתח ואחריה מופע של מחלקת החריגה המותאמת אישית שלך, ומעבירים לה הודעת שגיאה כארגומנט:

ifTrue:
raise MyCustomError("A Custom Error Was Raised...")

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

ifTrue:
raise MyCustomError # shorthand

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

כיצד לטפל בחריגים מותאמים אישית

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

try:
 print("Hello, You're learning how to MakeUseOf Custom Errors")
raise MyCustomError("Opps, Something Went Wrong...")
except MyCustomError as err:
 print(f"Error: {err}")
finally:
 print("Done Handling Custom Error")

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

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

try:
raise KeyboardInterrupt
except MyCustomError as err:
 print(f"Error: {err}")
finally:
 print("Did not Handle the KeyboardInterrupt Error. \
Can Only Handle MyCustomError")

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

הורשת מחלקות שגיאה מותאמות אישית

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

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

classBaseAPIException(Exception):
Base class for API-related exceptions.
def__init__(self, message):
 super().__init__(message)
 self.message = message

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

classAPINotFoundError(BaseAPIException):
Raised when the requested resource is not found in the API.
pass
classAPIAuthenticationError(BaseAPIException):
Raised when there's an issue with authentication to the API.
pass
classAPIRateLimitExceeded(BaseAPIException):
Raised when the rate limit for API requests is exceeded.
pass

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

defrequest_api():
try:
# Simulate an API error for demonstration purposes
raise APINotFoundError("Requested resource not found.")
except APINotFoundError as err:
# Log or handle the 'Not Found' error case
 print(f"API Not Found Error: {err}")
except APIAuthenticationError:
# Take appropriate actions for authentication error
 print(f"API Authentication Error: {err}")
except APIRateLimitExceeded:
# Handle the rate limit exceeded scenario
 print(f"API Rate Limit Exceeded: {err}")
except BaseAPIException:
# Handle other unknown API exceptions
 print(f"Unknown API Exception: {err}")

סעיף החוץ האחרון בודק מול מחלקת האב ופועל כ-catch-all עבור כל שגיאה אחרת הקשורה ל-API.

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

גלישת חריגים מותאמים אישית

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

שקול את התרחיש שבו אפליקציית האינטרנט שלך מקיימת אינטראקציה עם API. אם ה-API מעלה א LookupError, אתה יכול לתפוס את זה, ואז להעלות מנהג APINotFoundError חריג המתייחס לשגיאת ה- LookupError כגורם לה:

defrequest_api():
try:
# Simulate an API error for demonstration purposes
# Assuming the external API raised a LookupError
raise LookupError("Sorry, You Encountered A LookUpError !!!")
except LookupError as original_exception:
try:
# Wrap the original exception with a custom exception
raise APINotFoundError \
 ("Requested resource not found.") from original_exception
except APINotFoundError as wrapped_exception:
# Handle the wrapped exception here 
 print(f"Caught wrapped API exception: {wrapped_exception}")
# or re-raise it if necessary
raise
try:
 request_api()
except APINotFoundError as err:
 print(f"Caught API exception: {err.__cause__}")

תשתמש ב מ סעיף עם ה הַעֲלָאָה הצהרה כדי להתייחס לחריג המקורי בתוך החריג המותאם אישית שלך.

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

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

התאמה אישית של התנהגות הכיתה ב-Python

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