Plan du site  
français  English
pixel
pixel

Articles - Étudiants SUPINFO

Chapitre 07 - Autres structures de données

Ensembles

Le but de cette partie est d'introduire deux structures de données non séquentielles, très proches de la notion d'ensemble mathématique.

Types "set" et "frozenset"

Le langage Python possède deux types de structures de données implémentant la notion d’ensemble mathématique :

  • Le type set qui est une structure muable.

  • Le type frozenset qui est une structure immuable.

Rappelons qu'en mathématiques le terme ensemble désigne une collection d'éléments distincts. Il en sera de même en Python, un ensemble ne pourra pas contenir deux fois le même élément. Lors de sa création ou lors de sa mise à jour, les doublons seront donc supprimés automatiquement.

Autre propriété de ces structures de données, elles ne sont pas séquentielles. L’accès à un élément ne se fait donc pas par sa position.

Figure 1.1. Visualisation d'un ensemble de plusieurs éléments

Visualisation d'un ensemble de plusieurs éléments

Voici quelques syntaxes possibles pour déclarer un ensemble de type set :

monSetVide = set()

monSet = {element1,element2,...,elementN}

monSet = set(sequence)

Example 1.1. Déclarations d'ensembles de type set

On déclare des ensembles de type set en utilisant les différentes syntaxes précédentes :

>>> s = {1, 3, 5, 7, 9}
>>> s
{9, 3, 1, 5, 7}
>>> s = set('barbara')
>>> s
{'a', 'b', 'r'}
>>> s = set(range(10,21,2))
>>> s
{10, 12, 14, 16, 18, 20}

On retrouve bien sur ces exemples le côté non ordonné et la suppression des doublons.

Pour bien fixer les idées, voici une petite représentation du premier des ensembles précédents :


Voici maintenant quelques syntaxes possibles pour déclarer un ensemble de type frozenset :

monFrozenSetVide = frozenset()

monFrozenSet = frozenset(sequence)

monFrozenSet = frozenset(ensemble)
[Note]

Un frozenset étant non modifiable, en déclarer un vide n'est pas d'une grande utilité. C'est cependant possible.

Example 1.2. Déclarations d'ensembles de type frozenset

On déclare des ensembles de type frozenset en utilisant les différentes syntaxes précédentes :

>>> s = frozenset('barbara')
>>> s
frozenset({'a', 'b', 'r'})
>>> s = frozenset([1, 5, 666])
>>> s
frozenset({1, 666, 5})
>>> s = frozenset({5, 12, 777})
>>> s
frozenset({777, 12, 5})

Là encore on retrouve sur ces exemples le côté non ordonné et la suppression des doublons.


Opérations communes aux deux types d'ensembles

Les opérations communes aux types set et frozenset sont celles des ensembles en mathématiques :

  • Test d’appartenance

  • Test d’inclusion

  • Union

  • Intersection

  • Différence

  • Différence symétrique

[Note]

Voir le cours de théorie des ensembles 1SET pour toutes ces définitions.

Voici les différents tests d'appartenance :

Opération Résultat
x in s Teste si x appartient à s
x not in s Teste si x n’appartient pas à s
len(s) Nombre d’éléments de s
s.isdisjoint(t) True si l’intersection de s et t est vide
s.issubset(t) True si s est inclus dans t
s <= t True si s est inclus dans t
s.issuperset(t) True si t est inclus dans s
s >= t True si t est inclus dans s

A noter que les opérations s.isdisjoint(t), s.issubset(t) et s.isuppersubset(t) nécessitent que s soit un ensemble, t pouvant être un ensemble ou une séquence. Les raccourcis s<=t et s>=t nécessitent que s et t soient tous deux des ensembles.

Example 1.3. Quelques tests d'appartenance sur des ensembles

>>> s = {1, 3, 5, 7, 9}
>>> s.isdisjoint([2, 4, 6, 9])
False
>>> s.isdisjoint({2, 4, 6, 8})
True
>>> s.issubset(range(10))
True
>>> s.issuperset(range(1, 6, 2))
True

Présentons maintenant les opérations classiques sur les ensembles :

