Introduction à la

Programmation
PYTHON

VERSION 0.20
BalacSoft - Introduction Programmation Python 1
 SOMMAIRE
- Introduction
- Installation et outils Python
- Règles de codage et Types en Python
- Python – 1 – Objets et classes
- Python – 2 – Les fonctions
- Python – 3 – Les Boucles & Conditions
- Python – 4 – Les tableaux
- Python – 5 – Graphique
- Python – 6 – CI/CD
- Projet de développement
BalacSoft - Introduction Programmation Python 2
 Introduction

BalacSoft - Introduction Programmation Python 3

Historique de Python

- Créé en 1989 par Guido Van Rossom

(développeur Néerlandais)
- Le nom Python provient des Monty Python
- La 1ière version publique sort en 1991 (v0.9)
- Python 3.0 sort fin 2008 et est non compatible
avec Python 2.x
- Les dernières versions:
- En 2.x est la v2.7.17
- En 3.x est la v3.8.2
BalacSoft - Introduction Programmation Python 4
Principales Caractéristiques

- Langage Interprété
- Multiparadigme
- Multiplaforme
- Typage dynamique
- Garbage Collector

BalacSoft - Introduction Programmation Python 5

Langage Interprété

- Il n’y a pas de compilation: différent d’un

langage comme JAVA ou C/C++

- Il est possible de lancer le source directement

- Il sera exécuté ligne par ligne en mode script

BalacSoft - Introduction Programmation Python 6
Langage Multiparadigme

Python est multiparadigme, c’est à dire qu’il

peut être:

- Procédurale
- Orientée Objet
- Programmation Fonctionelle

BalacSoft - Introduction Programmation Python 7

Langage Multiplateforme

- Python est multiplateforme, c’est à dire qu’il

peut fonctionner aussi bien sur Windows que
sur Linux ou encore MacOS

- Mais aussi sur des plateformes telles que

Android (avec par exemple python-for-android
ou encore Kivy)
BalacSoft - Introduction Programmation Python 8
Langage à Typage Dynamique

- Typage Statique: Java, C/C++, etc.

- Pour les langages à typage statique, il faut
définir les variables et indiquer leur type
- En typage dynamique, le type n’est pas défini
et il peut changer au cours du script
- une variable peut être un INT à sa première
initialisation et devenir un STRING ensuite par
exemple
BalacSoft - Introduction Programmation Python 9
Langage à Garbage Collector

- A l’instar du Java, il y a aussi un garbage

collector avec Python (ce qui n’est pas le cas en
C ou C++)
- C’est à dire que le langage va gérer la
libération des objets, des allocations mémoires,
etc.
- Cela simplifie grandement le développement
BalacSoft - Introduction Programmation Python 10
Installation et Outils
Python

BalacSoft - Introduction Programmation Python 11

Installation
- Installation: www.python.org
- Pour Windows: suivre Install et ajout PATH
- Pour Linux (Ubuntu):
sudo apt-get update
sudo apt-get install python 3.6
- Test installation:
python --version
python2 --version / python3 --version
- Installer aussi pip:
sudo apt-get install python3-pip
- Test installation de pip:
pip --version
BalacSoft - Introduction Programmation Python 12
 Manipulation : Installation et mode console
- Installation de Python
- vérification avec
$python –version et $which python
- Faire un essai en mode console
$python
- afficher “Bonjour !” : >>> print(“Bonjour”)
- importer un module : >>> import os
- effacer l’écran : >>> os.system(“clear”) ou >>> os.system(“cls”)
en Windows
- >>> dir(os) pour connaître les définitions
- >>> exit() pour quitter la console
BalacSoft - Introduction Programmation Python 13
Choisir son IDE

- IDE=Integrated Development Environment

- Il en existe des dizaines pour développer en Python, les
plus populaires étant :

- pyCharm : https://www.jetbrains.com/fr-fr/pycharm/
- Visual Studio Code : https://code.visualstudio.com/

Dans cette formation, nous utiliserons VS Code

BalacSoft - Introduction Programmation Python 14

Shebang Line
- C’est la première ligne d’un script. Elle permet de lancer
le script python sans le préfixe “python”
Windows : #!python3
Linux: #!/usr/bin/python3

Pour identifier la version de python:

$ which python
=> /usr/bin/python

Quelques éditeurs Python

- pycharm : www.jetbrains.com/pycharm/
- visual studio code: https://code.visualstudio.com
BalacSoft - Introduction Programmation Python 15
Utiliser Python en mode SCRIPT

- Les fichiers Python ont l’extension ‘.py’

- Par exemple : “hello.py”
- pour lancer le programme, simplement taper

$ python hello.py

hello.py # si le shebang est bien positionné

Ou sous Linux : ./hello.py
BalacSoft - Introduction Programmation Python 16
 Manipulation : premier script
- Faire son premier script
- Créer un fichier bonjour.py qui va afficher le message
“Bonjour” sur la console
- mettre le shebang (voir slides plus haut)
- le mot clé pour afficher “print”
- print(“Bonjour”)
- Lancer le script : $ python bonjour.py
- si le shebang est bon, il est possible de le lancer en double
clique sous Windows
- ou avec ./bonjour.py sour Linux (droits d’exec)
BalacSoft - Introduction Programmation Python 17
Outils utiles en Python – 1/3 - pylint

