Vous êtes sur la page 1sur 11

Université de Monastir

Faculté des Sciences de Monastir

Département des Sciences de l’Informatique

Matière : Informatique A.U : 2018/2019 Classe : Prépa PC1-MP1

Enseignants : Jaafar CHAAOURI, Sihem LOUKIL

Les Fichiers

1. Introdcution
Les données que l'on peut souhaiter manipuler (textes, images, ...) sont souvent fournies sous forme de
fichiers; l'objectif de cette section est d'apprendre à effectuer un certain nombre de tahes, en particulier :

Ouvrir un fichier
Lire le contenu d'un fichier
Modifier le contenu d'un fichier
Fermer un fichier

On divise habituellement les fichiers en deux catégories :

Fichiers textes

ceux-ci sont humainement lisibles. Autrement dit, ils contiennent du texte (lettres, ponctuations, nombres, ... ).
Leur contenu est souvent divisé en lignes. Ces fichiers peuvent etre lus et manipulés avec les outils
traditionnels, de meme que le code source d'un programme python

Fichiers binaires

ceux-ci ne contiennent pas exculsivement du texte et ne peuvent etre convenablement traités que par des
logiciels spécialisé. Un fichier Pdf, une image JPEG ou un fichier mp3 sont quelques exemples de
fichiersbinaires.

2. lecture et écriture dans un fichier texte


La fonction open propose trois modes d'ouverture d'un fichier :
en lecture ('r')
en écriture ('w')
en mode ajout ('a')

Entrée [10]:

f = open('file.txt','w')
f.write('test d écriture dans un fichier')
f.close()

Le meme fichier peut etre créé avec un éditeur de textes (Bloc-notes) par exemple. taper les lignes suivantes
pis enregistrer sous "Le Zen de Python.txt"

Le Zen de Python Préfère :

La beauté à la laideur,
L'explicite à l'implicite,
Le simple au complexe
et le complexe au compliqué,
Le déroulé à l'imbriqué,
L'aéré au compact.
Prends en compte la lisibilité.
Les cas particuliers ne le sont jamais assez pour violer les règles.
Mais, à la pureté, privilégie l'aspect pratique.
Si l'implémentation s'explique diffcilement, c'est une mauvaise idée.
Si l'implémentation s'explique aisément, c'est peut-être une bonne idée.

pour ouvrir le fichier "Le Zen de python.txt" du répertoire courant

Entrée [8]:

zen = open('Le Zen de Python.txt', "r:UTF-8")

nous venons de créer un objet zen faisant référence au fichier "Le zen du python.txt" :

Entrée [15]:

zen

Out[15]:

<open file 'Le Zen de Python.txt', mode 'r' at 0x7f2bf90eb030>

cet objet est un flux : les caractères sont lisibles uniquement les uns après les autres, sans possibilités de
retour en arrière ni de saut en avant.

pour lire le fichier tout entier : la méthode read().


Entrée [9]:

print(zen.read())

Le Zen de Python Préfère :


- La beauté à la laideur,
- L'explicite à l'implicite,
- Le simple au complexe
- et le complexe au compliqué,
- Le déroulé à l'imbriqué,
- L'aéré au compact.
- Prends en compte la lisibilité.
- Les cas particuliers ne le sont jamais assez pour violer les règles.
- Mais, à la pureté, privilégie l'aspect pratique.
- Si l'implémentation s'explique diffcilement, c'est une mauvaise idé
e.
- Si l'implémentation s'explique aisément, c'est peut-être une bonne i
dée.

Pour lire le fichier ligne par ligne : la méthode readlines(n)

Entrée [47]:

zen = open("Le Zen de Python.txt","r")


zen.readlines()

Out[47]:

['\xef\xbb\xbfLe Zen de Python Pr\xc3\xa9f\xc3\xa8re :\n',


'- La beaut\xc3\xa9 \xc3\xa0 la laideur,\n',
"- L'explicite \xc3\xa0 l'implicite,\n",
'- Le simple au complexe\n',
'- et le complexe au compliqu\xc3\xa9,\n',
"- Le d\xc3\xa9roul\xc3\xa9 \xc3\xa0 l'imbriqu\xc3\xa9,\n",
"- L'a\xc3\xa9r\xc3\xa9 au compact.\n",
'- Prends en compte la lisibilit\xc3\xa9.\n',
'- Les cas particuliers ne le sont jamais assez pour violer les r\xc3
\xa8gles.\n',
"- Mais, \xc3\xa0 la puret\xc3\xa9, privil\xc3\xa9gie l'aspect pratiq
ue.\n",
"- Si l'impl\xc3\xa9mentation s'explique diffcilement, c'est une mauv
aise id\xc3\xa9e.\n",
"- Si l'impl\xc3\xa9mentation s'explique ais\xc3\xa9ment, c'est peut-
\xc3\xaatre une bonne id\xc3\xa9e.\n"]

la méthode readline() (sans s) lit une ligne d'un fichier et la renvoie sous forme d'une chaine de caracère. A
chaque appel de readline(), la ligne suivante est renvoyée.
Entrée [2]:

zen = open("Le Zen de Python.txt","r")


ligne = zen.readline()
while ligne != "" :
print(ligne)
ligne = zen.readline()

Le Zen de Python Préfère :

- La beauté à la laideur,

- L'explicite à l'implicite,

- Le simple au complexe

- et le complexe au compliqué,

- Le déroulé à l'imbriqué,

- L'aéré au compact.

- Prends en compte la lisibilité.

- Les cas particuliers ne le sont jamais assez pour violer les règles.

- Mais, à la pureté, privilégie l'aspect pratique.

- Si l'implémentation s'explique diffcilement, c'est une mauvaise idé


e.

- Si l'implémentation s'explique aisément, c'est peut-être une bonne i


dée.

Pour fermer un fichier : la méthode close()

Entrée [4]:

zen.close()

3. Fichiers CSV (Comma separated Value)


Un fichier CSV est un fichier texte représentant des donées tabulaires sous fome de valeurs séparées par des
virgules. chaque ligne du texte correspond à une ligne du tableau et les virgules correspondent aux séparations
entre les colonnes.

Distance au Période de Période de


Planètes Rayon Masse
soleil révolution rotation
Mercure 57,9.106 km 2 440 km 88 d 58,6 d 0,330.1024 kg

La Terre 150.106 km 6 378 km 365 d 23h 56min 04s 5,97.1024 kg

687 d ou 2 ans 2
Mars 228.106 km 3 400 km 24,6 h 0,642.1024 kg
mois
sera représenté par le fichier planets.csv contenant le texte suivant :

Planètes,Distance au soleil,Rayon,Période de révolution,Période de rotation,Masse


Mercure,"57,9.106 km",2 440 km,88 d,"58,6 d","0,330.1024 kg"
La Terre,150.106 km,6 378 km,365 d,23h 56min 04s,"5,97.1024 kg"
Mars,228.106 km,3 400 km,687 d ou 2 ans 2 mois,"24,6 h","0,642.1024 kg"

Pour construire ce fichier taper les commandes suivantes :

Entrée [38]:

planetes= open('planetes.csv','r')
lignes = planetes.readlines()
planetes.close()
lignes

Out[38]:

['Mercure,"57,9.106 km",2 440 km,88 d,"58,6 d","0,330.1024 kg"\n',


'La Terre,150.106 km,6 378 km,365 d,23h 56min 04s,"5,97.1024 kg"\n',
'Mars,228.106 km,3 400 km,687 d ou 2 ans 2 mois,"24,6 h","0,642.1024
kg"\n']

Entrée [40]:

tab=[]
for ligne in lignes :
tab.append(ligne.split(',')) # on indique le caractère de séparation(,)

Entrée [ ]:

tab

Pour modifier un fichier csv, deux modes d'ouvertures possibles: le mode'w'(write:


écrase le contenu si le ficheir est présent) et le mode 'a' (append: ajout à la
fin du fichier).

Pour ajouter des données suplmémentaires :

Entrée [43]:

planetes = open('planetes.csv' , 'a')


planetes.write('Jupiter, 779.106 km, 71 500 km, 12 ans, 10 h, 1,9.1027 kg')
planetes.close()

le fichier planetes.csv contient le texte suivant :


Entrée [44]:

planetes= open('planetes.csv','r')
lignes = planetes.readlines()
planetes.close()
lignes

Out[44]:

['Mercure,"57,9.106 km",2 440 km,88 d,"58,6 d","0,330.1024 kg"\n',


'La Terre,150.106 km,6 378 km,365 d,23h 56min 04s,"5,97.1024 kg"\n',
'Mars,228.106 km,3 400 km,687 d ou 2 ans 2 mois,"24,6 h","0,642.1024
kg"\n',
'Jupiter, 779.106 km, 71 500 km, 12 ans, 10 h, 1,9.1027 kg']

4. Encodage d’un fichier texte


Historiquement un caractère est codé sur 7 bits, ce qui donne 27 =128 caractères différents, qui constituent le
jeu de caractères ASCII.

En python, on obtient le code ASCII d’un caractère à l’aide de la fonction ord ; à l’inverse, la fonction chr
retourne le caractère dont le code ASCII est donné en paramètre.

Entrée [46]:

ord('A')

Out[46]:

65

Entrée [47]:

chr(97)

Out[47]:

'a'

Chaque langue ayant des besoins spécifiques, les extensions sont nombreuses et non compatibles entre elles :
la norme LATAIN-1 permet d’encoder les langues d’Europe occidentale, la norme LATIN-2 pour les langues
d’Europe centrale, etc. Pas moins de 16 variantes existent pour le seul standard ISO8859.

L’encodage le plus fréquent de l’Unicode est la norme UTF-8 ; c’est la norme utilisée par défaut par Python. Le
fichier comptine.txt ouvert au format LATIN :
Entrée [56]:

zen = open('Le Zen de Python.txt','r:utf-8' )


print(zen.read())

Le Zen de Python Préfère :


- La beauté à la laideur,
- L'explicite à l'implicite,
- Le simple au complexe
- et le complexe au compliqué,
- Le déroulé à l'imbriqué,
- L'aéré au compact.
- Prends en compte la lisibilité.
- Les cas particuliers ne le sont jamais assez pour violer les règles.
- Mais, à la pureté, privilégie l'aspect pratique.
- Si l'implémentation s'explique diffcilement, c'est une mauvaise idé
e.
- Si l'implémentation s'explique aisément, c'est peut-être une bonne i
dée.

5. Fichiers image
La représentation numérique des images la plus employée, nommée Bitmap, consiste à stocker le tableau des
pixels : sa taille ((L;H) nombres de pixels en largeur et en hauteur), son mode de représentation des couleurs,
et le tableau des valeurs de ses L x H pixels. L’image peut être en mode (de représentation des couleurs) :

Noir et blanc : Dans ce cas chaque pixel est représenté sur un bit, 0 pour noir, 1 pour blanc. C’est de ce
mode que vient le nom « bitmap ».
Niveau de gris : Chaque pixel est représenté sur un octet (256 valeurs) dont la valeur varie de plus obscur
0 (noir) au plus clair 255 (blanc) en passant par 254 nuances de gris.
Couleur RGB : Chaque pixel est représenté par 3 octets, chacun donnant l’amplitude des 3 couleurs
fondamentales additives : R (rouge), G (vert), B (bleu). Le noir est alors (0 ; 0 ; 0) et le blanc (255 ; 255 ;
255).

Une image Bitmap peut être stockée sous divers formats de fichiers : BMP, PNG, GIF, JPEG, etc. compressés
ou non.

5.1 Fichiers image

Une image binaire peut être représentée par une matrice pxq dont les éléments, des 0 ou des 1 (plus
exactement des booléens), indiquant la couleur du pixel : 0 pour le noir et 1 pour le blanc.
Une image binaire et la matrice qui lui est associée

5.2 Image en gris

Une image en gris est aussi représentée par une matrice, mais chaque élément détermine la luminance du
pixel correspondant (en général un entier non signé codé sur 8 bits).

Voici par exemple dix niveaux de gris différents :

5.3 Images couleurs

Une image en couleur peut être représentée par trois matrices, chacune déterminant la quantité respective de
rouge, de vert et de bleu qui constitue l’image (c’et le modèle RGB).

Les éléments de ces matrices sont des nombres entiers compris entre 0 et 255 (des entiers non signés sur 8
bits) qui déterminent la luminance de la couleur de la matrice pour le pixel correspondant.

5.4 Opérations sur les images

Le module matplotlib.image propose quelques fonctions basiques pour importer une image, essentiellement
imread(‘fichier.png’) qui prend en argument le nom d’un fichier image au format png et retourne un tableau
numpy;
imsave(‘fichier.png’, tableau) qui sauvegarde le tableau numpy représentant une image sous la forme d’un
fichier png.

A ces deux fonctions il peut être intéressant d’associer la fonction imshow du module matplotlib.pyplot qui
affiche à l’écran une représentation imagée d’un tableau numpy.

Attention, la fonction imread convertit une image m x n en niveau de gris en un tableau m x n dont les valeurs
sont non pas au type uint8 comme on pourrait s’y attendre (entiers non signés sur 8 bits) mais au type float32
(flottants codés sur 32 bits) et s’échelonnent entre 0 (le noir) et 1 (le blanc).

De même, une image en couleur de taille m x n sera transformée en un tableau tri-dimensionnel m x n x 3,


chaque pixel étant associé à un triplet RGB au type float32.

Pour lire une image

Entrée [16]:

import numpy as np
import matplotlib as mp
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt

%matplotlib inline
import matplotlib.image as mpimg
img= mpimg.imread("tulips.png")

on peut afficher cette donnée sous forme d'unn tableau

Entrée [ ]:

img

pour visualiser l'image :


Entrée [18]:

imgplot= plt.imshow(img)
plt.show()

Entrée [19]:

print(img.shape)

(1139, 1832, 4)

Entrée [20]:

print(img.dtype)

float32

la séparation des trois couches se fait par

Entrée [21]:

rouge= img[:,:,0]
vert= img[:,:,1]
vert= img[:,:,2]

Entrée [22]:

rouge

Out[22]:

array([[1., 1., 1., ..., 1., 1., 1.],


[1., 1., 1., ..., 1., 1., 1.],
[1., 1., 1., ..., 1., 1., 1.],
...,
[1., 1., 1., ..., 1., 1., 1.],
[1., 1., 1., ..., 1., 1., 1.],
[1., 1., 1., ..., 1., 1., 1.]], dtype=float32)

Entrée [23]:

mpimg.imsave('rouge.png', rouge)
6. Exercices
1. Enregistrer dans un fichier pair.txt tous les nombres allant de 0 à 100.
2. Ecrire les nombres parfaits de l’intervalle [1..1000] dans un fichier parfait.txt avec retour à la ligne
3. Ecrire dans un fichier num.csv les couples de valeurs x et sin(x) pour x ϵ [0..2π] avec un pas de π/2.
Ecrire un script permettant de lire le fichier num.csv et de récupérer les abscisses dans une liste Lx et
ordonnées dans une liste Ly. Tracer la courbe Ly=f(x)

Vous aimerez peut-être aussi