Modules et librairies

Pourquoi des librairies ou des modules ?

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 :

Python

>>>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.

Importer un module

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

Importer une fonction d'un module

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

Importer toutes les fonctions d'un module

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.

Cas général

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"

Exemple

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.