Aller au contenu
DevSecOps Logo DevSecOps Logo DevSecOps
Docs
Blog
Blog

Python, les fichiers, les exceptions et les fonctions

Mise à jour :

logo python

Dans le précédent guide, j’ai couvert les bases du langage Python, telles que la syntaxe générale, les types de données, les boucles et les conditions. Si vous avez suivi ce guide, vous avez désormais une bonne compréhension des fondamentaux du langage et êtes capable d’écrire des scripts simples et fonctionnels. Ce guide va plus loin en abordant des concepts plus avancés comme la gestion des fichiers, la gestion des exceptions, ainsi que la l’utilisation de fonctions et la création de fonctions personnalisées. Ces compétences vous permettront de créer des programmes Python plus robustes, flexibles et performants.

Gestion des fichiers en Python

La gestion des fichiers est une fonctionnalité essentielle en programmation, permettant de lire, écrire, modifier ou supprimer des fichiers directement depuis vos scripts. Python fournit des outils simples mais puissants pour travailler avec des fichiers. Dans ce chapitre, je vais vous montrer comment ouvrir, lire, écrire et manipuler des fichiers en Python de manière efficace et sécurisée.

Ouvrir et lire un fichier

L’une des opérations les plus courantes en programmation est la lecture d’un fichier. Pour ouvrir un fichier en Python, vous utilisez la fonction open(), qui prend en paramètre le chemin du fichier et le mode dans lequel vous souhaitez l’ouvrir.

Voici un exemple de lecture d’un fichier en mode lecture ('r'), qui est le mode par défaut :

# Ouverture d'un fichier en mode lecture
fichier = open('mon_fichier.txt', 'r')


# Lecture du contenu du fichier
contenu = fichier.read()


# Fermeture du fichier après utilisation
fichier.close()


# Affichage du contenu
print(contenu)

Explication :

  • open('mon_fichier.txt', 'r') : Ouvre le fichier en mode lecture ('r' pour read).
  • fichier.read() : Lit l’intégralité du fichier.
  • fichier.close() : Ferme le fichier une fois l’opération terminée. C’est une étape importante pour libérer les ressources utilisées par le fichier.

Utilisation du mot-clé with pour la gestion des fichiers

Oublier de fermer un fichier peut entraîner des fuites de mémoire ou d’autres problèmes dans votre programme. C’est pourquoi Python propose une méthode plus élégante pour ouvrir et fermer automatiquement les fichiers à l’aide du mot-clé with. L’avantage de cette approche est que le fichier sera fermé automatiquement à la fin du bloc d’instructions, même en cas d’erreur.

Voici un exemple utilisant with :

# Utilisation de 'with' pour gérer automatiquement l'ouverture et la fermeture du fichier
with open('mon_fichier.txt', 'r') as fichier:
    contenu = fichier.read()
    print(contenu)

Explication :

  • with open('mon_fichier.txt', 'r') as fichier : Ouvre le fichier et assigne son gestionnaire à la variable fichier.
  • contenu = fichier.read() : Lit le contenu du fichier.
  • fichier est automatiquement fermé à la fin du bloc with, sans avoir besoin d’appeler explicitement close().

Modes d’ouverture des fichiers

En fonction des actions que vous souhaitez effectuer sur un fichier, il est important de choisir le bon mode d’ouverture. Python propose plusieurs modes d’ouverture des fichiers qui vous permettent de lire, écrire ou ajouter du contenu. Voici les principaux modes disponibles :

  • 'r' : Mode lecture (par défaut). Utilisé pour lire un fichier. Si le fichier n’existe pas, une erreur FileNotFoundError est levée.
  • 'w' : Mode écriture. Crée un nouveau fichier si le fichier n’existe pas ou écrase le fichier existant. Si vous avez besoin de conserver les données du fichier existant, ce mode n’est pas recommandé.
  • 'a' : Mode ajout. Ajoute du contenu à la fin du fichier. Si le fichier n’existe pas, il sera créé.
  • 'r+' : Mode lecture et écriture. Vous pouvez à la fois lire et modifier le fichier. Le fichier doit déjà exister.
  • 'b' : Mode binaire. Utilisé avec les autres modes pour travailler avec des fichiers non-textuels, comme des images ou des fichiers audio.

