faire une exception pour le python

Estimation du temps de lecture : 5 procès-verbal

Dans un programme informatique, il y a beaucoup de pièces mobiles différentes, que le programmeur a créées lui-même.

Et selon le degré de sophistication du code, des exceptions écrites peuvent se produire, généralement personne ne comprend ce qu'elles signifient !

Nous avons donc établi que des problèmes peuvent survenir, que faire ensuite ?

Dans le cadre du processus d'élaboration de la logique, la connaissance sera du ressort du programmeur informatique.

Dans ce cas, les erreurs qu'ils connaissent et pour lesquelles ils programment, ne sont pas toujours comprises par tout le monde.

Si le programme informatique ne les explique pas correctement, cela peut souvent conduire à de longues heures de recherche pour résoudre le problème.

Cela est généralement dû au fait que le message d'erreur qu'ils codent pour expliquer le problème n'est pas toujours conçu de manière à être facilement compréhensible.

Il faut s'en souvenir :

  • Il se peut que toutes les erreurs ne soient pas connues au moment de l'élaboration du programme.
  • Certains messages d'erreur peuvent être générés automatiquement, et non à la demande du programmeur.

Entrez dans le cadre, la possibilité de créer vos propres messages d'erreur avec des explications compréhensibles.

Les bons programmeurs ont de nombreux traits qui rendent ce qu'ils développent si puissant.

Étonnamment, il est possible de passer à côté de choses simples, mais en fonction du temps et du budget, des messages d'erreur génériques peuvent être nécessaires, ce qui n'est certainement pas idéal.

Dans cette optique, examinons le code suivant :

def checkvalue() :
    try :
        integervalues = input("Tapez quelque chose pour tester ceci : ")
        if integervalue != "55" et integervalue.isdecimal() :
            raise ValueError
        elif integervalue.isalpha() :
            raise TypeError
        d'autre part :
            imprimer ("55 saisi correctement")
    sauf ValueError :
        augmenter ValueError ("Integervalue needs to be fifty five")
    sauf TypeError :
        raise TypeError("Number needs to be entered")
    enfin :
        imprimer ("Tous les contrôles sont terminés")


checkvalue()
Il revient :
NameError : le nom "integervalue" n'est pas défini

Le problème est que la variable utilisée comporte une faute d'orthographe.

Heureusement, nous pouvons facilement constater que la variable "valeur entière" est mal orthographiée avec un "s" supplémentaire, mais la suppression de ce dernier réglera le problème.

C'est pourquoi nous avons pris le code ci-dessus, sans essai et sauf :

de distlib.compat import raw_input
def checkvalue() :
    integervalue =raw_input("Tapez quelque chose pour tester ceci : ")

    si valeur entière == int(55) :
        print("succès")
    d'autre part :
        print("integervalvalue needs to be a fifty five")


checkvalue()
Il revient :
Tapez quelque chose pour le tester : aa
la valeur entière doit être un cinquante-cinq

En substance, les deux font la même chose, surtout que le premier morceau de code permet une meilleure personnalisation.

Cela nous permet de tester des types d'erreurs spécifiques, ce qui donne lieu à un piégeage des erreurs plus spécifique comme :

  • Erreur de valeur
  • Erreur de type

Les deux ci-dessus ne sont que des exemples d'exceptions intégrées codées pour piéger les erreurs.

Mais que faire si nous voulons créer notre propre liste d'exceptions ?

Le moyen le plus simple de contourner ce problème est de créer votre propre classe qui a les erreurs que vous devez saisir.

Ensuite, vous faites référence à cette classe dans le try/except et bingo, et voilà.

Pour y parvenir, la première étape consiste à créer des classes avec les erreurs que vous voulez attraper :

classe ValueTooSmall(Exception) :
    """Augmenté lorsque la valeur d'entrée est trop petite"""
    passer
classe ValeurLongueur(Exception) :
    """Augmenté lorsque la valeur saisie est vide """
    passer
classe ValueAlphabetic(Exception) :
    """Relevé lorsque la valeur est alphabétique"""
    passer

