4. Fichiers et indexation

Données numériques

Une donnée informatique est un élément d'information ayant subi un encodage numérique

Consultable/manipulable/échangeable par des programmes informatiques
Possibilité de la conserver sur un support de stockage numérique (CD-ROM, disque dur, SSD, …)
- Les informations peuvent être stockés dans un fichier (ex : fichier csv).

Types de données

Données quantitatives:
- numérique entier ou réel, discrètes ou continues, bornées ou non. ex: poids, taille, âge, taux d’alcoolémie,…
- temporel : date, heure
- numéraire
- etc…
Données qualitatives:
- de type vrai/faux (données booléennes). ex: marié/non marié, majeur/non majeur
- de type appartenance à une classe. ex: célibataire/marié/divorcé/veuf, salarié/chômeur/retraité etc…
- de type texte (autrement dit “chaine de caractères”). ex: nom, prénom, ville,…

Donnée numérique

D'un point de vue informatique,
- il n'existe pas de distinction entre le quantitatif et le qualitatif.
- Tout est valeur numérique.
Une valeur numérique (digitale) consiste en:
- un champ de bits (dont la longueur est exprimée en octets)
- un processus de décodage : le format (ou type)

Donnée numérique

Les données manipulées par un programme:
- sont codées sous un format binaire,
- correspondant à un des types informatiques que vous connaissez déjà :
  - entier,
  - chaîne de caractères,
  - réel simple ou double précision etc…
- ce qui implique en particulier :
  - une précision finie,
  - éventuellement des contraintes de place (le nom ou le prénom ne pouvant pas dépasser n caractères, les entiers pouvant être choisis sur un intervalle fini etc…).

Types de données standard

INTEGER : entier (codage classique sur 4 octets),
FLOAT : nombre à virgule flottante simple précision (4 octets),
DOUBLE : nombre à virgule flottante double précision (8 octets),
CHAR : caractère (symbole sur 1 octet)
STRING : chaîne de caractères (un texte d,e longueur quelconque),
DATE, ex: '2005-12-12' (12 décembre 2005)
TIME, ex: '10:45:02' (10 h 45 min 2 s)
DATETIME, ex: '2005-12-12 10:45:02'
DECIMAL, ...

Production des données

Tout commence par une fiche à remplir…

Production des données

Tout commence par une fiche à remplir…

Un formulaire se présentant sous la forme d’un ensemble de rubriques à remplir.
Le modèle de fiche définit le format des données à enregistrer:
- liste des rubriques du formulaire,
- domaine de valeurs attendues dans chaque rubrique.
A toute fiche remplie correspond un jeu de valeurs (ou mesure) :
- liste de valeurs correspondant au contenu d’une fiche particulière.

D’un point de vue informatique, un jeu de valeurs recueilli est appelé un enregistrement
- correspondant à l’encodage des données recueillies sur un support numérique
Une structure de données définit les données de manière logique,
- c’est à dire l’ordre dans lequel elles doivent être lues
- et la manière dont elles doivent être interprétées par les programmes qui les utilisent.
Exemples de structures de données (cours d'algorithmie):
- listes,
- listes de listes,
- dictionnaires,
- arbres,…

Stockage des données

Transport des données

La transmission des données entre programmes nécessite l’ouverture d’un canal de communication:
- entre client et serveur
- par lequel transitent les données (les requêtes et les réponses).

Transport des données

Le transport est géré:
- par le système d’exploitation (lorsque les données transitent au sein d’un même ordinateur)
- ainsi que par des routeurs (lorsque les données transitent d’un ordinateur à l’autre sur le réseau).
Au niveau du client,
- les réponses en provenance du serveur sont organisées sous la forme d’une liste,
- qu’on appelle un flux de données.

Requête

En informatique, une requête (en anglais query)
- est une demande de consultation,
- effectuée par un programme client
- à l’attention d’un programme serveur.

Requête

Une requête peut être :
- une simple référence vers un fichier
- l’expression d’une recherche plus spécifique:
  - consultation de certaines fiches d’un fichier,
  - croisement d’information (entre plusieurs fichiers),
  - etc…)
- Dans ce cas, il est nécessaire d’utiliser un langage de requête (le plus souvent SQL).

Client/Serveur

