Python est mon ami

Ludovic P INELLI

23 mai 2001
2

Copyright c 2001 Ludovic P INELLI.

Permission is granted to copy, distribute and/or modify this document under the terms
of the GNU Free Documentation License, Version 1.1 or any later version published
by the Free Software Foundation ; with the Invariant Sections being :
– Copyright,
– Avant-propos,
with the Front-Cover Texts being :
– Python est mon ami,
and with no Back-Cover Texts. A copy of the license is included in the section entitled
"GNU Free Documentation License".
Avant-propos

Ce document n’est pas un cours complet sur le langage Python, ni sur la program-
mation en général. Il ne se destine pas non plus à un public averti. Il faut plutôt le
considérer comme un didacticiel destiné aux personnes n’ayant jamais programmé.
J’ai essayé d’y mettre un peu d’humour pour rendre l’apprentissage plus vivant et
moins académique, tout en étant conscient que l’humour est une chose bien suggestive,
et qui plus est, difficile à faire passer par écrit... Veuillez donc excusez les fautes de
goût...
Python est l’un des langages les plus facile d’accès (Ruby peut être une bonne
alternative). Sa concision et sa puissance, permettent aux commençants d’adopter de
bonnes pratiques de programmation. Enfin, son orientation objet fait de lui une plate
forme idéal pour s’introduire dans le monde de langages plus difficiles comme le C++
ou le Java.
Comme vous le remarquerez, ce « didacticiel » est loin d’être terminé, il est même à
l’état d’ébauche si l’on considère le travail qu’il me reste à faire ! Je travaille dessus au
grè du temps qui m’est disponible (et de mon propre apprentissage de ce langage !)...
Toute remarque, suggestion, critique, insulte, sera évidemment bienvenue à l’une
des adresses suivantes (deux c’est mieux qu’une) :

ludovic.pinelli@free.fr
Pinelli.Ludovic@wanadoo.fr

Ce document est soumis aux termes de la GFDL (GNU Free Documentation Li-
cense). Vous avez donc le droit de le lire, de le distribuer, de le donner, de l’utiliser ou
de le brûler sans avoir à rien payer (les closes de la GFDL sont reproduites en annexe
B)...
Enfin, vous trouverez ce texte dans les formats suivants : html, ps, pdf, et dvi, le
tout issu du fichier source LATEX également disponible. Ils sont tous là :

http://ludovic.pinelli.free.fr/Python/Python_ami.html

Bonne lecture !

3
4
Table des matières

I Du basic ? Non, du Python ! 9

1 Je connais rien à la programmation ! 11

1.1 Quand on dit Python, on parle du serpent ? . . . . . . . . . . . . . . . 11
1.2 Python peut me sauver la vie... . . . . . . . . . . . . . . . . . . . . . 12
1.3 Si c’est si bien, ça doit coûter cher ! . . . . . . . . . . . . . . . . . . 13
1.4 Ça y est je l’ai ! Comment je le fait marcher ? . . . . . . . . . . . . . 13

2 Programmer : but de tout programmeur 17

2.1 Variation en Do mineur . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.1.1 variabilisons donc... . . . . . . . . . . . . . . . . . . . . . . 19
2.2 En fonction de quoi ? . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2.1 En français c’est quoi ? . . . . . . . . . . . . . . . . . . . . . 20
2.2.2 Et voilà, je fais une fonction en Python, sans complexe... . . . 20
2.2.3 Comment que j’fais pour l’utiliser c’te fonction ? . . . . . . . 22
2.2.4 A quoi ça sert puisque je peux taper mon calcul directement
dans l’interpréteur interactif Python ? . . . . . . . . . . . . . 23
2.3 Je te jure que c’est vrai ! . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3.1 L’if est un très bal arbre . . . . . . . . . . . . . . . . . . . . 24
2.3.2 Laissez lui vous poser les questions . . . . . . . . . . . . . . 26
2.3.3 Tant qu’il y aura Python, je ne serais plus seul... . . . . . . . . 27
2.3.4 Comment dit-il vrai ou faux ? . . . . . . . . . . . . . . . . . 27
2.4 Et si je ne veux pas qu’il continue ses bouclettes ? . . . . . . . . . . . 28
2.4.1 break-down ! . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.4.2 continuons je vous prie... . . . . . . . . . . . . . . . . . . . . 28
2.5 C’est tout ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.6 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Annexes 35

A Corrigés des exercices 35

A.1 Exercices de la partie I . . . . . . . . . . . . . . . . . . . . . . . . . 35
A.1.1 Petit exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . 35
A.1.2 Petit exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . 35
A.1.3 Petit exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . 37

5
6 TABLE DES MATIÈRES

B GNU Free Documentation License (GFDL) 39

B.1 Applicability and definitions . . . . . . . . . . . . . . . . . . . . . . 40
B.2 Verbatim copying . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
B.3 Copying in quantity . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
B.4 Modifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
B.5 Combining documents . . . . . . . . . . . . . . . . . . . . . . . . . 42
B.6 Collections of documents . . . . . . . . . . . . . . . . . . . . . . . . 43
B.7 Aggregation with independent works . . . . . . . . . . . . . . . . . . 43
B.8 Translation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
B.9 Termination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
B.10 Future revisions of this license . . . . . . . . . . . . . . . . . . . . . 44

Bibliographie 45

Index 46
Liste des tableaux

2.1 Opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . 25

7
8 LISTE DES TABLEAUX
 Première partie

Du basic ? Non, du Python !

9
Chapitre 1

Je connais rien à la
programmation !

Sommaire
1.1 Quand on dit Python, on parle du serpent ? . . . . . . . . . . . 11
1.2 Python peut me sauver la vie... . . . . . . . . . . . . . . . . . . 12
1.3 Si c’est si bien, ça doit coûter cher ! . . . . . . . . . . . . . . . . 13
1.4 Ça y est je l’ai ! Comment je le fait marcher ? . . . . . . . . . . 13

C’est pas grave, avec Python, c’est tout c..n (il faudra que je propose ce slogan qui
me parait pertinent). Il y a tout de même quelques connaissances de base à acquérir,
mais je vous rassure, elles sont peu nombreuses et pas difficiles.

1.1 Quand on dit Python, on parle du serpent ?

Pas du tout, on parle des Monty Pyhon, bien sûr (créateurs, entre autre, de La vie de
Brian, Monty Python Sacré Graal, la série des Monty Python’s Flying Circus, ...) ! Et
accessoirement du langage de programmation qui porte ce nom. En effet, Guido VAN
ROSSUM, qui inventa ce langage en 1989, aime beaucoup. Et vous aussi j’espère, parce
que sinon :
1. vous n’avez pas d’humour, ou vous n’aimez pas l’humour anglais, dans ce cas,
nous n’allons pas nous entendre ;
2. la majorité des exemples que vous trouverez sur le net pour ce langage font
référence aux séries ou aux films des Monty Pyhon.
Python est donc un langage de programmation, mais ça, vous le saviez déjà si vous
lisez ce texte. Mais de quel type de langage s’agit-il ? Car il en existe plusieurs. Certains
sont compilés, d’autres sont interprétés.
Pour les premiers, une fois que vous avez écrit le code, il faut un compilateur
qui le transforme en un langage que seul un ordinateur peut comprendre (le langage
machine), en faisant appel au linker qui s’occupe de rassembler les fichiers épars, ainsi
qu’au debugger qui vérifie la syntaxe. Résultat, vous obtenez un fichier exécutable qui
est votre programme. L’avantage est que le fichier obtenu est optimisé pour l’ordinateur
sur lequel il a été compilé, et, étant en code machine, ses performances sont très bonnes.

11
12 CHAPITRE 1. JE CONNAIS RIEN À LA PROGRAMMATION !

Les inconvénients sont que chaque fois que vous voulez tester la moindre fonctionnalité
de votre programme, il faut au préalable le re-compiler, et, bien sûr, ça ne fonctionnera
pas si l’ensemble du code n’est pas opérationnel, enfin, le fichier ne s’exécutera que
sur un ordinateur ayant le même SE 1 que le vôtre.
Les langages interprétés fonctionnent différemment. L’interpréteur interprète (ben
oui) directement le code que vous tapez sans que vous ayez à compiler quoi que ce
soit. L’avantage est clair : gain de temps, possibilité de tester une fonctionnalité en
temps réel, etc. L’inconvénient, c’est que pour faire fonctionner votre programme sur
une autre machine, il faut que l’interpréteur y soit installé.
Python fait partie de cette seconde catégorie. De plus, l’interpréteur Python peut
être installé sous de nombreux SE différents : Unix/Linux, WindowsXX, BeOS, Ma-
cintosh et j’en passe. Et bien sûr, vous n’avez pas à adapter votre code, ce sera le même
pour tous.

1.2 Python peut me sauver la vie...