Opération Résultat
s.union(t) Union de s et t
s | t Union de s et t
s.intersection(t) Intersection de s et t
s & t Intersection de s et t
s.difference(t) Difference de s par t
s - t Difference de s par t
s.symmetric_difference(t) Différence symétrique de s et t
s ^ t Différence symétrique de s et t

Voici quelques compléments d'informations sur ces opérations :

  • Les opérations s.union(t), s.intersection(t), s.difference(t) et s.symmetric_difference(t) nécessitent que s soit un ensemble, t pouvant être un ensemble ou une séquence. Les raccourcis s | t, s & t, s – t et s ^ t nécessitent par contre que s et t soient tous deux des ensembles.

  • Les trois premiers opérateurs peuvent admettre un nombre variable de paramètres, avec une syntaxe du style s.union(t,u,...) ou s | t | u | ... .

  • Ces opérations ne modifient pas les opérandes sur lesquelles elles s’appliquent. Elles retournent un nouvel ensemble. Celui-ci sera du type (set ou frozenset) de l'opérande de gauche.

Example 1.4. Quelques opérations sur des ensembles

>>> s = {1, 3, 5, 7, 9}
>>> t = frozenset({2, 4, 6, 8})
>>> u = s | t
>>> u
{1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> u.symmetric_difference(range(6,16))
{1, 2, 3, 4, 5, 10, 11, 12, 13, 14, 15}
>>> u.difference(range(3),[5, 6],'e')
{3, 4, 7, 8, 9}
>>> type(s | t)
<class 'set'>
>>> type(t | s)
<class 'frozenset'>

Itérations sur les éléments d'un ensemble

Il est tout à fait possible d’itérer sur les éléments d’un set ou d’un frozenset en utilisant la structure for.

Les éléments d'un ensemble n’étant pas mémorisés de façon séquentielle, l’ordre de parcours sera par contre indéfini et imprévisible.

Example 1.5. Itération sur les éléments d'un ensemble

>>> s = {1, 3, 5, 7, 9}
>>> for x in s:
	print(x**2)

	
81
9
1
25
49

Comme mentionné précédemment, on ne contrôle pas l'ordre dans lequel les éléments sont parcourus.


Opérations spécifiques aux "set"

Les ensembles de type set étant muables, on dispose de plusieurs opérations afin de les modifier.

Voici les opérations de mise à jour d'un ensemble à l'aide d'un autre ensemble (ou d'une séquence) :

Opération Résultat
s.update(t) s mis à jour vers l’union de s et t
s |= t s mis à jour vers l’union de s et t
s.intersection_update(t) s mis à jour vers l’intersection de s et t
s &= t s mis à jour vers l’intersection de s et t
s.difference_update(t) s mis à jour vers la difference de s par t
s -= t s mis à jour vers la difference de s par t
s.symmetric_difference_update(t) s mis à jour vers la différence symétrique de s et t
s ^= t s mis à jour vers la différence symétrique de s et t

Donnons quelques compléments d'informations sur ces opérations :

  • Les opérations s.update(t), s.intersection_update(t), s.difference_update(t) et s.symmetric_difference_update(t) nécessitent que s soit un ensemble, t pouvant être un ensemble ou une séquence. Les raccourcis s |= t, s &= t, s –= t et s ^= t nécessitent par contre que s et t soient tous deux des ensembles

  • Les trois premiers opérateurs peuvent admettre un nombre variable de paramètres, avec la syntaxe s.update(t,u,...) ou s |= t | u | ... , la mise à jour ne se fera que pour l’opérande s.

Example 1.6. Quelques mises à jour d'ensembles

>>> s = set('barbara')
>>> s
{'r', 'b', 'a'}
>>> s.update('boris')
>>> s
{'r', 's', 'b', 'a', 'o', 'i'}
>>> s.intersection_update('brio')
>>> s
{'r', 'b', 'o', 'i'}

Présentons maintenant les opérations d'ajouts et de suppressions d'éléments dans un ensemble :

Opération Résultat
s.add(x) Ajoute l’élément x à s
s.remove(x) Supprime l’élément x de s, retourne une erreur s’il est absent
s.discard(x) Supprime l’élément x de s s’il est présent, ne retourne rien s’il est absent
s.pop() Supprime et retourne un élément de s quelconque
s.clear() Supprime tous les éléments de s

