Cours complet

PYTHON
Présenté par :
Mr. Sény Mbaye
Doctorant à ED2DS
[email protected]
www.mesprofs.com
Présentation du Formateur

❑ El Hadji Sény Mbaye

❑ Email : [email protected] / [email protected]
❑ Consultant, Concepteur et Formateur
❑ Chef de projet IT, réalisation d’applications web/mobile
❑ Co-fondateur de TEQLAB
❑ Actuelle en mission sur un projet de recherche: le fact checking (doctorant)
❑ Mes références
❑ Linkedin : https://www.linkedin.com/in/seny-mbaye/
❑ Skype : @senol.mbaye
A propos du cours
Objectif du cours : (60 heures)
● Comprendre les notions de bases (Variables, conditions, boucles, functions, listes,
dictionnaires et autres)
● Manipuler les notions avancées de Python (POO)
Objectif pédagogiques :
● Apprendre de façon pratique les bases de python
● Découvrir la programmation orienté objet avec python
● Ecrire du code maintenable avec python
● Quelques bibliothèques & frameworks python
Pré-requis :
● Aucun
Évaluation :
● Devoir (TP, Questions de cours + Exercices)
● Examen (Quiz + Exercices)
SOMMAIRE
Partie 1 : Les bases de Pythons

Partie 2 : Mise en place d’un environnement Python

Partie 3 : Programmation Orienté Objet avec Python

Partie 4 : Code Python Maintenable

Partie 5 : Framework Django

Partie 6 : Introduction à Python pour la Data Science

Partie 7 : A là découverte de FLASK pour la conception d’API (Bonus)

