ਬਿਲਟ-ਇਨ ਐਕਸੈਪਸ਼ਨ¶

Python ਵਿੱਚ, ਸਾਰੇ exception ਉਸ class ਦੇ instance ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ ਜੋ BaseException ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤੀ ਗਈ ਹੋਵੇ। ਕਿਸੇ try statement ਵਿੱਚ ਜੇ except clause ਕਿਸੇ ਖਾਸ class ਦਾ ਜ਼ਿਕਰ ਕਰਦਾ ਹੈ, ਤਾਂ ਉਹ clause ਉਸ class ਤੋਂ ਪ੍ਰਾਪਤ ਹੋਣ ਵਾਲੀਆਂ ਸਾਰੀਆਂ exception classes ਨੂੰ ਵੀ ਸੰਭਾਲਦਾ ਹੈ (ਪਰ ਉਹਨਾਂ classes ਨੂੰ ਨਹੀਂ ਜਿਨ੍ਹਾਂ ਤੋਂ ਉਹ class ਖੁਦ ਪ੍ਰਾਪਤ ਕੀਤੀ ਗਈ ਹੋਵੇ)। ਦੋ exception classes ਜੋ subclassing ਰਾਹੀਂ ਸੰਬੰਧਿਤ ਨਹੀਂ ਹਨ, ਕਦੇ ਵੀ ਇੱਕੋ ਜਿਹੀਆਂ ਨਹੀਂ ਮੰਨੀਆਂ ਜਾਂਦੀਆਂ, ਭਾਵੇਂ ਉਹਨਾਂ ਦਾ ਨਾਮ ਇੱਕੋ ਹੀ ਕਿਉਂ ਨਾ ਹੋਵੇ।

ਇਸ ਅਧਿਆਇ ਵਿੱਚ ਦਿੱਤੇ ਬਿਲਟ-ਇਨ exception interpreter ਜਾਂ built-in functions ਦੁਆਰਾ ਪੈਦਾ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਜਿੱਥੇ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਨਾ ਦੱਸਿਆ ਗਿਆ ਹੋਵੇ, ਉਨ੍ਹਾਂ ਦੇ ਨਾਲ ਇੱਕ "associated value" ਹੁੰਦੀ ਹੈ ਜੋ ਗਲਤੀ ਦੇ ਵਿਸਥਾਰਪੂਰਵਕ ਕਾਰਨ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਇਹ ਇੱਕ string ਜਾਂ ਜਾਣਕਾਰੀ ਦੇ ਕਈ ਤੱਤਾਂ ਵਾਲਾ tuple ਹੋ ਸਕਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ error code ਅਤੇ ਉਸ code ਦੀ ਵਿਆਖਿਆ ਕਰਨ ਵਾਲੀ string)। ਇਹ associated value ਆਮ ਤੌਰ 'ਤੇ exception class ਦੇ constructor ਨੂੰ arguments ਵਜੋਂ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ।

ਯੂਜ਼ਰ ਕੋਡ built-in exceptions ਨੂੰ raise ਕਰ ਸਕਦਾ ਹੈ। ਇਸਦਾ ਉਪਯੋਗ exception handler ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਜਾਂ ਕਿਸੇ error condition ਦੀ ਰਿਪੋਰਟ ਕਰਨ ਲਈ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ ਜਿਵੇਂ interpreter ਉਹੀ exception raise ਕਰਦਾ ਹੈ। ਪਰ ਧਿਆਨ ਰੱਖੋ ਕਿ ਯੂਜ਼ਰ ਕੋਡ ਨੂੰ ਗਲਤ ਜਾਂ ਅਣਉਚਿਤ error raise ਕਰਨ ਤੋਂ ਰੋਕਣ ਲਈ ਕੋਈ ਪ੍ਰਬੰਧ ਨਹੀਂ ਹੈ।

ਨਵੇਂ exception ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ built-in exception classes ਦੀ subclass ਬਣਾਈ ਜਾ ਸਕਦੀ ਹੈ। Programmers ਨੂੰ ਸਲਾਹ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਨਵੇਂ exception Exception class ਜਾਂ ਇਸ ਦੀਆਂ subclasses ਤੋਂ ਪ੍ਰਾਪਤ ਕਰਨ, ਨਾ ਕਿ BaseException ਤੋਂ। Exception ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ Python Tutorial ਦੇ ਵਰਤੋਂਕਾਰ-ਪਰਿਭਾਸ਼ਿਤ Exceptions ਭਾਗ ਵਿੱਚ ਉਪਲਬਧ ਹੈ।

ਐਕਸੈਪਸ਼ਨ ਸੰਦਰਭ¶

Exception objects ਉੱਤੇ ਮੌਜੂਦ ਤਿੰਨ attributes ਉਸ ਸੰਦਰਭ ਬਾਰੇ ਜਾਣਕਾਰੀ ਦਿੰਦੇ ਹਨ ਜਿਸ ਵਿੱਚ exception raise ਕੀਤਾ ਗਿਆ ਸੀ:

BaseException.__context__¶

BaseException.__cause__¶

BaseException.__suppress_context__¶

ਜਦੋਂ ਕਿਸੇ exception ਨੂੰ ਸੰਭਾਲਿਆ ਜਾ ਰਿਹਾ ਹੋਵੇ ਅਤੇ ਉਸ ਦੌਰਾਨ ਕੋਈ ਨਵਾਂ exception raise ਕੀਤਾ ਜਾਵੇ, ਤਾਂ ਨਵੇਂ exception ਦਾ __context__ attribute ਆਪਣੇ ਆਪ ਉਸ exception ਨਾਲ ਸੈੱਟ ਹੋ ਜਾਂਦਾ ਹੈ ਜਿਸਨੂੰ ਸੰਭਾਲਿਆ ਜਾ ਰਿਹਾ ਸੀ। Exception ਨੂੰ except, finally clause ਜਾਂ with statement ਦੀ ਵਰਤੋਂ ਦੌਰਾਨ ਸੰਭਾਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਇਸ ਅਪਰੋਕਸ਼ exception context ਨੂੰ raise ਨਾਲ from ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਪਸ਼ਟ ਕਾਰਨ ਨਾਲ ਵਧਾਇਆ ਜਾ ਸਕਦਾ ਹੈ:

raise new_exc from original_exc

from ਤੋਂ ਬਾਅਦ ਦਿੱਤਾ ਗਿਆ expression ਇੱਕ exception ਜਾਂ None ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ raise ਕੀਤੇ ਗਏ exception ਦੇ __cause__ ਵਜੋਂ ਸੈੱਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। __cause__ ਨੂੰ ਸੈੱਟ ਕਰਨ ਨਾਲ __suppress_context__ attribute ਵੀ ਅਪਰੋਕਸ਼ ਤੌਰ 'ਤੇ True ਹੋ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਕਾਰਨ raise new_exc from None ਦੀ ਵਰਤੋਂ display ਦੇ ਮਕਸਦ ਲਈ ਪੁਰਾਣੇ exception ਨੂੰ ਨਵੇਂ exception ਨਾਲ ਬਦਲ ਦਿੰਦੀ ਹੈ (ਉਦਾਹਰਨ ਲਈ KeyError ਨੂੰ AttributeError ਵਿੱਚ ਬਦਲਣਾ), ਜਦਕਿ debugging ਦੌਰਾਨ ਜਾਂਚ ਲਈ ਪੁਰਾਣਾ exception __context__ ਵਿੱਚ ਉਪਲਬਧ ਰਹਿੰਦਾ ਹੈ।

ਮੂਲ traceback display code exception ਦੇ ਆਪਣੇ traceback ਤੋਂ ਇਲਾਵਾ ਇਹਨਾਂ ਜੁੜੀਆਂ ਹੋਈਆਂ exceptions ਨੂੰ ਵੀ ਦਿਖਾਉਂਦਾ ਹੈ। __cause__ ਵਿੱਚ ਮੌਜੂਦ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਜੁੜੀ exception ਹਮੇਸ਼ਾਂ ਦਿਖਾਈ ਜਾਂਦੀ ਹੈ। __context__ ਵਿੱਚ ਮੌਜੂਦ ਅਪਰੋਕਸ਼ ਤੌਰ 'ਤੇ ਜੁੜੀ exception ਤਦੋਂ ਹੀ ਦਿਖਾਈ ਜਾਂਦੀ ਹੈ ਜਦੋਂ __cause__ ਦੀ value None ਹੋਵੇ ਅਤੇ __suppress_context__ false ਹੋਵੇ।

ਦੋਵੇਂ ਹਾਲਤਾਂ ਵਿੱਚ exception ਖੁਦ ਹਮੇਸ਼ਾਂ ਸਾਰੀਆਂ chained exceptions ਤੋਂ ਬਾਅਦ ਦਿਖਾਈ ਜਾਂਦੀ ਹੈ ਤਾਂ ਜੋ traceback ਦੀ ਆਖਰੀ ਲਾਈਨ ਹਮੇਸ਼ਾਂ ਆਖਰੀ raise ਕੀਤੀ ਗਈ exception ਨੂੰ ਦਰਸਾਏ।

ਬਿਲਟ-ਇਨ ਐਕਸੈਪਸ਼ਨਾਂ ਤੋਂ ਵਿਰਾਸਤ ਲੈਣਾ¶

ਯੂਜ਼ਰ ਕੋਡ ਐਸੀ subclasses ਬਣਾ ਸਕਦਾ ਹੈ ਜੋ ਕਿਸੇ exception type ਤੋਂ ਵਿਰਾਸਤ ਲੈਂਦੀਆਂ ਹਨ। ਇਹ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਕੇਵਲ ਇੱਕ exception type ਦੀ ਹੀ subclass ਬਣਾਈ ਜਾਵੇ, ਤਾਂ ਜੋ args attribute ਨੂੰ ਸੰਭਾਲਣ ਦੇ ਤਰੀਕਿਆਂ ਵਿੱਚ ਸੰਭਾਵਿਤ ਟਕਰਾਵਾਂ ਅਤੇ memory layout ਦੀਆਂ ਅਣਅਨੁਕੂਲਤਾਵਾਂ ਤੋਂ ਬਚਿਆ ਜਾ ਸਕੇ।