Example 1.7. Quelques ajouts/suppressions d'éléments d'un ensemble

>>> s = set()
>>> s.add(666)
>>> s.add('VL')
>>> s.remove(777)
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    s.remove(777)
KeyError: 777
>>> s.discard(777)
>>> s.pop()
666
>>> s
{'VL'}

L'erreur provient du fait que l'on cherche à supprimer un élément n'appartenant pas à l'ensemble s avec la commande remove. Lorsque l'on tente cette même suppression avec la commande discard, l'ensemble s n'est bien sûr pas modifié, mais l'on ne reçoit plus d'erreur.


Ensembles définis en compréhension

Le principe est exactement le même que celui des listes définies en compréhension.

En voici la syntaxe générale :

{expression for x in sequence if conditionnelle}

A noter qu'il peut y avoir plus d'une structure for. La partie if conditionnelle est facultative.

Example 1.8. Un ensemble défini en compréhension

En utilisant une séquence et une conditionnelle, on définit l'ensemble constitué des carrés des entiers pairs entre 0 et 20 :

>>> s = {x**2 for x in range(21) if x%2 == 0}
>>> s
{0, 64, 4, 324, 144, 256, 16, 400, 196, 100, 36}

Exercice

On propose ici au lecteur un petit exercice d'application immédiate afin qu'il puisse tester sa bonne compréhension de ce qui précède.

Exercice corrigé

1.1.

Ecrire une fonction prenant en paramètre une liste L et qui retourne True ou False selon que cette liste soit une permutation de { 0,1,2 , . . . , n } , où n est le nombre d’éléments de la liste L.

L'idée est de créer deux ensembles, le premier à partir du paramètre et le second avec les entiers compris entre 0 et n. Si ces ensembles sont égaux, cela signifie bien que l'un est une permutation de l'autre. On obtient donc cette fonction :

def permut(L):
    return set(L) == set(range(len(L)))

Dictionnaires

On va présenter dans cette partie la notion de dictionnaire, qui est une autre structure de données non séquentielle.

Principe

Un dictionnaire est une structure de données non séquentielle, muable, permettant de mémoriser des couples clé : valeur. L’accès à une valeur se fait via sa clé.

Les clés doivent nécessairement être d’un type immuable (int, str, t-uple,etc.) et être toutes différentes. Les valeurs sont par contre de n’importe quel type.

Contrairement aux séquences, l’accès à une valeur ne se fait donc pas par sa position mais par une clé. Autre différence majeure, les données ne sont pas stockées en mémoire les unes à la suite des autres. Cette structure de données n’est donc pas séquentielle.

Figure 1.2. Visualisation des différences entre une séquence et un dictionnaire

Visualisation des différences entre une séquence et un dictionnaire

Construction d'un dictionnaire

Voici quelques syntaxes possibles pour déclarer un dictionnaire :

monDicoVide = dict()

monDicoVide = {}

monDico = {cle1:val,cle2:val,...,cleN,val}

monDico = dict([(cle1,val),...,(cleN,val)])

monDico = dict(((cle1,val),...,(cleN,val)))

monDico = dict(zip([cle1,...,cleN],[val,...,val]))
[Note]

Le lecteur n'aura aucunes difficultés pour comprendre ces différentes syntaxes, elles parlent d'elles-mêmes.

Une fois un dictionnaire déclaré, on peut ajouter un élément (i.e. un couple clé : valeur) ou modifier une valeur comme ceci :

monDico[maCle] = maValeur

Deux cas de figure se présentent alors :

  • Si la clé maClé ne fait pas partie du dictionnaire, il y a création d’un couple maClé : maValeur.

  • Si elle en fait partie, sa valeur associée est mise à jour vers maValeur.

Example 1.9. Ajouts d'élements dans un dictionnaire vide

On déclare un dictionnaire vide, on y insère trois couples clé : valeur puis l'on modifie l'une des valeurs :

