Installer des packages R : install.packages, library et mises à jour

Q: How do I install a package in R?

Exécutez install.packages("name") une fois, puis library(name) pour le charger à chaque session. Par exemple install.packages("ggplot2") puis library(ggplot2). Installez-en plusieurs à la fois avec un vecteur : install.packages(c("dplyr", "readr")).

Q: What is the difference between library() and require() in R?

library() s’arrête sur une erreur si le package est absent ; require() renvoie FALSE et avertit seulement. Utilisez library() dans vos scripts pour qu’un package manquant échoue bruyamment ; utilisez require() uniquement quand vous voulez délibérément tester si un package est disponible.

Q: Do I need to install a package every time I use it?

Non. Installez une fois par machine avec install.packages() ; ensuite, faites simplement library() au début de chaque session. Vous ne réinstallez qu’après une mise à niveau majeure de R ou pour obtenir une version plus récente.

Q: Where are R packages installed?

Dans un dossier appelé library. Exécutez .libPaths() pour voir les chemins de library que R parcourt ; le premier est l’endroit où install.packages() écrit par défaut. Le chemin inclut votre version de R, donc les packages ne sont pas automatiquement repris d’une mise à niveau majeure à l’autre.

Q: How do I install a package from GitHub or Bioconductor in R?

GitHub : install.packages("pak") puis pak::pak("user/repo") (ou remotes::install_github("user/repo")). Bioconductor : install.packages("BiocManager") puis BiocManager::install("packageName").

Q: How do I update R packages?

Exécutez update.packages(ask = FALSE) pour tout mettre à jour depuis CRAN, ou update.packages(oldPkgs = c("readr", "ggplot2")) pour cibler des packages précis. Listez ce qui est installé avec installed.packages().

Installez depuis CRAN, chargez avec library(), vérifiez ce que vous avez et gardez le tout à jour

Installez des packages R avec install.packages() depuis CRAN, chargez-les avec library(), et comprenez library() vs require(), où vivent les packages (.libPaths()), comment installer depuis GitHub et Bioconductor, et comment mettre à jour et lister les packages installés.

Date de publication

26 juin 2026

Modifié

7 juillet 2026

Points clés

Installez une fois avec install.packages("name") ; chargez à chaque session avec library(name).
library() provoque une erreur si le package est absent ; require() renvoie FALSE à la place — utilisez library() dans vos scripts.
Les packages vivent dans un dossier appelé library ; affichez les chemins avec .libPaths() et ce qui est installé avec installed.packages().
Au-delà de CRAN : remotes/pak installent depuis GitHub, BiocManager depuis Bioconductor.
Restez à jour avec update.packages() ; supprimez avec remove.packages("name").

Introduction

R de base peut faire beaucoup de choses, mais c’est l’écosystème qui fait aimer R : des milliers de packages ajoutent des fonctions et des données pour tout, de la lecture d’Excel à l’ajustement de modèles. Un package est une extension que vous installez une fois sur votre ordinateur, puis que vous chargez au début de chaque session pour utiliser ses fonctions.

Cette leçon présente le flux de travail pratique : installer depuis CRAN, charger avec library(), trouver où vivent les packages, installer depuis GitHub et Bioconductor quand CRAN ne suffit pas, et tout garder à jour. Nous clarifierons aussi la seule chose qui déroute chaque débutant — la différence entre library() et require().

Note

Installer des packages touche au réseau et à votre système de fichiers, donc install.packages() ne s’exécute pas dans le bac à sable en navigateur de cette page (et vous n’installez pas un package à chaque fois — une seule fois). Le code ci-dessous est ce qu’il faut réellement exécuter dans votre propre RStudio ; la cellule interactive à la fin se limite au chargement et à l’inspection des packages, qui s’exécutent bien dans le navigateur.

Installer un package depuis CRAN

CRAN est le dépôt principal de packages de R. install.packages() télécharge et installe un package par son nom — exécutez-le une fois par machine (ou après une mise à niveau de R), pas à chaque session :

install.packages("readr")

Installez-en plusieurs à la fois en passant un vecteur :

install.packages(c("readr", "dplyr", "ggplot2"))

La première fois que vous installez dans une session, R peut vous demander de choisir un miroir CRAN (un serveur de téléchargement) — choisissez-en un proche de vous. Dans RStudio, vous pouvez aussi cliquer sur Packages ▸ Install et taper le nom, ce qui exécute le même appel install.packages() pour vous.

Charger un package avec `library()`

Installer met le package sur votre ordinateur ; cela ne rend pas encore ses fonctions disponibles. Chargez-le dans la session courante avec library() — faites-le en haut de chaque script :

library(readr)
# now read_csv(), read_tsv(), ... are available

Vous installez une fois, mais vous faites library() à chaque session — fermer R décharge tout. C’est pourquoi les scripts s’ouvrent sur un bloc d’appels library() : ils déclarent ce dont le script a besoin.

`library()` vs `require()`

Les deux chargent un package, mais ils se comportent différemment quand le package n’est pas installé :

