Structure fonctionnelle

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

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

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

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

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

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

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

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

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

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

1
2
3
4
5
6

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

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

Du coup, notre programme devient :

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

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

La fonction est définie avant son appel.

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

1
2
3
4
5
6
7
8
9

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

Voici le résultat du programme :

1
2

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

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

1
2
3
4
5
6
7
8
9
10

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

Alors on obtient :

1
2

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

1
2
3

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

1

print "Fin du programme à ", ctime()