- PYLINT est un outil qui permet l’analyse des règles de codage des scripts
Python. Il attribue une note sur 10 aux scripts.
Installation Linux: apt-get install pylint

- Utilisation:
$ pylint le_script.py
Ou simplement $ pylint *.py

- Il est possible de mettre le paramètre ‘--exit-zero’ pour avoir un code retour

OK
- A noter que pylint contient un executable pyreverse très pratique pour créer
des diagrammes. En installant graphviz. On peut générer des diagrammes
de package et de classe :
$ pyreverse -o png *.py
BalacSoft - Introduction Programmation Python 18
Outils utiles en Python – 2/3 - coverage

COVERAGE est un outil qui permet de fournir une couverture

de tests unitaires en python

Installation: $ pip install coverage

Utilisation:
$ coverage run
$ coverage report

Pour avoir un rapport plus jolie:

$ coverage html
BalacSoft - Introduction Programmation Python 19
Outils utiles en Python – 3/3 - pyinstaller

pyinstaller est un outil qui permet de générer un binaire

executable. Aussi bien un Exe pour Windows qu’un executable
Linux.

Installation: $ pip install pyinstaller

Utilisation:
$ pyinstaller --onefile mon_main.py

Il faut fournir le script qui contient le main du projet. pyinstaller

fera le nécessaire pour trouver les autres. L’option ‘--onefile’
permet de tout packager dans un seul et unique fichier exe
BalacSoft - Introduction Programmation Python 20
 Manipulation : Utilisation de pylint
- Installer pylint
- Lancer pylint sur son script bonjour.py
$ pylint bonjour.py
- La note est sur 10, il faut atteindre 10/10
- pour cela rajouter le docstring
""" ce script affiche Bonjour sur la console """
- et relancer pylint jusqu’à atteindre 10/10
- Les docstring servent d’aide pour la commande ‘help()’. Passer
en mode console :
>>> import bonjour puis >>> help(bonjour)
(:q pour quitter)
BalacSoft - Introduction Programmation Python 21
Règles de codage et
types en Python

BalacSoft - Introduction Programmation Python 22

Règles de codage - 1/2

Convention Python : PEP-8

PEP=Python Enhancement Proposals

Règles

- Utilisation de 4 espaces pour l’indentation

- 80 caractères maximum par ligne
- Encoding par défaut UTF-8
- Ajouter ‘docstring’ pour les fonctions, les classes et les fichiers:
””” ceci est un docstring ”””
- Ne pas laisser d’espace en fin de ligne
BalacSoft - Introduction Programmation Python 23
Règles de codage - 2/2

Règles (suite)

- Commentaire : # ceci est un commentaire

- Convention de nommage:
* variable: snake_case (minuscule)
* constante: SNAKE_CASE (majuscule)
* classes: PascalCase

kamelCase est non utilisé

BalacSoft - Introduction Programmation Python 24
IMPORT (inclusion)
Permet le chargement d’un module: un module est un fichier
contenant des definitions et des méthodes=collection de
fonctions (include en C)

Exemple:
>>> import XXX
>>> dir(XXX)

- dir(xxx) : permet de connaitre toutes les définitions pour le

module xxx.
- Possible de prendre une partie seulement:
>>> from os import listdir
BalacSoft - Introduction Programmation Python 25
Types élémentaires en Python - 1/2

Nombres:

- Integer <type ‘int’>

- Float <type ‘float’>
- Complex <type ‘complex’>
=> utiliser 1j pour un nombre imaginaire

Booleans:

- True ou False
BalacSoft - Introduction Programmation Python 26
Types élémentaires en Python - 2/2

Strings:

- Pas de différences entre “xxx” ou ‘xxx’

- Caractères d’échappement
- Chaines de caractères brutes (raw):
>>> r’chaine brute’
- Les quotes triples ’’’ permettent des chaines de
caractères multiligne
- Unicode: u’Bert \x26 Ernie’ <type ‘unicode’>
BalacSoft - Introduction Programmation Python 27
 Manipulation : Les types de données
