Apprendre Python : Les Fonctions et Modules

Dans le chapitre précédent, nous avons brièvement mentionné les fonctions et les modules. Dans ce chapitre, examinons-les en détail. Pour réitérer, tous les langages de programmation sont livrés avec des codes intégrés que nous pouvons utiliser pour nous faciliter la vie en tant que programmeurs.

Ces codes se composent de classes, de variables et de fonctions préécrites pour l’exécution de certaines tâches communes et sont sauvegardés dans des fichiers connus sous le nom de modules. Voyons d’abord les fonctions.

Que signifie Fonctions ?

Les fonctions sont simplement des codes pré-écrits qui exécutent une certaine tâche. Pour une analogie, pensez aux fonctions mathématiques disponibles dans MS Excel. Pour ajouter des nombres, nous pouvons utiliser la fonction sum() et taper sum(A1:A5) au lieu de taper A1+A2+A3+A4+A5.

Selon la façon dont la fonction est écrite, si elle fait partie d’une classe (une classe est un concept en programmation orientée objet que nous ne traiterons pas dans ce chapitre) et comment vous l’importez, nous pouvons appeler une fonction simplement en tapant le nom de la fonction ou en utilisant la notation par points.

Certaines fonctions exigent que nous transmettions des données pour qu’ils puissent accomplir leurs tâches. Ces données sont appelées paramètres et nous les transmettons à la fonction en mettant leurs valeurs entre parenthèses ( ) séparées par des virgules.

• Par exemple, pour utiliser la fonction print() pour afficher du texte à l’écran, nous l’appelons en tapant print(« Hello World ») où print est le nom de la fonction et « Hello World » le paramètre.
• Par contre, pour utiliser la fonction replace() pour manipuler les chaînes de texte, il faut taper « Hello World ».replace(« World », « Universe ») où replace est le nom de la fonction et « World » et « Universe » sont les paramètres. La chaîne avant le point (c’est-à-dire « Hello World ») est la chaîne qui sera affectée. Par conséquent, « Hello World » sera changé en « Hello Universe ».

Définition de vos propres fonctions

Nous pouvons définir nos propres fonctions en Python et les réutiliser tout au long du programme. La syntaxe pour définir une fonction est la suivante :

def functionName(paramètres) :
code détaillant ce que la fonction doit faire
return [expression]

Syntaxe pour déclarer une fonction sous Python

Il y a deux mots-clés ici, def et return.

• def indique au programme que le code en retrait à partir de la ligne suivante fait partie de la fonction.
• return est le mot-clé que nous utilisons pour renvoyer une réponse de la fonction. Il peut y avoir plus d’une instruction de retour dans une fonction. Toutefois, une fois que la fonction exécute une instruction de retour, la fonction se termine. Si votre fonction n’a pas besoin de retourner une valeur, vous pouvez omettre l’option déclaration de retour. Alternativement, vous pouvez écrire return ou return None.

Définissons maintenant notre première fonction. Supposons que nous voulions déterminer si un nombre donné est un nombre premier. Voici comment définir la fonction à l’aide de l’opérateur de module (%) que nous avons appris au chapitre précédent et de la boucle for.

def checkIfPrime (numberToCheck) :
 for x in range(2, numberToCheck) :
       if (numberToCheck%x == 0) :
             retour False
 return True

Dans la fonction ci-dessus, les lignes 2 et 3 utilisent une boucle pour pour diviser le numéro de paramètre donné numberToCheck par tous les numéros de 2 à numberToCheck – 1 pour déterminer si le reste est nul. Si le reste est zéro, numberToCheck n’est pas un nombre premier. La ligne 4 renvoie False et la fonction se termine.

Si par la dernière itération de la boucle for, aucune des divisions ne donne un reste de zéro, la fonction atteindra la ligne 5, et retournera True. La fonction se termine alors.

Pour utiliser cette fonction, nous tapons checkIfPrime(13) et l’assignons à une variable comme celle-ci :

réponse = checkIfPrime(13)

Ici nous passons 13 comme paramètre. Nous pouvons ensuite imprimer la réponse en tapant print(réponse). On aura la sortie : Vrai.

Portée des variables : Variables locales et variables globales

Un concept important à comprendre lors de la définition d’une fonction est le concept de portée variable. Les variables définies à l’intérieur d’une fonction sont traitées différemment des variables définies à l’extérieur. Il y a deux différences principales.

• Tout d’abord, toute variable déclarée à l’intérieur d’une fonction n’est accessible qu’à l’intérieur de la fonction. Ces variables sont connues sous le nom de variables locales.
• Toute variable déclarée en dehors d’une fonction est connue comme une variable globale et est accessible n’importe où dans le programme.

Pour comprendre cela, essayez le code ci-dessous :

message1 = "Global Variable"
 def myFunction():
 print(“\nINSIDE THE FUNCTION”)
 #Global variables are accessible inside a function
 print (message1)
 #Declaring a local variable
 message2 = “Local Variable”
 print (message2)
 #Calling the function
 myFunction()
 print(“\nOUTSIDE THE FUNCTION”)
 #Global variables are accessible outside function
 print (message1)
 #Local variables are NOT accessible outside function.
 print (message2)

Si vous exécutez le programme, vous obtiendrez le résultat ci-dessous :

