Concepts d'erreur et d'exception Python

Concepts d'erreurs et d'exceptions Python (généraux)

1. Comment gérer les erreurs et les exceptions

1. Erreurs courantes

2. a : NameError

3. if True : SyntaxError

4. f = oepn('1.txt') : IOError

5. 10/0 : ZeropisionError

6. a = int('d') : ValueError

7. Programme en cours d'exécution interruption : KeyboardInterrupt

2.Python-utilisez try_sauf pour gérer les exceptions (1)

try:
    try_suite
except Exception [e]:
    exception_block

1. try est utilisé pour capturer les erreurs dans try_suite , et transmettez l'erreur à except

2. sauf est utilisé pour gérer les exceptions. Si la gestion des exceptions est cohérente avec la définition de l'exception capturée, utilisez exception_block pour gérer les exceptions

<.>

# case 1
try:
    undef
except:
    print 'catch an except'

# case 2
try:
    if undef
except:
    print 'catch an except'

• case1 : L'exception peut être interceptée car il s'agit d'une erreur d'exécution

• case2 : L'exception ne peut pas être interceptée car c'est une erreur de syntaxe, une erreur de pré-exécution

--

# case 3
try:
    undef
except NameError,e:
    print 'catch an except',e

# case 4
try:
    undef
except IOError,e:
    print 'catch an except',e

• case3 : L'exception peut être interceptée car le paramètre capture l'exception NameError

• case4 : Impossible d'intercepter l'exception car le paramètre IOError ne gérera pas NameError

Exemple

import random

num = random.randint(0, 100)

while True:
    try:
        guess = int(raw_input("Enter 1~100"))
    except ValueError, e:
        print "Enter 1~100"
        continue
    if guess > num:
        print "guess Bigger:", guess
    elif guess < num:
        print "guess Smaller:", guess
    elif guess == num:
        print "Guess OK,Game Over"
        break
    print &#39;\n&#39;

3. Python utilise try_sauf pour gérer les exceptions (2)

• try-sauf : gérer plusieurs exceptions

try:
    try_suite
except Exception1[e]:
    exception_block1
except Exception2[e]:
    exception_block2
except ExceptionN[e]:
    exception_blockN

4. . Python-try_finally utilise

try:
    try_suite
finally:
    do_finally

• Si l'instruction try ne capture pas l'erreur, le code exécute l'instruction do_finally

• Si le. L'instruction try capture l'erreur, le programme exécute d'abord l'instruction do_finally, puis transmet l'erreur capturée au traitement de l'interpréteur python

Python-try-sauf-else-finally

 try:
    try_suite
 except:
    do_except
 finally:
    do_finally

• Si l'instruction try n'attrape pas l'exception, l'exécution est terminée. Après le segment de code try, exécutez enfin

• Si try détecte une exception. , exécutez d'abord sauf pour gérer l'erreur, puis exécutez enfin

6. Python-with_as L'instruction

with context [as var]:
    with_suite

• with est utilisé pour remplacer l'instruction try_sauf_final pour rendre le code plus concis

• L'expression de contexte renvoie un objet

• var est utilisé pour enregistrer le retour de contexte objet, une seule valeur de retour ou une primitive

• with_suite utilise des variables var pour opérer sur l'objet de retour de contexte

L'essence de l'instruction with est la gestion de contexte :

1. Protocole de gestion de contexte : contient les méthodes

   et __enter__(), les objets qui supportent ce protocole doivent implémenter ces deux méthodes __exit（）__

2. Gestionnaire de contexte : définit le contexte d'exécution à établir lors de l'exécution de l'instruction with, et est responsable de l'exécution des opérations d'entrée et de sortie dans le contexte du bloc d'instruction with

3. Entrez le gestionnaire de contexte : appelez la méthode

   du gestionnaire. Si l'instruction as var est définie, la variable var accepte la valeur de retour de la méthode __enter__ __enter__()

4. Quittez le gestionnaire de contexte : appelez la gestion. Appareil

   Méthode__exit__

class Mycontex(object):
    def __init__(self, name):
        self.name = name

    def __enter__(self):
        print "__enter__"
        return self

    def do_self(self):
        print "do_self"

    def __exit__(self, exc_type, exc_val, exc_tb):
        print "__exit__"
        print "Error:", exc_type, " info:", exc_val


if __name__ == "__main__":
    with Mycontex('test context') as f:
        print f.name
        f.do_self()

avec scénario d'application de déclaration :

1. Opération sur fichier

2. Objets mutex entre les threads de processus, tels que les verrous mutex

3. Autres objets prenant en charge le contexte

Exceptions standard et exceptions automatiques

1. Déclarations Python-assert et raise

• instruction rais

• l'instruction reise est utilisée pour lancer activement une exception

• Format de syntaxe : raise[exception[,args]]

• exception : Classe d'exception

• args : Tuple décrivant les informations d'exception

raise TypeError, 'Test Error'

raise IOError, 'File Not Exit'

• déclaration d'assertion

• Assertion instruction : L'instruction assert est utilisée pour vérifier si l'expression est vraie. Si elle est fausse, une AssertionError est levée

• Format de syntaxe : assert expression[,args]

experession : expression
args : description informations de la condition de jugement

assert 0, 'test assert'

2. Exceptions standard Python et exceptions personnalisées

assert 4==5, 'test assert'

Exceptions standard
Exceptions intégrées Python, qui sont générées avant le programme est exécuté Existe déjà

• 

Exception personnalisée :
Python permet aux exceptions personnalisées de décrire les exceptions non impliquées dans Python
Les exceptions personnalisées doivent hériter de la classe Exception
Les exceptions personnalisées ne peuvent être déclenchées que activement

class CustomError(Exception):
    def __init__(self, info):
        Exception.__init__(self)
        self.message = info
        print id(self)

    def __str__(self):
        return 'CustionError:%s' % self.message


try:
    raise CustomError('test CustomError')
except CustomError, e:
    print 'ErrorInfo:%d,%s' % (id(e), e)

Pour plus d'articles liés aux erreurs Python et aux concepts d'exception, veuillez faire attention au site Web PHP chinois !