- Lancer python en mode console
- pour connaître le type d’une variable, il est possible d’utiliser le
mot clé ‘type(xxx)’
- créer plusieurs types :
>>> val=10 puis >>> msg=”hello” et >>> num=10,5
- Demander à python les types de ces variables :
>>> print(type(val)) résultat => <class ‘int’>
>>> print(type(msg)) résultat => <class ‘str’>
>>> print(type(num) résultat => <class ‘float’>
- Si on change ‘val’ :
>>> val=’abc’ et >>> print(type(val)) résultat => <class ‘str’>
=> C’est le typage dynamique ! ‘val’ a changé de type
BalacSoft - Introduction Programmation Python 28
 Le Langage Python
- Objets et Classes -

BalacSoft - Introduction Programmation Python 29

Programmation Orientée Objet (POO) - OOP en anglais

La POO est un concept de programmation informatique

axé sur la notion d’objets. L’objet étant un élément plus
“concrêt”, proche des objets de la réalité de tous les jours.

La POO va consister à identifier des objets, les catégoriser,

définir leur relation et leur comportement.

- Notions principales de la POO :

- Encapsulation
- Héritage
- Polymorphisme
BalacSoft - Introduction Programmation Python 30
POO – le principe d’encapsulation

- En POO, chaque objet est vu comme “une boite noire”,

son fonctionnement interne n’est pas connu des autres
objets => c’est le principe d’encapsulation

- Pour y accéder, il faut passer par ses méthodes

publiques (éventuellement ses membres publics). En
interne, l’objet utilisera des membres et méthodes pouvant
être privées ou protégées (qui lui sont propre).

BalacSoft - Introduction Programmation Python 31

POO – le principe de l’héritage - 1/2
- L’héritage consiste à avoir des déclinaisons d’une classe. Ce qui est
équivalent à avoir une “spécialisation” d’une classe générique. On dit
que la classe est “dérivée de” ou “héritée de”. On peut utiliser
l’expression “est un” pour identifier si une classe dérive d’une autre.

- Le plus simple est de prendre un exemple :

Si on considère une classe “Animal”. Un “Chien” ou un “Chat” seront
des classes dérivées de “Animal”. En effet, tous les animaux ont des
points communs : ce sont des être vivants, qui ont l’instinct de survie,
de reproduction, qui se déplacent, etc. “Chat” est un “Animal”
Il est ensuite possible de dérivée des classes de la classe “Chat” : par
exemple en classifiant les chats sauvages d’un côté et les chats
domestiques de l’autre.
BalacSoft - Introduction Programmation Python 32
POO – le principe de l’héritage - 2/2
- Un autre exemple souvent utilisé et très parlant, qu’on
retrouvera plus loin : la classe “Forme”.
Les classes “Rectangle” et « Ellipse » dérivent/héritent de la
classe “Forme”.

La classe “Carre” dérive de la classe “Rectangle” puisqu’un

carré n’est autre qu’un rectangle avec longueur=largeur

De la même manière, la classe “Cercle” dérive de la classe

“Ellipse”. En effet, un cercle est une ellipse avec la même valeur
pour les rayons en X et en Y.
BalacSoft - Introduction Programmation Python 33
POO – le principe de polymorphisme
- Polymorphisme : du latin “poly” qui signifie “multiple” et “morphisme”
qui signifie “forme”
Le concept de polymorphisme correspond donc au fait qu’une même
méthode puisse avoir plusieurs formes et donc plusieurs
comportements.

Polymorphisme par paramètrage : Il s’agit d’avoir plusieurs méthodes

ayant le même nom mais des paramètres différents. On parle aussi
de “surcharge” de fonctions. Donc le comportement de cette fonction
va varier en fonction des paramètres fournis

Polymorphisme par héritage : Surcharge d’une méthode entre 2

classes, l’une étant dérivée de l’autre
BalacSoft - Introduction Programmation Python 34
Les classes et les objets Python

- Comme vu dans l’introduction, Python permet notamment

la programmation objet. Il permet donc de manipuler des
classes et des objets
- Comme dans la plupart des langages, il est recommandé
de créer les classes dans des fichiers séparés

- Pour le nommage :
- Utiliser snake_case pour le nom du fichier
- Utiliser PascalCase pour le nom de classe
BalacSoft - Introduction Programmation Python 35
Définition d’une classe en Python

- Fichier ma_classe.py
- Exemple de contenu du fichier:
class MaClasse( ):
””” ceci est une classe Python “””
m_param = 0 # membre

def get_param(self) :
””” getter de la classe “””
return self.m_param

def set_param(self, val) :

””” setter de la clase “””
self.m_param=val
‘self’ identifie l’objet courant, équivalent à ‘this’ dans d’autre langages
BalacSoft - Introduction Programmation Python 36
Utilisation de la classe en Python

- Il faut d’abord importer : import ma_classe

- Il est possible ensuite d’appeler les méthodes

import ma_classe
(...)
ma_classe.set_param(5)
value = ma_classe.get_param()

- Dans cet exemple, la variable ‘m_param’ est privée (ou

protected) il faudrait lui ajouter un ou 2 underscores devant
(voir chapitre suivant)
BalacSoft - Introduction Programmation Python 37
Héritage de classe

- En Python, le principe d’héritage de classe existe. Il est réalisé

grâce au nom de la classe.
- Dans l’exemple précédent, la classe ‘MaClasse’ n’héritait de
rien. Par défaut : de object
- Pour qu’elle hérite d’une autre classe, il faut placer son nom
dans les paranthèses :

class MaClasseCercle(MaClasseForme):
””” Cette classe derive de MaClasseForme “””

- Ici la classe MaClasseCercle dérive de la classe

MaClasseForme
BalacSoft - Introduction Programmation Python 38
Le constructeur
- Nous reviendrons sur le constructeur dans le chapitre sur les fonctions
- Comme dans tous les langages objets, il est appelé à l’instanciation de la
classe
- Par contre, il a un nom spécifique “__init__”
- Attention, il n’y a pas de mot clé de type “new” en Python

class MaClasseCercle(MaClasseForme):
””” Cette classe derive de MaClasseForme “””
m_rayon = 10
def __init__(self, le_rayon):
””” Constructeur de la classe “””
self.m_rayon = le_rayon
def deplacer_cercle(self, delta_x, delta_y):
””” Methode publique de la classe “””
(...)
BalacSoft - Introduction Programmation Python 39
Instancier une classe Python

- Nous avons créé la classe MaClasseCercle avec son

constructeur (fichier ma_classe_cercle.py)
- Il est possible de l’instancier dans un autre fichier

import ma_classe_cercle
(…)
# instancier la classe - cela effectue l’appel au constructeur
le_cercle = ma_classe_cercle.MaClasseCercle()
# Il est possible d’utiliser maintenant les methodes
le_cercle.deplacer_cercle(10, 5)

BalacSoft - Introduction Programmation Python 40

 Manipulation : Classe Python
- Écrire la définition d’une classe MaClasseForme
- Idem avec 2 classes dérivées : MaClasseCercle et MaClasseRectangle
- Puis une classe dérivée de MaClasseRectangle qui sera
MaClasseCarre
- Pour l’instant, laisser vide le contenu, nous verrons l’implémentation de
ces classes dans le chapitre sur les fonctions

Résultat :
class MaClasseForme( ):
class MaClasseCercle(MaClasseForme):
class MaClasseRectangle(MaClasseForme):
class MaClasseCarre(MaClasseRectangle):
BalacSoft - Introduction Programmation Python 41
Le Langage Python
- Les fonctions -

BalacSoft - Introduction Programmation Python 42

Créer une fonction en Python

def function_name(arguments):
# ligne1
# ligne2
return xyz
Exemple:
Implémentation:
def first_function(x):
return x*2
Appel:
first_function(5)

L’indentation est essentielle en Python !

BalacSoft - Introduction Programmation Python 43
 Manipulation : Ma première fonction Python
- Ouvrir le fichier bonjour.py
- Le sauvegarder sous le nom #!/usr/bin/python3
#!/usr/bin/python3
""" ce script affiche Bonjour sur la console """
“f21_fonction1.py” """ ce script affiche Bonjour sur la console """

def affiche_bonjour():
def affiche_bonjour():
- L’affichage de bonjour va se faire via """ Fonction qui affiche bonjour """
""" Fonction qui affiche bonjour """
une fonction désormais print("Bonjour")
print("Bonjour")

affiche_bonjour()
affiche_bonjour()
- Le main sera réduit à l’appel de la
fonction

- Vérifier pylint (notamment penser à

rajouter un docstring pour la fonction)
BalacSoft - Introduction Programmation Python 44
 Manipulation : fonction main
- A partir de “f21_fonction1.py” créer
un fichier “f22_fonction2.py” #!/usr/bin/python3
#!/usr/bin/python3
- En python, il y a une syntaxe pour """ ce script affiche Bonjour sur la console via une fonction """
""" ce script affiche Bonjour sur la console via une fonction """

la fonction main def affiche_bonjour(my_message):

def affiche_bonjour(my_message):
if __name__ == "__main__": """ Fonction qui affiche un message passe en parametre """
""" Fonction qui affiche un message passe en parametre """
- C’est le code qui s’execute en print(my_message)
print(my_message)
premier : __main__
if __name__ == "__main__":
- Changer la fonction pour qu’elle if __name__ == "__main__":
affiche_bonjour("Bonjour")
prenne le message à afficher en affiche_bonjour("Bonjour")

paramètre
- Vérifier pylint

BalacSoft - Introduction Programmation Python 45

Scope d’une variable
Le scope définit le périmètre d’activité d’une variable, elle peut
être locale ou globale.
Lorsque la variable est utilisée à l’intérieur d’une fonction locale.
Dans ce cas, son scope est limitée uniquement à la fonction :
def function_name(arguments):
ma_variable_locale = 0

Il est néanmoins possible d’accéder à une variable globale à

l’intérieur d’une fonction grâce au mot clé global :
def function_name(arguments):
global ma_variable_global
ma_variable_global = 5
BalacSoft - Introduction Programmation Python 46
 Manipulation :Variables locales et globales
- Ouvrir le fichier “f22_fonction2.py”
- Le sauvegarder sous le nom “f23_fonction3.py”
- Afficher la valeur d’une variable à l’intérieur d’une fonction
- Créer une variable globale et y accéder à partir de la fonction
- Vérifier pylint (notamment penser à rajouter un docstring pour la
fonction)

BalacSoft - Introduction Programmation Python 47

Fonction en Python – plusieurs retours

En Python, il est possible de renvoyer plusieurs valeurs en retour

d’une fonction

Exemple:
Implémentation:
def second_function(x):
return x*2, x*x
Appel:
my_double, my_square = second_function(5)

C’est une fonctionnalité rare dans un langage de programmation!

BalacSoft - Introduction Programmation Python 48
Fonction en Python – paramètre par défaut 1/2

En Python, il n’existe pas de surcharge de fonction

(polymorphisme). A la place, il y a les arguments ‘par défaut’

Exemple :

Implémentation:
def multiply(a, b=2):
return a*b
Appel:
multiply(2, 5) # le resultat est 10
multiply(4) # le resultat est 8 : 4*2
BalacSoft - Introduction Programmation Python 49
Fonction en Python – paramètre par défaut 2/2

Il est possible de nommer les arguments pour avoir plusieurs

valeurs par défaut

Implémentation:
def multiply_new(a=1, b=2):
return a*b
Appel:
multiply_new(a=3, b=4) # le resultat est 12 (3*4)
multiply_new(3, 4) # le resultat est 12 (3*4)
multiply_new(2) # le resultat est 4 (2*2)
multiply_new(b=1) # le resultat est 1 (1*1)
multiply_new() # le resultat est 2 (1*2)
BalacSoft - Introduction Programmation Python 50
 Manipulation : fonction à multiple retours
- Créer un fichier “f24_fonction_cercle.py” #!/usr/bin/python3
#!/usr/bin/python3
""" aire et perimetre d'un cercle """
""" aire et perimetre d'un cercle """
- On va créer une fonction qui calcul le import math
import math
périmètre et l’aire d’un cercle dont le rayon def calcul(le_rayon):
est passé en paramètre def calcul(le_rayon):
""" renvoi le perimetre et l'aire """
""" renvoi le perimetre et l'aire """
le_perimetre = 2 * le_rayon * math.pi
le_perimetre = 2 * le_rayon * math.pi
- On aura besoin de l’import de math pour la l_aire = math.pi * le_rayon * le_rayon
l_aire = math.pi * le_rayon * le_rayon
valeur de PI return le_perimetre, l_aire
return le_perimetre, l_aire

if __name__ == "__main__":
- Utiliser str(xx) pour convertir en string, on if __name__ == "__main__":
PERIMETRE, AIRE = calcul(3)
PERIMETRE, AIRE = calcul(3)
voit aussi toute la force du type dynamique print("Perimetre=" + str(PERIMETRE))
print("Perimetre=" + str(PERIMETRE))
(en float sans rien préciser) print("Aire=" + str(AIRE))
print("Aire=" + str(AIRE))

BalacSoft - Introduction Programmation Python 51

Fonction en Python – fonctions spécifiques
Constructeur (2 underscores):
def __init__(self,...):
# lignes...
Destructeur :
def __del__(self,...):
# lignes...
Utilisation (‘self’ correspond à ‘this’ en Java):
class MyAddition() :
m_arg=0
def __init__(self, a) :
self.m_arg=a
Appel : value = MyAddition(5)
BalacSoft - Introduction Programmation Python 52
Fonction en Python–public/private/protected 1/2

En Python, par défaut toutes les méthodes et les membres sont

PUBLIC

- PRIVATE: visible uniquement dans la classe  => Deux

underscores devant
- PROTECTED : visible dans la classe courante et les classes
dérivées (héritées)
=> un underscore devant
- PUBLIC : visible par toutes les classes
=> RAS (par défaut)

BalacSoft - Introduction Programmation Python 53

Fonction en Python–public/private/protected 2/2

Attributs/Méthodes PROTECTED
self._my_protected_member=0
def _my_protected_function(self) :
# lignes...
Attributs/Méthodes PRIVATE
self.__my_private_member=0
def __my_private_function(self) :
# lignes...
Appel :
self.__my_private_function( )
BalacSoft - Introduction Programmation Python 54
Utilisation de ‘super’

- Pour appeler le constructeur de la classe parent, on

utilise la syntaxe suivante :
- Ici, la classe mère est MaClasseForme

def __init__(self, new_x=0, new_y=0):

""" constructeur appelle le super constructor """
MaClasseForme.__init__(self, new_x, new_y)

Astuce: Penser à utiliser from xxx import yyy pour éviter de

rajouter le préfixe de la classe pour chaque appel

BalacSoft - Introduction Programmation Python 55

 Manipulation : Créer les classes formes 1/2
- Nous revenons sur les classes définies dans le
chapitre précédent : MaClasseForme,
MaClasseRectangle, MaClasseCercle,
MaClasseCarre

- Pour chaque classe créer une méthode pour

calculer l’aire et une pour calculer le périmètre
- Pour la classe mère (MaClasseForme), il y aura 2
méthodes : une pour déplacer un objet et l’autre
pour afficher les coordonnées de l’objet
- Rajouter les membres protégés nécessaires :
rayon pour le cercle, longueur et largeur pour le
rectangle, côté pour le carré
BalacSoft - Introduction Programmation Python 56
 Manipulation : Créer les classes formes 2/2

- Dans le main, nous allons créer un rectangle de 2 sur 3 (peu importe

sa position), un carré de 6 de côté (peu importe sa position) et un
cercle à la position 15, 5 et de rayon 4

- nous allons appeler les méthodes pour calculer les périmètres et les
aires du carré, du cercle et du rectangle

- Pour finir, nous afficherons la position du cercle, que nous

déplacerons de (+2, +1) et afficherons à nouveau

- Bien sûr, pylint doit afficher 10/10

BalacSoft - Introduction Programmation Python 57
Les expressions lambda

- Une expression lambda est une fonction anonyme

pouvant prendre plusieurs paramètres en entrées mais un
seul en sortie. Cela permet notamment d’avoir un code
source condensé.
- La syntaxe est : lambda arguments : expression

x = lambda a, b : a + b
print(x(5, 2))

=> affiche 7
BalacSoft - Introduction Programmation Python 58
 Le Langage Python
- Boucles & Conditions -

BalacSoft - Introduction Programmation Python 59

Condition : IF - 1/2

if a==b:
# ligne1
elif a==c:
# ligne2
else:
# ligne3

Conditions :
>, <, >=, <= , ==, !=
value in table (ou not in)
Exemple : if ‘toto’ in m_string :

Pas de SWITCH/CASE en Python !

BalacSoft - Introduction Programmation Python 60
Condition : IF - 2/2

Operateurs: and / or
if a==b or a==c:
# ligne1

Pour un booléen:
if condition:

Il est possible d’utiliser le mot clé ‘pass’ qui n’effectue aucune

action :
if a==b:
pass
BalacSoft - Introduction Programmation Python 61
Boucle : WHILE
while condition:
# boucle ligne 1
# boucle ligne 2
# ligne 3, hors de la boucle

Il n’y a pas de boucle DO/WHILE en Python !

Il est possible d’utiliser les mots clés : ‘break’ (arrete la boucle), ‘continue’
(arrete l’iteration en cours) ou encore ‘else’ (possible dans une boucle
‘while’):
i=0
while i<6:
print(i)
if i==3 :
break
i += 1
BalacSoft - Introduction Programmation Python 62
 Manipulation : IF / WHILE
#!/usr/bin/python3
#!/usr/bin/python3
""" ce script test la fonction IF """
- Nous allons écrire un script du jeu plus """ ce script test la fonction IF """
import random

petit/plus grand import random

def lance_jeu():
def lance_jeu():
""" Jeu de plus petit, plus grand. Nombre de 1 a 1000 """
""" Jeu de plus petit, plus grand. Nombre de 1 a 1000 """
essai = 0

- Nous utiliserons random et input. essai = 0

# definir un nombre aleatoire
# definir un nombre aleatoire
Respectivement pour calculer un nombre resultat = random.randint(1, 1000)
resultat = random.randint(1, 1000)
rejouer = True
aléatoire et pour demander un nombre à rejouer = True
while rejouer:
while rejouer:
l’utilisateur essai += 1
essai += 1
ma_reponse = int(input("Saisissez une valeur>"))
ma_reponse = int(input("Saisissez une valeur>"))
if ma_reponse > resultat:
if ma_reponse > resultat:
print("Plus petit")
print("Plus petit")
elif ma_reponse < resultat:
elif ma_reponse < resultat:
print("Plus grand")
print("Plus grand")
else:
else:
# victoire
# victoire
print("Vous avez GAGNE en " + str(essai) + " coups !")
print("Vous avez GAGNE en " + str(essai) + " coups !")
rejouer = False
rejouer = False
if __name__ == "__main__":
if __name__ == "__main__":
BalacSoft - Introduction Programmation Python lance_jeu() 63
lance_jeu()
Boucle : FOR - 1/3

for index in range(X):

# boucle ligne 1

Si index n’est pas requis (utiliser un ‘_’):

for _ in range(10) :
# boucle ligne 1

Range peut être utilisé en increment/decrement :

for index in range(min, max, inc):
min=valeur de début
max=valeur de fin
inc=increment positif ou négatif
BalacSoft - Introduction Programmation Python 64
Boucle : FOR - 2/3

Une boucle peut fonctionner avec TOUS les itérables :

range, tableau, string, etc.
days=[‘L’, ‘M’, ‘M’, ‘J’, ‘V’, ‘S’, ‘D’]
for my_day in days:
print(my_day)

Boucle avec limites :

for index in range(2, 6):
print(index) # affichera 2 3 4 5

BalacSoft - Introduction Programmation Python 65

Boucle : FOR - 3/3

Boucle décroissante :
for index in range(10, 0, -1):
print(index)
Affichera : 10 9 8 7 6 5 4 3 2 1

Boucle avec string, arrays, object list, etc. 

for my_object in object_list:
# boucle

=> Les boucles sont très puissantes et simples à utiliser en

Python
BalacSoft - Introduction Programmation Python 66
 Manipulation : La boucle FOR 1/2
#!/usr/bin/python3
#!/usr/bin/python3
- Nous allons écrire un script pour """ ce script test la boucle FOR """
""" ce script test la boucle FOR """

traduire les jours de la semaine # constantes

# constantes
WEEK_DAYS = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]
WEEK_DAYS = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]
LA_SEMAINE = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"]
- La boucle FOR sert à parcourir les LA_SEMAINE = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"]

