Le langage de programmation choisi pour l'enseignement est python.

Pourquoi ce choix ? Il y a de nombreux avantages :

• python est un langage très intuitif, proche de ce qu'on appelle le pseudo-code. Sa syntaxe permet d'obtenir un code simple et aéré.
• python est multiplateforme et gratuit : chaque élève peut donc s'entrainer chez soi, quelque soit son installation personnelle.
• python possède un shell ( c'est-à-dire un interpréteur ) : cela permet de tester directement les instructions en ligne de commande.
• python est très documenté sur le net et possède de nombreux modules, qui simplifient énormément la vie et de s'intéresser à de nombreux domaines ( systèmes d'exploitations, interface graphique, réseaux, etc... ).
• avec les nouvelles versions actuelles, python devient un langage plus populaire.

Il y a bien sûr des inconvénients, comme l'optimisation du temps d'exécution, l'introduction aux pointeurs, etc...mais le but de ces séquence d'enseignement est la logique de programmation. Cela signifie que ces inconvénients ne gênent pas pour un apprentissage des structures/méthodes de programmation.

Pour en savoir plus : python .

Logiciel

Pour vous entrainez, vous pouvez utiliser le logiciel gratuit ActivePython ( actuellement en version 2.6.3.7 ) sous windows.

Il est déjà installé sur les ordinateurs du lycée.

On peut l'utiliser sous deux formes différentes :