ਜ਼ਿਆਦਾਤਰ built-in exceptions ਕੁਸ਼ਲਤਾ ਲਈ C ਵਿੱਚ ਲਾਗੂ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ, ਵੇਖੋ: Objects/exceptions.c। ਕੁਝ exceptions ਦੇ custom memory layouts ਹੁੰਦੇ ਹਨ, ਜਿਸ ਕਾਰਨ ਐਸੀ subclass ਬਣਾਉਣਾ ਸੰਭਵ ਨਹੀਂ ਹੁੰਦਾ ਜੋ ਕਈ exception types ਤੋਂ ਵਿਰਾਸਤ ਲਵੇ। ਕਿਸੇ type ਦਾ memory layout ਇੱਕ implementation detail ਹੈ ਅਤੇ Python ਦੇ ਵੱਖ-ਵੱਖ versions ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਭਵਿੱਖ ਵਿੱਚ ਨਵੇਂ ਟਕਰਾਵ ਪੈਦਾ ਹੋ ਸਕਦੇ ਹਨ। ਇਸ ਲਈ ਆਮ ਤੌਰ 'ਤੇ ਕਈ exception types ਦੀ subclassing ਤੋਂ ਬਚਣ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਬੇਸ ਕਲਾਸਾਂ¶

ਹੇਠਾਂ ਦਿੱਤੀਆਂ exceptions ਮੁੱਖ ਤੌਰ 'ਤੇ ਹੋਰ exceptions ਲਈ base classes ਵਜੋਂ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

exception BaseException¶

ਸਾਰੀਆਂ built-in exceptions ਲਈ base class। ਇਹ user-defined classes ਦੁਆਰਾ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਵਿਰਾਸਤ ਲੈਣ ਲਈ ਨਹੀਂ ਬਣਾਈ ਗਈ (ਇਸ ਲਈ Exception ਦੀ ਵਰਤੋਂ ਕਰੋ)। ਜੇ ਇਸ class ਦੇ ਕਿਸੇ instance ਉੱਤੇ str() ਕਾਲ ਕੀਤਾ ਜਾਵੇ, ਤਾਂ instance ਨੂੰ ਦਿੱਤੇ ਗਏ argument(s) ਦੀ representation ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਾਂ ਜੇ ਕੋਈ arguments ਨਾ ਹੋਣ ਤਾਂ ਖਾਲੀ string ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

args¶: exception constructor ਨੂੰ ਦਿੱਤੀਆਂ ਗਈਆਂ arguments ਦਾ tuple। ਕੁਝ built-in exceptions (ਜਿਵੇਂ OSError) ਇੱਕ ਨਿਰਧਾਰਤ ਗਿਣਤੀ ਦੀਆਂ arguments ਦੀ ਉਮੀਦ ਕਰਦੀਆਂ ਹਨ ਅਤੇ ਇਸ tuple ਦੇ ਤੱਤਾਂ ਨੂੰ ਖਾਸ ਅਰਥ ਦਿੰਦੀਆਂ ਹਨ, ਜਦਕਿ ਹੋਰ exceptions ਆਮ ਤੌਰ 'ਤੇ ਕੇਵਲ ਇੱਕ error message ਵਾਲੀ string ਨਾਲ ਹੀ ਕਾਲ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

with_traceback(tb)¶

ਇਹ method tb ਨੂੰ exception ਲਈ ਨਵੇਂ traceback ਵਜੋਂ ਸੈੱਟ ਕਰਦੀ ਹੈ ਅਤੇ exception object ਵਾਪਸ ਕਰਦੀ ਹੈ। PEP 3134 ਦੀ exception chaining ਵਿਸ਼ੇਸ਼ਤਾ ਉਪਲਬਧ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਇਸਦੀ ਵਰਤੋਂ ਵੱਧ ਕੀਤੀ ਜਾਂਦੀ ਸੀ। ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਨ ਦਿਖਾਉਂਦੀ ਹੈ ਕਿ traceback ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦਿਆਂ SomeException ਦੇ instance ਨੂੰ OtherException ਦੇ instance ਵਿੱਚ ਕਿਵੇਂ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ। raise ਹੋਣ ਉਪਰੰਤ ਮੌਜੂਦਾ frame OtherException ਦੇ traceback ਵਿੱਚ ਸ਼ਾਮਲ ਹੋ ਜਾਂਦੀ ਹੈ, ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ ਜਿਵੇਂ ਮੂਲ SomeException ਦਾ traceback caller ਤੱਕ propagate ਹੋਣ 'ਤੇ ਹੁੰਦਾ।

try:
    ...
except SomeException:
    tb = sys.exception().__traceback__
    raise OtherException(...).with_traceback(tb)

__traceback__¶: ਇੱਕ writable field ਜੋ ਇਸ exception ਨਾਲ ਸੰਬੰਧਿਤ traceback object ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ। ਇਹ ਵੀ ਵੇਖੋ: The raise statement।

add_note(note)¶: string note ਨੂੰ exception ਦੇ notes ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ, ਜੋ standard traceback ਵਿੱਚ exception string ਤੋਂ ਬਾਅਦ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ। ਜੇ note string ਨਾ ਹੋਵੇ ਤਾਂ TypeError raise ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

Added in version 3.11.

__notes__¶: ਇਸ exception ਦੇ notes ਦੀ ਇੱਕ list, ਜੋ add_note() ਨਾਲ ਜੋੜੇ ਗਏ ਹੋਣ। ਇਹ attribute add_note() ਕਾਲ ਹੋਣ 'ਤੇ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ।

Added in version 3.11.

exception Exception¶: ਸਾਰੀਆਂ built-in, non-system-exiting exceptions ਇਸ class ਤੋਂ ਵਿਰਾਸਤ ਲੈਂਦੀਆਂ ਹਨ। ਸਾਰੀਆਂ user-defined exceptions ਨੂੰ ਵੀ ਇਸ class ਤੋਂ ਹੀ ਵਿਰਾਸਤ ਲੈਣੀ ਚਾਹੀਦੀ ਹੈ।

exception ArithmeticError¶: ਉਹਨਾਂ built-in exceptions ਲਈ base class ਜੋ ਵੱਖ-ਵੱਖ arithmetic errors ਲਈ raise ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ: OverflowError, ZeroDivisionError, FloatingPointError।

exception BufferError¶: ਜਦੋਂ ਕਿਸੇ buffer ਨਾਲ ਸੰਬੰਧਿਤ operation ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ, ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

exception LookupError¶: ਉਹ exceptions ਲਈ base class ਜੋ ਤਦੋਂ raise ਹੁੰਦੀਆਂ ਹਨ ਜਦੋਂ mapping ਜਾਂ sequence ਉੱਤੇ ਵਰਤੀ ਗਈ key ਜਾਂ index ਗਲਤ ਹੋਵੇ: IndexError, KeyError। ਇਸਨੂੰ codecs.lookup() ਦੁਆਰਾ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਵੀ raise ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਖਾਸ exceptions¶

ਹੇਠਾਂ ਦਿੱਤੀਆਂ exceptions ਉਹ ਹਨ ਜੋ ਆਮ ਤੌਰ 'ਤੇ raise ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

exception AssertionError¶: ਜਦੋਂ assert statement ਅਸਫਲ ਹੋ ਜਾਂਦੀ ਹੈ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

exception AttributeError¶

ਜਦੋਂ ਕਿਸੇ attribute ਦਾ ਹਵਾਲਾ (ਵੇਖੋ Attribute references) ਜਾਂ assignment ਅਸਫਲ ਹੋ ਜਾਂਦੀ ਹੈ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। (ਜੇ ਕੋਈ object attribute references ਜਾਂ attribute assignments ਨੂੰ ਬਿਲਕੁਲ ਸਮਰਥਨ ਨਹੀਂ ਦਿੰਦਾ, ਤਾਂ TypeError raise ਕੀਤਾ ਜਾਂਦਾ ਹੈ।)

ਵਿਕਲਪਿਕ name ਅਤੇ obj keyword-only arguments ਸੰਬੰਧਿਤ attributes ਸੈੱਟ ਕਰਦੀਆਂ ਹਨ:

name¶: ਉਸ attribute ਦਾ ਨਾਮ ਜਿਸਨੂੰ access ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਗਈ ਸੀ।

obj¶: ਉਹ object ਜਿਸ 'ਤੇ ਦਿੱਤੇ attribute ਨੂੰ access ਕੀਤਾ ਗਿਆ ਸੀ।

Changed in version 3.10: name ਅਤੇ obj attributes ਜੋੜੇ ਗਏ।

exception EOFError¶: ਜਦੋਂ input() function ਕੋਈ ਡਾਟਾ ਪੜ੍ਹੇ ਬਿਨਾਂ end-of-file (EOF) ਸਥਿਤੀ 'ਤੇ ਪਹੁੰਚ ਜਾਂਦੀ ਹੈ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। (ਨੋਟ: io.TextIOBase.read() ਅਤੇ io.IOBase.readline() methods EOF ਮਿਲਣ 'ਤੇ ਖਾਲੀ string ਵਾਪਸ ਕਰਦੀਆਂ ਹਨ।)

exception FloatingPointError¶: ਵਰਤਮਾਨ ਵਿੱਚ ਵਰਤੀ ਨਹੀਂ ਜਾਂਦੀ।

exception GeneratorExit¶: ਜਦੋਂ ਕਿਸੇ generator ਜਾਂ coroutine ਨੂੰ ਬੰਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ; ਵੇਖੋ generator.close() ਅਤੇ coroutine.close()। ਇਹ Exception ਦੀ ਬਜਾਏ ਸਿੱਧੇ BaseException ਤੋਂ ਵਿਰਾਸਤ ਲੈਂਦੀ ਹੈ ਕਿਉਂਕਿ ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ ਇਹ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੈ।

exception ImportError¶

ਜਦੋਂ import statement ਨੂੰ module ਲੋਡ ਕਰਨ ਵਿੱਚ ਸਮੱਸਿਆ ਆਉਂਦੀ ਹੈ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਉਸ ਵੇਲੇ ਵੀ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ from ... import ਦੀ "from list" ਵਿੱਚ ਦਿੱਤਾ ਨਾਮ ਨਹੀਂ ਲੱਭਦਾ।

ਵਿਕਲਪਿਕ name ਅਤੇ path keyword-only arguments ਸੰਬੰਧਿਤ attributes ਸੈੱਟ ਕਰਦੀਆਂ ਹਨ:

name¶: ਉਸ module ਦਾ ਨਾਮ ਜਿਸਨੂੰ import ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਗਈ ਸੀ।