Exemple d’écriture dans un fichier avec 'w' :

# Ouverture d'un fichier en mode écriture
with open('mon_fichier.txt', 'w') as fichier:
    fichier.write("Ceci est un fichier de test.\n")
    fichier.write("Une autre ligne de texte.")

Dans cet exemple, 'w' écrase tout contenu existant dans le fichier mon_fichier.txt et y écrit de nouvelles données.

Exemple d’ajout à un fichier avec 'a' :

# Ouverture d'un fichier en mode ajout
with open('mon_fichier.txt', 'a') as fichier:
    fichier.write("\nCette ligne est ajoutée à la fin.")

Lecture de lignes de fichier

Si vous travaillez avec de grands fichiers texte, vous souhaiterez probablement lire les données ligne par ligne plutôt que de charger tout le fichier en mémoire. Python offre plusieurs moyens de le faire, notamment via la méthode readline() ou en parcourant directement l’objet fichier.

Lecture ligne par ligne avec readline() :

with open('mon_fichier.txt', 'r') as fichier:
    ligne = fichier.readline()
    while ligne:
        print(ligne.strip())  # strip() pour retirer les espaces en trop et les retours à la ligne
        ligne = fichier.readline()

Lecture de toutes les lignes à la fois avec readlines() :

with open('mon_fichier.txt', 'r') as fichier:
    lignes = fichier.readlines()
    for ligne in lignes:
        print(ligne.strip())

Utilisation d’un itérateur sur le fichier :

with open('mon_fichier.txt', 'r') as fichier:
    for ligne in fichier:
        print(ligne.strip())

Manipulation des fichiers binaires

Si vous devez manipuler des fichiers non-textuels, comme des fichiers d’images ou des fichiers audio, vous devez ouvrir les fichiers en mode binaire en ajoutant le caractère 'b' au mode d’ouverture.

Exemple de lecture d’un fichier binaire :

# Lecture d'un fichier binaire
with open('image.png', 'rb') as fichier:
    donnees = fichier.read()
    print(donnees)

Exemple d’écriture dans un fichier binaire :

# Écriture dans un fichier binaire
with open('copie_image.png', 'wb') as fichier:
    fichier.write(donnees)

Gestion des Erreurs

La gestion des erreurs est un aspect fondamental dans de nombreux autres langages. En Python, les erreurs sont appelées “exceptions”. Une exception se produit lorsqu’une opération ne peut pas être effectuée correctement. Par exemple, une division par zéro provoque une exception.

Python offre un large éventail d’exceptions prédéfinies, telles que FileNotFoundError, ZeroDivisionError, ou encore IndexError, qui peuvent survenir dans diverses situations.

Utilisation de try

La manière la plus courante de gérer les exceptions en Python est d’utiliser un bloc try / except. Le bloc try contient le code susceptible de générer une exception, tandis que le bloc except spécifie ce qui doit être fait si une exception survient.

Voici un exemple d’utilisation de try et except pour gérer une exception de division par zéro :

try:
    resultat = 10 / 0
except ZeroDivisionError:
    print("Division par zéro n'est pas autorisée.")
  • Le bloc try contient le code qui peut générer une exception.
  • Le bloc except spécifie quel type d’exception vous souhaitez gérer et définit le code à exécuter en cas d’exception.

Utilisation du bloc else

Le bloc else permet de spécifier du code qui doit être exécuté si aucune exception n’est levée dans le bloc try. Cela peut être utile si vous souhaitez exécuter des instructions uniquement si tout se passe bien.

Exemple d’utilisation de else :

try:
    fichier = open('mon_fichier.txt', 'r')
except FileNotFoundError:
    print("Erreur : Le fichier n'existe pas.")
else:
    # Ce bloc sera exécuté seulement si aucune exception n'est levée
    contenu = fichier.read()
    print(contenu)

Utilisation de finally