• en mode console, c'est-à-dire qu'on peut entrer/tester les commandes ou opérations une à une ( d'ailleurs essayez de comprendre les commandes données en exemples ci-dessous ) :

• ou en tant qu'éditeur de script. Rappelons qu'un script est un ensemble de commandes que doit effectuer ce script ( encore une fois, essayez de comprendre ce que fait le script ci-dessous ) :

Comme d'habitude, l'icône qui désigne une feuille blanche sert à écrire un nouveau script, et on peut ouvrir un script existant grâce à l'icône représentant un dossier ( jaune ) ouvert : il faut ensuite choisir "Python Script".

Le raccourcis clavier pour enregistrer le script en cours d'édition est Ctrl + s, un classique.

Pour tester le script ( une fois qu'il est enregistré ! ), il faut cliquer sur le bouton en forme de triangle noir.

Si il devait y avoir une faute de syntaxe, cette faute apparaitrait dans la barre de statut en bas, si cette faute est plus grave, elle apparait dans la console, comme on peut le voir ici ( j'imagine que vous aurez trouvé l'erreur et que vous saurez comment la corriger ) :

Quand vous enregistrez un script python, celui-ci va porter l'extension .py (on verra plus tard que cela pourra également être .pyw ).

En double-cliquant sur le fichier .py, celui-ci sera exécuté grâce à l'interpréteur python dans une fenêtre DOS, c'est-à-dire que les commandes vont être converties en langage machine "à la volée" et exécutées, mais, sur un ordinateur n'ayant pas d'interpréteur python, ce script ne produira rien.

De la même façon, on peut considérer qu'un navigateur internet est un interpréteur de html.

Si on veut que le script devienne un exécutable, ou un programme, il faudra d'abord le compiler, c'est-à-dire le convertir en langage machine une fois pour toute. Cette étape ne sera pas nécessaire pour l'apprentissage de python au lycée.

Cours sur Internet

• Cours de Gérard Swinnen
• Openbook de Galileo
• Dive into Python : Un livre complet sur python, téléchargeable dans plusieurs formats ( html, pdf, ... ) et dans plusieurs langues ( malheureusement pas en allemand ).

Instructions de base

PRINT

L'instruction print permet d'afficher une valeur, un texte à l'écran.

Pour afficher la valeur d'une variable a :

print a

print a
print b

print a, b

Remarque : Attention, car à partir de la version 3 de python, print devient une fonction, et dans ce cas son utilisation se fait sous la forme :

print(a)

INPUT

Pour récupérer les données saisies par un utilisateur, on utilise les fonctions input() et raw_input(). Les parenthèses sont prévues pour y mettre un message à l'utilisateur, à mettre entre guillemets :

nombre = input("Entrez un nombre :\n")

Ainsi, avec cet exemple, la valeur que va entrer l'utilisateur sera enregistrée dans la variable appelée nombre.
Le \n permet de passer à une nouvelle ligne, tout comme en PHP.

Différence entre input() et raw_input() :

• input récupère la variable telle qu'elle est écrite, après l'avoir évaluée : si la variable est un nombre entier, elle sera enregistrée en tant que int, si il s'agit de caractères mélangés, elle sera enregistrée en tant que chaîne de caractères, etc....
• raw_input récupère toujours une variable de type string, c'est-à-dire une chaîne de caratères.

Astuce : Pour pouvoir visualiser le résultat d'un programme dans la fenêtre DOS, toujours terminer le programme par la ligne raw_input(), ce qui met le programme en pause tant que la touche ENTER n'est pas frappée.

Cela peut paraitre un peu abstrait pour le moment, mais nous allons de suite faire les premiers tests en console...

Les exercices viennent à la page suivante.

Premiers pas en console

Les questions suivantes sont prévues pour être faites en mode console.

Pour ouvrir une console python :

• sous linux, dans un terminal, simplement taper 'python'
• sous windows, lancer le programme activepython ( qui doit être installé... ) et travailler dans la fenêtre Interactive Window :

Les caractères ">>>" correspondent à une nouvelle ligne où l'on peut entrer les instructions, etles résultats des instructions s'affichent en dessous, sans ces caractères ( en bleu sur l'image ci-dessus ).

Définir une variable

Comme son nom l'indique, une variable est un objet qui peut changer de valeur. Afin d'être sûr de toujours parler de la même variable, et surtout pour l'utiliser, on lui donne un nom ( comme en maths... ). Dans l'exemple ci-dessous, je définis un nombre entier, sous le nom de "monnombre" :

monnombre = 10

Python ne laisse pas apparaitre l'anti-symétrie de cette définition : pour définir une variable, il faut toujours commencer par son nom à gauche, puis terminer par sa valeur à droite. Donc la syntaxe suivante est incorrecte :

10 = monnombre

Comme on va le voir dans la suite, il existe plusieurs types de variables : des nombres entiers, des nombres réels, des chaines de caractères, des listes, etc....

Tester avec des nombres entiers

Dans une console :

Tester avec des nombres réels

Pour noter un nombre réel, il suffit d'ajouter une virgule. Attention, car la virgule anglaise se note avec un point...

Donc par exemple :

6.2
5.

sont des nombres réels ( ou à virgule flottante ) pour python.

Les chaines de caractères

Une chaine de caractères est une suite de lettres, ou de chiffres, ou de caractères spéciaux. Bref, une chaine de caractère est une suite de caractères . Pour définir une chaine de caractères, il faut la délimiter par des guillemets, simples ou non :

maphrase = "Voici une phrase."

Chaque caractère de la chaine est indexé, c'est-à-dire repéré par un nombre, ce qui permet d'avoir un accès rapide à chaque caractère.

Pour tester vos connaissances à ce sujet, faire le quizz sur le thème entrée-sortie.

Les listes

Une liste est, comme son nom l'indique, une liste de variables : elle peut contenir des entiers, des réels, des chaines de caractères, ou même des listes. Tout comme les chaines de caractères avec les guillemets, il existe un symbole pour reconnaitre une liste, et ce symbole est obligatoire, il s'agit des crochets :

malisteamoi = [542, 5.3, "un mot !", "vive python", 10.5]

On y voit les trois types de variables définis précédemment. Tout comme pour les chaines de caractères, chaque élément d'une liste est indexé.

Pour faire la synthèse des connaissances sur les variables, faire le quizz sur le thème des variables.

Je reviendrai plus tard et plus en profondeur sur le thème des variables, donc il se peut que quelques questions soient trop difficiles ( en particulier les dernières ).

Un premier programme

Nous allons maintenant enregistrer une suite d'instructions afin de former un script ( ou un programme, je risque d'utiliser les deux mots ).

Dans activepython, comme dit précédemment, ouvrir une feuille vide d'édition pour un script python à l'aide de l'icône feuilel blanche en haut à gauche :

Dans un premier temps, il faudra éviter de mettre des caractères spéciaux ou accentués ( par exemple ä, é, è, etc... ).

Nous reviendrons plus tard sur les problèmes d'encodages.

L'objectif de ce premier programme est simplement de calculer le carré d'un nombre.

Une fois que vous avez fini d'écrire ce programme, l'enregistrer sous le nom carre.py dans votre dossier personnel, et double-cliquer dessus pour le tester. Quand on le lance, une fenêtre DOS s'ouvre et affiche les instructions et/ou leurs résultats, ce qui dans ce cas devrait avoir la forme :

Un problème ? Est-ce que la fenêtre disparait rapidement ? C'est normal, il faut mettre une "pause" à la fin du script, grâce à l'instruction :

raw_input()

C'est-à-dire que le script est en train d'attendre que l'utilisateur appuie sur la touche "Entrée" pour terminer.

N'afficher la réponse qu'en cas de réelle difficulté ou si le programme a été réalisé correctement pour vérification :

1
2
3
4

nombre = input("Donner un nombre\n")
 
print "Merci pour le nombre", nombre, "."
print "Le carre du nombre", nombre, "est", nombre**2

1
2
3
4
5

nombre_article = input("Combien de fois achetez-vous cet article ?\n")
prix = input("Quel est le prix en euros de cet article ?\n")
 
print "Le prix total sera de :"
print nombre_article, "*", prix, "* 1,196 =", nombre_article * prix * 1.196, "euros."

L'instruction IF

Que se passe-t-il si l'utilisateur donne une largeur de rectangle négative dans la question 2. de l'exercice précédent ?

Il va falloir mettre des tests en place pour éviter des réponses qui n'ont pas de sens...

Ou, dans une autre situation, on peut avoir des variables qui prennent des valeurs différentes suivant certains cas. Exemple facile, les tarifs d'entrée au cinéma :

• pour les moins de 6 ans : 3€
• entre 6 et 14 ans : 4€
• entre 14 et 18 ans : 6€
• au-dessus de 18 ans : 7,5€

L'instruction if permet de tester, et d'effectuer des instructions suivant les résultats du test.

Pour considérer le premier tarif, il faudrait dire : Si l'âge est inférieur à 6, alors le prix est de 3.

Ceci se traduit en python par :

1
2

if ( age < 6 ):
  prix = 3

Sauf que....il faut traiter les autres tarifs possibles. Il existe pour cela l'instruction else ( sinon ) qui traite le cas complémentaire :

1
2
3
4

if ( age < 6 ):
  prix = 3
else:
  prix = ????

1
2
3
4
5
6
7
8
9
10

if ( age < 6 ):
  prix = 3
else:
  if ( age < 14 ):
    prix = 4
  else:
    if ( age < 18 ):
      prix = 6
    else:          
      prix = 7.5

On n'a pas besoin de faire le dernier test, car on est automatiquement dans la situation où l'âge est supérieur à 18 ans, donc l'instruction else suffit.

Le code devient beaucoup plus lourd, et là nous n'avons que deux tests, imaginez de tester toutes les possiblités lorsqu'on a 15 cas différents ...

Heureusement les langages de programmation ont prévu cela et permettent d'aller un peu plus vite grâce à l'instruction elif ( contraction de "else if" ) :

1
2
3
4
5
6
7
8

if ( age < 6 ):
  prix = 3
elif ( age < 14 ):
  prix = 4
elif ( age < 18 ):
  prix = 6
else:          
  prix = 7.5

La syntaxe complète est donc :

1
2
3
4
5
6
7

if (condition1):
  instruction1
elif (condition2):
  instruction2
else:
  instruction3
# retour à la ligne pour la suite du programme

On peut utiliser les instructions elif et else, mais elles ne sont pas obligatoires.

Une remarque importante : après la ligne contenant "if (condition1):" il faut absolument respecter l'indentation pour chaque ligne contenant une instruction, mais pas pour les lignes "elif (condition2):" et "else:".

Respecter une indentation signifie mettre des espaces pour faire apparaitre une hiérarchie dans le code.

La remarque sera la même pour les boucles qui suivent ( WHILE et FOR ).

La boucle WHILE

On a souvent besoin de répéter une même suite d'instructions, ou des instructions du même type, par exemple si on veut afficher tous les nombres entiers de 1 à 15 un par un. Cela signifie qu'il faudrait effectuer les instructions :

print 1
print 2
print 3
print 4
print 5
print 6
print 7
print 8
print 9
print 10
print 11
print 12
print 13
print 14
print 15
 

Assez embêtant de l'écrire tel quel.

Heureusement la boucle while permet cela. La syntaxe est :

while (condition):
  instruction 1
  instruction 2
  ...
  instruction n
# retour à la ligne pour la suite du programme

Tant que la condition est vérifiée, les instructions de 1 à n seront effectuées. Bien faire attention à respecter la même indentation pour chaque instruction dans la boucle. Le retour à la ligne signifie la fin des instructions à répéter dans la boucle while.

Avant d'écrire ce genre de boucles, assurez-vous qu'elle n'est pas infinie ! Ou prévoyez un moyen de sortir à un moment donnée de sortir de la boucle.

Par exemple, le code suivant lancera un programme qui ne s'arrêtera jamais :

1
2
3

n = 5
while (n > 0):
  print n

Le problème est que la valeur de n ne change pas, et donc la condition n > 0 est toujours vérifiée, la boucle ne se finit jamais.

Pour corriger, il faut qu'à un moment donné n devienne négatif ou nul, voici un exemple de solution :

1
2
3
4

n = 5
while (n > 0):
  print n
  n = n - 1

La valeur de n baisse d'un cran à chaque fois que la boucle s'exécute, et atteindra un moment ou un autre 0.

D'ailleurs, combien de fois va-t-on avoir un résultat affiché dans le code ci-dessus ?

La boucle FOR

La boucle FOR peut-être vue comme un cas particulier d'une boucle while : il s'agit des cas pour lesquels on a une incrémentation simple.

Elle est surtout pratique lorsque l'on désire parcourir les éléments d'un objet ( par exemple afficher chaque élément d'une liste ) ou lorsque l'on sait précisément le nombre de fois que les instructions doivent être répétées ( par exemple afficher les 15 premiers nombres entiers ).

Sa syntaxe est ( pour le parcourt d'un objet, qui peut être une liste ou une chaine de caractères, etc... ) :

1
2
3
4
5
6

for element in objet :
  instruction 1
  instruction 2
  ...
  instruction n
# retour à la ligne pour la suite du programme

"element" est une variable qui n'est valable que dans la boucle for et qui parcourt chaque élément de "objet".

Par exemple, pour afficher chaque élément de la liste "maliste" :

1
2

for element in maliste:
  print element

Deux lignes !

Pour une incrémentation fixée :

1
2
3
4
5

for n in range(nombre) :
  instruction 1
  instruction 2
  ...
  instruction n

range est une fonction qui créée une liste de nombre, par exemple :

range(8)

va afficher :

[0, 1, 2, 3, 4, 5, 6, 7]

Donc "n" est une variable qui va parcourir tous les éléments dans la liste de nombre créée par range(nombre).

On peut reprendre l'exemple de l'affichage des 15 premiers nombres pour illustrer cela :

1
2

for n in range(15):
  print n + 1

Synthèse sur les variables

Rappel : Pour connaitre le type d'une variable var, on utilise l'instruction type :

type(var)

INT et LONG

Le type INT représente les nombres entiers de -2147483648 à +2147483648 ( 32 bits ). Si cet intervalle est trop limité pour les calculs prévus, on peut plutôt utiliser le type LONG, pour les nombres entiers sans limitation, enfin disons la limitation de mémoire de l'ordinateur.

FLOAT

Il s'agit des nombres réels, enregistrés sur 64 bits, donc pour les réels de -10^308 à 10^308, avec 12 chiffres significatifs. On fait la différence avec un entier par le point, qui correspond chez nous à la virgule :

3.14
10.
.0000001
15e100
15e-100

STRING

Le type STRING correspond aux chaines de caractères. Les caractères doivent être écrits entre des guillemets ( doubles ou simples ) :

phrase='test'
phrase="test"
phrase="c\'est un test\n"

len(phrase)

• concaténation : c'est-à-dire mettre deux chaines de caractères bout à bout, à l'aide du signe +
• répétition : répéter une chaine de caractères en la "multipliant" par un entier, à l'aide du signe *

LES LISTES

Comme son nom l'indique, une liste est une liste d'objets ou de variables, séparés par une virgule. Par exemple :

liste=[2,5.,"1324","test"]

>>>liste[2]
1324

>>>liste[0:2]
[2,5.]

liste.remove(liste[n])

liste.remove(element)

liste.append("juin")

liste[3:3]=["juin"]

liste[4:]=["hiver"]

• Addition : liste1 + liste2, concaténation de deux listes, l'une à la suite de l'autre.
• Multiplication : liste * 5, création d'une nouvelle liste contenant 5 fois la répétition des éléments de la liste.

liste=chaine.split()

liste=chaine.split(",")

LES BOOLEENS

Ces variables sont un peu particulières, et pourtant nous les avons déjà si souvent utilisées ! ( intrinsèquement ).

Ce sont des variables qui ne peuvent prendre que deux états, typiquement True ou False.

Pour les instructions conditionnelles de type if, ou les boucle while, le déclencheur était toujours un booléen de type True ( les commandes de ces structures sont amorcées si la condition est Vraie ).

Nous pouvons vérifier cela rapidement à l'aide de la console python et de code élémentaire :

1
2
3
4
5
6
7
8
9
10
11
12
13
14

>>> a = 3<5
>>> print a
True
>>> if a:
       print "BRAVO !"
 
BRAVO !
>>> b = 3>5
>>> print b
False
>>> if b:
       print "BRAVO AUSSI !"
 
>>>

Dans l'exemple ci-dessus, je définis les variables a et b par des affirmations, qui sont vraies ou fausses. Ce sont donc des variables de type booléen, et on voit leur influence sur des structures conditionnelles.

On peut convertir des nombres, des chaines de caractères et des listes en booléens, via la fonction bool() :

1
2
3
4
5
6
7
8
9
10
11
12

>>> bool(0)
False
>>> bool(17.2)
True
>>> bool('')
False
>>> bool('a')
True
>>> bool([])
False
>>> bool([1,2,3])
True

En gros, il faut retenir que tout ce qui n'est pas "vide" est "vrai".

Test d'appartenance

Une manière classique de générer des booléens se fait à l'aide du mot-clé in, pour tester l'appartenance d'une chaine de caractères dans une autre, ou d'une liste dans une autre. On a déjà rencontré ce mot clé dans les boucles de type for.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

>>> if 'e' in 'merci':
...     print "OUI !"
...
OUI !
>>> if 'erc' in 'merci':
...     print "OUI !"
...
OUI !
>>> if 'a' in 'merci':
...     print "OUI !"
...
>>> if 'abc' in [1, 5.2, 'efg', 'abc', -78.6 ]:
...     print "OUI !"
...
OUI !
>>> if 'cba' in [1, 5.2, 'efg', 'abc', -78.6 ]:
...     print "OUI !"
...
>>> if 5.2 in [1, 5.2, 'efg', 'abc', -78.6 ]:
...     print "OUI !"
...
OUI !

Quelques opérations entre booléens :

Il existe également des opérations entre les booléens, mais on commence à entrer dans des éléments de logique qui ne sont pas toujours simples à appréhender :

La négation :

>>> not True
False

La conjonction ( on obtient True si et seulement si les deux éléments sont True, traduit communément par le "ET" ) :

>>> True and False
False
>>> True and True
True

La disjonction ( on obtient True si l'un au moins des deux éléments est True, traduit communément par le "OU" ) :

>>> True or False
True
>>> False or False
False
>>> True or True
True

Pour plus d'informations, voir l'article Wikipédia sur l'algèbre de Boole.

1
2

while liste:
	liste.remove(liste[0])

Utilisation de modules

Principe

Un module est une collection de fonctions, en général regroupées suivant un même thème.

Pour rappel, input() et raw_input() sont des fonctions de base du langage python permettant de récupérer des entrées utilisateurs.

Donc pour éviter que chaque programmeur réécrive à chaque fois des fonctions utiles à tous, on les enregistre sous forme de module.

Imaginons par exemple que nous ayons besoin de calculer la racine d'un nombre dans plusieurs programmes. Il faudrait pour chaque programme redéfinir la fonction racine(). Si on cherche ( un tout petit peu... ), on se rend compte qu'une telle fonction existe déjà dans le module math, sous le nom sqrt() ( square root de l'anglais qui signifie racine carrée ).

Donc plutôt que de réinventer la roue, il suffit d'importer la fonction sqrt() du module math là où on en a besoin. Pratique !

Importation

D'où la question : comment importer une fonction d'un module ou même un module complet ?

Il y a plusieurs possibilités :

from math import sqrt

qui va importer simplement la fonction voulue. Dans toute la suite du programme, on pourra alors appeler directement la fonction :

>>> sqrt(5)
2.2360679774997898

Si on doit importer plusieurs fonctions ou constantes, il suffit de les séparer par une virgule :

from math import sqrt, pi, cos, exp

ou pour tout importer d'un coup ( et je répète, cela va importer toutes les fonctions du modules et rendre le programme peut-être inutilement lourd ) :

from math import *

Il existe une manière plus courte d'importer toutes les fonctions d'un module :

import math

MAIS ! Il faut bien noter que l'utilisation des fonctions avec cette syntaxe est très différentes, car pour l'appel des fonctions il faut préciser le nom du module en premier lieu :

>>> math.sqrt(5)
2.2360679774997898

Cette notation peut sembler plus lourde, mais permet tout de même une syntaxe plus claire à l'intérieur du code : on sait exactement à quel module appartient une fonction en lisant le code.

Quelques modules que nous utiliserons

• math : comme décrit plus haut, ce module permet d'utiliser les fonctions et constantes classiques en math : les fonctions trigonométriques ( cos(), sin(), tan(), etc...), fonction racine ( sqrt() ), les nombres pi et e, les logarithmes et exponentielles ( log(), log10(), exp() ), partie entière et partie fractionnaire ( modf() ), valeur absolue( abs() et fabs() ), etc....

• random : offre tout un panel de fonctions pour générer des nombres de manière aléatoire. Par exemple, la fonction randint(a,b) qui rend un nombre entier compris entre a et b :
  

  >>> randint(1,10)
  5

  
  ou random() qui renvoit un nombre réel compris entre 0 et 1 :

  >>> random()
  0.39041964805607265

• time et datetime : modules permettant la gestion du temps et des dates, avec des conversions, calculs, etc...
  Pour plus d'infos : page officielle de time et page officielle de datetime ( pages en anglais ).

• Tkinter : pour générer une interface graphique rapidement et simplement à vos programmes. Quelques exemples sont traités dans la dernière page de cette introduction.

• re : pour le traitement des expressions régulières. Je ne vais expliquer en détail ce que sont les expressions régulières, simplement me cantonner à dire qu'il s'agit de chercher/remplacer un motif dans une chaine de caractères ( par exemple pour vérifier dans un formulaire si une adresse email a été rentrée correctement ). On utilise en général les fonctions split() ( pour couper une chaine à chaque motif trouvé ) ou match() ( pour chercher un motif ). Pour plus d'infos : page officielle ( page en anglais ).

Structure fonctionnelle

Les structures en while et for permettent aisément d'effectuer des tâches répétitives.

Par contre, pour effectuer une même série de tâches à des endroits différents du programme, il faudrait copier ce code plusieurs fois.

Pour illustrer ces propos, voici un petit programme destiné à chercher le maximum parmi trois listes de nombres entrées successivement par l'utilisateur, sachant qu'il est obligatoire de donner le max de chaque liste :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

liste1 = input('Entrez une première liste de nombres :\n')
 
max1 = liste1[0]
for element in liste1:
  if element > max1:
  max1 = element
 
print max1
 
liste2 = input('Entrez la seconde liste de nombres :\n')
 
max2 = liste2[0]
for element in liste2:
  if element > max2:
  max2 = element
 
print max2
 
liste3 = input('Entrez la troisième liste de nombres :\n')
 
max3 = liste3[0]
for element in liste3:
  if element > max3:
  max3 = element
 
print max3
 
liste_resultat = [max1, max2, max3] 
 
max = liste_resultat[0]
for element in liste_resultat:
  if element > max:
  max = element
 
print max

La recherche du max d'une liste est réutilisée plusieurs fois : 3 fois pour les listes utilisateur, et 1 fois pour le résultat global.

Bon d'accord, on peut faire un algorithme plus rapide pour ce programme, mais ce n'est pas l'objet de la discussion .

On pourrait synthétiser un peu en utilisant les fonctions : une fonction permet précisément d'effectuer une série d'action, à l'aide d'un ou plusieurs paramètres d'entrée, et "retourne" le résultat à l'aide de l'instruction return.

La définition d'une fonction se fait à l'aide de l'instruction def, suivie du nom de la fonction, et de la liste des paramètres entre parenthèses.

Dans ce cas là, notre fonction, qui va calculer le max d'une liste de nombres, aura comme entrée une liste, que l'on peut nommer comme on veut, et aura pour sortie un nombre, le maximum de la liste donnée :

1
2
3
4
5
6

def cherche_max_liste(maliste):
  max = maliste[0]
  for element in maliste:
    if element > max:
      max = element
  return max

Encore une fois, il faudra bien respecter la syntaxe avec ":" et l'indentation.

Du coup, notre programme devient :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

def cherche_max_liste(maliste):
  maximum = maliste[0]
  for element in maliste:
    if element > maximum:
      maximum = element
  return maximum
 
liste1 = input('Entrez une première liste de nombres :\n')
 
print cherche_max_liste(liste1)
 
liste2 = input('Entrez la seconde liste de nombres :\n')
 
print cherche_max_liste(liste2)
 
liste3 = input('Entrez la troisième liste de nombres :\n')
 
print cherche_max_liste(liste3)
 
liste_resultat = [max1, max2, max3] 
 
print cherche_max_liste(liste_resultat)

La fonction est définie avant son appel.

Les variables définies dans la fonction cherche_max_liste sont locales, c'est-à-dire qu'elles n'existent pas en dehors de cette fonction et ne risque pas de modifier les autres variables contenues dans le programme :

1
2
3
4
5
6
7
8
9

r = 5
 
def test():
  r = 18
  return r
 
print "Dans la fonction, r = ", test()
 
print "A l'extérieur, r = ", r

Voici le résultat du programme :

1
2

Dans la fonction, r =  18
A l'extérieur, r =  5

Par contre, si on définit la variable r comme globale dans la fonction ( à l'aide du mot clé global ) :

1
2
3
4
5
6
7
8
9
10

r = 5
 
def test():
  global r
  r = 18
  return r
 
print "Dans la fonction, r = ", test()
 
print "A l'extérieur, r = ", r

Alors on obtient :

1
2

Dans la fonction, r =  18
A l'extérieur, r =  18

1
2
3

from time import ctime
 
print "Démarrage du programme à ", ctime()

1

print "Fin du programme à ", ctime()

Un peu de dessin avec le module Turtle

Le module Turtle est un module pour effectuer un peu de dessin. Ne vous attendez pas à des animations 3D époustouflantes, si j'en parle, c'est simplement pour entraîner les bases de la programmation, cela changera un peu des exercices purement mathématiques.

Le dessin se fait par le biais d'une flèche, que je vais plutôt appeler "curseur", et qui se comporte comme un stylo auquel on donne des ordres, sous forme de commandes ( on voit là une magnifique ligne rouge en train d'être tracée :) ) :

Fonctions de base du module

Comme pour chaque module, il faut commencer par son importation :

from turtle import *

Puis on donne les instructions.

Plutôt que de m'étendre sur des explications qui n'amélioreraient pas forcément la compréhension, je préfère commencer par un exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from turtle import *
color('red')
forward(200)
left(90)
color('black')
forward(50)
right(150)
color('blue')
forward(300)
up()
goto(-100,-100)
down()
color('green')
width(5)
forward(100)
raw_input() ## Pause obligatoire pour observer le chef d'oeuvre

Arrivé à ce point, si vous avez compris le sens de l'instruction "forward", ainsi que son paramètre, vous comprendrez aisément le sens de l'instruction "backward" ainsi que son utilisation. Ce qui peut encore paraitre un peu flou, ce sont les instructions "up" et "down". Si c'est le cas, n'oubliez pas ma première remarque : le curseur se comporte comme un stylo...

Voici maintenant une liste des instructions de base :Turtle dans le tuto de Gérard Swinnen.

Pour une documentation plus complète, il faut évidemment voir l'officielle en anglais : Documentation officielle Turtle.

Il est temps de tester tout ça :

Constructions répétitives

Vous vous êtes maintenant un peu amusé à dessiner quelques figures de base, et je ne sais pas comment vous vous y êtes pris.

Pour dessiner l'escalier, avez-vous dessiner chacune des marches une à une ? Ou avez-vous trouvez une autre méthode plus rapide ?

Si non, comment vous y prendriez-vous pour dessiner un polygone régulier à 30 côtés ? ou à 120 côtés ? ( cela dit, avec turtle, ce dernier ressemblerait plutôt à un cercle ).

Il faut bien sûr penser à utiliser les boucles pour les séquences d'instructions répétitives.

Eviter le superflux avec une meilleure structure

Dans la dernière question de l'exercice précédent, il fallait dessiner des carrés de tailles identiques, ce qui a pour avantage de ne pas demander de modifications dans le code du dessin du carré en soit. Les choses se compliquent nettement si je décide de dessiner une suite de carrés en alternance avec des étoiles et des triangles, le tout avec des tailles différentes à chaque fois, suivie de carrés imbriqués, puis d'une colonne d'étoiles de tailles différentes.

Il faudrait créer trois boucles :

• une pour la suite de figures en alternance,
• une pour la suite de carrés imbriqués,
• une pour la colonne d'étoiles.

Dans la première boucle seraient définies les constructions du carré, de l'étoile et du triangle équilatéral. Dans la seconde boucle, il faudrait redéfinir la construction du carré, et enfin dans la 3e boucle, celle de l'étoile. Cela rend le code inutilement long et très confus.

Vous aurez compris où je veux en venir : l'utilisation de fonctions permettrait largement de pallier à tous ces inconvénients.

En effet, il suffit de créer une fonction Carre ( dépendante d'un paramètre, je vous laisse deviner lequel ), une fonction Etoile ( également dépendante d'un paramètre ) et une fonction TriangleEquilateral ( dépendante d'un paramètre ), et d'appeler ces fonctions à chaque qu'on a besoin de dessiner les éléments cités. Pour la création de fonctions, je vous renvoie au paragraphe concernant la Structure fonctionnelle.

Les trois boucles dont nous aurions besoin bénéficieraient alors d'une belle cure de minceur, et nous pourrions réutiliser tous ces dessins sans avoir à les redéfinir ailleurs.

Le module Tkinter

Tkinter est un module permettant de réaliser une interface graphique simple pour un programme python.

Il existe de nombreux autres modules à cet effet, mais qui peuvent paraitre complexes pour une introduction à python.

Evidemment, la première chose à faire pour utiliser les fonctions du module Tkinter, c'est d'importer de l'importer dans le script :

from Tkinter import *

Pour bien comprendre la suite, il faut se familiariser un peu avec la notion d'objet.

Oui, oui, c'est bien le même mot que celui qui apparait dans l'expression "Programmation Orientée Objet", mais nous n'allons pas aller aussi loin.

Si nous voulons programmer une interface graphique à notre programme, il va falloir définir un objet fenêtre, que je vais nommer mafenetre.

Heureusement, Tkinter permet de définir cet objet très simplement, en effet, il suffit d'écrire :

mafenetre = Tk()

Voilà, mon objet fenêtre est maintenant créé, et enregistré sous le nom mafenetre.

Maintenant, il y a un certain nombre de méthodes qui peuvent s'appliquer à cette objet, comme par exemple une méthode pour quitter la fenêtre, ce qui s'écrit par exemple :

mafenetre.quit()

D'une manière générale, pour appliquer une méthode à un objet, la syntaxe à respecter est la suivante ( ne pas oublier le point ! ) :

objet.methode()

Dans les parenthèses, on peut préciser les options, ou on laisse vide comme dans l'exemple ci-dessus.

Une fois cela de compris, on peut à nouveau appliquer ce principe pour créer de nouveaux objets dans la fenêtre mafenetre. On peut notamment créer des bouton ( objet Button ), afficher un texte ( objet Label ), récupérer des données de l'utilisateur ( objet Entry ), faire des dessins ( objet Canvas ), etc...

On peut créer autant d'objets que l'on veut dans une fenêtre, mais d'un point de vue pratique, on évite bien sûr de surcharger le tout...

Le seul point important pour chacun de ces objets est de les placer dans la fenêtre mafenetre, sinon ils n'apparaitront pas, ou peut-être même que le script ne se lancera pas.

Il existe pour cela la méthode .pack() et la méthode .grid(). Ma préférence va à la seconde.

Voyons cela avec un exemple ( tout ce qui suit les ######### sont des commentaires qui ne seront pas interprétés par le script ) :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from Tkinter import * ######### Importation du module Tkinter pour créer des fenêtres
 
mafenetre = Tk() ######### Création d'une nouvelle fenêtre, appellée mafenetre
 
######### Création d'un « Label » dans mafenetre pour afficher le texte avec couleur de texte ( foreground ) noire
######### et un fond ( background ) jaune. Ce Label s'appelle montexte.
 
montexte = Label(mafenetre, text='Hello !', fg = 'black', bg='yellow')
 
######### Affichage de « montexte » avec la méhode .grid(), dans la ligne 0, colonne 0 et à gauche ( West ).
######### La création ne suffit donc pas pour l'afficher.
 
montexte.grid(row = 0, column = 0, sticky = W)
 
######### Création et affichage d'un bouton pour fermer la fenêtre.
######### Remarquer la commande mafenetre.quit, on aurait pu mettre n'importe quel nom de fonction à la place.
 
monbouton = Button( mafenetre, text='Quitter', command=mafenetre.quit)
monbouton.grid(row = 1, column = 1, sticky = E)
 
######### Enfin, lancer la boucle de réception des événements de fen ( c'est-à-dire l'activer par rapport au
######### clic, au texte clavier, etc... ). Indispensable.
 
mafenetre.mainloop()

Ce script est un tout petit exemple, et peut-être qu'en lisant le code, vous aurez compris ce qu'il se passe : le lancement ouvre une petite fenêtre affichant un magnifique texte noir sur fond jaune ( Hello ! ), avec un bouton "Quitter".

Tout simplement extraordinaire.

Bon, pour rester sérieux, bien observer les options de création de chaque objet ( Button et Label ) et chaque option utilisées dans la méthode .grid() pour comprendre le positionnement.

Cela ne devrait pas trop poser de problèmes.

Le dernier point important, est l'extension du script. Jusqu'à maintenant, nous avons toujours enregistré nos scripts en .py. Pour une interface graphique, on le fera en .pyw ( je vous laisse deviner ce que signifie le "w" ). Si on met une extension .py, le programme s'ouvrira avec une fenêtre DOS en arrière plan. Si c'est pratique pour obtenir les messages d'erreurs pour débugger le programme, ce sera désagréable pour l'utilisateur.

Voici un lien vers un site qui propose des screenshots des différents objets habituellement utilisés avec Tkinter : Gnuprog - Tkinter

Un autre lien vers une liste complète des widgets ( ou objets ) ainsi que leurs options, en anglais, au format html ou pdf, issu du site officiel :

• format html
• format pdf

Remarque : Attention au copié-collé du code sur le site. Ici le langage HTML ne reproduit pas les bonnes indentations qui sont essentielles au code python.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# -*- encoding: iso-8859-15 -*-
 
from Tkinter import *
 
def factorielle():
n = int(input1.get())
i = 1
while n > 0:
i *= n
n = n - 1
 
texte = "Le résultat est : " + str(input1.get()) + "! = " + str(i)
 
resultat = Tk()
 
texte1 = Label(resultat, text=texte, fg = 'white', bg='black')
texte1.grid(row = 0, column = 1, sticky = W+E, ipadx = 5, ipady = 5)
 
bouton1 = Button(resultat, text='Quitter', command=resultat.quit, bg='red', fg='white')
bouton1.grid(row = 1, column = 2, sticky = E)
 
fenetre = Tk()
 
texte1 = Label(fenetre, text='Entrez le nombre dont vous voulez calculer la factorielle', fg = 'black')
texte1.grid(row = 0, column = 0, sticky = W)
 
input1 = Entry(fenetre, fg='purple', bg='light blue')
input1.grid(row = 1, column = 1, sticky = W+E, ipadx = 5, ipady = 5)
 
bouton = Button( fenetre, text='Calculer', command=factorielle, bg='light green', fg='blue')
bouton.grid(row = 3, column = 1, sticky = W)
 
bouton2 = Button( fenetre, text='Quitter', command=fenetre.quit, bg='red', fg='white')
bouton2.grid(row = 3, column = 2, sticky = E)
 
fenetre.mainloop()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

# -*- encoding: iso-8859-15 -*-
 
from Tkinter import *
from tkFont import *
 
def factorielle(nb):
prod = 1
while ( nb > 1 ):
prod = prod * nb
nb = nb - 1
return prod
 
 
def combinaison(nb, total):
return factorielle(total) / ( factorielle(nb) * factorielle(total - nb) )
 
 
def pascal(event):
k = int(input1.get())
texte = ""
j = 0
while ( j <= k ):
i = 0
while ( i <= j ):
texte = texte + " " + str(combinaison(i,j))
i = i + 1
texte = texte + "\n\n"
j = j + 1
blabla.configure(text = "Voici le triangle de Pascal jusqu\'à " + str(k) + "\n", fg='yellow', bg='gray', font=("Times", "24", "bold italic"))
resultat.configure(text = texte, fg='green', bg='black', font = ("Times", "16"))
 
fenetre = Tk()
 
texte1 = Label(fenetre, text='Afficher le triangle de Pascal jusqu\'a combien ?', fg = 'black')
texte1.grid(row = 0, column = 1, sticky = W+E)
 
input1 = Entry(fenetre, bg='white', fg='red')
input1.bind("<Return>", pascal)
input1.grid(row = 1, column = 1, sticky = W+E, ipadx = 5, ipady = 5)
 
blabla = Label(fenetre)
blabla.grid(row = 2, column = 1, sticky = W+E, ipadx = 5, ipady = 5)
 
resultat = Label(fenetre)
resultat.grid(row = 3, column = 1, sticky = W+E, ipadx = 5, ipady = 5)
 
bouton2 = Button( fenetre, text='Quitter', command=fenetre.quit, relief='groove')
bouton2.grid(row = 4, column = 2, sticky = W)
 
fenetre.mainloop()

Quelques remarques à propos de la solution proposée :

• On importe au début le module tkfont pour s'amuser un peu les l'affichage des polices ( analyser le code pour comprendre où ),
• les trois fonctions définies au début sont celles que nous avions déjà rencontré dans l'exercice sur le triangle de Pascal, il y a une grosse différence dans la définition de la fonction pascal, que j'expliquerai plus tard,
• comme d'habitude, les fonctions ne sont pas lancées tant qu'on ne les appelle pas, donc après l'importation des modules, la première chose qui sera effectuée sera de construire la fenêtre,
• on définit donc une fenêtre contenant un widget d'entrée pour l'utilisateur, deux widgets Label pour l'affichage de texte et de la réponse, et un widget bouton pour quitter le programme,
• une action est reliée à la fenêtre d'entrée grâce à la méthode .bind : dès que l'on appuie sur la touche entrée ( <Return> ), le programme "pascal" est lancé. On aurait très bien pu concevoir le programme avec un bouton pour lancer la fonction "pascal". Pour que l'événement sur la touche entrée soit "actif", il FAUT que l'argument de la fonction pascal soit "event",
• nous avons ajouté dans la fonction pascal les lignes "blabla.configure(...)" et "resultat.configure(...)". La méthode .configure permet de reconfigurer les widgets, et ici en l'occurrence de mettre à jour les textes des labels blabla et resultat.

Un dernier point que j'aimerais aborder : comment insérer une image ?

On peut pour cela utiliser le widget Canvas et la classe PhotoImage qui permet d'importer des images. Le seul problème, c'est que l'on est restreint sur le choix des extensions : cela ne fonctionne pas avec jpg et png, mais avec gif ( pour jpg et png, il faudra utiliser par exemple le modul PIL ).

Une fois une fenêtre "fenetre" créée avec Tk(), on y créé un widget canvas, on créé un objet image associé à l'image qui se nomme 1.gif grâce à la fonction PhotoImage et on importe cette image dans le canvas grâce à la méthode .create_image :

can = Canvas(fenetre, width=800, height=600, bg='#07e0e3')
maphoto = PhotoImage(file='1.gif')
photo=can.create_image(400,300, image=maphoto)
can.grid(row = 1, column = 1, sticky = W+E)

Si l'on veut changer l'image dans le canvas, on peut utiliser la méthode .itemconfigure.

Quelques exercices de synthèse

Chacun des exercices peut être fait avec ou sans interface graphique, le but étant que chacun travaille à son niveau.

Les exercices sont de niveaux variés, et il n'y a pas de progression dans la difficulté.

Bon, là je vous sens super motivés, alors je donne encore des liens utiles pour assoiffer votre envie d'exercices :

• Exercices Python sur le site Calque : ou comment un professeur se donne des devoirs de vacances pour apprendre un nouveau langage. Comme il est sympa, il fournit les réponses.
• Le Projet Euler : quelques centaines de problèmes de type mathématiques à résoudre à l'aide de la programmation.
• Le challenge Python : je crois que tout est dit, bon courage...