Ensuite, créez une fonction qui supportera tous les essais, sauf la logique, pour vérifier les erreurs

essayer :
        integervalue = input ("Tapez quelque chose pour tester ceci : ") # Crée une chaîne ici
        si len(valeur entière) == 0 :
            augmenter la valeurLongueur
        elif integervalue.isalpha() :
            raise ValueAlphabetic
        elif int(integervalue) != 55 et int(integervalue) < 10 : # conversion en nombre entier pour permettre la comparaison
            Augmenter la valeur de la petite entreprise
        elif int(integervalue) != 55 et int(integervalue) > 10 : # conversion en nombre entier pour permettre la comparaison
            augmenter la valeurError
        d'autre part :
            imprimer ("55 saisi correctement")
    sauf ValueError :
        augmenter ValueError ("Integervalue needs to be fifty five")
    sauf TypeError :
        raise TypeError("Number needs to be entered")
    sauf ValueTooSmall :
        augmenter ValueTooSmall ("Le nombre doit être supérieur à 10")
    sauf ValueLength :
        augmenter ValueLength ("Le nombre doit être saisi, il ne peut pas être vide")
    sauf ValueAlphabetic :
        raise ValueAlphabetic ("Vous ne pouvez pas entrer une valeur alphabétique")
    enfin :

Tout mettre ensemble

classe ValueTooSmall(Exception) :
    """Augmenté lorsque la valeur d'entrée est trop petite"""
    passer
classe ValeurLongueur(Exception) :
    """Augmenté lorsque la valeur saisie est vide """
    passer
classe ValueAlphabetic(Exception) :
    """Relevé lorsque la valeur est alphabétique"""
    passer

def checkvalue() :
    try :
        integervalue = input("Tapez quelque chose pour tester ceci : ") # Crée une chaîne de caractères ici
        si len(valeur entière) == 0 :
            augmenter la valeurLongueur
        elif integervalue.isalpha() :
            raise ValueAlphabetic
        elif int(integervalue) != 55 et int(integervalue) < 10 : # conversion en nombre entier pour permettre la comparaison
            Augmenter la valeur de la petite entreprise
        elif int(integervalue) != 55 et int(integervalue) > 10 : # conversion en nombre entier pour permettre la comparaison
            augmenter la valeurError
        d'autre part :
            imprimer ("55 saisi correctement")
    sauf ValueError :
        augmenter ValueError ("Integervalue needs to be fifty five")
    sauf TypeError :
        raise TypeError("Number needs to be entered")
    sauf ValueTooSmall :
        augmenter ValueTooSmall ("Le nombre doit être supérieur à 10")
    sauf ValueLength :
        augmenter ValueLength ("Le nombre doit être saisi, il ne peut pas être vide")
    sauf ValueAlphabetic :
        raise ValueAlphabetic ("Vous ne pouvez pas entrer une valeur alphabétique")
    enfin :
        imprimer ("Tous les contrôles sont terminés")


checkvalue()

Vous remarquerez que les classes que nous avons créées sont référencées dans le code pour appeler l'exception exacte que nous cherchons à capturer.

Pour cette raison, quels sont les avantages de l'aborder de cette manière :

  • Vous pouvez saisir des exceptions adaptées au code que vous écrivez.
  • Des contrôles peuvent être facilement créés et mis en œuvre afin de pouvoir signaler immédiatement les erreurs spécifiques dans vos données.
  • Si vous cherchez à repérer les mêmes exceptions dans de nombreux endroits, cette méthodologie vous aidera à mettre en place une meilleure structure pour les gérer.
  • Vous pouvez commencer à constituer un répertoire centralisé des exceptions et de la manière de les traiter.
  • Tous les contributeurs à votre projet savent comment soulever une exception en python, vous n'obtenez pas de multiples v différents.

Sur notre chaîne YouTube, vous pouvez vous abonner pour obtenir plus d'informations sur les exceptions et de nombreux conseils et astuces pour une meilleure analyse des données.

Laissez une réponse

Votre adresse électronique ne sera pas publiée. Les champs obligatoires sont marqués d'un *.