Chapitre 6 Programmation et langages - Apprendre en ligne.net

L'informatique au lycée Chapitre 6
http://ow.ly/2xxkI
Chapitre 6
Programmation et langages
La programmation consiste à créer une séquence d'instructions pour un ordinateur afin qu'il
puisse résoudre un problème ou exécuter une tâche.
À partir de ce chapitre, on supposera que le lecteur maîtrise le langage Python 3.
6.1. Un peu d'histoire
En 1936, la publication de l'article fondateur de la science informatique On Computable
Numbers with an Application to the Entscheidungsproblem, par Alan Mathison Turing, allait donner
le coup d'envoi à la création de l'ordinateur programmable. Il y présente sa machine de Turing, le
premier calculateur universel programmable, et invente les concepts et les termes de programmation
et de programme.
En 1948, Konrad Zuse publie un article sur son langage de programmation qu'il a développé
entre 1943 et 1945 : le Plankalkül. Zuse le considère comme étant le premier langage de haut
niveau.
C'est à partir des années 50 que l'on verra apparaître les premiers langages de programmation
modernes. Voici les créateurs des langages les plus utilisés :
• John Backus, inventeur de Fortran (1954)
• John McCarthy, inventeur de LISP (1958)
• Grace Hopper, surnommée « la mère langage COBOL » (1959)
• John George Kemeny, concepteur du BASIC (1963)
• Dennis Ritchie et Ken Thompson, inventeurs du langage C (1972)
• Niklaus Wirth inventeur de Pascal (1970) et Modula-2 (1977)
• Bjarne Stroustrup, développeur de C++ (1985)
• Guido van Rossum, créateur de Python (1991)
• James Gosling et Patrick Naughton, créateurs de Java (1991).
6.1.1. Évolution des langages informatiques
On distingue aujourd'hui cinq générations de langages.
La première génération est le langage machine, ou code machine. On parle aussi de langage
natif. Il est composé d'instructions et de données à traiter codées en binaire. C'est le seul langage
qu'un ordinateur peut traiter directement.
Voici à quoi peut ressembler un programme en langage machine :
A1 01 10 03 06 01 12 A3 01 14
Il s'agit de la représentation hexadécimale d'un programme permettant d'additionner les valeurs
de deux cases mémoire et de stocker le résultat dans une troisième case. On voit immédiatement la
difficulté d'un tel langage...
Didier Müller 6-1 Juin 2013

Programmation et langages
La deuxième génération est le langage assembleur 1 : le code devient lisible et compréhensible
par un plus grand nombre d'initiés. Il existe en fait un langage assembleur par type de processeur.
Le programme précédent écrit en assembleur donnerait ceci :
MOV AX, [0110]
ADD AX, [0112]
MOV [0114], AX
Il reste utilisé dans le cadre d'optimisations, mais a été supplanté en popularité par les langages
plus accessibles de troisième génération.
La troisième génération utilise une syntaxe proche de l'anglais. Proposés autour de 1960, ces
langages ont permis un gain énorme en lisibilité et en productivité. Ils ne dépendent plus du
processeur, comme c'était le cas des générations précédentes, mais d'un compilateur 2 spécifique du
processeur. L'idée de portabilité 3 des programmes était lancée.
La plupart des langages de programmation actuels sont de troisième génération. On trouve dans
cette catégorie tous les grands langages : Ada, Algol, Basic, Cobol, Eiffel, Fortran, C, C++, Java,
Perl, Pascal, Python, Ruby, ... Cette génération couvre d'ailleurs tant de langages qu'elle est souvent
subdivisée en catégories, selon le paradigme 4 particulier des langages.
Les langages de quatrième génération, abrégés L4G, souvent associée à des bases de données,
se situent un niveau au-dessus, en intégrant la gestion de l'interface utilisateur 5 et en proposant un
langage moins technique, plus proche de la syntaxe naturelle.
Ils sont conçus pour un travail spécifique : gestion de base de données (Microsoft Access, SQL),
production graphique (Postscript), création d'interface (4D).
La cinquième génération de langages sont des langages destinés à résoudre des problèmes à
l'aide de contraintes, et non d'algorithmes écrits. Ces langages reposent beaucoup sur la logique et
sont particulièrement utilisés en intelligence artificielle. Parmi les plus connus, on trouve Prolog,
dont voici un exemple :
frère_ou_soeur(X,Y) :- parent(Z,X), parent(Z,Y), X \= Y.
parent(X,Y) :- père(X,Y).
parent(X,Y) :- mère(X,Y).
mère(trude, sally).
père(tom, sally).
père(tom, erica).
père(mike, tom).
Il en résulte que la demande suivante est évaluée comme vraie :
- frère_ou_soeur(sally, erica).
oui.
Ce qui signifie que Sally et Erica sont sœurs. En effet, Sally et Erica ont le même père (Tom).
1 Pour s'initier à l'assembleur : www.commentcamarche.net/contents/asm/assembleur.php3
2 En pratique, un compilateur sert le plus souvent à traduire un code source écrit dans un langage de programmation en un autre langage,
habituellement un langage assembleur ou un langage machine. Le premier compilateur, A-0 System, a été écrit en 1951 par Grace Hopper.
3 En informatique, la portabilité d'un programme est caractérisée par sa capacité à fonctionner plus ou moins facilement dans différents
environnements d'exécution
4 Voir paragraphe 6.5
5 L'interface utilisateur définit les moyens et outils mis en œuvre pour qu'un humain puisse contrôler et communiquer avec une machine.
Didier Müller 6-2 Juin 2013