>>> rs = {}
>>> rs['Mick'] = 73
>>> rs['Keith'] = 73
>>> rs['Charlie'] = 85
>>> rs
{'Charlie': 85, 'Keith': 73, 'Mick': 73}
>>> rs['Charlie'] = 75
>>> rs
{'Charlie': 75, 'Keith': 73, 'Mick': 73}

Pour bien fixer les idées, voici une représentation du dictionnaire précédent :


Example 1.10. Déclarations de dictionnaires

On utilise deux des syntaxes précédentes pour construire des dictionnaires :

>>> rs = dict([('Mick',73),('Keith',73),('Charlie',75)])
>>> rs
{'Charlie': 75, 'Keith': 73, 'Mick': 73}
>>> b = dict(zip(['John','Paul','Ringo'],[40,74,76]))
>>> b
{'John': 40, 'Paul': 74, 'Ringo': 76}

Opérations sur les dictionnaires

Commençons tout d'abord par quelques opérations génériques (au sens où l’on retrouve ces opérations sur la plupart des structures de données en Python) que l'on peut effectuer sur les dictionnaires :

Opération Résultat
x in d Teste si la clé x appartient à d
x not in d Teste si la clé x n’appartient pas à d
len(d) Nombre d’éléments de d
d[x] Si x est une clé, retourne d[x] sinon renvoie une erreur
del d[x] Si x est une clé, supprime d[x] sinon renvoie une erreur
d.clear() Supprime tous les éléments de d
d.update(e) Met à jour d avec e

A noter que pour l’opération d.update(e), e peut être un autre dictionnaire ou par exemple une liste de t-uples de longeur 2.

Example 1.11. Quelques une de ces opérations génériques sur un dictionnaire

On met à jour un dictionnaire avec un autre, puis l'on supprime un des éléments :

>>> rs = dict([('Mick',73),('Keith',73)])
>>> rs.update({'Charlie':75,'Ron':69})
>>> rs
{'Charlie': 75, 'Keith': 73, 'Ron': 69, 'Mick': 73}
>>> rs['Keith']
73
>>> del rs['Ron']
>>> rs
{'Charlie': 75, 'Keith': 73, 'Mick': 73}

Présentons maintenant quelques opérations plus spécifiques aux dictionnaires :

Opération Résultat
d.get(x) Si x est une clé retourne d[x] sinon retourne None
d.get(x,y) Si x est une clé retourne d[x] sinon y
d.pop(x) Si x est une clé retourne d[x] et supprime le couple x : d[x], sinon renvoie une erreur
d.pop(x,y) Si x est une clé retourne d[x] et supprime le couple x : d[x], sinon retourne y
d.popitem() Si le dictionnaire d est vide retourne une erreur, sinon retourne un couple arbitraire de d et le supprime
d.setdefault(x,y) Si x est une clé retourne d[x] sinon retourne y et insère le couple x : y

Example 1.12. Quelques opérations sur un dictionnaire

>>> rs = {'Mick': 73, 'Keith': 73, 'Charlie': 75}
>>> rs.get('Mick')
73
>>> rs.get('Ron',"Pas là")
'Pas là'
>>> rs.pop('Keith')
73
>>> rs.setdefault('Ron',69)
69
>>> rs
{'Charlie': 75, 'Ron': 69, 'Mick': 73}

Il peut être utile d'avoir une vue à un instant donné sur sur l'ensemble du contenu (clés, valeurs ou couples clé : valeur) d'un dictionnaire. Les commandes suivantes le permettent :

Opération Résultat
d.keys() Permet d’avoir une vue sur l’ensemble des clés de d
d.values() Permet d’avoir une vue sur l’ensemble des valeurs de d
d.items() Permet d’avoir une vue sur l’ensemble des couples clé : valeur de d

On pourra ensuite si besoin est créer une liste (ou une autre structure de données) avec ces informations.

Example 1.13. Des vues sur un dictionnaire

On définit une vue sur les clés d'un dictionnaire :

>>> rs = {'mick':73,'Keith':73,'Charlie':75,'Ron':69}
>>> c = rs.keys()
>>> list(c)
['Charlie', 'Keith', 'Ron', 'mick']
>>> del rs['Ron']
>>> list(c)
['Charlie', 'Keith', 'mick']
>>> tuple(rs.items())
(('Charlie', 75), ('Keith', 73), ('mick', 73))

