Numérique et sciences informatiques (spécialité) · Première

Utiliser des bibliothèques en Python : cours de NSI Première

Publié le 6 novembre 2026 · Mis à jour le 6 novembre 2026 · Signaler une erreur

L'essentiel

Une bibliothèque regroupe du code déjà écrit et testé : on l'importe avec import au lieu de réécrire ses fonctions.
Plusieurs formes d'import existent : import math, import math as m, from math import sqrt ; on évite from math import *.
Pour comprendre une fonction : help(math.gcd), dir(math) et la documentation, qui donnent la signature, le rôle et la valeur renvoyée.
Avec random, une même graine (seed) redonne la même suite : indispensable pour tester un programme qui utilise le hasard.
Un fichier .py est un module : tu peux écrire ta propre bibliothèque, mais jamais la nommer comme une bibliothèque existante (random.py).

Pourquoi utiliser des bibliothèques ?

Quand tu écris un programme, tu n'as pas besoin de tout fabriquer toi-même. Imagine que tu doives calculer une racine carrée, tirer un nombre au hasard, ou calculer la moyenne d'une longue liste de notes. Tu pourrais écrire ces fonctions, mais tu y passerais du temps, et tu risquerais de laisser des erreurs.

Ce cours suit le programme officiel de la spécialité NSI en classe de première, publié par le ministère de l'Éducation nationale ¹. Les ressources que propose Éduscol pour cette spécialité abordent notamment la mise au point des programmes et la gestion des bugs ². Utiliser une bibliothèque, c'est justement s'appuyer sur du code déjà éprouvé pour limiter les bugs.

Une bibliothèque fonctionne comme une bibliothèque de livres : on y trouve des ouvrages déjà prêts, rangés par thème, et on les emprunte au lieu de les réécrire. Ici, ce que tu empruntes, ce sont des fonctions, des constantes et parfois des types de données déjà programmés.

Dans ce cours, tu vas apprendre à :

importer une bibliothèque de plusieurs façons, et savoir laquelle choisir ;
explorer ce qu'elle contient et lire sa documentation ;
utiliser quelques bibliothèques classiques (math, random, statistics) ;
tester un programme qui les utilise, y compris quand il y a du hasard ;
écrire ta propre bibliothèque et éviter les pièges classiques.

Utiliser du code déjà écrit présente des avantages concrets :

Le gain de temps : une ligne suffit pour obtenir un calcul qui en demanderait vingt.
La fiabilité : une fonction très utilisée a été vérifiée par de nombreuses personnes. Elle est en général plus sûre que celle que tu écrirais en dix minutes.
La lisibilité : math.sqrt(x) se comprend immédiatement, alors qu'une boucle qui approche une racine demande de l'attention.

Importer une bibliothèque

Le code d'une bibliothèque n'est pas disponible automatiquement dans ton programme. Il faut le demander avec l'instruction import. Tant que tu ne l'as pas fait, Python ne connaît pas les noms que la bibliothèque définit.

Il existe plusieurs formes d'import. Elles diffèrent par la façon dont les noms deviennent accessibles.

MéthodeLes formes d'import à connaître

Forme 1 : importer le module entier.

import math
print(math.sqrt(16))   # 4.0
print(math.pi)         # 3.141592653589793

On écrit le nom du module, un point, puis le nom de la fonction. Le préfixe math. indique d'où vient la fonction.

Forme 2 : importer le module sous un autre nom.

import math as m
print(m.sqrt(16))      # 4.0

Le nom m remplace math. Après cet import, le nom math n'existe plus dans ton programme : écrire math.sqrt(16) provoque une erreur NameError.

Forme 3 : importer seulement certains noms.

from math import sqrt, pi
print(sqrt(16))        # 4.0
print(pi)

On utilise alors sqrt et pi directement, sans préfixe. Seuls les noms listés sont importés : floor ne serait pas accessible ici.

ExempleUne erreur typique et sa lecture

import math
print(sqrt(25))

Python affiche une erreur du type NameError: name 'sqrt' is not defined. Le message dit que le nom sqrt n'existe pas dans le programme. La fonction existe bien, mais dans l'espace de noms de math. Il faut écrire math.sqrt(25), ou bien utiliser from math import sqrt.