L'informatique au lycée Chapitre 6
6.1.2. Quelques langages courants
Il existe environ
2500 langages de
programmation,
certains étant très
généraux (C, Java),
d'autres hyperspécialisés.
Par exemple,
RobotProg permet
de déplacer un
robot virtuel, R est
un langage pour la
statistique, etc.
Par comparaison,
on recense environ
6800 langues
humaines parlées
et/ou écrites de par
le monde.
Source de ce schéma : [1]
Le nom Ada a été
choisi en l'honneur
d'Ada Lovelace, qui
est supposée avoir
écrit le premier
programme de
l'histoire.
La première version
d'Ada remonte à
1983.
6.1.3. « Hello world ! »
C'est dans un memorandum interne de Brian Kernighan, Programming in C : A tutorial, écrit en
1974 dans les laboratoires Bell, que l'on trouve la première version d'un mini-programme affichant à
l'écran « Hello World! ». Voici comment cela s'écrit dans divers langages 6 :
Ada
with Ada.Text_IO;
use Ada.Text_IO;
procedure Bonjour is
begin -- Bonjour
Put("Hello world!");
end Bonjour;
6 Une liste plus complète est disponible sur Wikipédia : http://fr.wikipedia.org/wiki/Hello_world
Didier Müller 6-3 Juin 2013