Partie 1 : Les bases de Pythons
TP 1: Prise en main de python
Partie 2 : Mise en place d’un environnement
Python
Avant propos
● Nous allons apprendre dans cette partie du cours à configurer l’environnement de travail
de manière à ce que nous avions le même environnement et que nous puissions passer
d’un projet à un autre sans problème en :
● Explorant PyPi : l’index des paquets Python
● Gérant notre environnement de développement local
● Utilisant PIP, l’installateur de paquets Python
● Enfin, en apprenant comment l'utilisation d'un environnement de développement
intégré (nous utiliserons PyCharm !) améliorera votre flux de travail afin que vous
puissiez travailler plus efficacement.
Paquets Python
● Les fonctionnalités considérées comme indispensables pour tous les développeurs
Python ont été ajoutées par défaut à Python : bibliothèque standard de Python.
● Les morceaux de code que les développeurs veulent mettre à la disposition de tous sont
regroupés sous forme de paquets Python
● Toutefois, ils ne sont pas accessibles par défaut dans Python et sont installés via PyPI (de
l'anglais « Python Package Index ), l'index de paquets Python. Les paquets Python
sont un ensemble d'un ou plusieurs modules.
● Exemples :
○ module CSV intégré pour lire et écrire des données de/vers des fichiers CSV
○ paquet requests pour envoyer des requêtes à des URL particulières.
● Pour installer, désinstaller et mettre à jour des paquets Python (et bien plus encore),
nous utilisons pip , l'installateur de paquets de Python. pip utilise PyPI comme
source par défaut pour ses paquets.
● Les paquets Python sont mis à la disposition du public via PyPI, l'index de paquets de
Python. (+240 000 paquets)
Gestion des paquets Python
● Installer & utiliser un paquet python
○ pip install <package>
○ Exemple : pip install matplotlib (package permettant de dessiner des graphes)
● Créez un fichier appelé generate_graph.py et écrivez-y ce code :

import matplotlib.pyplot as plt

Dans votre terminal, placez-vous dans le répertoire dans
lequel vous avez créé le fichier (à l’aide de la commande
cd ), puis exécutez la commande :
plt.figure() python generate_graph.py

plt.plot([1, 2, 3, 4, 5])

plt.show()
Quelques commandes à connaître
● pip list ou pip freeze ( Pour vérifier les paquets Python que vous avez installés)
● pip show <package(s)> ( vous montre des informations utiles sur un ou plusieurs
paquets que vous avez installés)
○ exemples :
○ pip show requests
pip show requests numpy pandas
● Exercice 1

Téléchargez ce script et essayez de l'exécuter : p1c2s2_script.py

S'il s'exécute correctement dès la première fois, c'est parfait, vous n'avez pas besoin d'essayer
autre chose ! Cependant, si ce n'est pas le cas, vous allez devoir rechercher dans PyPI les
paquets que vous devez installer, puis exécuter le script correctement !
Importer des paquets et modules python
● import <module>
○ Exemple : (afficher le répertoire de travail actuel) ⇒ script.py
import os
print(os.getcwd())
○ ou (Pour importer uniquement les fonctionnalités dont nous avons besoin)
from os import getcwd
print(getcwd())
● Nous importons des paquets dans des fichiers Python de la même façon que nous importons des
modules de la bibliothèque standard
○ Par exemple, nous pouvons nous servir du paquet numpy pour arrondir les nombres à l'entier
inférieur ou supérieur
pip install numpy import numpy
number_rounding.py print(numpy.ceil(1.2)) C:\> python number_rounding.py
print(numpy.ceil(1.933)) 2.0
2.0
print(numpy.floor(1.2)) 1.0
Importez tout le contenu d’un paquet Python
● Une alternative à l'utilisation de la syntaxe import <package> consiste à importer tout le contenu d'un
paquet à l'aide de la commande from <package> import *
● Exemple :
○ A partir du shell Python : from numpy import * (tout le contenu du paquet numpy)
○ Maintenant, nous pouvons utiliser les méthodes ceil() et floor() sans avoir besoin du préfixe
numpy.
● Bien que l'utilisation de from <package> import * dans le shell Python soit correcte, elle n'est pas
considérée comme une bonne pratique dans le code d'une application. Si vous utilisez from
<package_a> import * et from <package_b> import * , et qu'un conflit de noms se produise
entre les fonctionnalités de package_a et de package_b , cela peut entraîner des conséquences
indésirables.
● Alias de paquets : import <package> as <alias>
● Exemple :
import numpy as np
On peut reprendre notre exemple précédent.
Utiliser le système de versionning de paquets
Les paquets Python sont "versionnés" pour faciliter le suivi des versions de chacun. Les
versions des paquets Python, toutefois, sont gérées selon un format strict :
major.minor.patch (où major , minor et patch sont tous des nombres entiers.)

● Par exemple, à l'heure actuelle, la dernière version du paquet requests est 2.24.0
● Chaque fois qu'un changement est apporté à un paquet Python, le numéro de version change (quelle
que soit l'importance de la modification). Les modifications sont réparties en trois catégories différentes
:
○ patch est incrémenté : correction de bug rétrocompatible
○ minor est incrémenté : nouvelle fonctionnalité rétrocompatible
○ major est incrémenté : « breaking change », ce qui signifie que le changement de version peut
“casser” un script Python donné, et il sera nécessaire de réécrire ce dernier en tenant compte des
changements apparus dans la nouvelle version du paquet.
● Le moyen le plus simple pour installer une version de paquet Python consiste à utiliser l'opérateur == .
Par exemple, pip install requests==2.1.0
Exercice 2
Votre responsable a effectué des analyses à l'aide de Python. Il a écrit un script qui utilise deux
paquets Python : matplotlib version 3.2.2 et numpy version 1.19.0 .

D’abord, créer le script : p1c4s2_script.py

& Ajouter s’y le code suivant :

import numpy as np

import matplotlib.pyplot as plt

x = np.random.rand(100)
y = np.random.rand(100)
plt.scatter(x, y)
plt.title('Scatter Diagram')
plt.show()

Puis installez les deux versions spécifiques de paquets et exécutez le script.

Environnements virtuels

● Définition :
○ Chaque environnement virtuel comprend sa propre version de Python et tous les
paquets Python que vous décidez d'y installer.
○ Pour garantir que vous disposiez des bons paquets (notamment de leurs versions
spécifiques) au sein de votre environnement de développement local lorsque vous
passez d'un projet à l'autre, nous utilisons des environnements virtuels.
● Outils de création d’environnements virtuels
○ venv est une nouveauté de Python 3.3, vous pourrez donc l'exploiter à condition
d'utiliser une version à jour de Python !
○ python -m venv --help (vérifier que vous avez accès à venv en saisissant dans
votre terminal)
Création d’un environnement virtuel (1)
● D’abords quand on utilise pas d’environnement virtuel

● Commencez par créer un répertoire projects qui héberge votre projet.

C:/> mkdir projects
C:/> cd projects
● À ce stade, nous créons un nouveau répertoire appelé demo-app , pour y stocker le code de notre projet :
mkdir demo-app
cd demo-app/
● Créez un fichier appelé demo.py contenant les éléments suivants :
import requests
r = requests.get('http://www.example.com')
print(r.status_code)
● À ce stade, vous pouvez essayer d'exécuter demo.py comme suit : python demo.py (Le code 200 signifie
que la requête vers http://www.example.com a été correctement exécutée.
● Le script s'est correctement exécuté parce que vous avez installé le paquet de requêtes dans vos paquets
globaux. Vous pouvez voir vos paquets Python globaux en exécutant pip freeze
Création d’un environnement virtuel (2)
● Exécutons l'application dans un environnement virtuel
○ Il est fortement conseillé d'utiliser le moins possible les paquets Python installés globalement.
○ Comme nous l'avons vu au chapitre précédent, il est préférable de créer un environnement pour
chacun des projets sur lesquels nous travaillons et d'installer les paquets localement, au sein de
l'environnement.
○ Pour créer un environnement, utilisez la commande python -m venv <environment name>
○ NB : <environment name> est un nom que vous choisissez, mais par convention, nous utilisons
env : python -m venv env
○ Pour activer l'environnement, exécutez source env/bin/activate (si vous êtes sous Windows,
la commande sera env/Scripts/activate.bat ).
○ À ce stade, votre terminal (selon celui que vous utilisez) ajoutera probablement le nom de votre
environnement au début de chaque ligne de votre terminal (ici, ‘env’) :
env/Scripts/activate.bat (ou source env/bin/activate sur mac os)
○ pip freeze (aucun paquets sur votre nouvel environnement) ⇒ python demo.py (ne
marche plus)
○ pip install requests (vérifier à nouveau avec pip freeze & python demo.py)
○ deactivate (« quitter » ou « désactiver » votre environnement virtuel)
Exercice 3
Vous travaillez dans une agence de vente et de marketing en tant que spécialiste du marketing. Votre patron
travaille sur un projet Python depuis quelques semaines, et il veut maintenant vous faire travailler dessus.
Malheureusement, il n'est pas au bureau aujourd'hui !

