I11: Chapitre 2

Structures de controle Nicolas Meloni Licence 1: 1er semestre (2018/2019)

================================
Sequences d'instructions
================================

Les instructions d’un script sont executees sequentiellement 
i.e. les unes apres les autres dans l'ordre de lecture du script.

# Script 1
a , b = 1 ,2
a = b
b = a
print (a , b )

# Script 2
a , b = 1 ,2
b = a
a = b
print (a , b )

>>>
2 2

>>>
1 1

================================
Sequence d'instructions
================================

Il est necessaire de pouvoir perturber l'ordre d’execution pour 
ecrire des "vrais" programmes . Il existe deux grandes categories 
de controleurs de flux :

-- alternative : opérateurs de selection (if-elif-else )
-- itérative   : opérateurs de répétition (while-for)

================================
Instruction alternative simple
================================

syntaxe :


if condition :
<tab>    instruction 1
<tab>    ...
<tab>    instruction N


condition est une exoression de type booléeen.


semantique :

si condition est vraie, les instructions 1 à N  sont executees, 
sinon elles sont ignorées. 


*** La tabulation decrit la portee de l'instruction  *** 
 


# Script 1
a = 10
if a > 5 :
   a = a + 5
   a = a * 2
print ( a )
>>>
30

# Script 2
a = 4
if a > 5 :
   a = a + 5
a = a * 2
print ( a )
>>>
4

================================
instruction alternative complete
================================

syntaxe :


if condition :
<tab>    instruction A-1
<tab>    ...
<tab>    instruction A-N
else  :
<tab>    instruction B-1
<tab>    ...
<tab>    instruction B-N

condition est une expression de type booléeen.


semantique :
si condition est vraie  alors la sequence d'instruction A 
est executee sinon la sequence d'instruction B est executee.    


La tabulation decrit la portee de l'instruction !

================================
La structure if-elif-else
================================

Syntaxe :

if   condition_1 :
     sequence_1
elif condition_2 :
     sequence_2
elif condition_3 :
     sequence_3
...
elif condition_N :
     sequence_N
else:
     sequence

Une condition est testée seulement si toutes les précédentes 
valent faux. Une seule des séquences d’instructions sera executee !


Exemples


# Script 1
a = 10
if a >= 10:
   print ( " >= 10 " )
elif a <10 and a >0 :
   print ( " 0 < <10 " )
else :
   print ( " < 0 " )

>>>
>= 10


# Script 2
a = 5
if a >= 10:
    print ( " >= 10 " )
elif a <10 and a >0:
    print ( " 0 < <10 " )
else :
   print ( " <0 " )
>>>
0 < <10


# Script 3
a = -2
if a >= 10:
   print ( " >= 10 " )
elif a <10 and a >0:
   print ( " 0 < <10 " )
else :
  print ( " <0 " )
>>>
<0


================================
La boucle tant que
================================

Syntaxe :


while condition :
	instruction_1
	...
	instruction_N


condition est une expresion de type booléeen


si condition est vraie, la sequence des instructions 1 à N est
executees, une fois l'instruction N terminee, si condition est 
toujours vraie, les instructions 1 à N sont à nouveau executees 
ainsi de suite tant que condition est vraie. 


Remarques:

condition s'appelle le critere de continuation de la boucle
les variables composant condition doivent toutes avoir une 
valeur lors de sa première évaluation.


Il faut s'assurer que la boucle se termine ! ! !


Exemples
# Script 1
a = 5
while a > 0:
	a = a -1
	print ( a )
>>>
4
3
2
1
0


12/21

# Script 2
a = 5
while a < 3:
a = a +1
print ( a )
>>>

================================
Table de valeurs
================================
La table de valeurs permet de suivre les modifications des variables ou
expression au cours de l’ex´ecution d’un script.

Exemple

# Script 1
a = 3
while a > 0:
	a = a -1
	print ( a )

a
3
2

a   	a > 0
3	True
2	True
1	True
0	False

================================
Exemples d'iterations
================================

1. Ecrire un script qui affiche tous les entiers entre 1 et 100.

# entiers de 1 a 100
n = 1
while n <= 100:
	print ( n )
	n = n +1


2. Ecrire un script qui affiche la somme des entiers entre 1 et 100.
# entiers de 1 a 100
n = 1
somme = 0
while n <= 100:
	somme = somme + n
	n = n +1
print ( somme )

3. Ecrire un script qui calcule la somme des entiers saisis par l’utilisateur, 
la saisie s’arrˆete quand l’utilisateur saisit 0.

# saisie a la volee (1)
a = 1
somme = 0
while a != 0:
	a = int ( input ())
	somme = somme + a
print ( somme )



================================
Boucles imbriquees
================================

Repeter un bloc d’instructions contenant lui meme 
une boucle while.

1. Ecrire un script qui affiche la table de multiplication 
d’un entier n saisit au clavier

# table de n
n = int ( input ())
i = 1
while i <= 10:
	print (n , ’ * ’ ,i , ’ = ’ , n * i )
	i = i +1


2. 
Modifier le script pour qu’il affiche toutes les tables 
des entiers entre 1 et 10


# table des nombres
# entre 1 et 10
n = 1
while n <= 10:
	i = 1
	while i <= 10:
		print (n , ’ * ’ ,i , ’= ’ ,n * i )
		i = i +1
	n = n +1

================================
Liste des nombres premiers
================================

On dit que entier n ≥ 2 est premier s’il n’est divisble que 
par 1 et par lui-meme. On veut afficher tous les nombres 
premiers inferieurs  a un entier n saisit
au clavier :

1. Ecrire un script permettant de savoir si un entier n est premier

# n est - il premier ?
div = 2
est_premier = True
while div < n :
	if n % div  == 0:
	est_premier = False
div = div +1

2. Repeter le bloc de code precedent pour tous les entiers entre 2 et n.



# Liste des nombres
# premiers
n_max = int ( input ()))
n = 2
while n <= n_max :
	div = 2
	est_premier = True
	while div < n :
		if n % div == 0:
			est_premier = False
		div = div +1
	if est_premier 
		print ( n )
n = n + 1