Programmation et langages
BASIC est un
acronyme pour
Beginner's Allpurpose
Symbolic
Instruction Code.
Il a été conçu à la
base en 1963 par
John George
Kemeny et
Thomas Eugene
Kurtz.
Inventé au début
des années 1970
avec UNIX, C est
devenu un des
langages les plus
utilisés.
Bjarne Stroustrup
a développé C++ au
cours des années
1980. Il s'agissait
d'améliorer le
langage C.
Fortran (FORmula
TRANslator) est
utilisé dans les
applications de
calcul scientifique.
Java a été créé par
Sun Microsystems,
et présenté
officiellement le
23 mai 1995.
JavaScript est un
langage de
programmation de
scripts utilisé dans
les pages web
interactives .
Assembleur X86 sous DOS
BASIC
C
C++
cseg segment
assume cs:cseg, ds:cseg
org 100h
main proc
jmp debut
mess db 'Hello world!$'
debut:
mov dx, offset mess
mov ah, 9
int 21h
ret
main endp
cseg ends
end main
10 PRINT "Hello world!"
20 END
#include
int main()/* ou int argc, char *argv[] */
{
printf("Hello world!\n");
return 0;
}
#include
int main()
{
std::cout

L'informatique au lycée Chapitre 6
6.2. La machine de Turing
Une machine de Turing est une machine théorique, inventée par Alan Turing en 1936, pour
servir de modèle idéal lors d'un calcul mathématique. Ce modèle est toujours largement utilisé en
informatique théorique, en particulier pour résoudre les problèmes de complexité algorithmique et de
calculabilité.
Turing Machine par Tom Dunne
American Scientist, Mars-Avril 2002
Une machine de Turing se compose des éléments suivants :
• Un « ruban » divisé en cases adjacentes. Chaque case contient un symbole parmi un
alphabet fini. L'alphabet contient un symbole spécial « blanc » et un ou plusieurs autres
symboles. Le ruban est de longueur infinie vers la gauche ou vers la droite (en d'autres
termes, la machine doit toujours avoir assez de longueur de ruban pour son exécution). On
considère que les cases non encore écrites du ruban contiennent le symbole « blanc ».
• Une « tête de lecture/écriture » qui peut lire et écrire les symboles sur le ruban, et se
déplacer vers la gauche ou vers la droite du ruban.
• Un « registre d'état » qui mémorise l'état courant de la machine de Turing. Le nombre d'états
possibles est toujours fini, et il existe un état spécial appelé « état de départ » qui est l'état
initial de la machine avant son exécution.
• Une « table d'actions » qui indique à la machine quel symbole écrire, comment déplacer la
tête de lecture (« G » pour une case vers la gauche, « D » pour une case vers la droite), et
quel est le nouvel état, en fonction du symbole lu sur le ruban et de l'état courant de la
machine. Si aucune action n'existe pour une combinaison donnée d'un symbole lu et d'un
état courant, la machine s'arrête.
Les machines de Turing sont une abstraction des ordinateurs :
• Le ruban représente la mémoire de l'ordinateur. Ceci comprend la mémoire centrale ainsi
que les mémoires externes telles les disques durs. Contrairement à un ordinateur, la
mémoire d'une machine de Turing est infinie.
• La tête de lecture/écriture représente le bus qui relie le microprocesseur à la mémoire. Une
autre différence entre une machine de Turing et un ordinateur est que l'ordinateur peut
accéder à la mémoire de manière directe, alors que la tête de lecture de la machine de
Turing ne se déplace que d'une position à la fois.
• Le registre d'états et la table d'actions représentent le microprocesseur. Le nombre d'états est
fini comme dans la réalité.
Didier Müller 6-5 Juin 2013

Programmation et langages
Exemple
La machine de Turing qui suit possède un alphabet {0, 1}, 0 étant le « blanc ». On suppose que le
ruban contient une série de 1, et que la tête de lecture/écriture se trouve initialement au-dessus du 1
le plus à gauche. Cette machine a pour effet de doubler le nombre de 1, en intercalant un 0 entre les
deux séries. Par exemple, « 111 » deviendra « 1110111 ». L'ensemble d'états possibles de la machine
est {e1, e2, e3, e4, e5} et l'état initial est e1. La table d'actions est la suivante :
État courant Symbole lu Symbole écrit Mouvement Nouvel état
e1
e2
e3
e4
e5
0 (Arrêt)
1 0 Droite e2
1 1 Droite e2
0 0 Droite e3
1 1 Droite e3
0 1 Gauche e4
1 1 Gauche e4
0 0 Gauche e5
1 1 Gauche e5
0 1 Droite e1
L'exécution de cette machine pourrait être par exemple (la position de la tête de lecture/écriture
sur le ruban est inscrite en caractères gras et rouges) :
Étape État Ruban
1 e1 11
2 e2 01
3 e2 010
4 e3 0100
5 e4 0101
6 e5 0101
7 e5 0101
8 e1 1101
9 e2 1001
10 e3 1001
11 e3 10010
12 e4 10011
13 e4 10011
14 e5 10011
15 e1 11011
16 (Arrêt)
Le comportement de cette machine peut être décrit comme une boucle :
• Elle démarre son exécution dans l'état e1, remplace le premier 1 par un 0.
• Puis elle utilise l'état e2 pour se déplacer vers la droite, en sautant les 1, et le premier 0
qu'elle rencontre.
• L'état e3 est alors utilisé pour sauter la séquence suivante de 1 (initialement aucun) et
Didier Müller 6-6 Juin 2013