Il vous a toutefois envoyé un dossier contenant le projet sur lequel il a travaillé. Vos tâches seront les suivantes
:

● Télécharger le dossier et les fichiers, puis les placer dans votre dossier de projets : p2c2s2_script.py.
● Créer un environnement virtuel.
● La première fois que vous tenterez d'exécuter l'application, elle échouera.
● Trouver et installer les paquets dont vous pensez avoir besoin.
● Exécuter l'application avec succès.
Travailler avec plusieurs environnements (1)
● Créez un deuxième environnement virtuel pour une autre application
cd projects/
mkdir demo-app-2
dir ou ls (pour afficher les deux projets)
● Passons dans le répertoire demo-app-2 et créons un script appelé demo.py : cd demo-app-2
import matplotlib.pyplot as plt
import numpy as np
plt.figure()
plt.plot([1, 2, 3, 4, 5], [10, 20, 30, 40, 50])
plt.show()
● Comme pour le premier projet (demo-app ), si vous tentez d'exécuter le script, il pourra s'exécuter
correctement ou échouer, selon que matplotlib et numpy sont installés ou pas parmi les paquets
globaux. Si matplotlib n'a pas été installé globalement
● Rappelons-nous qu’il ne faut installer que le strict minimum de paquets globaux, mais qu'il faut plutôt
les installer dans l'environnement virtuel propre à chaque projet.
● python -m venv env
● source env/bin/activate ou env\Scripts\activate.bat sur windows & pip freeze (pour vérifier)
● pip install matplotlib
● python demo.py
Travailler avec plusieurs environnements (2)
● Basculez entre plusieurs environnements virtuels
○ Imaginons maintenant que nous souhaitions basculer rapidement entre nos applications
demo-app et demo-app-2 . Pour l'instant, l'environnement virtuel de demo-app-2 est activé.
Commençons par le désactiver : deactivate
○ Passons maintenant dans le répertoire demo-app et activons son environnement virtuel :
cd ../demo-app
source env/bin/activate ou env\Scripts\activate.bat (windows)
○ pip freeze
○ même process pour demo-app2
○ Vous noterez que le (env) ajouté à l'invite de commande reste cohérent lorsque nous passons
de l'environnement virtuel de demo-app à celui de demo-app-2 . C'est parce que les
environnements virtuels ont tous les deux le même nom (env ). Nous verrons ce point de façon
plus détaillée dans la prochaine section
Exercice 4
Vous travaillez cette fois encore dans une agence de vente et de marketing en tant que spécialiste du
marketing. Votre patron a travaillé sur deux projets Python différents, mais il veut à présent que vous en
preniez la responsabilité. Malheureusement, il n'est pas au bureau aujourd'hui !

Il vous a toutefois envoyé un dossier compressé contenant les projets sur lesquels il a travaillé. Vos tâches
seront les suivantes :

● Télécharger les dossiers et les fichiers des deux projets et les placer dans votre dossier de projets :
https://s3-eu-west-1.amazonaws.com/course.oc-static.com/courses/6900846/p2c3s2_exercise.zip .
● Créer un environnement virtuel pour chaque projet.
● La première fois que vous tenterez d'exécuter chacune des applications, elle échouera.
● Trouver et installer les paquets dont vous pensez avoir besoin pour exécuter chaque application.
● Exécuter chaque application.
● Vous entraîner à passer d'un environnement virtuel à l'autre et à exécuter chaque application.
Nommons nos environnements virtuels
● Options de nommage d'un environnement virtuel
○ nous avons jusqu'ici appelé nos environnements virtuels de la même manière pour les deux
projets : env (Au début, cela peut prêter à confusion)
○ Pourquoi ne donnons-nous pas à nos environnements virtuels un nom spécifique ?
○ Si vous basculez très vite entre un grand nombre de projets ou de répertoires différents, il est
pratique de pouvoir toujours activer votre environnement virtuel avec source
env/bin/activate plutôt que d'utiliser ls pour répertorier les fichiers ou les répertoires à la
racine de votre projet afin de retrouver (ou de vous rappeler) le nom de l'environnement virtuel,
puis d'exécuter source <env name>/bin/activate pour l'activer.
○ Une autre question souvent posée est "Pourquoi ne pas appeler notre environnement virtuel par
le nom du projet auquel il est associé ?". La réponse est très simple : cela crée un conflit de noms
de répertoires, ce qui est souvent source de confusion.
Gestion des environnements virtuels à l’aide du fichier
requirements.txt
Pour garantir que tous les développeurs travaillant sur un projet utilisent le même environnement virtuel,
nous utilisons un fichier requirements.txt . Il s'agit de la liste des paquets Python dont l'installation est
requise dans un environnement virtuel pour que l'application s'exécute correctement.