jours à l’intérieur du tableau def lance_traduction():

def lance_traduction():
""" Traduit les jours de la semaine """
""" Traduit les jours de la semaine """
jour_a_traduire = input("Donner un jour>")
jour_a_traduire = input("Donner un jour>")
jour_en_anglais = traduit_jour(jour_a_traduire)
jour_en_anglais = traduit_jour(jour_a_traduire)
print(jour_a_traduire + " => " + jour_en_anglais)
print(jour_a_traduire + " => " + jour_en_anglais)

def traduit_jour(le_jour):
def traduit_jour(le_jour):
""" Traduit un jour en anglais """
""" Traduit un jour en anglais """
for index in range(len(LA_SEMAINE)):
for index in range(len(LA_SEMAINE)):
if le_jour == LA_SEMAINE[index]:
if le_jour == LA_SEMAINE[index]:
return WEEK_DAYS[index]
return WEEK_DAYS[index]
return "Non trouve"
return "Non trouve"

if __name__ == "__main__":
if __name__ == "__main__":
BalacSoft - Introduction Programmation Python lance_traduction() 67
lance_traduction()
 Manipulation : La boucle FOR 2/2
- En fait, l’exemple précédent fonctionne très bien mais génère un warning pylint
- C’est parce qu’il peut s’écrire de manière plus efficace avec un objet enumerate