Le programme client représente l’utilisateur, il s’agit du programme qui
- enregistre la demande de l’utilisateur,
- la transmet au serveur,
- puis met en forme visuellement la réponse du serveur.
Les données sont centralisées au niveau du serveur, chargé de :
- la gestion,
- de la manipulation
- et du stockage des données.
- Il traite la requête, consulte les données et transmet le résultat au client.

Types de requêtes

On distingue quatre grands types de requêtes (approche “CRUD”):
- Création (Create) : ajout de nouvelles données dans la base
- Lecture/recherche (Read) : consulation du contenu de la base
- Mise à jour (Update) : changement du contenu existant
- Suppression (Delete) : suppression des données obsolètes

Ordre des réponses

Exemples :

Requêtes http :
- demande de consultation d’une page web
- URL = référence vers un fichier
Moteur de recherche :
- recherche de pages contenant les mots-clés spécifiés
Bases de données : utilisation d’un langage de requête :

SELECT *
FROM  Eleves
WHERE NOM = 'Dugenou'

Ordre des réponses

Lors d’une consultation de type lecture/recherche,
- il y a souvent plusieurs réponses qui correspondent à la demande.
- Le résultat d’une requête prend donc la forme d’un ensemble de réponses.
- Ces réponses sont éventuellement classées,
  - selon la valeur d’un certain identifiant,
  - ou selon le degré de pertinence.

4.1 Mémoire

Données persistantes

Les données persistantes:
- sont une des composantes essentielles des programmes informatiques.
- Il s'agit par définition des informations qui doivent être conservées entre deux exécutions.
- les quantités de données conservées ont considérablement augmenté au cours des dernières décennies.
Nous aborderons:
- Le stockage de ces données sur un support informatique (Fichiers, bases de données)
- les méthodes permettant de consulter et mettre à jour régulièrement ces données.

Structure de stockage

La conservation des données repose principalement sur la structure de stockage,
- définissant la manière dont les données sont physiquement stockées sur le support,
- autrement dit la méthode de rangement de la série de mesures :
  - fichiers,
  - répertoires,
  - index,
  - etc…
- reposant sur des supports de stockage (ou mémoires) :
  - mémoire centrale,
  - mémoires secondaires (disque dur, CD-ROM, memoire flash (SSD), etc…).

Tableau statique

Le tableau statique correspond à l'organisation séquentielle fondamentale des mémoires informatique :

taille limitée du support matériel
données accessibles grâce à leur adresse (position dans le tableau)
problème de rangement:
- il faut conserver une information sur la position des données déjà enregistrées
- organisation logique des données sur le support.

Tableau statique

Dans un tableau statique T, la position des cases reste fixe au cours de l'utilisation :

T[i] désigne toujours la mếme zone mémoire
Analogie : les pages d'un cahier

Tableau dynamique

Dans un tableau dynamique (liste python par exemple), la position des cases varie au cours de l'utilisation :

T[i] ne désigne pas toujours la mếme zone mémoire
Analogie : briques de lego, puzzle glissant

Mémoires adressables

Les mémoires à accès aléatoire (Random Access Memory - RAM)
- stockent les données mémorisées dans un tableau statique
- les données sont consultables grâce à leur adresse
- L'adresse est l'équivalent pour la mémoire de l'index des tableaux de données

Adresse

Structure de stockage

Les mémoires informatiques sont des structures statiques. Une fois les données enregistrées, il est difficile d’insérer ou de supprimer des éléments.
La difficulté consiste à définir une organisation logique du tableau permettant de gérer efficacement un tel ensemble (qui peut être de grande taille) :
- savoir où enregistrer les données
- savoir comment les retrouver
On parle de structure de stockage. Une telle structure doit permettre :
- d’ajouter des données
- d'effacer des données
- d’accéder rapidement à une case particulière

Stockage dense

On considère un ensemble de k données stockés dans un tableau de données statique T de n cases (avec 0≤k ≤ n).
Propriété : les données sont stockés dans les k premières cases du tableau. Ainsi, les cases de 0 à k-1 sont occupées et l'indice k désigne la première case libre.

Stockage dense

Problème : définir des opérations :

de recherche
d'insertion
de suppression

qui conservent la propriété du tableau

Insertion : O(1)

Algo : insertion
Données :
  - d : donnée à insérer
  - T : tableau de données
  - k : indice
Début :
  T[k] <-- d
  k <-- k + 1
Fin

Recherche : O(k)

