Ce cours/TP va vous permettre de vous initier à la programmation en utilisant le langage Python.

Ses caractéristiques le rendent très pratique non seulement pour l’enseignement de la programmation informatique mais également dans le cadre de travaux de recherches (ex.: analyse de données, visualisation de courbes…). Sa modularité et les nombreuses bibliothèques existantes en font un des langages de programmation les plus utilisés.

1. Introduction

Avant de nous intéresser au langage Python proprement dit, nous allons commencer par des généralités sur la programmation.

1.1. Qu’est-ce que la programmation ?

La programmation consiste à élaborer une suite d’instructions à faire exécuter par un ordinateur qui est une machine dédiée au traitement de l’information.

Cette suite d’instructions est déterminée par un algorithme et est contenue dans une entité appelée programme.

Un algorithme représente d’une manière plus ou moins précise la procédure à suivre pour obtenir un résultat à partir d’un ensemble d’informations pour répondre à une problématique.

Un être humain va construire un algorithme sous une forme qui lui parait naturelle en utilisant par exemple des phrases simples présentées de la manière la plus claire qui soit.

On peut ainsi assimiler un algorithme à une recette de cuisine qui présente de manière synthétique la suite d’opérations à effectuer pour préparer un plat à partir d’ingrédients.

Cependant, cet algorithme n’est pas directement compréhensible par l’ordinateur.

On va donc devoir traduire l’algorithme dans un langage qui lui est adapté.

L’ordinateur étant finalement qu’un assemblage de composants électroniques appelés transistors, dont le rôle est de laisser passer ou non un courant électrique à la manière d’un interrupteur, les instructions qu’il reconnait sont "rudimentaires".

L’ensemble des ces instructions "rudimentaires" constitue le seul et unique langage compris par un ordinateur (où plus précisément par le microprocesseur qui constitue le cerveau de l’ordinateur): c’est le langage machine.

Traduire un algorithme en langage machine est certes possible mais très, très pénible !

Pour se faire comprendre de l’ordinateur de manière plus aisée, une multitude de langages intermédiaires entre le langage humain et le langage machine ont été créés. Celui de ce cours s’appelle donc Python mais il en existe d’autres comme C/C++, Java, C#, Perl, PHP, Ruby, Fortran Cobol, Basic, Smalltalk…

L’utilisation de ce langage intermédiaire apporte un confort indéniable mais nécessite forcément une étape supplémentaire de traduction :

  • La 1ière traduction est réalisée par l’être humain pour traduire son algorithme dans le langage intermédiaire.

  • La 2ième traduction consiste à passer du langage intermédiaire au langage machine.

Cependant, comme le langage intermédiaire est très structuré, la 2ième étape de traduction peut s’opérer de manière automatique en recourant à un programme qui porte un nom différent selon le langage choisi : interpréteur ou compilateur.

Finalement, la procédure pour faire exécuter un traitement à un ordinateur est toujours la suivante :

  1. Élaborer un algorithme

  2. Traduire l’algorithme dans le langage «intermédiaire» de son choix (Python dans ce cours).
    Le résultat de cette traduction correspond à ce que l’on appelle le code source

  3. Entrer le code source dans l’ordinateur

  4. Lancer le processus de traduction en langage machine

  5. Faire exécuter par l’ordinateur le programme obtenu

Les 2 dernières étapes s’enchaînent automatiquement avec Python lorsqu’on exécute le programme. L’utilisateur a donc l’impression qu’elles n’en forment qu’une mais les deux étapes sont bel et bien effectuées.

1.2. Constitution d’un programme

Comme il a été expliqué plus haut, un programme est une suite d’instructions.

Ces instructions peuvent être de différents types. Par exemple, les langages informatiques proposent tous des instructions de :

  • calcul (Ex. : Additionner 3 et 2)

  • test (Ex. : SI <condition remplie> ALORS <suite d’instructions> )

  • répétition (Ex. : REPETER <suite d’instructions> TANT QUE <condition remplie>)

Ces instructions opèrent souvent sur des données qui sont la représentation sous forme informatique d’informations issues du monde réel (ex.: volume sonore, prix de l’essence).

Les données peuvent être de différentes natures. Par exemple, elle peuvent représenter :

  • Des nombres (entiers, décimaux, relatifs)

  • Du texte

  • Des ensembles de nombres ou de texte

Au moment de l’exécution d’un programme, les valeurs des données sont stockées dans des endroits bien précis de la mémoire de l’ordinateur.

Afin de pouvoir accéder simplement à ces données depuis un code source, on attribue un nom à chacun de leur emplacement dans la mémoire.

Cet emplacement de la mémoire caractérisé par un nom et une valeur porte le nom de variable.

En dehors, des instructions et des variables, on va souvent trouver dans un code source ce que l’on appelle des fonctions.

Une fonction est simplement un ensemble d’instructions que le programme est souvent amené à exécuter.