for index in range(len(LA_SEMAINE)):

if le_jour == LA_SEMAINE[index]:
return WEEK_DAYS[index]

Devient :

for index, index_jour in enumerate(LA_SEMAINE):

if le_jour == index_jour:
return WEEK_DAYS[index]

BalacSoft - Introduction Programmation Python 68

Gestion des Exceptions
De la même manière qu’en Java, il est possible (recommandé) de gérer les
exceptions de son logiciel. Pour cela, les mots clés sont: try / except. Il est
aussi possible d’utiliser finally pour le code qui sera toujours executé :

try:
x>3
except :
print(“un probleme…”)
else :
print(“Tout est ok”)
finally :
print(“le block try-except est termine”)

A noter qu’on peut aussi lever sa propre exception (personnalisée) en créant

une classe dérivée de ‘Exception’ et en utilisant le mot clé : raise
BalacSoft - Introduction Programmation Python 69
 Manipulation : EXCEPTIONS
- Nous allons mettre en évidence l’exception
#!/usr/bin/python3
‘division par 0’. Voici le résultat (voir fichier #!/usr/bin/python3
""" ce script teste les exceptions """
‘f33_exceptions_ko.py’): """ ce script teste les exceptions """

def mon_exception(valeur1, valeur2):

def mon_exception(valeur1, valeur2):
Traceback (most recent call last): """ gestion des exceptions """
""" gestion des exceptions """
File ".\fxx_exceptions.py", line 12, in <module> try:
try:
mon_exception(5, 0) resultat = valeur1 / valeur2
resultat = valeur1 / valeur2
File ".\fxx_exceptions.py", line 6, in mon_exception print("Resultat=" + str(resultat))
resultat = valeur1 / valeur2 print("Resultat=" + str(resultat))
except:
ZeroDivisionError: division by zero except:
print("Division par zero")
print("Division par zero")
- Il faut protéger le code en rajoutant un # main
block try/except # main
if __name__ == "__main__":
if __name__ == "__main__":
=> Voir fichier ‘f33_exceptions_ok.py’ mon_exception(6, 2)
mon_exception(6, 2)
mon_exception(5, 0)
mon_exception(5, 0)
Resultat=3.0
Division par zero
BalacSoft - Introduction Programmation Python 70
Le Langage Python
- Les Tableaux -