En plus de try et except, Python propose également le bloc finally. Ce bloc est exécuté quel que soit le résultat (exception ou pas). Il est souvent utilisé pour effectuer des opérations de nettoyage, telles que la fermeture de fichiers.

Exemple d’utilisation de finally :

try:
    fichier = open("mon_fichier.txt", "r")
    contenu = fichier.read()
except FileNotFoundError:
    print("Le fichier n'existe pas.")
finally:
    fichier.close()  # Assurez-vous de fermer le fichier, que l'exception se produise ou non.

Gestion de plusieurs exceptions

Il est possible qu’un bloc de code génère différents types d’exceptions. Python permet de gérer plusieurs types d’exceptions dans un seul bloc try en ajoutant plusieurs blocs except, chacun traitant un type d’exception particulier.

Exemple de gestion de plusieurs exceptions :

try:
    fichier = open('fichier_inexistant.txt', 'r')
    resultat = 10 / 0  # Cela provoquera une ZeroDivisionError
except FileNotFoundError:
    print("Erreur : Le fichier n'existe pas.")
except ZeroDivisionError:
    print("Erreur : Division par zéro.")

Dans cet exemple, si le fichier n’existe pas, Python exécutera le bloc except FileNotFoundError. Si le fichier existe mais qu’une division par zéro se produit, Python exécutera le bloc except ZeroDivisionError.

Capturer toutes les exceptions avec Exception

Si vous ne savez pas quel type d’exception peut survenir ou si vous souhaitez capturer toutes les exceptions, vous pouvez utiliser Exception. Cependant, cette pratique doit être utilisée avec précaution, car elle pourrait masquer des erreurs inattendues.

Exemple de capture de toutes les exceptions :

try:
    fichier = open('fichier_inexistant.txt', 'r')
    resultat = 10 / 0
except Exception as e:
    print(f"Une erreur est survenue : {e}")

Ici, Exception capture toutes les exceptions, quelle que soit leur nature. La variable e contient le message de l’exception qui s’est produite, permettant ainsi d’afficher des informations utiles sur l’erreur.

L’instruction raise

Vous pouvez également générer vos propres exceptions en utilisant l’instruction raise. Cela peut être utile lorsque vous souhaitez signaler une erreur spécifique à votre programme.

Exemple d’utilisation de raise :

def diviser(a, b):
    if b == 0:
        raise ValueError("La division par zéro n'est pas autorisée.")
    return a / b


try:
    resultat = diviser(10, 0)
except ValueError as e:
    print(e)
  • Vous pouvez personnaliser le message d’erreur en utilisant raise.
  • L’exception générée est du type ValueError avec le message spécifié.

Utilisation de assert

L’instruction assert est utilisée pour vérifier une condition. Si la condition est fausse, une exception AssertionError est levée. Cela peut être utile pour effectuer des vérifications de base dans votre code.

Exemple d’utilisation de assert :

age = 15
assert age >= 18, "L'âge doit être d'au moins ans pour accéder."

Si l’âge est inférieur à 18, une exception AssertionError est levée avec le message spécifié.

La gestion des erreurs en Python est un élément essentiel pour rendre vos programmes plus robustes et fiables. En comprenant les exceptions courantes et en utilisant try, except, finally, raise et assert, vous pouvez gérer efficacement les situations imprévues.

Gestion des erreurs lors de la manipulation de fichiers

Lorsque vous travaillez avec des fichiers, des erreurs peuvent survenir, comme le fichier qui n’existe pas ou l’impossibilité de lire un fichier pour diverses raisons. Il est donc important de gérer ces erreurs en utilisant un bloc try / except.

Exemple de gestion des erreurs sur la lecture d’un fichier :

try:
    with open('fichier_inexistant.txt', 'r') as fichier:
        contenu = fichier.read()
except FileNotFoundError:
    print("Erreur : Le fichier n'existe pas.")

Bien sûr ! Voici un nouveau chapitre sur les fonctions fournies par le langage Python, également appelées fonctions intégrées ou built-in functions. Ces fonctions sont disponibles sans avoir besoin d’importer de module supplémentaire et constituent des outils puissants pour effectuer des opérations courantes de manière simple et efficace.

Les fonctions intégrées en Python

