Suite du cours :

programmation Python

Réalisée par : Mme N. EL-GHARDOUF

Année universitaire: 2022-2023
 1. Fichiers - Lecture: I. Fichiers:
Une grande partie de l’information est stockée sous forme de texte dans des fichiers. Pour traiter cette information,
vous devez le plus souvent lire ou écrire dans un ou plusieurs fichiers. Python possède pour cela de nombreux
outils qui vous simplifient la vie.
1.1. Méthode .readlines():
Soit le texte suivant un fichier dans un éditeur de texte que vous enregistrerez
dans votre répertoire courant avec le nom zoo.txt et le contenu suivant .
Afin de lire le fichier dans l’interpréteur Python, on utilise :

Ligne 1. L’instruction open() ouvre le fichier zoo.txt. Ce fichier est ouvert en lecture seule, comme l’indique le second
argument r (pour read) de la fonction open(). Remarquez que le fichier n’est pas encore lu, mais simplement ouvert
Ligne 2. Lorsqu’on affiche le contenu de la variable filin, on se rend compte que Python la considère comme un objet de type
fichier ouvert (ligne 3).
Ligne 4. Nous utilisons la méthode .readlines() agit sur l’objet filin en déplaçant le curseur de lecture du début à la fin du
fichier, puis elle renvoie une liste contenant toutes les lignes du fichier .
Ligne 6. Enfin, on applique la méthode .close() sur l’objet filin ferme le fichier Vous remarquerez que la méthode .close() ne
renvoie rien mais modifie l’état de l’objet filin en fichier fermé.
Il existe en Python le mot-clé with qui permet d’ouvrir et de fermer un fichier de manière efficace. Si pour une
raison ou une autre l’ouverture ou la lecture du fichier conduit à une erreur, l’utilisation de with garantit la bonne
fermeture du fichier, ce qui n’est pas le cas dans le code précédent. Voici donc le même exemple avec with :

Remarque :
— L’instruction with introduit un bloc d’indentation. C’est à l’intérieur de ce bloc que nous effectuons toutes les
opérations sur le fichier.
— Une fois sorti du bloc d’indentation, Python fermera automatiquement le fichier. Vous n’avez donc plus besoin
d’utiliser la méthode .close().
1.2. Méthode .read():

Il existe d’autres méthodes que .readlines() pour

lire (et manipuler) un fichier. Par exemple, la
méthode .read() lit tout le contenu d’un fichier et
renvoie une chaîne de caractères unique.

1.3. Méthode .readline():

La méthode .readline() (sans s à la fin) lit une ligne

d’un fichier et la renvoie sous forme de chaîne de
caractères. À chaque nouvel appel de .readline(), la
ligne suivante est renvoyée. Associée à la boucle
while, cette méthode permet de lire un fichier ligne par
ligne.
 2. Fichiers - Ecriture:
Quelques commentaires sur cet exemple :
Ligne 1. Création d’une liste de chaînes de caractères animaux2.
Ligne 2. Ouverture du fichier zoo2.txt en mode écriture, avec le caractère w pour write. L’instruction with crée un bloc
d’instructions qui doit être indenté.
Ligne 3. Parcours de la liste animaux2 avec une boucle for.
Ligne 4. À chaque itération de la boucle, nous avons écrit chaque élément de la liste dans le fichier. La méthode .write()
s’applique sur l’objet filout. Notez qu’à chaque utilisation de la méthode .write(), celle-ci nous affiche le nombre d’octets
(équivalent au nombre de caractères) écrits dans le fichier (lignes 6 à 8).
Ceci est valable uniquement dans l’interpréteur, si vous créez un programme avec les mêmes lignes de code, ces valeurs
ne s’afficheront pas à l’écran.
 II. Modules:
➢ Les modules sont des programmes Python qui contiennent des fonctions que l’on est amené à réutiliser souvent (on
les appelle aussi bibliothèques ou libraries). Ce sont des « boîtes à outils » qui sont très utiles. Les développeurs de
Python ont mis au point de nombreux modules qui effectuent une quantité phénoménale de tâches.
➢ La plupart de ces modules sont déjà installés dans les versions standards de Python, avec plus de 300 modules
disponibles sur le site officiel de python.

1. Module random :

• Le module random contient des

fonctions pour la génération de nombres
aléatoires :

• Le module random permet aussi de

permuter aléatoirement des listes :
 • Mais aussi de tirer aléatoirement
un ou plusieurs éléments dans une
liste donnée :

La fonction choice() tire aléatoirement un élément d’une liste alors que choices() (avec un s à la fin) réalise
plusieurs tirages aléatoires, dont le nombre est précisé par le paramètre k.

2. Module math :

Il contient les fonctions et constantes

mathématiques de base (sin, cos, exp, pi.,
sqrt…).
 3. Module os:
Le module os gère l’interface avec le système
d’exploitation.
➢ La fonction os.path.exists() est une fonction
pratique de ce module qui vérifie la présence
d’un fichier sur le disque dur. Dans cet
exemple, si le fichier n’existe pas sur le
disque, on quitte le programme avec la
fonction exit() du module sys

➢ La fonction os.getcwd() renvoie le répertoire

(sous forme de chemin complet) depuis lequel
est lancé Python :

➢ Enfin, la fonction os.listdir() renvoie le contenu

du répertoire depuis lequel est lancé Python. Le
résultat est renvoyé sous forme d’une liste
contenant à la fois le nom des fichiers et des
répertoires.
 III. Fonctions:
En programmation, les fonctions sont très utiles pour réaliser plusieurs fois la même opération au sein
d’un programme. Elles rendent également le code plus lisible et plus clair en le fractionnant en blocs
logiques.

Pour définir une fonction, Python utilise le mot-clé

def. Si on souhaite que la fonction renvoie quelque
chose, il faut utiliser le mot-clé return. Par exemple :
Notez qu’une fonction ne prend pas forcément un
argument et ne renvoie pas forcément une valeur, par
exemple :

1. Passage d’arguments:
Le nombre d’arguments que l’on peut passer à une fonction est
variable. Nous avons vu ci-dessus des fonctions auxquelles on
passait 0 ou 1 ou plusieurs argument. Le nombre d’argument est
donc laissé libre à l’initiative du programmeur qui développe
une nouvelle fonction. Une particularité des fonctions en Python
est que vous n’êtes pas obligé de préciser le type des arguments
que vous lui passez, dès lors que les opérations que vous
effectuez avec ces arguments sont valides. Python est en effet
connu comme étant un langage au « typage dynamique », c’est-
à-dire qu’il reconnaît pour vous le type des variables au moment
de l’exécution. Par exemple :
 2. Renvoi de résultats:
Un énorme avantage en Python est que les fonctions sont
capables de renvoyer plusieurs objets à la fois, comme dans
cette fraction de code :

En réalité Python ne renvoie qu’un seul objet, mais celui-ci peut

être séquentiel, c’est-à-dire contenir lui même d’autres objets.
Dans notre exemple Python renvoie un objet de type tuple,
Notre fonction pourrait tout autant renvoyer une liste :

3. Arguments positionnels et arguments par mot-clé:

❑ Lorsqu’on définit une fonction def fct(x, y): les arguments x et y

sont appelés arguments positionnels. Il est strictement obligatoire
de les préciser lors de l’appel de la fonction. De plus, il est
nécessaire de respecter le même ordre lors de l’appel que dans la
définition de la fonction. Dans l’exemple , 2 correspondra à x et 3
correspondra à y. Finalement, tout dépendra de leur position, d’où
leur qualification de positionnel.
 ❑ Un argument défini avec une syntaxe def fct(arg=val): est
appelé argument par mot-clé. Le passage d’un tel argument
lors de l’appel de la fonction est facultatif. Ce type
d’argument ne doit pas être confondu avec les arguments
positionnels présentés ci-dessus, dont la syntaxe est def
fct(arg) :

IV. Dictionnaires et tuples :

1. Dictionnaires:
Les dictionnaires se révèlent très pratiques lorsque
on veut manipuler des structures complexes à décrire
et que les listes présentent leurs limites. Les
dictionnaires sont des collections non ordonnées
d’objets (ceci est vrai jusqu’à la version 3.6 de
Python). Il ne s’agit pas d’objets séquentiels comme
les listes ou chaînes de caractères, mais plutôt
d’objets dits de correspondance ou tableaux
associatifs. En effet, on accède aux valeurs d’un
dictionnaire par des clés.
 ❑ Itération sur les clés pour obtenir les valeurs:
Si on souhaite voir toutes les associations clés /
valeurs, on peut itérer sur un dictionnaire de la
manière suivante :
Par défaut, l’itération sur un dictionnaire se fait sur
les clés. Dans cet exemple, la variable d’itération
key prend successivement la valeur de chaque clé,
ani2[key] donne la valeur correspondant à chaque
clé.
❑ Méthodes .keys(), .values() et .items() :
 2. Tuples:
Les tuples sont des objets séquentiels correspondant aux
listes (itérables, ordonnés et indexables) mais ils sont
toutefois non modifiables. L’intérêt des tuples par rapport
aux listes réside dans leur immutabilité. Cela, accélère
considérablement la manière dont Python accède à
chaque élément et ils prennent moins de place en
mémoire. Par ailleurs, on ne risque pas de modifier un de
ses éléments par mégarde. Pratiquement, on utilise les
parenthèses au lieu des crochets pour les créer.

Si vous voulez ajouter Les opérateurs + et *

un élément (ou le fonctionnent comme pour les
modifier), vous devez listes (concaténation et
créer un nouveau tuple . duplication).

Enfin, on peut utiliser la fonction tuple(sequence) qui

fonctionne exactement comme la fonction list(), c’est-à-
dire qu’elle prend en argument un objet de type liste ou
chaine de caractère et renvoie le tuple correspondant:
 V. Programmation objet:
✓ La programmation orientée objet (POO) est un concept de programmation très puissant qui permet de structurer ses
programmes d’une manière nouvelle. En POO, on définit un « objet » qui peut contenir des « attributs » ainsi que des «
méthodes » qui agissent sur lui-même.
✓ Une classe définit des objets qui sont des instances (des représentants) de cette classe. Les objets peuvent posséder des
attributs (variables associées aux objets) et des méthodes (qui sont des fonctions associées aux objets et qui peuvent
agir sur ces derniers ou encore les utiliser).

Par exemple, la voiture de Jonathan, qui est de couleur rouge avec une vitesse de 30 km/h, est une instance de la
classe Voiture, c’est un objet. De même, la voiture de Denis, qui est de couleur grise avec une vitesse de 50 km/h, est un
autre objet. Nous pouvons donc avoir plusieurs objets pour une même classe, en particulier ici deux objets (autrement dit :
deux instances de la même classe). Chacun des objets a des valeurs qui lui sont propres pour les attributs.
 1. Classe et Objet:
❑ Définition d’une classe:

Voici comment définir une classe appelée ici Point. Par convention en Python, le nom identifiant une classe (qu’on
appelle aussi son identifiant) débute par une majuscule. Ici Point débute par un P majuscule.

❑ Création d’un objet:

Il faut bien noter que pour créer une instance, on utilise le nom de la
classe suivi de parenthèses. Créons par exemple un nouvel objet et
mettons la référence à cet objet dans la variable p :

Nous pouvons dès à présent effectuer quelques

manipulations élémentaires avec notre nouvel objet
dont la référence est dans p. Le message renvoyé par
Python indique que p contient une référence à une
instance de la classe Point, qui est définie elle-même
au niveau principal du programme. Elle est située dans
un emplacement bien déterminé de la mémoire vive,
dont l’adresse apparaît ici en notation hexadécimale.
 2. Définition des attributs:

L’objet dont la référence est p possède deux attributs : x et

y. La syntaxe pour accéder à un attribut est la suivante : la
variable qui contient la référence à l’objet et on ajoute un
point . puis le nom de l’attribut.

3. Définition des méthodes:

Cette classe possède une méthode : deplace().
Pour définir une méthode, il faut :
- indiquer son nom (ici deplace()).
- indiquer les arguments entre des parenthèses. Le premier
argument d’une méthode doit être self.

Pour accéder aux méthodes d’un objet, on indique :

- le nom de la variable qui fait référence à cet objet
- un point
- le nom de la méthode
 ❑ Notion de Constructeur:

Un constructeur n’est rien d’autre qu’une méthode, sans valeur de retour, qui porte un nom imposé par le
langage Python : __init__(). Ce nom est constitué de init entouré avant et après par __ (deux fois le symbole
underscore _). Cette méthode sera appelée lors de la création de l’objet. Le constructeur peut disposer d’un
nombre quelconque de paramètres, éventuellement aucun.
 4. Notion d’encapsulation:

Le concept d’encapsulation est un concept très utile de la POO. Il permet en particulier d’éviter une
modification par erreur des données d’un objet. En effet, il n’est alors pas possible d’agir directement sur les
données d’un objet ; il est nécessaire de passer par ses méthodes qui jouent le rôle d’interface obligatoire.

❑ Attributs privés:
On réalise la protection des attributs de notre
classe Point grâce à l’utilisation d’attributs
privées. Pour avoir des attributs privés, leur
nom doit débuter par __ (deux fois le
symbole underscore _)

Il n’est alors plus possible de faire appel

aux attributs __x et __y depuis
l’extérieur de la classe Point. Il faut donc
disposer de méthodes qui vont permettre
par exemple de modifier ou d’afficher les
informations associées à ces variables
 ❑ Accesseurs et mutateurs:

Parmi les différentes méthodes que comporte une

classe, on a souvent tendance à distinguer :
- les constructeurs ;

- les accesseurs (en anglais accessor) qui fournissent

des informations relatives à l’état d’un objet, c’est-
à-dire aux valeurs de certains de ses attributs
(généralement privés) sans les modifier ;

- les mutateurs (en anglais mutator) qui modifient

l’état d’un objet, donc les valeurs de certains de ses
attributs.

On rencontre souvent l’utilisation de noms de la forme

get_XXXX() pour les accesseurs et set_XXXX() pour
les mutateurs. Par exemple, pour la classe Point sur
laquelle nous avons déjà travaillé on peut définir les
méthodes suivantes :