Ինչպես ստեղծել անհատական բացառություններ Python-ում

Բացառությունները ձեր Python ծրագրերում սխալները կարգավորելու հզոր և նրբագեղ միջոց են: Հատուկ բացառությունները այս իշխանությունը տեղափոխում են նոր մակարդակ:

Python-ի ներկառուցված բացառությունների դասերը չեն անդրադառնում որոշակի սխալի իրավիճակներին, որոնք կարող են առաջանալ ձեր կոդում: Նման դեպքերում դուք պետք է ստեղծեք հատուկ բացառություններ՝ այս սխալներն արդյունավետ կարգավորելու համար:

Python-ում դուք կարող եք սահմանել հատուկ բացառություններ և բարձրացնել դրանք, երբ առաջանում են հատուկ սխալ իրավիճակներ: Դուք կարող եք կառավարել հատուկ, տեղեկատվական սխալները՝ հատուկ բացառություններով, բարելավելով ձեր կոդի ընթեռնելիությունը և պահպանելիությունը:

Ինչու՞ են ձեզ հարկավոր հատուկ բացառություններ:

Հավելվածի մշակման ընթացքում սխալի տարբեր սցենարներ կարող են առաջանալ կոդի փոփոխության, այլ փաթեթների կամ գրադարանների հետ ինտեգրվելու և արտաքին հավելվածների հետ փոխգործակցության պատճառով: Շատ կարևոր է կարգավորել այս սխալները՝ դրանցից վերականգնվելու կամ ձախողումը նրբագեղորեն վարվելու համար:

Python-ն առաջարկում է մի շարք ներկառուցված բացառությունների դասեր, որոնք ծածկում են այնպիսի սխալներ, ինչպիսիք են ValueError, TypeError, FileNotFoundError և այլն: Թեև այս ներկառուցված բացառությունները լավ են ծառայում իրենց նպատակին, դրանք կարող են միայն երբեմն ճշգրիտ ներկայացնել սխալները, որոնք կարող են առաջանալ ձեր հավելվածում:

Ստեղծելով հատուկ բացառություններ՝ դուք կարող եք դրանք հատուկ հարմարեցնել ձեր հավելվածի պահանջներին համապատասխան և տեղեկատվություն տրամադրել մշակողների համար, ովքեր օգտագործում են ձեր կոդը:

Ինչպես սահմանել մաքսային բացառությունները

Հատուկ բացառություններ ստեղծելու համար սահմանեք Python դաս, որը ժառանգում է Exception դասից: Բացառություն դասը առաջարկում է հիմնական գործառույթներ, որոնք ձեզ անհրաժեշտ կլինեն բացառությունները կարգավորելու համար, և դուք կարող եք հարմարեցնել այն՝ ձեր հատուկ կարիքների հիման վրա գործառույթներ ավելացնելու համար:

Հատուկ բացառությունների դասեր ստեղծելիս դրանք պարզ պահեք՝ միաժամանակ ներառելով սխալի մասին տեղեկությունները պահելու համար անհրաժեշտ ատրիբուտները: Այնուհետև բացառությունների մշակողները կարող են մուտք գործել այս ատրիբուտները՝ սխալները պատշաճ կերպով կարգավորելու համար:

Ահա սովորական բացառությունների դասը՝ MyCustomError:

class MyCustomError(Exception):
    def __init__(self, message=None):
        self.message = message
        super().__init__(message)