Python est livré avec un ensemble de fonctions intégrées qui vous permettent d’accomplir des tâches courantes sans avoir à écrire de code supplémentaire ou à importer de bibliothèques externes. Ces fonctions sont accessibles directement et couvrent une grande variété de besoins, comme la manipulation des types de données, l’entrée/sortie, et les calculs mathématiques simples.

Introduction aux fonctions intégrées

Les fonctions intégrées, ou built-in functions, sont incluses dans le langage Python par défaut. Elles peuvent être utilisées à tout moment et dans n’importe quel programme. Il n’est pas nécessaire de les importer via un module. Voici quelques exemples de fonctions intégrées que vous avez peut-être déjà rencontrées :

  • print() : Affiche un message à l’écran.
  • len() : Retourne la longueur (le nombre d’éléments) d’une liste, chaîne de caractères ou autre type séquentiel.
  • type() : Retourne le type de la variable ou de l’objet passé en argument.
  • input() : Permet à l’utilisateur d’entrer une valeur via la console.

Nous allons maintenant explorer certaines des fonctions les plus utilisées.

Fonctions de base pour les entrées et sorties

print()

La fonction print() est l’une des fonctions les plus couramment utilisées en Python. Elle permet d’afficher des informations à l’écran.

print("Bonjour, Python !")  # Affiche "Bonjour, Python !"

Vous pouvez aussi afficher plusieurs éléments en les séparant par des virgules :

nom = "Alice"
age = 25
print("Nom:", nom, "Âge:", age)  # Affiche "Nom: Alice Âge: 25"

input()

La fonction input() permet de demander à l’utilisateur de saisir une valeur via la console. Par défaut, elle renvoie la valeur sous forme de chaîne de caractères.

nom = input("Entrez votre nom: ")
print("Bonjour", nom)

Si vous avez besoin d’un type spécifique (par exemple, un entier), vous devrez convertir la valeur en utilisant des fonctions comme int().

age = int(input("Entrez votre âge: "))
print("Vous avez", age, "ans.")

Fonctions de conversion de type

Python inclut des fonctions pour convertir entre différents types de données. Voici quelques-unes des plus courantes :

  • int() : Convertit une chaîne de caractères ou un nombre à virgule flottante en un entier.
  • float() : Convertit une chaîne ou un entier en un nombre flottant.
  • str() : Convertit une valeur en chaîne de caractères.
  • list() : Convertit un itérable (comme une chaîne de caractères ou un tuple) en une liste.
x = "100"
y = int(x)  # Convertir une chaîne de caractères en entier
z = float(x)  # Convertir une chaîne en nombre flottant


print(y + 1)  # Affiche 101
print(z + 0.5)  # Affiche 100.5

Fonctions mathématiques de base

Python offre des fonctions intégrées pour effectuer des calculs mathématiques de base.

abs()

La fonction abs() renvoie la valeur absolue d’un nombre, c’est-à-dire la distance entre ce nombre et zéro.

x = -5
print(abs(x))  # Affiche 5

round()

La fonction round() permet d’arrondir un nombre flottant au nombre de décimales spécifié.

x = 3.14159
print(round(x, 2))  # Affiche 3.14

Si vous ne spécifiez pas de décimales, le nombre sera arrondi à l’entier le plus proche.

Fonctions sur les séquences

Python propose plusieurs fonctions intégrées qui permettent de travailler avec les séquences, comme les chaînes de caractères, les listes et les tuples.

len()

La fonction len() retourne la longueur d’une séquence, c’est-à-dire le nombre d’éléments qu’elle contient.

nom = "Alice"
nombres = [1, 2, 3, 4, 5]


print(len(nom))  # Affiche 5
print(len(nombres))  # Affiche 5

max() et min()

Les fonctions max() et min() permettent de retourner respectivement la valeur maximale et la valeur minimale dans une séquence.

nombres = [10, 20, 5, 40, 15]


print(max(nombres))  # Affiche 40
print(min(nombres))  # Affiche 5

sum()

La fonction sum() retourne la somme des éléments d’une séquence numérique.