library(pkg) — s’arrête sur une erreur si le package est absent. C’est ce que vous voulez dans un script : échouer bruyamment et tôt.
require(pkg) — renvoie TRUE/FALSE (de façon invisible) et avertit seulement si le package est absent, laissant le script continuer dans un état défaillant.

# library() halts the script here if 'readr' isn't installed:
library(readr)

# require() returns FALSE instead of stopping — useful ONLY for a deliberate check:
if (!require(readr)) install.packages("readr")

Règle générale : utilisez library() partout ; réservez require() au cas rare où vous voulez réellement tester si un package est présent et réagir au résultat.

Où vivent les packages : `.libPaths()`

Les packages installés se trouvent dans un dossier appelé library. .libPaths() affiche les chemins de library que R parcourt — celui-ci s’exécute bien, voici donc la vraie réponse pour cette session :

.libPaths()

[1] "/Users/kassambara/Library/R/arm64/4.5/library"                       
[2] "/Library/Frameworks/R.framework/Versions/4.5-arm64/Resources/library"

Le premier chemin est l’endroit où install.packages() écrit par défaut. Le savoir aide quand un package « n’est pas trouvé » après installation — il est généralement allé dans une library différente de celle que R lit, souvent parce que vous l’avez installé sous une autre version de R.

Voir ce qui est installé et ce qui est chargé

Pour lister tous les packages installés sur votre machine, utilisez installed.packages() (il renvoie une grande matrice — ici on se contente de compter et de jeter un œil) :

inst <- installed.packages()
nrow(inst)              # how many packages are installed

[1] 687

head(rownames(inst), 8)  # the first few names

[1] "abind"         "ade4"          "ALL"           "annotables"   
[5] "annotate"      "AnnotationDbi" "AnnotationHub" "ape"

Pour voir quels packages sont chargés dans la session courante, utilisez search() ou (.packages()) :

(.packages())  # currently attached packages

[1] "stats"     "graphics"  "grDevices" "utils"     "datasets"  "methods"  
[7] "base"

Installer depuis GitHub

Les versions de développement — ou les packages jamais publiés sur CRAN — vivent généralement sur GitHub. Installez-les avec remotes (léger) ou pak (plus rapide, meilleure gestion des dépendances) ; les deux ont remplacé l’ancien devtools::install_github() pour cette tâche :

install.packages("remotes")
remotes::install_github("kassambara/survminer")

# or, with pak:
install.packages("pak")
pak::pak("kassambara/survminer")

L’argument est "user/repo". pak est la recommandation moderne — il résout les dépendances en une étape et installe en parallèle.

Installer depuis Bioconductor

Bioconductor est un dépôt distinct pour les packages de génomique et de bio-informatique. Installez une fois son gardien BiocManager, puis utilisez-le pour installer les packages Bioconductor (cela remplace l’ancien script biocLite()) :

install.packages("BiocManager")
BiocManager::install("limma")

Mettre à jour et supprimer des packages

Gardez les packages CRAN à jour avec update.packages() ; ciblez-en certains avec oldPkgs :

update.packages(ask = FALSE)                       # update everything
update.packages(oldPkgs = c("readr", "ggplot2"))   # just these

Supprimez un package dont vous n’avez plus besoin :

remove.packages("readr")

Après une mise à niveau majeure de R, il est normal de réinstaller de nombreux packages, car ils sont installés par version de R (le nom du dossier .libPaths() inclut la version).

Essayez en direct

install.packages() a besoin du réseau, il ne peut donc pas s’exécuter ici — mais charger et inspecter les packages, si. Exécutez ceci dans votre navigateur via webR (sans installation) :

Note

Le bac à sable en navigateur installe les packages différemment de votre bureau : au lieu de install.packages(), webR utilise webr::install("name") (quand un package n’est pas déjà intégré). Sur votre propre ordinateur, restez sur install.packages().

🟢 Avec un agent IA

Vous tombez sur there is no package called 'X' au milieu du script de quelqu’un d’autre ? Demandez à Prova « de quels packages ce script a-t-il besoin et comment les installer ? » — elle parcourt les appels library() et écrit la ligne install.packages(), et comme le runtime est juste là, vous l’exécutez pour confirmer que le script se charge proprement. Demander à Prova →

Vous travaillez en Python ? L’équivalent pip install / environnement virtuel arrive dans la série Python.

Problèmes courants

there is no package called 'readr'. Le package n’est pas installé (ou installé sous une autre version de R). Exécutez install.packages("readr") une fois, puis library(readr). Si vous venez de mettre R à niveau, vous devrez peut-être réinstaller — les packages vivent dans un dossier .libPaths() spécifique à la version.

could not find function "read_csv". Le package est installé mais pas chargé dans cette session. Ajoutez library(readr) avant d’appeler ses fonctions — l’installation seule ne suffit pas.

install.packages() demande un miroir CRAN à chaque fois, ou échoue derrière un pare-feu. Choisissez un miroir proche quand on vous le demande, ou définissez-en un avec options(repos = "https://cloud.r-project.org"). Sur un réseau verrouillé, un paramètre de proxy manquant est la cause habituelle d’un échec de téléchargement.

