Sous-routines (Python) : Procédures et fonctions - 1

Sous-programmes

L'utilisation de sous-programmes vous permet d'éviter la duplication de code, si vous devez écrire le même code à différents endroits du programme. 
Les bibliothèques importées dans un programme (par exemple, la bibliothèque mathématique math) sont constituées de sous-programmes qui ont déjà été compilés par quelqu'un. Les programmeurs n'ont pas besoin de réfléchir aux algorithmes qu'ils implémentent, mais simplement de les appliquer, en pensant uniquement à ce qu'ils font exactement. C'est un gain de temps considérable. Il n'est pas nécessaire d'écrire un algorithme qui a déjà été écrit par quelqu'un d'autre.

Chaque sous-programme ne doit effectuer qu'une seule tâche,  ; soit simplement calculer quelque chose, soit générer des données, soit faire autre chose. 

Il existe deux types de sous-programmes : les procédures et les fonctions.

Les sous-procédures effectuent certaines actions, telles que l'affichage d'un résultat à l'écran sous une certaine forme (un exemple simple, l'instruction print() est une sous-procédure standard qui imprime des données à l'écran).

Les sous-routines de fonctions retournent un résultat (nombre, chaîne de caractères, etc.) que nous pouvons utiliser dans le programme principal.

Essayons d'écrire une procédure simple :
Supposons que nous ayons besoin d'afficher la chaîne "Erreur" à l'écran chaque fois qu'une erreur peut se produire dans le code en raison de la faute de l'utilisateur, par exemple lorsqu'il saisit des données incorrectes.
Cela peut être fait en écrivant l'opérateur print("Erreur") Et maintenant, imaginez qu'une telle ligne doive être insérée à de nombreux endroits dans le programme. Bien sûr, vous pouvez simplement l'écrire partout. Mais cette solution a deux inconvénients.
1) Cette chaîne sera stockée en mémoire plusieurs fois.
2) Si nous voulons changer la sortie en cas d'erreur, nous devrons changer cette ligne tout au long du programme, ce qui est plutôt gênant

Dans de tels cas, des procédures sont nécessaires.
Un programme avec une procédure pourrait ressembler à ceci :
  def printError() : # description de la procédure print("Erreur") ... printError() # lance la procédure d'exécution. # Spécifiez simplement le nom de la procédure que nous voulons exécuter ... impressionErreur()

Ne pas oublier !

1. La procédure commence par le mot def (de l'anglais - define - à définir). Après le nom de la procédure, des crochets vides et deux-points sont écrits . Les paramètres peuvent être spécifiés entre parenthèses (nous en reparlerons plus tard).
2. Toutes les instructions exécutées dans une procédure sont en retrait. 
3. Pour exécuter une procédure, dans le programme principal, vous devez l'appeler par son nom et n'oubliez pas d'écrire des parenthèses !
4. Vous pouvez appeler une procédure dans un programme autant de fois que vous le souhaitez.

Paramètres et arguments

Imaginons maintenant que nous ayons besoin d'afficher différents messages en réponse à l'erreur d'un utilisateur, selon le type d'erreur qu'il a commise.
Dans ce cas, vous pouvez écrire votre propre procédure pour chaque erreur :   def printErrorZero() : print("Erreur. Division par zéro !") def printErrorInput() : print("Erreur de saisie !")
Et s'il y a beaucoup plus d'erreurs possibles ? Cette solution ne nous conviendra pas !
Nous devons apprendre à contrôler la procédure en lui indiquant quel message d'erreur afficher.
Pour cela, nous avons besoin de paramètres que nous écrirons entre parenthèses après le nom de la procédure def printErreur(s) : imprimer("s")
Dans cette procédure, s est un paramètre - une variable spéciale qui vous permet de contrôler la procédure.
 

Le paramètre est une variable qui détermine le fonctionnement de la sous-routine. Les noms des paramètres sont séparés par des virgules dans l'en-tête de la sous-routine.

Maintenant, lors de l'appel de la procédure, vous devez indiquer entre parenthèses la valeur réelle qui sera affectée au paramètre (variable s) à l'intérieur de notre procédure printError("Erreur ! Division par zéro !")
Une telle valeur est appelée un argument.
 

L'argument est la valeur du paramètre qui est transmise à la sous-routine lorsqu'elle est appelée.

Un argument peut être non seulement une valeur constante, mais également une variable ou une expression arithmétique.

Variables locales et globales

Vous pouvez accéder aux variables globales à partir de n'importe quel sous-programme. 

Il est souvent nécessaire d'introduire des variables supplémentaires qui ne seront utilisées que dans le sous-programme. De telles variables sont appelées locales (ou locales). Vous ne pouvez travailler avec eux qu'à l'intérieur du sous-programme dans lequel ils sont créés. Le reste des routines ne "sait" rien d'eux.

Ainsi, il est possible de limiter la portée (portée) d'une variable uniquement au sous-programme où elle est vraiment nécessaire. En programmation, cette technique est appelée encapsulation  - masquer la variable pour qu'elle ne soit pas modifiée de l'extérieur.

Analysez trois programmes :

def test() : imprimer(i)

def test() :   je = 2 imprimer(i)

def test() :   global i je = 2 # programme principal je = 15 imprimer (je)

Description	Programme
1) Dans ce programme, la variable i est locale. S'il n'y a pas de variable i dans le programme principal, alors nous aurons un message d'erreur. Et s'il existe une telle variable (alors c'est une variable globale), alors sa valeur est affichée à l'écran.
2) Ici, même s'il y a une variable globale i, une nouvelle variable locale i sera créée avec une valeur de 2, et 2 apparaîtra sur le écran.
3) Dans ce programme, il y a une variable globale i avec une valeur de 15. Sa valeur peut être changée à l'intérieur du sous-programme, pour cela il faut déclarer explicitement qu'elle est globale ( utilisez la commande global ). La procédure fonctionnera avec la variable globale i et on lui affectera une nouvelle valeur de 2. La valeur 2 s'affiche.