Apprendre à programmer, c’est apprendre un langage de programmation. Or il en
existe plusieurs. Comme pour les langages parlés, ils n’utilisent pas les mêmes mots,
ceux-ci ne sont pas forcément placés dans le même ordre, mais dans tous les cas, il y a
au moins un sujet et un verbe. Alors pourquoi en apprendre un plutôt qu’un autre ?
Parce que si tous sont difficiles à maîtriser, certains sont faciles à apprendre. L’un
des plus facile s’appelle d’ailleurs Python (ça tombe bien). De plus, Python est totale-
ment orienté objet (si vous ne savez pas ce que cela veut dire, don’t worry), et peut donc
être une excellente passerelle pour aborder des langages comme le C++ ou le Java, en
vous évitant de prendre de mauvaises habitudes.
Vous avez certainement remarqué que certaines personnes parlent pour ne rien dire,
avec une multitude de fioritures, et il faut avoir un bon esprit de synthèse pour com-
prendre ce qu’ils veulent dire ; alors que d’autres parlent avec une clarté et une fluidité
exceptionnelle. Et bien Python fait parti de ces derniers (ça tombe encore bien).
Enfin pour bien programmer, il faut bien penser. En effet, si vous ne savez pas
exprimer clairement une idée, sa réalisation sera plutôt difficile et le code de votre
programme sera certainement très embrouillé (oh ! zut j’ai oublié de mettre telle fonc-
tionnalité, je vais la coller là et puis là et puis là aussi, je l’intégrerai plus tard dans le
programme... 2 jours plus tard : c’est quoi ce truc que j’ai mis là, ça a pas l’air d’être re-
lié à quelque chose, je l’enlève... voilà... Ah ! m..de c’était le truc que j’avais oublié...).
Heureusement, Python, de par son style clair et dépouillé, vous oblige à structurer vos
idées et vous les présente sous une forme très lisible. Moralité, Python vous apprend
à structurer votre façon de penser. Vos proches seront abasourdis de vous entendre ex-
primer vos points de vue philosophiques et métaphysiques avec une efficacité et une
justesse troublante ; votre patron vous donnera sa place tellement il sera impressionné
par vos facultés d’anticipation... Par contre, méfiez-vous de vos enfants, qui vous de-
manderont de rédiger à leur place leurs dissertations, de faire leurs devoirs de math, de
physique... Mais je crois que je m’éloigne du sujet (« Comment bien vivre la célébrité
dû à l’utilisation intensive de Python » sera le titre de mon prochain article).
En conclusion, Python vous aide à mieux vivre !
Alors, prêt à devenir ce nouvel être supérieur ? Il faut pour cela commencer par
apprendre...
1 SE : Système d’exploitation
1.3. SI C’EST SI BIEN, ÇA DOIT COÛTER CHER ! 13

1.3 Si c’est si bien, ça doit coûter cher !

C’est vrai que ça coûte un peu de temps d’investissement, comme quand vous ap-
prenez n’importe quoi. Sinon, côté pécunier, vous n’avez rien à dépenser. Python est
en effet un logiciel libre et librement distribuable (Python n’est pas sous license GPL,
mais son copyright est compatible avec celle-ci), ce qui veut dire qu’il est gratuit et
que vous pouvez même changer toutes ces fonctionnalités si vous le souhaitez puisque
vous avez accès à son code source (écrit en C). Vous n’avez donc qu’une chose à faire,
télécharger ou trouver sur un CD de magazine le fichier d’installation correspondant
à votre SE. Pour le téléchargement, rendez-vous donc là : www.python.org , centre
névralgique de la communauté Python.
Et si vous avez besoin d’aide ? Inutile de payer un expert, la communauté est là
pour vous aider gratuitement (sur le même site, vous trouverez toutes les FAQ, aides,
et listes de diffusion disponibles en différentes langues). Le seul engagement que vous
avez, est de faire de même avec les moins avancés que vous.

1.4 Ça y est je l’ai ! Comment je le fait marcher ?

Je ne m’étalerai pas sur l’installation de Python. D’une part, elle diffère suivant le
SE que vous utilisez, d’autre part, une documentation accompagnant le fichier l’ex-
plique très bien.
Pour démarrer Python, vous avez deux possibilités. Soit vous tapez python (ou
python2.0 oupython2.1 si c’est ce dernier que vous avez installé 2 ) sur une ligne
de commande (terminal Linux, fenêtre MS-DOS...), soit vous utilisez IDLE (qui s’ins-
tallera en même temps que Python), programme conçu par Guido VAN ROSSUM, per-
mettant, par exemple, la coloration automatique du texte, l’indentation automatique...
Dans les deux cas, vous devriez obtenir quelque chose qui ressemble à ceci :