L'informatique au lycée Chapitre 6
remplacer le premier 0 rencontré par un 1.
• e4 permet de revenir vers la gauche jusqu'à trouver un 0, et passer dans l'état e5.
• e5 permet ensuite à nouveau de se déplacer vers la gauche jusqu'à trouver un 0, écrit au
départ par l'état e1.
• La machine remplace alors ce 0 par un 1, se déplace d'une case vers la droite et passe à
nouveau dans l'état e1 pour une nouvelle itération de la boucle.
Ce processus se répète jusqu'à ce que e1 tombe sur un 0 (c'est le 0 du milieu entre les deux
séquences de 1) ; à ce moment, la machine s'arrête.
Exercice 6.1
Construisez les machines de Turing suivantes :
1. Une machine qui écrit 0 1 0 1 0 1 0 ... sur un ruban blanc.
2. Une machine qui multiplie par 2 son entrée binaire écrite sur le ruban.
3. Une machine qui ajoute 1 à son entrée binaire écrite sur le ruban.
Pour les questions 2 et 3, on suppose que la tête de lecture/écriture est positionnée sur le symbole
le plus à gauche.
6.3. Pseudo-code
En programmation, le pseudo-code est une façon de décrire un algorithme en respectant certaines
conventions, mais sans référence à un langage de programmation en particulier. L'écriture en pseudocode
permet de développer une démarche structurée, en « oubliant » temporairement la syntaxe
rigide d'un langage de programmation.
6.3.1. Conventions
Il n'existe pas de convention universelle pour le pseudo-code. Afin de bien se comprendre dans la
suite de ce cours, nous adopterons celle décrite ci-dessous.
Nom de l'algorithme
Par exemple : Calcul de la date de Pâques
Données d'entrées
Par exemple : Année > 1582
Résultat en sortie
Par exemple : Date de Pâques pour l'année donnée
Bloc tant que :
TANT QUE condition FAIRE
instruction
...
FIN TANT QUE
Bloc répéter jusqu'à :
REPETER
instruction
...
JUSQU'A condition
Bloc pour :
POUR i ALLANT DE d À f FAIRE
instruction
...
FIN POUR
Didier Müller 6-7 Juin 2013

Programmation et langages
Bloc si :
Tableau :
SI condition ALORS
instruction-si-vrai
...
SINON
instruction-si-faux
...
FIN SI
A[i] : l'élément de rang i dans le tableau A, on suppose les tableaux numérotés à partir de 0.
Tableau multidimensionnel A[i,j] :
Élément en ligne i et en colonne j du tableau A.
Chaine de caractères :
"string" (entre guillemets)
Affectation :
a := 10
Fonction :
FONCTION nom(paramètres)
instruction
...
RETOURNER résultat
Procédure :
PROCEDURE nom(paramètres)
instruction
...
résultat
6.3.2. En pratique
• Le pseudo-code doit être suffisamment précis pour que quelqu'un d'autre l'ayant lu sans
connaître l'algorithme soit capable de le coder.
• L'objectif est d'avoir le pseudo-code le plus simple possible, afin de le coder facilement et
sans bug. Le pseudo-code d'un petit algorithme prend en général une douzaine de lignes.
Pour un problème plus complexe, il faut compter jusqu'à 20 ou 25 lignes.
• Prévoyez assez de place pour faire tenir tout le pseudo-code sur une même page.
• Lorsqu'on commence à écrire le pseudo-code, on ne sait pas encore précisément ce qui va
venir ensuite. Il est judicieux de laisser des lignes blanches régulièrement pour pouvoir
ajouter des choses ensuite tout en gardant quelque chose de propre.
• Pour rendre compte visuellement des imbrications des boucles, indentez vers la droite le
corps des boucles et des fonctions. Sur le papier, on peut ajouter de grandes barres verticales
pour faire ressortir encore plus les différents blocs d'instructions.
6.3.3. Exemple de pseudo-code
Algorithme : Tri d'une liste de nombres
Donnée : Tableau A de n nombres
Résultat : Tableau A de n nombres triés par ordre croissant
Didier Müller 6-8 Juin 2013

L'informatique au lycée Chapitre 6
permut := 1
TANT QUE permut = 1 FAIRE
permut := 0
POUR i ALLANT DE 0 À n-2 FAIRE
SI A[i] > A[i+1] ALORS
echanger A[i] et A[i+1]
permut := 1
FIN SI
FIN POUR
FIN TANT QUE
6.4. Transformation du code source
Le code source n'est (presque) jamais utilisable tel quel. Il est généralement écrit dans un langage
« de haut niveau », compréhensible pour l'homme, mais pas pour la machine. Il existe deux stratégies
de traduction, ces deux stratégies étant parfois disponibles au sein du même langage.
• Le langage traduit les instructions au fur et à mesure qu'elles se présentent. Cela s'appelle la
compilation à la volée, ou l'interprétation.
• Le langage commence par traduire l'ensemble du programme en langage machine,
constituant ainsi un deuxième programme (un deuxième fichier) distinct physiquement et
logiquement du premier. Ensuite, et ensuite seulement, il exécute ce second programme.
Cela s'appelle la compilation.
6.4.1. Compilation
Certains langages sont « compilés ». En toute généralité, la compilation est l'opération qui
consiste à transformer un langage source en un langage cible. Dans le cas d'un programme, le
compilateur va transformer tout le texte représentant le code source du programme, en code
compréhensible pour la machine, appelé code machine.
Dans le cas de langages compilés, ce qui est exécuté est le résultat de la compilation. Une fois
effectuée, l'exécutable obtenu peut être utilisé sans le code source.
6.4.2. Interprétation
D'autres langages ne nécessitent pas de phase spéciale de compilation. La méthode employée
pour exécuter le programme est alors différente. Le programme entier n'est jamais compilé. Chaque
ligne de code est compilée « en temps réel » par un programme. On dit de ce programme qu'il
interprète le code source. Par exemple, Python est un langage interprété.
Cependant, ce serait faux de dire que la compilation n'intervient pas. L'interprète produit le code
machine, au fur et à mesure de l'exécution du programme, en compilant chaque ligne du code source.
6.4.3. Avantages, inconvénients
Les avantages généralement retenus pour l'utilisation de langages « compilés », est qu'ils sont
plus rapides à l'exécution que des langages interprétés, car l'interprète doit être lancé à chaque
exécution du programme, ce qui mobilise systématiquement les ressources.
Les langages interprétés offrent en revanche une certaine portabilité, ainsi qu'une facilité pour
l'écriture du code. En effet, il n'est pas nécessaire de passer par la phase de compilation pour tester le
code source.
Didier Müller 6-9 Juin 2013