nombres = [1, 2, 3, 4, 5]
print(sum(nombres))  # Affiche 15

Fonctions utiles pour les objets et types

type()

La fonction type() renvoie le type de l’objet passé en argument. Cela peut être utile pour vérifier la nature des variables.

x = 42
y = "Python"
z = [1, 2, 3]


print(type(x))  # Affiche <class 'int'>
print(type(y))  # Affiche <class 'str'>
print(type(z))  # Affiche <class 'list'>

isinstance()

La fonction isinstance() permet de vérifier si un objet appartient à un type spécifique. Elle retourne True ou False.

x = 42
print(isinstance(x, int))  # Affiche True
print(isinstance(x, str))  # Affiche False

Autres fonctions intégrées utiles

Pour consulter l’intégralité des fonctions intégrées disponibles, vous pouvez vous référer à la documentation officielle de Python : https://docs.python.org/3/library/functions.html ↗.

Écrire vos propre fonctions

Les fonctions en Python sont des blocs de code réutilisables qui permettent de structurer votre programme et de le rendre plus lisible, maintenable et modulaire. Une fonction est définie une seule fois et peut être appelée plusieurs fois, ce qui vous évite de réécrire le même code à plusieurs endroits. Les fonctions sont essentielles dans n’importe quel programme, car elles permettent d’organiser le code de manière logique et de le rendre plus clair.

Définition d’une fonction

En Python, les fonctions sont définies à l’aide du mot-clé def, suivi du nom de la fonction, des paramètres (le cas échéant) entre parenthèses, et enfin d’un bloc de code indenté qui constitue le corps de la fonction.

def nom_de_la_fonction(parametres):
    # Bloc de code qui définit ce que fait la fonction
    return valeur

Le mot-clé return est utilisé pour renvoyer une valeur depuis la fonction, mais il est optionnel. Si une fonction ne retourne rien explicitement, elle renvoie None par défaut.

Exemple simple de fonction :

def dire_bonjour():
    print("Bonjour, tout le monde!")

Dans cet exemple, la fonction dire_bonjour() ne prend aucun paramètre et affiche simplement “Bonjour, tout le monde!” lorsque vous l’appelez.

Appeler une fonction

Une fois que vous avez défini une fonction, vous pouvez l’appeler à tout moment dans votre programme. Pour appeler une fonction, il suffit d’utiliser son nom suivi de parenthèses (et de passer des arguments si nécessaire).

Exemple d’appel de fonction :

# Définition de la fonction
def dire_bonjour():
    print("Bonjour, tout le monde!")


# Appel de la fonction
dire_bonjour()  # Affiche "Bonjour, tout le monde!"

Ici, dire_bonjour() est appelé, ce qui exécute le code à l’intérieur de la fonction.

Fonctions avec des paramètres

Les fonctions peuvent également accepter des paramètres, qui sont des valeurs que vous transmettez à la fonction pour qu’elle les utilise. Ces paramètres permettent de rendre les fonctions plus flexibles et réutilisables.

Exemple avec paramètres :

def dire_bonjour(nom):
    print(f"Bonjour, {nom}!")


# Appel de la fonction avec un argument
dire_bonjour("Alice")  # Affiche "Bonjour, Alice!"

Dans cet exemple, la fonction dire_bonjour() accepte un paramètre appelé nom, qui est utilisé pour personnaliser le message de bienvenue. Lors de l’appel de la fonction, vous transmettez une valeur ("Alice" dans ce cas), et la fonction l’utilise pour générer un message spécifique.

Paramètres avec valeurs par défaut

Python permet également de définir des valeurs par défaut pour les paramètres d’une fonction. Si un argument n’est pas fourni lors de l’appel de la fonction, la valeur par défaut sera utilisée. Cela rend les fonctions encore plus flexibles.

Exemple avec des paramètres par défaut :

def dire_bonjour(nom="tout le monde"):
    print(f"Bonjour, {nom}!")


# Appel avec et sans argument
dire_bonjour()        # Affiche "Bonjour, tout le monde!"
dire_bonjour("Alice")  # Affiche "Bonjour, Alice!"