BalacSoft - Introduction Programmation Python 71

Les tableaux simples/listes
list.append(x): ajoute l’élément ‘x’ dans le tableau
list.append(x): ajoute l’élément ‘x’ dans le tableau
list.extend(iterable): étend le tableau avec ‘iterable’
- Le tableau à une dimension : list.extend(iterable): étend le tableau avec ‘iterable’
list.insert(i, x): insère l’élement ‘x’ à la position ‘i’
list.insert(i, x): insère l’élement ‘x’ à la position ‘i’
list.remove(x): retire le premier élément ‘x’
list.remove(x): retire le premier élément ‘x’
mon_tableau = [ ] list.pop([i]): retire et renvoi la valeur à la position ‘i’
list.pop([i]): retire et renvoi la valeur à la position ‘i’
mon_tableau.append(5) list.clear(): supprime tous les élements
list.clear(): supprime tous les élements
list.index(x): renvoi l’index du premier élément de valeur ‘x’
mon_tableau.append(12) list.index(x): renvoi l’index du premier élément de valeur ‘x’
list.count(x): renvoi le nombre d’éléments de valeur ‘x’
mon_tableau.append(7) list.count(x): renvoi le nombre d’éléments de valeur ‘x’
list.sort(key=None, reverse=False): tri la liste
print(mon_tableau) list.sort(key=None, reverse=False): tri la liste
list.reverse(): inverse l’ordre des éléments
list.reverse(): inverse l’ordre des éléments
list.copy(): renvoi une copie de la liste
list.copy(): renvoi une copie de la liste
=> Cela donnera : [5, 12, 7]
Pour accéder à une valeur du tableau : mon_tableau[x]
print(mon_tableau[2])