Programmation et langages
6.5. Paradigmes
En informatique, un paradigme est une une façon de programmer, un modèle qui oriente notre
manière de penser pour formuler et résoudre un problème.
Certains langages sont conçus pour supporter un paradigme en particulier (Smalltalk et Java
supportent la programmation orientée objet, tandis que Haskell est conçu pour la programmation
fonctionnelle), alors que d'autres supportent des paradigmes multiples (à l'image de C++, Common
Lisp, OCaml, Python, Ruby ou Scheme).
6.5.1. Programmation impérative
C'est le paradigme le plus ancien. Les recettes de cuisine et les itinéraires routiers sont deux
exemples familiers qui s'apparentent à de la programmation impérative. La grande majorité des
langages de programmation sont impératifs. Les opérations sont décrites en termes de séquences
d'instructions exécutées par l'ordinateur pour modifier l'état du programme.
Niklaus Wirth
Edsger Wybe
Dijkstra
6.5.2. Programmation structurée (ou procédurale)
La programmation structurée constitue un sous-ensemble de la programmation impérative. C'est
un paradigme important de la programmation, apparu vers 1970. Elle dérive de travaux de Niklaus
Wirth pour son Algol W et reçut son coup d'envoi avec l'article fondateur de Dijkstra dans
Communications of the ACM intitulé GO TO statement considered harmful.
Elle est en effet célèbre pour son essai de suppression de l'instruction GOTO ou du moins pour la
limitation de son usage.
La programmation structurée est possible dans n'importe quel langage de programmation
procédural, mais certains, comme le Fortran IV, s'y prêtaient très mal. Vers 1970, la programmation
structurée devint une technique populaire, et les langages de programmation procéduraux intégrèrent
des mécanismes rendant aisée la programmation structurée. Parmi les langages de programmation les
plus structurants, on trouve PL/I, Pascal et, plus tardivement pour les projets de très grande taille,
Ada.
Exemple
Dans certains langages anciens comme le BASIC, les lignes de programmation portent des
numéros, et les lignes sont exécutées par la machine dans l'ordre de ces numéros. Dans tous ces
langages, il existe une instruction de branchement, notée « aller à » en pseudo-code, instruction qui
envoie directement le programme à la ligne spécifiée. Inversement, ce type de langage ne comporte
pas d'instructions comme « Fin Tant Que », ou « Fin Si », qui ferment un bloc.
Prenons l'exemple d'une structure « Si … Alors … Sinon »
Programmation Structurée
Si condition Alors
instructions 1
Sinon
instructions 2
FinSi
Programmation non structurée
1000 Si condition Alors Aller En 1200
1100 instruction 1
1110 etc.
1120 etc.
1190 Aller en 1400
1200 instruction 2
1210 etc.
1220 etc.
1400 suite de l'algorithme
Les programmeurs décomposent leur code en procédures ne dépassant guère 50 lignes, afin
d'avoir le programme en entier sous leurs yeux.
Une procédure, aussi appelée routine, sous-routine, module ou fonction, contient une série
d'étapes à réaliser. N'importe quelle procédure peut être appelée à n'importe quelle étape de
l'exécution du programme, incluant d'autres procédures, voire la procédure elle-même (récursivité).
Didier Müller 6-10 Juin 2013

