📄 Fichiers Textes

📖 DĂ©finition clĂ© : Un fichier texte est une structure de donnĂ©es persistante stockĂ©e sur une mĂ©moire de masse, composĂ©e d’une suite de caractĂšres organisĂ©s en lignes. Chaque ligne se termine par un caractĂšre spĂ©cial de fin de ligne et son accĂšs est sĂ©quentiel.

🔗 Ouverture, Fermeture et Modes

Opération Déclaration en Algorithme Déclaration en Python
Ouvrir / Fermer Ouvrir(NPh, NL, Mode)
Fermer(F)		 NL = open(NPh, Mode)
F.close()

⚠ Modes d’ouverture disponibles : "w" (Écriture), "r" (Lecture), "a" (Ajout).

✍ Écriture et Lecture

Opération Algorithme Python
Écriture Ecrire(NL, chaine) / Ecrire_nl(NL, chaine) NL.write(chaine) / NL.write(chaine + "\n")
Lecture Lire(NL, Variable) / Lire_ligne(NL, Variable) Variable = NL.read() / Variable = NL.readline()

🏆 Exercice 1 : Programme « Ville »

📋 ÉnoncĂ© : Écrire l’algorithme d’un programme nommĂ© « Ville » qui permet de :

  • CrĂ©er un fichier nommĂ© physiquement « villes.txt » et logiquement F.
  • Remplir le fichier F par les noms de N villes non vides (2 ≀ N ≀ 20), suivis du caractĂšre # et d’un entier reprĂ©sentant la quantitĂ© de pluie tombĂ©e.
  • Afficher le contenu du fichier ainsi que le nombre de villes ayant une quantitĂ© ≄ 10.

Programme Principal & TDO Globaux (TDOG)

Nom Type / Nature
N Entier
F Fichier texte (ou Texte)
Taille, Remplir, Afficher Procédure
Algorithme : 
Algorithme Programmation
DĂ©but
  Taille(N)
  Remplir(F, N)
  Afficher(F, N)
Fin
Python : 

N = taille()
remplir("villes.txt", N)
afficher("villes.txt", N)

Procédure Taille

Objet Local (TDOL) Type / Nature
Aucun (passage par rĂ©fĂ©rence @N) –
Algorithme : 
Procédure Taille (@N : entier)
DĂ©but
  Répéter
    Lire (N)
  Jusqu’à (2 ≀ N ≀ 20)
Fin
Python : 
def taille():
    N = int(input("Donner N (2<=N<=20) : "))
    while not (2 <= N <= 20):
        N = int(input("Donner N (2<=N<=20) : "))
    return N

Procédure Remplir

Objet Local (TDOL) Type / Nature
i, qte Entier
ch Chaine
Algorithme : 
Procédure Remplir (@F : Texte, N : entier)
DĂ©but
  Ouvrir ("villes.txt", F, "w")
  Pour i de 0 Ă  N-1 Faire
    Répéter
      Ecrire ("Ville ", i)
      Lire (ch)
    Jusqu’à long(ch) ≠ 0
    Répéter
      Ecrire ("quantité ")
      Lire (qte)
    Jusqu’à qte ≄ 0
    Ecrire_nl (F, ch + "#" + convch(qte))
  Fin pour
  Fermer(F)
Fin
Python : 
def remplir(nph, N):
    F = open(nph, "w")
    for i in range(N):
        ch = input(f"Ville {i} : ")
        while len(ch) == 0:
            ch = input(f"Ville {i} : ")
        qte = int(input("Quantité : "))
        while qte < 0:
            qte = int(input("Quantité : "))
        F.write(ch + "#" + str(qte) + "\n")
    F.close()

Procédure Afficher

Objet Local (TDOL) Type / Nature
i, Nb Entier
ch, X Chaine
Algorithme : 
Procédure Afficher (@F : Texte, N : entier)
DĂ©but
  Ouvrir ("villes.txt", F, "r")
  Nb ← 0
  Pour i de 0 Ă  N-1 Faire
    Lire_ligne(F, ch)
    X ← souschaine(ch, pos('#', ch) + 1, long(ch))
    Si valeur(X) ≄ 10 Alors
      Nb ← Nb + 1
    Fin si
    Ecrire (ch)
  Fin pour
  Ecrire("Le nombre de villes est ", Nb)
  Fermer(F)
