Python3 TS STIC

Cours de
Initiation
programmation
à Python 3
Initiation à
Python 3
TS STIC 1
S. T. I. C
2018 - 2019
Auteur
Enseignant vacataire en informatique à l’INP-HB

Doctorant à l’EDP / INP-HB au LARIT
Département : Maths – Info
kpoloua@gmail.com / 00225 77 09 37 26
CM : 24 Heure
Novembre 2018
A Celui qui peut tout
Et qui me rend capable de tout,
Mon bien-aimé Père !

Table des matières
CHAPITRE 1 : Introduction à python ...................................................................................... 4
I. Historique de python.......................................................................................................................... 5
1.1. Genèse ........................................................................................................................................ 5
1.2. Evolution..................................................................................................................................... 5
II. Les avantages de python .................................................................................................................... 5
III. Les IDE pour développer en python ............................................................................................... 6
3.1. Installation de python ................................................................................................................ 6
3.2. Les environnements de développement intégré (IDE) .............................................................. 6
IV. Fonctionnement de python ............................................................................................................ 8
CHAPITRE 2 : Éléments de base en python........................................................................ 9
I. Déclaration de variables ................................................................................................................... 10
II. Quelques notions ............................................................................................................................. 10
III. Structure d’un programme en python ......................................................................................... 11
IV. Premier programme ..................................................................................................................... 11
V. Les types de base en python ............................................................................................................ 11
5.1. Les entiers (integer).................................................................................................................. 12
5.2. Les nombres flottants ou réel (float)........................................................................................ 12
5.3. Les chaînes de caractères (les string) ....................................................................................... 12
5.4. Les listes.................................................................................................................................... 12
5.5. Les tuples .................................................................................................................................. 16
5.6. Les dictionnaires ....................................................................................................................... 18
CHAPITRE 3 : Les fonctions / Les exceptions en python .......................................... 21
I. Notion de fonction et procédure en python .................................................................................... 22
II. Exemple de fonction......................................................................................................................... 23
III. Les modules et packages .............................................................................................................. 26
IV. Les exceptions python .................................................................................................................. 26
4.1. Try except ................................................................................................................................. 27
4.2. Cibler les erreurs ...................................................................................................................... 27
4.3. Finally........................................................................................................................................ 29
4.4. Compréhension des listes ! ...................................................................................................... 29
CHAPITRE 4 : La POO en python ............................................................................................ 31
I. Notion de classe et d’objet............................................................................................................... 32
1.1. Définition d’une classe ............................................................................................................. 32
TS STIC 1 / 2018-2019
II. Les différents concepts de la POO (Programmation Orienté Objet) en Python .............................. 34
2.1. Le constructeur......................................................................................................................... 34
2.2. L’héritage .................................................................................................................................. 35
2.3. Le polymorphisme / Surcharge de méthode ............................................................................ 36
CHAPITRE 5 : Les bibliothèques Mathématiques.......................................................... 40
I. La bibliothèque math ....................................................................................................................... 41
1.2. Fonctions logarithme et exponentielle .................................................................................... 42
1.3. Fonctions trigonométriques ..................................................................................................... 43
1.4. Conversion angulaire ................................................................................................................ 43
1.5. Fonctions hyperboliques .......................................................................................................... 44
1.6. Constantes ................................................................................................................................ 44
II. Le module random ........................................................................................................................... 45
III. La bibliothèque mathplotlib ......................................................................................................... 46
3.1. Définition .................................................................................................................................. 46
3.2. Des détails ................................................................................................................................ 47
3.3. Quelques exemples .................................................................................................................. 48
CHAPITRE 6 : La gestion des fichiers ................................................................................. 52
I. Edition d’un fichier ........................................................................................................................... 53
1.1. Editer un fichier ........................................................................................................................ 53
1.2. La fonction open ....................................................................................................................... 53
1.3. Les types d'ouverture ............................................................................................................... 53
1.4. Fermeture d'un fichier.............................................................................................................. 54
1.5. Lire le contenu d'un fichier ....................................................................................................... 54
1.6. Ecrire dans un fichier ................................................................................................................ 54
1.7. Le mot clé with ......................................................................................................................... 54
II. Application........................................................................................................................................ 55
2.1. Concernant le répertoire .......................................................................................................... 55
2.2. Application 1............................................................................................................................. 55
2.3. Application 2............................................................................................................................. 55
2.4. Les exceptions .......................................................................................................................... 56
2.5. Application 3............................................................................................................................. 57
CHAPITRE 7 : La bibliothèque graphique tkinter .......................................................... 58
I. Présentation de tkinter .................................................................................................................... 59
II. Création d’une fenêtre avec tkinter ................................................................................................. 59
III. Construisons notre première fenêtre en python avec la bibliothèque « tkinter ». ........................ 59
TS STIC 1 / 2018-2019
IV. Considérons cette application suivante : ........................................................................................... 59
V. Les composants visuels ou widgets V. Les évènements ...................................................................... 60
VI. Les classes de widgets tkinter ...................................................................................................... 61
VII. Animation automatique – Récursivité.......................................................................................... 62
VIII. POO avec les interfaces graphiques ................................................................................................. 64
5.1. Cahier des charges de notre programme ................................................................................. 64
5.2. Mise en œuvre concrète .......................................................................................................... 65
5.3. Commentaires .......................................................................................................................... 67
Objectif visé :
▪ Savoir écrire des programmes en python
Compétences spécifiques visées par l’EC :
▪ Savoir écrire des programmes simples en python

▪ Maîtriser la POO en python
▪ Maîtriser certaines bibliothèques scientifiques en python
▪ Savoir faire la programmation graphique en python
Prérequis :
▪ Notions de base en algorithmique ;
TS STIC 1 / 2018-2019
CHAPITRE 1 : Introduction à python
TS STIC 1 / 2018-2019
I. Historique de python
1.1. Genèse
Python est un langage de programmation, dont la première version est sortie en 1991. Créé
par Guido van Rossum, il a voyagé du Macintosh de son créateur, qui travaillait à cette époque
au Centrum voor Wiskunde en Informatica aux Pays-Bas, jusqu'à se voir associer une
organisation à but non lucratif particulièrement dévouée, la Python Software Foundation, créée
en 2001. Ce langage a été baptisé ainsi en hommage à la troupe de comiques les « Monty
Python ».
1.2. Evolution
Lors de la création de la Python Software Foundation, en 2001, et durant les années qui ont
suivi, le langage Python est passé par une suite de versions que l'on a englobées dans
l'appellation Python 2.x (2.3, 2.5, 2.6…). Depuis le 13 février 2009, la version 3.0.1 est disponible.
Cette version casse la compatibilité ascendante qui prévalait lors des dernières versions. A
présent python existe sous la version 3.7.0
II. Les avantages de python
Python est un langage puissant, à la fois facile à apprendre et riche en possibilités. Dès l'instant
où vous l'installez sur votre ordinateur, vous disposez de nombreuses fonctionnalités intégrées
au langage que nous allons découvrir tout au long de ce livre.
Il est, en outre, très facile d'étendre les fonctionnalités existantes, comme nous allons le voir.
Ainsi, il existe ce qu'on appelle des bibliothèques qui aident le développeur à travailler sur des
projets particuliers. Plusieurs bibliothèques peuvent ainsi être installées pour, par exemple,
développer des interfaces graphiques en Python.
Concrètement, voilà ce qu'on peut faire avec Python :
de petits programmes très simples, appelés scripts, chargés d'une mission très précise
sur votre ordinateur ;
des programmes complets, comme des jeux, des suites bureautiques, des logiciels
multimédias, des clients de messagerie…
des projets très complexes, comme des progiciels (ensemble de plusieurs logiciels
pouvant fonctionner ensemble, principalement utilisés dans le monde professionnel).
Voici quelques-unes des fonctionnalités offertes par Python et ses bibliothèques :
créer des interfaces graphiques ;
faire circuler des informations au travers d'un réseau ;
dialoguer d'une façon avancée avec votre système d'exploitation ;
… et j'en passe…
Bien entendu, vous n'allez pas apprendre à faire tout cela en quelques minutes. Mais ce cours
vous donnera des bases suffisamment larges pour développer des projets qui pourront devenir,
par la suite, assez importants.
TS STIC 1 / 2018-2019
III. Les IDE pour développer en python
3.1. Installation de python
1. Pour installer python, rendez-vous sur le site suivant :

https://www.python.org/ftp/python/3.7.0/python-3.7.0.exe
2. Lancer l’exécutable ainsi téléchargé et suivez les instructions d’installation.
3.2. Les environnements de développement intégré (IDE)
Un environnement de développement intégré est un outil qui va vous faciliter la

programmation dans un langage de programmation. En python il en existe plusieurs dont nous
allons présenter quelques-uns.
Sublime Text
Sublime text possède tout une panoplie de plugins dont vous serez vite
accroc ! Sa version de base est gratuite, une petite alerte vous
demandera de temps en temps si vous voulez acheter une licence pour
soutenir le projet mais rien ne vous oblige à le faire.
Spyder
Créé et développé par Pierre Raybaut en 2008, Spyder est maintenu, depuis 2012, par une
communauté de développeurs qui ont pour point commun d'appartenir à la communauté
Python scientifique.
En comparaison avec d'autres IDE pour le développement scientifique, Spyder a un ensemble
unique de fonctionnalités - multiplateforme, open-source, écrit en Python et disponible sous
TS STIC 1 / 2018-2019
une licence non-copyleft. Spyder est extensible avec des plugins, comprend le support d'outils
interactifs pour l'inspection des données et incorpore des instruments d'assurance de la qualité
et d'introspection spécifiques au code Python, tels que Pyflakes, Pylint et Rope. C’est celui que
nous allons utiliser dans ce cours.
Python notebook
L’interpréteur
TS STIC 1 / 2018-2019
L’interpréteur de script permet d’exécuter les instructions directement.
IV. Fonctionnement de python