Python 2.1b1(#1,May 5 2001, 17:47:43)

[GCC 2.95.2 19991030 (prerelease)] on Linux2
Type ‘‘copyright’’, ‘‘credits’’ or ‘‘license’’ for more informations.
>>>

Cela peut être différent suivant la version de Python que vous utilisez 3 , et votre
système d’exploitation.
Pour quitter l’interpréteur, utilisez Ctrl+D (ou Ctrl+X sous Windows), mais ce n’est
pas encore le moment !
Voilà, c’est tout, vous venez de démarrez l’interpréteur interactif Python, et vous
savez comment le fermer.
Les signes « >>> » indiquent que c’est à vous de jouer !
Vous pouvez d’ors et déjà taper des commandes qui seront directement exécutées.
Essayons tout de suite. Tapez :
2 Si vous utilisez Python 2.0 (ou 2.1), remplacez python par python2.0 (ou python2.1) chaque
fois que vous voyez cette commande dans le texte. Le choix de Guido VAN ROSSUM d’ajouter le numéro
de version, permet d’utiliser ou de tester vos programmes sur différentes versions antérieures ou futures de
Python.
3 La dernière version en date lors de l’écriture de ce texte est Python 2.1. Ne vous formalisez pas trop

sur la version car dans le développement de Python une grand importance est attachée à la compatibilité.
Ainsi, un programme écrit avec Python 1.5.2 (qui est une version très stable), fonctionnera parfaitement sous
Python 2.x. Toutefois, Python 2.x contient quelques nouveautés bien pratiques dont nous reparlerons dans un
chapitre qui lui sera consacré.
14 CHAPITRE 1. JE CONNAIS RIEN À LA PROGRAMMATION !

25 + 3

et appuyez sur la touche « entrer » de votre clavier. Miracle, Python a calculé pour
vous le résultat !
Les opérateurs + (addition) , - (soustraction) , * (multiplication) , et / (division) ,
sont bien sûr tous utilisables 4 . Nous en verrons d’autres par la suite.

Remarque concernant la lisibilité : Python se fiche comme d’une

gigne des espaces à l’intérieur d’une instruction, vous pouvez donc
écrire (25+3) comme ( 25 + 3) sans que ça ne change rien. Choi-
sissez le format le plus lisible possible, une expression telle que :

( 2 / (5 - 3) ) * (15 / 5)

est bien plus facile à lire que son équivalent :

(2/(5-3))*15/5

Vous pouvez vous essayer à d’autres calculs plus compliqués, et une fois que vous
aurez fini de jouer avec votre nouvelle calculatrice, nous pourrons passer à autre chose
(oui, oui, Python peut faire encore mieux !).
Le fait de taper quelque chose et d’avoir directement le résultat est très pratique
pour apprendre Python et pour tester des bouts de codes, mais en règle générale, ce
n’est pas ce que nous souhaitons. Nous aimerions plutôt un fichier qui pourra être
sauvegarder pour être réutilisé par la suite. Pour ce faire, vous écrivez votre code dans
n’importe quel éditeur de texte comme Emacs ou Vi sous Linux ou le bloc-note sous
Windows (Emacs est également disponible sous Windows...). La seule chose à faire est
de l’enregistrer avec l’extension .py. Vous pouvez aussi utiliser IDLE en ouvrant dans
celui-ci une nouvelle fenêtre (File | New Window ou Ctrl+X/Ctrl+N). Essayons tout de
suite. Ouvrez votre éditeur de texte favori et tapez ce qui suit :

print ‘‘Pour l’instant, je ne vois pas où il veut en venir...’’

print ‘‘j’espère que la suite sera plus intéressante~!’’

Maintenant, enregistrez ce fichier sous « prog.py ». Allez à la ligne de commande

(DOS, terminal Linux, terminal BeOS ou autre suivant votre SE), placez-vous dans le
répertoire où se trouve votre fichier nouvellement créé, et tapez python prog.py.
Vous devriez obtenir ceci :

Pour l’instant, je ne vois pas où il veut en venir...

j’espère que la suite sera plus intéressante~!

Et oui, c’est de la magie, et je vous assure que la suite sera encore plus intéressante
(d’ailleurs de quel droit vous permettez-vous de juger ce texte sans l’avoir lu jusqu’au
bout ?) !
4 Si vous utilisez la division de nombres entiers, vous verrez que Python ne donne pas les chiffres après la

virgule dans son résultat (ex : 5 / 2 = 2). Ceci est normal ! Il faut spécifier à Python que vous les voulez
en écrivant par exemple 5 / 2.0 ou 5.0 / 2 Ceci est dû au typage, notion que nous aborderons par la
suite.
1.4. ÇA Y EST JE L’AI ! COMMENT JE LE FAIT MARCHER ? 15

Bien, maintenant que nous savons démarrer Python, utiliser l’interpréteur interac-
tif, créer et exécuter des fichiers python, il ne nous reste plus qu’à apprendre à pro-
grammer...
16 CHAPITRE 1. JE CONNAIS RIEN À LA PROGRAMMATION !
Chapitre 2

Programmer : but de tout

programmeur

Sommaire
2.1 Variation en Do mineur . . . . . . . . . . . . . . . . . . . . . . 17
2.1.1 variabilisons donc... . . . . . . . . . . . . . . . . . . . . . 19
2.2 En fonction de quoi ? . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2.1 En français c’est quoi ? . . . . . . . . . . . . . . . . . . . 20
2.2.2 Et voilà, je fais une fonction en Python, sans complexe... . . 20
2.2.3 Comment que j’fais pour l’utiliser c’te fonction ? . . . . . . 22
2.2.4 A quoi ça sert puisque je peux taper mon calcul directement
dans l’interpréteur interactif Python ? . . . . . . . . . . . . 23
2.3 Je te jure que c’est vrai ! . . . . . . . . . . . . . . . . . . . . . . 24
2.3.1 L’if est un très bal arbre . . . . . . . . . . . . . . . . . . . 24
2.3.2 Laissez lui vous poser les questions . . . . . . . . . . . . . 26
2.3.3 Tant qu’il y aura Python, je ne serais plus seul... . . . . . . 27
2.3.4 Comment dit-il vrai ou faux ? . . . . . . . . . . . . . . . . 27
2.4 Et si je ne veux pas qu’il continue ses bouclettes ? . . . . . . . . 28
2.4.1 break-down ! . . . . . . . . . . . . . . . . . . . . . . . . 28
2.4.2 continuons je vous prie... . . . . . . . . . . . . . . . . . . 28
2.5 C’est tout ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.6 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.1 Variation en Do mineur

La première notion à connaître est celle de variable. Une variable est un emplace-
ment dans la mémoire de l’ordinateur où est stockée une valeur qui peut varier (d’où le
nom de variable !). Nous pouvons, par exemple, créer une variable (c’est-à-dire, réser-
ver une place dans l’ordinateur) que nous appellerions : total et dans laquelle nous
stockerions la somme de deux nombres.

17
18 CHAPITRE 2. PROGRAMMER : BUT DE TOUT PROGRAMMEUR

Une variable a un nom 1 (dans notre cas : total) et une valeur qui peut changer
au cours du déroulement du programme, par exemple, si nous écrivons ceci :

total = 5 + 2
total = 7 + 4

La valeur stockée par total à la première ligne est 7, qui est remplacée par 11 à
la deuxième ligne.
Les plus perspicaces d’entre vous auront peut-être remarqué que le signe « = » ne
correspond donc pas au signe mathématique. Car si total = 7 puis total = 11,
ça veut dire que total peut être différent de total ! En fait, le signe « = » est un
caractère d’affectation qui signifie « stocke ce qu’il y a à droite dans le truc à gauche ».
De même, les fins limiers auront vu qu’il n’est pas nécessaire de livrer quelque
chose de tout cuit (du style 7 ou 11) à la variable, car Python est capable de trouver le
résultat du calcul avant de le stocker dans la variable.
Si vous n’avez été ni perspicace ni fin limier, ne vous en faites pas, Python va vous
aider à le devenir.
Enfin, une variable peut stocker un entier, un nombre réel, un caractère, un mot, une
phrase... ce sont les types de valeur qu’elle peut prendre. Ici les langages de program-
mation diffèrent : dans le cas d’un langage dit « typé », il faut déclarer une fois pour
toute quel est le type de valeur que stockera la variable, et ça ne pourra pas changer de
tout le programme. Python, lui, fait cela pour vous, et ne vous demandera pas, comme
le ferait un douanier, ce que vous avez à déclarer avant de passer à votre programme !
On dit que Python est « typé dynamiquement » (il reconnaît le type des variables
au fur et à mesure que vous les entrez). Mais il faut tout de même savoir vous faire
comprendre de Python, si vous avez essayer 5 / 2 dans l’interpréteur interactif vous
vous êtes rendu compte que Python ne vous retourne que la partie entière du calcul
(vous allez voir que c’est d’ailleurs très pratique...). Pour pallier à cela, il faut écrire
5 / 2.0 ou 5.0 / 2 (ou même 5./2) pour prévenir Python que vous voulez un
chiffres réél comme résultat.
Enfin, Python possède des types très pratiques dont vous ne soupçonnez pas l’exis-
tence, mais ceci sera vu en temps utile. Pour vous mettre en bouche, voici tout de même
quelques types qu’il est possible d’utiliser dans une variables : les listes, les diction-
naires, les nombres complexes... si vous avez envie de savoir ce que sont ces types
lisez la suite (cette phrase utilise un procédé expérimental visant à tenir le lecteur en
haleine...).

Pourquoi il a dit que c’était pratique de n’avoir que la partie entière du chiffre
comme résultat ?... Modulez vos humeurs !
Vous n’oubliez jamais rien vous ! Bon d’accord, je m’explique. Il existe un autre
opérateur moins connu du commun des mortels qui se nomme « modulo » et qui s’écrit
avec le signe « % ». Cet opérateur permet d’avoir le reste de la division. Exemple :

>>> 5 / 2
2
1 Les noms de variables peuvent être constitués de n’importe quel caractère non accentué. Ils ne peuvent

pas commencer par des chiffres mais peuvent en contenir (ex : variable1) ni ne peuvent contenir d’es-
pace. Par contre, elles peuvent commencer et contenir le caractère « _ » (AltGr+8) (ex : _variable ou
ma_variable). Enfin, Python est sensible à la casse (majuscules/minuscules), ainsi mavariable et Ma-
Variable sont deux variables différentes.
2.1. VARIATION EN DO MINEUR 19

>>> 5 % 2
1
Pour retrouver vos souvenirs d’école vous pouvez pensez comme ceci : « Dans 5
combien il y a de fois 2 : 2 fois, il reste 1 ».
En quoi c’est pratique ? Et bien si vous voulez savoir si 4736 est divisible par 37, il
vous suffit d’écrire :
>>>4736 % 37
0
Étant donné qu’il ne reste rien, c’est que 4736 est divisible par 37. Vous allez me
dire qu’il vous suffisez de faire 4736 / 37.0 pour savoir... Ok, pour cette fois, mais
nous verrons qu’il y a des cas ou ce n’est pas si simple (lisez la suite... lisez la suite...
lisez la suite... lisez la suite... lisez la suite...)

2.1.1 variabilisons donc...

Vous pouvez d’ors et déjà utiliser vos nouvelles connaissances avec l’interpréteur
interactif. Au lieu de taper 352 + 27, puis de recopier le résultat pour le multiplier
par 54, puis de recopier ce dernier résultat pour lui soustraire votre premier calcul, ce
qui donnerait :

>>>352 + 27
379
>>>379 * 54
20466
>>>20466 - 379
2087

Vous pourriez utiliser les variables :

>>>total1 = 352 + 27
>>>total2 = total1 * 54
>>>total2 - total1
2087

Je vous le dis, votre calculatrice ne peut pas rivaliser avec Python !

Vous pouvez aussi vous essayer aux chaînes de caractères, pour cela, il suffit d’uti-
liser les guillemets, par exemple :

>>>Prenom = ’’Chevalier’’
>>>Nom = ’’ qui dit Ni’’
>>>dit = ’’ Ni‘‘
>>>Prenom + Nom + dit * 10
’Chevalier qui dit Ni Ni Ni Ni Ni Ni Ni Ni Ni Ni Ni’

Comme vous pouvez le remarquez, le signe + « concatène » plusieurs chaînes de

caractères (il les place les unes à côté des autres (sans ajouter d’espace)), alors que le
signe * répète une chaine autant de fois que précisé.
Mais nous en apprendrons plus sur les différentes utilisations des types et de leurs
opérateurs un peu plus tard... (deuxième procédé expérimental pour affirmer l’emprise
du texte sur le lecteur...)
20 CHAPITRE 2. PROGRAMMER : BUT DE TOUT PROGRAMMEUR

« _ » Une variable un peu spéciale En effet, la variable _ (AltGr+8) stocke le ré-

sultat du dernier calcul fait en mode interactif . Nous pourrions donc écrire l’exemple
que nous avions pris précédemment de cette manière :

>>>352 + 27
379
>>>_ * 54
20466
>>>_ - 379
2087

Surtout, ne vous dites pas : « Ce Python est incroyable ! », car si c’est le cas, vous
risquez de vous évanouir d’admiration en lisant la suite... (troisième procédé expéri-
mental, visant cette fois à faire croire au lecteur que je sais de quoi je parle...)

2.2 En fonction de quoi ?

Vous devez déjà vous sentir plus fort, mais ce n’est que le début... Passons mainte-
nant à une autre notion de base : les fonctions.

2.2.1 En français c’est quoi ?

Une fonction est simplement une suite d’instructions qui réaliseront une tâche spé-
cifique. On pourrait, par exemple, imaginer une fonction qui converti des mètres en
centimètres parce que ça, c’est super dur à calculer de tête !
Une fonction a un nom 2 (par exemple conversion), peut avoir des variables en
paramètres , c’est-à-dire, les données que nous allons lui envoyer et avec lesquelles elle
va travailler. Dans notre exemple, il faudrait une variable le chiffre en mètre
que tu vas expressément me convertir en centimètre (sauf que si
vous avez tout suivi et lu les notes de bas de page, ce nom de variable n’est pas valide).
Enfin, elle peut renvoyer un résultat (dans notre exemple, elle renvoie le résultat de la
conversion).
Notre exemple pourrait alors s’écrire ainsi :

fonction conversion (chiffre en mètre)

début des instructions
chiffre en centimètre = chiffre en mètre x 100
renvoi du chiffre en centimètre
fin des instructions
...suite du programme...

Sauf que là nous l’avons écrit en français et pas en Python. Mais ce n’est pas très
différent.

2.2.2 Et voilà, je fais une fonction en Python, sans complexe...

Voici à quoi ressemble notre fonction en Pythonien :
2 Les règles pour les noms de fonctions sont les même que pour les noms de variables.
2.2. EN FONCTION DE QUOI ? 21

def conversion( chiffre_m ):

chiffre_cm = chiffre_m * 100
return chiffre_cm
#...suite du programme...

Qu’avons nous ici :

– Le mot def correspond à ce qu’en français nous avions appelé « fonction », il
signifie « je déf -ini une fonction » ;
– conversion est le nom de notre fonction « conversion » (ben oui !). Bien sûr
vous pouvez choisir le nom que vous voulez ;
– (chiffre_m) est le paramètre « chiffre en mètre » que nous passons à notre
fonction. Celui-ci est, bien sûr, une variable. Remarquez qu’un paramètre se
met entre parenthèses. D’ailleurs, même si notre fonction n’avait pas besoin
d’argument (synonyme de paramètre), il faut quand même mettre les paren-
thèses, cela distingue clairement une fonction d’une variable (par ex : conversion()
est une fonction, alors que conversion est une variable. Ceci dit, il vaut mieux
éviter ce genre de confusion en mettant toujours des noms différents 3 ) ;
– Ensuite, viens une tabulation qui correspond à « début des instruction »
(très important, ne l’oubliez pas !) ;
– le signe « : » (deux points) est utilisé comme en français, c’est-à-dire, « ce qui
suit est la définition de ce que je suis » ;
– chiffre_cm = chiffre_m * 100 ; sur cette ligne est indiqué ce que fait
la fonction (ici, ça ne prend qu’une ligne, mais ce n’est pas une limitation !). Nous
avons introduit une nouvelle variable qui s’appelle chiffre_cm (« chiffre en
centimètre »). Dans cette variable sera stocké le calcul chiffre_m * 100, ou
pour parler plus « programmationniquement », le résultat du calcul chiffre_m
* 100 sera affecté à la variable chiffre_cm (le “=” étant le caractère d’af-
fectation, comme vous le savez déjà sauf si vous n’avez pas lu la partie précé-
dente, et dans ce cas, je ne vois pas ce que vous faites ici !)
– return signifie, en anglais, « retourne ». Donc, return chiffre_cm, veut
dire « retourne maintenant le résultat à celui qui te l’a demandé, et plus vite que
ça ». Notez que quand l’instruction return intervient, on sort obligatoirement
de la fonction. Dans le code qui suit, par exemple, le calcul ne sera jamais effec-
tué, puisqu’au premier return (qui ne renvoi rien), la fonction s’arrête :
def conversion( chiffre_m ):
return
chiffre_cm = chiffre_m * 100
return chiffre_cm
Enfin, return n’est pas obligatoire. Il est par exemple inutile dans une fonction
qui ne sert qu’à afficher quelque chose 4 .
– Enfin, viens la suite du programme, qui, vous le remarquerez, commence au tout
début de la ligne et non pas au niveau de la tabulation . Ceci marque que notre
fonction est terminée. Ce qui se trouve indenté (c’est-à-dire, précédé par une
tabulation, mais ça peut-être par un simple espace) est appelé un bloc et appar-
tient à la fonction conversion. Peut-être avez-vous aussi remarqué le symbole #
qui commence la ligne. Tout ce qui suit ce symbole jusqu’à la fin de la ligne est
ignoré par l’interpréteur Python. Ce qui signifie que vous pouvez utiliser ce sym-
bole pour mettre tout ce qui vous passe par la tête. En règle générale, on l’utilise
3 Et oui, Python développe aussi votre imagination !
4 vous trouverez parfois les termes de procédure ou routine pour parler d’une fonction qui ne renvoie rien.
22 CHAPITRE 2. PROGRAMMER : BUT DE TOUT PROGRAMMEUR

pour commenter ce que nous faisons, afin que quelqu’un d’autre ou vous-même
un peu plus tard, puissiez savoir ce que vous avez voulu faire dans cette partie du
programme. Vous pouvez y placer aussi votre liste de courses à faire, mais cela
relève plus de la psychothérapie...
Vous pouvez recopiez directement cette fonction dans l’interpréteur interactif. Après
avoir tapé la première ligne, celui-ci affiche « ... », indiquant qu’il a reconnu une
définition de fonction et vous invitant à taper la suite . Quand vous avez terminé, tapez
deux fois sur « entrer » pour le lui dire :

>>>def conversion(chiffre_m):
... chiffre_cm = chiffre_m * 100
... return chiffre_cm
...
>>>

Si vous avez un message d’erreur c’est que vous avez certainement oublié la ta-
bulation sur la deuxième et/ou troisième ligne ! Bien sûr, votre superbe fonction ne
restera pas en mémoire quand vous fermerez l’interpréteur ! Si vous voulez garder
ce chef d’oeuvre, vous pouvez le taper dans un éditeur de texte et l’enregistrer sous
« chef_d_oeuvre.py » (le nom que j’ai choisit de lui donner n’est qu’un proposition...).
Notez que nous aurions pu simplifier cette fonction en évitant d’avoir recours à une
deuxième variable, de la manière suivante :

def conversion(chiffre\_m):
return chiffre\_m * 100

L’instructon return se comporte un peu comme une variable sans le caractère

d’affectation (« = »). Elle renvoie donc le résultat du calcul.

2.2.3 Comment que j’fais pour l’utiliser c’te fonction ?

Pour l’utiliser, il suffit de l’appeler par son petit nom et de lui donner le paramètre.
Par exemple, si nous voulons convertir 18 m en centimètres nous écririons ceci :

conversion (18)

Ce qui aura pour effet d’envoyer 18 en paramètre à la fonction conversion qui

remplacera donc chiffre_m par 18 et fera le calcul :

chiffre\_cm = 18 * 100

Enfin, elle nous retournera le résultat avec la ligne :

return chiffre\_cm

Si nous optons pour la fonction « simplifiée », c’est pareil, sauf que c’est direc-
tement la ligne de l’instruction return qui fera le calcul avant de nous donner la
réponse :

return 18 * 100

C’est pas beau tout ça ?

2.2. EN FONCTION DE QUOI ? 23

2.2.4 A quoi ça sert puisque je peux taper mon calcul directement

dans l’interpréteur interactif Python ?
C’est vrai, sauf qu’une fonction, vous l’appelez autant de fois que vous le désirez.
Si vous aviez des calculs un peu plus long, comme par exemple ajouter un pourcentage
différent à une série de 50 chiffres, vous auriez à taper 50 fois un calcul du type (ajout
de 2,5% à 200) :

>>>200 * 2.5 / 100

5.0
>>>_ + 200
205.0

Alors que vous pourriez écrire la fonction suivante :

>>>def prcnt (chiffre, prct):

... return chiffre + (chiffre * prct / 100)
...

Et l’appeler autant de fois que nécessaire de cette manière :

>>>prcnt(200, 2.5)
205.0

Et allons même plus loin ! Imaginons que dans la série de 50 chiffres que vous avez,
le pourcentage à appliquer pour la majorité d’entre eux est de 2,5%. Vous pouvez écrire
votre fonction comme suit :

>>>def prcnt(chiffre, prct = 2.5):

... return chiffre + (chiffre * prct / 100)
...

Dans ce cas, chaque fois que le pourcentage à appliquer est de 2.5%, il vous suffit
d’écrire :

>>>prcnt(200)
205.0

Si ce n’est pas 2,5%, alors vous le spécifiez comme nous l’avons fait auparavant.
C’est ce qu’on appel mettre une valeur par défaut à un paramètre d’une fonction.
C’est quand même bien plus fonctionnel que de taper 50 fois le calcul, non ?
D’ailleurs, c’est pour cela que l’on apelle ce type de programmation, programmation
fonctionnelle.
Alors, heureux ?
24 CHAPITRE 2. PROGRAMMER : BUT DE TOUT PROGRAMMEUR

Petit exercice 1 : Il est temps de couper un peu le cordon, et d’acquérir

un minimum d’autonomie ! Je vous propose donc un petit exercice, que
vous ferez sans tricher, sinon ça ne compte pas :
1. Écrivez une fonction (directement dans l’interpréteur ou dans un
fichier) qui vous permet de calculer la moyenne de 2 nombres
(ben oui, je sais, ça irait plus vite de tête, mais c’est un exer-
cice...).
2. Une fois que vous l’avez testé, que pourriez-vous lui ajouter si
vous savez que la plupart du temps, l’un des deux nombres est
1234 ? (Ne me demandez-pas « pourquoi 1234 ? », je n’en sais
rien...)
(Corrigé p.35)

2.3 Je te jure que c’est vrai !

D’abord, on ne jure pas, ensuite, laissons Python à cette appréciation s’il vous plaît.
Oui, parfaitement, Python est capable de dire si quelque chose est vrai ou pas, et d’ac-
complir une action plutôt qu’une autre en fonction de la réponse.
Nous pouvons donc lui dire : si ça c’est vrai, tu fait ça, sinon tu fais ça.

2.3.1 L’if est un très bal arbre

Mais c’est aussi un mot anglais qui veut dire « si » (rien à voir avec la note de
musique), et une instruction Python qui veut dire la même chose. Cette instruction sert
à tester si une condition est vrai.
Par exemple : si votre nom est Chevalier, Python dira cinq fois « Ni », si ce n’est
pas le cas Python dira qu’il ne peut pas dire « Ni » en présence d’un non chevalier.
Écrivons cela de manière structurée (ne vous disais-je pas que Python oblige à bien
penser ?) :

fonction Ni:
Si Nom = ’’Chevalier’’ :
écrit 5 x ‘‘Ni’’
Sinon:
écrit ‘‘Je ne peux pas dire Ni en votre présence.’’

Ce qui nous donnera à peu près la même chose en Python, mais en anglais :

>>>def Ni(Nom):
... if Nom == ’’Chevalier’’:
... print 5 * ’’Ni‘‘
... else:
... print ‘‘Je ne peux pas dire Ni en votre présence.’’
...

Que remarquons nous ?

Nous avons d’abord la définition de fonction que nous connaissons bien.
Ensuite, vient l’instruction if qui va tester notre condition qui est Nom == ”Chevalier”
. Remarquez bien le double signe « = » qui veut dire « égal à », contrairement au simple
2.3. JE TE JURE QUE C’EST VRAI ! 25

« = » qui signifie, comme nous l’avons vu, « attribue ce qu’il y a à droite à ce qu’il y a
à gauche ». Si vous vous trompez, Python attribuera sagement la valeur « Chevalier » à
la variable Nom, et la condition sera forcément toujours vrai ! La ligne de l’instruction
if est suivit de « : ». Si la condition est vérifiée, la ligne suivante sera exécutée (re-
marquez la deuxième tabulation qui marque notre bloc if, celui-ci peut être en effet de
plusieurs lignes). Cette ligne contient l’instruction print (qui signifie « imprime » en
anglais), et qui « imprimera » sur l’écran ce qui est entre guillemets (rassurez-vous, cela
ne veut pas dire que votre écran sera marqué de manière indélébile ! Si cette expression
vous angoisse, ramplacez-là simplement par « qui affichera à l’écran »).
Qu’est-ce donc que else : ? Cela signifie tout simplement « sinon » en anglais.
Donc, si la condition n’est pas vérifiée, c’est la ligne qui suit cette instruction qui
sera exécutée (toujours indentée à l’aide d’une tabulation, of course 5 ). Il n’est pas
obligatoire de mettre une instruction else, si celle-ci n’est pas utile.
Entrez cette fonction dans votre interpréteur et testez là avec Ni(“Chevalier”)
et Ni(“Ce que vous voulez”).
Considérez maintenant le code suivant :

>>>def Ni (Nom):
... if Nom == ’’Chevalier’’:
... print 5 * ’’Ni ‘‘
... elif Nom == ’’Guido van Rossum’’:
... print ‘‘Je peux faire une exception : ’’ + 5 * ’’Ni ’’
... else :
... print ‘‘Je ne peux pas dire Ni en votre présence.’’
...

L’instruction elif à été ajoutée. elif est l’abréviation de else if (« sinon si »).
Donc si le test du premier if est faux, Python teste la condition qui suit elif. Si c’est
vrai la ligne suivante est exécutée, sinon c’est le bloc else qui l’est. Vous pouvez
mettre autant de elif que vous le souhaitez.
Nous avons fait appel ici à « == » pour tester notre condition. Beaucoup d’autres
opérateurs de comparaisons existent. Les plus courants sont listés dans le tableau 2.1.

Principaux opérateurs
de comparaison
opérateur signification
== égal à
!= différent de
<> différent de (identique à !=)
< strictement inférieur à
> strictement supérieur à
<= inférieur ou égal à
>= supérieur ou égal à

TAB . 2.1 – Opérateurs de comparaison

5 En fait, une indentation est nécessaire chaque fois, que la ligne précédente se termine par « : ». Grace

à cette façon de faire, le code Python est extrêmement lisible et clair.

26 CHAPITRE 2. PROGRAMMER : BUT DE TOUT PROGRAMMEUR

2.3.2 Laissez lui vous poser les questions

Ben oui, ce serait tout de même sympathique si Python était capable de vous de-
mander votre nom pour lancer la fonction du paragraphe précédent.
Comme vous vous en doutez, Python est capable de tout, entrez ceci dans un fichier
que vous appellerez « ni.py » :

def Ni (Nom):
if Nom == ’’Chevalier’’:
print 5 * ’’Ni ‘‘
elif Nom == ’’Guido van Rossum’’:
print ‘‘Je peux faire une exception : ’’ + 5 * ’’Ni ’’
else :
print ‘‘Je ne peux pas dire Ni en votre présence.’’

Nom = raw_input(‘‘Quel est votre nom ? ’’)

Ni(Nom)

Enregistrez votre fichier puis lancer python ni.py dans un terminal, vous de-
vriez obtenir :

Quel est votre nom ?

Et c’est là que, prenant votre courage à deux mains, vous entrez en scène et répon-
dez fièrement à la question posée. Votre réponse conditionnera ce que fera Python, bien
évidemment.
Comment cela se fait-il ?
Observons un peu notre code. Tout d’abord nous écrivons la fonction que nous
connaissons bien. Ensuite nous disons à Python de mettre
raw_input(‘‘Quel est votre nom ? ’’) dans la variable Nom. raw_input()
est en fait une fonction intégrée à Python qui lit et stocke ce qui est écrit au clavier
(jusqu’à ce que l’on tape sur la touche « return ». Optionnellement, on peut lui ajou-
ter du texte en argument (comme nous l’avons fait ici) pour qu’elle l’imprime. Le
texte que vous entrez va donc être lu par raw_input() puis stocké dans la variable
Nom. Celle-ci est ensuite envoyée à la fonction. S’il fallait récupérer non pas du texte
(des caractères) mais des chiffres avec lesquelles Python doit travailler, il faut utiliser
input() à la place.
Exemple :

a = raw_input(‘‘Entrez un nombre : ’’)

print a * 10

Si j’entre le nombre 10, voici ce que j’obtient :

10101010101010101010

En effet, Python a considéré le nombre entré comme du texte et l’a donc répété 10
fois au lieu de faire le calcul. Pour que notre programme (qui ne sert vraiment à rien
d’ailleurs...) fonctionne, il faudra donc écrire :

a = input(‘‘Entrez un nombre : ’’)

print a * 100
2.3. JE TE JURE QUE C’EST VRAI ! 27

Petit exercice 2 : Continuons notre sevrage. . .

1. Écrivez dans un fichier nommé « examen.py » une
fonction resultat à qui on envoie un nombre et
qui réagit comme suit :
– Si le nombre est égal à 20, Python écrit « Je n’en
attendais pas moins de vous ».
– Si le nombre est inférieur ou égal à 10, Python doit
doit écrire « Vous vous foutez du monde, ce n’est
pas possible autrement ! ».
– Si le nombre est supérieur à 10, Python écrit « Vous
aviez certainement la tête ailleurs pour ne pas avoir
atteint la perfection ! ».
2. Ajouter une instruction qui demande à l’utilisateur
d’entrer sa note d’examen.
3. Envoyer cette note à la fonction resultat.
(Corrigé p.35)

2.3.3 Tant qu’il y aura Python, je ne serais plus seul...

Il ya des moments où il serait interessant de dire à Python de faire quelque chose
tant qu’une condition est vrai. Reprenons par exemple notre fonction qui vise à ajouter
un certain pourcentage à une série de nombre. Supposons que cette série contienne tous
les nombres compris entre 10 et 100 et que vous deviez leur ajouter 2.5%. Plutôt que
de taper 90 fois l’appel de votre fonction, vous pouvez écrire :

>>>def prcnt():
... chiffre = 10
... while chiffre <= 100 :
... print chiffre + (chiffre * 2.5 / 100)
... chiffre = chiffre + 1

Nous avons d’abord défini une fonction (sans argument). Dans celle-ci, nous créons
une variable chiffre qui prend 10 pour valeur. La ligne suivante contient l’instruc-
tion while qui veut dire “tant que” en anglais. Ainsi, tant que chiffre est inférieur
ou égal (<=) à 100, le bloc qui suit est exécuté. Dans ce bloc, nous trouvons d’abord
une ligne qui dit à python d’afficher le résultat de notre calcul avec chiffre qui a
pour valeur 10. La deuxième ligne met chiffre + 1 dans la variable chiffre,
autrement dit, 11 (vous me suivez ?). Puis, la condition de while est testée à nou-
veau. Si c’est toujours vrai, c’est reparti pour un tour : la 1ère ligne affiche le résultat,
mais cette fois, avec chiffre ayant 11 comme valeur et la deuxième ligne ajoute 1
à chiffre pour l’amener à 12 et ainsi de suite jusqu’à ce que chiffre soit égal à 100.
La boucle se termine alors.

2.3.4 Comment dit-il vrai ou faux ?

Pour Python tous ce qui est différent de 0 (ou un objet vide ou none, mais nous
verrons cela plus tard) est vrai. Un test de comparaison (comme ceux que nous avons
rencontré avec if et while) fonctionne comme une fonction qui renvoie une valeur
qui peut être 1 (vrai) ou 0 (faux). Ainsi l’instruction « while 1 : » provoque une
28 CHAPITRE 2. PROGRAMMER : BUT DE TOUT PROGRAMMEUR

boucle infinie (Python interprétant 1 comme vrai). Il peut sembler souhaitable de ne

pas provoquer de boucle infinie, pourtant ça a son utilité... (n ième procédé visant à
interloquer le lecteur...)

2.4 Et si je ne veux pas qu’il continue ses bouclettes ?

Vous, vous êtes du genre à vouloir maîtriser la situation ! Rassurez-vous, Python
ne pourra pas agir sans votre accord (rassuré ?). En effet, il existe deux instruction
permettant de contrôler le déroulement d’une boucle while.

2.4.1 break-down !
L’instruction break est la première à connaître. Elle permet de sortir d’une boucle
while quand c’est nécessaire. Quand est-ce que c’est nécessaire ? Dans bien des cas...
Mais un exemple valant mieux qu’un long discours, imaginez que vous venez de dé-
barquer sur terre, que vous connaissez encore mal les mathématiques de notre planète
(mais vous connaissez l’universel Python bien sûr). Vous ne vous souvenez plus si le
symbole 5 fait partie des nombres entre 0 et 5 000 000, (si vous avez plus débile comme
exemple, je suis preneur...). Vous pourriez alors écrire :
x = 0
while x <= 5000000 :
if x == 5 :
print ‘‘5 fait partie des chiffres’’
x = x + 1
Ca marche, mais vous perdez du temps (essayez, vous verrez) ! En effet la boucle
while continue jusqu’à ce que x soit arrivé à 5 000 000, alors qu’il a trouvé le 5 depuis
longtemps. Heureusement, l’instruction break est là :
x = 0
while x <= 5000000 :
if x == 5 :
print ‘‘5 fait partie des chiffres’’
break
x = x + 1
Dans ce cas dès que x est égal à 5, on sort de la boucle (c’est-à-dire presque immé-
diatement).

2.4.2 continuons je vous prie...

Une autre instruction permettant de contôler une boucle se nomme « continue ».
Comme son nom ne l’indique pas, elle ne permet pas de continuer mais de reprendre
en haut de la boucle :
x = 0
while x < 20 :
x = x + 1
if x % 2 == 0 :
continue
print x
2.5. C’EST TOUT ? 29

Ce code affiche les chiffres pairs entre 1 et 20. On met d’abord x à 0, puis on
lance la boucle while. La première instruction ajoute 1 à x, l’instruction if teste si
x est pair (c’est-à-dire, divisible par 2) 6 . Si c’est le cas, l’instruction continue est
exécutée faisant remonter en haut de la boucle sans que le reste soit exécuté. Si ce n’est
pas le cas (1 fois sur 2), l’instruction print x est exécutée.
Alors ! Hein ? Qu’est-ce qu’on dit à M. Python ?
faisons le point.
Vous connaissez maintenant les instructions if et while avec lesquelles vous avez
contrôlez le flux des informations. C’est-à-dire que vous avez dit à Python quelle était
la décision à prendre face à une condition précise. C’est pourquoi elles sont appellées
instructions conditionnelles. Il existe encore une autre instruction de ce type très utile.
Mais nous n’allons pas la voir tout de suite, car il vous manque encore quelques petites
choses à savoir avant de pouvoir l’utiliser pleinement. Vous connaissez aussi break et
continue, qui servent à contôler le déroulement d’une boucle. Nous sommes donc
prêt pour un exercice un peu plus conséquent :

Petit exercice 3 : Un vrai programme avec interface utilisateur !

1. Écrivez dans un fichier nommé « tva.py » une fonc-
tion tva qui ajoute 5.5% au prix qu’on lui envoi.
2. Arrangez vous pour que le programme ait l’air de ça
quand on le lance :
Prix (tapez -1 pour sortir) ?
(Ne vous occupez pas du « tapez -1 pour sortir » pour
le moment.) Et bien sûr, donner à l’utilisateur le ré-
sultat.
3. Mettez l’instruction de demande du prix et d’envoi de
celui-ci à la fonction tva dans une boucle infinie (ne
testez pas votre programme maintenant sous peine de
ne jamais en sortir 7 ...).
4. Arrangez-vous pour que le programme se termine si
l’utilisateur tape -1.
(Corrigé p.37)

2.5 C’est tout ?

Vous savez maintenant ce qu’est une variable et ce qu’est une fonction. Et vous avez
utilisez des instructions conditionnelles.Nous avons aussi parlé des types de variables.
C’est un bon début, mais ne laissez pas enfler votre égo. Vous n’avez fait que frapper
à la porte, celle-ci s’est ouverte, et devant vous se déployent de nouvelles contrées de
connaissances, que seul les hommes réalisés (c’est-à-dire, les initiés Python, bien sûr !)
peuvent fouler du pied. Le Saint Graal vous y attend quelque part et je serais votre
guide. N’ayez pas peur des lapins et suivez moi.

6 Vous voyez, je vous le disez que c’était pratique le %...

7 Si vous êtes pris dans une boucle infinie, tapez Ctrl + C pour en sortir
30 CHAPITRE 2. PROGRAMMER : BUT DE TOUT PROGRAMMEUR

2.6 Résumé
– Python est un langage interprété. Un programme Python (appelé aussi parfois
script) n’a pas besoin d’être compilé. L’interpréteur Python le lit et l’éxécute au
fur et à mesure.
– L’interpréteur interactif (lancé avec la commande python) permet de tester des
fonctions, de faire différents calculs, etc. en temps réél.
– Une variable est un emplacement mémoire dans lequel est stockée une valeur.
Une variable a :
– Un nom. Celui-ci ne peut comporter de caractères accentués ou spéciaux ni
d’espace et ne doit pas commencer par un chiffre. Il peut comporter le carac-
tère de soulignement (« _ »), toutefois il n’est pas conseillé de commencer
une variable avec ce caractère, cela pourrait provoquer une confusion avec
des variables spéciales que Python fait commencer par un double caractère
« _ » (ne commencez pas à lui embrouiller l’esprit...). Pour finir, Python fait
la distinction entre majuscule et minuscule.
– Quelques variables correctes : var, var1, MaVariable Ma_Variable,
_variable (correct mais pas conseillé).
– Quelques variables incorrectes : 1var, var !,var1&var2, ma variable.
– Un type : ce peut être une nombre entier, un nombre réél, une chaîne de carac-
tère (et bien d’autres que nous n’avons pas encore vu... mystère...).
– En Python, les variables sont typées dynamiquement. Ce qui ne veut pas dire
que les variables sont des créatures sensuelles capable de changer leur couleur
de peaux et de cheveux pour s’adapter à l’homme macho dérrière son écran. Cela
veut dire que vous n’avez pas à déclarer au préalable quelle sera le type de va-
leur qui sera stockée dans ces variables (c’est une nécéssité dans certains autres
langages de programmation). Python affectera de lui-même le type en fonction
de ce que vous y mettez. C’est une facilité que vous offre le langage mais en
contrepartie, Python sera incapable de vous prévenir si vous avez mis une chaîne
de caractère là où il fallait un entier.
– « _ » est une variable spéciale utilisée dans l’interpréteur interactif. Cette va-
riable stocke le dernier calcul effectué.
– Python possède une instruction de test (if) utilisé de la manière suivante :
if <condition> :
#faire des trucs
elif <condition2> :
#faire d’autres trucs
else :
#faire des trucs encore différents
Ce qui signifie : « Si <condition> est vrai, faire des trucs, sinon si <condition2>
est vrai faire d’autres trucs, sinon, faire des trucs encore différents. » Les condi-
tions sont le plus souvent une comparaison (ou plusieurs, encore mystère...). Les
opérateurs de comparaisons sont regroupés dans le tableau 2.1, p.25. Vous pou-
vez mettre autant de elif que vous voulez, ou ne pas en mettre du tout. else
est lui aussi optionnel.
– Python comporte deux instruction de boucle, mais vous n’en connaissez qu’une
(encore encore mystère...), qui se présente comme cela :
while <condition> :
#faire des trucs
Ce qui signifie : « Tant que <condition> est vrai, faire des trucs. »
2.6. RÉSUMÉ 31

– Deux instructions permettent de contrôler une boucle :

– break : sortir de la boucle.
– continue : reprendre au début de la boucle sans exécuter ce qui suit continue.
– Une fonction est une suite d’instructions regroupées permettant d’effectuer des
tâches répétitive, ou tout simplement, de découper le code pour qu’il soit encore
plus clair. Une fonction se présente comme suit :
def MaFonction (a, b) :
#faire des trucs avec a et b
return #quelque chose
Les fonctions ont :
– Un nom, qui se soumet aux même règles que pour les variables (ici c’est
MaFonction).
– Zéro, un ou plusieurs paramètres qui sont en fait des valeurs de variables
passées à la fonction et avec lesquelles elle va travailler (ici, ce sont a et b)
L’instruction return sert à renvoyer le résultat de la fonction, ou plus généra-
lement à sortir de celle-ci (c’est une instruction optionnelle).
32 CHAPITRE 2. PROGRAMMER : BUT DE TOUT PROGRAMMEUR
Annexes

33
Annexe A

Corrigés des exercices

Sommaire
A.1 Exercices de la partie I . . . . . . . . . . . . . . . . . . . . . . . 35
A.1.1 Petit exercice 1 . . . . . . . . . . . . . . . . . . . . . . . 35
A.1.2 Petit exercice 2 . . . . . . . . . . . . . . . . . . . . . . . 35
A.1.3 Petit exercice 3 . . . . . . . . . . . . . . . . . . . . . . . 37

A.1 Exercices de la partie I

A.1.1 Petit exercice 1
p.24
1. Écrivez une fonction (directement dans l’interpréteur ou dans un fichier) qui vous
permet de calculer la moyenne de 2 nombres.
def moyenne(a, b) :
result = (a + b) / 2
return resultat
Ou :
def moyenne(a, b)
return (a + b) / 2
2. Une fois que vous l’avez testé, que pourriez-vous lui ajouter si vous savez que la
plupart du temps, l’un des deux nombres est 1234 ?
def moyenne(a, b=1234)
return (a + b) / 2

A.1.2 Petit exercice 2

p.27
(les instructions trop longues pour être imprimées sur une seule ligne continuent sur la
ligne suivante avec le signe [.)

35
36 ANNEXE A. CORRIGÉS DES EXERCICES

1. Écrivez dans un fichier nommé « examen.py » une fonction resultat à qui on

envoie un nombre et qui réagit comme suit :
– Si le nombre est égal à 20, Python écrit « Je n’en attendais pas moins de vous ».
– Si le nombre est inférieur ou égal à 10, Python doit doit écrire « Vous vous
foutez du monde, ce n’est pas possible autrement ! ».
– Si le nombre est supérieur à 10, Python écrit « Vous aviez certainement la tête
ailleurs pour ne pas avoir atteint la perfection ! ».
def resultat(nombre)
if nombre == 20 :
print ‘‘je n’en attendais pas moins de vous.’’
elif nombre <= 10 :
print ‘‘Vous vous foutez du monde, ce n’est
[pas possible autrement !’’
elif nombre > 10 :
print ‘‘Vous aviez certaienement la tête ailleurs
[pour ne pas avoir atteint la perfection !’’
Vous remarquerez l’importance de l’instruction elif qui est indis-
pensable ici, en effet, si nous avions écrit :
def resultat(nombre)
if nombre == 20 :
print ‘‘je n’en attendais pas moins de vous.’’
if nombre <= 10 :
print ‘‘Vous vous foutez du monde, [...]’’
if nombre > 10 :
print ‘‘Vous aviez certaienement la [...]’’
Si nombre est égal à 20, la première condition est vraie, mais la
troisième ({nombre > 10), l’est aussi. Python aurait donc écrit les
deux phrases correspondantes. Si elif n’existait pas, nous aurions
pu contourner le problème en écrivant :
def resultat(nombre)
if nombre == 20 :
print ‘‘je n’en attendais pas moins de vous.’’
return
if nombre <= 10 :
print ‘‘Vous vous foutez du monde, [...]’’
if nombre > 10 :
print ‘‘Vous aviez certaienement la [...]’’
Ici, return force à sortir de la fonction si la première condition est
vrai. Les autres conditions ne sont donc même pas testées.
2. Ajouter une instruction qui demande à l’utilisateur d’entrer sa note d’examen.
def resultat(nombre)
if nombre == 20 :
print ‘‘je n’en attendais pas moins de vous.’’
elif nombre <= 10 :
print ‘‘Vous vous foutez du monde, ce n’est
[pas possible autrement !’’
elif nombre > 10 :
A.1. EXERCICES DE LA PARTIE ?? 37

print ‘‘Vous aviez certaienement la tête ailleurs

[pour ne pas avoir atteint la perfection !’’

nombre = input(‘‘Entrez votre note d’examen : ’’)

3. Envoyer cette note à la fonction resultat.
def resultat(nombre)
if nombre == 20 :
print ‘‘je n’en attendais pas moins de vous.’’
elif nombre <= 10 :
print ‘‘Vous vous foutez du monde, ce n’est
[pas possible autrement !’’
elif nombre > 10 :
print ‘‘Vous aviez certaienement la tête ailleurs
[pour ne pas avoir atteint la perfection !’’

nombre = input(‘‘Entrez votre note d’examen : ’’)

resultat(nombre)

A.1.3 Petit exercice 3

p.29
1. Écrivez dans un fichier nommé « tva.py » une fonction tva qui ajoute 5.5% au
prix qu’on lui envoi.
def tva(prix) :
return prix + (prix * 5.5 / 100)
2. Arrangez vous pour que le programme ait l’air de ça quand on le lance :
Prix (tapez -1 pour sortir) ?
(Ne vous occupez pas du « tapez -1 pour sortir » pour le moment.) Et bien sûr,
donner à l’utilisateur le résultat.
def tva(prix) :
return prix + (prix * 5.5 / 100)

prix = input(‘‘Prix (tapez -1 pour sortir) ? ’’)

print tva(prix)
3. Mettez l’instruction de demande du prix et d’envoi de celui-ci à la fonction tva
dans une boucle infinie.
def tva(prix) :
return prix + (prix * 5.5 / 100)

while 1 :
prix = input(‘‘Prix (tapez -1 pour sortir) ? ’’)
print tva(prix)
4. Arrangez-vous pour que le programme se termine si l’utilisateur tape -1.
def tva(prix) :
return prix + (prix * 5.5 / 100)
38 ANNEXE A. CORRIGÉS DES EXERCICES

while 1 :
prix = input(‘‘Prix (tapez -1 pour sortir) ? ’’)
if prix == -1 :
break
print tva(prix)
Annexe B

GNU Free Documentation

License (GFDL)

Note : Pour l’instant, seule la version originale en anglais est légale, c’est
pourquoi c’est celle qui est donnée ici. Vous trouverez des traductions fran-
çaises de la GFDL sur internet.

Sommaire
B.1 Applicability and definitions . . . . . . . . . . . . . . . . . . . . 40
B.2 Verbatim copying . . . . . . . . . . . . . . . . . . . . . . . . . . 40
B.3 Copying in quantity . . . . . . . . . . . . . . . . . . . . . . . . 41
B.4 Modifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
B.5 Combining documents . . . . . . . . . . . . . . . . . . . . . . . 42
B.6 Collections of documents . . . . . . . . . . . . . . . . . . . . . . 43
B.7 Aggregation with independent works . . . . . . . . . . . . . . . 43
B.8 Translation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
B.9 Termination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
B.10 Future revisions of this license . . . . . . . . . . . . . . . . . . . 44

GNU Free Documentation License

Version 1.1, March 2000
Copyright (C) 2000 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

Preamble
The purpose of this License is to make a manual, textbook, or other written document "free" in
the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with
or without modifying it, either commercially or noncommercially. Secondarily, this License pre-
serves for the author and publisher a way to get credit for their work, while not being considered
responsible for modifications made by others.

39
40 ANNEXE B. GNU FREE DOCUMENTATION LICENSE (GFDL)

This License is a kind of "copyleft", which means that derivative works of the document
must themselves be free in the same sense. It complements the GNU General Public License,
which is a copyleft license designed for free software.
We have designed this License in order to use it for manuals for free software, because free
software needs free documentation: a free program should come with manuals providing the
same freedoms that the software does. But this License is not limited to software manuals; it
can be used for any textual work, regardless of subject matter or whether it is published as a
printed book. We recommend this License principally for works whose purpose is instruction or
reference.

B.1 Applicability and definitions

This License applies to any manual or other work that contains a notice placed by the copyright
holder saying it can be distributed under the terms of this License. The "Document", below,
refers to any such manual or work. Any member of the public is a licensee, and is addressed as
"you".
A "Modified Version" of the Document means any work containing the Document or a por-
tion of it, either copied verbatim, or with modifications and/or translated into another language.
A "Secondary Section" is a named appendix or a front-matter section of the Document that
deals exclusively with the relationship of the publishers or authors of the Document to the Docu-
ment’s overall subject (or to related matters) and contains nothing that could fall directly within
that overall subject. (For example, if the Document is in part a textbook of mathematics, a Sec-
ondary Section may not explain any mathematics.) The relationship could be a matter of histor-
ical connection with the subject or with related matters, or of legal, commercial, philosophical,
ethical or political position regarding them.
The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being
those of Invariant Sections, in the notice that says that the Document is released under this
License.
The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or
Back-Cover Texts, in the notice that says that the Document is released under this License.
A "Transparent" copy of the Document means a machine-readable copy, represented in a
format whose specification is available to the general public, whose contents can be viewed
and edited directly and straightforwardly with generic text editors or (for images composed of
pixels) generic paint programs or (for drawings) some widely available drawing editor, and that
is suitable for input to text formatters or for automatic translation to a variety of formats suitable
for input to text formatters. A copy made in an otherwise Transparent file format whose markup
has been designed to thwart or discourage subsequent modification by readers is not Transparent.
A copy that is not "Transparent" is called "Opaque".
Examples of suitable formats for Transparent copies include plain ASCII without markup,
Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and
standard-conforming simple HTML designed for human modification. Opaque formats include
PostScript, PDF, proprietary formats that can be read and edited only by proprietary word pro-
cessors, SGML or XML for which the DTD and/or processing tools are not generally available,
and the machine-generated HTML produced by some word processors for output purposes only.
The "Title Page" means, for a printed book, the title page itself, plus such following pages
as are needed to hold, legibly, the material this License requires to appear in the title page. For
works in formats which do not have any title page as such, "Title Page" means the text near the
most prominent appearance of the work’s title, preceding the beginning of the body of the text.

B.2 Verbatim copying

You may copy and distribute the Document in any medium, either commercially or noncom-
mercially, provided that this License, the copyright notices, and the license notice saying this
B.3. COPYING IN QUANTITY 41

License applies to the Document are reproduced in all copies, and that you add no other con-
ditions whatsoever to those of this License. You may not use technical measures to obstruct or
control the reading or further copying of the copies you make or distribute. However, you may
accept compensation in exchange for copies. If you distribute a large enough number of copies
you must also follow the conditions in section 3.
You may also lend copies, under the same conditions stated above, and you may publicly
display copies.

B.3 Copying in quantity

If you publish printed copies of the Document numbering more than 100, and the Document’s
license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and
legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
the back cover. Both covers must also clearly and legibly identify you as the publisher of these
copies. The front cover must present the full title with all words of the title equally prominent
and visible. You may add other material on the covers in addition. Copying with changes limited
to the covers, as long as they preserve the title of the Document and satisfy these conditions, can
be treated as verbatim copying in other respects.
If the required texts for either cover are too voluminous to fit legibly, you should put the first
ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent
pages.
If you publish or distribute Opaque copies of the Document numbering more than 100, you
must either include a machine-readable Transparent copy along with each Opaque copy, or state
in or with each Opaque copy a publicly-accessible computer-network location containing a com-
plete Transparent copy of the Document, free of added material, which the general network-
using public has access to download anonymously at no charge using public-standard network
protocols. If you use the latter option, you must take reasonably prudent steps, when you begin
distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus
accessible at the stated location until at least one year after the last time you distribute an Opaque
copy (directly or through your agents or retailers) of that edition to the public.
It is requested, but not required, that you contact the authors of the Document well before
redistributing any large number of copies, to give them a chance to provide you with an updated
version of the Document.

B.4 Modifications
You may copy and distribute a Modified Version of the Document under the conditions of sec-
tions 2 and 3 above, provided that you release the Modified Version under precisely this License,
with the Modified Version filling the role of the Document, thus licensing distribution and mod-
ification of the Modified Version to whoever possesses a copy of it. In addition, you must do
these things in the Modified Version:

A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document,
and from those of previous versions (which should, if there were any, be listed in the History
section of the Document). You may use the same title as a previous version if the original
publisher of that version gives permission.
B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of
the modifications in the Modified Version, together with at least five of the principal authors
of the Document (all of its principal authors, if it has less than five).
C. State on the Title page the name of the publisher of the Modified Version, as the publisher.
D. Preserve all the copyright notices of the Document.
42 ANNEXE B. GNU FREE DOCUMENTATION LICENSE (GFDL)

E. Add an appropriate copyright notice for your modifications adjacent to the other copyright
notices.
F. Include, immediately after the copyright notices, a license notice giving the public permis-
sion to use the Modified Version under the terms of this License, in the form shown in the
Addendum below.
G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts
given in the Document’s license notice.
H. Include an unaltered copy of this License.
I. Preserve the section entitled "History", and its title, and add to it an item stating at least
the title, year, new authors, and publisher of the Modified Version as given on the Title
Page. If there is no section entitled "History" in the Document, create one stating the title,
year, authors, and publisher of the Document as given on its Title Page, then add an item
describing the Modified Version as stated in the previous sentence.
J. Preserve the network location, if any, given in the Document for public access to a Trans-
parent copy of the Document, and likewise the network locations given in the Document
for previous versions it was based on. These may be placed in the "History" section. You
may omit a network location for a work that was published at least four years before the
Document itself, or if the original publisher of the version it refers to gives permission.
K. In any section entitled "Acknowledgements" or "Dedications", preserve the section’s title,
and preserve in the section all the substance and tone of each of the contributor acknowl-
edgements and/or dedications given therein.
L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles.
Section numbers or the equivalent are not considered part of the section titles.
M. Delete any section entitled "Endorsements". Such a section may not be included in the
Modified Version.
N. Do not retitle any existing section as "Endorsements" or to conflict in title with any Invariant
Section.
If the Modified Version includes new front-matter sections or appendices that qualify as
Secondary Sections and contain no material copied from the Document, you may at your option
designate some or all of these sections as invariant. To do this, add their titles to the list of
Invariant Sections in the Modified Version’s license notice. These titles must be distinct from
any other section titles.
You may add a section entitled "Endorsements", provided it contains nothing but endorse-
ments of your Modified Version by various parties–for example, statements of peer review or
that the text has been approved by an organization as the authoritative definition of a standard.
You may add a passage of up to five words as a Front-Cover Text, and a passage of up to
25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version.
Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through
arrangements made by) any one entity. If the Document already includes a cover text for the
same cover, previously added by you or by arrangement made by the same entity you are acting
on behalf of, you may not add another; but you may replace the old one, on explicit permission
from the previous publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this License give permission to
use their names for publicity for or to assert or imply endorsement of any Modified Version.

B.5 Combining documents

You may combine the Document with other documents released under this License, under the
terms defined in section 4 above for modified versions, provided that you include in the combi-
nation all of the Invariant Sections of all of the original documents, unmodified, and list them all
as Invariant Sections of your combined work in its license notice.
B.6. COLLECTIONS OF DOCUMENTS 43

The combined work need only contain one copy of this License, and multiple identical In-
variant Sections may be replaced with a single copy. If there are multiple Invariant Sections with
the same name but different contents, make the title of each such section unique by adding at the
end of it, in parentheses, the name of the original author or publisher of that section if known,
or else a unique number. Make the same adjustment to the section titles in the list of Invariant
Sections in the license notice of the combined work.
In the combination, you must combine any sections entitled "History" in the various original
documents, forming one section entitled "History"; likewise combine any sections entitled "Ac-
knowledgements", and any sections entitled "Dedications". You must delete all sections entitled
"Endorsements."

B.6 Collections of documents

You may make a collection consisting of the Document and other documents released under this
License, and replace the individual copies of this License in the various documents with a single
copy that is included in the collection, provided that you follow the rules of this License for
verbatim copying of each of the documents in all other respects.
You may extract a single document from such a collection, and distribute it individually
under this License, provided you insert a copy of this License into the extracted document, and
follow this License in all other respects regarding verbatim copying of that document.

B.7 Aggregation with independent works

A compilation of the Document or its derivatives with other separate and independent documents
or works, in or on a volume of a storage or distribution medium, does not as a whole count
as a Modified Version of the Document, provided no compilation copyright is claimed for the
compilation. Such a compilation is called an "aggregate", and this License does not apply to
the other self-contained works thus compiled with the Document, on account of their being thus
compiled, if they are not themselves derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these copies of the Document, then
if the Document is less than one quarter of the entire aggregate, the Document’s Cover Texts may
be placed on covers that surround only the Document within the aggregate. Otherwise they must
appear on covers around the whole aggregate.

B.8 Translation
Translation is considered a kind of modification, so you may distribute translations of the Docu-
ment under the terms of section 4. Replacing Invariant Sections with translations requires special
permission from their copyright holders, but you may include translations of some or all Invari-
ant Sections in addition to the original versions of these Invariant Sections. You may include
a translation of this License provided that you also include the original English version of this
License. In case of a disagreement between the translation and the original English version of
this License, the original English version will prevail.

B.9 Termination
You may not copy, modify, sublicense, or distribute the Document except as expressly provided
for under this License. Any other attempt to copy, modify, sublicense or distribute the Docu-
ment is void, and will automatically terminate your rights under this License. However, parties
who have received copies, or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
44 ANNEXE B. GNU FREE DOCUMENTATION LICENSE (GFDL)

B.10 Future revisions of this license

The Free Software Foundation may publish new, revised versions of the GNU Free Documenta-
tion License from time to time. Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns. See

http:///www.gnu.org/copyleft/

Each version of the License is given a distinguishing version number. If the Document
specifies that a particular numbered version of this License "or any later version" applies to it,
you have the option of following the terms and conditions either of that specified version or of
any later version that has been published (not as a draft) by the Free Software Foundation. If the
Document does not specify a version number of this License, you may choose any version ever
published (not as a draft) by the Free Software Foundation.

Addendum: How to use this License for your documents

To use this License in a document you have written, include a copy of the License in the docu-
ment and put the following copyright and license notices just after the title page:

Copyright c YEAR YOUR NAME.

Permission is granted to copy, distribute and/or modify this document under the
terms of the GNU Free Documentation License, Version 1.1 or any later version
published by the Free Software Foundation; with the Invariant Sections being LIST
THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover
Texts being LIST. A copy of the license is included in the section entitled "GNU
Free Documentation License".
If you have no Invariant Sections, write "with no Invariant Sections" instead of saying which
ones are invariant. If you have no Front-Cover Texts, write "no Front-Cover Texts" instead of
"Front-Cover Texts being LIST"; likewise for Back-Cover Texts.
If your document contains nontrivial examples of program code, we recommend releasing
these examples in parallel under your choice of free software license, such as the GNU General
Public License, to permit their use in free software.
Bibliographie

[1] I. VAN L ANINGHAM (T RADUCTION DE D.F RÈRE , K.C OTTEREAUX et N.R ENARD ) –
L’intro python, ISBN 2-7440-0946-6 éd., CampusPress, Octobre 2000, Cet ouvrage très
didactique est bien adapté au débutants. Il propose aussi une bonne introduction à la pro-
grammation d’interfaces graphiques.
[2] O. B ERGER – http ://perso.club-internet.fr/olberger/python/pyton.html
Vous trouverez sur la page web d’Olivier B ERGER la traduction française du tutorial Python,
ainsi que des liens vers les pages fracophones relatives à Python.
[3] M. L UTZ , D. A SCHER (T RADUCTION DE S.TANGUY , O.B ERGER et J.K ALIFA ) – Intro-
duction à python, ISBN 2-84177-089-3 éd., O’Reilly, Janvier 2000, Le livre idéal pour les
personnes pas tout à fait débutantes en programmation.
[4] G. VAN ROSSUM , F. L. D RAKE , J R . et EDITOR – Python tutorial, BeOpen Python-
Labs, python-docs@python.org - http ://www.python.org, Octobre 2000,
Ce texte, ainsi que toute la documentation est livré avec Python, si ce n’est pas le cas, vous
pouvez le télécharger à l’adresse indiquée. C’est bien évidemment un incontournable ! (La
traduction française est disponible sur le site d’Olivier B ERGER (voir ci-dessus)).
[5] M. L UTZ (T RADUCTION J.G UÉRIN ) – Python précis & concis, ISBN 2-84177-111-3 éd.,
O’Reilly, 2000, Un petit guide de référence sur le langage, indispensable tant que l’on ne
connait pas toutes les instructions, fonctions intégrées et modules par cœur...

45
Index

Symboles def . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
!= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 division. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14, 19
+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14, 19
- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
E
elif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
/ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
<= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
<> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
F
fonction . . . . . . . . . . . . . . . . . . . . . . . . . 20–23
< . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
def . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
== . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24, 25
nom . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
paramètre par défaut . . . . . . . . . . . . 23
>= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 I
% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 IDLE . . . . . . . . . . . . . . . . . . . . . . . . . . . 13, 14
_ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
indentation. . . . . . . . . . . . . . . . . . . . . . . . . . 21
A input() . . . . . . . . . . . . . . . . . . . . . . . . . . 26
instruction conditionnelle . . . . . . . . . 24, 29
addition . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
affectation . . . . . . . . . . . . . . . . . . . . . . . . . . 18 elif . . . . . . . . . . . . . . . . . . . . . . . . . 25
else . . . . . . . . . . . . . . . . . . . . . . . . . 25

B if . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
interpréteur interactif . . . . . . . . . . . . . . . . 13
bloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
break . . . . . . . . . . . . . . . . . . . . . . . . 28 L
continue . . . . . . . . . . . . . . . . . . . . 28 langage compilé . . . . . . . . . . . . . . . . . . . . . 11
while . . . . . . . . . . . . . . . . . . . . . . . . 27 langage interprété . . . . . . . . . . . . . . . . 11, 12
infinie . . . . . . . . . . . . . . . . . . . . . . . . . 28 linker. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
M
C mode interactif
particularités . . . . . . . . . . . . . . . 20, 22
chaîne de caractères. . . . . . . . . . . . . . . . . . 19
commentaire . . . . . . . . . . . . . . . . . . . . . . . . 21 modulo . . . . . . . . . . . . . . . . . . . . . . . . . 18, 29
compilateur . . . . . . . . . . . . . . . . . . . . . . . . . 11 multiplication . . . . . . . . . . . . . . . . . . . . . . . 14
condition . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
égalité . . . . . . . . . . . . . . . . . . . . . . . . .
vrai/faux. . . . . . . . . . . . . . . . . . . . . . .
24
27
O
opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . 14
continue . . . . . . . . . . . . . . . . . . . . . . . . . 28 égalité . . . . . . . . . . . . . . . . . . . . . . . . . 24
contrôle de flux . . . . . . . . . . . . . . . . . . . . . . 29 addition . . . . . . . . . . . . . . . . . . . . . . . 14
booléen. . . . . . . . . . . . . . . . . . . . . . . . 27
D comparaison . . . . . . . . . . . . . . . . . . . 25
debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 concaténation . . . . . . . . . . . . . . . . . . 19

46
INDEX 47

division . . . . . . . . . . . . . . . . . . . . . . . 14
modulo . . . . . . . . . . . . . . . . . . . . . . . . 18
multiplication . . . . . . . . . . . . . . . . . . 14
répétition . . . . . . . . . . . . . . . . . . . . . . 19
soustraction . . . . . . . . . . . . . . . . . . . . 14

P
paramètre . . . . . . . . . . . . . . . . . . . . . . . 20, 21
programmation fonctionnelle . . . . . . . . . 23

R
raw_input() . . . . . . . . . . . . . . . . . . . . . 26
return . . . . . . . . . . . . . . . . . . . . . . . . 21, 22

S
soustraction . . . . . . . . . . . . . . . . . . . . . . . . . 14

T
tabulation . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
chaîne de caractères . . . . . . . . . 19, 26
entier . . . . . . . . . . . . . . . . . . . . . . . . . . 18
réel . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

V
variable . . . . . . . . . . . . . . . . . . . . . . . . . 17, 19
nom . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
spéciale . . . . . . . . . . . . . . . . . . . . . . . 20
type . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
chaîne de caractères . . . . . . . . . . 19
entier . . . . . . . . . . . . . . . . . . . . . . . 18
réel . . . . . . . . . . . . . . . . . . . . . . . . . 18

W
while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27