Chp G. Utilisation des bibliothèques en python

Le langage python est capable d'effectuer les principales tâches algorithmiques de base (gestion des variables, boucles, tests). Mais, il y a des tâches courantes qu'il ne sait pas faire nativement. C'est pourquoi, afin d'éviter de "réinventer la roue" à chaque fois, il existe d'innombrables bibliothèques qui accompagnent ce langage. Pour faire simple, ces bibliothèques (on parle aussi de modules, ou de librairies ou parfois de packages) sont des ensembles de fonctions relatives à une thématique donnée (par exemple le module math regroupe des fonctions relatives aux mathématiques !) qui ont été programmées par d'autres personnes et qui sont mises à disposition de la communauté pour faciliter la création de programmes. On peut retrouver sur la documentation officielle de python une liste de bibliothèques accessibles : doc python Il existe beaucoup d'autres libraires, qui ne sont pas fournies avec le langage de base, mais qui peuvent être téléchargées et installées. Là aussi plusieurs possibilités coexistent. Par exemple on peut citer le programme pip qui se charge de télécharger et d'installer des bibliothèques. On ne l'utilisera pas ici, mais on peut aller faire un tour sur https://pypi.org/ pour voir ce qui existe !

L'objectif de ce mini chapitre est de voir comment faire pour importer les fonctions d'une bibliothèque puis de travailler sur deux ou trois classiques.

1. Différentes méthodes pour importer une bibliothèque

Pour faire simple, une bibliothèque est un simple fichier python contenant diverses fonctions auxquelles on pourra accéder depuis notre programme principal après les avoir importées. Voyons sur un exemple générique les différentes possibilités et précisons celles à privilégier.

différentes méthodes d'importation

Imaginons que nous disposons d'un fichier test.py contenant :

# test.py

def carree(x : float) -> float:
    """reçoit un flottant et renvoie son carré"""
    return x**2

def cube(x : float) -> float :
    """reçoit un flottant et renvoie son cube"""
    return x**3

variable = 1.414

Ensuite, au début du programme souhaitant importer cette bibliothèque, on mettra l'une des lignes de la première colonne du tableau ci-dessous, et pour accéder aux fonctions ont utilisera le code des 3 dernières colonnes:

Syntaxe	Accès à `carree`	Accès à `cube`	Accès à variable
`import test`	`test.carree`	`test.cube`	`test.variable`
`import test as t`	`t.carree`	`t.cube`	`t.variable`
`from test import *`	`carree`	`cube`	`variable`
`from test import carree`	`carree`	Impossible	Impossible
`from test import carree as c`	`c`	Impossible	Impossible

Important

Il est important de noter que les méthodes utilisant from..., bien que séduisantes a priori (pas besoin de faire précéder le nom de la fonction par le nom de la bibliothèque), ne sont pas utilisables à grande échelle et on ne les utilisera (éventuellement) que pour des phases de tests. En effet on comprend bien que si l'on importe plusieurs modules, il pourrait rapidement y avoir conflit avec des fonctions qui porteraient le même nom ! Elles sont donc à éviter et on privilégiera autant que faire se peut celles avec import..., sachant que la plupart des éditeurs possèdent une aide à la saisie qui nous évite de taper le nom de la fonction en entier...

2. Un exemple concret : module `math`

Si l'on veut calculer une exponentielle ou un logarithme népérien, on pourra utiliser le module math.

Méthode conseillée

import math

print(math.exp(2)) # affiche l'exponentielle de 2
print(math.log(2)) # affiche le logarithme népérien de 2
print(math.pi) # affiche une valeur approchée de pi
print(math.cos(math.pi/4)) # ...

import math as m

print(m.exp(2)) # affiche l'exponentielle de 2
print(m.log(2)) # affiche le logarithme népérien de 2
print(m.pi) # affiche une valeur approchée de pi
print(m.cos(m.pi/4)) # ...

Méthode déconseillée

from math import exp, log, pi, cos

print(exp(2)) # affiche l'exponentielle de 2
print(log(2)) # affiche le logarithme népérien de 2
print(pi) # affiche une valeur approchée de pi
print(cos(pi/4)) # ...

from math import * 
# * signifie qu'on importe toutes les fonctions du module !

print(exp(2)) # affiche l'exponentielle de 2
print(log(2)) # affiche le logarithme népérien de 2
print(pi) # affiche une valeur approchée de pi
print(cos(pi/4)) # ...

3. Accès à la documentation d'un module

Lorsqu'une bibliothèque est bien conçue, elle contient sa propre documentation. Voyons sur un exemple ce que l'on peut trouver. Supposons que l'on ait importé le module math en tapant import math, alors on peut taper dans le shell :

help(math) : pour obtenir de l'aide sur le module complet (pas très lisible...)
help(math.log) : pour obtenir de l'aide uniquement sur la fonction log
dir(math): affiche la liste de toutes les fonctions disponibles dans le module math

>>>dir(math)

['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh',
 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist',
 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum',
 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp',
 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow',
 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']

>>>help(math.log)

Help on built-in function log in module math:

log(...)
    log(x, [base=math.e])
    Return the logarithm of x to the given base.

    If the base not specified, returns the natural logarithm (base e) of x.

À noter que la documentation affichée par l'instruction help n'est autre que la docstring de la fonction. D'où l'importance de bien rédiger les docstrings... Si cette aide n'est pas suffisante, on utilisera bien entendu des sources Internet (ou IA) comme W3School.