Python contient déjà des fonctions natives, par exemple :
print("Hello world!")
Mais afin de ne pas alourdir le programme ou ne pas réserver trop de noms de fonctions, certaines fonctions ne peuvent pas être directement appelées sous Python.
Ces fonctionnalités sont présentes dans des modules, c'est à dire un fichier code contenant ces fonctions, que l'on appelle au besoin.
Utiliser un module
Par exemple, la fonction cosinus existe et se nomme "cos". Mais si vous l'appelez, vous rencontrez une erreur :
>>>cos(0)
NameError: name 'cos' is not defined
La fonction cosinus existe, mais elle est contenue dans le module "math". Il faut donc d'abord appeler ce module pour exploiter les fonctions qu'il contient.
On importe un module. Ensuite il faudra appeler les fonctions en précisant qu'elles sont contenues dans ce module de la sorte : module.fonction(...)
import math
>>>math.cos(0) #On appelle la fonction "cos" du module "math"
1.0
On peut également importer une fonction précise d'un module, pour l'utiliser sans faire appel au module
from math import cos
>>>cos(0) #La fonction "cos" a été importée, on peut l'utiliser directement
1.0
Ou plusieurs fonctions :
from math import cos, sin, tan
>>>cos(0)
1.0
>>>sin(0)
0.0
On peut également importer toutes les fonctions d'un module (mémoire plus importante)
from math import *
>>>cos(0) #La fonction "cos" a été importée, on peut l'utiliser directement
1.0
Les modules disponibles
Les modules disponibles peuvent être connus sur EduPython en tappant "import" et faisant ctrl+espace.
En physique, on utilisera notamment (non exhaustif !) :
math : pour avoir accès à des fonctions de math (!)
random : pour générer des nombres aléatoires
numpy : pour générer des tableaux
matplotlib : pour tracer des graphiques
Modules personnels
Vous pouvez-vous même créer un module et y créer vos fonctions, et les appeler dans d'autres programmes. En réalité, un module, c'est un fichier python comme un autre, qui définie des fonctions.
Un fichier (aussi appelé module) python contient et définie des fonctions.
On souhaite importer ces fonctions dans un fichier pour ne pas avoir à les ré-écrire.
L'appel se fait ainsi en début de programme :
from nomdumodule import nomdelafonction #Pour importer qu'une fonction du module
from nomdumodule import * #Pour importer toutes les fonctions du module
Les deux fichiers doivent être dans le même dossier ; ou alors il faut préciser le lien relatif entre les deux.
Ne pas préciser l'extension ".py" du module importé
Attention, le chemin relatif s'écrit avec des points "." en python.
Sur windows, le dossier "modules" contient le fichier fonction.py donne "modules\fonction.py" ; en python ça donne "modules.fonction"
Pour illustrer cela, reprenons le projet nucléaire (fin module 2) et travaillons la désintégration d'une population de noyaux en effectuant des "lancé de dés".
Un premier programme (module) définie des fonctions (générer une liste, lancer un dé) et s'appelle "fonctionDe.py"
Un second programme "desintregration.py" va chercher les fonctions contenues dans le module "fonctions.py" pour les utiliser.
Les deux fichiers sont dans le même dossier
fonctionDe.py
import random
def listeDe(n,contenu="dé"):
"""
Cette fonction génère une liste de n dé. Par défaut la valeur de chaque dé est "dé" (chaine de caractère
Exemple d'appel : listeDe(3) génère une liste ['dé', 'dé', 'dé']
"""
return ["dé"]*n
def lanceDe():
"""
Cette fonction génère un nombre entier aléatoire compris entre 1 et 6
Exemple d'appel : lanceDe()
"""
return random.randint(1,6)
def desintegration(l):
"""
Cette fonction prend une liste de noyaux, et teste pour chacun d'eux si ils sont spontanément désintégrés. La fonction retourne la liste de noyau conservés.
Exemple d'appel : desintegration(listeDe(10)) pour tester la désintégration ou non de 10 noyaux (dé).
"""
nb_noyau = len(l)
nb_desintegre = 0
i = 0
while i < nb_noyau:
if lanceDe()==6:
nb_desintegre = nb_desintegre+1
i=i+1
nb_noyau = nb_noyau - nb_desintegre
return ["dé"]*nb_noyau
desintegration.py
from fonctionDe import *
#Définir le nombre de dé/noyaux initiaux
nb_des = 10
#Créer la liste contenant tous les dés/noyaux
liste_de = listeDe(nb_des)
print("Il y a "+str(len(liste_de))+" noyaux dans la liste")
#...et on lance (si appel) le dé pour chaque noyau (1 chance sur 6 d'être désintegré)
liste_de = desintegration(liste_de)
print("Après desintégration, il reste "+str(len(liste_de))+" noyaux dans la liste")
Librairies (package)
On parle également de librairies ou bibliothèque (package en anglais). Une librairie est un ensemble de modules.
Pour la suite, sauf mention particulière, on parlera de module pour désigner des fonctions contenus des fichiers externes.