Situation	Forme conseillée
Tu utilises beaucoup de fonctions du module	`import math`
Le nom du module est long et revient souvent	`import module as court`
Tu n'as besoin que d'une ou deux fonctions	`from math import sqrt`
Tu veux gagner du temps sans réfléchir	À éviter : `from math import *`

Explorer une bibliothèque et lire sa documentation

Une bibliothèque contient souvent des dizaines de fonctions. Personne ne les connaît toutes par cœur. Savoir chercher et lire la documentation est une compétence aussi utile que savoir programmer.

Dans une bibliothèque de livres, le bibliothécaire a pour mission de donner accès à l'information et d'aider les usagers à bien s'en servir ³. En programmation, c'est la documentation qui joue ce rôle : elle te donne accès aux fonctions et t'apprend à les utiliser. Les bibliothèques peuvent aussi mettre à disposition de tous des équipements et des outils adaptés, pour que chacun puisse s'en servir en autonomie ³ ; une bonne documentation poursuit le même but pour un programmeur.

Python te donne des outils directement dans l'interpréteur.

MéthodeDes outils pour s'informer

1. dir(module) liste les noms disponibles dans un module.

import math
print(dir(math))

Le résultat est une longue liste de noms : sqrt, pi, floor, gcd, etc. Elle te dit ce qui existe, mais pas comment s'en servir.

2. help(objet) affiche la documentation d'une fonction ou d'un module.

import math
help(math.gcd)

Tu y lis la signature (les paramètres attendus), puis une phrase décrivant le rôle et le résultat.

3. La documentation officielle du langage, consultable dans un navigateur, qui donne des explications plus complètes et des exemples.

Quand tu lis une documentation, cherche toujours ces informations :

ce que la fonction attend : combien de paramètres, de quel type ;
ce qu'elle renvoie : un entier, un flottant, une liste, ou rien ;
ses cas limites : que se passe-t-il pour zéro, un nombre négatif, une liste vide ?
ses bornes : un intervalle est-il ouvert ou fermé à ses extrémités ?