● Voici un exemple de fichier requirements.txt :

matplotlib
numpy
requests
● Si le fichier requirements.txt ci-dessus est stocké dans un projet, il indique à tout nouvel utilisateur :
”pour commencer à travailler sur ce projet, créez et activez un environnement virtuel, puis installez ces
paquets”
● Il est préférable de spécifier une version exacte ou une plage de versions de paquets dans votre fichier
requirements.txt . Voici un autre exemple :
matplotlib==3.2.2
numpy>1.12
requests>2.0,<3.0
● Cela indique la version exacte à utiliser pour matplotlib , et une plage de versions utilisables pour
numpy et requests
Créer et Stocker un fichier requirements.txt
● Revenons au projet demo-app-2 sur lequel nous avons travaillé plus tôt. D'abord, placez-vous dans le
répertoire demo-app-2: cd projects/demo-app-2
● L'exécution de ls ou dir doit montrer que vous avez un fichier appelé demo.py , et un dossier
d'environnement virtuel appelé env
● Comme auparavant, nous pouvons exécuter notre démonstration en activant l'environnement virtuel
et en utilisant Python pour exécuter l'application :
source env/bin/activate ou env\Scripts\activate.bat (windows)
python demo.py
● Maintenant, nous voulons créer et stocker un fichier requirements.txt afin de pouvoir partager notre
projet (et la spécification de l'environnement virtuel) avec d'autres développeurs. Il existe deux
méthodes pour ce faire. Créez le fichier requirements.txt manuellement
● pip freeze (pour vérifier la version des paquets)
● Maintenant, nous sommes prêts. Créez un fichier requirements.txt et ajoutez les éléments suivants :
matplotlib==3.2.2
numpy==1.19.0
● Créez le fichier requirements.txt automatiquement à l'aide de pip : pip freeze > requirements.txt
● À ce stade, vous remarquerez que le fichier requirements.txt répertorie tout le résultat de pip
freeze , et pas seulement les paquets que vous installés explicitement : numpy et matplotlib . En
effet, leurs dépendances ont aussi été ajoutées. C'est une autre manière, plus explicite, d'écrire un
fichier requirements.txt .
Installer des paquets dans notre environnement virtuel à
l’aide d’un fichier requirements
Imaginez maintenant que vous récupériez le projet d'un autre développeur. Le projet possède déjà un fichier
requirements.txt que vous pouvez utiliser pour installer des paquets dans votre environnement virtuel. Dans l'idéal,
il devrait aussi posséder une documentation !

● Tout d'abord, téléchargez le script et ce fichier requirements.txt. Placez le projet demo-app-3 dans votre dossier
projects . Depuis votre terminal, placez-vous dans demo-app-3 et vérifiez-en le contenu
● Vérifions maintenant le contenu des deux fichiers
● Notez que dans demo.py , nous utilisons deux paquets : requests et bs4 . Ces deux paquets, ainsi que leurs
versions, sont répertoriés de manière explicite dans requirements.txt
● À ce stade, vous pouvez essayer d'exécuter demo.py à l'aide de Python. Si requests et bs4 sont installés
globalement (dans l'idéal, ce n'est pas le cas), le script s'exécutera correctement. Toutefois, même dans ce cas,
vous ne pouvez pas savoir si le script s'exécute exactement de la façon prévue par l'auteur du projet, car vous
utilisez peut-être des versions de requests et bs4 différentes de celles spécifiées dans requirements.txt .
● Pour garantir que vous avez la même configuration que les autres développeurs qui travaillent sur le projet,
nous utilisons un environnement virtuel. D'abord, créez et activez un environnement virtuel :
python -m venv env
source env/bin/activate Ensuite, nous devons installer les paquets Python répertoriés dans le fichier
requirements.txt . Pour ce faire, nous utilisons la commande suivante : pip install -r requirements.txt
● pip freeze (vous constatez que vous avez correctement installé requests et bs4 , ainsi que certaines de
leurs dépendances)
● Vous pouvez enfin exécuter le script demo.py correctement : python demo.py
Exercice 5
● Tâche 1

Vous occupez un poste au service des ventes, et un membre de votre équipe travaille sur un projet Python et voudrait le
partager avec vous.

Vous pouvez télécharger le code ici :

https://s3-eu-west-1.amazonaws.com/course.oc-static.com/courses/6900846/p2c5s3_task_1.zip

Votre tâche consiste à créer un environnement virtuel, installer les paquets requis répertoriés dans le fichier
requirements.txt et exécuter l'application : que fait-elle ?

● Tâche 2

Un autre membre de votre équipe travaille sur un autre projet Python, mais n'est pas aussi expérimenté que vous. Son projet ne
contient pas de fichier requirements.txtƒ.

Téléchargez son projet ici : https://s3-eu-west-1.amazonaws.com/course.oc-static.com/courses/6900846/p2c5s3_task_2.zip .

Voyez si vous pouvez faire en sorte qu'il s'exécute dans un environnement virtuel. Vous aurez peut-être besoin d'examiner son code
pour savoir quels paquets vous devez installer. Une fois que vous aurez exécuté l'application correctement, créez un fichier
requirements.txt pour que quelqu'un d'autre puisse travailler sur le projet au besoin. Une fois que vous aurez terminé, vous
pourrez tester le fonctionnement de votre fichier requirements.txt de la façon suivante : supprimez votre environnement
virtuel, créez-en un autre, utilisez votre fichier requirements.txt pour installer les paquets Python, puis exécutez l'application.
Supprimer les environnements virtuels
● Pourquoi supprimer des environnements virtuels ?
○ Il existe de nombreuses raisons de vouloir supprimer un environnement virtuel :
■ Vous ne travaillez plus sur un projet, donc vous voulez supprimer les fichiers du projet et
l'environnement virtuel associé.
■ Lorsque vous avez créé l'environnement virtuel, vous avez fait une faute en le nommant :
vous voulez recréer l'environnement virtuel avec un nom correct.
■ Vous avez des difficultés à exécuter votre application, pour une raison quelconque. Afin
d'écarter la possibilité d'un problème lié à votre environnement virtuel, vous voulez
rapidement recréer celui-ci à partir de zéro.
○ Quelle que soit la raison pour laquelle vous voulez supprimer un environnement virtuel, vous allez
pouvoir le faire en un rien de temps !
● Pour supprimer un environnement virtuel, il suffit de supprimer son répertoire :
○ cd projects/demo-app
rm -r env/
ou supprimer le dossier sur windows
Choisissons l’éditeur le plus approprié pour notre cas
● Utilisez un éditeur de texte/code
○ Lors d'un projet Python, il est important d'avoir un bon environnement de développement
local, car il vous permet de travailler plus efficacement.
○ Un aspect essentiel de cet environnement de développement local est votre environnement
virtuel. Un autre composant important de votre environnement de développement local est
votre éditeur, l'endroit où vous écrivez réellement votre code.
○ Un éditeur de texte (également appelé éditeur de code), est un programme qui permet d'écrire
et de modifier le code source, mais pas beaucoup plus que ça! Les éditeurs de texte sont
généralement légers et s'exécutent rapidement.
○ Parmi les plus connus, citons Visual Studio Code, Sublime Text et Atom.
● Pourquoi utiliser un IDE ?
○ IDE (Integrated Development Environment). Un IDE contient toutes les fonctionnalités des
éditeurs de texte/code normaux, avec en plus des fonctionnalités très intéressantes. Les IDE
Python, par exemple, proposent notamment les fonctionnalités suivantes : Un terminal de
ligne de commande, Un shell Python interactif, Un débuggeur Python, Une fonctionnalité qui
enregistre automatiquement votre code, puis le déploie sur un serveur/dépôt de votre choix,
La possibilité d'exécuter des tests à l'intérieur de l'IDE, Et bien plus encore !
○ Parmi les IDE, citons, par exemple, Microsoft Visual Studio et PyCharm. Microsoft Visual Studio
et PyCharm proposent tous les deux des éditions ‘Professional’ payantes, mais également des
versions ‘Community’ gratuites n'offrant pas toutes les fonctionnalités possibles
Téléchargeons, installons et exécutons PyCharm

● L'édition PyCharm Community est une version gratuite de

l'IDE PyCharm qui est fortement recommandée !
● PyCharm est un produit de JetBrains. Vous pouvez donc le
télécharger à partir de son site web.
● Vous pouvez exécuter PyCharm à partir de la ligne de
commande, ou par une façon plus classique de lancer un
programme.
TP 2 : Premier projet PyCharm
Partie 3 : Programmation Orienté Objet
avec Python
Introduction

❖ La POO (programmation orientée objet) est un paradigme de programmation qui vous

permet de modéliser le monde réel dans du code. L’utilisation de ce paradigme offre
plusieurs avantages. Avec la POO, vous pouvez créer des implémentations faciles à
modifier et à étendre avec moins de code.
❖ Dans le cadre d’une équipe de développement, vous allez écrire du code qui résout
des petits problèmes ainsi que des problèmes plus grands et plus complexes. La POO
est un paradigme de programmation parmi de nombreux autres, mais elle a des
constructions et des principes intéressants qui vont vous aider à structurer votre
réflexion.
❖ Vous décidez d’évaluer la POO en l’appliquant à un petit problème bien défini, le jeu «
pierre, papier, ciseaux », pour voir si elle vous convient, à vous et votre équipe.
Objectifs d’apprentissage

À l’issue de ce module, vous pourrez :

● Modéliser des problèmes en utilisant les concepts de la POO

● Décrire les concepts de base de la POO
● Distinguer les classes des objets
Prérequis

❖ Connaître les bases de Python : syntaxe, écriture et

appel de fonctions, création de variables, lecture
d’entrées et génération de sorties à partir de la console
Python
❖ Savoir utiliser un éditeur de texte ou un IDE
❖ Savoir exécuter un programme Python
❖ Mots clés de Python
Qu’est-ce que la programmation orientée objet ?

La programmation orientée objet est un paradigme de programmation. Elle est basée sur
l’idée de regroupement des données et des fonctions associées en « îlots » d’informations.
Ces îlots sont appelés des objets.

Quel que soit le paradigme utilisé, les programmes utilisent la même série d’étapes pour
résoudre les problèmes :

1. Entrée de données : Les données sont lues depuis un certain endroit, qui peut être
un stockage de données comme un système de fichiers ou une base de données.
2. Traitement : Les données sont interprétées et éventuellement modifiées afin de les
préparer pour l’affichage.
3. Sortie de données : Les données sont présentées de façon à pouvoir être lues et
être en interaction avec un utilisateur physique ou un système.
POO et programmation procédurale

Essayons de définir ce qu’est la POO en la comparant à un autre paradigme : la

programmation procédurale. La programmation procédurale vise à résoudre un
problème donné en appelant des procédures, également appelées fonctions ou
méthodes. Des fonctions et des variables sont construites pour traiter les différentes
phases décrites dans les étapes précédentes.

Le paradigme POO ne diffère pas de ce point de vue. Ce qui le distingue, c’est la façon
dont il considère le monde. Par rapport à la programmation procédurale, la POO prend
du recul. Au lieu de travailler sur les données et de les passer d’une phase à la
suivante, la POO essaie de comprendre le monde dans lequel les données évoluent.
Elle fait cela en modélisant ce qu’elle voit.
Avantages de la POO

Pourquoi utiliser la POO ? Pourquoi ne pas utiliser un autre paradigme ? Pour être
clair, la POO n’est pas meilleure ou pire que n’importe quel autre paradigme. Il y a pour
tout des avantages et des inconvénients. La POO offre des avantages intéressants et
en voici quelques-uns :

● Encapsulation des données

● Simplicité
● Maintenabilité
● Réutilisabilité
Utiliser des classes et des variables pour traduire votre modèle
POO en code
Vous voulez évaluer la programmation orientée objet (POO) en créant le jeu « pierre, papier,
ciseaux ». Pour cela, vous devez d’abord le modéliser dans un format POO.

Nous allons devoir appliquer certains concepts fondamentaux de la POO, comme les
classes, les objets et l’état. Cette unité explore les parties suivantes :

● Concepts importants de la POO : Pour raisonner en termes de POO, vous devez

comprendre certains concepts fondamentaux comme les classes, les objets et l’
état. Vous devez connaître la différence entre ces concepts et savoir comment ils
sont liés les uns aux autres.
● Variables dans la POO : Vous devez savoir comment gérer les variables et
comment les ajouter à vos objets.
Qu’est-ce qu’un objet ?
Le concept d’objet a déjà été mentionné quelques fois dans le cadre de la tentative de
modéliser des domaines de problème. Un objet est un acteur. C’est quelque chose qui fait
quelque chose dans un système. À la suite de la réalisation d’une action, il change l’état au
sein de lui-même ou dans d’autres objets.

Imaginons un objet dans le monde réel. Vous êtes dans un parking. Que voyez-vous ? Vous
voyez probablement plusieurs voitures, qui ont des formes, des dimensions et des couleurs
différentes. Pour décrire une voiture, vous pouvez utiliser des propriétés comme la marque,
le modèle, la couleur et le type de voiture. Si vous affectez des valeurs à ces propriétés, il
devient rapidement évident que vous parlez d’une Ferrari rouge, d’une à quatre roues
motrices, d’une Mustang jaune, etc.

Dans une autre scène, imaginez un jeu de cartes à Las Vegas. Vous regardez deux cartes
différentes, qui sont deux objets. Vous réalisez qu’elles ont des propriétés communes, en
l’occurrence la couleur. La couleur pour les objets peut être trèfle, cœur, carreau ou pique.
Leurs valeurs peuvent être as, roi, neuf, etc.
Qu’est-ce qu’une classe ? (1)

Une classe est un type de données qui fait office de définition de modèle pour un
type particulier d’objet.

Vous avez appris qu’un système POO a des objets et que ces objets ont des
propriétés. Il existe un concept similaire à un objet : une classe.

Qu’est-ce donc qu’une classe ? Une classe est un blueprint d’un objet. Alors que
la classe est le blueprint d’une voiture, l’objet est la vraie voiture que vous pouvez
conduire. La classe est ce que vous écrivez dans le code. L’objet est ce que vous
obtenez quand vous indiquez à l’environnement d’exécution d’exécuter votre
code.
Qu’est-ce qu’une classe ? (2)

Voici un tableau de quelques exemples de classes et des objets qui en résultent :

La façon dont vous allez créer un objet à partir d’une classe est similaire à la façon dont vous créez une voiture à partir
d’un blueprint. Quand vous créez un objet, votre programme demande des ressources au système d’exploitation, c’est-
à-dire de la mémoire, pour pouvoir construire l’objet. À l’inverse, quand une voiture est fabriquée à partir d’un blueprint,
l’usine demande des ressources comme du métal, du caoutchouc et du verre pour pouvoir assembler la voiture.

Classe Objet

Blueprint d’une voiture Honda Accord, Jeep Wrangler

Chat Garfield le chat

Description de la glace Fraise, chocolat ou vanille

Créer une classe

Une classe dans Python est créée en utilisant le mot clé class et en lui
attribuant un nom, comme dans cet exemple :

class Car:
Créer un objet à partir d’une classe

Quand vous créez un objet à partir d’une classe, on dit que vous l’instanciez. Ce que
vous faites, c’est demander au système d’exploitation de vous fournir suffisamment de
mémoire pour créer un objet en utilisant ce modèle (la classe) et ces valeurs de
démarrage. « Instancier » est en fait un autre mot pour « créer ».

Pour instancier un objet, vous ajoutez des parenthèses au nom de la classe. Ce que
vous obtenez est un objet que vous pouvez choisir d’affecter à une variable, comme
suit :
car = Car()
Variables dans la POO et variables dans les programmes procéduraux

Dans la programmation procédurale, vous avez l’habitude d’utiliser des variables pour y placer des
informations et faire le suivi de l’état. Vous pouvez définir ces variables partout où vous en avez
besoin dans votre fichier. La variable initialization courante peut se présenter comme suit :

pi = 3.14

Vous avez également des variables dans la POO, mais elles sont attachées aux objets au lieu d’
être définies indépendamment. Vous faites référence aux variables d’un objet en tant qu’attributs.
Quand un attribut est attaché à un objet, il est utilisé de deux façons :

● Décrire l’objet : Un exemple de variable de description est la couleur d’une voiture ou le

nombre de tâches sur une girafe.
● Conserver l’état : Une variable peut aussi être utilisée pour décrire l’état d’un objet. Un
exemple d’état est l’étage où se trouve un ascenseur, ou s’il est en fonctionnement ou
non.
Ajouter des attributs à une classe

Savoir quels sont les attributs (variables) à ajouter à votre classe fait partie de
la modélisation. Vous avez vu comment créer une classe dans le code, mais
comment lui ajouter un attribut ? Vous devez indiquer à la classe les attributs
qu’elle doit avoir au moment de la construction, quand un objet est instancié.
Il existe une fonction spéciale qui est appelée au moment de la création,
appelée un constructeur.
Constructeur

De nombreux langages de programmation ont la notion de constructeur, une

fonction spéciale appelée seulement lors de la création initiale de l’objet. Le
constructeur n’est appelé qu’une seule fois. Dans cette méthode, vous créez les
attributs que l’objet doit avoir. Vous affectez également des valeurs de démarrage
aux attributs créés.

Dans Python, le nom du constructeur est __init__(). Vous devez également

passer un paramètre spécial, self, au constructeur. Le paramètre self référence
l’instance de l’objet. Une affectation à ce mot clé signifie que l’attribut se retrouve
sur l’instance de l’objet. Si vous n’ajoutez pas d’attribut à self, il sera alors traité
comme une variable temporaire qui n’existera plus une fois l’exécution de
__init__() terminée.
Ajouter et initialiser des attributs sur une classe (1)

Voyons un exemple de configuration d’attributs dans un constructeur :

class Elevator:
def __init__(self, starting_floor):
self.make = "The elevator company"
self.floor = starting_floor
# To create the object
elevator = Elevator(1)
print(elevator.make) # "The Elevator company"
print(elevator.floor) # 1
Ajouter et initialiser des attributs sur une classe (2)

L’exemple précédent décrit la classe Elevator avec deux variables, make et

floor. Un point important dans le code est que __init__() est appelé
implicitement. Vous n’appelez pas la méthode __init__() par son nom : elle
est appelée lors de la création de l’objet, dans cette ligne de code :

elevator = Elevator(1)
Utilisation incorrecte de self

class Car:
def __init__():
self.color = "Red" # ends up on the object
make = "Mercedes" # becomes a local variable in the constructor
car = Car()
print(car.color) # "Red"
print(car.make) # would result in an error, `make` does not exist on the object
Si l’objectif était de faire de color et make des attributs de la classe Car, vous devriez modifier le code. Dans le constructeur, vérifiez
que les deux attributs sont affectés à self, comme suit :

self.color = "Red" # ends up on the object

self.make = "Mercedes"
Exercice 1
Partie 4 : Code Python Maintenable pour la
Conception d’API
Partie 5 : Framework Django
“La plateforme de développement Web pour les
perfectionnistes sous pression”
Qu'est-ce-que Django ?

❖ Django est un framework Python pour le Web qui

encourage le développement rapide et propre avec une
conception pragmatique
❖ Django permet de construire des applications web
rapidement et avec peu de code
❖ Malgré son haut niveau d'abstraction, il est toujours
possible de descendre dans les couches
Historique
❖ Créé en 2003, basé sur le langage Python créé en 1990
❖ Rendu Open Source (BSD) en 2005
❖ Version actuelle : Django 4.1
❖ Aujourd'hui utilisé par de très nombreuses entreprises :
Mozilla, Instagram, Pinterest, Disqus, ...
 10 raison d’utiliser django

1. Facile à installer
2. Fonctionne out of the box
3. Excellente documentation
4. Modèles en Python et ORM efficace (peu de connaissances SQL
requises)
5. Interface d'administration auto-générée
6. Architecture pluggable, nombreux modules existants
7. Gestion de formulaires
8. Serveur de développement standalone
9. Déploiement facile
10. Communauté autour du projet très active
Environnement
● Django : 4.1
● Python : 2.6 / 2.7 / 3.3 / 3.9
● Base de données : SQLite, PostgreSQL, MySQL
● Il est préférable de travailler dans un environnement virtualisé
(virtualenv)

En production
● Derrière Apache, nginx, ...
● Avec mod_wsgi, uWSGI, gunicorn, ...
Architecture MVC, ou plutôt MTV
L'architecture de Django s'inspire du principe MVC (Model, View, Controller) ou
plutôt MTV (Model, Template, View) :

● Model : Un modèle est écrit en Python et Django fournit un ORM (Django ORM)
complet pour accéder à la base de données
● Template : Django possède son propre moteur de template (Django Template
Engine)
● View : Une vue Django définit quelles données sont présentées à l'utilisateur.
Une vue peut être une simple fonction Python retournant une réponse HTTP ou
être basée sur une classe

La fonction correspondant au controller est assumée par l'URL dispatcher qui

permet de faire correspondre des URLs sous forme d'expressions régulières à des
vues.
Installer Django
Création et activation de l'environnement virtuel
$ python -m venv env
$ env\Scripts\activate.bat

Installation de Django
$ pip install django (pour installer la dernière version)

Création du projet
$ django-admin startproject nouveau-projet

Lancement du serveur de développement

$ cd nouveau-projet
$ python manage.py runserver
Arborescence du projet
● /nouveau-projet : conteneur du projet
├── nouveau-projet
(le nom est sans importance)
│ ├── manage.py ● /manage.py : utilitaire en ligne de
│ └── nouveau-projet commande permettant différentes actions
sur le projet
│ ├── __init__.py ● /nouveau-projet/nouveau-projet :
│ ├── settings.py paquet Python effectif du projet
● /nouveau-projet/settings.py : réglages
│ ├── urls.py et configuration du projet
│ └── wsgi.py ● /nouveau-projet/urls.py : déclaration des
URLs du projet
● /nouveau-projet/wsgi.py : point d'entrée
pour déployer le projet avec WSGI
Créer une application
Une application est un module métier Web qui fait quelque chose – par exemple un
système de blog, une base de données publique ou une application de sondage.

Création de l'application
$ ./manage.py startapp myapp

Déclaration de l'application dans les settings

# settings.py

INSTALLED_APPS = (

'django.contrib.admin',

...

'myapp')
L’application créée
├── myapp
│ ├── admin.py
│ ├── __init__.py
│ ├── models.py
│ ├── tests.py
│ └── views.py

● models.py : déclaration des modèles de l'application

● views.py : écriture des vues de l'application
● admin.py : comportement de l'application dans l'interface d'administration
● tests.py : Il. Faut. Tester.
Déclarer un modèle
# mushrooms/models.py
from django.db import models

class MyAppSpot(models.Model):
specy = models.CharField(max_length=100)
location = models.CharField(max_length=200)
discovery = models.DateField(blank=True, null=True)
famous = models.BooleanField(default=False)
picture = models.FileField(upload_to='pictures')
Activer le modèle
Création des tables en base de données
$ ./manage.py syncdb

Déclaration dans l'interface d'administration

# myapp/admin.py
from django.contrib import admin
from MyApp.models import MyAppSpot

admin.site.register(MyAppSpot)
Aller plus loin avec ces concepts

● Les modèles : Relations 1-1 / 1-N / N-N, héritage

● Les vues : Vues basées sur une fonction / sur une
classe
● Les templates : inclusion & héritage, filtres & tags
● Les URLs : passage d'arguments,
internationalisation
● L'ORM : managers, CRUD
● L'interface d'administration : complètement
personnalisable
Partie 6 : Introduction à Python pour la Data
Science
Partie 7: A la découverte de FLASK