Cette vue est dynamique, elle se met à jour en même temps que le dictionnaire.


Itération sur les éléments d'un dictionnaire

Les vues que l'on vient de présenter vont nous permettre également d'itérer sur les éléments d'un dictionnaire en utilisant une structure for. Plus précisément on pourra itérer sur les clés, sur les valeurs ou sur les couples clé : valeur.

Comme pour les ensembles, les éléments n’étant pas mémorisés de façon séquentielle, l’ordre de parcours sera par contre indéfini et imprévisible.

Example 1.14. Itérations sur les clés

Première version en utilisant une vue :

rs = {'mick':73,'Keith':73,'Charlie':75,'Ron':69}
for nom in rs.keys():
      print(nom,end=' ')
Charlie Keith Ron mick

Seconde version :

rs = {'mick':73,'Keith':73,'Charlie':75,'Ron':69}
for nom in rs:
      print(nom,end=' ')

A noter que la seconde méthode est certes beaucoup moins lisible mais plus rapide.


Example 1.15. Itération sur les valeurs

On utilise pour cela une vue :

rs = {'mick':73,'Keith':73,'Charlie':75,'Ron':69}
total = 0
for age in rs.values():
    total += age
print("âge cumulé :",total,'ans')
âge cumulé : 290 ans

Example 1.16. Itération sur les couples clé : valeur

On utilise pour cela une vue :

rs = {'mick':73,'Keith':73,'Charlie':75,'Ron':69}
for nom,age in rs.items():
    print(nom,':',age,'ans')
mick : 73 ans
Ron : 69 ans
Keith : 73 ans
Charlie : 75 ans

Dictionnaires définis en compréhension

Le principe est exactement le même que celui des listes ou ensembles définis en compréhension.

En voici la syntaxe générale :

{c(x,y):v(x,y) for x,y in sequence if conditionnelle}

A noter qu'il peut y avoir plus d'une structure for. La partie if conditionnelle est facultative.

Example 1.17. Des dictionnaires définis en compréhension

>>> d = {chr(i+64):i for i in range(1,5)}
>>> d
{'C': 3, 'B': 2, 'A': 1, 'D': 4}
>>> dd = {v:c for c,v in d.items()}
>>> dd
{1: 'A', 2: 'B', 3: 'C', 4: 'D'}

Le second exemple nous permet de voir comment créer un dictionnaire à partir d'un autre en inversant le rôle des clés et des valeurs.


Example 1.18. D'autres dictionnaires définis en compréhension

>>> d = {(x,y):x+y for x in range(4) for y in range(3) if x!=y}
>>> d
{(0, 1): 1, (1, 2): 3, (3, 2): 5, (2, 0): 2, (3, 0): 3, (1, 0): 1, (3, 1): 4, (0, 2): 2, (2, 1): 3}
>>> dd = {x:x**2 for x in range(6)}
>>> dd
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Le premier exemple utilise la syntaxe générale (itération et conditionnelle). Il présente au passage un cas où les clés sont des t-uples.


Exercice

On propose ici au lecteur un petit exercice d'application immédiate afin qu'il puisse tester sa bonne compréhension de ce qui précède.

Exercice corrigé : un dictionnaire avec les valeurs des lettres au Scrabble

1.1.

Voici une liste de t-uples, chaque t-uple étant un couple constitué d'une des valeurs des lettres au Scrabble et d'une chaîne de caractère avec les lettres correspondant à cette valeur :

scrabbleT = [(1, "EAINORSTUL"), (2,"DMG"), (3, "BCP"), (4, "FHV"), (8, "JQ"), (10, "KWXYZ")]

Construire à partir de cette liste un dictionnaire qui aura pour clés chacune des lettres de l’alphabet, et pour valeur celle des règles du Scrabble.

On utilise une définition en compréhension d'un dictionnaire et deux boucles for, l'une pour parcourir les différents t-uples et l'autre pour prendre les lettres une par une des chaînes de caractères :

scrabbleD = {lettre:valeur for valeur,listeLettres in scrabbleT for lettre in listeLettres}

Fichiers

On va s'intéresser ici à un moyen de sauvegarder des données de façon plus permanente qu'en mémoire vive.

Généralités

L'objectif principal est de pouvoir conserver des données en mémoire durablement. Pour l’instant nos données sont stockées dans des variables. Elles ne sont donc disponibles que pendant l’exécution du programme et sont supprimées après celle-ci. Pour remédier à ce problème, nous allons voir comment stocker nos données dans des fichiers.

On distingue deux principaux types de fichiers :

  • Les fichiers textes qui sont organisés sous la forme d’une suite de lignes, chacune étant composée d’un certain nombres de caractères et terminée par ‘\n’.

  • Les fichiers binaires qui sont une suite d’octets pouvant représenter toutes sortes de données, comme par exemple des exécutables, MP3, JPEG, PDF...

[Note]

Dans la suite nous ne traiterons que le cas des fichiers textes.

Ouverture d'un fichier

Avant toute manipulation du contenu d'un fichier, il faudra au préalable l'ouvrir.

Voici la syntaxe générale de l'ouverture d'un fichier :

monFichier = open('NomDuFichier','mode')
[Note]

Le nom du fichier contient également son extension (.txt, .csv, …).

Par défaut on considère que le fichier est situé dans le même répertoire que notre script. Dans le cas contraire, on devra préciser son emplacement, par exemple avec un chemin absolu (du style C:\ … sous windows).

Le mode est la façon selon laquelle on va ouvrir le fichier. Il existe trois différents modes d'ouverture :

  • Un mode lecture nommé 'r'. On peut alors lire le contenu du fichier mais on ne peut pas y écrire. Le fichier doit donc exister auparavant.

  • Un mode écriture nommé 'w'. Si le fichier existait, son contenu est effacé, sinon il est créé.

  • Un mode ajout nommé 'a'. Si le fichier existait on peut écrire à la fin de celui-ci sans effacer son contenu. Sinon il est créé.

Fermeture d'un fichier

Une fois son utilisation terminée, il conviendra de refermer un fichier préalablement ouvert. Cela pemettra de libérer la mémoire temporairement allouée pour la manipulation de ce fichier. Cela offrira aussi la possibilité à d'autres applications d'accéder au fichier en question.

Voici la syntaxe générale de fermeture d'un fichier :

monFichier.close()
[Note]

Cette commande fonctionnera quel que soit le mode d’ouverture du fichier.

Lecture dans un fichier

Selon que l'on souhaite lire le contenu d'un fichier intégralement d'une seule fois ou ligne par ligne, on utilisera différentes commandes.

Voici la syntaxe pour lire l'intégralité d'un fichier :

monFichier.read()

Cette instruction retourne l’intégralité du fichier sous la forme d’une chaîne de caractères.

Si l'on passe un paramètre entier à cette fonction read, on ne lira alors que ce nombre précis de caractère. On sera ensuite positionné à cet endroit pour une lecture ultérieure.

Example 1.19. Lecture de l'intégralité d'un fichier

Imaginons que nous ayons ce fichier texte dans notre répertoire courant :

Ouvrons le en mode lecture et récupérons l'intégralité de son contenu avec l'instruction read :

>>> monFichier = open('sympathy.txt','r')
>>> monTexte = monFichier.read()
>>> print(monTexte)
Please allow me to introduce myself
I'm a man of wealth and taste
I've been around for a long, long year
Stole many a man's soul to waste

[Note]

Si le fichier est volumineux lire l’intégralité de celui-ci d’une seule fois peut provoquer des débordements de mémoire.

Il sera préférable alors de passer un paramètre à la fonction read, ou de lire le fichier ligne par ligne comme allons le faire à présent.

Voici la syntaxe pour lire une ligne d'un fichier :

monFichier.readline()

Après la lecture d’une ligne, on sera positionné au début de la suivante pour une éventuelle lecture ultérieure.

Example 1.20. Lecture ligne par ligne d'un fichier

Considérons le même fichier texte que précédemment (refermé entre temps), et récupérons son contenu ligne par ligne avec la commande readline :