path¶: ਉਸ ਫਾਈਲ ਦਾ path ਜਿਸ ਕਾਰਨ ਇਹ exception trigger ਹੋਈ।

Changed in version 3.3: name ਅਤੇ path attributes ਜੋੜੇ ਗਏ।

exception ModuleNotFoundError¶: ImportError ਦੀ ਇੱਕ subclass ਜੋ import ਦੁਆਰਾ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਕੋਈ module ਲੱਭਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ। ਇਹ ਉਸ ਵੇਲੇ ਵੀ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ sys.modules ਵਿੱਚ None ਮਿਲਦਾ ਹੈ।

Added in version 3.6.

exception ImportCycleError¶: ImportError ਦੀ ਇੱਕ subclass ਜੋ ਉਸ ਵੇਲੇ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ lazy import ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਉਹ (ਸਿੱਧੇ ਜਾਂ ਅਸਿੱਧੇ ਤੌਰ 'ਤੇ) ਆਪਣੇ ਆਪ ਨੂੰ ਹੀ import ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ।

Added in version 3.15.

exception IndexError¶: ਜਦੋਂ sequence ਦਾ subscript ਸੀਮਾ ਤੋਂ ਬਾਹਰ ਹੋਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। (Slice indices ਨੂੰ ਚੁੱਪਚਾਪ ਮਨਜ਼ੂਰਸ਼ੁਦਾ ਸੀਮਾ ਵਿੱਚ ਕੱਟ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ; ਜੇ index integer ਨਾ ਹੋਵੇ ਤਾਂ TypeError raise ਕੀਤਾ ਜਾਂਦਾ ਹੈ।)

exception KeyError¶: ਜਦੋਂ mapping (dictionary) ਦੀ key ਮੌਜੂਦਾ keys ਦੇ ਸਮੂਹ ਵਿੱਚ ਨਹੀਂ ਮਿਲਦੀ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

exception KeyboardInterrupt¶: ਜਦੋਂ ਉਪਭੋਗਤਾ interrupt key (ਆਮ ਤੌਰ 'ਤੇ Control-C ਜਾਂ Delete) ਦਬਾਉਂਦਾ ਹੈ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਚਲਾਉਣ ਦੌਰਾਨ interrupts ਲਈ ਨਿਯਮਿਤ ਤੌਰ 'ਤੇ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ exception BaseException ਤੋਂ ਵਿਰਾਸਤ ਲੈਂਦੀ ਹੈ ਤਾਂ ਜੋ Exception ਨੂੰ catch ਕਰਨ ਵਾਲਾ code ਇਸਨੂੰ ਗਲਤੀ ਨਾਲ ਨਾ ਫੜ ਲਵੇ ਅਤੇ interpreter ਦੇ ਬੰਦ ਹੋਣ ਨੂੰ ਨਾ ਰੋਕੇ।

Note

KeyboardInterrupt ਨੂੰ catch ਕਰਨ ਲਈ ਖਾਸ ਧਿਆਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਕਿਉਂਕਿ ਇਹ ਅਣਅੰਦਾਜ਼ੇ ਵਾਲੇ ਸਮੇਂ 'ਤੇ raise ਹੋ ਸਕਦੀ ਹੈ, ਕੁਝ ਹਾਲਾਤਾਂ ਵਿੱਚ ਇਹ ਚੱਲ ਰਹੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਅਸੰਗਤ ਹਾਲਤ ਵਿੱਚ ਛੱਡ ਸਕਦੀ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ ਕਿ KeyboardInterrupt ਨੂੰ ਜਿੰਨੀ ਜਲਦੀ ਹੋ ਸਕੇ ਪ੍ਰੋਗਰਾਮ ਖਤਮ ਕਰਨ ਦਿੱਤਾ ਜਾਵੇ ਜਾਂ ਇਸਨੂੰ catch ਕਰਨ ਤੋਂ ਬਚਿਆ ਜਾਵੇ। (ਵੇਖੋ Note on Signal Handlers and Exceptions)।

exception MemoryError¶: ਜਦੋਂ ਕੋਈ operation memory ਤੋਂ ਖਾਲੀ ਹੋ ਜਾਂਦੀ ਹੈ ਪਰ ਹਾਲਾਤ ਅਜੇ ਵੀ ਠੀਕ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ (ਕੁਝ objects ਨੂੰ ਮਿਟਾ ਕੇ), ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਨਾਲ ਸੰਬੰਧਿਤ value ਇੱਕ string ਹੁੰਦੀ ਹੈ ਜੋ ਦੱਸਦੀ ਹੈ ਕਿ ਕਿਹੜੀ (ਅੰਦਰੂਨੀ) operation memory ਤੋਂ ਖਾਲੀ ਹੋ ਗਈ। ਧਿਆਨ ਦਿਓ ਕਿ ਅਧਾਰਭੂਤ memory management architecture (C ਦੀ malloc() function) ਕਾਰਨ interpreter ਹਮੇਸ਼ਾਂ ਪੂਰੀ ਤਰ੍ਹਾਂ recover ਨਹੀਂ ਕਰ ਸਕਦਾ; ਫਿਰ ਵੀ ਇਹ exception raise ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ stack traceback ਪ੍ਰਿੰਟ ਕੀਤਾ ਜਾ ਸਕੇ ਜੇ ਕਾਰਨ ਕੋਈ ਬੇਕਾਬੂ ਪ੍ਰੋਗਰਾਮ ਹੋਵੇ।

exception NameError¶

ਜਦੋਂ ਕੋਈ local ਜਾਂ global ਨਾਮ ਨਹੀਂ ਲੱਭਦਾ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਸਿਰਫ਼ unqualified names 'ਤੇ ਲਾਗੂ ਹੁੰਦੀ ਹੈ। ਇਸ ਨਾਲ ਸੰਬੰਧਿਤ value ਇੱਕ error message ਹੁੰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਉਹ ਨਾਮ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ ਜੋ ਨਹੀਂ ਲੱਭਿਆ ਜਾ ਸਕਿਆ।

ਵਿਕਲਪਿਕ name keyword-only argument ਹੇਠਾਂ ਦਿੱਤਾ attribute ਸੈੱਟ ਕਰਦਾ ਹੈ:

name¶: ਉਸ variable ਦਾ ਨਾਮ ਜਿਸਨੂੰ access ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਗਈ ਸੀ।

Changed in version 3.10: name attribute ਜੋੜਿਆ ਗਿਆ।

exception NotImplementedError¶: ਇਹ exception RuntimeError ਤੋਂ ਵਿਰਾਸਤ ਲੈਂਦੀ ਹੈ। User-defined base classes ਵਿੱਚ abstract methods ਨੂੰ ਇਹ exception raise ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਜਦੋਂ derived classes ਨੂੰ method override ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇ ਜਾਂ ਜਦੋਂ class ਵਿਕਾਸ ਅਧੀਨ ਹੋਵੇ ਅਤੇ ਅਸਲ implementation ਅਜੇ ਜੋੜਨੀ ਬਾਕੀ ਹੋਵੇ।

Note

ਇਸਦੀ ਵਰਤੋਂ ਇਹ ਦਰਸਾਉਣ ਲਈ ਨਹੀਂ ਕਰਨੀ ਚਾਹੀਦੀ ਕਿ ਕੋਈ operator ਜਾਂ method ਬਿਲਕੁਲ ਵੀ ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ। ਉਸ ਹਾਲਤ ਵਿੱਚ operator / method ਨੂੰ undefined ਛੱਡੋ ਜਾਂ, ਜੇ subclass ਹੋਵੇ, ਤਾਂ ਇਸਨੂੰ None ਸੈੱਟ ਕਰੋ।

Caution

NotImplementedError ਅਤੇ NotImplemented ਇੱਕ-ਦੂਜੇ ਦੇ ਬਦਲੇ ਨਹੀਂ ਵਰਤੇ ਜਾ ਸਕਦੇ। ਇਸ exception ਦੀ ਵਰਤੋਂ ਸਿਰਫ਼ ਉਪਰ ਦਿੱਤੇ ਤਰੀਕੇ ਨਾਲ ਹੀ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ; built-in constant ਦੀ ਸਹੀ ਵਰਤੋਂ ਬਾਰੇ ਵੇਰਵੇ ਲਈ NotImplemented ਵੇਖੋ।

exception OSError([arg])¶

exception OSError(errno, strerror[, filename[, winerror[, filename2]]])

ਇਹ exception ਤਦੋਂ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਕੋਈ system function system-ਸੰਬੰਧਿਤ ਗਲਤੀ ਵਾਪਸ ਕਰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ I/O ਅਸਫਲਤਾਵਾਂ ਜਿਵੇਂ "file not found" ਜਾਂ "disk full" ਸ਼ਾਮਲ ਹਨ (ਗਲਤ argument types ਜਾਂ ਹੋਰ ਸਹਾਇਕ ਗਲਤੀਆਂ ਲਈ ਨਹੀਂ)।

Constructor ਦਾ ਦੂਜਾ ਰੂਪ ਹੇਠਾਂ ਵਰਣਿਤ ਸੰਬੰਧਿਤ attributes ਸੈੱਟ ਕਰਦਾ ਹੈ। ਜੇ attributes ਨਿਰਧਾਰਤ ਨਾ ਕੀਤੇ ਜਾਣ ਤਾਂ ਉਹਨਾਂ ਦੀ ਮੂਲ value None ਹੁੰਦੀ ਹੈ। ਪਿਛਲੀ ਅਨੁਕੂਲਤਾ ਲਈ, ਜੇ ਤਿੰਨ arguments ਦਿੱਤੇ ਜਾਣ, ਤਾਂ args attribute ਵਿੱਚ ਸਿਰਫ਼ ਪਹਿਲੇ ਦੋ constructor arguments ਵਾਲਾ 2-tuple ਹੀ ਹੁੰਦਾ ਹੈ।

Constructor ਅਕਸਰ ਅਸਲ ਵਿੱਚ OSError ਦੀ ਕੋਈ subclass ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਹੇਠਾਂ OS exceptions ਵਿੱਚ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ। ਖਾਸ subclass ਅੰਤਿਮ errno value 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ। ਇਹ ਵਿਹਾਰ ਕੇਵਲ OSError ਨੂੰ ਸਿੱਧੇ ਜਾਂ alias ਰਾਹੀਂ ਬਣਾਉਣ ਵੇਲੇ ਹੁੰਦਾ ਹੈ ਅਤੇ subclassing ਦੌਰਾਨ ਵਿਰਾਸਤ ਵਿੱਚ ਨਹੀਂ ਮਿਲਦਾ।

errno¶: C variable errno ਤੋਂ ਮਿਲਿਆ ਇੱਕ ਸੰਖਿਆਤਮਕ error code।

winerror¶

Windows ਵਿੱਚ ਇਹ ਤੁਹਾਨੂੰ native Windows error code ਦਿੰਦਾ ਹੈ। errno attribute ਫਿਰ ਉਸ native error code ਦਾ POSIX ਅਨੁਸਾਰ ਇੱਕ ਅੰਦਾਜ਼ਨ ਅਨੁਵਾਦ ਹੁੰਦਾ ਹੈ।

Windows ਵਿੱਚ, ਜੇ winerror constructor argument ਇੱਕ integer ਹੋਵੇ, ਤਾਂ errno attribute Windows error code ਤੋਂ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ errno argument ਨੂੰ ਅਣਡਿੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਹੋਰ platforms 'ਤੇ winerror argument ਨੂੰ ਅਣਡਿੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ winerror attribute ਮੌਜੂਦ ਨਹੀਂ ਹੁੰਦਾ।

strerror¶: Operating system ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤਾ ਗਿਆ ਸੰਬੰਧਿਤ error message। POSIX ਵਿੱਚ ਇਸਨੂੰ C function perror() ਅਤੇ Windows ਵਿੱਚ FormatMessage() ਦੁਆਰਾ format ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

filename¶
filename2¶: ਜਿਨ੍ਹਾਂ exceptions ਵਿੱਚ file system path ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ (ਜਿਵੇਂ open() ਜਾਂ os.unlink()), ਉਨ੍ਹਾਂ ਵਿੱਚ filename ਉਹ file name ਹੁੰਦਾ ਹੈ ਜੋ function ਨੂੰ ਦਿੱਤਾ ਗਿਆ ਸੀ। ਜਿਹੜੀਆਂ functions ਵਿੱਚ ਦੋ file system paths ਹੁੰਦੇ ਹਨ (ਜਿਵੇਂ os.rename()), ਉਨ੍ਹਾਂ ਵਿੱਚ filename2 ਦੂਜੇ file name ਦੇ ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ।

Changed in version 3.3: EnvironmentError, IOError, WindowsError, socket.error, select.error ਅਤੇ mmap.error ਨੂੰ OSError ਵਿੱਚ ਮਿਲਾ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਅਤੇ constructor ਇੱਕ subclass ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ।

Changed in version 3.4: filename attribute ਹੁਣ function ਨੂੰ ਦਿੱਤਾ ਗਿਆ ਮੂਲ file name ਰੱਖਦਾ ਹੈ, ਨਾ ਕਿ ਉਹ ਨਾਮ ਜੋ filesystem encoding and error handler ਰਾਹੀਂ encode ਜਾਂ decode ਕੀਤਾ ਗਿਆ ਹੋਵੇ। ਇਸਦੇ ਨਾਲ filename2 constructor argument ਅਤੇ attribute ਵੀ ਜੋੜੇ ਗਏ ਹਨ।

exception OverflowError¶: ਜਦੋਂ ਕਿਸੇ arithmetic operation ਦਾ ਨਤੀਜਾ ਦਰਸਾਏ ਜਾਣ ਲਈ ਬਹੁਤ ਵੱਡਾ ਹੋਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ integers ਲਈ ਨਹੀਂ ਹੁੰਦਾ (ਉਹ ਇਸਦੀ ਥਾਂ MemoryError raise ਕਰਨਗੇ)। ਹਾਲਾਂਕਿ ਇਤਿਹਾਸਕ ਕਾਰਨਾਂ ਕਰਕੇ, ਕਈ ਵਾਰ ਲੋੜੀਂਦੀ ਸੀਮਾ ਤੋਂ ਬਾਹਰ ਵਾਲੇ integers ਲਈ ਵੀ OverflowError raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। C ਵਿੱਚ floating-point exception handling ਦੇ ਮਿਆਰੀਕਰਨ ਦੀ ਘਾਟ ਕਾਰਨ ਜ਼ਿਆਦਾਤਰ floating-point operations ਦੀ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ।

exception PythonFinalizationError¶

ਇਹ exception RuntimeError ਤੋਂ ਵਿਰਾਸਤ ਲੈਂਦੀ ਹੈ। ਇਹ ਤਦੋਂ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ interpreter shutdown, ਜਿਸਨੂੰ Python finalization ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਦੌਰਾਨ ਕੋਈ operation ਰੋਕ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ।

ਉਹ operations ਜਿਨ੍ਹਾਂ ਨੂੰ Python finalization ਦੌਰਾਨ PythonFinalizationError ਨਾਲ ਰੋਕਿਆ ਜਾ ਸਕਦਾ ਹੈ:

ਨਵਾਂ Python thread ਬਣਾਉਣਾ।
ਚੱਲ ਰਹੇ daemon thread ਨੂੰ Joining ਕਰਨਾ।
os.fork(),
threading.Lock ਵਰਗਾ lock ਪ੍ਰਾਪਤ ਕਰਨਾ, ਜਦੋਂ ਇਹ ਪਤਾ ਹੋਵੇ ਕਿ ਨਹੀਂ ਤਾਂ operation deadlock ਵਿੱਚ ਫਸ ਜਾਵੇਗੀ।

ਇਸ ਨਾਲ ਸੰਬੰਧਿਤ sys.is_finalizing() function ਵੀ ਵੇਖੋ।

Added in version 3.13: ਪਹਿਲਾਂ ਇੱਕ ਸਧਾਰਣ RuntimeError raise ਕੀਤੀ ਜਾਂਦੀ ਸੀ।

Changed in version 3.14: threading.Thread.join() ਹੁਣ ਇਹ exception raise ਕਰ ਸਕਦੀ ਹੈ।

Changed in version 3.15: threading.Lock() ਜਾਂ threading.RLock() ਪ੍ਰਾਪਤ ਕਰਨ ਵੇਲੇ ਇਹ exception raise ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

exception RecursionError¶: ਇਹ exception RuntimeError ਤੋਂ ਵਿਰਾਸਤ ਲੈਂਦੀ ਹੈ। ਇਹ ਤਦੋਂ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ interpreter ਇਹ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ ਕਿ recursion ਦੀ ਅਧਿਕਤਮ ਗਹਿਰਾਈ (sys.getrecursionlimit() ਵੇਖੋ) ਪਾਰ ਹੋ ਗਈ ਹੈ।

Added in version 3.5: ਪਹਿਲਾਂ ਇੱਕ ਸਧਾਰਣ RuntimeError raise ਕੀਤੀ ਜਾਂਦੀ ਸੀ।

exception ReferenceError¶: ਇਹ exception ਤਦੋਂ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ weakref.proxy() function ਦੁਆਰਾ ਬਣਾਇਆ ਗਿਆ weak reference proxy, referent ਦੇ garbage collect ਹੋ ਜਾਣ ਤੋਂ ਬਾਅਦ ਉਸਦੀ ਕਿਸੇ attribute ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। weak references ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ weakref module ਵੇਖੋ।

exception RuntimeError¶: ਜਦੋਂ ਅਜਿਹੀ ਗਲਤੀ ਮਿਲਦੀ ਹੈ ਜੋ ਹੋਰ ਕਿਸੇ ਵੀ ਸ਼੍ਰੇਣੀ ਵਿੱਚ ਨਹੀਂ ਆਉਂਦੀ, ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਨਾਲ ਜੁੜੀ value ਇੱਕ string ਹੁੰਦੀ ਹੈ ਜੋ ਦੱਸਦੀ ਹੈ ਕਿ ਅਸਲ ਵਿੱਚ ਕੀ ਗਲਤ ਹੋਇਆ।

exception StopIteration¶

Built-in function next() ਅਤੇ iterator ਦੀ __next__() method ਦੁਆਰਾ ਇਹ ਸੰਕੇਤ ਦੇਣ ਲਈ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ iterator ਵੱਲੋਂ ਹੋਰ ਕੋਈ items ਉਤਪੰਨ ਨਹੀਂ ਕੀਤੇ ਜਾਣਗੇ।

value¶: Exception object ਵਿੱਚ ਇੱਕੋ attribute value ਹੁੰਦਾ ਹੈ, ਜੋ exception ਬਣਾਉਂਦੇ ਸਮੇਂ argument ਵਜੋਂ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੂਲ ਰੂਪ ਵਿੱਚ None ਹੁੰਦਾ ਹੈ।

ਜਦੋਂ ਕੋਈ generator ਜਾਂ coroutine function ਵਾਪਸ return ਕਰਦੀ ਹੈ, ਤਾਂ ਇੱਕ ਨਵਾਂ StopIteration instance raise ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ function ਵੱਲੋਂ ਵਾਪਸ ਕੀਤੀ ਗਈ value ਨੂੰ exception ਦੇ constructor ਵਿੱਚ value parameter ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਜੇ generator code ਸਿੱਧੇ ਜਾਂ ਅਸਿੱਧੇ ਤੌਰ 'ਤੇ StopIteration raise ਕਰਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ RuntimeError ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ (ਜਿੱਥੇ StopIteration ਨਵੇਂ exception ਦੇ cause ਵਜੋਂ ਕਾਇਮ ਰਹਿੰਦੀ ਹੈ)।

Changed in version 3.3: value attribute ਅਤੇ generator functions ਲਈ ਇਸਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੋਈ value return ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਜੋੜੀ ਗਈ।

Changed in version 3.5: from __future__ import generator_stop ਰਾਹੀਂ RuntimeError transformation ਪੇਸ਼ ਕੀਤੀ ਗਈ, ਵੇਖੋ PEP 479।

Changed in version 3.7: ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਾਰੇ code ਲਈ PEP 479 ਨੂੰ ਸਮਰੱਥ ਕੀਤਾ ਗਿਆ: generator ਵਿੱਚ raise ਹੋਈ StopIteration ਗਲਤੀ ਨੂੰ RuntimeError ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।

exception StopAsyncIteration¶: Iteration ਨੂੰ ਰੋਕਣ ਲਈ asynchronous iterator object ਦੀ __anext__() method ਵੱਲੋਂ ਇਹ raise ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ।

Added in version 3.5.

exception SyntaxError(message, details)¶

ਜਦੋਂ parser ਨੂੰ syntax error ਮਿਲਦੀ ਹੈ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ import statement ਵਿੱਚ, built-in functions compile(), exec(), ਜਾਂ eval() ਦੀ call ਦੌਰਾਨ, ਜਾਂ ਸ਼ੁਰੂਆਤੀ script ਜਾਂ standard input ਪੜ੍ਹਦੇ ਸਮੇਂ (interactive ਤਰੀਕੇ ਨਾਲ ਵੀ) ਹੋ ਸਕਦੀ ਹੈ।

Exception instance ਦਾ str() ਸਿਰਫ਼ error message ਵਾਪਸ ਕਰਦਾ ਹੈ। Details ਇੱਕ tuple ਹੈ ਜਿਸਦੇ members ਵੱਖਰੇ attributes ਵਜੋਂ ਵੀ ਉਪਲਬਧ ਹੁੰਦੇ ਹਨ।

filename¶: ਉਸ file ਦਾ ਨਾਮ ਜਿਸ ਵਿੱਚ syntax error ਆਈ ਸੀ।

lineno¶: File ਵਿੱਚ ਉਹ line number ਜਿੱਥੇ error ਆਈ ਸੀ। ਇਹ 1-indexed ਹੈ: file ਦੀ ਪਹਿਲੀ line ਦਾ lineno 1 ਹੁੰਦਾ ਹੈ।

offset¶: Line ਵਿੱਚ ਉਹ column ਜਿੱਥੇ error ਆਈ ਸੀ। ਇਹ 1-indexed ਹੈ: line ਦੇ ਪਹਿਲੇ ਅੱਖਰ ਦਾ offset 1 ਹੁੰਦਾ ਹੈ।

text¶: ਗਲਤੀ ਨਾਲ ਸੰਬੰਧਿਤ source code ਦਾ ਪਾਠ।

end_lineno¶: File ਵਿੱਚ ਉਹ line number ਜਿੱਥੇ error ਖਤਮ ਹੁੰਦੀ ਹੈ। ਇਹ 1-indexed ਹੈ: file ਦੀ ਪਹਿਲੀ line ਦਾ lineno 1 ਹੁੰਦਾ ਹੈ।

end_offset¶: ਅੰਤਿਮ line ਵਿੱਚ ਉਹ column ਜਿੱਥੇ error ਖਤਮ ਹੁੰਦੀ ਹੈ। ਇਹ 1-indexed ਹੈ: line ਦੇ ਪਹਿਲੇ ਅੱਖਰ ਦਾ offset 1 ਹੁੰਦਾ ਹੈ।

f-string fields ਵਿੱਚ errors ਲਈ message ਦੇ ਅੱਗੇ "f-string: " ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ offsets ਉਸ text ਦੇ offsets ਹੁੰਦੇ ਹਨ ਜੋ replacement expression ਤੋਂ ਬਣਾਇਆ ਗਿਆ ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, f'Bad {a b} field' compile ਕਰਨ ਨਾਲ ਇਹ args attribute ਮਿਲਦਾ ਹੈ: ('f-string: ...', ('', 1, 2, '(a b)n', 1, 5))।

Changed in version 3.10: end_lineno ਅਤੇ end_offset attributes ਜੋੜੇ ਗਏ।

exception IndentationError¶: ਗਲਤ indentation ਨਾਲ ਸੰਬੰਧਿਤ syntax errors ਲਈ base class। ਇਹ SyntaxError ਦੀ subclass ਹੈ।

exception TabError¶: ਜਦੋਂ indentation ਵਿੱਚ tabs ਅਤੇ spaces ਦੀ ਅਸੰਗਤ ਵਰਤੋਂ ਹੋਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ IndentationError ਦੀ subclass ਹੈ।

exception SystemError¶

ਜਦੋਂ interpreter ਨੂੰ ਕੋਈ ਅੰਦਰੂਨੀ error ਮਿਲਦੀ ਹੈ ਪਰ ਸਥਿਤੀ ਇੰਨੀ ਗੰਭੀਰ ਨਹੀਂ ਲੱਗਦੀ ਕਿ ਉਹ ਕੰਮ ਕਰਨਾ ਛੱਡ ਦੇਵੇ, ਤਦ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਨਾਲ ਜੁੜੀ value ਇੱਕ string ਹੁੰਦੀ ਹੈ ਜੋ ਦੱਸਦੀ ਹੈ ਕਿ ਕੀ ਗਲਤ ਹੋਇਆ (low-level terms ਵਿੱਚ)। CPython ਵਿੱਚ ਇਹ Python ਦੀ C API ਦੀ ਗਲਤ ਵਰਤੋਂ ਕਾਰਨ ਹੋ ਸਕਦੀ ਹੈ, ਜਿਵੇਂ exception set ਕੀਤੇ ਬਿਨਾਂ NULL value return ਕਰਨਾ।

ਜੇ ਤੁਹਾਨੂੰ ਯਕੀਨ ਹੈ ਕਿ ਇਹ exception ਤੁਹਾਡੀ ਜਾਂ ਤੁਹਾਡੇ ਵਰਤੇ ਜਾ ਰਹੇ package ਦੀ ਗਲਤੀ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਸਦੀ ਰਿਪੋਰਟ ਆਪਣੇ Python interpreter ਦੇ author ਜਾਂ maintainer ਨੂੰ ਕਰੋ। Python interpreter ਦਾ version (sys.version), ਸਹੀ error message (exception ਨਾਲ ਜੁੜੀ value) ਅਤੇ ਸੰਭਵ ਹੋਵੇ ਤਾਂ ਉਹ source program ਵੀ ਸ਼ਾਮਲ ਕਰੋ ਜਿਸਨੇ ਇਹ error ਪੈਦਾ ਕੀਤੀ।

exception SystemExit¶

ਇਹ ਐਕਸੈਪਸ਼ਨ sys.exit() ਫੰਕਸ਼ਨ ਵੱਲੋਂ ਉਠਾਈ ਜਾਂਦੀ ਹੈ। ਇਹ Exception ਦੀ ਥਾਂ BaseException ਤੋਂ ਵਿਰਾਸਤ ਕਰਦੀ ਹੈ, ਤਾਂ ਜੋ ਇਹ Exception ਫੜਨ ਵਾਲੇ ਕੋਡ ਵੱਲੋਂ ਗਲਤੀ ਨਾਲ ਫੜੀ ਨਾ ਜਾਵੇ। ਇਸ ਨਾਲ ਐਕਸੈਪਸ਼ਨ ਠੀਕ ਤਰੀਕੇ ਨਾਲ ਉੱਪਰ ਤੱਕ ਪਹੁੰਚਦੀ ਹੈ ਅਤੇ ਇੰਟਰਪ੍ਰੇਟਰ ਨੂੰ ਬੰਦ ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰਦੀ ਹੈ। ਜਦੋਂ ਇਸਨੂੰ ਹੈਂਡਲ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ, ਤਾਂ ਪਾਈਥਨ ਇੰਟਰਪ੍ਰੇਟਰ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ; ਕੋਈ ਸਟੈਕ ਟਰੇਸਬੈਕ ਨਹੀਂ ਛਾਪਿਆ ਜਾਂਦਾ। ਕੰਸਟ੍ਰਕਟਰ ਉਹੀ ਵਿਕਲਪੀ ਤਰਕ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਜੋ sys.exit() ਨੂੰ ਦਿੱਤਾ ਗਿਆ ਸੀ। ਜੇ ਇਹ ਮੁੱਲ ਇੰਟਿਜਰ ਹੈ, ਤਾਂ ਇਹ ਸਿਸਟਮ ਨਿਕਾਸ ਸਥਿਤੀ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ (C ਦੇ exit() ਫੰਕਸ਼ਨ ਨੂੰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ); ਜੇ ਇਹ None ਹੈ, ਤਾਂ ਨਿਕਾਸ ਸਥਿਤੀ ਜ਼ੀਰੋ ਹੁੰਦੀ ਹੈ; ਜੇ ਇਹ ਕਿਸੇ ਹੋਰ ਕਿਸਮ (ਜਿਵੇਂ ਕਿ ਸਟਰਿੰਗ) ਦੀ ਹੈ, ਤਾਂ ਆਬਜੈਕਟ ਦਾ ਮੁੱਲ ਪ੍ਰਿੰਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਨਿਕਾਸ ਸਥਿਤੀ ਇੱਕ ਹੁੰਦੀ ਹੈ।

sys.exit() ਨੂੰ ਕਾਲ ਕਰਨ ਨੂੰ ਇੱਕ ਐਕਸੈਪਸ਼ਨ ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਸਾਫ਼-ਸਫ਼ਾਈ ਹੈਂਡਲਰ (finally ਕਲੌਜ਼ਾਂ ਜੋ try ਬਿਆਨਾਂ ਵਿੱਚ ਹੁੰਦੀਆਂ ਹਨ) ਚਲਾਏ ਜਾ ਸਕਣ, ਅਤੇ ਡੀਬੱਗਰ ਬਿਨਾਂ ਕੰਟਰੋਲ ਗੁਆਉਣ ਦੇ ਖਤਰੇ ਦੇ ਸਕ੍ਰਿਪਟ ਚਲਾ ਸਕੇ। ਜੇ ਤੁਰੰਤ ਬਾਹਰ ਨਿਕਲਣਾ ਬਿਲਕੁਲ ਜ਼ਰੂਰੀ ਹੋਵੇ (ਉਦਾਹਰਨ ਵਜੋਂ, os.fork() ਨੂੰ ਕਾਲ ਕਰਨ ਤੋਂ ਬਾਅਦ ਚਾਈਲਡ ਪ੍ਰੋਸੈਸ ਵਿੱਚ), ਤਾਂ os._exit() ਫੰਕਸ਼ਨ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

code¶: Constructor ਨੂੰ ਦਿੱਤਾ ਗਿਆ exit status ਜਾਂ error message। (ਮੂਲ ਰੂਪ ਵਿੱਚ None ਹੁੰਦਾ ਹੈ।)

exception TypeError¶

ਜਦੋਂ ਕੋਈ operation ਜਾਂ function ਗਲਤ type ਦੇ object 'ਤੇ ਲਾਗੂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਨਾਲ ਜੁੜੀ value ਇੱਕ string ਹੁੰਦੀ ਹੈ ਜੋ type mismatch ਬਾਰੇ ਜਾਣਕਾਰੀ ਦਿੰਦੀ ਹੈ।

ਇਹ exception user code ਵੱਲੋਂ ਇਹ ਦਰਸਾਉਣ ਲਈ raise ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਕਿ object ਉੱਤੇ ਕੀਤੀ ਗਈ operation ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ। ਜੇ object ਨੂੰ ਕਿਸੇ operation ਨੂੰ support ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਪਰ implementation ਹਾਲੇ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਤਾਂ NotImplementedError raise ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।

ਗਲਤ type ਦੇ arguments (ਜਿਵੇਂ int ਦੀ ਉਮੀਦ ਹੋਣ 'ਤੇ list ਦੇਣਾ) TypeError ਪੈਦਾ ਕਰਦੇ ਹਨ, ਜਦਕਿ ਸਹੀ type ਪਰ ਗਲਤ value (ਜਿਵੇਂ ਉਮੀਦ ਕੀਤੀ ਸੀਮਾ ਤੋਂ ਬਾਹਰ ਕੋਈ number) ValueError ਪੈਦਾ ਕਰਦੀ ਹੈ।

exception UnboundLocalError¶: ਜਦੋਂ function ਜਾਂ method ਵਿੱਚ ਕਿਸੇ local variable ਦਾ ਹਵਾਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਪਰ ਉਸ variable ਨਾਲ ਕੋਈ value bind ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੁੰਦੀ, ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ NameError ਦੀ subclass ਹੈ।

exception UnicodeError¶

ਜਦੋਂ Unicode ਨਾਲ ਸੰਬੰਧਿਤ encoding ਜਾਂ decoding error ਆਉਂਦੀ ਹੈ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ValueError ਦੀ subclass ਹੈ।

UnicodeError ਵਿੱਚ ਉਹ attributes ਹੁੰਦੇ ਹਨ ਜੋ encoding ਜਾਂ decoding error ਦਾ ਵੇਰਵਾ ਦਿੰਦੇ ਹਨ। ਉਦਾਹਰਨ ਵਜੋਂ err.object[err.start:err.end] ਉਹ invalid input ਦਿੰਦਾ ਹੈ ਜਿਸ 'ਤੇ codec ਅਸਫਲ ਹੋਇਆ ਸੀ।

encoding¶: ਉਸ encoding ਦਾ ਨਾਮ ਜਿਸਨੇ error ਪੈਦਾ ਕੀਤੀ।

reason¶: ਇੱਕ string ਜੋ ਖਾਸ codec error ਦਾ ਵੇਰਵਾ ਦਿੰਦੀ ਹੈ।

object¶: ਉਹ object ਜਿਸਨੂੰ codec encode ਜਾਂ decode ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਸੀ।

start¶

object ਵਿੱਚ invalid data ਦਾ ਪਹਿਲਾ index।

ਇਹ value negative ਨਹੀਂ ਹੋਣੀ ਚਾਹੀਦੀ ਕਿਉਂਕਿ ਇਸਨੂੰ absolute offset ਵਜੋਂ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ, ਪਰ runtime ਦੌਰਾਨ ਇਸ ਪਾਬੰਦੀ ਨੂੰ ਲਾਗੂ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ।

end¶

object ਵਿੱਚ ਆਖਰੀ invalid data ਤੋਂ ਬਾਅਦ ਵਾਲਾ index।

ਇਹ value negative ਨਹੀਂ ਹੋਣੀ ਚਾਹੀਦੀ ਕਿਉਂਕਿ ਇਸਨੂੰ absolute offset ਵਜੋਂ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ, ਪਰ runtime ਦੌਰਾਨ ਇਸ ਪਾਬੰਦੀ ਨੂੰ ਲਾਗੂ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ।

exception UnicodeEncodeError¶: ਜਦੋਂ encoding ਦੌਰਾਨ Unicode ਨਾਲ ਸੰਬੰਧਿਤ error ਆਉਂਦੀ ਹੈ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ UnicodeError ਦੀ subclass ਹੈ।

exception UnicodeDecodeError¶: ਜਦੋਂ decoding ਦੌਰਾਨ Unicode ਨਾਲ ਸੰਬੰਧਿਤ error ਆਉਂਦੀ ਹੈ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ UnicodeError ਦੀ subclass ਹੈ।

exception UnicodeTranslateError¶: ਜਦੋਂ translating ਦੌਰਾਨ Unicode ਨਾਲ ਸੰਬੰਧਿਤ error ਆਉਂਦੀ ਹੈ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ UnicodeError ਦੀ subclass ਹੈ।

exception ValueError¶: ਜਦੋਂ ਕਿਸੇ operation ਜਾਂ function ਨੂੰ ਸਹੀ type ਦਾ argument ਮਿਲਦਾ ਹੈ ਪਰ ਉਸਦੀ value ਅਣਉਚਿਤ ਹੁੰਦੀ ਹੈ ਅਤੇ ਸਥਿਤੀ ਨੂੰ IndexError ਵਰਗੀ ਹੋਰ ਖਾਸ exception ਨਾਲ ਨਹੀਂ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ, ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

exception ZeroDivisionError¶: ਜਦੋਂ division ਜਾਂ modulo operation ਦਾ ਦੂਜਾ argument zero ਹੋਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਨਾਲ ਜੁੜੀ value ਇੱਕ string ਹੁੰਦੀ ਹੈ ਜੋ operands ਦੀ type ਅਤੇ operation ਬਾਰੇ ਜਾਣਕਾਰੀ ਦਿੰਦੀ ਹੈ।

ਹੇਠ ਲਿਖੀਆਂ exceptions ਪੁਰਾਣੀਆਂ versions ਨਾਲ compatibility ਲਈ ਰੱਖੀਆਂ ਗਈਆਂ ਹਨ; Python 3.3 ਤੋਂ ਇਹ OSError ਦੇ aliases ਹਨ।

exception EnvironmentError¶

exception IOError¶

exception WindowsError¶: ਕੇਵਲ Windows ਉੱਤੇ ਉਪਲਬਧ।

OS exceptions¶

ਹੇਠ ਲਿਖੀਆਂ exceptions OSError ਦੀਆਂ subclasses ਹਨ ਅਤੇ system error code ਦੇ ਅਨੁਸਾਰ raise ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

exception BlockingIOError¶

ਜਦੋਂ non-blocking operation ਲਈ ਸੈੱਟ ਕੀਤੇ object (ਜਿਵੇਂ socket) ਉੱਤੇ ਕੋਈ operation block ਹੋ ਸਕਦੀ ਹੋਵੇ, ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ errno EAGAIN, EALREADY, EWOULDBLOCK ਅਤੇ EINPROGRESS ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ।

OSError ਦੇ attributes ਤੋਂ ਇਲਾਵਾ, BlockingIOError ਵਿੱਚ ਇੱਕ ਹੋਰ attribute ਵੀ ਹੋ ਸਕਦਾ ਹੈ:

characters_written¶: ਇੱਕ integer ਜਿਸ ਵਿੱਚ stream block ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਲਿਖੇ ਗਏ bytes ਦੀ ਗਿਣਤੀ ਹੁੰਦੀ ਹੈ। ਇਹ attribute io module ਦੀਆਂ buffered I/O classes ਵਰਤਣ ਸਮੇਂ ਉਪਲਬਧ ਹੁੰਦਾ ਹੈ।

exception ChildProcessError¶: ਜਦੋਂ child process ਉੱਤੇ ਕੋਈ operation ਅਸਫਲ ਹੋ ਜਾਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ errno ECHILD ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ।

exception ConnectionError¶

Connection ਨਾਲ ਸੰਬੰਧਿਤ ਸਮੱਸਿਆਵਾਂ ਲਈ ਇੱਕ base class।

ਇਸ ਦੀਆਂ subclasses ਹਨ BrokenPipeError, ConnectionAbortedError, ConnectionRefusedError ਅਤੇ ConnectionResetError।

exception BrokenPipeError¶: ConnectionError ਦੀ ਇੱਕ ਸਬਕਲਾਸ, ਜੋ ਉਸ ਵੇਲੇ ਉਠਾਈ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਪਾਈਪ 'ਤੇ ਲਿਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਪਰ ਦੂਜਾ ਸਿਰ ਬੰਦ ਹੋ ਚੁੱਕਾ ਹੁੰਦਾ ਹੈ, ਜਾਂ ਲਿਖਣ ਲਈ ਸ਼ਟਡਾਊਨ ਕੀਤੇ ਸਾਕਟ 'ਤੇ ਲਿਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ errno, EPIPE ਅਤੇ ESHUTDOWN ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ।

exception ConnectionAbortedError¶: ConnectionError ਦੀ ਇੱਕ ਉਪ-ਕਲਾਸ, ਜੋ ਪੀਅਰ ਵੱਲੋਂ ਕਨੈਕਸ਼ਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਰੱਦ ਹੋਣ 'ਤੇ ਉਠਾਈ ਜਾਂਦੀ ਹੈ। ਇਹ errno ਅਤੇ ECONNABORTED ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ।

exception ConnectionRefusedError¶: ConnectionError ਦੀ ਇੱਕ ਉਪ-ਕਲਾਸ, ਜੋ ਪੀਅਰ ਵੱਲੋਂ ਕਨੈਕਸ਼ਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਰੱਦ ਹੋਣ 'ਤੇ ਉਠਾਈ ਜਾਂਦੀ ਹੈ। ਇਹ errno ਅਤੇ ECONNREFUSED ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ।

exception ConnectionResetError¶: ConnectionError ਦੀ ਇੱਕ ਉਪ-ਕਲਾਸ, ਜੋ ਪੀਅਰ ਦੁਆਰਾ ਕਨੈਕਸ਼ਨ ਰੀਸੈੱਟ ਹੋਣ 'ਤੇ ਉਠਾਈ ਜਾਂਦੀ ਹੈ। ਇਹ errno ECONNRESET ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ।

exception FileExistsError¶: ਜਦੋਂ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ file ਜਾਂ directory ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ errno EEXIST ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ।

exception FileNotFoundError¶: ਜਦੋਂ ਮੰਗੀ ਗਈ file ਜਾਂ directory ਮੌਜੂਦ ਨਾ ਹੋਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ errno ENOENT ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ।

exception InterruptedError¶: ਜਦੋਂ ਕਿਸੇ system call ਨੂੰ ਆਉਣ ਵਾਲੇ signal ਦੁਆਰਾ ਰੋਕ ਦਿੱਤਾ ਜਾਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ errno EINTR ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ।

Changed in version 3.5: ਪਾਈਥਨ ਹੁਣ ਸਿਸਕਾਲ ਨੂੰ ਸਿਗਨਲ ਨਾਲ ਰੋਕੇ ਜਾਣ 'ਤੇ ਸਿਸਕਾਲਾਂ ਨੂੰ ਮੁੜ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ, ਸਿਵਾਏ ਜਦੋਂ ਸਿਗਨਲ ਹੈਂਡਲਰ ਐਕਸੈਪਸ਼ਨ ਉਠਾਉਂਦਾ ਹੈ (ਕਾਰਨ ਲਈ ਵੇਖੋ PEP 475 ), ਨਾ ਕਿ InterruptedError ਉਠਾਉਂਦਾ ਹੈ।

exception IsADirectoryError¶: ਜਦੋਂ directory ਉੱਤੇ file operation (ਜਿਵੇਂ os.remove()) ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ errno EISDIR ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ।

exception NotADirectoryError¶: ਜਦੋਂ directory operation (ਜਿਵੇਂ os.listdir()) ਕਿਸੇ ਐਸੀ ਚੀਜ਼ ਉੱਤੇ ਕੀਤੀ ਜਾਵੇ ਜੋ directory ਨਾ ਹੋਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ errno ENOTDIR ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ।

exception PermissionError¶: ਜਦੋਂ ਯੋਗ access rights ਉਦਾਹਰਨ ਲਈ filesystem permissions ਤੋਂ ਬਿਨਾਂ ਕੋਈ operation ਚਲਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ errno EACCES, EPERM ਅਤੇ ENOTCAPABLE ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ।

Changed in version 3.11.1: WASI ਦਾ ENOTCAPABLE ਹੁਣ PermissionError ਨਾਲ map ਕੀਤਾ ਗਿਆ ਹੈ।

exception ProcessLookupError¶: ਜਦੋਂ ਦਿੱਤਾ ਗਿਆ process ਮੌਜੂਦ ਨਾ ਹੋਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ errno ESRCH ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ।

exception TimeoutError¶: ਜਦੋਂ ਕੋਈ system function system level ਉੱਤੇ timeout ਹੋ ਜਾਵੇ ਤਾਂ ਇਹ raise ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ errno ETIMEDOUT ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ।

Added in version 3.3: ਉੱਪਰ ਦਿੱਤੀਆਂ ਸਾਰੀਆਂ OSError subclasses ਸ਼ਾਮਲ ਕੀਤੀਆਂ ਗਈਆਂ।

Warnings¶

ਹੇਠ ਲਿਖੀਆਂ exceptions warning categories ਵਜੋਂ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ; ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ Warning Categories documentation ਵੇਖੋ।

exception Warning¶: Warning categories ਲਈ base class।

exception UserWarning¶: User code ਦੁਆਰਾ ਬਣਾਈਆਂ warnings ਲਈ base class।

exception DeprecationWarning¶

Deprecated features ਬਾਰੇ warnings ਲਈ base class, ਜਦੋਂ ਇਹ warnings ਹੋਰ Python developers ਲਈ ਹੋਣ।

ਮੂਲ warning filters ਦੁਆਰਾ ਇਸਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਸਿਵਾਏ __main__ module ਦੇ (PEP 565)। Python Development Mode ਚਾਲੂ ਕਰਨ ਨਾਲ ਇਹ warning ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ।

Deprecation policy ਦਾ ਵੇਰਵਾ PEP 387 ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ।

exception PendingDeprecationWarning¶

ਉਹਨਾਂ features ਬਾਰੇ warnings ਲਈ base class ਜੋ obsolete ਹਨ ਅਤੇ ਭਵਿੱਖ ਵਿੱਚ deprecated ਹੋਣ ਦੀ ਉਮੀਦ ਹੈ, ਪਰ ਇਸ ਵੇਲੇ deprecated ਨਹੀਂ ਹਨ।

ਇਹ class ਘੱਟ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਕਿਉਂਕਿ ਸੰਭਾਵਿਤ ਭਵਿੱਖੀ deprecation ਬਾਰੇ warning ਦੇਣਾ ਅਸਧਾਰਣ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਪਹਿਲਾਂ ਤੋਂ ਸਰਗਰਮ deprecations ਲਈ DeprecationWarning ਨੂੰ ਤਰਜੀਹ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ।

ਮੂਲ warning filters ਦੁਆਰਾ ਇਸਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Python Development Mode ਚਾਲੂ ਕਰਨ ਨਾਲ ਇਹ warning ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ।

Deprecation policy ਦਾ ਵੇਰਵਾ PEP 387 ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ।

exception SyntaxWarning¶

ਸ਼ੱਕੀ syntax ਬਾਰੇ warnings ਲਈ base class।

ਇਹ warning ਆਮ ਤੌਰ 'ਤੇ Python source code compile ਕਰਨ ਵੇਲੇ ਜਾਰੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਪਹਿਲਾਂ ਤੋਂ compile ਕੀਤੇ code ਨੂੰ ਚਲਾਉਣ ਵੇਲੇ ਆਮ ਤੌਰ 'ਤੇ ਰਿਪੋਰਟ ਨਹੀਂ ਹੁੰਦੀ।

exception RuntimeWarning¶: ਸ਼ੱਕੀ runtime ਵਿਵਹਾਰ ਬਾਰੇ warnings ਲਈ base class।

exception FutureWarning¶: Deprecated features ਬਾਰੇ warnings ਲਈ base class, ਜਦੋਂ ਇਹ warnings Python ਵਿੱਚ ਲਿਖੀਆਂ applications ਦੇ ਅੰਤਿਮ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਹੋਣ।

exception ImportWarning¶

Module imports ਵਿੱਚ ਸੰਭਾਵਿਤ ਗਲਤੀਆਂ ਬਾਰੇ warnings ਲਈ base class।

ਮੂਲ warning filters ਦੁਆਰਾ ਇਸਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Python Development Mode ਚਾਲੂ ਕਰਨ ਨਾਲ ਇਹ warning ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ।

exception UnicodeWarning¶: Unicode ਨਾਲ ਸੰਬੰਧਿਤ warnings ਲਈ base class।

exception EncodingWarning¶

Encoding ਨਾਲ ਸੰਬੰਧਿਤ warnings ਲਈ base class।

ਵੇਰਵਿਆਂ ਲਈ Opt-in EncodingWarning ਵੇਖੋ।

Added in version 3.10.

exception BytesWarning¶: bytes ਅਤੇ bytearray ਨਾਲ ਸੰਬੰਧਿਤ warnings ਲਈ base class।

exception ResourceWarning¶

Resource usage ਨਾਲ ਸੰਬੰਧਿਤ warnings ਲਈ base class।

ਮੂਲ warning filters ਦੁਆਰਾ ਇਸਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Python Development Mode ਚਾਲੂ ਕਰਨ ਨਾਲ ਇਹ warning ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ।

Added in version 3.2.

Exception groups¶

ਹੇਠ ਲਿਖੇ ਤਦੋਂ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਜਦੋਂ ਕਈ ਅਸੰਬੰਧਤ exceptions ਨੂੰ ਇਕੱਠੇ raise ਕਰਨਾ ਲੋੜੀਂਦਾ ਹੋਵੇ। ਇਹ exception hierarchy ਦਾ ਹਿੱਸਾ ਹਨ, ਇਸ ਲਈ ਇਨ੍ਹਾਂ ਨੂੰ except ਨਾਲ ਹੋਰ exceptions ਵਾਂਗ handle ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, except* ਵੀ ਇਨ੍ਹਾਂ ਨੂੰ ਪਛਾਣਦਾ ਹੈ।

exception ExceptionGroup(msg, excs)¶

exception BaseExceptionGroup(msg, excs)¶

ਇਹ ਦੋਵੇਂ ਐਕਸੈਪਸ਼ਨ ਕਿਸਮਾਂ ਐਕਸੈਪਸ਼ਨਾਂ ਨੂੰ excs ਵਿੱਚ ਲਪੇਟਦੀਆਂ ਹਨ। msg ਪੈਰਾਮੀਟਰ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਦੋਹਾਂ ਕਲਾਸਾਂ ਵਿੱਚ ਫਰਕ ਇਹ ਹੈ ਕਿ BaseExceptionGroup, BaseException ਨੂੰ ਵਿਸਥਾਰ ਕਰਦੀ ਹੈ ਅਤੇ ਇਹ ਕਿਸੇ ਵੀ ਐਕਸੈਪਸ਼ਨ ਨੂੰ ਲਪੇਟ ਸਕਦੀ ਹੈ, ਜਦਕਿ ExceptionGroup, Exception ਨੂੰ ਵਿਸਥਾਰ ਕਰਦੀ ਹੈ ਅਤੇ ਇਹ ਸਿਰਫ Exception ਦੀਆਂ ਸਬ-ਕਲਾਸਾਂ ਨੂੰ ਹੀ ਲਪੇਟ ਸਕਦੀ ਹੈ। ਇਹ ਡਿਜ਼ਾਈਨ ਇਸ ਲਈ ਹੈ ਤਾਂ ਜੋ except Exception, ExceptionGroup ਨੂੰ ਫੜ ਸਕੇ ਪਰ BaseExceptionGroup ਨੂੰ ਨਹੀਂ।

ਜੇ contained exceptions ਸਾਰੀਆਂ Exception instances ਹੋਣ ਤਾਂ BaseExceptionGroup constructor, BaseExceptionGroup ਦੀ ਬਜਾਏ ExceptionGroup ਵਾਪਸ ਕਰਦਾ ਹੈ। ਦੂਜੇ ਪਾਸੇ, ExceptionGroup constructor TypeError raise ਕਰਦਾ ਹੈ ਜੇ ਕੋਈ contained exception Exception subclass ਨਾ ਹੋਵੇ।

Exception groups ਆਪਣੀਆਂ contained exceptions ਦੀ type ਉੱਤੇ generic ਹੁੰਦੀਆਂ ਹਨ।

excs parameter ਕੋਈ ਵੀ sequence ਹੋ ਸਕਦੀ ਹੈ, ਪਰ lists ਅਤੇ tuples ਇੱਥੇ ਵਧੇਰੇ ਕੁਸ਼ਲਤਾ ਨਾਲ process ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਸਭ ਤੋਂ ਵਧੀਆ performance ਲਈ excs ਵਜੋਂ tuple ਵਰਤੋ।

message¶: Constructor ਦਾ msg argument। ਇਹ ਇੱਕ read-only attribute ਹੈ।

exceptions¶: Constructor ਨੂੰ ਦਿੱਤੀ excs sequence ਵਿੱਚ ਮੌਜੂਦ exceptions ਦੀ tuple। ਇਹ ਇੱਕ read-only attribute ਹੈ।

subgroup(condition)¶

ਇੱਕ exception group ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਕੇਵਲ ਉਹ exceptions ਹੁੰਦੀਆਂ ਹਨ ਜੋ condition ਨਾਲ ਮੇਲ ਖਾਂਦੀਆਂ ਹਨ। ਜੇ ਨਤੀਜਾ ਖਾਲੀ ਹੋਵੇ ਤਾਂ None ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਸ਼ਰਤ ਇੱਕ ਐਕਸੈਪਸ਼ਨ ਕਿਸਮ ਜਾਂ ਐਕਸੈਪਸ਼ਨ ਕਿਸਮਾਂ ਦਾ ਟਿਊਪਲ ਹੋ ਸਕਦੀ ਹੈ, ਜਿਸ ਸਥਿਤੀ ਵਿੱਚ ਹਰ ਐਕਸੈਪਸ਼ਨ ਨੂੰ ਉਸੇ ਜਾਂਚ ਨਾਲ ਮੇਲ ਲਈ ਜਾਂਚਿਆ ਜਾਂਦਾ ਹੈ ਜੋ except ਕਲਾਜ਼ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਸ਼ਰਤ ਇੱਕ ਕਾਲੇਬਲ (ਟਾਈਪ ਆਬਜੈਕਟ ਤੋਂ ਇਲਾਵਾ) ਵੀ ਹੋ ਸਕਦੀ ਹੈ ਜੋ ਆਪਣਾ ਇਕੱਲਾ ਦਲੀਲ ਵਜੋਂ ਐਕਸੈਪਸ਼ਨ ਲੈਂਦੀ ਹੈ ਅਤੇ ਉਹਨਾਂ ਐਕਸੈਪਸ਼ਨਾਂ ਲਈ ਸੱਚ ਵਾਪਸ ਕਰਦੀ ਹੈ ਜੋ ਸਬਗਰੁੱਪ ਵਿੱਚ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ।

ਨਤੀਜੇ ਵਿੱਚ ਮੌਜੂਦਾ exception ਦੀ nesting structure ਸੁਰੱਖਿਅਤ ਰਹਿੰਦੀ ਹੈ। message, __traceback__, __cause__, __context__ ਅਤੇ __notes__ ਦੀਆਂ values ਵੀ ਸੁਰੱਖਿਅਤ ਰਹਿੰਦੀਆਂ ਹਨ।

Condition ਨੂੰ nested exception group ਦੀਆਂ ਸਾਰੀਆਂ exceptions ਲਈ ਜਾਂਚਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ top-level ਅਤੇ nested exception groups ਵੀ ਸ਼ਾਮਲ ਹਨ। ਜੇ condition ਸਹੀ ਹੋਵੇ ਤਾਂ ਉਹ exception group ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਤੀਜੇ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

Added in version 3.13: condition ਕੋਈ ਵੀ callable ਹੋ ਸਕਦੀ ਹੈ ਜੋ type object ਨਾ ਹੋਵੇ।

split(condition)¶: subgroup() ਵਾਂਗ, ਪਰ ਇਹ (match, rest) ਜੋੜਾ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਿੱਥੇ match = subgroup(condition) ਅਤੇ rest ਬਾਕੀ non-matching ਭਾਗ ਹੁੰਦਾ ਹੈ।

derive(excs)¶

ਉਹੀ message ਵਾਲਾ exception group ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ excs ਵਿੱਚ ਦਿੱਤੀਆਂ exceptions ਨੂੰ wrap ਕਰਦਾ ਹੈ।

ਇਹ method subgroup() ਅਤੇ split() ਦੁਆਰਾ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਜੇ subclass ਚਾਹੁੰਦੀ ਹੈ ਕਿ subgroup() ਅਤੇ split() ExceptionGroup ਦੀ ਬਜਾਏ ਉਸ subclass ਦੀਆਂ instances ਵਾਪਸ ਕਰਨ, ਤਾਂ ਇਸ method ਨੂੰ override ਕਰਨਾ ਲਾਜ਼ਮੀ ਹੈ।

subgroup() ਅਤੇ split(), ਮੂਲ exception group ਤੋਂ __traceback__, __cause__, __context__ ਅਤੇ __notes__ fields ਨੂੰ derive() ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ group ਵਿੱਚ ਕਾਪੀ ਕਰਦੀਆਂ ਹਨ, ਇਸ ਲਈ derive() ਨੂੰ ਇਨ੍ਹਾਂ fields ਨੂੰ update ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ।

>>> class MyGroup(ExceptionGroup):
...     def derive(self, excs):
...         return MyGroup(self.message, excs)
...
>>> e = MyGroup("eg", [ValueError(1), TypeError(2)])
>>> e.add_note("a note")
>>> e.__context__ = Exception("context")
>>> e.__cause__ = Exception("cause")
>>> try:
...    raise e
... except Exception as e:
...    exc = e
...
>>> match, rest = exc.split(ValueError)
>>> exc, exc.__context__, exc.__cause__, exc.__notes__
(MyGroup('eg', [ValueError(1), TypeError(2)]), Exception('context'), Exception('cause'), ['a note'])
>>> match, match.__context__, match.__cause__, match.__notes__
(MyGroup('eg', [ValueError(1)]), Exception('context'), Exception('cause'), ['a note'])
>>> rest, rest.__context__, rest.__cause__, rest.__notes__
(MyGroup('eg', [TypeError(2)]), Exception('context'), Exception('cause'), ['a note'])
>>> exc.__traceback__ is match.__traceback__ is rest.__traceback__
True

ਧਿਆਨ ਦਿਓ ਕਿ BaseExceptionGroup ਨੇ __new__() ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ, ਇਸ ਲਈ ਉਹਨਾਂ ਸਬਕਲਾਸਾਂ ਨੂੰ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਵੱਖਰਾ ਕੰਸਟਰਕਟਰ ਸਿਗਨੇਚਰ ਚਾਹੀਦਾ ਹੈ, __init__() ਦੀ ਥਾਂ ਇਸਨੂੰ ਓਵਰਰਾਈਡ ਕਰਨਾ ਪਵੇਗਾ। ਉਦਾਹਰਨ ਵਜੋਂ, ਹੇਠਾਂ ਦਿੱਤੀ ਕੋਡ ਇੱਕ ਐਕਸੈਪਸ਼ਨ ਗਰੁੱਪ ਸਬਕਲਾਸ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ ਜੋ exit_code ਸਵੀਕਾਰ ਕਰਦੀ ਹੈ ਅਤੇ ਉਸ ਤੋਂ ਗਰੁੱਪ ਦਾ ਸੁਨੇਹਾ ਤਿਆਰ ਕਰਦੀ ਹੈ।

class Errors(ExceptionGroup):
   def __new__(cls, errors, exit_code):
      self = super().__new__(Errors, f"exit code: {exit_code}", errors)
      self.exit_code = exit_code
      return self

   def derive(self, excs):
      return Errors(excs, self.exit_code)

ExceptionGroup ਵਾਂਗ, BaseExceptionGroup ਦੀ ਕੋਈ ਵੀ subclass ਜੋ Exception ਦੀ ਵੀ subclass ਹੋਵੇ, ਸਿਰਫ਼ Exception ਦੀਆਂ instances ਨੂੰ ਹੀ wrap ਕਰ ਸਕਦੀ ਹੈ।

Added in version 3.11.

Exception hierarchy¶

Built-in exceptions ਲਈ class hierarchy ਇਹ ਹੈ:

BaseException
 ├── BaseExceptionGroup
 ├── GeneratorExit
 ├── KeyboardInterrupt
 ├── SystemExit
 └── Exception
      ├── ArithmeticError
      │    ├── FloatingPointError
      │    ├── OverflowError
      │    └── ZeroDivisionError
      ├── AssertionError
      ├── AttributeError
      ├── BufferError
      ├── EOFError
      ├── ExceptionGroup [BaseExceptionGroup]
      ├── ImportError
      │    └── ImportCycleError
      │    └── ModuleNotFoundError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── MemoryError
      ├── NameError
      │    └── UnboundLocalError
      ├── OSError
      │    ├── BlockingIOError
      │    ├── ChildProcessError
      │    ├── ConnectionError
      │    │    ├── BrokenPipeError
      │    │    ├── ConnectionAbortedError
      │    │    ├── ConnectionRefusedError
      │    │    └── ConnectionResetError
      │    ├── FileExistsError
      │    ├── FileNotFoundError
      │    ├── InterruptedError
      │    ├── IsADirectoryError
      │    ├── NotADirectoryError
      │    ├── PermissionError
      │    ├── ProcessLookupError
      │    └── TimeoutError
      ├── ReferenceError
      ├── RuntimeError
      │    ├── NotImplementedError
      │    ├── PythonFinalizationError
      │    └── RecursionError
      ├── StopAsyncIteration
      ├── StopIteration
      ├── SyntaxError
      │    └── IndentationError
      │         └── TabError
      ├── SystemError
      ├── TypeError
      ├── ValueError
      │    └── UnicodeError
      │         ├── UnicodeDecodeError
      │         ├── UnicodeEncodeError
      │         └── UnicodeTranslateError
      └── Warning
           ├── BytesWarning
           ├── DeprecationWarning
           ├── EncodingWarning
           ├── FutureWarning
           ├── ImportWarning
           ├── PendingDeprecationWarning
           ├── ResourceWarning
           ├── RuntimeWarning
           ├── SyntaxWarning
           ├── UnicodeWarning
           └── UserWarning

ਬਿਲਟ-ਇਨ ਐਕਸੈਪਸ਼ਨ¶

ਐਕਸੈਪਸ਼ਨ ਸੰਦਰਭ¶

ਬਿਲਟ-ਇਨ ਐਕਸੈਪਸ਼ਨਾਂ ਤੋਂ ਵਿਰਾਸਤ ਲੈਣਾ¶

ਬੇਸ ਕਲਾਸਾਂ¶

ਖਾਸ exceptions¶

OS exceptions¶

Warnings¶

Exception groups¶

Exception hierarchy¶

Table of Contents

Previous topic

Next topic

This page