Fin
Python : 
def afficher(nph, N):
    F = open(nph, "r")
    nb = 0
    for i in range(N):
        ch = F.readline()
        if len(ch) > 0 and ch[len(ch)-1] == '\n':
            ch = ch[:len(ch)-1]
        pos_hash = ch.find('#')
        if pos_hash != -1:
            x = ch[pos_hash+1:]
            if int(x) >= 10:
                nb += 1
        print(ch)
    print("Le nombre de villes est :", nb)
    F.close()

🏆 Exercice 2 : Remplir un fichier depuis une Matrice

📋 ÉnoncĂ© : Écrire l’algorithme d’un programme qui permet de :

  1. Remplir une matrice M par L*C entiers (2 < L < C < 10) comme le montre l’exemple suivant :
12345
678910
1112131415
  1. Copier chaque ligne de la matrice M dans une ligne du fichier texte nommé physiquement « contenu.txt » en séparant les nombres par un seul espace.

Tableau de DĂ©claration des Objets Globaux (TDO Globaux) & TDNT

Nom / Objet Type / Nature
Mat (TDNT) Tableau de 9 lignes * 9 colonnes d’entiers
NPH Chaine
M Mat
L, C Entier
RemplirM, RemplirF Procédure

Programme Principal

Algorithme : 
Algorithme Programmation
DĂ©but
  NPH ← "contenu.txt"
  RemplirM(L, C, M)
  RemplirF(L, C, M, NPH)
Fin
Python : 

    nph = "contenu.txt"
    remplir_m(L,C,M)
    remplir_f(L, C, M, nph)

Procédure RemplirM

Objet Local (TDOL) Type / Nature
i, j, k Entier
Algorithme : 
Procédure RemplirM(@L, C : Entier, @M : Mat)
DĂ©but
  Répéter
    Lire (L)
    Lire (C)
  Jusqu’à (2 < L < 10) Et (L < C < 10)
  K ← 1
  Pour i de 0 Ă  L-1 Faire
    Pour j de 0 Ă  C-1 Faire
      M[i,j] ← k
      K ← K + 1
    Fin pour
  Fin pour
Fin
Python : 
def remplir_m():
    L = int(input("Donner L (2 < L < 10) : "))
    C = int(input("Donner C (L < C < 10) : "))
    while not (2 < L < 10 and L < C < 10):
        L = int(input("Donner L (2 < L < 10) : "))
        C = int(input("Donner C (L < C < 10) : "))
    M = [[0]*9 for _ in range(9)]
    k = 1
    for i in range(L):
        for j in range(C):
            M[i][j] = k
            k += 1
    return L, C, M

Procédure RemplirF

Objet Local (TDOL) Type / Nature
i, j Entier
ch Chaine
F Fichier texte
Algorithme : 
Procédure RemplirF(L, C : Entier, M : Mat, NPH : chaßne)
DĂ©but
  Ouvrir (NPH, F, "w") 
  Pour i de 0 Ă  L-1 Faire
    ch ← ""
    Pour j de 0 Ă  C-1 Faire
      ch ← ch + convch(M[i,j]) + " "
    Fin pour
    Ecrire_nl (F, souschaine(ch, 0, long(ch)-1))
  Fin pour
  Fermer(F)
Fin
Python : 
def remplir_f(L, C, M, nph):
    F = open(nph, "w")
    for i in range(L):
        ch = ""
        for j in range(C):
            ch += str(M[i][j]) + " "
        if len(ch) > 0:
            ch = ch[:len(ch)-1]
        F.write(ch + "\n")
    F.close()

🏆 Exercice 3 : Programme « eleve »