Dans cet exemple, si aucun argument n’est passé à la fonction dire_bonjour(), le paramètre nom prend la valeur par défaut "tout le monde".

Paramètres nommés (ou mots-clés)

Lorsque vous appelez une fonction, vous pouvez aussi préciser quel paramètre vous souhaitez assigner en utilisant des paramètres nommés. Cela permet d’améliorer la clarté de l’appel et d’éviter les erreurs liées à l’ordre des arguments.

Exemple avec paramètres nommés :

def saluer(prenom, nom):
    print(f"Bonjour, {prenom} {nom}!")


# Utilisation des paramètres nommés
saluer(prenom="Jean", nom="Dupont")  # Affiche "Bonjour, Jean Dupont!"

Dans cet exemple, vous spécifiez clairement quel argument correspond à quel paramètre, ce qui rend le code plus lisible et évite de devoir respecter un ordre précis.

Fonctions avec des arguments variadiques (*args)

Il est parfois nécessaire de définir une fonction capable d’accepter un nombre variable d’arguments. Pour cela, Python offre la possibilité d’utiliser *args, qui permet de passer une liste d’arguments à une fonction.

Exemple avec *args :

def additionner(*nombres):
    return sum(nombres)


# Appel de la fonction avec différents nombres d'arguments
print(additionner(1, 2, 3))      # Affiche 6
print(additionner(5, 10, 15, 20))  # Affiche 50

Dans cet exemple, la fonction additionner() peut accepter un nombre illimité d’arguments grâce à *args. Tous les arguments passés sont ensuite traités comme une liste.

Fonctions avec des arguments nommés variadiques (**kwargs)

De la même manière que *args permet de passer un nombre variable d’arguments positionnels, **kwargs permet de passer un nombre variable d’arguments nommés. Ceux-ci sont traités comme un dictionnaire à l’intérieur de la fonction.

Exemple avec **kwargs :

def afficher_infos(**infos):
    for cle, valeur in infos.items():
        print(f"{cle}: {valeur}")


# Appel de la fonction avec des arguments nommés
afficher_infos(nom="Dupont", age=30, ville="Paris")

Dans cet exemple, la fonction afficher_infos() accepte un nombre illimité d’arguments nommés et les affiche sous forme de clé-valeur.

Fonctions imbriquées

Python vous permet de définir des fonctions imbriquées, c’est-à-dire des fonctions à l’intérieur d’autres fonctions. Cela peut être utile pour structurer du code complexe ou pour encapsuler certaines logiques spécifiques qui ne sont pas nécessaires en dehors d’une fonction particulière.

Exemple de fonction imbriquée :

def fonction_exterieure(texte):
    def fonction_interieure():
        print(texte)
    fonction_interieure()


# Appel de la fonction extérieure
fonction_exterieure("Bonjour, Python !")  # Affiche "Bonjour, Python !"

Dans cet exemple, fonction_interieure() est définie à l’intérieur de fonction_exterieure(), et elle accède à la variable texte qui est dans la portée de la fonction extérieure.

La fonction main

La fonction main est un concept couramment utilisé dans les programmes Python (et dans de nombreux autres langages de programmation) pour organiser l’exécution principale du script. Bien qu’il n’y ait pas de fonction main réservée en Python (contrairement à des langages comme C ou Java), il est recommandé d’utiliser une fonction main() pour structurer votre code et pour gérer l’exécution principale du programme.

L’utilisation d’une fonction main() présente plusieurs avantages :

  1. Clarté et organisation : Regrouper la logique principale de votre programme dans une fonction main() rend le code plus clair et facile à comprendre. On sait exactement où se trouve le point d’entrée du programme.
  2. Réutilisabilité : Vous pouvez réutiliser votre code sous forme de module (importé dans un autre programme) sans que la logique principale soit exécutée par défaut. Cela est utile dans des projets plus vastes.
  3. Modularité : La fonction main() vous permet d’appeler d’autres fonctions, ce qui améliore la structure et la modularité de votre code.

Exemple simple avec main() :

def main():
    print("Ceci est le point d'entrée principal du programme.")
    # Vous pouvez appeler d'autres fonctions ici
    dire_bonjour("Alice")


