Cours 4 Mécanisme d’exceptions et lecture de fichiers

Trace d’erreur

• Une erreur d'exécution imprime une trace d'erreur Chemin d'exécution complet qui a provoqué l'erreur

def percentage(score: float, total:int) -> float:
  return score / total * 100

print('Alexis a obtenu', percentage(18, 20), '%')
print('Sébastien a obtenu', percentage(6, 0), '%')

Trace d’erreur

• L'erreur a comme origine l'exécution de l'instruction en ligne 5

• L'erreur est dans la fonction percentage()

• L'erreur est de type division par zéro

ZeroDivisionError: division by zero

Types d’erreur

• On peut considérer trois types d'erreur possibles
  • Erreur de syntaxe Code source mal formé
  • Erreur d'exécution Exécution d'une opération interdite
  • Erreur logique Programme ne calcule pas ce qu'il faut
• Le troisième type est le plus difficile à déceler Il faut pouvoir vérifier que le programme fait ce qu'il faut

Erreur de syntaxe

• Erreur détectée lors de l'exécution de l'instruction Python est en effet un langage interprété
• Code source du programme contient des fautes de syntaxe Un peu comme l'orthographe en français

score = 12
if score > 10
  print('Vous avez réussi !')

Erreur d'exécution

• Erreur produite durant l'exécution d'une opération interdite Division par zéro, indice en dehors d'une liste...

data = [1, 2, 3]

i = 0
while i <= len(data):
  print(data[i])
  i += 1

Erreur logique

• Le programme ne calcule pas ce qu'il faut Aucune erreur de syntaxe ou d'exécution ne se produit

def perimeter(length: float, width: float) -> float:
  return length + width * 2

print(perimeter(2, 1))

• Il peut être utile de décrire clairement ce que la fonction devrait faire Pour s'assurer qu'il y a bien une erreur

Documentation

• La documentation d'une fonction décrit le résultat produit Permet à un utilisateur d'interpréter le résultat de l'appel
• Description de conditions sur les paramètres Et de la valeur de retour si elles ne sont pas satisfaites

def percentage(score: float, total: int) -> Optional[float]:
  """Returns a grade as a percentage

  Args:
    `score`: the obtained grade. Must be positive and `<= total`
    `total`: the maximum grade obtainable. Must be positive

  Returns:
    the computed percentage
  """
  return score / total * 100

Documentation

• Conditions de la documentation non-respectées Le programme continue de fonctionner avec une valeur illogique

print(percentage(15, 20), '%')
print(percentage(22, 20), '%')

• Erreur de logique

Programmation défensive

• Vérification de conditions sensées être vraies avec assert On vérifie notamment les conditions sur les paramètres avec cette instruction
• Un programme doit fonctionner si on supprime les assertions Elles ne doivent pas faire partie du code fonctionnel

def percentage(score: float, total: int) -> float:
  """Returns a grade as a percentage

  Args:
    `score`: the obtained grade. Must be positive and `<= total`
    `total`: the maximum grade obtainable. Must be positive

  Returns:
    the computed percentage
  """
  assert total > 0, 'total must be positive'
  assert 0 <= score, 'score must be positive'
  assert score <= total, 'score must be <= total'

  return score / total * 100

Instruction assert

• Arrêt du programme en cas d'erreur d'assertion Avec affichage d'un message d'information
• Empêche des erreurs qui ne devraient pas se produire Le programme peut être modifié pour les éviter
• Augmente nos chances d’avoir une erreur d’exécution au lieu d’une erreur de logique Ce qui est trés désirable

print(percentage(15, 20), '%')
print(percentage(22, 20), '%')

• Se pratique sur du code dont vous avez le contrôle

Gestion d’erreurs

• Prendre en compte tous les cas possibles d'exécution Utilisation de if-else

from typing import Optional

def percentage(score: float, total: int) -> Optional[float]:
  """Returns a grade as a percentage

  Args:
    `score`: the obtained grade
    `total`: the maximum grade obtainable

  Returns:
    the computed percentage
    if `total <= 0`, `score < 0` or `score > total`, then returns `None`
  """
  if total > 0 and (0 <= score <= total):
    return score / total * 100
  return None