INSIDE THE FUNCTION
 Global Variable
 Local Variable
  
 OUTSIDE THE FUNCTION
 Global Variable
 NameError: name 'message2' is not defined

Dans la fonction, les variables locales et globales sont accessibles. En dehors de la fonction, le message variable local2 n’est plus accessible. Nous obtenons une erreur de nom quand nous essayons d’y accéder en dehors de la fonction.

Le deuxième concept à comprendre au sujet de la portée des variables est que si une variable locale porte le même nom qu’une variable globale, tout code à l’intérieur de la fonction accède à la variable locale. Tout code extérieur accède à la variable globale. Essayez d’exécuter le code ci-dessous :

message1 = "Global Variable (shares same name as a local variable)"
  
 def myFunction():
 message1 = "Local Variable (shares same name as a global variable)"
 print(“\nINSIDE THE FUNCTION”)
 print (message1)      
  
 # Calling the function
 myFunction()
  
 # Printing message1 OUTSIDE the function
 print (“\nOUTSIDE THE FUNCTION”)
 print (message1)

Vous obtiendrez le résultat comme suit :

INSIDE THE FUNCTION
Local Variable (shares same name as a global variable)
OUTSIDE THE FUNCTION
Global Variable (shares same name as a local variable)

Lorsque nous imprimons le message1 à l’intérieur de la fonction, il imprime « Local Variable (partage le même nom qu’une variable globale) » comme il imprime la variable locale. Lorsque nous l’imprimons à l’extérieur, il accède à la variable globale et imprime donc « Variable globale (partage le même nom qu’une variable locale) ».

Importation de modules

Python est livré avec un grand nombre de fonctions intégrées. Ces fonctions sont sauvegardées dans des fichiers appelés modules. Pour utiliser les codes intégrés dans les modules Python, nous devons d’abord les importer dans nos programmes. Nous le faisons en utilisant le mot-clé d’importation. Il y a trois façons de le faire :

La première façon est d’importer le module entier en écrivant : import moduleName.

Par exemple, pour importer le module aléatoire, nous écrivons :

import random

Pour utiliser la fonction randrange() dans le module random, nous écrivons
random.randrange(1, 10).

Si vous trouvez trop compliqué d’écrire aléatoirement à chaque fois que vous utilisez la fonction, vous pouvez importer le module en écrivant import random ou import r (où r est un nom quelconque d’un module de votre choix). Maintenant pour utiliser la fonction randrange(), vous écrivez simplement r.randrange(1, 10).

La troisième façon d’importer des modules est d’importer des fonctions spécifiques du module en écrivant : from moduleName import name1, name2[, … nameN]].

Par exemple, pour importer la fonction randrange() du module aléatoire, nous écrivons: from random import randrange. Si nous voulons importer plusieurs fonctions, nous les séparons par une virgule. Pour importer les fonctions randrange() et randint(), nous écrivons from random import randrange, randint.

Pour utiliser la fonction maintenant, nous n’avons plus besoin d’utiliser la notation par points. Il suffit d’écrire randrange(1, 10).

Créer votre propre module

Outre l’importation de modules intégrés, nous pouvons également créer nos propres modules. Ceci est très utile si vous avez des fonctions que vous voulez réutiliser dans d’autres projets de programmation à l’avenir.

Créer un module est simple. Sauvegardez simplement le fichier avec une extension.py et placez-le dans le même dossier que le fichier Python à partir duquel vous allez l’importer.

Supposons que vous vouliez utiliser la fonction checkIfPrime() définie précédemment dans un autre script Python. Voilà comment faire. Sauvegardez d’abord le code ci-dessus sous le nom prime.py sur votre bureau. prime.py devrait avoir le code suivant :

def checkIfPrime (numberToCheck):
 for x in range(2, numberToCheck):
       if (numberToCheck%x == 0):
       return False
 return True

Ensuite, créez un autre fichier Python et nommez-le en utilisantCheckIfPrime.py. Enregistrez-le également sur votre bureau. useCheckIfPrime.py devrait avoir le code suivant :

import prime
 answer = prime.checkIfPrime(13)
 print (answer)

Exécutez maintenant useCheckIfPrime.py. Vous devriez obtenir la sortie True. C’est aussi simple que ça.

Cependant, supposons que vous vouliez stocker prime.py et utiliserCheckIfPrime.py dans différents dossiers. Vous allez devoir ajouter quelques codes pour utiliserCheckIfPrime.py pour indiquer à l’interpréteur Python où trouver le module.

Disons que vous avez créé un dossier nommé ‘MyPythonModules’ dans votre lecteur C pour stocker prime.py. Vous devez ajouter le code suivant en haut de votre fichier useCheckIfPrime.py (avant l’amorce d’importation).

import sys
  
 if 'C:\\MyPythonModules' not in sys.path:
     sys.path.append('C:\\MyPythonModules')

sys.path fait référence au chemin système de votre Python. Voici la liste des répertoires que Python utilise pour rechercher des modules et des fichiers. Le code ci-dessus ajoute le dossier ‘C:\MyPythonModules’ à votre chemin système.

Maintenant vous pouvez mettre prime.py dans C:\MyPythonModules et checkIfPrime.py dans tout autre dossier de votre choix.

N’oubliez pas de partager l’article avec vos amis !