L'informatique au lycée Chapitre 6
Il n'y a que des avantages à découper un programme en procédures :
• on a la possibilité de réutiliser le même code à différents emplacements dans le programme
sans avoir à le retaper ;
• il est plus simple de suivre l'évolution du programme (la programmation procédurale permet
de se passer d'instructions « GOTO ») ;
• on crée un code plus modulaire et structuré ;
• chaque programmeur peut développer son bout de code de son côté.
6.5.3. Programmation orientée objet
La programmation orientée objet (POO) ou programmation par objet, est un paradigme de
programmation informatique qui consiste en la définition et l'assemblage de « briques logicielles »
appelées objets. Un objet représente un concept, une idée ou toute entité du monde physique, comme
une voiture, une personne ou encore une page d'un livre. Le langage Simula-67 jette les prémisses
de la programmation objet, résultat des travaux sur la mise au point de langages de simulation
informatique dans les années 1960 dont s'inspira aussi la recherche sur l'intelligence artificielle dans
les années 1970-80. Mais c'est réellement par et avec Smalltalk 72 puis Smalltalk 80, inspiré en
partie par Simula, que la programmation par objets débute et que sont posés les concepts de base de
celle-ci : objet, messages, encapsulation, polymorphisme, héritage, etc.
À partir des années 1980, commence l'effervescence des langages à objets : Objective C (début
des années 1980), C++ (C with classes) en 1983, Eiffel en 1984, Common Lisp Object System
dans les années 1980, etc. Les années 1990 voient l'âge d'or de l'extension de la programmation par
objet dans les différents secteurs du développement logiciel.
Quelques langages à objets : Ada, Java, C#, Objective C, Eiffel, Python, C++, PHP,
Smalltalk...
6.5.4. Programmation fonctionnelle
La programmation fonctionnelle est un paradigme de programmation qui considère le calcul en
tant qu'évaluation de fonctions mathématiques et rejette le changement d'état et la mutation des
données. Elle souligne l'application des fonctions, contrairement au modèle de programmation
impérative qui met en avant les changements d'état.
Le langage fonctionnel le plus ancien est Lisp, créé en 1958 par McCarthy. Lisp a donné
naissance à des variantes telles que Scheme (1975) et Common Lisp (1984). Haskell (1987) est
aussi un langage à paradigme fonctionnel. La programmation fonctionnelle s'affranchit de façon
radicale des effets secondaires en interdisant toute opération d'affectation.
Le paradigme fonctionnel n'utilise pas de machine d'états pour décrire un programme, mais un
emboîtement de « boîtes noires » que l'on peut imbriquer les unes dans les autres. Chaque boîte
possédant plusieurs paramètres en entrée mais une seule sortie, elle ne peut sortir qu'une seule valeur
possible pour chaque n-uplet de valeurs présentées en entrée. Ainsi, les fonctions n'introduisent pas
d'effets de bord. Un programme est donc une application, au sens mathématique, qui ne donne qu'un
seul résultat pour chaque ensemble de valeurs en entrée. Cette façon de penser, qui est très différente
de la pensée habituelle en programmation impérative, est l'une des causes principales de la difficulté
qu'ont les programmeurs formés aux langages impératifs pour aborder la programmation
fonctionnelle. Cependant, elle ne pose généralement pas de difficultés particulières aux débutants qui
n'ont jamais été exposés à des langages impératifs.
Exercice 6.2
Expliquez cette description de Python, tirée de Wikipédia :
« Python est un langage de programmation interprété multi-paradigme. Il favorise la
programmation impérative structurée, et orientée objet. »
Didier Müller 6-11 Juin 2013