Eh oui, vous allez devoir patienter encore un peu car il me reste deux ou trois choses à vous
expliquer, et je suis persuadé qu'il est important de connaître un minimum ces détails qui
peuvent sembler peu pratiques de prime abord.
Python est un langage de programmation interprété, c'est-à-dire que les instructions que vous
lui envoyez sont « transcrites » en langage machine au fur et à mesure de leur lecture. D'autres
langages (comme le C / C++) sont appelés « langages compilés » car, avant de pouvoir les
exécuter, un logiciel spécialisé se charge de transformer le code du programme en langage
machine. On appelle cette étape la « compilation ». À chaque modification du code, il faut
rappeler une étape de compilation.
Les avantages d'un langage interprété sont la simplicité (on ne passe pas par une étape de
compilation avant d'exécuter son programme) et la portabilité (un langage tel que Python est
censé fonctionner aussi bien sous Windows que sous Linux ou Mac OS, et on ne devrait avoir à
effectuer aucun changement dans le code pour le passer d'un système à l'autre). Cela ne veut
pas dire que les langages compilés ne sont pas portables, loin de là ! Mais on doit utiliser des
compilateurs différents et, d'un système à l'autre, certaines instructions ne sont pas
compatibles, voire se comportent différemment.
En contrepartie, un langage compilé se révélera bien plus rapide qu'un langage interprété (la
traduction à la volée de votre programme ralentit l'exécution), bien que cette différence tende
à se faire de moins en moins sentir au fil des améliorations. De plus, il faudra installer Python
sur le système d'exploitation que vous utilisez pour que l'ordinateur puisse comprendre votre
code.
TS STIC 1 / 2018-2019
CHAPITRE 2 : Éléments de base en
python
TS STIC 1 / 2018-2019
I. Déclaration de variables
Une variable est un espace mémoire dans lequel il est possible de mettre une valeur. Python
est typé dynamiquement. C’est-à-dire qu’une variable déclarée en tant que qu’un entier peut
également contenir une chaine de caractère après.
Par exemple : X = 1 (X est du type Integer)
X = 1.0 (X passe au type float)
Cela n’existe pas dans les autres langages comme C, C++ …
Une variable ne doit pas faire partir du vocabulaire de Python ou mots réservés :
II. Quelques notions
Nom Symbole
Addition +
Opérations Multiplication *
mathématique Division /
Division entière //
Modulo %
Comparaison <>
Différent !=
Logique Test égalité ==
ET – OU and - or
Affectation Affectation =
Exposant **
TS STIC 1 / 2018-2019
III. Structure d’un programme en python
La programmation en python est organisée en bloc d’instruction. Un bloc d'instructions est une
suite d'instructions qui est alignée sur la même tabulation. Les blocs d'instructions sont créés
par les instructions de contrôles comme if, while et for, ainsi que par les instructions permettant
de déclarer des fonctions.
Sous Python, toutes les instructions composées ont toujours la même structure : une ligne d'en-
tête terminée par un double point, suivie d'une ou de plusieurs instructions indentées sous
cette ligne d'en-tête. L’indentation est obligatoire en python.
Ligne d'en-tête:
première instruction du bloc
... ...
... ...
dernière instruction du bloc
autre instruction
une autre par ici
Il y a deux solutions pour indenter : utiliser quatre espaces ou un seul caractère tabulation, mais
jamais un mélange des deux sous peine d'erreurs IndentationError : unindent does not match
any outer indentation level. En effet, et même si le résultat paraît identique à l'écran, espaces
et tabulations sont des codes binaires distincts : Python considérera donc que ces lignes
indentées différemment font partie de blocs différents.
IV. Premier programme

Ouvrez votre éditeur préférer et saisissez ceci :
>>> nom = "KPO LOUA"

>>> print("Bonjour monsieur ! Votre nom est : ",nom)
Bonjour monsieur ! Votre nom est : KPO LOUA
Commentez ce code !
V. Les types de base en python
Là se trouve un concept très important, que l'on retrouve dans beaucoup de langages de
programmation. Ouvrez grand vos oreilles, ou plutôt vos yeux, car vous devrez être
TS STIC 1 / 2018-2019
parfaitement à l'aise avec ce concept pour continuer la lecture de ce livre. Rassurez-vous
toutefois, du moment que vous êtes attentifs, il n'y a rien de compliqué à comprendre.
Qu'entend-on par « type de donnée » ?
Jusqu'ici, vous n'avez travaillé qu'avec des nombres. Et, s'il faut bien avouer qu'on ne fera que
très rarement un programme sans aucun nombre, c'est loin d'être la seule donnée que l'on peut
utiliser en Python. À terme, vous serez même capables de créer vos propres types de données,
mais n'anticipons pas.
Python a besoin de connaître quels types de données sont utilisés pour savoir quelles
opérations il peut effectuer avec. Dans ce chapitre, vous allez apprendre à travailler avec des
chaînes de caractères, et multiplier une chaîne de caractères ne se fait pas du tout comme la
multiplication d'un nombre. Pour certains types de données, la multiplication n'a d'ailleurs
aucun sens. Python associe donc à chaque donnée un type, qui va définir les opérations
autorisées sur cette donnée en particulier.
5.1. Les entiers (integer)
Le type entier se nomme int en Python (qui correspond à l'anglais « integer », c'est-à-dire
entier). La forme d'un entier est un nombre sans virgule.
5.2. Les nombres flottants ou réel (float)
Les flottants sont les nombres à virgule. Ils se nomment float en Python (ce qui signifie « flottant
» en anglais). La syntaxe d'un nombre flottant est celle d'un nombre à virgule (n'oubliez pas de
remplacer la virgule par un point). Si ce nombre n'a pas de partie flottante mais que vous voulez
qu'il soit considéré par le système comme un flottant, vous pouvez lui ajouter une partie
flottante de 0 (exemple 52.0).
5.3. Les chaînes de caractères (les string)
Heureusement, les types de données disponibles en Python ne sont pas limités aux seuls
nombres, bien loin de là. Le dernier type « simple » que nous verrons dans ce chapitre est la
chaîne de caractères. Ce type de donnée permet de stocker une série de lettres, pourquoi pas
une phrase.
On peut écrire une chaîne de caractères de différentes façons :
• entre guillemets ("ceci est une chaîne de caractères") ;
• entre apostrophes ('ceci est une chaîne de caractères') ;
• entre triples guillemets ("""ceci est une chaîne de caractères""").
On peut, à l'instar des nombres (et de tous les types de données) stocker une chaîne de
caractères dans une variable (ma_chaine = "Bonjour, la foule !")
5.4. Les listes
Une liste en python est une collection de donne de tout type dans une seul variable.
Création de liste : Pour créer une liste, rien de plus simple:
TS STIC 1 / 2018-2019
>>> liste = [] # ou bien
>>> liste = list()
Ajout des éléments à mon ma liste :

Après la création de la liste avec la méthode append (qui signifie "ajouter" en anglais):
>>> liste = []
>>> liste
[]
>>> liste.append(1)
>>> liste
[1]
>>> liste.append("ok")
>>> liste
[1, 'ok']
Afficher un item d'une liste

Pour lire une liste, on peut demander à voir l'index de la valeur qui nous intéresse :
>>> liste = ["a","d","m"]
>>> liste[0]
'a'
>>> liste[2]
'm'
Le premier item commence toujours avec l'index 0. Pour lire le premier item on utilise la valeur
0, le deuxième on utilise la valeur 1, etc.
Il est d'ailleurs possible de modifier une valeur avec son index
>>> liste = ["a","d","m"]
>>> liste[0]
'a'
>>> liste[2]
TS STIC 1 / 2018-2019
'm'
>>> liste[2] = "z"
>>> liste
['a', 'd', 'z']
Supprimer une entrée avec un index

Il est parfois nécessaire de supprimer une entrée de la liste. Pour cela vous pouvez
utiliser la fonction del.
>>> liste = ["a", "b", "c"]
>>> del liste[1]
>>> liste
['a', 'c']
Supprimer une entrée avec sa valeur

Il est possible de supprimer une entrée d'une liste avec sa valeur avec la
méthode remove.
>>> liste = ["a", "b", "c"]
>>> liste.remove("a")
>>> liste
['b', 'c']
Compter le nombre d'items d'une liste

Il est possible de compter le nombre d'items d'une liste avec la fonction len.
>>> liste = [1,2,3,5,10]
>>> len(liste)
Compter le nombre d'occurrences d'une valeur

Pour connaitre le nombre d'occurrences d'une valeur dans une liste, vous pouvez utiliser
la méthode count.
>>> liste = ["a","a","a","b","c","c"]
>>> liste.count("a")
TS STIC 1 / 2018-2019
>>> liste.count("c")
Trouver l'index d'une valeur

La méthode index vous permet de connaitre la position de l'item cherché.
>>> liste = ["a","a","a","b","c","c"]
>>> liste.index("b")
Manipuler une liste

Voici quelques astuces pour manipuler des listes :
>>> liste = [1, 10, 100, 250, 500]
>>> liste[0]
>>> liste[-1] # Cherche la dernière occurence
500
>>> liste[-4:] # Affiche les 4 dernières occurrences
[500, 250, 100, 10]
>>> liste[:] # Affiche toutes les occurences
[1, 10, 100, 250, 500]
>>> liste[2:4] = [69, 70]
[1, 10, 69, 70, 500]
>>> liste[:] = [] # vide la liste
[]
Transformer un string en liste

Parfois il peut être utile de transformer une chaine de caractère en liste. Cela est possible avec
la méthode split.
>>> ma_chaine = "Olivier:ENGEL:Strasbourg"
>>> ma_chaine.split(":")
['Olivier', 'ENGEL', 'Strasbourg']
TS STIC 1 / 2018-2019
Transformer une liste en string
L'inverse est possible avec la méthode "join".
>>> liste = ["Olivier","ENGEL","Strasbourg"]
>>> ":".join(liste)
'Olivier:ENGEL:Strasbourg'
Trouver un item dans une liste

Pour savoir si un élément est dans une liste, vous pouvez utiliser le mot clé in de cette
manière:
>>> liste = [1,2,3,5,10]
>>> 3 in liste
True
>>> 11 in liste
False
5.5. Les tuples
Un tuple est une liste qui ne peut plus être modifiée.

Créer un tuple
Pour créer un tuple, vous pouvez utiliser la syntaxe suivante :
>>> mon_tuple = ()
Ajouter une valeur à un tuple

Pour créer un tuple avec des valeurs, vous pouvez le faire de cette façon :
>>> mon_tuple = (1, "ok", "olivier")
Les parenthèses ne sont pas obligatoires mais facilite la lisibilité du code (rappelons que la force
de python est sa simplicité de lecture):
>>> mon_tuple = 1, 2, 3
>>> type(mon_tuple)
<type 'tuple'>
Lorsque vous créez un tuple avec une seule valeur, n'oubliez pas d'y ajouter une virgule, sinon
ce n'est pas un tuple.
TS STIC 1 / 2018-2019
>>> mon_tuple = ("ok")
>>> type(mon_tuple)
<type 'str'>
>>> mon_tuple = ("ok",)
>>> type(mon_tuple)
<type 'tuple'>
Afficher une valeur d'un tuple

Le tuple est une sorte de liste, on peut donc utiliser la même syntaxe pour lire les
données du tuple.
>>> mon_tuple[0]
Et évidemment si on essaie de changer la valeur d'un index, l'interpréteur nous insulte

copieusement:
>>> mon_tuple[1] = "ok"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
A quoi sert un tuple alors ?

➢ Le tuple permet une affectation multiple :
>>> v1, v2 = 11, 22
>>> v1
11
>>> v2
22
➢ Il permet également de renvoyer plusieurs valeurs lors d'un appel d'une fonction :
>>> def donne_moi_ton_nom():
... return ("olivier", "engel")
TS STIC 1 / 2018-2019
...
>>> donne_moi_ton_nom()
('olivier', 'engel')
On utilisera un tuple pour définir des sortes de constantes qui n'ont donc pas vocation à
changer.
5.6. Les dictionnaires
Un dictionnaire en python est une sorte de liste mais au lieu d'utiliser des index, on utilise
des clés, c'est à dire des valeurs autres que numériques.
Comment créer un dictionnaire ?

Pour initialiser un dictionnaire, on utile la syntaxe suivante :
>>> a = {}
Comment ajouter des valeurs dans un dictionnaire ?