=> Cela donnera : 7

BalacSoft - Introduction Programmation Python 72
Les tableaux à 2 dimensions
- Le tableau à 2 dimensions est défini ainsi:
mon_tableau_2 = [ ]
mon_tableau_2.append([1,2,3,4])
mon_tableau_2.append([7,8,9])
print(mon_tableau_2)
=> Cela donnera : [ [ 1,2,3,4], [7, 8, 9] ]

print(mon_tableau_2[1])
=> Cela donnera : [7, 8, 9]

print(mon_tableau_2[1][2])
=> Cela donnera : 9
BalacSoft - Introduction Programmation Python 73
L’utilisation de listes
- Il est aussi possible d’avoir des éléments non numériques avec les listes.
Par exemple :
mes_couleurs = ["blue", "red", "green", "yellow", "black"]
mes_couleurs.append("white")
print(mes_couleurs)
=> Cela donnera : ['blue', 'red', 'green', 'yellow', 'black', 'white']

Il est possible de parcourir la liste très facilement avec une boucle for :
for ma_couleur in mes_couleurs :
print(ma_couleur)
=> Cela donnera : blue red green yellow black white
- Il est possible d’utiliser les mêmes opérateurs : append, pop, remove, etc.

BalacSoft - Introduction Programmation Python 74

 #!/usr/bin/python3