Programmation et langages
6.6. Les notions principales de la programmation
La plupart des langages de programmation ont des caractéristiques communes que nous allons
passer rapidement en revue ici.
6.6.1. L'affectation
Une affectation est une opération qui permet d'attribuer une valeur à une variable. Pour expliquer
ce qui se passe lors d'une affectation, il faut imaginer qu'il existe, dans un recoin de l'ordinateur, une
case mémoire appelée x. L'instruction x=t consiste à remplir la case x avec la valeur de l'expression
t. Si x contenait déjà une valeur, celle-ci est écrasée.
Exemples
Après l'affectation x=3, la variable x contiendra la valeur 3.
Après y=4+x, la variable y contiendra la valeur 7.
Affectation et comparaison
Il ne faut pas confondre l'affectation avec la comparaison. Par exemple, la comparaison x==3
permet de savoir si oui ou non la valeur de la variable x est 3. Dans la plupart des langages, on
différencie ces deux opérations. En Python, l'affectation est exprimée par un « = », tandis que la
comparaison est exprimée par « == ». D'autres langages (Pascal par exemple) utilisent
respectivement les opérateurs « := » et « = ».
Incrémentation / décrémentation
Il arrive fréquemment que l'on doive incrémenter (ou décrémenter) une variable, c'est-à-dire
augmenter (ou diminuer) sa valeur d'une ou plusieurs unités. Dans ce cas, on peut utiliser
l'instruction x=x+1 7 . Voici ce qui se passe : on prend la valeur contenue dans x, on y ajoute 1, puis
on remet le nouveau résultat dans la variable x.
L'instruction x=x+1 est tellement fréquente qu'il existe souvent des raccourcis : x+=1 (Python)
ou x++ (C, Mathematica).
6.6.2. Les tests
Un test est une instruction du genre si...alors...sinon. La suite du programme dépendra du résultat
du test.
SI Test 1 ALORS
Instruction 1
SINON
Instruction 2
FIN SI
Instruction 3
Par exemple, en Python, on aura :
if x>=10:
x=x-20
else:
x=x+2
7 Remarquez bien que cette expression n'a mathématiquement aucun sens
Didier Müller 6-12 Juin 2013

L'informatique au lycée Chapitre 6
Le même test en Java serait :
if (x>=10) x=x-20 else x=x+2
On peut enchaîner autant d'instructions « sinon si » que l'on veut : seule la première dont la
condition sera vérifiée sera exécutée. On peut généralement associer une clause sinon qui ne sera
exécutée que si aucune clause sinon si n'a été vérifiée.
SI Test 1 ALORS
Instruction 1
SINON SI Test 2 ALORS
Instruction 2
FIN SI
Instruction 3
Par exemple, en Python 3 :
if x==0:
print("x est nul")
elif x

Programmation et langages
heure 0 minute, 1 heure 1 minute, ... On voit qu'une première boucle parcourra les heures, tandis que
la deuxième parcourra les minutes, et que l'on incrémentera l'heure seulement quand 60 minutes
seront passées. Voilà ce que cela donnera en Python 3 :
h=0
while h

L'informatique au lycée Chapitre 6
En Pascal :
En C :
for i := depart to fin do instruction;
Itérateur
Un itérateur est un objet qui permet de réaliser une boucle parcourant tous les éléments contenus
dans une structure de données (par exemple une liste).
POUR CHAQUE valeur DANS collection
Instruction 1
FIN POUR CHAQUE
Instruction 2
Exemple en Python :
for animal in ["chat", "chien", "poule"] :
print(animal)
6.6.4. Les sous-programmes
Un sous-programme est un ensemble d'instructions pouvant être appelé depuis plusieurs endroits
du programme. Les sous-programmes sont utilisés pour améliorer la structure du programme et sa
lisibilité. Ces constructions ajoutent la notion de passage de paramètres et aussi la notion de variables
locales qui évite que le sous-programme ait un effet de bord sur la routine appelante.
Une fonction peut d'une part effectuer une action (par exemple afficher un résultat), et d'autre
part retourner une valeur. Une fonction qui ne renvoie pas de valeur est appelée une procédure.
Portée d'une variable
En Python, une variable définie au moment où elle est affectée d'une valeur. Une variable définie
dans le programme principal est visible de l'intérieur des fonctions, mais une variable définie dans
une fonction n'est pas visible de l'extérieur (à moins d'utiliser l'instruction global). Deux variables
peuvent donc avoir le même nom mais être différentes selon l'endroit où elles sont définies.
Dans une fonction, Python utilise une variable définie localement. S'il elle n'est pas définie
localement, Python recherche la variable au niveau global, mais dans ce cas, il n'est pas possible de
modifier la variable globale.
Prenons un exemple en Python :
def ecrire():
n = 3
print(n,end=' ')
n=5
ecrire()
print(n)
Didier Müller 6-15 Juin 2013

