erreurs python3 et exceptions

En tant que débutant Python, en train d'apprendre la programmation Python voir souvent un message d'erreur, nous ne mentionnions pas en face de ce chapitre, nous sera consacrée.

Python a deux erreurs facilement reconnaissables: les erreurs et exceptions syntaxe.

erreur de syntaxe

Python Les erreurs de syntaxe ou mauvais appel analytique, les débutants rencontrent souvent, à titre d'exemples

>>> while True print('Hello world')
  File "<stdin>", line 1, in ?
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

Dans cet exemple, la fonction print () est cochée pour les erreurs avant qu'il manque deux points (:).

Parser a fait remarquer l'erreur de son parti, et dans le mauvais endroit pour trouver le premier marqueur d'une petite flèche.

anormal

Même la grammaire programme Python est correct, il est temps de courir, il peut y avoir des erreurs. Les erreurs d'exécution détectées sont appelées exceptions.

La plupart ne sera pas un gestionnaire d'exception sous la forme de messages d'erreur d'affichage ici:

>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly

Apparaître anormale dans différents types, ces types sont imprimés dans le cadre de l'information: Des exemples de types ZeroDivisionError, NameError et TypeError.

La partie avant du message d'erreur indique le contexte d'une exception se produit, la pile d'appel et affichée sous la forme d'informations spécifiques.

Gestion des exceptions

L'exemple suivant, permet aux utilisateurs d'entrer un entier valide, mais permet à l'utilisateur d'interrompre le programme (en utilisant les méthodes du système d'exploitation fournis Control-C ou). interruptions de l'utilisateur entraînera une exception KeyboardInterrupt.

>>> while True:
        try:
            x = int(input("Please enter a number: "))
            break
        except ValueError:
            print("Oops!  That was no valid number.  Try again   ")
   

essayez les travaux de déclaration de la manière suivante;

• Tout d'abord, la clause d'essai (entre les mots clés et mots-clés, sauf instructions try)
• Si aucune exception se produit, la clause d'exception est ignorée, essayez clause extrémités exécutées.
• Si une exception se produit dans la procédure de la clause try, puis essayer clause, le reste sera ignoré. Si le nom et le type de l'exception, sauf après le match, le correspondant, sauf clause est exécutée. Code de tenter déclaration après la dernière exécution.
• Si une exception ne correspond pas à toute exception, cette exception sera transmise à l'essai supérieur.

Une instruction try peut contenir plus d'une clause d'exception, pour faire face à différentes exceptions spécifiques. Tout au plus une branche sera exécutée.

Handler seulement pour le traitement d'exception de la clause try correspondant, plutôt que de l'autre gestionnaire essayer d'exception.

Une clause d'exception peut gérer plusieurs exceptions qui seront placés dans une parenthèse comme un tuple, par exemple:

    except (RuntimeError, TypeError, NameError):
        pass

La dernière clause d'exception peut ignorer le nom de l'exception, il sera traité comme un joker. Vous pouvez utiliser cette méthode pour imprimer un message d'erreur, puis de nouveau jeté.

import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

essayez except a une clause else facultative, si vous utilisez cette clause, doit être placé après tout, sauf clauses. Cette clause n'aura aucun problème se produit dans la clause try exécute. Par exemple:

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

Utilisez la clause que toutes les déclarations contenues dans la clause d'essai qui vaut mieux éviter certains inattendu d'autre, mais, sauf qu'ils ne sont pas attraper l'exception.

La gestion des exceptions ne traitent que de ces exceptions se produisent essayer directement clause, mais aussi appeler clause de gestionnaire (même des appels de fonctions indirects) où jeté. Par exemple:

>>> def this_fails():
        x = 1/0
   
>>> try:
        this_fails()
    except ZeroDivisionError as err:
        print('Handling run-time error:', err)
   
Handling run-time error: int division or modulo by zero

Jeter une exception

Python utilise instruction throw pour élever une exception spécifiée. Par exemple:

>>> raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: HiThere

soulever un seul paramètre spécifie l'exception d'être jeté. Il doit être une instance inhabituelle d'une classe ou anormale (ie sous-classe d'exception).

Si vous voulez savoir si elle lance une exception, ne veut pas traiter avec elle, une déclaration simple peut soulever à nouveau jeté.

>>> try:
        raise NameError('HiThere')
    except NameError:
        print('An exception flew by!')
        raise
   
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in ?
NameError: HiThere

exceptions définies par l'utilisateur

Vous pouvez avoir vos propres exceptions en créant une nouvelle classe d'exception. Les exceptions devraient hériter de la classe d'exception, soit l'héritage directement, succession ou indirectement, par exemple:

>>> class MyError(Exception):
        def __init__(self, value):
            self.value = value
        def __str__(self):
            return repr(self.value)
   
>>> try:
        raise MyError(2*2)
    except MyError as e:
        print('My exception occurred, value:', e.value)
   
My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
__main__.MyError: 'oops!'

Dans cet exemple, la classe Exception __init par défaut __ () est remplacé.

class Error(Exception):
    """Base class for exceptions in this module."""
    pass

class InputError(Error):
    """Exception raised for errors in the input.

    Attributes:
        expression -- input expression in which the error occurred
        message -- explanation of the error
    """

    def __init__(self, expression, message):
        self.expression = expression
        self.message = message

class TransitionError(Error):
    """Raised when an operation attempts a state transition that's not
    allowed.

    Attributes:
        previous -- state at beginning of transition
        next -- attempted new state
        message -- explanation of why the specific transition is not allowed
    """

    def __init__(self, previous, next, message):
        self.previous = previous
        self.next = next
        self.message = message

>>> try:
        raise KeyboardInterrupt
	finally:
        print('Goodbye, world!')
   
Goodbye, world!
KeyboardInterrupt

>>> def divide(x, y):
        try:
            result = x / y
        except ZeroDivisionError:
            print("division by zero!")
        else:
            print("result is", result)
        finally:
            print("executing finally clause")
   
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

for line in open("myfile.txt"):
    print(line, end="")

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")