#!/usr/bin/python3

Manipulation : Tableau
""" ce script calcul la moyenne de notes sur 20 """
""" ce script calcul la moyenne de notes sur 20 """
def saisir_note():
def saisir_note():
""" Fonction qui saisie une note sur 20 """
""" Fonction qui saisie une note sur 20 """
la_note = int(input("Saisie note sur 20>"))
la_note = int(input("Saisie note sur 20>"))
- Créer un script qui permet de saisir des return la_note
return la_note
def calcul_moyenne(tableau_notes):
notes sur 20 et qui va effectuer la moyenne def calcul_moyenne(tableau_notes):
""" Fonction qui calcule la moyenne des notes """
""" Fonction qui calcule la moyenne des notes """
de toutes ces notes lorsque l’on ne saisira somme = 0
somme = 0
# effectue la somme
rien (valider sans saisie) # effectue la somme
for value in tableau_notes:
for value in tableau_notes:
somme = somme + value
somme = somme + value
return somme / len(tableau_notes)
- On utilisera “input” pour la saisie de la return somme / len(tableau_notes)
def mon_main():

valeur def mon_main():

""" le main du script """
""" le main du script """
fin = False
fin = False
le_tableau = []
le_tableau = []
while not fin:
while not fin:
note_saisie = saisir_note()
note_saisie = saisir_note()
if note_saisie >= 0 and note_saisie <= 20:
if note_saisie >= 0 and note_saisie <= 20:
le_tableau.append(note_saisie)
le_tableau.append(note_saisie)
else:
else:
# si la saisie n'est pas entre 0 et 20, on effectue le calcul
# si la saisie n'est pas entre 0 et 20, on effectue le calcul
fin = True
fin = True
print(calcul_moyenne(le_tableau))
print(calcul_moyenne(le_tableau))
# main
BalacSoft - Introduction Programmation Python # main 75
if __name__ == "__main__":
if __name__ == "__main__":
mon_main()
L’utilisation de dictionnaire
- Le dictionnaire correspond à un tableau de couple de données : (clé,
valeur) avec des éléments non ordonnés. La création d’un dictionnaire va se
faire avec des accolades { }. Par exemple, un couple “prénom”:”age” :
mes_eleves = {"Paul":"16","Pierre":"15", "Julie":"15", "Anne":"16"}
print(mes_eleves)
=> Cela donnera : {'Julie': '15', 'Paul': '16', 'Anne': '16', 'Pierre': '15'}

print(mes_eleves[“Paul”]) => 16

- Pour rajouter un élément :

mes_eleves[“Jacques”] = "14"
print(mes_eleves)
=> Cela donnera :
{'Julie': '15', 'Paul': '16', 'Anne': '16', 'Pierre': '15', ’Jacques’:’14’}
BalacSoft - Introduction Programmation Python 76
Le Langage Python
- Graphique -

BalacSoft - Introduction Programmation Python 77

 => TODO : Montrer l’utilisation de TKINTER pour
l’IHM

BalacSoft - Introduction Programmation Python 78

Le Langage Python
- Frameworks -

BalacSoft - Introduction Programmation Python 79

 => TODO : Donner quelques exemples de framework
intéressants :
- json : librairie Json
- pygame : jeu video
- django : web
- flask :
- NumPy / SciPy : Data Science
- ...

BalacSoft - Introduction Programmation Python 80

Le Langage Python
- CI/CD -

BalacSoft - Introduction Programmation Python 81

=> TODO : Montrer comment intégrer Python dans un
environnement d’intégration continue (Continuous
Integration / Continuous Delivery)
=> TODO : Prendre GITLAB en exemple (gratuit)

BalacSoft - Introduction Programmation Python 82

Le Langage Python
- Projet -

BalacSoft - Introduction Programmation Python 83

=> TODO : Identifier un projet complet à faire en mode
manipulation

BalacSoft - Introduction Programmation Python 84