def dire_bonjour(nom):
    print(f"Bonjour, {nom} !")


# Lancement de la fonction main
if __name__ == "__main__":
    main()

Explication :

  • def main() : Cette fonction contient la logique principale du programme. Dans cet exemple, elle affiche un message et appelle la fonction dire_bonjour().
  • if __name__ == "__main__" : Cette condition vérifie si le script est exécuté directement (c’est-à-dire, non importé comme un module). Si le script est exécuté directement, main() est appelée.

En Python, chaque fichier est potentiellement un module, et chaque module a une variable spéciale appelée __name__. Cette variable indique si le fichier est exécuté directement ou s’il est importé dans un autre fichier.

  • __name__ == "__main__" signifie que le script est exécuté directement.
  • Si le script est importé dans un autre fichier, la condition if __name__ == "__main__" est fausse, et main() ne sera pas appelée.

Cela permet de protéger le code dans main() de ne pas être exécuté lorsque le fichier est importé comme un module dans un autre script.

Exercice

L’objectif de ce programme est de lire un fichier texte contenant des informations sur des utilisateurs, traiter ces informations, et les afficher de manière formatée. Le programme est conçu pour gérer les erreurs courantes, comme l’absence du fichier ou un mauvais formatage des données dans le fichier.

Ce que doit contenir le programme :

  1. Une fonction pour lire le fichier : Le programme lit un fichier texte contenant des informations utilisateur. Le fichier contient plusieurs lignes, chaque ligne ayant le format : nom,age,ville.
  2. Une fonction pour traiter les lignes : Le programme doit analyser chaque ligne, en extraire les informations, et les traiter.
  3. Une fonction pour afficher les informations : Le programme doit afficher les informations extraites (nom, âge, ville) de manière lisible.
  4. Gestion des erreurs :
    • Gérer les erreurs lorsque le fichier est absent (afficher un message approprié).
    • Gérer les erreurs lorsque certaines lignes sont mal formatées (afficher un message indiquant la ligne problématique).
  5. Une fonction principale : C’est le point d’entrée du programme qui gère l’exécution des différentes étapes.

Fonctionnement du programme :

  1. Lecture du fichier texte :
    • Le programme commence par lire un fichier texte contenant des informations d’utilisateurs.
    • Le fichier à lire s’appelle utilisateurs.txt et doit être placé dans le même répertoire que le programme.
    • Chaque ligne du fichier doit être formatée comme ceci : nom,âge,ville. Par exemple : 
      Alice,30,Paris
      Bob,25,Lyon
  2. Gestion des erreurs lors de la lecture :
    • Si le fichier n’existe pas, le programme affiche un message d’erreur : Erreur : Le fichier 'utilisateurs.txt' n'a pas été trouvé.
    • Si le fichier est trouvé, il lit toutes les lignes et les renvoie pour être traitées.
  3. Traitement des lignes :
    • Le programme analyse chaque ligne lue à partir du fichier.
    • Il s’attend à ce que chaque ligne soit correctement formatée avec trois éléments séparés par des virgules : nom, âge, ville.
    • Si une ligne n’est pas correctement formatée, le programme affiche un message d’erreur spécifique à cette ligne : Erreur de format : 'ligne' ne contient pas les informations attendues.
  4. Affichage des informations :
    • Pour chaque ligne correctement formatée, le programme affiche les informations de l’utilisateur de manière claire : Nom: Alice, Âge: 30, Ville: Paris
  5. Exécution du programme :
    • Lorsque le programme est lancé, il exécute la fonction principale, qui lit le fichier, traite les lignes et affiche les résultats.

Conclusion

En conclusion, ce guide vous a permis de découvrir des concepts avancés de Python, tels que la gestion des fichiers, les exceptions, et la création de fonctions. En maîtrisant ces notions, vous êtes désormais capable d’écrire des programmes plus robustes et mieux structurés, facilitant ainsi la maintenance et l’extensibilité de votre code.

Pa la suite, nous explorerons des aspects encore plus poussés, tels que l’utilisation des bibliothèques Python les plus populaires, et leur création.