Այս դասը սկզբնավորման ընթացքում ընդունում է կամընտիր հաղորդագրության արգումենտ: Այն օգտագործում է super() մեթոդը` կանչելու Exception բազային դասի կոնստրուկտորը, որը կարևոր է բացառությունների մշակման համար:

Ինչպես բարձրացնել մաքսային բացառությունները

Սխալ առաջացնելու համար օգտագործեք բարձրացնել հիմնաբառը, որին հաջորդում է ձեր սովորական բացառության դասի օրինակը, որպես արգումենտ փոխանցելով այն սխալի հաղորդագրություն:

if True:
    raise MyCustomError("A Custom Error Was Raised!!!.")

Դուք կարող եք նաև բարձրացնել սխալը՝ առանց որևէ արգումենտ փոխանցելու.

if True:
    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")

Այս նմուշում տեղի է ունենում KeyboardInterrupt բացառություն, սակայն բացառությամբ բլոկը կարգավորում է միայն MyCustomError բացառությունները: Այս դեպքում, վերջապես բլոկը գործարկվում է, ապա չկառավարվող բացառությունը կրկին բարձրանում է:

Պատվերով սխալների դասերի ժառանգում

Հիմնվելով Օբյեկտ-կողմնորոշված ծրագրավորման (OOP) հայեցակարգի վրա, դուք կարող եք նաև ժառանգել սովորական բացառությունների դասերից, ինչպես սովորական դասերը: Ժառանգելով սովորական բացառությունների դասից՝ դուք կարող եք ստեղծել սխալների դասեր, որոնք ավելի կոնկրետ ենթատեքստ են տրամադրում բացառությանը: Այս մոտեցումը թույլ է տալիս կարգավորել ձեր կոդի տարբեր մակարդակների սխալները և ավելի լավ հասկանալ, թե ինչն է առաջացրել սխալը:

Ասեք, որ դուք մշակում եք վեբ հավելված, որը փոխազդում է արտաքին API-ի հետ: Այս API-ն կարող է ունենալ սխալի տարբեր սցենարներ: Դուք կցանկանաք հետևողականորեն և հստակորեն կարգավորել այս սխալները ձեր կոդի ամբողջ ընթացքում: Դրան հասնելու համար ստեղծեք հատուկ բացառության դաս՝ BaseAPIException:

class BaseAPIException(Exception):
    """Base class for API-related exceptions."""
    def __init__(self, message):
        super().__init__(message)
        self.message = message

Այս բազային հատուկ բացառությունների դասը ունենալուց հետո կարող եք ստեղծել երեխայի բացառության դասեր, որոնք ժառանգում են դրանից.

class APINotFoundError(BaseAPIException):
    """Raised when the requested resource is not found in the API."""
    pass
class APIAuthenticationError(BaseAPIException):
    """Raised when there's an issue with authentication to the API."""
    pass
class APIRateLimitExceeded(BaseAPIException):
    """Raised when the rate limit for API requests is exceeded."""
    pass

Բարձրացրեք և բռնեք այս հատուկ բացառությունները ձեր վեբ հավելվածում API-ին զանգեր կատարելիս: Կառավարեք դրանք համապատասխանաբար՝ օգտագործելով ձեր կոդի համապատասխան տրամաբանությունը:

def request_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}")

Եզրափակիչ դրույթը ստուգում է ծնող դասի դեմ և գործում է որպես բոլորը API-ի հետ կապված այլ սխալների համար:

Երբ դուք ժառանգում եք հատուկ բացառության դասեր, դուք կարող եք արդյունավետորեն կարգավորել սխալները API-ի ներսում: Այս մոտեցումը թույլ է տալիս տարանջատել ձեր սխալների կառավարումը API-ի իրականացման մանրամասներից՝ հեշտացնելով հատուկ բացառություններ ավելացնելը կամ փոփոխություններ կատարելը, երբ API-ն զարգանում է կամ հանդիպում է նոր սխալների դեպքերի:

Փաթաթում Պատվերով Բացառություններ

Բացառությունները փաթաթել նշանակում է բռնել բացառություն, այն ներառել հատուկ բացառության մեջ և այնուհետ բարձրացնել այդ սովորական բացառությունը՝ որպես դրա պատճառ նշելով սկզբնական բացառությունը: Այս տեխնիկան օգնում է ապահովել սխալի հաղորդագրությունների համատեքստը և թաքնված է պահում կատարման մանրամասները զանգի կոդից:

Հաշվի առեք այն սցենարը, որտեղ ձեր վեբ հավելվածը փոխազդում է API-ի հետ: Եթե API-ն բարձրացնում է LookupError, դուք կարող եք բռնել այն, ապա բարձրացրեք հատուկ APINotFoundError բացառություն, որը հղում է կատարում LookupError-ին որպես դրա պատճառ:

def request_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__}")

Օգտագործեք -ից կետ՝ բարձրացնել հայտարարությամբ՝ ձեր հատուկ բացառության մեջ սկզբնական բացառությանը հղում կատարելու համար:

Երբ տեղի է ունենում հատուկ բացառություն, այն ներառում է սկզբնական բացառությունը որպես __cause__ հատկանիշ՝ կապ ապահովելով հատուկ բացառության և բնօրինակի միջև: Սա թույլ է տալիս հետևել բացառության ծագմանը:

Բացառությունները փաթաթելով՝ դուք կարող եք ապահովել ավելի բովանդակալից համատեքստ և օգտատերերին ուղարկել ավելի համապատասխան սխալի հաղորդագրություններ՝ չբացահայտելով ձեր կոդի կամ API-ի ներքին կատարման մանրամասները: Այն նաև թույլ է տալիս համակարգված և միատեսակ կերպով կառավարել և հասցեագրել սխալների տեսակները:

Դասի վարքագծի հարմարեցում Python-ում

Ժառանգելով հիմնական բացառությունների դասը, որը տրամադրում է Python-ը, դուք կարող եք ստեղծել պարզ և օգտակար բացառություններ, որոնք կարող եք բարձրացնել, երբ ձեր կոդում որոշակի սխալներ են տեղի ունենում: Դուք կարող եք նաև կիրառել հատուկ վարքագիծ ձեր բացառության դասերի համար՝ կախարդական կամ դենդեր մեթոդների օգնությամբ: