Ecole Supérieure de Technologie Master d’Université Spécialisé en

de Kénitra Systèmes Electriques et Industrie Intelligents

(ESTK) (MUS-SE2I)

Cours
Destiné aux étudiants de la
Filière : Master d’Université Spécialisé en Systèmes Electriques et Industrie Intelligents (MUS –
SE2I) – Semestre 1.

Programmation orientée objet

Python/Raspberry

Pr. A.Tayebi

Année Universitaire 2023-2024

Table des matières
Partie 1 : La programmation en python : ................................................................................................. 3
I- Introduction : ................................................................................................................................... 3
1- Définition : .................................................................................................................................. 3
2- Logiciels indispensables .............................................................................................................. 3
a- Python...................................................................................................................................... 3
b- Environnement de développement : ........................................................................................ 4
II- Prise en main de l’environnement de programmation : ............................................................... 6
1- Création d’un premier projet Python ........................................................................................... 6
2- Les variables :.............................................................................................................................. 7
3- Les fonctions lire et écrire : ......................................................................................................... 8
a- Fonction Ecrire « Print() »:...................................................................................................... 8
b- Fonction lire input() : ............................................................................................................ 10
4- Les commentaires : .................................................................................................................... 10
5- Les Boucles : ............................................................................................................................. 11
a- La boucle While : .................................................................................................................. 11
b- La boucle for : ....................................................................................................................... 12
6- Les conditions : ......................................................................................................................... 12
7- L’exception :.............................................................................................................................. 13
8- Les fonctions : ........................................................................................................................... 14
9- Les structures de données : ........................................................................................................ 15
a- Les listes : .............................................................................................................................. 15
b- Les tuples :............................................................................................................................. 16
c- Les dictionnaires : ................................................................................................................. 16
III- La Programmation orienté objet en Python : ............................................................................. 17
1- Les classes : ............................................................................................................................... 17
2- Les instances : ........................................................................................................................... 18
3- L’héritage : ................................................................................................................................ 19
Partie 2 : Les Raspberry pi : .............................................................................................................. 22
I- Introduction : ................................................................................................................................. 22
1- Spécifications matérielles et architectures des raspberry pi .................................................... 22
a- Présentation de la raspberry pi 4 .......................................................................................... 22
b- Caractéristique de la Raspberry pi 4 :.................................................................................... 23
2- Démarrage de Raspbian ............................................................................................................ 23

1
 3- Mettre à jour votre distribution ................................................................................................ 25
4- Connecter votre Raspberry Pi à votre ordinateur en SSH et VNC : ........................................... 27
5- Installation du IDLE3 pour python 3 .......................................................................................... 31
II- Prise en main des broches GPIO sur Raspberry pi : ...................................................................... 32
1- Introduction : ............................................................................................................................. 32
2- Principe de base des GPIO : ...................................................................................................... 32
a- Que sont les broches GPIO ? ................................................................................................. 32
b- Brochage GPIO : ................................................................................................................... 32
3- Configuration du Raspberry Pi .......................................................................................... 32
4- Pratique sur les GPIO ................................................................................................................ 33
a- Clignoter une led par GPIO : ................................................................................................. 33
b- Commander une led par interface graphique : ..................................................................... 35
c- Communication entre Raspberry pi et Arduino par USB : .................................................... 37

2
Partie 1 : La programmation en python :
I- Introduction :
1- Définition :
Python est un langage de programmation qui peut s'utiliser dans de nombreux contextes et
s'adapter à tout type d'utilisation grâce à des bibliothèques spécialisées. Il est cependant
particulièrement utilisé comme langage de script pour automatiser des tâches simples mais
fastidieuses, comme un script qui récupérerait la météo sur Internet ou qui s'intégrerait dans
un logiciel de conception assistée par ordinateur afin d'automatiser certains enchaînements
d'actions répétitives. On l'utilise également comme langage de développement de prototype
lorsqu'on a besoin d'une application fonctionnelle avant de l'optimiser avec un langage de plus
bas niveau. Il est particulièrement répandu dans le monde scientifique, et possède de
nombreuses bibliothèques optimisées destinées au calcul numérique.
2- Logiciels indispensables
a- Python
Le logiciel python permet à votre ordinateur de comprendre ce langage. Ce logiciel est open
source et il peut être téléchargé du site officiel de python : https://www.python.org/ .

Il existe plusieurs versions du logiciel python pour notre cas nous allons utiliser la dernière
version disponible. A savoir que la version 2.x est différente au niveaux programmation de la
version 3.x et n’est plus mise à jour.
Pour savoir la version exacte de python que vous avez sur votre ordinateur il suffit d’accéder
au CMD de votre ordinateur et taper la commande : « python - -version »

3
Etapes d’installation sous Windows :
La première étape consiste à accéder au site officiel et de télécharger la dernière version sou
l’angle Download

Une fois téléchargé lancer le fichier .exe et cochez la case « Add Python 3.10 to PATH »
comme ci-dessous puis cliquez sur install Now

b- Environnement de développement :
Pour réaliser un scripte il nous faut un éditeur de texte pour écrire notre scripte, or un
simple éditeur de texte ne nous sera pas optimale c’est pour ça qu’on va utiliser un
Environnement de développement.
Il existe plusieurs Environnement de développement, le plus pratique au point de vue des
développeur est le logiciel « Pycharm » or ce logiciel nécessite une bonne configuration

4
 sur votre machine et fonctionnelle qu’avec les systèmes 64-bits, Pour les ordinateurs
moins performants on peut utiliser le logiciel « Visual studio code» .
 Installation de Pycharm :
Vous pouvez télécharger pycharm depuis le site : https://www.jetbrains.com/fr-fr/pycharm/ et
vous choisissez le téléchargement « Community » comme suite et qui est open source mais
compatible qu’avec le langage python dont nous avons besoin

Une fois téléchargé l’installation est simple dans notre cas il n’y aura pas de modifications il
suffit de suivre les étapes et de cliquer sur next
 Installation de Visual Studio code :
Vous pouvez télécharger Visual Studio Code depuis le site : https://code.visualstudio.com/
puis cliquez sur télécharger.

Comme précédemment l’installation est simple il suffit de suivre les étapes sans modifier
les choix par default.
Une fois installé il faut ajouter le langage python à votre console comme ci-dessous ainsi
que l’extension Importmagic

5
 II- Prise en main de l’environnement de programmation :
Soit sur « Pycharm » ou sur « Visual Studio Code » la page de saisie du code suive le
même principe et le même langage qui est le Python. Dans la suite de cette formation nous
allons utiliser l’environnement de développement « Pycharme » mais vous pouvez faire la
même chose sure « Visual Studio Code ».
1- Création d’un premier projet Python
Vous lancez votre environnement de programmation pycharm puis en haut à gauche
appuyer sur : =>File =>New project, puis vous créer le dossier qui va comporter votre
projet une fois fait cliquez sur =>Create

Une foi le projet créer dans un dossier ce dernier s’affiche à gauche de votre console
appuyiez avec le bouton gauche de votre souri sur le dossier puis => New =>Python File,
comme suite.

6
 A la fin de cette étape Pycharme vous demande de nommer votre fichier Python, dans
notre cas nous l’avons nommé « main » comme suite :

Une fois nommé appuyez sur entrer et votre page de programmation vierge s’affiche sur la
console avec le nom qui lui a été attribué.

2- Les variables :
Pour Python il suffit de déclarer la variable sans préciser sa nature ( Int, Float, str,bool), ce
dernier détecte automatiquement sa nature. Concernant le nom des variables, elles ne doivent
pas comporter d’espace.
a = “Bonjour“ => chaine de caractères : str
b=5 => nombre entier : int

7
c = 1.5 => nombre à virgules : float
d = True => True ou False : bool

La nature de la variable ne peut être précisé si on ne différencie pas une chaine de caractère
d’une chaine numérique c’est pour cela que la variable caractère est affecté en utilisant une
double apostrophe au début et à la fin de la chaine de caractère tandis que les affectations
numérique n’ont pas besoin de mètre des doubles apostrophes comme suite :

Or, pour afficher le contenue d’une variable numérique dans une chaine de caractère on doit
faire une convention pour avoir le même type d’où la fonction « str(nom de la variable) ».
Cette fonction va permettre de convertir le contenu de la variable numérique à un caractère. Il
existe aussi une technique de conversion d’une variable caractère ver une valeur numérique et
ce en précisant la nature numérique de la conversion :
- Conversion ver un réel => int(nom de la variable)
- Conversion ver un nombre à virgule => float(nom de la variable)
Par contre si la variable caractère ne comporte pas que des nombres, une erreur s’affichera
pour la conversion
3- Les fonctions lire et écrire :
a- Fonction Ecrire « Print() »:
La fonction « Print » est une fonction déjà prédéfini par Phyton qui permet de fait sortir un
message qui sera placer juste devant la fonction entre parenthèse.
Exemple :
Si on veut écrire par exemple un message « Bonjour » on fait comme suite :

Pour visualiser le résultat de notre fonction il suffit de cliquer sur =>Run en haut à droit ou
par clique gauche sur notre texte puis Run. Une foi fait une console s’ouvre en bas, elle
affiche en première ligne l’emplacement du fichier exécuté puis le contenu du résultat comme
suite :

8
Dans les parenthésés de la fonction print on peut utiliser soit des doubles apostrophes soit une
apostrophe pour commencer et finir notre message, or il est préférable d’utiliser les doubles
apostrophes vues que le message à afficher peux contenir une apostrophe qui va être
considéré comme la fin du message si on a commencé par une apostrophe.
Exemple :

ami ne sera pas prise en compte par la fonction, et du coups un message d’erreur sera
affiché.
Pour afficher un saut de ligne il suffit d’ajouter un autre print avec le contenu de la ligne
qui suit vue que le programme python s’exécute ligne par ligne comme suite :

Pour ajouter le contenue d’une variable au message à afficher on peux utiliser trois façons
différentes, tous en sachant que le contenue de la variable doit étre convertie en caractére vue
que c’est un message :
print(“Vous vous appelez “ + nom) => concaténation de chaine (si la variable nom est
. numérique on doit la convertir par str(nom))
print(f“Vous vous appelez {nom}“) => chaine formatée (le f au début converti en str)
print(“Vous vous appelez %s“ % nom) => chaine formatée (conversion automatique)

9
 b- Fonction lire input() :
La fonction input demande l’affectation d’une variable et ce avec le message qui va être saisie
entre les parentés, or une foi la variable saisie par l’utilisateur notre programme doit l’affecter
à une variable pour pouvoir l’utiliser par la suite, d’où l’intérêt de créer une variable de
sauvegarde.
Exemple :

Une fois le scripte exécuté la console nous demande de saisir le nom, une fois écrit, on appuis
sur entrer, la saisie est affectée à la variable « nom » et utilisé dans la ligne qui suit tous en
affichant son contenu.
4- Les commentaires :
Les commentaires sont très utilisés au niveau de la programmation, soit pour commenter
votre bloque de scripte pour faciliter la compréhension de ce dernier, ou pour désactiver une
ou plusieurs lignes de votre scripte temporairement tous en le gardant sur le scripte pour les
réactiver plus tard.
Pour désactiver une ligne du scripte ou la rendre comme commentaire il suffit de mètre un
dièse # tous au début de la ligne, puis l’enlever pour la réactiver comme site :

Il existe une autre syntaxe mais cette fois pour commenter tous un bloc de lignes du scripte
et ça en utilisant trois double apostrophe pour ouvrir le commentaire puis trois autre pour
le fermer comme suite :

10
 5- Les Boucles :
Les boucles sont un outil très puissant a disposition du programmeur pour réaliser une tâche
infiniment sans pour autant avoir des pages de programme.
a- La boucle While :
La boucle While qui signifie faire cette tache tant que la condition de sortie n’est pas
réalisée. En python elle se présente comme suit :
while nom de la variable et sa condition:
A faire si la condition n’est pas vérifiée
Exemple :
Dans cet exemple on va faire une boucle qui va permettre de calculer le nombre d’année
qu’il vous faut pour atteindre 35 ans.

Il existe l’inverse de la boucle while qui est « While not » et dans ce cas le contenu ne va pas
s’exécuter si la condition n’est pas respectée.

11
b- La boucle for :
La boucle for comme la boucle While permet de refaire la même tache plusieurs fois mais
la condition d’arrêt de la boucle for sera limité par le nombre de fois à boucler et non par
une condition et ce comme suite :
for i in range(de, à): => de (inclus), à (exclu)
print(i) => de,…….à-1
Exemple :
Nous reprenant le même exemple de la boucle while et nous allons la reformuler de
tel sorte de remplacer while par for.

6- Les conditions :
Avent de parler des conditions, nous avons besoin de connaitre les outils de comparaison,
vue que la condition se fait par une comparaison de la variable conditionné par rapport à
une variable conditionnant, d’où l’intérêt de ces outils de comparaison ci-dessous :
== # égal
<= # inférieur ou égal
< # inférieur
>= # supérieur ou égal
> # supérieur
Autres outils nécessaires sont les outilles de liaison entre plusieurs conditions et sont :
or => qui représente la réalisation soit de la première ou la deuxième condition pour
exécuter le scripte de la condition.
and => qui représente cette fois la réalisation des deux conditions simultanée pour
exécuter le scripte de la condition
la condition if exécute le scripte qu’elle comporte si la condition se réalise et si on doit
exécuter un autre scripte si la condition n’est pas réalisé on ajoute le bloque else comme
suite

12
 if variable_conditionné == variable_conditionnant :
print(“On exécute le scripte de la condition validé“)
else :
print(“On exécute le scripte de la condition non validé“)

Si nous avons besoin d’introduire plusieurs conditions à différent scripte une nouvelle
fonction est utilisé et qui est elif . Cette fonction de suivre les conditions ligne par ligne
d’où l’importance de classer nos conditions par ordre de de priorité.

Exemple :

Dans cet exemple nous allons conditionner la saisie de l’âge d’une personne en affichant
comme retour la tranche d’âge qu’il a (Enfants, mineur, à peine majeur, majeur et senior)

7- L’exception :

L’exception permet de tester si le bloque qu’elle comporte peux être exécuté si se n’est pas le
cas on a le retour de l’exception. On réalise l’exception par les fonctions try et exept comme
suite :
try :
Scripte à effectuer
exept :
Print ("affiche le message d’erreur de l’exception")

Exemple :

Dans cet exemple nous allons calculer l’âge d’une personne l’an prochain, en utilisant
l’exception si la personne saisie une valeur non numérique à l’âge

13
 8- Les fonctions :

Les fonctions sont utilisées pour organiser et optimiser le programme, au lieu de refaire le
scripte qui fait une tache donné plusieurs fois dans le même programme, il est préférable
de le programmer une seul fois dans une fonction et la rappeler lors ce que ce dernier en a
besoin.

La déclaration de la fonction se fait au début de notre programme comme suite :

def nom_de_la_fonction(parametre1, parametre2, parametre3…):
Scripte de la fonction
return resultat_de_la_fonction
Le rappel de la fonction se fait comme suite :

nom_de_la_fonction (valeur_a_affecter_au_parametre1, valeur_a_affecter_au_parametre2,

valeur_a_affecter_au_parametre3)
Exemple :
Dans cet exemple nous allons créer une fonction qui demande trois paramètres et calcule
leur moyenne. Pour illustrer le rôle de la fonction nous allons la rappeler deux fois avec
des valeurs différentes et visualiser le résultat.

14
9- Les structures de données :
a- Les listes :
La fonction liste consiste à placer des valeurs sous forme d’une liste (tableau à une ligne).
Les listes sont muables, ordonné, peuvent avoir une valeur en double ou plus et leur
contenue se déclare entre crochet et les valeurs sont séparé par des virgules comme suite :
- On peut déterminer la dimension d’une liste par la commande : len(nom_de_la_liste)
- On peut insérer une valeur supplémentaire dans une liste par la commande :
nom_de_la_liste.append(’’valeur_à_ajouter’’) =>cette valeur s’ajoute à la fin de la
liste
- On peut insérer une valeur supplémentaire dans une liste à un emplacement précis par
la commande : nom_de_la_liste.insert(0,’’valeur_à_ajouter’’)
- On peut appeler une valeur pressise de la liste par la commande :
nom_de_la_liste[indice_de_la_valeur]
- On peut trier le contenue d’une liste par ordre alphabétique par la commande :
nom_de_la_variable.sort()
- On peut suprimer une valeur de la liste par la commande :
nom_de_la_liste.remove(‘’la_valeur’’) => dans le cas où la valeur existe plusieurs fois
dans la liste il va supprimer seulement la première valeur (indice le plus faible)
Exemple :
Dans cet exemple on va créer une liste puis faire différentes modifications sur cette
dernière pour enfin l’afficher en saluent tous les prénoms de la liste par ordre alphabétique

15
 b- Les tuples :
Les tuples sont identique à des listes sauf qu’ils sont protégé de la modification, une fois
programmé on ne peut plus les modifier. Les tuples sont déclaré comme les listes en
modifiant les crochets par des parenthèses :
Nom_du_tuple=(valeur1,valeur2,valeur3….)
On peut appliquer toutes les commandes, vue dans les listes de la même maniéré tant
qu’elles ne modifient pas le contenu du tuple.
Exemple :
On reprend le même exemple effectué pour les listes en enlevant les modifications qui vont
engendrer des erreurs, vue que les tuples sont protégé de la modification.

c- Les dictionnaires :
Contrairement au listes les dictionnaires ne comporte pas que des valeurs mais aussi ce qu’on
appelle des clés, donc pour chaque item du dictionnaire on va avoir une paire clé-valeur. Les
dictionnaires sont muables, les clés ne doivent pas être répété alors que deux clés différentes
peuvent avoir des valeurs identiques. Les dictionnaires sont déclarés comme suite :
Nom_du_dictionnaire={clé1 :valeur1, clé2 :valeur2, clé3 :valeur3,…}

16
 - Pour ajouter une valeur dans un dictionnaire on utilise la commande :
Nom_du_dictionnaire[‘’clé’’]=valeur
- Pour récupérer les clés d’un dictionnaire on peut utiliser la commande :
Non_du_dictionnaire.keys()
- Pour récupérer les valeurs d’un dictionnaire on peut utiliser la commande :
Non_du_dictionnaire.values()
- Pour récupérer les paires d’un dictionnaire on peut utiliser la commande :
Non_du_dictionnaire.items()
Exemple :
Dans cet exemple on va déclarer un dictionnaire lui ajouter un item, visualiser les clés, les
valeurs et la totalité des items.

III- La Programmation orienté objet en Python :

Pour des programmes simples il est facile de programmer avec une programmation de base
appelé aussi programmation impérative et ça en utilisent les boucles les fonctions etc, mais
plus vous vous dirigé ver des programmes plus complexe plus vous aurez plus de scriptes et
ça devient de plus en plus compliqué à organiser, d’où l’intérêt de passer à un autre
résonnement de programmation, qui est la programmation orienté objet POO.
Pour résonner en objet on ne doit plus résonner en variable élémentaire mais en objet ayant
plusieurs paramètres qu’on nomme attribue. Par exemple une voiture a une vitesse, une
couleur, une marque, un nombre de roues, un carbure etc, tous ces attributs formes la
description d’un objet, donc on peut créer plusieurs voitures (objets) en partant d’un moule
(classe) qui va permettre de créer une infinité d’objet. Pour plus de détaille nous allons
entamer de nouvelles syntaxes qui vont nous permettre de programmer en se basant sur ce
principe.
1- Les classes :
En reprenant le même exemple précèdent notre classe est une voiture qui a des attributs
qui la caractérise. Pour construire notre classe on utilise la commande suivante :
Class Nom_de_la_classe :
nom_de_l’atribut1=
nom_de_l’atribut2=

17
 nom_de_l’attribut3=
etc
Pour appeler l’un des attributs d’une classe on peut utiliser la commande suivante :
Nom_de_la_classe.non_de_l’attribut
Exemple :
Dans cet exemple nous allons créer une classe (voiture) avec des attributs (marque,
vitesse, couleur) et nous allons rappeler ses attributs dans un print.

2- Les instances :
Les instances seront les objets crée de la classe et ça en créent un objet avec les mêmes
attributs de la classe, mais avec des valeurs d’attributs différentes
Exemple :
On va reprendre l’exemple précèdent tout en ajoutant une instance nommée voiture1.

18
Pour passer des valeurs d’attributs directement à nos instances sans écraser les attributs
précédents, on utilise une nouvelle commande qu’on va insérer dans notre classe et qui
est :
def__init__(self, attribut1, attribut2, attribut3…)
self.attribut1=attribut1
self.attribut2=attribut2
self.attribut3=attribut3
L’attribut self existe toujours dans les attributs d’une classe, il représente le sac ou tous
nos instances sont entreposées.
Exemple :
Encore une fois nous allons créer une classe comportant la commande def __init__() avec
les trois attributs marque, vitesse et couleur, sauf que là nous allons créer deux instance
différentes : voiture1 et voiture2

3- L’héritage :

19
Dans le cas où nous avent déjà créer une classe et on veut créer une nouvelle classe qui
dépend de la première avec de nouvelles spécifications propre à la deuxième classe. Par
exemple si on veut créer une classe ‘’Camion’’ qui dépend de la classe ’’Voiture’’ avec un
paramètre volume _de_la_ vanne de plus il suffise d’appeler les paramètres de la classe
voiture et ça se fait de la manière suivante :
class Nom_de_la_classe2(Nom_de_la_classe1) :
On utilise la fonction ci-dessous pour hériter les attributs de la classe mère :
super(attribut1, attribut2, attribut3…)
Dans les parenthèses on n’affiche que les attributs identiques entre les deux classes.
Exemple :
Dans cet exemple on va créer une nouvelle classe « Camion » qui hérite de la classe
« Voiture » la marque, la vitesse, la couleur et l’affichage des informations, en plus de
l’héritage on va ajouter un attribut propre à la classe « Camion » qui est le volume de la vanne
puis l’introduire en plus de l’affichage d’informations hérité de la classe « Voiture » .

20
21