Python : fonctions perso. complexes & modules personnels
Dans ce chapitre je vais aborder les points suivants :
- compléments sur les fonctions personnelles
- créer ses propres modules (collection de fonctions perso.)
Retour sur les fonctions
J'ai déjà évoqué la création de fonctions personnelles dans le chapitre 4. Mais je n'ai pas tout dit car
le sujet est vaste.
Fonctions avec un nombre fixe d'arguments
Que se passe t-il si on ne passe pas le nombre correct d'arguments ?
>>> pow(10,5)
100000
>>> pow(10)
...
TypeError: pow() missing required argument 'exp' (pos 2)
La fonction native pow() exige obligatoirement deux arguments lors de son appel.
Donc si n'en passe qu'un argument, il y a plantage !
Fonction avec argument optionnel
Je vous montre maintenant que l'on peut donner une valeur par défaut à certains paramètres.
Aussi lors de l'appel de la fonction je ne suis pas obligé de saisir un argument correspondant au paramètre ayant
une valeur par défaut.
>>> def puissance(x, p =2) :
... return pow(x,p)
...
>>> puissance(5)
25 # 5 à la puissance 2
>>> puissance(5,3)
125
>>>
J'ai créé une fonction personnelle nommée puissance() et qui est une amélioration de la fonction native pow().
Notez la syntaxe : def puissance(x, p =2).
Lors de l'appel de la fonction je peux passer un seul argument ; le paramètre "p" prendra alors la valeur 2 : élever
à la puissance 2. Mais bien sûr je peux aussi passer deux arguments si je veux une puissance différente de 2.
Fonction flexible
Notion de fonction flexible
Certaines fonctions prédéfinies de Python acceptent un nombre variable d'arguments.
On peut parler de fonctions flexibles.
C'est le cas de la fonction math.gcd() qui précise le plus grand commun diviseur à plusieurs nombres.
>>> import math
>>> math.gcd(50,30)
10
>>> math.gcd(30,45,60)
15
>>>
Comment créer une fonction personnelle flexible ?
La fonction native sum() doit être argumentée avec un argument unique correspondant à une liste.
>>> maliste = range(10)
>>> sum(maliste)
45
>>> sum(1,2,3,4)
Traceback (most recent call last):
File "", line 1, in
TypeError: sum() takes at most 2 arguments (4 given)
Je crée une fonction personnelle plus souple d'emploi que je nomme : somme().
>>> def somme(*args):
... s=0
... for i in args:
... s = s+i
... return s
...
>>> somme(10,20)
30
>>> somme(10,20,15,25)
70
>>>
Lors de la déclaration de la fonction le paramètre doit être "* args" (remplacez 'args' par ce que voulez mais surtout
n'oubliez pas le caractère "*" devant le mot retenu).
Lors de l'appel de la fonction, vous saisissez en guise d'arguments un tuple de valeurs avec 2,3,4, ... n éléments.
Fonction récursive
Récursivité, un mot qui fait peur aux apprentis programmeurs.
Vous devez savoir qu’une fonction peut également s’appeler elle même dans son exécution. C’est ce qu’on appelle la récursivité.
L’exemple classique de fonction récursive est celle qui calcule une factorielle.
La factorielle de 4, par exemple, est égale à 1 * 2 * 3 * 4 = 24
La factorielle de 6 = 1 * 2 * 3 * 4 * 5 * 6 = 720
Fonction récursive pour calculer factorielle n
def factorielle(n):
if n == 0:
return 1
else:
return n * factorielle(n-1)
Dans la fonction notez la syntaxe : return n * factorielle(n-1) : appel récursif.
Si on argumente avec n > à 1 on retourne cette valeur et on appelle factorielle(n-1).
Si n-1 est toujours > à 1, on retourne cette valeur et on appelle à nouveau notre fonction
avec une valeur diminuée de 1 ce jusqu’à ce que la valeur passée à factorielle() soit 1.
Programme sans récursivité
On peut éviter la récursivité à condition d'utiliser la fonction range().
# nom_prog : factoriel_range.py
def calcul_factoriel(nbre) :
factoriel = 1
for i in range(1, nbre+1):
factoriel = factoriel * i
return factoriel
print(calcul_factoriel(3))
print(calcul_factoriel(4))
nbre = int(input('saisir un entier : '))
print(calcul_factoriel(nbre))
Dans ce programme j'appelle trois fois la fonction perso. "calcul_factoriel()".
Le rendu :
6
24
saisir un entier : 5
120
>>>
Solution ultime
Nous nous serions évités tous ces efforts de programmation si nous avions pris la peine de rechercher dans la documentation Python.
Ce langage est très orienté "mathématiques" (c'est pour cette raison qu'il est enseigné en lycée dans les filières
Math sup & Math spé.
Il existe dans le module math la fonction factorial()
>>> import math
>>> math.factorial(4)
24
>>> math.factorial(6)
720
Une fonction définie en une seule ligne
Une fonction peut être définie en une seule instruction à condition d'utiliser le mot clé "lamda".
Aussi désigne t-on ces fonctions sous l'expression "fonctions lambda".
Dans une fonction lambda on ne retrouve pas les mots clés "def" & "return".
>>> carre = lambda x: x*x
>>> carre(5)
25
>>> carre(10)
100
>>>
La syntaxe d'une fonction lambda : nomFonction = lambda arg1, arg2 : instruction de retour
J'ai défini la fonction "carre".
Concernant l'appel de la fonction il n'y a pas de différence avec une fonction classique : nomFonction(liste des arguments)
Créer ses propres modules
Utiliser un module personnel
>>> import geometrie as geom
>>> geom.cercle(50)
(314.0, 7850.0)
>>> geom.rectangle(30,50)
(160, 1500)
>>>
J'utilise un module que j'ai personnellement créé. Ce module contient deux fonctions personnelles.
Je sais que la fonction cercle() réclame deux arguments et la fonction rectangle() a besoin de deux arguments.
Chacune de ces fonctions retournent un tuple avec deux valeurs.
Pourquoi créer ses propres modules ?
Vous avez du créer une fonction perso. car vous n'avez pas trouvé votre bonheur dans le module de base, les modules importables voire
les bibliothèques. Mais avez-vous vraiment bien cherché ?
Si vous créer cette fonction dans le cadre d'un programme, celle-ci ne pourra être appelée qu'à partir de ce programme.
Ce qui est vraiment dommage cette fonction est vraiment innovante et représente un gros investissement personnel.
Par contre une fonction appartenant à un module peut être appelée via la console ou dans n'importe quel programme.
Comment créer un module perso. ?
Je crée un fichier nommé "geometrie.py" (comme un programme).
Contenu de ce fichier
""" Module geometrie
qui comprend deux fonctions : cercle() et rectangle() :
- cercle(rayon) -> circonférence, aire
- rectangle(largeur,longueur) -> périmètre, aire
"""
def cercle(rayon):
circonference = rayon * 2 * 3.14
aire = rayon* rayon * 3.14
return circonference, aire
def rectangle(longueur,largeur):
perimetre = (longueur *2) + (largeur*2)
aire = longueur*largeur
return perimetre, aire
Un module perso. doit débuter par un commentaire multilignes (délimité par une paire
de triple guillemets). Cette chaine de commentaire sera affichée via la commande help().
Il faut donc soigner la rédaction de ce texte.
Elle est appelée "docstrings" dans la documentation de Python.
Ensuite on trouve la définition des différentes fonctions et c'est tout.
Pour devenir un module à part entière, le fichier "geometrie.py" doit être enregistré dans le
répertoire courant de Python.
Comment connaitre le répertoire courant de Python ?
>>> import sys
>>> sys.path
['', 'C:\\Users\\darch\\AppData\\Local\\Programs\\Python\\Python313\\python313.zip',
'C:\\Users\\darch\\AppData\\Local\\Programs\\Python\\Python313\\DLLs',
'C:\\Users\\darch\\AppData\\Local\\Programs\\Python\\Python313\\Lib',
'C:\\Users\\darch\\AppData\\Local\\Programs\\Python\\Python313',
'C:\\Users\\darch\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages']
Tant que j'utilisais la version 3.9 de Python le répertoire courant était "c:/Python39"
comme je l'indique encore dans certaines pages de ce tuto.
Mais depuis que j'ai changé de PC et installé la version 3.13 de Python le répertoire courant à changé.
Utilisez la procédure ci-dessus pour savoir où enregistrer les modules perso. sur votre PC !
Utilisation des fonctions du module perso "geometrie"
Le fichier "geometrie.py" stocké dans : 'C:\\Users\\darch\\AppData\\Local\\Programs\\Python\\Python313\\Lib' comme les autres modules.
>>> import geometrie as geom
>>> geom.cercle(50)
(314.0, 7850.0)
>>> geom.rectangle(30,50)
(160, 1500)
Vous pouvez me contacter via Facebook pour questions & suggestions :
Page Facebook relative à mon site