එක් පේළියක බහු ව්‍යතිරේකයන් අල්ලා ගන්න (බ්ලොක් හැර)

මට කළ හැකි බව මම දනිමි:

try:
    # do something that may fail
except:
    # do this if ANYTHING goes wrong

මට මෙය කළ හැකිය:

try:
    # do something that may fail
except IDontLikeYouException:
    # say please
except YouAreTooShortException:
    # stand on a ladder

නමුත් මට එකම ව්‍යතිරේක දෙකක් තුළ එකම දේ කිරීමට අවශ්‍ය නම්, මට දැන් සිතිය හැකි හොඳම දේ මෙය කිරීමයි:

try:
    # do something that may fail
except IDontLikeYouException:
    # say please
except YouAreBeingMeanException:
    # say please

මට මේ වගේ දෙයක් කළ හැකි ක්‍රමයක් තිබේද (ව්‍යතිරේක දෙකෙහිම ගත යුතු පියවර වන්නේ say please):

try:
    # do something that may fail
except IDontLikeYouException, YouAreBeingMeanException:
    # say please

දැන් මෙය සැබවින්ම ක්‍රියා නොකරනු ඇත, මන්ද එය සඳහා වන වාක්‍ය ඛණ්ඩයට ගැලපේ:

try:
    # do something that may fail
except Exception, e:
    # say please

ඉතින්, සුවිශේෂී ව්‍යතිරේක දෙක අල්ලා ගැනීමට මා දරන උත්සාහය හරියටම ඉටු නොවේ.

මෙය කිරීමට ක්‍රමයක් තිබේද?

සිට Python Documentation :

ව්‍යතිරේකයක් හැරුණු විට වරහන් වර්‍ගයක් ලෙස බහු ව්‍යතිරේකයන් නම් කළ හැකිය

except (IDontLikeYouException, YouAreBeingMeanException) as e:
    pass

නැතහොත්, පයිතන් 2 සඳහා පමණි:

except (IDontLikeYouException, YouAreBeingMeanException), e:
    pass

විචල්‍යයෙන් කොමා සමඟ වෙන් කිරීම තවමත් පයිතන් 2.6 සහ 2.7 හි ක්‍රියා කරයි, නමුත් දැන් එය අතහැර දමා ඇති අතර පයිතන් 3 හි ක්‍රියා නොකරයි; දැන් ඔබ භාවිතා කළ යුතුයි as.

එක් පේළියක බහුවිධ ව්‍යතිරේකයන් මා අල්ලා ගන්නේ කෙසේද (බ්ලොක් හැර)

මෙය කරන්න:

try:
    may_raise_specific_errors():
except (SpecificErrorOne, SpecificErrorTwo) as error:
    handle(error) # might log or have some other default behavior...

වරහන් වර්‍ග අවශ්‍ය වන්නේ පැරණි වාක්‍ය ඛණ්ඩයක් නිසා කොමාව භාවිතා කර වැරදි වස්තුව නමකට පැවරීම සඳහා ය. මෙම asමූල පදය පැවරුම සඳහා භාවිතා කරනු ඇත. දෝෂ වස්තුව සඳහා ඔබට ඕනෑම නමක් භාවිතා කළ හැකිය, මම errorපෞද්ගලිකව කැමැත්තෙමි .

හොඳම පුහුණුව

මෙය දැනට සහ ඉදිරියට පයිතන් සමඟ අනුකූල වන පරිදි සිදු කිරීම සඳහා, ඔබ ව්‍යතිරේකයන් කොමාව සමඟ වෙන් කොට වරහන් සමඟ ඔතා, පෙර වාක්‍ය ඛණ්ඩයෙන් වෙන්කර හඳුනා ගැනීම සඳහා ව්‍යතිරේක අවස්ථාව විචල්‍ය නාමයකට පවරා ඇති ව්‍යතිරේක වර්ගය අනුගමනය කිරීමෙන් a කොමාව.

සරල භාවිතයට උදාහරණයක් මෙන්න:

import sys

try:
    mainstuff()
except (KeyboardInterrupt, EOFError): # the parens are necessary
    sys.exit(0)

දෝෂ සැඟවීම වළක්වා ගැනීම සඳහා මම මෙම ව්‍යතිරේකයන් පමණක් සඳහන් කරමි, මට හමු වුවහොත් සම්පූර්ණ තොග හෝඩුවාව අපේක්ෂා කරමි.

මෙය මෙහි ලේඛනගත කර ඇත: https://docs.python.org/tutorial/errors.html

ඔබට ව්‍යතිරේකය විචල්‍යයකට පැවරිය හැකිය, ( eපොදු ය, නමුත් ඔබට දිගු ව්‍යතිරේක හැසිරවීමක් තිබේ නම් හෝ ඔබේ IDE ඉස්මතු කරන්නේ ඊට වඩා විශාල තේරීම් පමණි, මගේ මෙන්.) උදාහරණයට ආග්ස් ගුණාංගයක් ඇත. මෙන්න උදාහරණයක්:

import sys

try:
    mainstuff()
except (KeyboardInterrupt, EOFError) as err: 
    print(err)
    print(err.args)
    sys.exit(0)

පයිතන් 3 හි, අවහිරය අවසන් errවූ විට වස්තුව විෂය පථයෙන් බැහැර වන බව සලකන්න except.

අතහැර දමා ඇත

කොමාව සමඟ දෝෂය පවරන කේතය ඔබට පෙනෙනු ඇත. පයිතන් 2.5 සහ ඊට පෙර ඇති එකම පෝරමය වන මෙම භාවිතය ඉවත් කර ඇති අතර, ඔබේ කේතය පයිතන් 3 සමඟ අනුකූල වීමට ඔබ කැමති නම්, නව පෝරමය භාවිතා කිරීම සඳහා ඔබ සින්ටැක්ස් යාවත්කාලීන කළ යුතුය:

import sys

try:
    mainstuff()
except (KeyboardInterrupt, EOFError), err: # don't do this in Python 2.6+
    print err
    print err.args
    sys.exit(0)

ඔබේ කෝඩ්බේස් හි කොමා නාම පැවරුම ඔබ දුටුවහොත් සහ ඔබ පයිතන් 2.5 හෝ ඊට වැඩි භාවිතා කරන්නේ නම්, එය සිදු කරන නව ක්‍රමයට මාරුවන්න එවිට ඔබ උත්ශ්‍රේණිගත කිරීමේදී ඔබේ කේතය අනුකූල වේ.

මෙම suppressසන්දර්භය කළමනාකරු

පිළිගත් පිළිතුර ඇත්ත වශයෙන්ම කේත පේළි 4 ක්, අවම:

try:
    do_something()
except (IDontLikeYouException, YouAreBeingMeanException) as e:
    pass

මෙම try, except, passරේඛා සමඟ එක පෙලට ඇල්ලීමට හැකි මැඩීමට සන්දර්භය කළමනාකරු, Python 3.4 ලබා ගත :

from contextlib import suppress

with suppress(IDontLikeYouException, YouAreBeingMeanException):
     do_something()

එබැවින් ඔබට passයම් ව්‍යතිරේක අවශ්‍ය වූ විට භාවිතා කරන්න suppress.

සිට Python ප්රලේඛනය -> 8.3 හැසිරවීම සම්බන්ධ ව්යතිරේක :

ඒ tryප්රකාශය වෙනස් ව්යතිරේක සඳහා පේනු නියම කිරීමට, වගන්තිය හැර එක් වඩා වැඩි විය හැක. බොහෝ විට එක් හසුරුවන්නෙකු ක්‍රියාත්මක කරනු ඇත. හසුරුවන්නන් හසුරුවන්නේ අදාළ උත්සාහක වගන්තියේ ඇති ව්‍යතිරේකයන් මිස එකම උත්සාහ ප්‍රකාශයේ වෙනත් හසුරුවන්නන් තුළ නොවේ. ව්‍යතිරේකයක් හැරුණු විට වර්‍ගගත කළ ටුපල් ලෙස බහු ව්‍යතිරේකයන් නම් කළ හැකිය:

except (RuntimeError, TypeError, NameError):
    pass

නූතන පයිතන්හි ( ValueError, e:සාමාන්‍යයෙන් except ValueError as e:පහත පරිදි විස්තර කර ඇති පරිදි) සාමාන්‍යයෙන් ලියා ඇති දේ සඳහා භාවිතා කරන වාක්‍ය ඛණ්ඩය හැරුණු විට මෙම පච්චය වටා ඇති වරහන් අවශ්‍ය බව සලකන්න . පසුගාමී අනුකූලතාව සඳහා පැරණි සින්ටැක්ස් තවමත් සහය දක්වයි. මෙයින් අදහස් කරන්නේ ඔබට අවශ්‍ය දේ නොවන නමුත් except RuntimeError, TypeErrorඑයට සමාන නොවන බවයි.except (RuntimeError, TypeError):except RuntimeError as TypeError:

ඔබ නිතරම ව්‍යතිරේක විශාල සංඛ්‍යාවක් භාවිතා කරන්නේ නම්, ඔබට ටුපල් එකක් කලින් නිර්වචනය කළ හැකිය, එබැවින් ඔබට ඒවා නැවත නැවත ටයිප් කිරීමට අවශ්‍ය නැත.

#This example code is a technique I use in a library that connects with websites to gather data

ConnectErrs  = (URLError, SSLError, SocketTimeoutError, BadStatusLine, ConnectionResetError)

def connect(url, data):
    #do connection and return some data
    return(received_data)

def some_function(var_a, var_b, ...):
    try: o = connect(url, data)
    except ConnectErrs as e:
        #do the recovery stuff
    blah #do normal stuff you would do if no exception occurred

සටහන්:

1. ඔබටත්, කලින් නිර්වචනය කර ඇති ටුපල් හැර වෙනත් ව්‍යතිරේකයන් අල්ලා ගැනීමට අවශ්‍ය නම්, ඔබට බ්ලොක් හැර වෙනත් අර්ථ දැක්වීමට අවශ්‍ය වනු ඇත.

2. ඔබට ගෝලීය විචල්‍යයක් ඉවසා සිටිය නොහැකි නම්, එය ප්‍රධාන () වලින් අර්ථ දක්වා එය අවශ්‍ය තැනට ගෙන යන්න ...

මෙය කළ හැකි එක් ක්‍රමයක් නම් ..

try:
   You do your operations here;
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
   If there is any exception from the given exception list, 
   then execute this block.
   ......................
else:
   If there is no exception then execute this block. 

තවත් ක්‍රමයක් නම්, exceptබ්ලොක් මඟින් ක්‍රියාවට නංවන ක්‍රමවේදයක් නිර්මාණය කර එය exceptඔබ ලියන සියලුම බ්ලොක් හරහා අමතන්න ..

try:
   You do your operations here;
   ......................
except Exception1:
    functionname(parameterList)
except Exception2:
    functionname(parameterList)
except Exception3:
    functionname(parameterList)
else:
   If there is no exception then execute this block. 

def functionname( parameters ):
   //your task..
   return [expression]

දෙවැන්න මෙය කිරීමට හොඳම ක්‍රමය නොවන බව මම දනිමි, නමුත් මම මේ දේ කිරීමට ක්‍රම ගණනාවක් පෙන්වමි.