Initiation `a la programmation

Chapitre 2
Initiation à la programmation
2.1
Notion d’algorithme
Python est un langage interprété. Ceci veut dire qu’à chaque fois que Python rencontre un appui sur la
touche < Entree >, il exécute l’instruction qu’on vient de lui fournir. L’exécution de cette instruction est effectuée par l’interpréteur qui se charge de traduire l’instruction écrite sous Python en ordres compréhensibles
par l’ordinateur, qui euxmêmes se transformeront en signaux envoyés aux circuits électroniques de l’ordinateur.
Le terme interpréteur peut prêter à confusion. Python est incapable d’interpréter une instruction autrement
que comme un ordre impératif. Il applique chaque instruction (c’est-à-dire chaque ordre) sans aucun recul, sans
aucun état d’âme, même si cela aboutit parfois à un résultat très éloigné de ce que le programmateur avait en
tête. Incapable d’empathie avec le programmateur, un ordinateur ne réinterprète jamais un ordre de sa propre
initiative. C’est une machine qui fait exactement ce qu’on lui dit de faire, mais pas forcément ce qu’on voudrait
qu’il fasse. Ecrire un programme sous Python, c’est écrire des instructions compréhensibles pour l’interpréteur
de Python. L’art de programmer, c’est agencer et imbriquer ces instructions de manière judicieuse pour faire
calculer par l’ordinateur un résultat voulu. C’est à la charge du programmateur de comprendre comment Python
effectue précisément chaque instruction pour pouvoir prévoir l’exécution du programme.
Dans cette optique, il est fondamental de pouvoir écrire en termes clairs une séquence ou une imbrication d’instructions pour détailler un algorithme. Nous verrons essentiellement trois façons d’effectuer cette description :
Méthode 1 : Ecrire le programme directement en Python. C’est une façon rigoureuse de détailler un algorithme,
mais ce n’est pas forcément la façon la plus intelligible, et elle n’est pas adaptée à la description
succincte de gros programmes.
Méthode 2 : le pseudocode. On détaille un algorithme avec des mots en français, avec une syntaxe proche de
Python mais plus souple. La traduction du pseudocode en Python est relativement aisée, et il
est facile de traduire le pseudocode vers n’importe quel autre langage. Par ailleurs, quand il faut
écrire de gros programmes, le pseudocode peut s’adapter avec des mots qui décrivent des parties
de programme plutôt que des instructions. En pseudocode, on utilise les notations suivantes :
— Une affectation se note avec la flèche ←. Par exemple l’affectation a ← 5 se traduira en Python
par a = 5.
— Le test d’égalité se note indifféremment = ou == (alors qu’en Python on le note ==).
Méthode 3 : le graphe du flux des instructions. On représente une instruction dans un rectangle si elle n’a
qu’une seule suite possible ; et dans un losange si elle ouvre la voie à plusieurs possibilités de suite.
Des flèches représentent l’ordre de déroulement des instructions. Nous verrons très bientôt ce genre
de représentation. Un graphe de flux est un outil très utile pour bien visualiser sur des exemples
de programmes courts le séquençage des instructions.
2.2
Instructions conditionnelles
Il est possible de réaliser des instructions seulement si une condition est vérifiée
11
2.3. BOUCLES INCONDITIONNELLES
CHAPITRE 2. INITIATION À LA PROGRAMMATION
>>> x = 0
>>> if 17%2 == 1 :
x=x+1
...
>>> x
1
Ici, une des particularités de Python entre en jeu. Pour indiquer à Python le bloc d’instruction à exécuter si
la condition est vérifiée, ce bloc d’instruction doit être indenté, c’est-à-dire être mis en retrait par rapport à la
marge gauche. Il suffit pour cela de mettre au début de chaque ligne de ce bloc des espaces ou une tabulation
pour placer le nouveau bloc plus à droite. On peut utiliser au choix un nombre fixe d’espaces ou une tabulation
mais il faut prendre garde à conserver ce choix tout au long du bloc. Cette indentation se substitue aux blocs
begin...end de nombreux langages. Par exemple, ceci est valide :
>>> if 17%2 == 1 :
x+ = 1
x∗ = x
mais ceci ne l’est pas :
>>> if 17%2 == 1 :
x+ = 1
x∗ = x
On peut effectuer des instructions si la condition n’est pas vérifiée grâce à l’instruction else qui doit se
trouver au même niveau que le if :
>>> if 17%2 == 1 :
x+ = 1
else :
x+ = 2
Il est également possible et même recommandé d’abréger les tests imbriqués à l’aide de elif. Ainsi, au lieu
d’écrire :
>>> if n%3 == 0 :
x+ = 1
else :
if n%3 == 1 :
x+ = 3
else :
x∗ = x
on utilisera :
>>> if n%3 == 0 :
x+ = 1
elif n%3 == 1 :
x+ = 3
else :
x∗ = x
Cette dernière version permet ainsi de placer tous les blocs d’instructions dans un même niveau d’indentation,
ce qui accroı̂t la lisibilité.
2.3
Boucles inconditionnelles
Lorsque l’on souhaite répéter un bloc d’instructions un nombre déterminé de fois, on peut utiliser un compteur actif, c’est-à-dire une variable qui compte le nombre de répétitions et va donc conditionner la sortie de la
12
CHAPITRE 2. INITIATION À LA PROGRAMMATION
2.4. BOUCLES CONDITIONNELLES
boucle. Les boucles bornées sont introduites par le mot-clé for.
Exemple classique : le calcul de la factorielle.
>>> n = 100
>>> r = 1
>>> for i in range(1, n+1) :
r∗ = i
...
>>> r
9332621544394415268169923885626670049071596826438162146859296389521759999322991560894146397615651
8286253697920827223758251185210916864000000000000000000000000L
Remarquez la syntaxe : pour effectuer une itération bornée de la variable i de a inclus à b exclu, on dit que
i doit parcourir la liste range(a,b). Attention, range(a,b) est l’intervalle d’entiers [a,b[ ouvert à droite, d’où le
n+1 dans le code ci-dessus.
Dans le programme précédent, le pas d’incrémentation n’étant pas spécifié, il est par défaut égal à +1. Si
on désire un autre pas d’incrémentation, on le précisera ainsi que le montre l’exemple suivant :
>>> n = 100
>>> r = 1
>>> for i in range(1, n+1,2) : # On a choisi un pas d’incrémentation égal à 2
r∗ = i
...
>>> r
Ici , on a choisi un pas égal à 2 . Au fait, que calcule le programme précédent ?
On peut aussi itérer sur une liste arbitraire :
>>> premiers = [2, 3, 5, 7, 11, 13, 17]
>>> prod = 1
>>> for x in premiers :
prod ∗ = x
...
>>> prod
510510
ou sur une chaı̂ne de caractères :
>>> for i in ’les caracteres’ :
print(i , end=’*’)
l*e*s* *c*a*r*a*c*t*e*r*e*s
2.4
Boucles conditionnelles
Cette structure permet d’executer un bloc d’instructions autant de fois qu’une condition est vérifiée. On
réalise une boucle conditionnelle à l’aide du mot-clé while suivi de la condition ponctuée d’un deux-points.
Vient alors le bloc d’instruction à répéter, ce dernier étant délimité par l’indentation.
>>> n = 42
>>> while n! = 0 :
n/ = 2
...
Le déroulement de la boucle est alors le suivant :
— On teste la condition : ici, n est-il non nul ?
13
2.5. COMPLÉMENTS
CHAPITRE 2. INITIATION À LA PROGRAMMATION
— Si la condition est vérifiée, l’évaluation de l’expression booléenne renvoie la valeurt True, Python effectue
les instructions et on revient au début de la boucle.
— Si elle n’est pas vérifiée, l’évaluation de l’expression booléenne renvoie la valeur False et on sort de la
boucle .
2.5
Compléments
Aussi bien dans les boucles for ou while, on peut utiliser ces deux instructions :
— break : interrompt la boucle.
— continue : termine le tour de boucle en cours et retourne au début de la boucle (avec itération suivante
pour une boucle for, ou test de la condition pour une boucle while).
Exemples :
PB1 : Que fait le programme suivant ?
>>> a = 0
>>> while (a >= 0) :
a+=1
if (a==5) :
continue
elif ( a==10) :
break
else :
print a
PB2 : Qu’affiche le programme suivant ?
>>> for i in range(11) :
if i % 2 :
continue
else :
print i
PB3 : Même question pour :
>>> l = [2, 3, 5, 7]
>>> i = 0
>>> for n in l :
if i == n :
break
i+ = 1
...
>>> i
4
14
CHAPITRE 2. INITIATION À LA PROGRAMMATION 2.6. RÈGLES DE BONNE PROGRAMMATION
2.6
Règles de bonne programmation
Bien programmer, c’est d’abord réfléchir avant d’écrire. Avant de saisir un programme sur l’ordinateur, il faut
toujours, en s’armant d’un papier et d’un crayon :
1. Analyser le problème à résoudre.
2. Déterminer les variables nécessaires à sa résolution.
3. Elaborer un premier schéma d’algorithme.
Un programme doit pouvoir être lu et relu. Pour faciliter ces échanges, quelques règles s’imposent :
1. Utiliser des noms de variables et de fonctions explicites.
2. Commenter les différentes étapes du programme avec le caractère #.
3. Documenter les fonctions (cf. Chapitre 4).
Enfin, quelques règles de présentation sont à respecter :
1. Placer un espace après une virgule, un point-virgule ou deux-points ;
2. Ne pas placer d’espace avant une virgule, un point-virgule ou deux-points ;
3. Placer un espace de chaque côté d’un opérateur ;
4. Ne pas placer d’espace entre le nom d’une fonction et sa liste d’arguments.
5. Indenter, c’est à dire décaler le texte par rapport à la marge.
2.7
Exercices
Ex 1 : Quelle est la valeur de la variable y après la suite d’instructions suivante ?
p=1
d=0
r=0
h=1
z=0
f = p and (d or r)
g = not r
m = not p and not z
g = g and (d or h or m)
if f or g : y = 1
else : y = 0
Ex 2 : Quelle est la valeur de la variable ok après la suite d’instructions suivante ?
x=2
y=3
d=5
h=4
if x > 0 and x < d :
if y > 0 and y < h : ok = 1
else : ok = 0
else : ok = 3
Ex 3 : Quelle est la valeur de la variable y après la suite d’instructions suivante ?
x=3
y = -2
if x < y : y = y − x
elif x == y : y = 0
else : y = x − y
15
2.7. EXERCICES
CHAPITRE 2. INITIATION À LA PROGRAMMATION
Ex 4 : Quelle est la valeur de la variable s à la fin des instructions suivantes ?
b=2
k=8
n = 23
s=0
i = k-1
q=n
while q != 0 and i >= 0 :
s = s + (q%b)*b**(k-1-i)
print q%b
q = q/b
i = i-1
Ex 5 : Qu’affichent les itérations suivantes ?
for n in range(0,15) :
f =1
f1 = 1
f2 = 1
for i in range(2,n+1) :
f = f1 + f2
f2 = f1
f1 = f
print f
Ex 6 : Initialiser deux entiers (par exemple a = 0 et b = 10). Ecrire une boucle affichant et incrémentant la
valeur de a d’une valeur (à saisir) tant qu’elle reste inférieure à celle de b.
Ex 7 : Utiliser l’instruction break pour interrompre une boucle for d’affichage des entiers compris entre 1 et
15 compris lorsque la variable de boucle vaut 8.
Ex 8 : Utiliser l’instruction continue pour qu’une boucle for d’affiche tous les entiers compris entre 1 et 15
compris sauf lorsque la variable de boucle vaut 5.
Ex 9 : Ecrire un programme qui affiche une suite de 12 nombres dont chaque terme est le triple du précédent,
chaque terme étant séparé par le symbole +.
Ex 10 : Ecrire un programme qui calcule les 50 premiers termes de la table de multiplication par 13 mais qui
n’affiche que ceux qui sont multiples de 7 .
Ex 11 : Ecrire un programme qui affiche la suite de symboles suivante, le nombre de ligne étant à préciser à
l’appel du programme :
*
**
***
****
*****
******
*******
puis transformer le programme pour obtenir pour obtenir un triangle symétrique par rapport à sa hauteur.
Ex 12 : Ecrire un programme qui affiche les 20 premiers termes de la table de multiplication par 7. Le résultat
devra être de la forme :
16
CHAPITRE 2. INITIATION À LA PROGRAMMATION
2.7. EXERCICES
1 fois 7 fait 7
2 fois 7 font 14
etc...
(On fera attention à l’orthographe).
Ex 13 : Ecrire un programme qui calcule la somme des inverses des carrés des n (à saisir) premiers entiers naturels (on fera tout d’abord la somme de 1 à n , puis de n à 1 et on commentera les résultats obtenus).
Ex 14 : Saisir un entier entre 2 et 12. Ecrire un programme qui donne le nombre de façons de faire n en lançant
deux dés.
Ex 15 : Ecrire un programme qui étant donné deux entiers n et m (à saisir) renvoie la liste des couples d’entiers
de [0; n] × [0; m].
Ex 16 : Ecrire un programme qui teste si un entier naturel n (à saisir) est premier .
Ex 17 : Saisir deux entiers naturels n et p. Ecrire un programme qui détermine la puissance la plus élevée de p
qui divise n et qui renvoie n non divisible par p si p ne divise pas n.
Ex 18 : Ecrire un programme qui donne les chiffres d’un entier n, séparés par un espace.
Ex 19 : Calculer la somme des chiffres composant un entier naturel n. On vérifiera le résultat avec n = 100!, le
résultat étant alors : .
Ex 20 : Ecrire un programme qui compte le nombre de mots dans une phrase ( deux mots étant séparés par un
espace).
Ex 21 : Ecrire un programme qui donne le plus grand entier naturel inférieur ou égal à un réel strictement positif
a.
Exemple : a = 5, 8765443. Le programme répond 5.
n
Ex 22 : (a) Ecrire un programme qui calcule le coefficient binomial
en n’utilisant que des multiplications.
k
(b) Transformer le programme précédent pour obtenir le triangle de pascal pour une valeur de n donnée.
Exemple : si n=4, on veut obtenir à l’affichage :
n=2 : 1 2 1
n=3 : 1 3 3 1
n=4 : 1 4 6 4 1
Ex 23 : (a) Ecrire un programme qui donne tous les n premiers nombres ne contenant que le chiffre 1.
Exemple : n=4 : 1 11 111 1111
(b) Transformer le programme précedant pour déterminer, parmi les nombres construits, les p premiers
qui sont de plus divisible par 13.
(
si un est pair
. La conjecture de
3un + 1 sinon
Syracuse, encore appelée conjecture de Collatz, conjecture d’Ulam, conjecture tchèque ou problème 3x+1
est l’hypothèse mathématique selon laquelle la suite de Syracuse de n’importe quel entier strictement
positif atteint 1.
Ex 24 : On définit la suite de syracuse (un ) par : u0 = a et ∀n ∈ N un+1 =
un
2
(a) Ecrire un programme qui détermine le plus petit entier n tel que un = 1 (= temps de vol), partant
d’une valeur a à préciser.
Exemple : a=15 n=17 et a=127 n=46.
17
2.7. EXERCICES
CHAPITRE 2. INITIATION À LA PROGRAMMATION
(b) Transformer le programme précédent pour qu’il précise ,de plus, valeur maximale atteinte(=hauteur
de vol).
Exemple : a=15 max = 160 et a=127 max =4372.
(c) Enfin, transformer le programme précédent pour qu’il affiche le temps de vol en altitude : c’est le
plus petit indice n tel que un+1 < u0 .
Il est de 10 pour la suite de Syracuse u0 = 15 et de 23 pour la suite de Syracuse u0 = 127.
Historique de la suite de syracuse : Dès 1928, Lothar Collatz s’intéressait aux itérations dans les nombres
entiers, qu’il représentait au moyen de graphes et d’hypergraphes. Il inventa alors le problème 3x + 1,
et le présentait souvent ensuite dans ses séminaires. En 1952, lors d’une visite à Hambourg, Collatz
expliqua son problème à Helmut Hasse. Ce dernier le diffusa en Amérique à l’université de Syracuse :
la suite de Collatz prit alors le nom de ” suite de Syracuse”. Entre temps, le mathématicien polonais
Stanislas Ulam le répand dans le Laboratoire national de Los Alamos. Dans les années 1960, le problème
est repris par le mathématicien Shizuo Kakutani qui le diffuse dans les universités de Yale et Chicago.
Cette conjecture mobilisa tant les mathématiciens durant les années 1960, en pleine guerre froide, qu’une
plaisanterie courut selon laquelle ce problème faisait partie d’un complot soviétique visant à ralentir la
recherche américaine.
18