📋 ÉnoncĂ© : Écrire l’algorithme d’un programme nommĂ© « eleve » qui permet de :

  • CrĂ©er un fichier nommĂ© physiquement « Listeeleve.txt » et logiquement F.
  • Remplir le fichier F par les prĂ©noms des N Ă©lĂšves (5 ≀ N ≀ 50) suivis d’un espace suivi de la moyenne M.
  • Afficher la liste des Ă©lĂšves admis (moyenne ≄ 10).
  • Afficher le nombre des Ă©lĂšves admis.

Programme Principal & TDO Globaux (TDOG)

Nom Type / Nature
N Entier
F Fichier texte (ou Texte)
Taille, Remplir, AfficherAdmis Procédure
Algorithme : 
Algorithme eleve
DĂ©but
  Taille(N)
  Remplir(F, N)
  AfficherAdmis(F, N)
Fin
Python : 

N = taille()
remplir("Listeeleve.txt", N)
afficher_admis("Listeeleve.txt", N)

Procédure Taille

Objet Local (TDOL) Type / Nature
Aucun (passage par rĂ©fĂ©rence @N) –
Algorithme : 
Procédure Taille (@N : entier)
DĂ©but
  Répéter
    Lire (N)
  Jusqu’à (5 ≀ N ≀ 50)
Fin
Python : 
def taille():
    N = int(input("Donner N (5<=N<=50) : "))
    while not (5 <= N <= 50):
        N = int(input("Donner N (5<=N<=50) : "))
    return N

Procédure Remplir

Objet Local (TDOL) Type / Nature
i Entier
prenom Chaine
moy RĂ©el
Algorithme : 
Procédure Remplir (@F : Texte, N : entier)
DĂ©but
  Ouvrir ("Listeeleve.txt", F, "w")
  Pour i de 0 Ă  N-1 Faire
    Répéter
      Ecrire ("Prénom élÚve ", i)
      Lire (prenom)
    Jusqu’à long(prenom) ≠ 0
    Répéter
      Ecrire ("Moyenne : ")
      Lire (moy)
    Jusqu’à (moy ≄ 0) Et (moy ≀ 20)
    Ecrire_nl (F, prenom + " " + convch(moy))
  Fin pour
  Fermer(F)
Fin
Python : 
def remplir(nph, N):
    F = open(nph, "w")
    for i in range(N):
        prenom = input(f"Prénom élÚve {i} : ")
        while len(prenom) == 0:
            prenom = input(f"Prénom élÚve {i} : ")
        moy = float(input("Moyenne : "))
        while not (0 <= moy <= 20):
            moy = float(input("Moyenne : "))
        F.write(prenom + " " + str(moy) + "\n")
    F.close()

Procédure AfficherAdmis

Objet Local (TDOL) Type / Nature
i, nb Entier
ch, p Chaine
m RĂ©el
Algorithme : 
Procédure AfficherAdmis (@F : Texte, N : entier)
DĂ©but
  Ouvrir ("Listeeleve.txt", F, "r")
  nb ← 0
  Ecrire("--- Liste des Ă©lĂšves admis ---")
  Pour i de 0 Ă  N-1 Faire
    Lire_ligne(F, ch)
    // Extraction du prénom et de la moyenne séparés par un espace
    p ← souschaine(ch, 0, pos(' ', ch) - 1)
    m ← valeur(souschaine(ch, pos(' ', ch) + 1, long(ch)))
    Si m ≄ 10 Alors
      nb ← nb + 1
      Ecrire (p, " - Moyenne : ", m)
    Fin si
  Fin pour
  Ecrire("Nombre total d'Ă©lĂšves admis : ", nb)
  Fermer(F)
Fin
Python : 
def afficher_admis(nph, N):
    F = open(nph, "r")
    nb = 0
    print("--- Liste des Ă©lĂšves admis ---")
    for i in range(N):
        ch = F.readline()
        if len(ch) > 0 and ch[len(ch)-1] == '\n':
            ch = ch[:len(ch)-1]
        pos_esp = ch.find(' ')
        if pos_esp != -1:
            p = ch[:pos_esp]
            m = float(ch[pos_esp+1:])
            if m >= 10:
                nb += 1
                print(p, "- Moyenne :", m)
    print("Nombre total d'Ă©lĂšves admis :", nb)
    F.close()