Ces points correspondent à ce que tu as déjà vu avec la spécification : préconditions (ce qui doit être vrai avant l'appel) et postconditions (ce qui est garanti après).

ExempleLire une erreur liée aux préconditions

import math
print(math.sqrt(-4))

La racine carrée n'est pas définie pour un nombre négatif dans le cadre de math : Python signale une erreur ValueError (« math domain error »). La précondition de sqrt est donc x >= 0. Pour t'en protéger, tu peux tester la valeur avant l'appel :

def racine(x):
    """Renvoie la racine carrée de x, avec x >= 0."""
    assert x >= 0, "x doit être positif ou nul"
    return math.sqrt(x)

Quelques bibliothèques à connaître

Certains modules reviennent très souvent dans les programmes de première : math pour le calcul, random pour le hasard et statistics pour les statistiques simples. Les grandes bibliothèques de livres rangent leurs documents selon une classification, dont celle de la Bibliothèque du Congrès, très utilisée dans le monde universitaire ³. Les modules suivent la même logique : un thème par module, et des noms de fonctions qui disent ce qu'elles font. Voici de quoi les prendre en main.

Modules classiques
Module	Fonction	Rôle	Exemple
math	sqrt	racine carrée	math.sqrt(49) donne 7.0
math	gcd	plus grand diviseur commun	math.gcd(84, 36) donne 12
random	randint	entier aléatoire, bornes comprises	random.randint(1, 6)
random	seed	fixe la suite de tirages	random.seed(42)
statistics	mean	moyenne d'une série	statistics.mean([12, 15, 9, 14]) donne 12.5

Modules classiques

Le module `math`

import math

print(math.sqrt(49))      # 7.0
print(math.floor(3.8))    # 3   : plus grand entier inférieur ou égal
print(math.ceil(3.2))     # 4   : plus petit entier supérieur ou égal
print(math.gcd(84, 36))   # 12  : plus grand diviseur commun
print(math.hypot(3, 4))   # 5.0 : racine de 3² + 4²

Tu remarques que sqrt renvoie toujours un flottant (7.0 et non 7), alors que floor, ceil et gcd renvoient des entiers. Ce détail compte quand tu compares des résultats ou que tu les utilises comme indices de liste.

Le module `random`

import random

print(random.randint(1, 6))        # entier de 1 à 6, bornes comprises
print(random.random())             # flottant dans [0 ; 1[
print(random.choice(['a', 'b']))   # un élément pris dans la séquence

Point de vigilance : random.randint(a, b) peut renvoyer a comme b. L'intervalle est fermé aux deux bouts. En revanche, random.random() peut renvoyer 0 mais jamais 1.

Le module `statistics`

import statistics

notes = [12, 15, 9, 14]
print(statistics.mean(notes))      # 12.5
print(statistics.median(notes))    # 13.0

mean renvoie la moyenne, median la valeur qui partage la série en deux groupes de même effectif. Avec un nombre pair de valeurs, la médiane est la moyenne des deux valeurs centrales : ici (12 + 14) / 2 = 13.

ExempleUn petit programme complet

On simule dix lancers d'un dé et on calcule la moyenne des résultats.

import random
import statistics

lancers = [random.randint(1, 6) for _ in range(10)]
print(lancers)
print(statistics.mean(lancers))

À chaque exécution, la liste change. La moyenne reste comprise entre 1 et 6, puisque chaque lancer est compris entre 1 et 6. Cette propriété pourra servir de test.

Le hasard, la reproductibilité et les tests

Un programme qui utilise random donne un résultat différent à chaque exécution. C'est voulu pour un jeu, mais c'est gênant pour tester et pour corriger un bug : comment retrouver une erreur qui n'apparaît qu'une fois sur dix ?

La mise au point des programmes et la gestion des bugs figurent parmi les thèmes des ressources Éduscol de la spécialité ². La solution, quand il y a du hasard, est de fixer la graine (seed) du générateur.

Exemple

import random

random.seed(42)
a = [random.randint(1, 6) for _ in range(5)]

random.seed(42)
b = [random.randint(1, 6) for _ in range(5)]

print(a == b)   # True

Les deux listes sont égales, car on a replacé le générateur dans le même état avant de recommencer. Sans le second seed, a et b seraient presque certainement différentes.

MéthodeTester un programme qui utilise le hasard

Teste des propriétés qui sont vraies quelle que soit la valeur tirée : un dé donne un entier entre 1 et 6, une liste tirée a la bonne longueur.
Fixe la graine pour rendre le test reproductible et retrouver une erreur.
Répète le test plusieurs fois sans graine pour vérifier que la propriété tient dans des cas variés.

import random

def lancer_de():
    """Renvoie un entier de 1 à 6."""
    return random.randint(1, 6)

for _ in range(1000):
    r = lancer_de()
    assert 1 <= r <= 6

Écrire et utiliser ses propres modules

Tu n'es pas obligé d'utiliser uniquement les bibliothèques des autres. Dès que tu as plusieurs fonctions utiles, tu peux les ranger dans un fichier et les importer là où tu en as besoin. Un fichier .py est déjà un module.

ExempleCréer un module `outils.py`

Fichier outils.py :

def carre(x):
    """Renvoie le carré de x."""
    return x * x

def est_pair(n):
    """Renvoie True si l'entier n est pair."""
    return n % 2 == 0

Fichier principal.py, placé dans le même dossier :

import outils

print(outils.carre(7))      # 49
print(outils.est_pair(10))  # True

Le nom du module est le nom du fichier sans l'extension .py. La syntaxe d'appel est exactement celle de math : module.fonction(...).

MéthodeÉviter que des tests s'exécutent à l'import

Quand tu importes un module, Python exécute tout le code qui se trouve à sa racine. Si ton fichier contient des print ou des tests, ils s'afficheront à chaque import. Pour les réserver au cas où le fichier est lancé directement, on écrit :

if __name__ == '__main__':
    assert carre(3) == 9
    assert est_pair(4)
    print('tests réussis')

Ce bloc ne s'exécute que si tu lances outils.py lui-même, pas quand un autre fichier fait import outils.

Méthode et erreurs fréquentes

RepérerChercher une fonction adaptée avant d'écrire la tienne
ImporterChoisir la forme d'import la plus lisible
Lirehelp, dir et documentation : paramètres et résultat
AppelerRespecter les préconditions de la fonction
TesterVérifier sur des cas dont tu connais la réponse

Utiliser une bibliothèque : la démarche

Cette démarche s'applique à n'importe quelle bibliothèque, y compris une que tu découvres. Elle te protège de la plupart des erreurs.

Message ou symptôme	Cause probable	Correction
`NameError: name 'sqrt' is not defined`	Appel sans préfixe après `import math`	Écrire `math.sqrt` ou importer `sqrt`
`NameError: name 'math' is not defined`	Oubli de l'import, ou import fait avec `as`	Ajouter `import math` ou utiliser l'alias choisi
`ModuleNotFoundError`	Nom mal écrit, ou bibliothèque non installée	Vérifier l'orthographe, puis l'installation
`ValueError: math domain error`	Précondition non respectée (`sqrt` d'un négatif)	Tester la valeur avant l'appel
`AttributeError` sur un module	Fonction qui n'existe pas, ou fichier local qui masque la bibliothèque	`dir(module)`, puis renommer le fichier
Résultat qui change à chaque exécution	Hasard non contrôlé	`random.seed(n)` pour les tests

Exercices corrigés

Exercice 1 Longueur d'une diagonale

★☆☆Environ 5 min

Un rectangle mesure 6 cm sur 8 cm. Tu utilises la bibliothèque math pour calculer la longueur de sa diagonale.

import math
d = math.hypot(6, 8)

Quelle est la valeur de d ?
Écris une instruction qui donne le même résultat avec math.sqrt et sans hypot.

Indice 1

hypot(a, b) calcule la racine de a² + b².

Indice 2

Pense au théorème de Pythagore.

Voir la correction pas à pas

math.hypot(6, 8) calcule la racine carrée de 6² + 8², soit la racine de 36 + 64.
36 + 64 = 100, et la racine carrée de 100 vaut 10 : d vaut 10.0 (un flottant).
Avec sqrt, on écrit math.sqrt(6**2 + 8**2), qui renvoie aussi 10.0.

Une même fonction de bibliothèque peut remplacer un calcul de plusieurs opérations. La valeur renvoyée est un flottant : 10.0, pas 10.

Exercice 2 Arrondis et nombres négatifs

★★☆Environ 8 min

On exécute :

import math
r = math.ceil(7.2) + math.floor(-2.5)

Quelle est la valeur de r ? Détaille chaque appel et explique pourquoi math.floor(-2.5) ne vaut pas -2.

Indice 1

ceil renvoie l'entier immédiatement supérieur ou égal.

Indice 2

floor renvoie le plus grand entier inférieur ou égal. Place -2,5 sur une droite graduée.

Voir la correction pas à pas

math.ceil(7.2) : le plus petit entier supérieur ou égal à 7,2 est 8.
math.floor(-2.5) : les entiers inférieurs ou égaux à -2,5 sont -3, -4, -5… Le plus grand d'entre eux est -3.
On ne trouve pas -2 car -2 est plus grand que -2,5 : il ne vérifie pas « inférieur ou égal ».
r = 8 + (-3) = 5.

floor ne « supprime » pas les décimales : il cherche l'entier inférieur ou égal. Pour les négatifs, le résultat s'éloigne de zéro.

Exercice 3 Moyenne d'une série de notes

★★☆Environ 8 min

Voici une série de notes : [12, 15, 9, 14].

import statistics
m = statistics.mean([12, 15, 9, 14])

Quelle est la valeur de m ?
Réécris ce calcul sans bibliothèque, avec sum et len.

Indice 1

La moyenne est la somme divisée par l'effectif.

Indice 2

sum(liste) additionne, len(liste) compte.

Voir la correction pas à pas

Somme des notes : 12 + 15 + 9 + 14 = 50.
Effectif : 4 notes.
Moyenne : 50 / 4 = 12,5. Donc m vaut 12.5.
Sans bibliothèque : notes = [12, 15, 9, 14] puis sum(notes) / len(notes), qui renvoie aussi 12.5.

La bibliothèque donne le même résultat que le calcul manuel, avec une écriture plus lisible. Elle devient surtout utile pour des fonctions moins évidentes, comme la médiane.

Exercice 4 Ton premier module avec tests

★★★Environ 15 min

Tu veux un fichier des.py qui simule un dé à n faces.

Écris une fonction lancer(n) qui renvoie un entier aléatoire de 1 à n inclus, avec sa docstring.
Écris un bloc de tests qui ne s'exécute que lorsque des.py est lancé directement. Il vérifie sur 1000 tirages que le résultat est toujours compris entre 1 et n.
Propose une façon de rendre un test reproductible.
Écris l'import et l'appel depuis un autre fichier.

Indice 1

Pense à random.randint(a, b), dont les deux bornes sont comprises.

Indice 2

Utilise if __name__ == '__main__': pour le bloc de tests.

Voir la correction pas à pas

Importer random en haut du fichier, puis définir lancer(n) avec une docstring qui précise la précondition n >= 1.
Dans le corps : return random.randint(1, n).
Ajouter le bloc if __name__ == '__main__': avec une boucle de 1000 tirages et assert 1 <= lancer(6) <= 6.
Pour la reproductibilité, appeler random.seed(0) avant la boucle : on obtient la même suite à chaque exécution, donc la même erreur si elle existe.
Dans un autre fichier du même dossier : import des puis print(des.lancer(20)).

Tu as appliqué toute la démarche : fonction spécifiée, test des propriétés, graine fixée, import d'un module personnel. Le bloc __main__ évite que les tests s'affichent à chaque import.

Les questions qu'on se pose

Quelle différence entre un module et une bibliothèque ?

Un module est un fichier .py qui contient des définitions. Une bibliothèque regroupe un ou plusieurs modules autour d'un thème. À ton niveau, on emploie souvent les deux mots indifféremment : math est autant un module qu'une bibliothèque. L'important est de savoir l'importer et l'utiliser.

Pourquoi mettre les imports en début de fichier ?

C'est une convention de lisibilité : en ouvrant le fichier, on voit tout de suite les bibliothèques utilisées. Techniquement, un import doit avoir été exécuté avant le premier usage des noms qu'il apporte, donc le début de fichier évite les oublis.

Comment savoir si une fonction existe déjà avant de la réécrire ?

Cherche d'abord dans la documentation d'une bibliothèque adaptée, puis utilise dir(module) pour parcourir les noms disponibles. Si tu trouves une fonction qui semble convenir, lis help pour vérifier ce qu'elle renvoie, puis teste-la sur des cas simples dont tu connais la réponse.

Est-ce que `random` est vraiment du hasard ?

Le module produit une suite pseudo-aléatoire : elle a l'air imprévisible, mais elle est calculée à partir d'une graine. C'est pourquoi random.seed(n) redonne la même suite. Cette propriété est très utile pour tester ou corriger un programme.

Que faut-il savoir faire sur ce thème pour réussir en classe ?

Il faut savoir importer un module selon les différentes formes, utiliser les fonctions courantes en comprenant ce qu'elles renvoient, lire une documentation pour une fonction inconnue, interpréter une erreur d'import ou de domaine, et écrire un petit module accompagné de tests.

Sources

Programme visé : Programme d'enseignement de spécialité de numérique et sciences informatiques de la classe de première de la voie générale · Ministère de l'Éducation nationale

Programme d'enseignement de spécialité de numérique et sciences informatiques de la classe de première de la voie générale, Ministère de l'Éducation nationale. Consulté le 6 novembre 2026.
Programmes et ressources en numérique et sciences informatiques - Voie générale, Éduscol. Consulté le 6 novembre 2026.
Bibliothèque, Wikipédia. Consulté le 6 novembre 2026.
Bibliothèques de Montréal, Wikipédia. Consulté le 6 novembre 2026.

Les numéros dans le texte renvoient à ces sources. Une source qui ne dit pas ce qu'on lui fait dire ? Signale-le.

Signaler une erreur sur cette page

Utiliser des bibliothèques en Python : cours de NSI Première

L'essentiel

Pourquoi utiliser des bibliothèques ?

Importer une bibliothèque

Explorer une bibliothèque et lire sa documentation

Quelques bibliothèques à connaître

Le module `math`

Le module `random`

Le module `statistics`

Le hasard, la reproductibilité et les tests

Écrire et utiliser ses propres modules

Méthode et erreurs fréquentes

Exercices corrigés

Exercice 1 Longueur d'une diagonale

Exercice 2 Arrondis et nombres négatifs

Exercice 3 Moyenne d'une série de notes

Exercice 4 Ton premier module avec tests

Quiz

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur

L'essentiel

Pourquoi utiliser des bibliothèques ?

Importer une bibliothèque

Explorer une bibliothèque et lire sa documentation

Quelques bibliothèques à connaître

Le module math

Le module random

Le module statistics

Le hasard, la reproductibilité et les tests

Écrire et utiliser ses propres modules

Méthode et erreurs fréquentes

Exercices corrigés

Quiz

Les questions qu'on se pose

Sources

Le module `math`

Le module `random`

Le module `statistics`