Ainsi au lieu de retaper cet ensemble d’instructions dans le code source à chaque fois que l’on désire l’exécuter, on va se contenter de l’écrire une fois pour toute dans une fonction. Ensuite, à chaque fois que l’on souhaite exécuter cet ensemble d’instructions, on exécute la fonction en réalisant un appel de fonction.

Ce qui précède n’a pas la prétention d’être exhaustif. Cependant, ce qui a été expliqué a un caractère «universel» et s’applique à n’importe quel langage de programmation. Il est donc essentiel de bien l’avoir compris.

Le chapitre suivant dresse un panorama des principaux langages de programmation.

2. Frise historique des langages

Le schéma suivant, figurent les dates de création des langages les plus connus ainsi que leurs liens de parenté.

Frise des langages
Figure 1. diagram of programming languages history [source : http://rigaux.org/language-study/diagram-light.png]

Un diagramme encore plus complet du même auteur est disponible ici

À présent, nous allons nous intéresser au véritable sujet de ce cours c’est-à-dire le langage Python.

3. Fiche d’identité du langage Python

  • Date de création : 1989

  • Créateur : Guido van Rossum. Programmeur d’origine hollandaise travaillant actuellement chez Google où il passe la moitié de son temps à suivre le développement du langage Python.

guido.jpg
  • Logo :

logo python
  • Versions actuelles (en 2019) : 2 branches de développement : Python 2.x et Python 3.x.

    • Python 2.x : v2.7.16

    • Python 3.x : v3.7.5

  • Domaines d’utilisation :

    • conception de sites internet (cf. framework web Django)

    • analyse de données avec visualisation éventuelle en 2D/3D

    • traitement d’images

    • applications scientifiques (cf. modules numpy, scipy, matplotlib)

    • administration système

  • Modes d’utilisation : L’utilisation du langage peut se faire selon plusieurs scénarios. Parmi ceux-ci, on trouve :

    • sous forme de script (Un script peut être considéré comme une succession de commandes que l’on va faire exécuter par la machine sans qu’on ait à les taper individuellement. Les informaticiens système s’en servent souvent pour automatiser des tâches répétitives.)

    • en tant qu’interface vers des biliothèques codées dans d’autres langages.
      Exemple : interface utilisateur codée en Python + traitements codés en langage C pour plus de rapidité

    • intégré de manière transparente pour l’utilisateur au sein d’un logiciel nécessitant l’utilisation de scripts.
      Exemples : Blender (logiciel de modélisation 3D), Gimp (logiciel d’édition/retouche d’images)

  • Popularité : À la 3ième place dans le classement Tiobe en Août 2019 (après le C et avant C++).

tiobe082019
  • Licence : Libre de type BSD (Berkeley Software Distribution).
    Permet l’utilisation de Python et la réutilisation de n’importe quelle partie de son code source sans restriction.
    Peut être intégré dans un logiciel libre ou propriétaire

4. Caractéristiques principales du langage Python

  • haut niveau

  • semi-interprété

  • orienté objet (…mais également procédural et même fonctionnel par divers aspects)

  • typage dynamique

  • typage fort

  • extensible

  • libre, gratuit, multiplateforme (Windows, Linux, Mac) …

4.1. Haut niveau

Le niveau d’un langage de programmation traduit aussi bien sa dépendance vis à vis du matériel sur lequel il s’exécute que sa capacité à «faciliter» la tâche du programmeur en lui proposant un ensemble de fonctionnalités de base accessibles avec une syntaxe qui tend à se rapprocher du langage humain.

Plus le niveau est bas, plus on se rapproche du matériel.

Python est souvent considéré par ses adeptes comme un langage de très haut niveau pour le différencier un peu des langage C/C++, Java, PHP, Perl qui sont des langages de haut niveau.

Il s’oppose alors à des langages bas niveau tels que les langages machine ou assembleur.

4.2. Semi-interprété

Il n’y a pas encore si longtemps de çà, un langage était soit interprété soit compilé.

Interprété signifie que l’on peut lancer directement l’exécution du programme correspondant au code source.

Rappelez vous que le code source est toujours traduit en langage machine avant d’être exécuté.

Dans un langage interprété, cette traduction est simplement transparente pour l’utilisateur.

Dans un langage interprété, le code source peut prendre 2 formes :

  1. une seule instruction.

  2. un ensemble d’instructions sauvegardées dans un fichier

Dans le 1ier cas, on exécutera un programme nommé interpréteur Python qui, comme son nom l’indique, interprète et exécute les instructions Python qu’on lui soumet. Par défaut, l’interpréteur se lance dans un mode appelé interactif qui consiste à attendre puis à exécuter chaque instruction saisie par l’opérateur, un peu à la manière d’une calculatrice.

Dans le 2ième cas, on exécutera le même interpréteur mais, cette fois-ci, en lui indiquant le nom d’un fichier contenant du code Python. L’interpréteur exécutera alors, les unes après les autres, les instructions Python contenues dans le fichier et ce, sans aucune intervention de l’opérateur.

Compilé signifie que le code source doit d’abord être transformé sous forme d’un fichier, appelé exécutable, spécifique à la machine et au système d’exploitation sur lesquels on désire l’exécuter grâce à un programme communément appelé compilateur.

Parmi les avantages des langages compilés, on retriendra leur plus grande rapidité par rapport aux langages interprétés et leur fonctionnement autonome (ils ne requièrent pas la présence d’un interpréteur sur la machine).

Les langages interprétés offrent quant à eux une plus grande portabilité. Il est ainsi inutile de recompiler un fichier source codé dans un langage interprété lorsqu’on désire l’exécuter sous Linux alors qu’on l’a codé sous Windows (…à condition de ne pas faire appel à des spécificités de chaque plateforme).

Pour réunir le meilleur des 2 mondes, on trouve maintenant des langages semi-interprétés comme Python, Java, C#.

Ces langages vont transformer le code source, de manière transparente pour l’utilisateur, dans un dialecte appelé bytecode.

Ce bytecode reste indépendant de la plateforme mais autorise une plus grande rapidité d’exécution.

Toutefois, les programmes semi-interprétés nécessitent toujours la présence d’un interpréteur sur la machine (appelé Machine Vituelle dans le cas du langage Java ou framework .Net dans le cas du langage C#). Ainsi, leur vitesse d’exécution reste moindre par rapport aux programmes générés par les compilateurs.

Dans le cadre du langage Python, plusieurs interpréteurs sont disponibles. Ils permettent d’étendre les capacités de Python en lui donnant accès aux bibliothèques proposées par d’autres langages.

Exemples:

  • CPython : implémentation par défaut basée sur le langage C.

  • Jython : implémentation permettant de mixer Python et langage Java.

  • IronPython :implémentation permettant d’utiliser Python sur la plateforme .NET de Microsoft.

  • PyPy : implémentation de Python … en Python !

4.3. Orienté objet

La programmation objet est un modèle de programmation (on dit aussi parfois "paradigme") qui consiste à décomposer les fonctionnalités d’un programme en terme d’interactions entre objets plutôt qu’en terme de séquences d’actions (cas du modèle de programmation dit procédural)

Pour tenter d’illustrer les 2 approches, nous allons prendre un exemple qui consiste à calculer la circonférence d’un cercle. Ce traitement informatique se décompose de la façon suivante selon le modèle de programmation choisi :

  • en programmation procédurale :

    1. Saisir le rayon

    2. Multiplier par 2 pour obtenir le diamètre

    3. Multiplier par PI pour obtenir la circonférence

    4. Afficher le résultat

  • en programmation objet :

    1. Créer un objet de type Cercle en spécifiant son rayon

    2. «Demander» au cercle sa circonférence (c’est une de ses caractéristiques donc il sait la calculer lui-même)

    3. Afficher la valeur retournée

4.4. Typage dynamique

En Python, les variables ne nécessitent pas d’être déclarées avant leur 1ière utilisation en spécifiant le type de la valeur qu’elles contiennent : le type est déduit automatiquement lors de l’affectation d’une valeur à cette variable.

Exemples d’instructions Python :

   prompt = 'Saisissez votre nom : '
   anneeNaissance = 1980

Dans cet exemple, la variable prompt sera considérée automatiquement de type texte alors que la variable anneeNaissance sera considérée de type numérique entière.

De même, en Python, la nature d’une variable peut évoluer au cours du temps. Par exemple, une variable peut contenir un entier à un moment puis une chaîne de caractères à un autre moment.

4.5. Typage fort

Cela signifie que l’on ne peut pas faire d’opérations entre variables de types (vraiment) différents car soit c’est ambigü soit cela n’a aucun sens.

Exemple : Que représente l’expression 'a' + 4 ?
Celle-ci doit-elle être évaluée comme 'e' c’est-à-dire la 4ième lettre après le 'a' ou comme la chaîne de caractères 'a4' c’est-à-dire la mise bout à bout du caractère 'a' et du caractère qui représente la valeur 4 ?

En Python, on obtiendra le 1ier résultat en tapant la commande chr(ord('a')+4) qui sera évaluée par l’interpréteur Python comme le caractère 'e' c’est-à-dire celui correspondant au code de la lettre 'a' dans le jeu de caractères courant augmenté de 4 :

On convertit d’abord, grâce à la fonction ord() , la lettre ’a' en un entier que l’on additionne avec 4 puis on transforme le résultat obtenu en caractère avec la fonction chr().

Un jeu de caractère est une table qui spécifie de manière normalisée comment les lettres doivent être codées dans l’ordinateur.

Ce code est une valeur numérique.

Par exemple, dans le jeu de caractères nommé Unicode, le code de la lettre 'a' vaut 97.

Unicode permet d’attribuer un code à la plupart des lettres ou symboles utilisés dans l’ensemble des langues parlées à travers le monde.

Pour arriver au 2ième résultat, on tapera la commande 'a' + str(4) qui sera évaluée comme la mise bout à bout de 'a' avec la représentation de la valeur 4 sous forme caractère.

À l’aide de la fonction str(), on représente la valeur 4 sous forme de texte (c’est-à-dire avec un chiffre) puis on le «colle» à la suite de la lettre 'a'. On dit aussi qu’on concatène les 2 chaines de caractères.

Dans un contexte de chaîne de caractères, l’opérateur + perd donc sa signification d’addition arithmétique.

Au temps des romains, la représentation de la valeur 4 en texte aurait donné 'IV' et non '4'.

Pour lever l’ambiguité sur l’opération à effectuer dans les 2 instructions précédentes, on les a codées de manière à effectuer des opérations sur des valeurs de même type (entier ou caractère) pour signifier à Python ce que l’on voulait vraiment faire.

4.6. Extensible

Les possibilités de Python peuvent facilement être étendues grâce à l’adjonction de modules qui donnent accès à des fonctionnalités couvrant de nombreux domaines (bases de données, web, calcul scientifique, réseau, traitement d’images …).

Cette caractéristique fait de Python un langage généraliste.

5. Découverte de l’interpréteur Python

La meilleure façon d’apprendre un langage informatique étant de pratiquer, nous allons nous familiariser progressivement avec le langage Python en effectuant quelques opérations de base.

Comme il l’a été mentionné dans les pages précédentes, Python est un langage interprété et, en tant que tel, il va nous permettre d’exécuter d’une manière simple nos premières instructions.

Pour commencer, on va donc utiliser Python dans un mode dit interactif qui va nous permettre d’exécuter des instructions que l’on va saisir les unes après les autres.

Dans le mode interactif, Python exécute en permanence la séquence suivante :

  1. Il affiche, sous la forme du symbole >>>, une invite de commande qui, comme son nom l’indique, invite l’utilisateur à saisir une expression.

  2. Il attend que l’utilisateur valide l’expression saisie avec la touche ENTRÉE.

  3. Il évalue l’expression saisie. Ceci signifie qu’il l’analyse et l’exécute.

  4. Il affiche le résultat de l’instruction

5.1. Travail faire : Python en tant que calculette basique

  • Si vous disposez d’une distribution de linux, lancez Python en exécutant dans un terminal la commande : python3.
    Une fenêtre s’affiche alors avec le contenu suivant:

Python 3.7.3 (default, Mar 27 2019, 22:11:17)
[GCC 7.3.0] :: Anaconda custom (64 bits) on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Sinon, utlisez le site https://repl.it/languages/Python3 qui fournit une console python dans une machine virtuelle linux.

  • Saisissez l’expression suivante 3 + 4 et validez avec la touche ENTRÉE.
    Quel miracle s’accomplit sous vos yeux éberlués ?

  • Calculez à présent 9 / 2.
    Le résultat obtenu est-il le résultat attendu ?

Ce comportement n’est observable que dans les versions de Python supérieure à 3.0. Les versions de python antérieures ne retourneront dans ce cas précis que la valeur entière de la division. Pour obtenir le bon résultat, il faut que le diviseur soit réel soit : 9/2.0

  • Évaluez à présent l’expression suivante en tapant 9 // 2
    Que retourne cet opérateur ?

Notez qu’en informatique la partie décimale d’un nombre est séparée de sa partie entière par un point et non une virgule.

  • Saisissez maintenant l’expression (9 / 2) * 2 + 9 % 2
    À partir du résultat affiché, à quoi servent selon vous les opérateurs * et % ?

  • Tapez le caractère _ (8) et validez avec Entrée
    Que s’affiche-t-il ?
    A quoi cela peut-il servir ?

Indice : Pensez à la fonction ANS présente sur de nombreuses calculatrices.

5.2. Travail faire : Python en tant que calculette scientifique

Vous allez à présent calculer la factorielle d’un nombre N. Celle-ci correspond au produit de tous les nombres entiers strictement positifs inférieurs ou égaux à N.

Il n’existe aucun opérateur (comme +, -, /) pour cette opération.

Cependant Python propose une fonction pour la calculer : celle ci s’appelle factorial().

Cette fonction ne fait pas partie du langage Python proprement dit mais est incluse dans une librairie livrée avec lui.

Pour appeler cette fonction, il faut lui indiquer dans les parenthèses le nombre pour lequel on veut calculer la factorielle. Ce nombre est appelé argument de la fonction.

Cependant, si on tape l’expression factorial(5) pour calculer la factorielle de 5, Python nous affiche une erreur :

>>> factorial(5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'factorial' is not defined

Ce message indique que le nom factorial n’est pas reconnu.

En effet, il a été précisé plus haut que la fonction factorial() ne faisait pas partie du langage Python mais d’une librairie.

Ainsi, avant d’appeler une fonction qui fait partie d’une librairie, il faut toujours indiquer à Python dans quelle librairie il peut la trouver. Ceci se fait à l’aide de l’instruction import suivie du nom de la librairie.

Dans le cas de la fonction factorial(), il s’agit de la librairie math.

Ensuite, il suffit d’appeler la fonction avec la syntaxe suivante math.factorial(5).

  • Reproduisez les instructions suivantes dans votre interpréteur Python et vérifiez que les résultats sont conformes à l’affichage ci-dessous.

RAPPEL : les >>> ne doivent pas être saisis au clavier

>>> import math
>>> math.factorial(5)
120
>>> 1 * 2 * 3 * 4 * 5
120
>>>

La directive import n’est à exécuter qu’une seule fois. Ainsi, si on veut calculer par la suite le cosinus d’un angle de pi avec la fonction cos() qui fait partie de cette même librairie, on peut taper directement math.cos(math.pi).

  • Vérifiez qu’il n’est pas nécessaire de réaliser un autre «import» de la librairie math pour faire appel à d’autres fonctions qu’elle propose en évaluant l’expression math.cos(0) qui calcule le cosinus d’un angle de 0 radian.

5.3. Travail faire : Obtenir de l’aide

Python possède une caractéristique intéressante qui permet d’obtenir facilement de l’aide sur un mot clé du langage, une fonction ou une librairie.

Pour cela, il suffit d’appeler la fonction help() depuis l’interpréteur Python en lui fournissant en argument le nom du sujet sur lequel on désire afficher l’aide. Tapez sur Q pour quitter l’aide.

  • Quelle instruction Python permet d’afficher l’aide de :

    • la librairie math ?

    • de la fonction factorial() ?

5.4. Travail faire : Utilisation des variables

Dans les activités précédentes, des calculs ont été réalisés directement sur des valeurs numériques. Ces valeurs sont appelées valeurs littérales.

Il faut éviter au maximum d’utiliser les valeur littérales dans les programmes. On doit au contraire privilégier l’utilisation de variables.

Comme expliqué dans le chapitre Constitution d’un programme de ce cours, les variables sont des noms qui font référence à des emplacements de la mémoire où sont stockées des valeurs.

Lorsqu’on veut modifier le contenu d’un emplacement mémoire on réalise une affectation à l’aide de l’opérateur = qui prend ici une signification différente de celle qui lui est accordée en mathématique.

Ainsi, en Python, x = 3 signifie «mettre la valeur 3 dans l’emplacement mémoire référencé par l’identificateur noté x».

En mathématique, x = 3 représente une égalité et peut également s’écrire 3 = x Cette dernière écriture, n’a aucune signification en Python. La preuve:

>>> 3 = x
File "<stdin>", line 1
SyntaxError: can't assign to literal    (1)
>>>
1 : Python manifeste son mécontentement lorsqu’on essaye d’affecter une valeur littérale

Pour lire le contenu d’une variable, il suffit de saisir son nom.

Pour affecter (assign en anglais) à la variable y le double de la variable x on écrit:

>>> x = 3
>>> y = 2 * x
>>> y
6
>>>

Lorsque le nom d’une variable apparait à gauche d’un signe = c’est une affectation. Lorsqu’il apparait à droite, c’est qu’on veut lire son contenu.

  • Reproduisez les instructions suivantes qui calculent le prix TTC d’un article dont le prix est 45€ sachant que la TVA vaut 20%:

>>> TVA = 20 / 100
>>> prixHT = 45
>>> prixTTC = prixHT * (1 + TVA)
>>> prixTTC
54
>>>
  • Modifiez la valeur de la TVA pour qu’elle prenne la valeur 10% et affichez immédiatement le prix TTC.

>>> TVA = 0.1
>>> print(prixTTC)
  • Celui-ci a-t-il été mis à jour ?

  • Tentez d’expliquer pourquoi.

    • Évaluez le prix à payer par le client lorsqu’on lui accorde une réduction de 5%.

Les variables peuvent contenir des valeurs de nature vraiment différente.

On a vu dans le chapitre Constitution d’un programme que les variables pouvaient notamment contenir des nombres ou du texte.

Lors de l’affectation d’une variable, Python va déterminer automatiquement le type de celle-ci afin de déterminer les opérations qu’il est possible ou non de réaliser sur elle.

Python dispose d’une fonction qui permet d’afficher le type qu’il a déterminé pour une variable. C’est la fonction type() à laquelle on passe le nom de la variable en argument.

  • Affectez le nombre 5 à une variable nommée unEntier.
    Affichez le type de cette variable en tapant type(unEntier).

  • Affectez la valeur 3.14 à une variable nommée pi.
    Demandez à Python d’afficher son type.

  • Affectez le texte dring… à une variable nommée sonnerie.
    Demandez à Python d’afficher son type.

Pour affecter du texte à une variable, il faut l’entourer soit d’apostrophes (4'{) soit de guillemets (3"#).

  • Si le texte contient ", il faut délimiter le texte avec '.

  • Si le texte contient ', il faut délimiter le texte avec ".

  • Le choix est libre si le texte ne contient ni de ' ni de ".

Exemple
>>> titreFilm = "Bienvenue chez les Ch'tis"
>>> intituleQuestion = 'Qui a dit : "Veni, vidi, vici" ?'
  • Tentez d’additionner 2 à 2 les variablesunEntier, pi, sonnerie et notez les résultats obtenus.

  • Multipliez à présent ces mêmes variables 2 à 2 et notez également les résultats.
    Quelle signification peut avoir l’opérateur * lorsqu’il est appliqué à une variable de type texte en Python ?

  • Quittez Python avec la séquence de touche Ctrl+D ou Ctrl+Z ou en tapant la fonction exit() ou raise SystemExit.

Le mode interactif de Python est très pratique pour tester des commandes/fonctions de Python.

Cependant, il n’est guère adapté pour rejouer une séquence de commandes à laquelle on désire apporter ne serait-ce qu’une seule petite modification car cela implique de saisir à nouveau toutes les commandes et les exécuter les unes après les autres.

Un autre inconvénient du mode interactif est de perdre tout ce qui a été tapé lorsqu’on quitte l’interpréteur.

Nous allons voir à présent comment écrire et exécuter des scripts Python.

6. Premiers scripts Python

Dans cette partie, vous allez utiliser Python dans le mode «normal» et non plus dans le mode interactif.

Dans le mode normal, vous lancez l’exécution de l’interpréteur Python en lui indiquant le nom d’un fichier (avec l’extension .py). Ce fichier contient l’ensemble des instructions que vous souhaitez qu’il exécute en séquence. Ce fichier s’appelle un script.

Ce mode offre l’avantage de pouvoir sauvegarder ou de diffuser votre code source Python.

La saisie du code source Python peut se faire avec n’importe quel éditeur de texte (notepad, vim, kate, emacs, geany, gedit, …). Cependant, Python propose en standard un environnement de développement intégré (EDI ou IDE en anglais) appelé IDLE.

Cette IDE va vous permettre non seulement de saisir des scripts Python mais également de taper des commandes en mode interactif.

IDLE propose également la coloration syntaxique et la «completion» automatique.

Ces 2 fonctionnalités consistent, pour l’une, à colorer de différentes manières, les mots clés de Python, les variables…et, pour l’autre, à tenter de deviner ce que vous voulez taper en proposant une liste de possibilités.

Ces fonctionnalités facilitent grandement l’apprentissage du langage.

6.1. Travail faire : Atelier dessin !!

Pour découvrir sous un aspect «ludique» le monde des scripts, vous allez réaliser des dessins (rudimentaires) en Python.

Rassurez-vous, Python propose un module qui va vous faciliter grandement la tâche.

Ce module s’appelle turtle.

Il met à votre disposition un ensemble de fonctions qui vont reproduire le comportement d’un crayon sur une feuille sur laquelle on désirerait dessiner.

Voici quelques unes des fonctions du module turtle :

  • reset() Efface tout le dessin

  • goto(x, y) Positionne le crayon à la position de coordonnées x, y

  • forward(distance) Avance d’une distance donnée

  • backward(distance) Recule d’une distance donnée

  • up() Relève le crayon pour pouvoir le déplacer sans dessiner

  • down() Repose le crayon pour recommencer à dessiner

  • color(couleur) Sélectionne la couleur du tracé. couleur peut être une chaîne prédéfinie (red, blue, green, etc.)

  • left(angle) Tourne à gauche d’un angle donné exprimé en degrés

  • right(angle) Tourne à droite

  • width(épaisseur) Choisit l’épaisseur du tracé

  • fill(True) Demande le remplissage du prochain contour fermé à l’aide de la couleur courante

  • write(texte) Écrit le texte délimité par ' ou " à l’endroit actuel du crayon.

  • Lancez IDLE.

$ python -m idlelib.idle
  • Dans le menu «File», sélectionnez «New window»

  • Saisissez le code suivant dans la fenêtre:

import turtle as t
t.reset()
t.color('blue')
t.forward(100)
t.left(120)
t.forward(100)
t.left(120)
t.forward(100)
t.left(120)
t.exitonclick()

Remarquez la variante de syntaxe dans l’utilisation de la directive import. Celle-ci permet d’invoquer les fonctions du module turtle en les faisant précéder de t. et non plus de turtle.. Le choix de t est arbitraire. On aurait pu choisir n’importe quelle autre lettre.

  • Sauvegardez ce code source dans un fichier de votre espace de travail en lui donnant le nom script01.py

Exécutez ce script en sélectionnant l’option «Run module» du menu «Run» de IDLE ou simplement en appuyant sur F5 au clavier.

Pour quitter le programme, cliquer simplement dans la fenêtre du dessin.

  • Analysez le code source pour identifier le rôle de chaque expression dans le dessin obtenu.

6.2. Travail faire : Instructions de boucle

Dans le code qui précède, vous pouvez remarquer que la séquence suivante est répétée 3 fois:

t.forward(100)
t.left(120)

C’est le genre de situation qu’il faut absolument éviter dans les programmes.

Tous les langages proposent à cet effet d'instructions de boucle.

En Python, il y en a une, appelée for, qui va permettre de répéter un certain nombre de fois un bloc d’instructions.

Pour que Python distingue les instructions à répéter de celles qui ne doivent pas l’être, il impose de les indenter les unes par rapport aux autres.

Indenter consiste simplement à décaler une ou plusieurs instructions en les faisant précéder d’une tabulation (la touche tabulation du clavier) ou de caractères d’espace.

La valeur de décalage importe peu du moment qu’elle est cohérente sur l’ensemble du bloc d’instructions à répéter.

Cette indentation obligatoire est une des spécificités de Python qui contribuent à rendre les programmes très lisibles.

  • Modifiez le script précédent comme suit et vérifiez que vous obtenez le même résultat à l’exécution que dans le travail précédent.

import turtle as t
t.reset()
t.color('blue')
for n in range(0,3) :
    t.forward(100)
    t.left(120)
t.exitonclick()

La ligne for n in range(0,3) : signifie que l’on désire exécuter le bloc d’instructions qui suit le : tant que la variable n n’aura pas parcouru l’ensemble des valeurs entières de l’intervalle [0…3[ sachant qu’au départ, elle vaut 0 et que Python augmente automatiquement sa valeur d’1 unité à chaque passage dans la boucle.

Chaque passage dans la boucle s’appelle aussi une itération.

6.3. Travail faire : Interaction avec l’utilisateur

Il est souvent nécessaire pour un programme de demander à l’utilisateur qu’il rentre des valeurs qui conditionneront le déroulement du programme.

Python dispose en standard d’une fonction qui permet cela : input().

Cette fonction renvoie au programme ce qui a été saisi au clavier par l’utilisateur sous forme de chaîne de caractères.

Cette chaîne de caractère peut ensuite être convertie en valeur numérique.

Exemples d’utilisation:
>>> txt = input("Entrez votre nom : ")
Entrez votre nom : Manvussa
>>> print(txt)
Manvussa
>>> dateNaissance = input("Année de naissance ? ")
Année de naissance ? 1980
>>> type(dateNaissance)
<class 'str'>
>>> print("Vous avez ", 2019 - dateNaissance, " ans.")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'int' and 'str' (1)
>>> dateNaissance = int(dateNaissance) (2)
>>> type(dateNaissance)
<class 'int'>
>>> print("Vous avez ", 2019 - dateNaissance, " ans.") (3)
Vous avez  39 ans.
>>>
1 Python signale une erreur car il ne sait pas soustraire une chaîne d’un entier
2 int(dateNaissance) convertit dateNaissance en entier
3 cette fois-ci, il n’y a aucune erreur car on soustrait bien 2 valeurs entières.

  • Modifiez le script du travail précédent. de façon à ce que l’utilisateur puisse saisir la longueur du côté du triangle à dessiner.

  • Faites évoluer votre script afin que le programme demande également la couleur désirée pour le triangle.

  • Modifiez enfin votre script de façon à ce que celui-ci puisse tracer un polygone (l’utilisateur devra donc saisir le nombre de côtés de la figure qu’il souhaite dessiner)

6.4. Travail faire : Instructions de test

Le déroulement d’un programme dépend souvent des circonstances rencontrées.

Pour gérer cette situation, les langages proposent tous des instructions qui testent des conditions et aiguillent le déroulement du programme.

En Python, une des ces instructions est if <condition>: … else: …

Exemple d’utilisation:
>>> a = 18
>>> if a < 18:
        print("Vous n'êtes pas majeur")
else:
        print("Vous êtes majeur")

Vous êtes majeur
>>>

Il est possible d’enchaîner des tests avec une structure if <condition>: … elif: … else: …

Exemple :

>>> moyenne=13
>>> if moyenne < 8:
        print("niveau médiocre")
elif 8<= moyenne < 12:
        print("niveau moyen")
elif 12 <= moyenne < 16:
        print("bon niveau")
elif 16 <= moyenne <= 20:
        print("Excellent niveau")
else:
        print("Moyenne invalide")

bon niveau
  • Réalisez un script qui permet à un utilisateur de trouver un nombre choisi aléatoirement par Python. Indiquez à l’utilisateur si le nombre qu’il propose est trop grand, trop petit ou s’il a trouver. Le jeu peut s’arrêter lorsque le nombre est trouvé ou bien après 10 tentatives.

L’opérateur d’égalité se note == en Python.

Pour demander à Python de choisir un nombre aléatoire entre 1 et 100 vous taperez le code suivant:

import random
r = random.randint(1,100)

6.5. Travail faire : Fonctions utilisateur

Jusqu’à présent, vous avez utilisé des fonctions proposées par Python ou un de ses modules. Cependant, il est très fréquent et même recommandé de décomposer votre code source en fonctions renfermant les traitements de vos scripts : vous y gagnerez en lisibilité, modularité, réutilisabilité, maintenance de code.

Une fonction se définit dans un bloc introduit par le mot clé def suivi du nom de la fonction et de la liste de ses paramètres entre parenthèses séparés par des virgules.

Les paramètres correspondent aux informations dont la fonction a besoin pour réaliser le traitement dont elle a la charge.

Le déroulement d’une fonction se termine par une instruction return qui retourne le résultat du traitement.

Exemple d’une fonction calculant la circonférence d’un cercle:
# Importation des modules utilisés dans le script (1)
import math

# Définition de la fonction qui permet de calculer la circonférence d'un cercle
def calculerCirconference(leRayon):
         circonference = 2 * math.pi * leRayon
         return circonference

# Point d'entrée du script
r = float(input("Saisir le rayon du cercle : ")) (2)
perimetre = calculerCirconference(r)
print("la circonférence du cercle de rayon ", r, " vaut ", perimetre)
1 En Python, un commentaire — c’est-à-dire du texte qui ne sera pas évalué par l’interpréteur — est introduit par le caractère #. Ces commentaires sont primordiaux car ils permettent de documenter son code. Je vous l’accorde, ici, ils ne sont pas d’une très grande utilité…
2 Notez que la 1ière instruction vraiment exécutée par Python du point de vue de l’utilisateur n’est pas la 1ière rencontrée dans le script.

La variable leRayon est parfois appelée paramètre formel tandis que la variable r est appelée paramètre effectif. On parle aussi, de manière générale, d' arguments.

Même si c’est possible, interdisez-vous de nommer les variables qui servent de paramètres effectifs avec les mêmes noms que les paramètres formels.

La variable leRayon n’est connue que dans le bloc de définition de la fonction. Un argument apparait donc comme une variable locale à la fonction et son affectation se fait au moment de l’appel.

Ainsi, dans l’exemple précédent leRayon prend la valeur de r lorsque Python exécute calculerCirconference(r).

Une fonction doit toujours être définie avant la ligne où elle est appelée.

  • Faites évoluer votre script de dessin avec le module turtle du travail précédent de façon à ce qu’il propose le tracé de plusieurs formes par l’intermédiaire de fonctions

Les fonctions retourneront le périmètre de chaque figure.

Ci-dessous, on vous propose un début de solution qui fait appraître la définition les fonctions que vous devez coder ainsi que le code d’une fonction qui permet de gérer un menu simple :

import turtle as t

def tracerCarre(origineX, origineY, cote):
  pass (1)
def tracerTriangleEquilateral(origineX, origineY, cote):
  pass (1)
def tracerTriangleIsocele(origineX, origineY, base, hauteur):
  pass (1)
def tracerRectangle(origineX, origineY, coteCourt, coteLong):
  pass (1)
def gererMenu():
  quit = False
  while not quit :
    print("MENU : ")
    print("1- Tracer un carré")
    print("2- Tracer un triangle équilatéral")
    print("3- Tracer un triangle isocèle")
    print("4- Tracer un rectangle")
    print("0- Quitter")

    choix = int(raw_input("Votre choix ? "))

    if not (0 <= choix <= 4) :
      print("!! Choix non valide !!")
    else :
      quit = True

  return choix

# Point d'entrée du script
choixMenu = -1
while choixMenu != 0 :
  choixMenu = gererMenu()
  t.reset()
  t.fill(True)
  # Compléter le code du programme principal à partir d'ici
  # ...
1 L’instruction pass est une instruction qui ne fait rien. Elle est utilisée à des endroits qui ne nécessitent aucun traitement mais où une instruction est quand même requise pour respecter la syntaxe. Ici, on l’utilise simplement pour indiquer la zone où vous devez compléter le code.

  • Les 2 fonctions tracerCarre() et tracerTriangleEquilateral() consistent toutes les 2 à tracer des polygones qui ne diffèrent que par leur nombre de côtés.

  • Définissez une fonction tracerPolygone(nbDeCotes, tailleCote) que vous appellerez depuis tracerCarre() et tracerTriangleEquilateral() pour réaliser le tracé effectif.

7. Conclusion

Voilà qui termine ce module de formation consacré à l’initiation à la programmation.

La 1ière partie (chapitres 1 à 4) a présenté, de manière plutôt théorique, des concepts généraux sur la programmation et les langages de programmation en s’appuyant sur la présentation du langage Python.

Ces concepts seront largement développés au cours de votre formation. Cependant, il faut dès maintenant, commencer à bien comprendre le processus de création d’un programme et la façon dont il s’exécute sur la machine.

La 2ième partie du module, essentiellement pratique, a montré de quoi était composé un programme Python : instructions, opérateurs de calcul, variables, instructions de test et de boucle, fonctions (créées par l’utilisateur ou importées d’un module)…

Il y a bien sûr beaucoup de sujets qui n’ont pas été abordés mais les grandes lignes ont cependant été exposées.

N’oubliez pas que la programmation est une activité qui nécessite énormément de pratique. N’hésitez donc surtout pas à refaire chez vous les exercices proposés et même à les compléter par vous même en proposant des alternatives ou des évolutions.

Les outils utilisés au labo d’informatique sont majoritairement gratuits. Vous n’avez donc aucune excuse pour ne pas les installer chez vous !

De plus, la programmation informatique — du moins à notre niveau — n’occasionne pas de dégâts irréversibles. Donc, osez expérimenter même si cela n’aboutit pas : échouer c’est apprendre à réussir.

Bonne programmation !


the_end.jpg