Pour ajouter des valeurs à un dictionnaire il faut indiquer une clé ainsi qu'une valeur :
>>> a = {}
>>> a["nom"] = "engel"
>>> a["prenom"] = "olivier"
>>> a
{'nom': 'engel', 'prenom': 'olivier'}
Vous pouvez utiliser des clés numériques comme dans la logique des listes.
Récupérer une valeur dans un dictionnaire
La méthode get vous permet de récupérer une valeur dans un dictionnaire et si la clé est
introuvable, vous pouvez donner une valeur à retourner par défaut :
>>> data = {"name": "Olivier", "age": 30}
>>> data.get("name")
'Olivier'
>>> data.get("adresse", "Adresse inconnue")
'Adresse inconnue'
TS STIC 1 / 2018-2019
Vérifier la présence d'une clé dans un dictionnaire
Vous pouvez utiliser la méthode haskey pour vérifier la présence d'une clé que vous cherchez :
>>> a.has_key("nom")
True
Supprimer une entrée de dictionnaire

Il est possible de supprimer une entrée en indiquant sa clé, comme pour les listes:
>>> del a["nom"]
>>> a
{'prenom': 'olivier'}
Récupérer les clés par une boucle

Pour récupérer les clés on utilise la méthode keys
>>> fiche = {"nom":"engel","prenom":"olivier"}
>>> for cle in fiche.keys():
... print cle
...
nom
prenom
Récupérer les valeurs par une boucle

Pour cela on utilise la méthode values
>>> for valeur in fiche.values():
... print valeur
...
engel
olivier
Récupérer les clés et les valeurs par une boucle

Pour récupérer les clés et les valeurs en même temps, on utilise la méthode items qui retourne
un tuple.
TS STIC 1 / 2018-2019
>>> for cle,valeur in fiche.items():
... print cle, valeur
...
nom engel
prenom olivier
Utiliser des tuples comme clé

Une des forces de python est la combinaison tuple/dictionnaire qui fait des merveilles dans
certains cas comme lors de l'utilisation de coordonnées.
>>> b = {}
>>> b[(3,2)]=12
>>> b[(4,5)]=13
>>> b
{(4, 5): 13, (3, 2): 12}
Créer une copie indépendante d'un dictionnaire

Comme pour toute variable, vous ne pouvez pas copier un dictionnaire en faisant dic1 = dic2:
>>> d = {"k1":"olivier", "k2":"engel"}
>>> e = d
>>> d["k1"] = "XXX"
>>> e
{'k2': 'engel', 'k1': 'XXX'}
Pour créer une copie indépendante vous pouvez utiliser la méthode copy:
>>> d = {"k1":"olivier", "k2":"engel"}
>>> e = d.copy()
>>> d["k1"] = "XXX"
>>> e
{'k2': 'engel', 'k1': 'olivier'}
TS STIC 1 / 2018-2019
CHAPITRE 3 : Les fonctions / Les
exceptions en python
TS STIC 1 / 2018-2019
I. Notion de fonction et procédure en python
Une fonction est un programme portant un nom et réutilisable dans un ou plusieurs autres
programmes. Son utilisation nous permet de coder très vite rendant la vie du programmeur très
douce. Elle exécute une tâche unique !
Une fonction n'est pas obligée de renvoyer une valeur, on parlera alors dans ce cas
plutôt de procédure.
def maFonction():
Mes_instructions
return resultat
def maProcedure():
Mes_instructions
Les fonctions et les procédures sont utilisées à cause de leur capacité à avoir des paramètres à
l’entrée. Elles ont la capacité d’avoir assez d’argument possible.
Les paramètres
Créons une fonction :
>>> def augmente_moi(a):
... return a + 2
...
>>> augmente_moi(1)
Cette fonction incrémente de 2 une valeur que l'on passe en paramètre.

Il est d'ailleurs possible d'utiliser plusieurs paramètres :
>>> def augmente_moi(a, b):
... return 30 + a + b
...
>>> augmente_moi(1, 2)
33
TS STIC 1 / 2018-2019
Si vous avez compris les principes des fonctions, vous avez compris 80% de ce qu'est la
programmation.
Variable local, variable global : on parle de la portée des variables

Une variable déclarée à la racine d'un module est visible dans tout ce module. On parle alors
de variable globale.
>>> x = "hello"
>>> def test():
... print x
...
>>> test()
hello
Et une variable déclarée dans une fonction ne sera visible que dans cette fonction. On parle
alors de variable locale.
>>> x = False
>>> def test():
... x = "hello"
...
>>> test()
>>> x
False
II. Exemple de fonction

abs(x)
Retourne une valeur absolue
>>> abs(-1)
str.capitalize()
La méthode capitalize permet de mettre une chaine de caractères au format Xxxxx
>>> "oLIviER".capitalize()
TS STIC 1 / 2018-2019
'Olivier'
choice([])
Retourne une valeur d'une liste aléatoirement.
>>> import random
>>> random.choice([1,2,3,4,5])
>>> random.choice([1,2,3,4,5])
str.count(string)
La méthode count compte le nombre d'occurrences de la recherche demandée.
>>> "olivier".count("i")
eval(expression,globals=None,locals=None)
Exécute une chaine de caractères.
>>> v = 101
>>> eval('v+1')
102
str.find(string)
La méthode find trouve la première occurrence de la recherche demandée.
>>> "olivier".find("i")
help(element)
Cette fonction vous retourne des informations sur l'utilisation de l'élément qui vous intéresse.
len(s)
Retourne le nombre d'items d'un objet.
>>> len([1,2,3])
>>> len("olivier")
TS STIC 1 / 2018-2019
7
max() / min()
Retourne la valeur la plus élevée pour max() et la plus basse pour min()
>>> max([1,3,2,6,99,1])
99
>>> max(1,4,6,12,1)
12
randint()
Retourne un int aléatoire.
>>> import random
>>> random.randint(1,11)
random()
Retourne une valeur aléatoire.
>>> import random
>>> random.random()
0.9563522652738929
str.replace(string, string)
La méthode replace remplace un segment d'une chaine de caractères par une autre :
>>> "olivier".replace("i", "a")
'olavaer'
reverse()
La méthode reverse inverse l'ordre d'une liste.
>>> x = [1,4,7]
>>> x.reverse()
>>> x
[7, 4, 1]
TS STIC 1 / 2018-2019
list.sort()
La méthode sort permet de trier une liste.
>>> l = [5,1,4,2,10]
>>> l.sort()
>>> l
[1, 2, 4, 5, 10]
sum(iterable [,start])
Additionne les valeurs d'un élément itérable.
>>> sum([1,2,3])
III. Les modules et packages

Un module est un ensemble de fonctions écrites qui ont un lien précis dans un seul ficher .py. Ces
fonctions pourront être utiliser dans un autre programme juste par importation avec la commande
(module.py) :
>>> import module # pour importer toutes les fonctions de mon module
>>>from module import fonction1, fonction2
>>>from module import* # Pour importer aussi toutes les fonctions du module
Le package c’est un dossier qui contient plusieurs modules. Son importation est similaire à celui
des modules.
>>>from package.module import fonction1, fonction2
>>>from package.module import* # Pour importer aussi toutes les fonctions du module
IV. Les exceptions python
Exécuter ce script ci-dessous :
>>> 5/0
TS STIC 1 / 2018-2019
ZeroDivisionError: integer division or modulo by zero
On remarque tout d'abord que python est certes sévère mais juste ; il nous dit pourquoi il n'est
pas content: ZeroDivisionError.
Cet exemple est sans intérêt mais il est tout à fait possible d'utiliser une variable comme
dénominateur et à ce moment-là comment éviter cette erreur?
Une solution serait de vérifier la valeur de la variable et si elle est égale à 0, on annule tout.
Une autre solution serait d'anticiper qu'il serait possible qu'il y ait une erreur et en cas d'erreur
prévoir des instructions spécifiques.
4.1. Try except
Try signifie "essayer" en anglais, ce mot clé permet d'essayer une action et si l'action échoue on
peut lui donner d'autres instructions dans un bloc except.
>>> v = 0
>>> w = 5
>>> try:
... w/v
... print "Ok pas erreur"
... except:
... print "Erreur"
...
Erreur
Alors pourquoi utiliser try ?