• Impact sur l’annotation du type de retour de la fonction
• Doit être pratiquée pour interface avec l'extérieur Vérification de toutes données hors contrôle

Mecanisme d’exceptions

• Gestion d’un code qui pourrait planter
• Code risqué placé dans un bloc try N'y placer que le code risqué et tout code qui en dépend
• Erreurs capturées dans le bloc except Y placer le code à exécuter en cas de capture d'une erreur

from datetime import *

birthyear = input('Année de naissance ? ')

try:
  now = datetime.now()
  age = now.year - int(birthyear)
  print('Tu as', age, 'ans')
except:
  print('Erreur')

Instruction try-except

• Si l'utilisateur entre un nombre entier, pas d'erreurs

• Si l'utilisateur n'entre pas un nombre entier, erreur capturée

Validité d'une donnée

• Demande d'une valeur à l'utilisateur en boucle Tant que la valeur demandée n'est pas du bon type

from datetime import *

valid = False
while not valid:
  birthyear = input('Année de naissance ? ')
  try:
    birthyear = int(birthyear)
    valid = True
  except:
    print('Veuillez entrer un nombre entier')

now = datetime.now()
age = now.year - birthyear
print('Tu as', age, 'ans')

Vérifier le type d'erreur

• Plusieurs types d'erreur sont possibles Division par zéro, erreur de conversion...
• Toutes les erreurs sont capturées par l'instruction except Possibilité de capturer les erreurs de manière spécifique

try:
  a = int(input('a ? '))
  b = int(input('b ? '))
  print(a, '/', b, '=', a / b)
except:
  print('Erreur')

Vérifier le type d'erreur

• Une exception est un objet qui représente une erreur L'objet est généralement de type Exception
• Types spécifiques pour différencier les types d'erreurs ZeroDivisionError, ValueError...

import sys

try:
  a = int(input('a ? '))
  b = int(input('b ? '))
  print(a, '/', b, '=', a / b)
except Exception as e:
  print(type(e))
  print(e)

Vérifier le type d'erreur

• Division par zéro

• Erreur de conversion

Capturer une erreur spécifique

• Gestionnaire d'erreurs différent pour chaque type d'erreur Il suffit de déclarer un bloc except par erreur à capturer
• Attention à l'ordre de capture (de haut en bas) Il faut classer les erreurs de la plus à la moins spécificité

import sys

try:
  a = int(input('a ? '))
  b = int(input('b ? '))
  print(a, '/', b, '=', a / b)
except ValueError:
  print('Erreur de conversion')
except ZeroDivisionError:
  print('Division par zéro')
except:
  print('Autre erreur')

Capturer une erreur spécifique

import sys

try:
  a = int(input('a ? '))
  b = int(input('b ? '))
  print(a, '/', b, '=', a / b)
except Exception:
  print('Erreur')
except ValueError:
  print('Erreur de conversion')
except ZeroDivisionError:
  print('Division par zéro')

Information sur une erreur

• L'objet de l'exception peut contenir de l'information On peut accéder à des propriétés ou à des méthodes

try:
  import mymod
except SyntaxError as e:
  print(e)
  print('File:', e.filename)
  print('Line:', e.lineno)
  print('Text:', e.text)

Gestionnaire d'erreurs partagé

• Même gestionnaire d'erreurs pour différents types Tuple d'exception fourni à l'instruction except

try:
  a = int(input('a ? '))
  b = int(input('b ? '))
  print(a / b)
except (ZeroDivisionError, ValueError):
  print('Erreur de calcul')
except:
  print('Erreur')

Propagation d'erreur

• Une erreur non capturée remonte les appels de fonction Jusqu'à être attrapée ou remonté jusqu'au bout
• La trace d'erreur montre le trajet pris par l'exception En la lisant à l'envers, on peut suivre la propagation

Propagation d'erreur

• Passage de fun à compute au programme principal

def fun():
  print(1 / 0)

def compute():
  fun()

compute()

Propagation d'erreur

• Exception interceptée dans la fonction compute

def fun():
  print(1 / 0)

def compute():
  try:
    fun()
  except:
    print('Erreur.')