>>> monFichier = open('sympathy.txt','r')
>>> ligne1 = monFichier.readline()
>>> print(ligne1)
Please allow me to introduce myself

>>> ligne2 = monFichier.readline()
>>> print(ligne2)
I'm a man of wealth and taste

Voici maintenant comment créer une liste constituée de toutes les lignes d’un fichier :

monFichier.readlines()

Example 1.21. Création d'une liste contenant les lignes d'un fichier

Considérons le même fichier texte que précédemment (refermé entre temps), et constituons une liste avec ses lignes à l'aide de la commande readlines :

>>> monFichier = open('sympathy.txt','r')
>>> maListe = monFichier.readlines()
>>> print(maListe)
['Please allow me to introduce myself\n', "I'm a man of wealth and taste\n", "I've been around for a long, long year\n", "Stole many a man's soul to waste"]

[Note]

Il va sans dire que le lecteur devra faire bien attention à ne pas confondre les commandes readline et readlines.

Pour terminer cette sous-partie, mentionnons la possibilité d'itérer sur les lignes d'un fichier à l'aide d'une structure for :

for maLigne in monFichier:
    traitement de la ligne maLigne

Example 1.22. Une itération

Considérons le même fichier texte que précédemment (refermé entre temps), et itérons sur ses lignes :

monFichier = open('sympathy.txt','r')
for ligne in monFichier:
    print(ligne.upper(),end='')
monFichier.close()
PLEASE ALLOW ME TO INTRODUCE MYSELF
I'M A MAN OF WEALTH AND TASTE
I'VE BEEN AROUND FOR A LONG, LONG YEAR
STOLE MANY A MAN'S SOUL TO WASTE

Ecriture dans un fichier

La syntaxe pour écrire dans un fichier est la même que l'on soit en mode écriture ou ajout :

monFichier.write('le texte à écrire')

Rappelons que que dans les deux cas si le fichier n'existait pas il est créé de fait lors de l'ouverture. S'il existait, une écriture en mode ajout se fait à la fin du fichier avec préservation du contenu existant, tandis qu'en mode écriture l'ancien contenu est effacé.

Si l'on utilise plusieurs fois cette commande, on écrira les différents textes les uns à la suite des autres.

Le paramètre passé à la fonction write est nécessairement du type str. Si besoin est il faudra donc convertir les variables numériques en chaînes de caractères.

[Note]

Voir le premier chapitre de ce cours pour les conversions de types.

Example 1.23. Un ajout à la fin d'un fichier

Considérons le fichier texte de la sous-partie précédente (refermé entre temps), ouvrons le en mode ajout et effectuons deux écritures avec la commande write :

monFichier = open('sympathy.txt','a')
monFichier.write('And I was round when Jesus Christ\n')
monFichier.write('Had his moment of doubt and pain')
monFichier.close()

Vu le mode d'ouverture choisi, ces écritures se font les unes à la suite des autres, à la fin du fichier. On peut constater que celui-ci a bien été modifié :


Example 1.24. Une écriture dans un fichier

Considérons maintenant le fichier texte modifié dans l'exemple précédent (refermé entre temps), ouvrons le en mode écriture et utilisons deux fois la commande write :

monFichier = open('sympathy.txt','w')
monFichier.write('plus de texte...')
monFichier.close()

Vu le mode d'ouverture choisi, l'ancien contenu du fichier est effacé avant l'écriture du nouveau. On peut constater que le fichier a bien été modifié :


A propos de SUPINFO | Contacts & adresses | Enseigner à SUPINFO | Presse | Conditions d'utilisation & Copyright | Respect de la vie privée | Investir
Logo de la société Cisco, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société IBM, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Sun-Oracle, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Apple, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Sybase, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Novell, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Intel, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Accenture, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société SAP, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Prometric, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo du IT Academy Program par Microsoft, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management

SUPINFO International University
Ecole d'Informatique - IT School
École Supérieure d'Informatique de Paris, leader en France
La Grande Ecole de l'informatique, du numérique et du management
Fondée en 1965, reconnue par l'État. Titre Bac+5 certifié au niveau I.
SUPINFO International University is globally operated by EDUCINVEST Belgium - Avenue Louise, 534 - 1050 Brussels