Programmation et langages
Tous ces exemples
sont très mauvais
du point de vue de
la lisibilité. Il faut
éviter d'écrire des
programmes
pareils ! Ils sont
juste là pour
préciser le concept
de portée d'une
variable.
Ce programme écrira 3 5. On voit bien que les deux n sont des variables différentes, puisque
l'instruction n=3 n'a pas modifié la valeur de l'autre n. Le n de la deuxième ligne est une variable
locale à la procédure ecrire, tandis que celui de la cinquième ligne est une variable locale.
Modifions légèrement ce programme :
def ecrire():
n += 3
print(n,end=' ')
n=5
ecrire()
print(n)
Ce programme produira une erreur, car le n local dans la procédure écrire n'a pas été initialisé.
Pour finir avec cet exemple, le programme ci-dessous donnera comme résultat 3 3. La ligne
global n signale que n est la variable globale initialisée dans le programme principal. Il ne s'agit
donc plus d'une variable locale. Il n'y a là plus qu'une seule variable n.
def ecrire():
global n
n = 3
print(n,end=' ')
n=5
ecrire()
print(n)
Passage de paramètres
On peut passer des paramètres à une procédure ou une fonction sous forme d'une liste de
paramètres formels entre parenthèses. A l'intérieur du corps de la procédure, les paramètres sont des
variables locales.
Il ne faut pas redéclarer le nom des paramètres dans la section des déclarations locales. Voici un
exemple en Pascal 8 , qui calcule x n (naïvement) :
var n : integer;
function puissance(x:real; n:integer) : real;
var p:real;
begin
p:=1;
while n>0 do
begin
p:=p*x;
n:=n-1
end;
puissance:=p
end;
begin
n:=3;
writeln('Pi au cube =',puissance(3.14159,n));
writeln(n) (*la valeur de n n'a pas été modifiée*)
end.
C'est la valeur du paramètre qui est passé à la procédure. Si la valeur est modifiée à l'intérieur de
la procédure, la modification n'est pas répercutée à la sortie de la procédure. On appelle ce type de
passage de paramètre un passage par valeur.
8 En Pascal, toutes les variables doivent être déclarées, ce qui n'est pas le cas en Python, où les variables « viennent au monde » en se voyant
assigner une valeur et sont automatiquement détruites lorsqu'elles se retrouvent hors de portée.
Didier Müller 6-16 Juin 2013

L'informatique au lycée Chapitre 6
Dans certains langages, il est possible de passer des variables comme paramètres. On appelle cela
un passage par variable ou passage par référence. Toute modification du paramètre dans la fonction
appelée entraîne alors la modification de la variable passée en paramètre.
Voici un autre programme en Pascal, qui échange les valeurs de deux variables :
var x,y : real;
Remarquez bien le
mot-clef var entre
les parenthèses qui
fait toute la
différence.
procedure echanger(var a,b:real)
var aux:real;
begin
aux:=a; a:=b; b:=aux
end;
begin
x:=3; y:=4;
echanger(x,y);
writeln(' x=',x, ', y=',y)
end.
Ce programme écrira x=4, y=3.
Puisque la procédure attend des variables en paramètres, on ne peut pas appeler echanger avec
des valeurs (echanger(3,4) est interdit, car 3 et 4 ne sont pas des variables : on ne peut pas les
modifier).
En Python, le passage des paramètres se fait toujours par référence, MAIS certains types sont
« immutables », c'est-à-dire non modifiables. Les règles sont les suivantes :
• si un paramètre transmis à une fonction est une valeur immutable (les nombres et les
chaînes de caractères), la fonction n'aura aucun moyen de modifier l'original. La valeur de
départ est conservée ;
• si un paramètre est une valeur mutable (les listes par exemple), la fonction pourra modifier
l'original, et avoir ainsi un effet de bord 9 (désiré ou non).
Prenons un exemple (vicieux) :
def ecrire(x):
x=5
print(x,end=' ')
x=0
ecrire(x)
print(x)
Le résultat sera 5 0, alors que l'on s'attendait plutôt à 5 5. Cela vient du fait que le type entier est
immutable.
Par contre :
def ecrire(x):
x[0]=5
# on modifie le 1er élément de la liste x
print(x[0],end=' ')
x=[0,1,2,3,4]
ecrire(x)
print(x[0])
produira 5 5, car une liste est mutable. D'une manière générale, il vaut mieux éviter les effets de
bords, afin d'avoir un programme plus lisible.
9 En informatique, une fonction est dite à effet de bord si elle modifie un état autre que sa valeur de retour.
Didier Müller 6-17 Juin 2013

Programmation et langages
Sources
[1] Pixel, « Diagram and history of programming languages »,
[2] Wikipédia, « Langages de programmation »,
[3] Wikipédia, « Programmation informatique »,
[4] Wikipédia, « Machine de Turing »,
[5] Wikipédia, « Paradigme (programmation) »,
[6] Wikipédia, « Machine de Turing »,
Didier Müller 6-18 Juin 2013