compute()

Générer une erreur

• L'instruction raise permet de générer une erreur Création d'un objet du type de l'exception

def fact(n: int) -> int:
  """Compute the factorial of `n`

  Args:
      `n`: a positive integer

  Returns:
      The factorial of `n`

  Raises:
      ArithmeticError: if `n` is negative
  """
  if n < 0:
    raise ArithmeticError()
  if n == 0:
    return 1
  return n * fact(n - 1)

try:
  n = int(input('Entrez un nombre : '))
  print(fact(n))
except ArithmeticError:
  print('Veuillez entrer un nombre positif.')
except:
  print('Veuillez entrer un nombre.')

Définir une erreur

• Définition d'une erreur en définissant une nouvelle classe La classe est créée à partir de la classe Exception
• L'instruction pass ne fait rien

from math import sqrt

class NoRootException(Exception):
  pass

def trinomialroots(a: float, b: float, c: float) -> tuple[float, ...]:
  """Compute the real roots of a second-degree equation

  Args:
      `a`, `b` and `c`: The coefficients of the second-degree equation

  Returns:
      A tuple with one or two real roots

  Raises:
      NoRootException: if the equation has no real roots
  """
  delta = b ** 2 - 4 * a * c
  if delta < 0:
    raise NoRootException()
  if delta == 0:
    return (-b / (2 * a),)
  x1 = (-b + sqrt(delta)) / (2 * a)
  x2 = (-b - sqrt(delta)) / (2 * a)
  return (x1, x2)

Définir une erreur

• Capture de la nouvelle erreur avec l'instruction except Le nouveau type d'erreur est maintenant connu par Python

try:
  print(trinomialroots(1, 0, 2))
except NoRootException:
  print('Pas de racine réelle.')
except:
  print('Erreur')

Exception paramétrée

• Stockage d'un paramètre dans l'exception

from math import sqrt

class NoRootException(Exception):
  def __init__(self, delta):
      self.delta = delta

def trinomialroots(a: float, b: float, c: float) -> tuple[float, ...]:
  """Compute the real roots of a second-degree equation

  Args:
      `a`, `b` and `c`: The coefficients of the second-degree equation

  Returns:
      A tuple with one or two real roots

  Raises:
      NoRootException: if the equation has no real roots
  """
  delta = b ** 2 - 4 * a * c
  if delta < 0:
      raise NoRootException(delta)
  if delta == 0:
      return (-b / (2 * a),)
  x1 = (-b + sqrt(delta)) / (2 * a)
  x2 = (-b - sqrt(delta)) / (2 * a)
  return (x1, x2)

try:
  print(trinomialroots(1, 0, 2))
except NoRootException as e:
  print(f'Pas de racine réelle (delta = {e.delta})')
except:
  print('Erreur')

Exception avec dataclass

from math import sqrt
from dataclasses import dataclass

@dataclass
class NoRootException(Exception):
  delta: float

def trinomialroots(a: float, b: float, c: float) -> tuple[float, ...]:
  """Compute the real roots of a second-degree equation

  Args:
      `a`, `b` and `c`: The coefficients of the second-degree equation

  Returns:
      A tuple with one or two real roots

  Raises:
      NoRootException: if the equation has no real roots
  """
  delta = b**2 - 4 * a * c
  if delta < 0:
      raise NoRootException(delta)
  if delta == 0:
      return (-b / (2 * a),)
  x1 = (-b + sqrt(delta)) / (2 * a)
  x2 = (-b - sqrt(delta)) / (2 * a)
  return (x1, x2)

try:
  print(trinomialroots(1, 0, 2))
except NoRootException as e:
  print(f"Pas de racine réelle (delta = {e.delta})")
except:
  print("Erreur")

Fichier

• Un fichier stocke des informations sur le disque dur Il est créé, modifié, supprimé
• Manipulation des fichiers grâce au système d'exploitation L'interpréteur fait le relais avec Linux, Windows, Mac OS X...
• Des informations sont associées à un fichier Nom, taille, date de création, dernière date de modification...

Type de fichier