Et bien ce genre d'erreur est bloquante, c'est-à-dire que si les instructions sont exécutées dans
un script, le script s'arrête et cela devient un bug.
4.2. Cibler les erreurs
La syntaxe exposée plus haut répond à tout type d'erreur, mais il est possible d'affiner
la gestion d'erreur.
Par exemple que se passe-t-il si nous divisons un nombre par des lettres ?
>>> 5/"stic"
TS STIC 1 / 2018-2019
TypeError: unsupported operand type(s) for /: 'int' and 'str'
On remarque que python nous affiche une erreur mais elle est différente de celle provoquée
par la division par 0. Ici l'erreur est TypeError.
Il est possible en python d'exécuter des instructions en fonction du type d'erreur. Par exemple
si la valeur est 0 on aimerait afficher un message et si le dénominateur est du texte on aimerait
pouvoir afficher un autre message à l'utilisateur.
>>> v = 0
>>> w = 5
>>> try:
... w/v
... except TypeError:
... print "Merci d'utiliser des chiffres"
... except ZeroDivisionError:
... print "Merci de ne pas utiliser le 0"
...
Merci de ne pas utiliser le 0
Et dans le cas où la variable v vaut "stic":
>>> v = "stic"
>>> w = 5
>>> try:
... w/v
... except TypeError:
... print "Merci d'utiliser des chiffres"
... except ZeroDivisionError:
... print "Merci de ne pas utiliser le 0"
TS STIC 1 / 2018-2019
...
Merci d'utiliser des chiffres
4.3. Finally
On utilise le mot clé finally pour exécuter des instructions quelque soit les erreurs générées ou
non (et même s’il y a présence d'un return). Dans tous les cas les instructions placées
dans finally seront exécutées.
try:
pass
except:
pass
finally:
print "Execution"
4.4. Compréhension des listes !
Un bon développeur cherchera toujours à augmenter sa productivité avec le temps. Il existe

des astuces python qui permettent d'optimiser le code.
L'idée est simple : simplifier le code pour le rendre plus lisible et donc plus rapide à écrire et
plus simple à maintenir.
Syntaxe
new_list = [function(item) for item in list if condition(item)]
Filtrer une liste

Prenons un exemple d'une liste :
>>> a = [1,4,2,7,1,9,0,3,4,6,6,6,8,3]
Nous voulons filtrer les valeurs de cette liste et ne garder que ceux dont la valeur est supérieure
à5:
>>> b=[]
>>> for x in a:
... if x > 5:
TS STIC 1 / 2018-2019
... b.append(x)
...
>>> b
[7, 9, 6, 6, 6, 8]
Il est possible de faire exactement ce que fait ce bloc de code en une seule ligne :
>>> [x for x in a if x > 5]
[7, 9, 6, 6, 6, 8]
Exécuter une fonction sur chaque item d'une liste

Prenons l'exemple d'une conversion de string en integer de plusieurs items :
>>> items = ["5", "10", "15"]
>>> items = [int(x) for x in items]
>>> print( items)
[5, 10, 15]
TS STIC 1 / 2018-2019
CHAPITRE 4 : La POO en python
TS STIC 1 / 2018-2019
I. Notion de classe et d’objet
1.1. Définition d’une classe
Qu’est-ce qu’un objet ?
Pour faire simple, un objet est une chose.

Il est possible de définir par exemple un objet télévision, voiture, bureau, musique… Un objet
peut donc être vu comme une donnée à manipuler.
Chaque objet est défini par des attributs et des méthodes qui lui sont propres.
Un attribut est une caractéristique de l’objet. Par exemple, un objet voiture peut avoir un
attribut couleur.
Une méthode est une action qui peut être appliquée à un objet. Par exemple, un objet voiture
peut avoir une méthode accélérer.
Qu’est-ce qu’une classe ?
Une classe correspond à un modèle de données. En effet, tous les objets d’une classe partagent
les mêmes attributs et méthodes.
Une classe peut être vue comme une famille d’objets.
Par exemple, tous les objets de la classe voiture ont un attribut couleur et une méthode
accélérer.
Une classe regroupe des fonctions et des attributs qui définissent un objet. On appelle par
ailleurs les fonctions d'une classe des "méthodes".
Qu’est-ce qu’une instance ?
Une instance représente une entité particulière d’une classe.
Par exemple, une voiture rouge peut être une instance de la classe voiture.
1.2. Représentation d’une classe en python
class Voiture :
def __init__(self):
self.nom = "Ferrari"
Notre classe Voiture est une sorte d'usine à créer des voitures.
La méthode __init__() est appelée lors de la création d'un objet.
TS STIC 1 / 2018-2019
self.nom est une manière de stocker une information dans la classe. On parle d'attribut de
classe. Dans notre cas, on stock le nom dans l'attribut nom.
Les attributs de classe
Les attributs de classe permettent de stocker des informations au niveau de la classe.

Elles sont similaires aux variables.
Dans notre exemple :
class Voiture :
def __init__(self):
ma_voiture = Voiture()
print(ma_voiture.nom) #affiche Ferrari
Le nombre d’attribue peut augmenter
class Voiture :
def __init__(self):
self.modele = "250"
Les méthodes
Les méthodes sont des fonctions définies dans une classe.

Créons une nouvelle méthode dans notre classe voiture :
class Voiture :
def __init__(self):
self.modele = "250"
self.nb_roue = 3
def get_modele(self): #pour obtenir le modèle de la voiture

return self.modele
def get_nom(self): #pour modifier le nom de la voiture

return self.nom
def set_nom(self,newNom):
self.nom = newNom
TS STIC 1 / 2018-2019
v = Voiture()
v.set_nom("Mercedesse")
print(v.nom)#affiche Mercedesse
On peut aussi créer notre voiture avec les éléments de base déjà. Et pour cela, il faudrait
modifier légèrement le code précédent comme suit :
class Voiture (objet):

def __init__(self,nom="Ferrari",modele="250",nb_roue=3):
self.nom = nom
self.modele = modele
self.nb_roue = nb_roue
def get_modele(self): #pour obtenir le modèle de la voiture

return self.modele
def get_nom(self): #pour modifier le nom de la voiture

return self.nom
def set_nom(self,newNom):
self.nom = newNom
v = Voiture("Mercedesse","TY45",4)
print(v.get_modele())
II. Les différents concepts de la POO (Programmation Orienté

Objet) en Python
2.1. Le constructeur
Une méthode constructeur a ceci de particulier qu’elle est exécutée automatiquement lorsque
l’on instancie un nouvel objet à partir de la classe. On peut donc y placer tout ce qui semble
nécessaire pour initialiser automatiquement l’objet que l’on crée.
Afin qu’elle soit reconnue comme telle par Python, la méthode constructeur devra
obligatoirement s’appeler __init__ (deux caractères « souligné », le mot init, puis encore deux
caractères « souligné »).
TS STIC 1 / 2018-2019
class Time(object) :
"Encore une nouvelle classe temporelle"
def __init__(self) :
self.heure = 12
self.minute = 0
self.seconde = 0
def affiche_heure(self) :
print("{}:{}:{}".format(self.heure,self.minute,
self.seconde))
2.2. L’héritage
Les classes constituent le principal outil de la programmation orientée objet (Object Oriented
Programming ou OOP), qui est considérée de nos jours comme la technique de programmation
la plus performante. L’un des principaux atouts de ce type de programmation réside dans le
fait que l’on peut toujours se servir d’une classe préexistante pour en créer une nouvelle, qui
héritera toutes ses propriétés mais pourra modifier certaines d’entre elles et/ou y ajouter les
siennes propres. Le procédé s’appelle dérivation. Il permet de créer toute une hiérarchie de
classes allant du général au particulier.
Gardons l'exemple de la voiture et créons une classe VoitureSport:
class Voiture :
roues = 4
moteur = 1
def __init__(self) :
self.nom = "A déterminer"
class VoitureSport(Voiture) :
def __init__(self):
On a indiqué que VoitureSport a hérité de classe Voiture, elle récupère donc toutes ses
méthodes et ses attributs.
On peut toujours instancier la classe Voiture si on le désire :
V = Voiture()
print(v.nom)
rint(v.roues)
TS STIC 1 / 2018-2019
Instancions maintenant la classe VoitureSport :
ma_voiture_sport = VoitureSport()
print(ma_voiture_sport.nom)# affiche "Ferrari"
rint(ma_voiture_sport.nom)# affiche 4
On remarque tout d'abord que l'attribut roues a bien été hérité. Ensuite on remarque que la
méthode __init__ a écrasé la méthode de la classe Voiture. On parle alors de surcharge de
méthode.
2.3. Le polymorphisme / Surcharge de méthode
Comme nous l'avons vu plus haut si une classe hérite d'une autre classe, elle hérite les
méthodes de son parent.
Exemple :
class Voiture:
roues = 4
moteur = 1
def __init__(self):
def allumer(self):
print("La voiture démarre")
class VoitureSport(Voiture):
def __init__(self):
ma_voiture_sport.allumer()
Le résultat :
La voiture démarre
TS STIC 1 / 2018-2019
Il est cependant possible d'écraser la méthode de la classe parente en la redéfinissant. On parle
alors de surcharger une méthode.
class Voiture:
roues = 4
moteur = 1
def __init__(self):
def allumer(self):
def __init__(self):
def allumer(self):
print("La voiture de sport démarre")
Le résultat :
La voiture de sport démarre
Enfin dernier point intéressant : il est possible d'appeler la méthode du parent puis de faire la
spécificité de la méthode. On peut d'ailleurs appeler n'importe quelle autre méthode.
class Voiture:
roues = 4
moteur = 1
TS STIC 1 / 2018-2019
def __init__(self):
def allumer(self):
def __init__(self):
def allumer(self):
Voiture.allumer(self)
Print("La voiture de sport démarre")
Le résultat :
La voiture démarre
La voiture de sport démarre
Les classes Voiture et VoitureSport possèdent donc chacune une méthode de même nom mais
ces méthodes n'effectuent pas les mêmes tâches. On parle dans ce cas de polymorphisme.
class Rectangle(object):
"Classe de rectangles"
def __init__(self, longueur =0, largeur =0):
self.L = longueur
self.l = largeur
self.nom ="rectangle"
def perimetre(self):
return "(%d + %d) * 2 = %d" % (self.L, self.l, (self.L + self.l)*2)
def surface(self):
return "%d * %d = %d" % (self.L, self.l, self.L*self.l)
def mesures(self):
print("Un %s de %d sur %d" % (self.nom, self.L, self.l))
TS STIC 1 / 2018-2019
print("a une surface de %s" % (self.surface(),))
print("et un périmètre de %s\n" % (self.perimetre(),))
class Carre(Rectangle):
"Classe de carrés"
def __init__(self, cote):
Rectangle.__init__(self, cote, cote)
self.nom ="carré"
if __name__ == "__main__":
r1 = Rectangle(15, 30)
r1.mesures()
c1 = Carre(13)
c1.mesures()
Vous pouvez remarquer encore une fois que le constructeur de la classe Carre() doit faire appel
au constructeur de sa classe parente ( Rectangle.__init__(self, ...) ), en lui transmettant la
référence de l’instance (self) comme premier argument.
TS STIC 1 / 2018-2019
CHAPITRE 5 : Les bibliothèques
Mathématiques
TS STIC 1 / 2018-2019
I. La bibliothèque math
La bibliothèque math contient plusieurs fonctions mathématiques dont voici quelques-uns :
1.1. Fonctions arithmétiques et de représentation
Import math
math.ceil(x)
Renvoie la fonction plafond de x, le plus petit entier plus grand ou égal à x. Si x est un flottant,
délègue à x.__ceil()__, qui doit renvoyer une valeur Intégral.
math.copysign(x, y)
Renvoie un flottant contenant la magnitude (valeur absolue) de x mais avec le signe de y. Sur
les plate-formes supportant les zéros signés, copysign(1.0, -0.0) renvoie -1.0.
math.fabs(x)
Renvoie la valeur absolue de x.
math.factorial(x)
Renvoie la factorielle de x. Lève une ValueError si x n’est pas entier ou s’il est négatif.
math.floor(x)
Renvoie le plancher de x, le plus grand entier plus petit ou égal à x. Si x n’est pas un flottant,
délègue à x.__floor()__, qui doit renvoyer une valeur Intégral.
math.fmod(x, y)
Renvoie fmod(x, y), tel que défini par la bibliothèque C de la plate-forme. Notez que l’expression
Python x % y peut ne pas renvoyer le même résultat. Le sens du standard C pour fmod(x, y) est
d’être exactement (mathématiquement, à une précision infinie) égal à x - n*y pour un
entier n tel que le résultat a le signe de x et une magnitude inférieure à abs(y). L’expression
Python x % y renvoie un résultat avec le signe de y, et peut ne pas être calculable exactement
pour des arguments flottants. Par exemple : fmod(-1e-100, 1e100) est -1e-100, mais le résultat
de l’expression Python -1e-100 % 1e100 est 1e100-1e-100, qui ne peut pas être représenté
exactement par un flottant et donc qui est arrondi à 1e100. Pour cette raison, la
fonction fmod() est généralement préférée quand des flottants sont manipulés, alors que
l’expression Python x % y est préféré quand des entiers sont manipulés.
math.frexp(x)
Renvoie la mantisse et l’exposant de x dans un couple (m, e). m est un flottant et e est un entier
tels que x == m * 2**e exactement. Si x vaut zéro, renvoie (0, 0), sinon 0.5 <= abs(m) < 1. Ceci
est utilisé pour « extraire » la représentation interne d’un flottant de manière portable.
math.fsum(iterable)
Renvoie une somme flottante exacte des valeurs dans l’itérable. Évite la perte de précision en
gardant plusieurs sommes partielles intermédiaires :
TS STIC 1 / 2018-2019
>>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
0.9999999999999999
>>> fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
1.0
math.trunc(x)
Renvoie la valeur Real x tronquée en un Integral (habituellement un entier). Délègue
à x.__trunc__().
1.2. Fonctions logarithme et exponentielle
math.exp(x)
Renvoie e élevé à la puissance x, où e = 2.718281… est la base des logarithmes naturels. Cela
est en général plus précis que math.e ** x ou pow(math.e, x).
math.expm1(x)
Renvoie e à la puissance x, moins 1. Ici, e est la base des logarithmes naturels. Pour de petits
flottants x, la soustraction exp(x) - 1 peut résulter en une perte significative de précision; la
fonction expm1() fournit un moyen de calculer cette quantité en précision complète :
>>> from math import exp, expm1
>>> exp(1e-5) - 1 # gives result accurate to 11 places
1.0000050000069649e-05
>>> expm1(1e-5) # result accurate to full precision
1.0000050000166668e-05
Nouveau dans la version 3.2.
math.log(x[, base])
Avec un argument, renvoie le logarithme naturel de x (en base e).
Avec deux arguments, renvoie le logarithme de x en la base donnée, calculé
par log(x)/log(base).
math.log1p(x)
Renvoie le logarithme naturel de 1+x (en base e). Le résultat est calculé par un moyen qui reste
exact pour x proche de zéro.
math.log2(x)
Renvoie le logarithme en base 2 de x. C’est habituellement plus exact que log(x, 2).
math.log10(x)
Renvoie le logarithme de x en base 10. C’est habituellement plus exact que log(x,10).
TS STIC 1 / 2018-2019
math.pow(x, y)
Renvoie x élevé à la puissance y. Les cas exceptionnels suivent l’annexe “F” du standard C99
autant que possible. En particulier, pow(1.0, x) et pow(x, 0.0)renvoient toujours 1.0, même
si x est zéro ou NaN. Si à la fois x et y sont finis, x est négatif et y n’est pas entier,
alors pow(x, y) est non défini et lève une ValueError.
À l’inverse de l’opérateur interne **, la fonction math.pow() convertit ses deux arguments
en float. Utilisez ** ou la primitive pow() pour calculer des puissances exactes d’entiers.
math.sqrt(x)
Renvoie la racine carrée de x.
1.3. Fonctions trigonométriques
math.acos(x)
Renvoie l’arc cosinus de x, en radians.
math.asin(x)
Renvoie l’arc sinus de x, en radians.
math.atan(x)
Renvoie l’arc tangente de x, en radians.
math.atan2(y, x)
Renvoie atan(y / x), en radians. Le résultat est entre -pi et pi. Le vecteur du plan allant de
l’origine vers le point (x, y) forme cet angle avec l’axe X positif. L’intérêt de atan2() est que le
signe des deux entrées est connu. Donc elle peut calculer le bon quadrant pour l’angle. par
exemple atan(1) et atan2(1, 1) donnent tous deux pi/4, mais atan2(-1, -1) donne -3*pi/4.
math.cos(x)
Renvoie le cosinus de x radians.
math.hypot(x, y)
Renvoie la norme euclidienne sqrt(x*x + y*y). C’est la longueur du vecteur allant de l’origine au
point (x, y).
math.sin(x)
Renvoie le sinus de*x* radians.
math.tan(x)
Renvoie la tangente de x radians.
1.4. Conversion angulaire
math.degrees(x)
Convertit l’angle x de radians en degrés.
TS STIC 1 / 2018-2019
math.radians(x)
Convertit l’ange x de degrés en radians.
1.5. Fonctions hyperboliques
Hyperbolic functions sont analogues à des fonctions trigonométriques qui sont basés sur des
hyperboles au lieu de cercles.
math.acosh(x)
Renvoie l’arc cosinus hyperbolique de x.
math.asinh(x)
Renvoie l’arc sinus hyperbolique de x.
math.atanh(x)
Renvoie l’arc tangente hyperbolique de x.
math.cosh(x)
Renvoie le cosinus hyperbolique de x.
math.sinh(x)
Renvoie le sinus hyperbolique de x.
math.tanh(x)
Renvoie la tangente hyperbolique de x.
Fonctions spéciales
math.erf(x)
Renvoie la fonction d’erreur en x.
La fonction erf() peut être utilisée pour calculer des fonctions statistiques usuelles telles qu e
la répartition de la loi normale :
def phi(x):
'Cumulative distribution function for the standard normal distribution'
return (1.0 + erf(x / sqrt(2.0))) / 2.0
1.6. Constantes
math.pi
La constante mathématique π = 3.141592…, à la précision disponible.
math.e
La constante mathématique e = 2.718281…, à la précision disponible.
TS STIC 1 / 2018-2019
math.tau
La constante mathématique τ = 6.283185…, à la précision disponible. Tau est une constante du
cercle égale à 2 *π*, le rapport de la circonférence d’un cercle à son rayon. Pour en apprendre
plus sur Tau, regardez la vidéo de Vi Hart, Pi is (still) Wrong, et profitez-en pour célébrer le Jour
de Tau en bavardant comme deux pies
Source : https://docs.python.org/fr/3/library/math.html
II. Le module random

Le module random permet la génération de nombres aléatoires.
Importation : import random
Pour utiliser les fonctions, on peut faire :
rnd = random.Random()
rnd.choice(['a', 'b', 'c'])

ou alors :
random.choice(['a', 'b', 'c'])
random.seed(2) : pour initialiser le générateur (utile pour avoir des séquences aléatoire
reproductibles).
random.choice(['a', 'b', 'c']) : renvoie un élément au hasard.
random.sample(['a', 'b', 'c', 'd', 'e'], 2) : sample de taille 2, sans remise (donc, la taille ne peut
pas être supérieure à celle de la liste).
l = ['a', 'b', 'c', 'd']

random.shuffle(l) : pour permuter de manière aléatoire une liste (sur place).
Valeurs aléatoires :
random.random() : valeur entre 0 et 1, 1 exclus.
random.randint(0, 3) : entier entre 0 et 3 inclus.
Source : http://www.python-simple.com/python-modules-math/random.php
random.randrange(start, stop[, step])

Return a randomly selected element from range(start, stop, step). This is equivalent
to choice(range(start, stop, step)), but doesn’t actually build a range object.
TS STIC 1 / 2018-2019
random.uniform(a, b)
Return a random floating point number N such
that a <= N <= b for a <= b and b<= N <= a for b < a.
The end-point value b may or may not be included in the range depending on floating-point
rounding in the equation a + (b-a) * random().
Sources : https://docs.python.org/3/library/random.html
III. La bibliothèque mathplotlib
3.1. Définition
Le module Matplotlib est chargé de tracer les courbes :

>>> import matplotlib.pyplot as plt
D’une manière générale les fonctions plt.plot attendent des vecteur/matrice, bref des tableaux
de points du plan. Selon les options, ces points du plan sont reliés entre eux de façon ordonnée
par des segments : le résultat est une courbe.
Commençons par la fonction sinus.
import matplotlib.pyplot as plt

import numpy as np
x=np.linspace(-5,5,100)
plt.plot(x,np.sin(x)) # on utilise la fonction sinus de Numpy
plt.ylabel('fonction sinus')
plt.xlabel("l'axe des abcisses")
plt.show()
TS STIC 1 / 2018-2019
Si tout se passe bien, une fenêtre doit s’ouvrir avec la figure ci-dessus. Il est possible de jouer
avec les menus dans le bas de cette fenêtre : zoomer, déplacer la figure, etc et surtout
sauvegarder dans un format PNG, PDF, EPS, etc.
plt.clf() : efface la fenêtre graphique
plt.savefig()
Sauvegarde le graphique. Par exemple plt.savefig("mongraphe.png") sauve sous le nom
“mongraphe.png” le graphique. Par défaut le format est PNG. Il est possible d’augmenter la
résolution, la couleur de fond, l’orientation, la taille (a0, a1, lettertype, etc) et aussi le format
de l’image. Si aucun format n’est spécifié, le format est celui de l’extension dans
“nomfigure.ext” (où “ext” est “eps”, “png”, “pdf”, “ps” ou “svg”). Il est toujours conseillé de
mettre une extension aux noms de fichier ; si vous y
tenez plt.savefig('toto',format='pdf') sauvegarder l’image sous le nom “toto” (sans extension !)
au format “pdf”.
3.2. Des détails
Pour connaître toutes les options, le mieux est de se référer à la documentation de Matplotlib.
Voyons ici quelques-unes d’entre elles
Bornes : spécifier un rectangle de représentation, ce qui permet un zoom, d’éviter les

grandes valeurs des fonctions par exemple, se fait via la
commande plt.axis([xmin,xmax,ymin,ymax])
Couleur du trait : pour changer la couleur du tracé une lettre g vert (green), r rouge
(red), k noir, b bleu, c cyan, m magenta, y jaune (yellow), wblanc
(white). plt.plot(np.sin(x),'r') tracera notre courbe sinus en rouge. Les amateurs
de gris sont servis via color='(un flottant entre 0 et1)'. Enfin pour avoir encore
plus de couleurs, comme en HTML la séquence color='#eeefff' donnera la couleur
attendu et les amateurs de RGB sont servis par color=( R, G, B) avec trois paramètres
compris entre 0 et 1 (RGBA est possible aussi).
Symboles : mettre des symboles aux points tracés se fait via l’option marker. Les
possibilités sont nombreuses parmi
[ ‘+’ | ‘*’ | ‘,’ | ‘.’ |‘1’ | ‘2’ | ‘3’ | ‘4’ | ‘<’ | ‘>’ | ‘D’ | ‘H’ | ‘^’ | ‘_’ | ‘d’ | ‘h’ | ‘o’ | ‘p’ | ‘s’ | ‘
v’ | ‘x’ | ‘|’ | TICKUP | TICKDOWN | TICKLEFT |TICKRIGHT | ‘None’ | ‘ ‘ | ‘’ ].
Style du trait : pointillés, absences de trait, etc se décident avec linestyle. Au choix '-
' ligne continue, '--' tirets, '-.' points-tirets, ':'pointillés, sachant que 'None', '', ' ' donnent
“rien-du-tout”. Plutôt que linestyle, ls (plus court) fait le même travail.
Épaisseur du trait : linewidth=flottant (comme linewidth=2) donne un trait,

pointillé (tout ce qui est défini par style du trait) d’épaiseur “flottant” en points. Il est
possible d’utiliser lw en lieu et place de linewidth.
Taille des symboles (markers) : markersize=flottant comme pour l’épaisseur du trait.

D’autres paramètres sont modifiables markeredgecolor la couleur du trait du pourtour du
TS STIC 1 / 2018-2019
marker, markerfacecolor la couleur de l’intérieur (si le marker possède un intérieur
comme 'o'), markeredgsize=flottant l’épaisseur du trait du pourtour du marker. Remarquez
que si la couleur n’est pas spécifiée pour chaque nouvel appel la couleur des “markers”
change de façon cyclique.
Étiquettes sur l’axe des abscisses/ordonnées : Matplotlib décide tout seul des graduations
sur les axes. Tout ceci se modifie via plt.xticks(tf), plt.yticks(tl) où tf est un
vecteur de flottants ordonnés de façon croissante.
Ajouter un titre : plt.title("Mon titre")
Légendes : c’est un peu plus compliqué. D’après ce que j’ai compris il faut assigner à des
variables le tracé, via g1=plt.plot(), etc. Enfin plt.legend((g1, g2), ("ligne 2","ligne 1")) fait le
boulot. Par exemple

import numpy as np
x=np.linspace(-5,5,100)
p1=plt.plot(x,np.sin(x),marker='o')
p2=plt.plot(x,np.cos(x),marker='v')
plt.title("Fonctions trigonometriques")#Problemes avec accents
(plot_directive) !
plt.legend([p1, p2], ["Sinus", "Cosinus"])
plt.show()
3.3. Quelques exemples
TS STIC 1 / 2018-2019
Pour superposer plusieurs graphes de fonctions, il est possible de faire une succession de
commandes plt.plot ou encore en une seule commande. Remarquez aussi que pour des
choses simples il est possible de se passer des ls, color et marker.
import numpy as np
t1=np.linspace(0,5,10)
t2=np.linspace(0,5,20)
plt.plot(t1, t1, 'r--', t1, t1**2, 'bs', t2, t2**3, 'g^-')
Enfin un système de sous-figures permet de juxtaposer différents graphiques

import numpy as np
def f(t):
return np.exp(-t) * np.cos(2*np.pi*t)
t1 = np.arange(0.0, 5.0, 0.1)

t2 = np.arange(0.0, 5.0, 0.02)
plt.figure(1)
plt.subplot(221)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')
plt.subplot(222)
plt.plot(t2, np.cos(2*np.pi*t2), 'r--')
plt.subplot(223)
plt.plot(t2, np.sin(2*np.pi*t2), 'b-')
TS STIC 1 / 2018-2019
Dans la commande plt.subplot
l’argument est nbre de lignes, nbre de colonnes, numéro de la figure. Il y a une condition à
respecter : le nombre de lignes multiplié par le nombre de colonnes est supérieur ou égal au
nombre de figure. Ensuite Matplotlib place les figures au fur et à mesure dans le sens des lignes.
Dans le même registre, ouvrir plusieurs fenêtres graphiques est possible. Si vous avez déjà une
fenêtre graphique, la commande plt.figure(2) en ouvre une seconde et les
instructions plt.plot qui suivent s’adresseront à cette seconde figure. Pour revenir et
modifier la première fenêtre graphique, plt.figure(1) suffit.
Pour terminer, un histogramme et un affichage de texte sur le graphique

import numpy as np
mu, sigma = 100, 15

x = mu + sigma * np.random.randn(10000)
# histogramme des donn\'es
n, bins, patches = plt.hist(x, 50, normed=1, facecolor='g', alpha=0.75)
plt.xlabel('Donn\'ees')
plt.ylabel('Probabilite')
plt.title('Histogramme')
plt.text(60, .025, r'$\mu=100,\ \sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
TS STIC 1 / 2018-2019
Source: http://math.mad.free.fr/depot/numpy/courbe.html
TS STIC 1 / 2018-2019
CHAPITRE 6 : La gestion des fichiers
TS STIC 1 / 2018-2019
I. Edition d’un fichier
Une manière de stocker des données de manière pérenne est de les stocker dans des fichiers.
1.1. Editer un fichier
Pour éditer un fichier en python on utilise la fonction open.

Cette fonction prend en premier paramètre le chemin du fichier (relatif ou absolu) et en second
paramètre le type d'ouverture.
Chemin relatif / chemin absolu

Un chemin relatif en informatique est un chemin qui prend en compte l'emplacement de
lecture.
Un chemin absolu est un chemin complet qui peut être lu quel que soit l'emplacement de
lecture.
1.2. La fonction open
Voici la syntaxe pour lire un fichier : open("chemin absolu du fichier", "type d’ouverture")
>>> fichier = open("data.txt", "r")
>>> print(fichier)
<open file 'data.txt', mode 'r' at 0x7ff6cf3fe4b0>
On remarque que le deuxième paramètre est renseigné par un r, ce paramètre indique

une ouverture de fichier en lecture.
1.3. Les types d'ouverture
Il existe plusieurs modes d'ouverture :
r, pour une ouverture en lecture (READ).
w, pour une ouverture en écriture (WRITE), à chaque ouverture le contenu du fichier

est écrasé. Si le fichier n'existe pas python le crée.
a, pour une ouverture en mode ajout à la fin du fichier (APPEND). Si le fichier n'e
xiste pas python le crée.
b, pour une ouverture en mode binaire.
t, pour une ouverture en mode texte.
x, crée un nouveau fichier et l'ouvre pour écriture
TS STIC 1 / 2018-2019
1.4. Fermeture d'un fichier
Comme tout élément ouvert, il faut le refermer une fois les instructions terminées. Pour cela
on utilise la méthode close().
>>> fichier.close()
1.5. Lire le contenu d'un fichier
Pour afficher tout le contenu d'un fichier, vous pouvez utiliser la méthode read sur l'objet-
fichier.
fichier = open("data.txt", "r")
print(fichier.read())
fichier.close()
1.6. Ecrire dans un fichier
Voici la syntaxe pour écrire dans un fichier :
fichier = open("data.txt", "a")
fichier.write("Bonjour monde")
fichier.close()
A noter que pour le monde d'ouverture a, si vous voulez écrire à la ligne, vous pouvez utiliser le
saut de ligne \n:
fichier = open("data.txt", "a")
fichier.write("\nBonjour monde")
fichier.close()
1.7. Le mot clé with
Il existe une autre syntaxe plus courte qui permet de s'émanciper du problème de fermeture
du fichier : le mot clé with.
Voici la syntaxe :
with open("data.txt", "r") as fichier:
print(fichier.read())
TS STIC 1 / 2018-2019
II. Application
2.1. Concernant le répertoire
>>> from os import chdir

>>> chdir("/home/jules/exercices")
chdir = change directory quand le chemin existe
>>> from os import getcwd

>>> rep_cour = getcwd()
>>> print(rep_cour)
D:\WinPython-64bit-3.6.3.0Qt5\settings\code kpo
2.2. Application 1
Ecrire une fonction copieFichier qui permet de copier le contenu d’un fichier source dans
le un fichier destinataire. copieFichier(fsource, fdestination)
def copieFichier(fsource, fdestination):

"copie intégrale d'un fichier"
fs = open(fsource, 'r')
fd = open(fdestination, 'w')
while 1:
txt = fs.read(50)
if txt =="":
break
fd.write(txt)
fs.close()
fd.close()
return None
Tester sur le fichier discours.txt
2.3. Application 2
Le script qui suit vous montre comment créer une fonction destinée à effectuer un certain
traitement sur un fichier texte. En l’occurrence, il s’agit ici de recopier un fichier texte, en
omettant toutes les lignes qui commencent par un caractère ’#’. Ecrivez cette fonction.
NB : au niveau de la méthode read() on peut également utiliser readline() est une

méthode qui renvoie une chaîne de caractères, alors que la méthode readlines() renvoie
une liste. À la fin du fichier, readline() renvoie une chaîne vide, tandis que readlines()
renvoie une liste vide.
TS STIC 1 / 2018-2019
def filtre(source,destination):
"recopier un fichier en éliminant les lignes de remarques"
fs = open(source, 'r')
fd = open(destination, 'w')
while 1:
txt = fs.readline()
if txt =='':
break
if txt[0] != '#':
fd.write(txt)
fs.close()
fd.close()
return
Tester sur le fichier electionPr2018.txt
2.4. Les exceptions
Considérons par exemple un script qui demande à l’utilisateur d’entrer un nom de fichier, lequel
fichier étant destiné à être ouvert en lecture. Si le fichier n’existe pas, nous ne voulons
pas que le programme se « plante ». Nous voulons qu’un avertissement soit affiché, et
éventuellement que l’utilisateur puisse essayer d’entrer un autre nom.
filename = input("Veuillez entrer un nom de fichier : ")

try:
f = open(filename, "r")
except:
print("Le fichier", filename, "est introuvable")
Si nous estimons que ce genre de test est susceptible de rendre service à plusieurs endroits
d’un programme, nous pouvons aussi l’inclure dans une fonction :
def existe(fname):
try:
f = open(fname,'r')
f.close()
return 1
except:
return 0
filename = input("Veuillez entrer le nom du fichier : ")

if existe(filename):
print("Ce fichier existe bel et bien.")
else:
print("Le fichier", filename, "est introuvable.")
TS STIC 1 / 2018-2019
2.5. Application 3
Écrivez un script qui permette de créer et de relire aisément un fichier texte. Votre
programme demandera d’abord à l’utilisateur d’entrer le nom du fichier. Ensuite il lui
proposera le choix, soit d’enregistrer de nouvelles lignes de texte, soit d’afficher le
contenu du fichier. L’utilisateur devra pouvoir entrer ses lignes de texte successives en utilisant
simplement la touche <Enter> pour les séparer les unes des autres. Pour terminer les entrées,
il lui suffira d’entrer une ligne vide (c’est-à-dire utiliser la touche <Enter> seule). L’affichage du
contenu devra montrer les lignes du fichier séparées les unes des autres de la manière la plus
naturelle (les codes de fin de ligne ne doivent pas apparaître)
def sansDC(ch):
"cette fonction renvoie la chaîne ch amputée de son dernier caractère"
nouv = ""
i, j = 0, len(ch) -1
while i < j:
nouv = nouv + ch[i]
i = i + 1
return nouv
def ecrireDansFichier():
of = open(nomF, 'a')
while 1:
ligne = input("entrez une ligne de texte (ou <Enter>) : ")
if ligne == '':
break
else:
of.write(ligne + '\n')
of.close()
def lireDansFichier():
of = open(nomF, 'r')
while 1:
ligne = of.readline()
if ligne == "":
break
# afficher en omettant le dernier caractère (= fin de ligne) :
print(sansDC(ligne))
of.close()
nomF = input('Nom du fichier à traiter : ')

choix = input('Entrez "e" pour écrire, "c" pour consulter les données : ')
if choix =='e':
ecrireDansFichier()
else:
lireDansFichier()
TS STIC 1 / 2018-2019
CHAPITRE 7 : La bibliothèque graphique
tkinter
TS STIC 1 / 2018-2019
I. Présentation de tkinter
Si vous ne le saviez pas encore, apprenez dès à présent que le domaine des interfaces
graphiques (ou GUI : Graphical User Interfaces) est extrêmement complexe. Chaque système
d’exploitation peut en effet proposer plusieurs « bibliothèques » de fonctions graphiques de
base, auxquelles viennent fréquemment s’ajouter de nombreux compléments, plus ou moins
spécifiques de langages de programmation particuliers. Tous ces composants sont
généralement présentés comme des classes d’objets, dont il vous faudra étudier les attributs
et les méthodes.
Avec Python, la bibliothèque graphique la plus utilisée jusqu’à présent est la bibliothèque
tkinter, qui est une adaptation de la bibliothèque Tk développée à l’origine pour le langage
Tcl. Plusieurs autres bibliothèques graphiques fort intéressantes ont été proposées pour Python
: wxPython, pyQT, pyGTK, etc. Il existe également des possibilités d’utiliser les bibliothèques de
widgets Java et les MFC de Windows. Dans le cadre de ces notes, nous nous limiterons
cependant à tkinter, dont il existe fort heureusement des versions similaires (et gratuites) pour
les platesformes Linux, Windows et Mac OS.
II. Création d’une fenêtre avec tkinter
Construisons notre première fenêtre en python avec la bibliothèque « tkinter ».
from tkinter import*
fenetre = Tk()
texte1 = Label(fenetre, text = "Bonjour la STIC 1", fg = "blue")
texte1.pack()
bouton1 = Button(fenetre, text = "Quiter", command = fenetre.destroy)
bouton1.pack()
fenetre.mainloop()
Considérons cette application suivante :
# Petit exercice utilisant la bibliothèque graphique tkinter

from tkinter import *
from random import randrange
# --- définition des fonctions gestionnaires d'événements : ---
def drawline():
"Tracé d'une ligne dans le canevas can1"
global x1, y1, x2, y2, coul
can1.create_line(x1,y1,x2,y2,width=2,fill=coul)
# modification des coordonnées pour la ligne suivante :
y2, y1 = y2+10, y1-10
TS STIC 1 / 2018-2019
def changecolor():
"Changement aléatoire de la couleur du tracé"
global coul
pal=['purple','cyan','maroon','green','red','blue','orange','yellow']
c = randrange(8) # => génère un nombre aléatoire de 0 à 7
coul = pal[c]
IV. Les composants visuels ou widgets
#------ Programme principal -------
V. Les évènements
# les variables suivantes seront utilisées de manière globale :
x1, y1, x2, y2 = 10, 190, 190, 10 # coordonnées de la ligne
coul = 'dark green' # couleur de la ligne
# Création du widget principal ("maître") :
fen1 = Tk()
# création des widgets "esclaves" :
can1 = Canvas(fen1,bg='dark grey',height=200,width=200)
can1.pack(side=LEFT)
bou1 = Button(fen1,text='Quitter',command=fen1.quit)
bou1.pack(side=BOTTOM)
bou2 = Button(fen1,text='Tracer une ligne',command=drawline)
bou2.pack()
bou3 = Button(fen1,text='Autre couleur',command=changecolor)
bou3.pack()
fen1.mainloop() # démarrage du réceptionnaire d’événements
fen1.destroy() # destruction (fermeture) de la fenêtre
TP 2
1. Comment faut-il modifier le programme pour ne plus avoir
que des lignes de couleur cyan, maroon et green ?
2. Comment modifier le programme pour que toutes les

lignes tracées soient horizontales et parallèles ?
3. Agrandissez le canevas de manière à lui donner une largeur de 500 unités et une hauteur
de 650. Modifiez également la taille des lignes, afin que leurs extrémités se
confondent avec les bords du canevas.
4. Ajoutez une fonction drawline2 qui tracera deux lignes rouges en croix au centre du
canevas : l’une horizontale et l’autre verticale. Ajoutez également un bouton portant
l’indication « viseur ». Un clic sur ce bouton devra provoquer l’affichage de la croix.
5. Reprenez le programme initial. Remplacez la méthode create_line par create_rectangle.

Que se passe-t-il ? De la même façon, essayez aussi create_arc, create_oval, et
create_polygon. Pour chacune de ces méthodes, notez ce qu’indiquent les coordonnées
fournies en paramètres. (Remarque : pour le polygone, il est nécessaire de modifier
légèrement le programme !)
TS STIC 1 / 2018-2019
Petite calculatrice scientifique
Bien que très court, le petit script ci-dessous implémente une calculatrice complète, avec
laquelle vous pourrez même effectuer des calculs comportant des parenthèses et des fonctions
scientifiques. N’y voyez rien d’extraordinaire. Toute cette fonctionnalité n’est qu’une
conséquence du fait que vous utilisez un interpréteur plutôt qu’un compilateur pour exécuter
vos programmes.
# Exercice utilisant la bibliothèque graphique tkinter et le module math

from math import *
# définition de l'action à effectuer si l'utilisateur actionne
# la touche "enter" alors qu'il édite le champ d'entrée :
def evaluer(event):
chaine.configure(text = "Résultat = " + str(eval(entree.get())))
# ----- Programme principal : -----

fenetre = Tk()
entree = Entry(fenetre)
entree.bind("<Return>", evaluer)
chaine = Label(fenetre)
entree.pack()
chaine.pack()
fenetre.mainloop()
TP 3 :
1. Modifier le programme afin qu’il prenne en compte le cas où
l’utilisateur entre une donnée erronée. Exemple : p/8. Dans ce cas
le programme ne doit pas présenter un bug ni rien du tout.
2. Ajouter des boutons à cette application afin qu’elle ressemble à
cette image :
III. Les classes de widgets tkinter

Il existe 15 classes de base pour les widgets tkinter :
Widget Description
Button Un bouton classique, à utiliser pour provoquer l’exécution d’une commande
quelconque.
Un espace pour disposer divers éléments graphiques. Ce widget peut être
Canvas utilisé pour dessiner, créer des éditeurs graphiques, et aussi pour
implémenter des widgets personnalisés.
TS STIC 1 / 2018-2019
Une case à cocher qui peut prendre deux états distincts (la case est cochée
Checkbutton ou
non). Un clic sur ce widget provoque le changement d’état.
Un champ d’entrée, dans lequel l’utilisateur du programme pourra insérer un
Entry texte quelconque à partir du clavier.
Une surface rectangulaire dans la fenêtre, où l’on peut disposer d’autres
Frame widgets. Cette surface peut être colorée. Elle peut aussi être décorée d’une
bordure.
Label Un texte (ou libellé) quelconque (éventuellement une image).
Une liste de choix proposés à l’utilisateur, généralement présentés dans une
Listbox sorte de boîte. On peut également configurer la Listbox de telle manière
qu’elle se comporte comme une série de « boutons radio » ou de cases à
cocher.
Menu Un menu. Ce peut être un menu déroulant attaché à la barre de titre, ou bien
un menu « pop up » apparaissant n’importe où à la suite d’un clic.
Menubutton Un bouton-menu, à utiliser pour implémenter des menus déroulants.
Permet d’afficher un texte. Ce widget est une variante du widget Label, qui
Message permet d’adapter automatiquement le texte affiché à une certaine taille ou à
un certain rapport largeur/hauteur.
Représente (par un point noir dans un petit cercle) une des valeurs d’une
Radiobutton variable qui peut en posséder plusieurs. Cliquer sur un bouton radio donne la
valeur correspondante à la variable, et « vide » tous les autres boutons radio
associés à la même variable.
Vous permet de faire varier de manière très visuelle la valeur d’une variable,
Scale en déplaçant un curseur le long d’une règle
Ascenseur ou barre de défilement que vous pouvez utiliser en association
Scrollbar avec
les autres widgets : Canvas, Entry, Listbox, Text.
Text Affichage de texte formaté. Permet aussi à l’utilisateur d’éditer le texte
affiché. Des images peuvent également être insérées.
Toplevel Une fenêtre affichée séparément, au premier plan.
IV. Animation automatique – Récursivité

Pour conclure cette première prise de contact avec
l’interface graphique tkinter, voici un dernier exemple
d’animation, qui fonctionne cette fois de manière
autonome dès qu’on l’a mise en marche.
TS STIC 1 / 2018-2019
# -*- coding: utf-8 -*-
"""
Created on Sun Nov 25 01:39:11 2018
@author: KPO LOUA ♥

"""

# définition des gestionnaires
# d'événements :
def move():
"déplacement de la balle"
global x1, y1, dx, dy, flag
x1, y1 = x1 +dx, y1 + dy
if x1 >210:
x1, dx, dy = 210, 0, 15
if y1 >210:
y1, dx, dy = 210, -15, 0
if x1 <10:
x1, dx, dy = 10, 0, -15
if y1 <10:
y1, dx, dy = 10, 15, 0
can1.coords(oval1,x1,y1,x1+30,y1+30)
if flag >0:
fen1.after(50,move) # => boucler, après 50 millisecondes
def stop_it():
"arrêt de l'animation"
global flag
flag =0
def start_it():
"démarrage de l'animation"
global flag
if flag ==0: # pour ne lancer qu’une seule boucle
flag =1
move()
#========== Programme principal =============
# les variables suivantes seront utilisées de manière globale :

x1, y1 = 10, 10 # coordonnées initiales
dx, dy = 15, 0 # 'pas' du déplacement
flag =0 # commutateur
# Création du widget principal ("parent") :

fen1 = Tk()
fen1.title("Exercice d'animation avec tkinter")
# création des widgets "enfants" :

can1 = Canvas(fen1,bg='dark grey',height=250, width=250)
can1.pack(side=LEFT, padx =5, pady =5)
oval1 = can1.create_oval(x1, y1, x1+30, y1+30, width=2, fill='red')
bou1 = Button(fen1,text='Quitter', width =8, command=fen1.quit)
bou2 = Button(fen1, text='Démarrer', width =8, command=start_it)
bou2.pack()
TS STIC 1 /text='Arrêter',
bou3 = Button(fen1, 2018-2019 width =8, command=stop_it)
bou3.pack()
bou1 = Button(fen1,text='Quitter', width =8, command=fen1.quit)
bou2 = Button(fen1, text='Démarrer', width =8, command=start_it)
bou2.pack()
bou3 = Button(fen1, text='Arrêter', width =8, command=stop_it)
bou3.pack()
# démarrage du réceptionnaire d'événements (boucle principale) :
fen1.mainloop()
TP 4
1. Dans la fonction start_it(), supprimez l’instruction if flag == 0: (et l’indentation

des deux lignes suivantes). Que se passe-t-il ? (Cliquez plusieurs fois sur le bouton «
Démarrer ».) Tâchez d’exprimer le plus clairement possible votre explication des faits
observés
2. Modifiez le programme de telle façon que la balle change de couleur à chaque « virage
».
3. Modifiez le programme de telle façon que la balle effectue des mouvements obliques
comme une bille de billard qui rebondit sur les bandes (« en zig-zag »).
4. Modifiez le programme de manière à obtenir d’autres mouvements. Tâchez par

exemple d’obtenir un mouvement circulaire (comme dans les exercices de la page 107).
5. À partir des scripts précédents, vous pouvez à présent écrire un programme de jeu
fonctionnant de la manière suivante : une balle se déplace au hasard sur un canevas, à
vitesse faible. Le joueur doit essayer de cliquer sur cette balle à l’aide de la souris. S’il y
arrive, il gagne un point, mais la balle se déplace désormais un peu plus vite, et ainsi de
suite. Arrêter le jeu après un certain nombre de clics et afficher le score atteint.
V. POO avec les interfaces graphiques
5.1. Cahier des charges de notre programme
Notre application doit faire apparaître une fenêtre comportant un dessin de la résistance, ainsi
qu’un champ d’entrée dans lequel l’utilisateur peut encoder une valeur numérique. Un bouton
« Montrer » déclenche la modification du dessin de la résistance, de telle façon que les trois
bandes de couleur se mettent en accord avec la valeur numérique introduite. Contrainte : Le
programme doit accepter toute entrée numérique fournie sous forme entière ou réelle, dans
les limites de 10 à 1011 Ω. Par exemple, une valeur telle que 4.78e6 doit être acceptée et
arrondie correctement, c’est-à-dire convertie en 4800000 Ω
TS STIC 1 / 2018-2019
5.2. Mise en œuvre concrète
Nous construisons le corps de cette application simple sous la forme d’une classe. Nous voulons
vous montrer ainsi comment une classe peut servir d’espace de noms commun, dans lequel
vous pouvez encapsuler vos variables et nos fonctions. Le principal intérêt de procéder ainsi
est que cela vous permet de vous passer de variables globales. En effet :
➢ Mettre en route l’application se résumera à instancier un objet de cette classe.
➢ Les fonctions que l’on voudra y mettre en œuvre seront les méthodes de cet objet-
application.
➢ À l’intérieur de ces méthodes, il suffira de rattacher un nom de variable au paramètre
self pour que cette variable soit accessible de partout à l’intérieur de l’objet. Une telle
variable d’instance est donc tout à fait l’équivalent d’une variable globale (mais
seulement à l’inté- rieur de l’objet), puisque toutes les autres méthodes de cet objet
peuvent y accéder par l’intermédiaire de self.
class Application(object):
def __init__(self):
"""Constructeur de la fenêtre principale"""
self.root =Tk()
self.root.title('Code des couleurs')
self.dessineResistance()
Label(self.root, text ="Entrez la valeur de la résistance, en ohms :").\
grid(row =2, column =1, columnspan =3)
Button(self.root, text ='Montrer', command =self.changeCouleurs).\
grid(row =3, column =1)
Button(self.root, text ='Quitter', command =self.root.quit).\
grid(row =3, column =3)
self.entree = Entry(self.root, width =14)
self.entree.grid(row =3, column =2)
# Code des couleurs pour les valeurs de zéro à neuf :
self.cc = ['black','brown','red','orange','yellow',\
'green','blue','purple','grey','white']
self.root.mainloop()
TS STIC 1 / 2018-2019
def dessineResistance(self):
"""Canevas avec un modèle de résistance à trois lignes colorées"""
self.can = Canvas(self.root, width=250, height =100, bg ='ivory')
self.can.grid(row =1, column =1, columnspan =3, pady =5, padx =5)
self.can.create_line(10, 50, 240, 50, width =5) # fils
self.can.create_rectangle(65, 30, 185, 70, fill ='light grey', width =2)
# Dessin des trois lignes colorées (noires au départ) :
self.ligne =[] # on mémorisera les trois lignes dans 1 liste
for x in range(85,150,24):
self.ligne.append(self.can.\
create_rectangle(x,30,x+12,70,fill='black',width=0))
def changeCouleurs(self):
"""Affichage des couleurs correspondant à la valeur entrée"""
self.v1ch = self.entree.get() # cette méthode renvoie une chaîne
try:
v = float(self.v1ch) # conversion en valeur numérique
except:
err =1 # erreur : entrée non numérique
else:
err =0
if err ==1 or v < 10 or v > 1e11 :
self.signaleErreur() # entrée incorrecte ou hors limites
else:
li =[0]*3 # liste des 3 codes à afficher
logv = int(log10(v)) # partie entière du logarithme
ordgr = 10**logv # ordre de grandeur
# extraction du premier chiffre significatif :
li[0] = int(v/ordgr) # partie entière
decim = v/ordgr - li[0] # partie décimale
# extraction du second chiffre significatif :
li[1] = int(decim*10 +.5) # +.5 pour arrondir correctement
# nombre de zéros à accoler aux 2 chiffres significatifs :
li[2] = logv -1
# Coloration des 3 lignes :
for n in range(3):
self.can.itemconfigure(self.ligne[n], fill =self.cc[li[n]])
def signaleErreur(self):
self.entree.configure(bg ='red') # colorer le fond du champ
self.root.after(1000, self.videEntree) # après 1 seconde, effacer
def videEntree(self):
self.entree.configure(bg ='white') # rétablir le fond blanc
self.entree.delete(0, len(self.v1ch)) # enlever les car. présents
# Programme principal :
if __name__ == '__main__':
from math import log10 # logarithmes en base 10
f = Application() # instanciation de l'objet application
TS STIC 1 / 2018-2019
5.3. Commentaires
Ligne 1 : La classe est définie comme une nouvelle classe indépendante (elle ne dérive
d’aucune classe parente préexistante, mais seulement de object, « ancêtre » de toutes les
classes).
Lignes 2 à 14 : Le constructeur de la classe instancie les widgets nécessaires : espace

graphique, libellés et boutons. Afin d’améliorer la lisibilité du programme, cependant, nous
avons placé l’instanciation du canevas (avec le dessin de la résistance) dans une méthode
distincte : dessineResistance(). Veuillez remarquer aussi que pour obtenir un code plus
compact, nous ne mémorisons pas les boutons et le libellé dans des variables (comme cela
a été expliqué à la page 102), parce que nous ne souhaitons pas y faire référence ailleurs
dans le programme. Le positionnement des widgets dans la fenêtre utilise la méthode grid()
décrite à la page 99.
Lignes 15-17 : Le code des couleurs est mémorisé dans une simple liste.
Ligne 18 : La dernière instruction du constructeur démarre l’application. Si vous préférez

démarrer l’application indépendamment de sa création, vous devez supprimer cette ligne,
et reporter l’appel à mainloop() au niveau principal du programme, en ajoutant une
instruction : f.root.mainloop() à la ligne 71.
Lignes 20 à 30 : Le dessin de la résistance se compose d’une ligne et d’un premier rectangle

gris clair, pour le corps de la résistance et ses deux fils. Trois autres rectangles figureront les
bandes colorées que le programme devra modifier en fonction des entrées de l’utilisateur.
Ces bandes sont noires au départ ; elles sont référencées dans la liste self.ligne.
Lignes 32 à 53 : Ces lignes contiennent l’essentiel de la fonctionnalité du programme.

L’entrée brute fournie par l’utilisateur est acceptée sous la forme d’une chaîne de
caractères.
À la ligne 36, on essaie de convertir cette chaîne en une valeur numérique de type float. Si
la conversion échoue, on mémorise l’erreur. Si l’on dispose bien d’une valeur numérique,
on vérifie ensuite qu’elle se situe effectivement dans l’intervalle autorisé (de 10 Ω à 1011
Ω). Si une erreur est détectée, on signale à l’utilisateur que son entrée est incorrecte en
colorant de rouge le fond du champ d’entrée, qui est ensuite vidé de son contenu (lignes 55
à 61).
Lignes 45-46 : Les mathématiques viennent à notre secours pour extraire de la valeur
numérique son ordre de grandeur (c’est-à-dire l’exposant de 10 le plus proche). Veuillez
consulter un ouvrage de mathématiques pour de plus amples explications concernant les
logarithmes.
Lignes 47-48 : Une fois connu l’ordre de grandeur, il devient relativement facile d’extraire
du nombre traité ses deux premiers chiffres significatifs. Exemple : supposons que la valeur
entrée soit 31687. Le logarithme de ce nombre est 4,50088... dont la partie entière (4) nous
donne l’ordre de grandeur de la valeur entrée (soit 104). Pour extraire de celle-ci son
TS STIC 1 / 2018-2019
premier chiffre significatif, il suffit de la diviser par 104, soit 10000, et de conserver
seulement la partie entière du résultat (3).
Lignes 49 à 51 : Le résultat de la division effectuée dans le paragraphe précédent est

3,1687. Nous récupérons la partie décimale de ce nombre à la ligne 49, soit 0,1687 dans
notre exemple. Si nous le multiplions par dix, ce nouveau résultat comporte une partie
entière qui n’est rien d’autre que notre second chiffre significatif (1 dans notre exemple).
Nous pourrions facilement extraire ce dernier chiffre, mais puisque c’est le dernier, nous
souhaitons encore qu’il soit correctement arrondi. Pour ce faire, il suffit d’ajouter une
demi-unité au produit de la multiplication par dix, avant d’en extraire la valeur entière. Dans
notre exemple, en effet, ce calcul donnera donc 1,687 + 0,5 = 2,187 , dont la partie entière
(2) est bien la valeur arrondie recherchée.
Ligne 53 : Le nombre de zéros à accoler aux deux chiffres significatifs correspond au calcul
de l’ordre de grandeur. Il suffit de retirer une unité au logarithme.
Ligne 56 : Pour attribuer une nouvelle couleur à un objet déjà dessiné dans un canevas, on
utilise la méthode itemconfigure(). Nous utilisons donc cette méthode pour modifier
l’option fill de chacune des bandes colorées, en utilisant les noms de couleur extraits de la
liste self.cc grâce à aux trois indices li[1], li[2] et li[3] qui contiennent les 3 chiffres
correspondants.
TP 5
1. Modifiez le script ci-dessus de telle manière que le fond d’image devienne bleu clair
(light blue), que le corps de la résistance devienne beige (beige), que le fil de cette
résistance soit plus fin, et que les bandes colorées indiquant la valeur soient plus larges.
2. Modifiez le script ci-dessus de telle manière que l’image dessinée soit deux fois plus
grande.
3. Modifiez le script ci-dessus de telle manière qu’il devienne possible d’entrer aussi des
valeurs de résistances comprises entre 1 et 10 Ω. Pour ces valeurs, le premier anneau
coloré devra rester noir, les deux autres indiqueront la valeur en Ω et dixièmes d’ Ω.
4. Modifiez le script ci-dessus de telle façon que le bouton « Montrer » ne soit plus
nécessaire. Dans votre script modifié, il suffira de frapper <Enter> après avoir entré la
valeur de la résistance, pour que l’affichage s’active.
5. Modifiez le script ci-dessus de telle manière que les trois bandes colorées redeviennent
noires dans les cas où l’utilisateur fournit une entrée inacceptable.
Source : « apprendre à programmer avec Python3 » Gérard Swinnen
TS STIC 1 / 2018-2019

Python3 TS STIC

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Python3 TS STIC

Transféré par

Droits d'auteur :

Formats disponibles

Cours de

Enseignant vacataire en informatique à l’INP-HB

Et qui me rend capable de tout,

Mon bien-aimé Père !

▪ Savoir écrire des programmes en python

Compétences spécifiques visées par l’EC :

▪ Savoir écrire des programmes simples en python

II. Les avantages de python

3.1. Installation de python

1. Pour installer python, rendez-vous sur le site suivant :

2. Lancer l’exécutable ainsi téléchargé et suivez les instructions d’installation.

3.2. Les environnements de développement intégré (IDE)

Un environnement de développement intégré est un outil qui va vous faciliter la

IV. Fonctionnement de python

II. Quelques notions

IV. Premier programme

>>> nom = "KPO LOUA"

V. Les types de base en python

5.1. Les entiers (integer)

5.2. Les nombres flottants ou réel (float)

5.3. Les chaînes de caractères (les string)

5.4. Les listes

>>> liste = list()

Ajout des éléments à mon ma liste :

Afficher un item d'une liste

>>> liste = ["a","d","m"]

>>> liste = ["a","d","m"]

>>> liste[2] = "z"

['a', 'd', 'z']

Supprimer une entrée avec un index

>>> liste = ["a", "b", "c"]

>>> del liste[1]

Supprimer une entrée avec sa valeur

>>> liste = ["a", "b", "c"]

Compter le nombre d'items d'une liste

>>> liste = [1,2,3,5,10]

Compter le nombre d'occurrences d'une valeur

>>> liste = ["a","a","a","b","c","c"]

Trouver l'index d'une valeur

>>> liste = ["a","a","a","b","c","c"]

Manipuler une liste

>>> liste = [1, 10, 100, 250, 500]

>>> liste[-1] # Cherche la dernière occurence

>>> liste[-4:] # Affiche les 4 dernières occurrences

[500, 250, 100, 10]

>>> liste[:] # Affiche toutes les occurences

[1, 10, 100, 250, 500]

>>> liste[2:4] = [69, 70]

[1, 10, 69, 70, 500]

>>> liste[:] = [] # vide la liste

Transformer un string en liste

>>> ma_chaine = "Olivier:ENGEL:Strasbourg"

['Olivier', 'ENGEL', 'Strasbourg']

>>> liste = ["Olivier","ENGEL","Strasbourg"]

Trouver un item dans une liste

>>> liste = [1,2,3,5,10]

5.5. Les tuples

Un tuple est une liste qui ne peut plus être modifiée.

Ajouter une valeur à un tuple

>>> mon_tuple = (1, "ok", "olivier")

>>> mon_tuple = ("ok",)

Afficher une valeur d'un tuple

Et évidemment si on essaie de changer la valeur d'un index, l'interpréteur nous insulte

>>> mon_tuple[1] = "ok"