Algo : recherche
Données :
  - d : donnée à trouver
  - T : tableau de données
  - k : indice
Retourne :
  un indice
Début :
  pour i de 0 à k-1 :
    si T[i] = d:
      retourner i
  retourner -1
Fin

Suppression : O(k)

Algo : suppression
Données :
  - d : donnée à supprimer
  - T : tableau de données
  - k : indice
Début :
  i <-- recherche(d,T,k)
  si i != -1:
      T[i] <-- T[k-1]
      k <-- k-1
Fin

Stockage distribué

Table d'allocation:

On considère un tableau de taille $n dans lequel k < n$ cases sont occupées.
- Chaque bloc de données d est indexée par l'adresse $i < n$ donnant sa position dans le tableau
- On connaît également sa taille $m$
La table d'allocation donne pour chaque bloc :
- son adresse $i$
- le nombre $m$ de cases occupées
- un indicateur LIBRE/OCCUPE

Stockage distribué

Stratégies d'allocation

Plus proche choix : la liste des blocs libres est parcourue jusqu’à trouver un bloc de la taille demandée (ou sinon, le premier bloc de taille supérieure, qui est alors découpé en deux blocs).
- first fit : le premier bloc suffisamment grand pour les besoins
- best fit : le plus petit bloc qui ait une taille au moins égale à la taille demandée
- worst fit : le plus grand bloc disponible (qui est donc découpé)

Exercice

Écrire un algorithme permettant d'insérer une donnée $d$ de taille $m$ dans le premier bloc libre disponible (pensez à mettre à jour la table d'allocation $B$ ).

Algo : insertion
Données :
  - T: tableau de données
  - d: donnée à insérer
  - m: taille de la donnée
  - B: table d allocation
Retourne:
  adresse de d après insertion
Début
  pour tout triplet (i,m_i,f_i) dans B:
    si m_i <= m et f_i = LIBRE:
      T[i] <-- d
      supprimer (i, m_i, f_i) dans B
      insérer (i, m, OCCUPE) dans B
      insérer (i+m, m_i-m, LIBRE) dans B
      retourner i
  retourner -1
Fin

Liste dynamique

On appelle liste une structure abstraite ordonnée telle que:
- l'on puisse accéder de manière directe à l'élément i
- et à laquelle on puisse ajouter (et supprimer) autant d'éléments que l'on souhaite.

Une caractéristique importante de cette structure est son nombre d'éléments.

On commence par créer un tableau de taille n = 1, 
Le nombre initial d éléments est k = 0
A chaque ajout d élément:
    si k < n,
        ajouter l élément à la position k
        k ← k + 1
    sinon :
        allouer un tableau à 2 * n éléments
        n ← n * 2
        copier les k premiers éléments du tableau initial dans le nouveau tableau 
        supprimer le tableau initial
        ajouter l élément à la position k
        k ← k + 1

4.2 Indexation

Principe

Pour une gestion efficace des données,
- il est nécessaire de pouvoir identifier chaque enregistrement de façon unique.
L'indexation des données
- repose sur un principe simple d'étiquetage
- consistant à attribuer une étiquette différente à chaque enregistrement.
Cette étiquette peut être
- une suite de caractères arbitraires,
- un entier,
- ou un descripteur explicite.
On parle en général de clé ou d'identifiant pour désigner cette étiquette.

Définition

L'indexation des données consiste à attribuer à chaque donnée distincte un identifiant unique.
On parle également de clé de l'enregistrement:
On peut représenter l'opération d'indexation sous la forme d'une fonction:
- Si d est le jeu de valeurs
- id(d) désigne l'identifiant de ce jeu de valeurs

Unicité/spécificité

L'indexation suppose l'existence d'une bijection entre l'ensemble des données et l'ensemble des clés, permettant d'assurer l'unicité et la spécificité de la clé.

Soient $d_{1}$ et $d_{2}$ deux enregistrements,

Unicité :
- si $_{1} = d 2$ alors id $(_{1}) =id (_{2})$ .
Spécificité:
- si $id (_{1}) = id (_{2}), alors_{1} = d 2 .$

Fonction d'adressage

L'existence d'un identifiant unique pour chaque donnée $d$ permet la mise en œuvre d'une recherche par identifiant (ou recherche par clé).
La recherche par identifiant repose sur une fonction d'adressage H qui à tout identifiant id(d) associe sa position (adresse) ref(d) dans un tableau de données:

$H : ens. des identifiants \to ens. des adresses$

$id (d) \to ref (d)$

Ainsi si id est l'identifiant servant à la recherche, l'extraction des informations se fait en 2 étapes:
- $ref = H (id) (lecture de l'adresse des données)$
- $d = T [ref]$ (lecture de la donnée elle-même)

Mise en oeuvre

Exemple : avec des listes:

Soit une liste:

$L = ((id_{1:} ref 1), (id_{2:} ref 2), \dots,$ $(id_{N:} ref N))$

telle que id $_{1} <$ id $2 < \dots <$ id $N$ ,

La recherche de l'adresse dans lune liste triée s'effectue en O(log N) (recherche dichotomique).

Exemples d'adressages:

Table des matières (en-têtes de chapîtres) --> num de page
nom de variable --> valeur
chemin d'accès (fichiers) --> adresse des données sur le support physique
URL --> adresse IP (L'index est fourni par un serveur de noms)
code d'accès --> contenu

Définition : On appelle index la structure de données qui implémente la fonction d'adressage

Compacité

L'identifiant doit en pratique tenir sur un nombre d'octets le plus petit possible pour que la liste $L$ puisse être manipulée en mémoire centrale.
Autrement dit, il faut que :
- $| id(d) | < < | d |$
$$ pour que :
- $| L | < < | T |$ $$

Un identifiant entier, codé sur 4 octets, permet d'indexer jusqu'à données différentes.

2^{4\times8}\simeq 4\times 10⁹

Unicité des données et Structure d'ensemble

L'index assure l'unicité des données (pas de doublons).
Soit $E$ un ensemble de données indexées :
- $E = {_{1}, d 2, \dots, d K}$
$On a l'équivalence :$
- $d \in E \Leftrightarrowid (d) \in Index(E)$
$$ Ainsi, il ne peut y avoir de doublon car :
- ∀d∈ E, id $(d)$ est unique
- ∀ id ∈ Index(E) , ref $(id)$ est unique

Index

ref

Exemples d'indexation des données

L'exemple le plus simple d'indexation est celui fourni par les numéros de case d'un tableau.

Soit $T un tableau de n lignes,$ le numéro de case $i < n est à la fois :$
- $l'identifiant$
- $et l' adresse (la référence) de la ligne T [i]$

!! L'ajout ou la suppression

de données viole

le principe d'unicité

de l'index

Exemples d'indexation des données

Maintenance centralisée d'un index

Lors de l'ajout de nouvelles données, il est nécessaire de définir une méthode permettant d'assurer:
- l'unicité de l'identifiant
  - d --> id
- l'intégrité de l'index (fonction d'adressage)
  - id --> d

Exemples d'indexation des données

Exemple :

Le programme maintient une liste triée des identifiants déjà utilisées.
Lors de l'ajout d'une nouvelle donnée, il s'assure que l'identifiant n'est pas déjà présente dans la liste.
- Coût :
  - $O (n) en mémoire$
  - $O (log n) pour la vérification, O(n) pour l'ajout$

intégrité id--> d : OK
unicité d --> id : OK

Exemples d'indexation des données

Exemple :

Dans le cas où les identifiants sont des numéros (entiers), il est possible d'utiliser un compteur qui s'incrémente à chaque nouvelle insertion.
Coût :
- $O (n) en mémoire (adressage)$
- $O (1) pour l'ajout$

intégrité id--> d : OK
unicité d --> id : KO !!

Exemples d'indexation des données

Exemples d'indexation centralisée :

numéro INE (étudiants)
numéro URSSAF (sécurité sociale)
numéro d'immatriculation (véhicules)
numéro de compte en banque
code barre
etc.

Indexation pseudo-aléatoire : les fonctions de hachage

Utilisation d'une fonction de hachage :

H : ens des données --> ens. des identifiants

d --> id = H(d)

qui "calcule" la valeur de l'identifiant à partir des valeurs du jeu de valeurs à insérer.
La fonction de hachage doit être telle que la probabilité de choisir le même identifiant pour deux données différentes soit extrêmement faible.

unicité d --> id(d) : presque OK!

Etape 1 : transcodage binaire des données

id = int.from_bytes(d, byteorder='big')

avantage : les données différentes ont un code entier différent
mais : |int(d)| = |d| donc |id| =|d|

s = 'paul.poitevin@centrale-marseille.fr'
d = bytes(s, 'ascii')
id = int.from_bytes(d, byteorder='big')
print("id =", id

Donne :

id = 852806586114976881510056778471769180697471859150728801241505293627173168229624211058

!! viole le principe de compacité

Etape 2 : réduction du code

Soit i = int(d):

Méthode 1 : le modulo r (reste de la division entière par r)

id = H(i) = i mod r

Avantage :

code borné entre 0 et r
$| id | < < | d | dans le cas général$

Inconvénient:

deux données proches ou très similaires auront un index proche ou similaire : si j = i + 1, H(j) = H(i) + 1 (presque toujours)
ce codage revient à sélectionner les bits de poids faible
deux données différentes peuvent avoir le même code
—> il faut prendre r premier

Etape 2 : réduction du code

Soit i = int(d):

Méthode 2 : combiner produit et modulo – soient m et n deux nombres premiers entre eux:

k = H(i) = (i * m) mod n
Avantage :
- $| k | < < | d |$
- deux entiers proches donneront auront des codes très différents : si j = i + 1, j * m - i * m = m

Inconvénient :
- deux données différentes peuvent avoir le même code
- le produit i * m peut etre coûteux à calculer

Etape 2 : réduction du code

Soit i = int(d):

Méthode 3 : Hachage cryptographique :

Le hachage cryptographique est construit de telle sorte qu'il soit très difficile de trouver un entier j != i tel que H(i) = H(j).
Un tel code est appelé une "signature".
- Exemples :
  - MD4
  - SHA

Application : Table de hachage

Soit T un tableau de données statique de taille n
Soit H une fonction de hachage à valeurs sur [0, n-1]
La fonction de hachage est utilisée comme fonction d'adressage :
- d --> id(d) = H(d)
- id(d) = ref(d) est l'adresse utilisée pour stocker d dans le tableau!
Avantage :
- Pas besoin de maintenir un index
- Recherche/Insertion/Suppression en 0(1)
Inconvénient :
- stockage non dense : nécessite une table d'allocation
- risque de collision

unicité d --> id : presque OK !!
intégrité id --> d : OK

Application : Table de hachage dynamique

On commence par créer un tableau de taille n = 1, le nombre initial d'éléments étant m = 0

A chaque ajout d'un élément d : id <-- H(d)
- si T[id] n'est pas occupé,
  - ajouter l'élément à la position id
- sinon :
  - si T[id] != d
    - allouer un tableau à 2 * n éléments et n ← n * 2
    - copier les m premiers éléments du tableau initial dans le nouveau tableau & supprimer le tableau initial.
    - répéter l'opération si nécessaire jusqu'à pouvoir ajouter l'élément d à la position H(d)

unicité d --> id : OK !!
intégrité id --> d : OK

Application : structure d'ensemble dynamique

Définition : un ensemble dynamique est une structure de données proposant les fonctionnalités suivantes:
- Il existe un ensemble vide
- Il existe une fonction permettant de tester l'appartenance d'un élément d à l'ensemble
- il est possible d'ajouter et de retirer des éléments de l'ensemble
- ajouter d à un ensemble le contenant déjà est sans effet
- retirer d d'un ensemble ne le contenant pas est sans effet
La table de hachage dynamique permet d'implémenter une telle structure d'ensemble

Application : le dictionnaire

Définition : un dictionnaire est un index:
- Autrement dit est un ensemble dynamique de couples (id:d) où:
- - id est l'identifiant
  - d est la donnée associée à la clé
- respectant la contrainte d'intégrité uniquement (à tout identifiant est associée une donnée unique)
- Au lieu de la liste, l'index est une table de hachage dynamique sur les identifiants:
  - id --> H(id) --> T[H(id)] --> d
  - T[H(id)] référence la donnée en mémoire
- Insertion/recherche/suppression en O(1)!

Application : le dictionnaire

H(id)

unicité

intégrité

M E M O I R E

H - S E T

Exemple : le dictionnaire Python

Dictionnaire vide :

dict = {}

Initialisation :

commande  = {'entree': 2, 'plat': 4, 'dessert': 2, 'café': 1}

Ajout / modification :

commande['aperitif'] = 3
commande['café'] += 1

Suppression :

del commande['entree']

Test :

if 'café' in commande :
  commande['café'] += 1
else:
  commande['café'] = 1

Exemple : le dictionnaire Python

Le dictionnaire Python est une structure de données extrêmement flexible et expressive:

structures d'arbres et hiérarchies,
compteurs,
etc.

arbre = {val : 12,
         gauche: {val:6,
                  gauche:None,
                  droit:None},
         droit: {val:15,
                 gauche:None,
                 droit:None}}
        }

promo2022 = {'demi promo A' : 
             {
               'TD1' : 26,
               'TD2' : 25,
               ...
             },
             'demi promo B' : 
             {
               'TD6' : 27,
               'TD7' : 25,
               ...
             }
            }

4.3 Les fichiers

Volume

Le volume est le support sur lequel sont enregistrées les données.
On parle de mémoire secondaire (Disque dur, disquette,CD-ROM, etc…).
Un volume est divisé en pistes concentriques numérotées de 0 à n ( par ex n = 1024).
Chaque piste supporte plusieurs enregistrements physiques appelés secteurs, de taille constante (1 secteur = 1 page).

Page (ou secteur)

Les pages sont les unités de base pour la lecture et l'écriture.
une page est une zone contiguë de la mémoire secondaire qui peut être chargée en mémoire centrale en une opération de lecture.
Taille standard : une page = 1-2 ko.
La mémoire secondaire est donc organisée comme un tableau de pages : (T[0],…,T[n-1]),
- où n est le nombre de pages.
- Chaque page fait m octets.
- Chaque page peut être libre ou occupée (allocation).

Système d'exploitation et Fichiers

La mémoire secondaire n’est pas directement accessible (les programmes n’ont pas la possibilité d’aller écrire directement sur le disque).
La gestion des fichiers est une des fonctions essentielles des systèmes d’exploitation :
- possibilité de traiter et conserver des quantités importantes de données
- possibilité de partager des données entre plusieurs programmes.

Fichiers

A retenir :

Un fichier est une référence vers un ou plusieurs blocs de données, enregistrés sur un support physique.
Un fichier est caractérisé par son descripteur, constitué de
- son nom,
- son chemin d’accès,
- ses droits d’accès (lecture/écriture/exécution) selon les utilisateurs,
- sa position sur le support,
- sa taille, etc…

Accès aux données

Le système d’exploitation assure ainsi l’indépendance du programme par rapport à l’emplacement des données, au travers d’instructions d’entrée/sortie spécialisées:
- ouverture : initialisation d'un flux en lecture ou en écriture
- lecture : consultation des lignes l'une après l'autre (à partir de la première ligne), dans l'ordre où elles ont été écrites sur le support
- écriture : ajout de nouvelles données à la suite ou en remplacement des données existantes

Répertoires

Tous les descripteurs de fichiers sont regroupés dans une table des matières appelée Répertoire (Directory)
Organisation hiérarchique :
- Lorsque le nombre de fichiers est élevé, les descripteurs de fichiers sont classés dans plusieurs répertoires, organisés sous une forme arborescente.
- Le répertoire de plus bas niveau hiérarchique est appelé racine
- → chemin d’accès (path)

Consultation des données : ouverture en lecture (Read)

try :
  f = open('/chemin/vers/mon/fichier.dat','r')
except IOError:
  print "Erreur d'ouverture!"

Lorsque l’opération d’ouverture est réalisée avec succès,

le flux de données devient accessible en lecture
les premières lignes du fichier sont chargées en mémoire et une tête de lecture se positionne sur le premier caractère de la première ligne
Il ne reste plus qu’à lire les données.

Consultation des données : lecture des données (Read)

Lecture d'une ligne unique (readline)

Lecture de toutes les lignes (la lecture s’effectue dans une boucle) + affichage de la ligne:

s = f.readline()

for s in f :
  print s

Mise à jour: ouverture en écriture (Write)

try :
  f = open('/chemin/vers/mon/fichier.dat','w')
except IOError:
  print "Erreur d'ouverture!"

Lorsque l’opération d’ouverture est réalisée avec succès,

le flux de données devient accessible en écriture
Il ne reste plus qu’à écrire les données.

Mise à jour: ouverture en écriture (Write)

Ecriture d'un texte:

Lecture de toutes les lignes (la lecture s’effectue dans une boucle) + affichage de la ligne:

f.write("Commande enregistrée:")

for k in commande:
  f.write(k + ':' + str(commande(k)))