• Au plus bas niveau, un fichier est une séquence de bits (0 et 1) La séquence doit être interprétée pour en obtenir le sens
• Deux types de fichiers manipulés à des niveaux différents
  • Fichier texte est une séquence de caractères
  • Fichier binaire est une séquence d'octets (8 bits)

Chemin

• Fichier identifié sur une machine à l'aide de son chemin Identifie l'endroit où se situe le fichier
• Deux façons de spécifier un chemin
  • Chemin absolu à partir de la racine C:\ (Windows), / (OSX et Linux)
  • Chemin relatif à partir du répertoire courant

Navigation en ligne de commande

Pour passer d'un répertoire à l'autre dans une console de commandes

• pwd: Affiche le chemin du répertoire courant Base des chemins relatifs
• cd (suivi d'un chemin): Change de répertoire courant .. pour le répertoire parent
• dir (Windows) ou ls (OSX et Linux): Liste le contenu du répertoire

Ouverture d'un fichier

• Pour manipuler un fichier, il faut d'abord l'ouvrir On utilise la fonction open, qui renvoie un identifiant de fichier
• Erreurs possibles lors de l'ouverture Fichier introuvable, …

try:
  file = open('data.txt')
except FileNotFoundError:
  print('Le fichier est introuvable')
except IOError:
  print("Erreur d'ouverture")

Mode d'ouverture

• Par défaut, fichier ouvert en lecture seule Tout ce qu'on peut faire c'est donc lire le contenu du fichier
• On peut spécifier le mode d'ouverture désiré Avec le deuxième paramètre de la fonction open()

try:
  file = open('data.txt', 'w')         # Ouverture en écriture
except IOError:
  print("Erreur d'ouverture")

Mode d'ouverture

• Mode d'ouverture définit avec des caractères

try:
  file = open('data.txt', 'rt')         # Mode par défaut
except FileNotFoundError:
  print('Le fichier est introuvable')
except IOError:
  print("Erreur d'ouverture")

Fermeture d'un fichier

• Une fois les opérations finies, il faut fermer le fichier On utilise la méthode close avec l'identifiant de fichier
• Libération des ressources et sauvegarde sur disque Le système d'exploitation limite le nombre de fichiers ouverts

try:
  file = open('data.txt')
  file.close()                          # Fermeture du fichier
except FileNotFoundError:
  print('Le fichier est introuvable')
except IOError:
  print("Erreur d'ouverture")

Lecture

• Lecture intégrale du fichier comme une chaîne de caractères On utilise la méthode read avec l'identifiant de fichier
• La lecture peut échouer et provoquer une exception IOError Par exemple si le disque est déconnecté pendant la lecture

try:
  file = open('data.txt')
  print(file.read())
  file.close()
except FileNotFoundError:
  print('Le fichier est introuvable')
except IOError:
  print("Erreur d'entrée/sortie")

Instruction finally

• En cas d'erreur, le fichier pourrait ne pas être fermé Car l'exécution du code saute directement dans l'except
• Instruction finally exécutée dans tous les cas Après la fin du bloc try ou après un except éventuel

try:
  file = open('data.txt')
  print(file.read())
except FileNotFoundError:
  print('Le fichier est introuvable')
except IOError:
  print("Erreur d'ouverture")
finally:
  file.close()

Instruction finally

• Bug dans le code précédent si le fichier n'a pas su être ouvert La variable file ne sera pas initialisée et close pas disponible
• On utilise une instruction try/finally additionnelle

try:
  file = open('data.txt')
  try:
    print(file.read())
  finally:
    file.close()
except FileNotFoundError:
  print('Le fichier est introuvable')
except IOError:
  print("Erreur d'entrée/sortie")

Instruction with

• Instruction with pour fermeture propre des ressources L'appel à close sera fait automatiquement
• Il faut garder le try/except pour les IOError

try:
  with open('data.txt') as file:
    print(file.read())
except FileNotFoundError:
  print('Le fichier est introuvable')
except IOError:
  print("Erreur d'entrée/sortie")

Écriture

• Écriture en ajoutant des chaines de caractères au fichier On utilise la fonction write avec l'identifiant de fichier
• L'écriture peut échouer et provoquer une exception IOError Par exemple si l'espace disque devient plein pendant l'écriture

with open('out.txt', 'w') as file:
  file.write('Table de 10\n')
  for i in range(10):
    file.write(f'{i} x 10 = {i*10}\n')

Copie d'un fichier

• Copie en faisant une lecture puis écriture du contenu lu Deux instruction with imbriquées
• Si le fichier destination existe déjà, il est effacé Il faut utiliser le mode x au lieu de w pour empêcher cela

with open('data.txt', 'r') as src, open('copy.txt', 'w') as dest:
  dest.write(src.read())

Lecture ligne par ligne

• Utilisation d'un itérateur sur le fichier ouvert, avec for Parcours ligne par ligne, avec le retour de ligne inclus
• Fonction rstrip pour retirer les caractères blancs de droite right strip

Facebook:lur@ecam.be:lurk:8dj,Sj0m1
Skype:mar@ecam.be:cedou:arduino
Facebook:fle@ecam.be:fingerfood:b8ur,g2er

with open('data.txt') as file:
  for line in file:
    cleaned = line.rstrip()
    tokens = cleaned.split(':')
    print(f'Compte {tokens[0]} de {tokens[2]} (mode de passe : {tokens[3]})')

Lecture ligne par ligne

• L'itérateur est un raccourci d'appel de readline Lis une ligne s'il en reste à lire dans le fichier
• Renvoie une chaine de caractères vide lorsqu'au bout du fichier Pratique lorsqu'on sait combien de lignes lire

with open('data.txt') as file:
  line = file.readline()
  while line != '':
    cleaned = line.rstrip()
    tokens = cleaned.split(':')
    print(f'Compte {tokens[0]} de {tokens[2]} (mode de passe : {tokens[3]})')
    line = file.readline()

Lecture ligne par ligne

• La fonction readlines lis l'intégralité des lignes en une traite La fonction renvoie une liste de chaines de caractères
• On peut supprimer la variable cleaned inutile En enchainant directement les appels à rstrip et split

with open('data.txt') as file:
  content = file.readlines()

for line in content:
  tokens = line.rstrip().split(':')
  print(f'Compte {tokens[0]} de {tokens[2]} (mode de passe : {tokens[3]})')

Lecture ligne par ligne

• Amélioration du code avec une fonction de formatage On définit une fonction qui formate une ligne
• On définit une liste par compréhension et on joint ses éléments Jointure des éléments d'une liste réalisée avec fonction join

def format(line: str) -> str:
  tokens = line.rstrip().split(':')
  return f'Compte {tokens[0]} de {tokens[2]} (mode de passe : {tokens[3]})'

with open('data.txt') as file:
  content = file.readlines()

print('\n'.join([format(line) for line in content]))

Exception

• L'erreur principale d'entrée/sortie est IOError On peut se limiter à capturer cette unique erreur
• Erreur spécialisée selon le type précis
  • FileNotFoundError, si le fichier n'est pas trouvé
  • FileExistsError, si le fichier existe déjà
  • PermissionError, si l'utilisateur n'a pas les droits d'accès
  • IsADirectoryError, si le fichier est en fait un dossier

Encodage

• Les caractères sont stockés au format binaire dans l'ordinateur Table de correspondance associant un entier à chaque caractère
• La table de caractères ASCII (iso-646) contient 128 caractères Table suffisante pour des textes en anglais

Encodage

• La fonction ord donne le code d'un caractère Sous forme d'un nombre entier
• La fonction chr donne le caractère correspondant à un code Sous forme d'une chaine de caractères

print(chr(65))           # Affiche A
print(ord('z'))          # Affiche 90

Unicode et UTF-8

• Unicode (ISO 10646) est un standard d'échange de texte Associe à tout caractère un nom et un identifiant numérique
• UTF-8 est un encodage pour les caractères Unicode Python travaille par défaut avec l'encodage UTF-8

Choisir l'encodage

• On spécifie l'encodage des fichiers avec le paramètre encoding

with open('contains_unicode.txt', 'w', encoding='utf8') as file:
  file.write('😆')

with open('contains_unicode.txt', 'r', encoding='ascii') as file:
  print(file.read())