Questions fréquentes

How do I install a package in R?

Exécutez install.packages("name") une fois, puis library(name) pour le charger à chaque session. Par exemple install.packages("ggplot2") puis library(ggplot2). Installez-en plusieurs à la fois avec un vecteur : install.packages(c("dplyr", "readr")).

What is the difference between library() and require() in R?

library() s’arrête sur une erreur si le package est absent ; require() renvoie FALSE et avertit seulement. Utilisez library() dans vos scripts pour qu’un package manquant échoue bruyamment ; utilisez require() uniquement quand vous voulez délibérément tester si un package est disponible.

Do I need to install a package every time I use it?

Non. Installez une fois par machine avec install.packages() ; ensuite, faites simplement library() au début de chaque session. Vous ne réinstallez qu’après une mise à niveau majeure de R ou pour obtenir une version plus récente.

Where are R packages installed?

Dans un dossier appelé library. Exécutez .libPaths() pour voir les chemins de library que R parcourt ; le premier est l’endroit où install.packages() écrit par défaut. Le chemin inclut votre version de R, donc les packages ne sont pas automatiquement repris d’une mise à niveau majeure à l’autre.

How do I install a package from GitHub or Bioconductor in R?

GitHub : install.packages("pak") puis pak::pak("user/repo") (ou remotes::install_github("user/repo")). Bioconductor : install.packages("BiocManager") puis BiocManager::install("packageName").

How do I update R packages?

Exécutez update.packages(ask = FALSE) pour tout mettre à jour depuis CRAN, ou update.packages(oldPkgs = c("readr", "ggplot2")) pour cibler des packages précis. Listez ce qui est installé avec installed.packages().

Testez vos connaissances

Exercice : charger un package de base et confirmer qu’il est attaché

Sans rien installer, chargez le package tools intégré à R et confirmez qu’il apparaît parmi les packages chargés. (Les packages de base sont livrés avec R, ils n’ont donc besoin d’aucun install.packages().)

library(tools)

(.packages())   # 'tools' is now in the list

Vérification rapide : installer vs charger

Vous avez écrit install.packages("dplyr") hier. Aujourd’hui vous ouvrez R et appelez filter() directement, mais obtenez could not find function "filter". Pourquoi ?

A. Le package n’était pas vraiment installé. B. Vous devez réexécuter install.packages("dplyr") à chaque session. C. Vous l’avez installé mais n’avez pas fait library(dplyr) cette session.

Afficher la réponse

C. Installer se fait une fois par machine ; charger se fait une fois par session. Fermer R décharge chaque package, donc à chaque nouvelle session vous devez faire library(dplyr) avant d’utiliser ses fonctions. (B est la confusion classique — vous ne réinstallez pas à chaque fois.)

Conclusion

Le flux de travail des packages tient en deux étapes que vous répéterez tout le reste de votre vie avec R : install.packages("name") une fois pour le mettre sur votre ordinateur, et library(name) à chaque session pour l’utiliser. Tournez-vous vers pak/remotes pour GitHub et BiocManager pour Bioconductor, vérifiez .libPaths() quand quelque chose « n’est pas trouvé », et exécutez update.packages() de temps en temps pour rester à jour.

Leçons connexes

RStudio et le répertoire de travail — configurez R avant d’installer quoi que ce soit. · Lire des fichiers CSV et texte — readr à l’œuvre une fois installé. · Lire des fichiers Excel — nécessite readxl. · Renommer des colonnes — dplyr à l’œuvre.
Aller plus loin : Fondamentaux R — la série complète. · Science computationnelle et IA — le pilier.

Cette page vous a-t-elle été utile ?

Prouvez que vous savez le faire. Maîtrisez toute la série Les bases de R — suivez votre parcours, construisez des projets et obtenez un certificat.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code affiché — modifiez n’importe quel bloc et appuyez sur Run pour le reproduire dans votre navigateur. The runtime is the judge.

Réutilisation

CC BY-NC-SA 4.0

Citation

BibTeX

@online{2026,
  author = {},
  title = {Installer des packages R : install.packages, library et mises
    à jour},
  date = {2026-06-26},
  url = {https://www.datanovia.com/learn/programming/r-foundations/installing-packages},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Installer des packages R : install.packages, library et mises à jour.” 2026. June 26. https://www.datanovia.com/learn/programming/r-foundations/installing-packages.

Introduction

Installer un package depuis CRAN

Charger un package avec library()

library() vs require()

Où vivent les packages : .libPaths()

Voir ce qui est installé et ce qui est chargé

Installer depuis GitHub

Installer depuis Bioconductor

Mettre à jour et supprimer des packages

Essayez en direct

Problèmes courants

Questions fréquentes

Testez vos connaissances

Conclusion

Leçons connexes

Réutilisation

Citation

Charger un package avec `library()`

`library()` vs `require()`

Où vivent les packages : `.libPaths()`