Qual è la differenza tra require()
e library()
?
Non c’è molto di uno nel lavoro di tutti i giorni.
Tuttavia, in base alla documentazione di entrambe le funzioni (a cui si accede inserendo un carattere prima del nome della funzione e premendo enter), viene require
all’interno delle funzioni, in quanto emette un avviso e continua se il pacchetto non viene trovato, mentre la library
genera un errore .
Un altro vantaggio di require()
è che restituisce un valore logico per impostazione predefinita. TRUE
se i pacchetti sono caricati, FALSE
se non lo è.
> test <- library("abc") Error in library("abc") : there is no package called 'abc' > test Error: object 'test' not found > test <- require("abc") Loading required package: abc Warning message: In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE, : there is no package called 'abc' > test [1] FALSE
Quindi puoi usare require()
in costruzioni come quella qui sotto. Che pricipalmente se vuoi distribuire il tuo codice alla nostra installazione R, i pacchetti potrebbero non essere installati.
if(require("lme4")){ print("lme4 is loaded correctly") } else { print("trying to install lme4") install.packages("lme4") if(require(lme4)){ print("lme4 installed and loaded") } else { stop("could not install lme4") } }
È ansible utilizzare require()
se si desidera installare i pacchetti se e solo se necessario, come ad esempio:
if (!require(package, character.only=T, quietly=T)) { install.packages(package) library(package, character.only=T) }
Per più pacchetti che puoi usare
for (package in c('', '')) { if (!require(package, character.only=T, quietly=T)) { install.packages(package) library(package, character.only=T) } }
Suggerimenti Pro:
Se utilizzato all’interno dello script, è ansible evitare una finestra di dialogo specificando il parametro repos
di install.packages()
, ad esempio
install.packages(package, repos="http://cran.us.r-project.org")
Puoi racchiudere require()
e library()
in suppressPackageStartupMessages()
per, beh, sopprimere i messaggi di avvio del pacchetto, e anche usare i parametri require(..., quietly=T, warn.conflicts=F)
se necessario per mantenere le installazioni silenzioso.
Oltre ai buoni consigli già forniti, vorrei aggiungere questo:
Probabilmente è meglio evitare l’uso di require()
meno che non si utilizzi effettivamente il valore che restituisce, ad esempio in un ciclo di controllo degli errori come quello fornito da thierry.
Nella maggior parte degli altri casi è meglio usare la library()
, perché questo darà un messaggio di errore al momento del caricamento del pacchetto se il pacchetto non è disponibile. require()
fallirà senza errori se il pacchetto non è presente. Questo è il momento migliore per scoprire se è necessario installare il pacchetto (o forse non esiste nemmeno perché è stato scritto erroneamente). Ottenere il feedback degli errori in anticipo e al momento opportuno eviterà possibili mal di testa con il rilevamento del motivo per cui un codice successivo non riesce quando tenta di utilizzare le routine di libreria
?library
e vedrai:
library(package)
erequire(package)
entrambi caricare il pacchetto con il pacchetto nome e inserirlo nell’elenco di ricerca.require
è progettato per l’uso all’interno di altre funzioni; restituisceFALSE
e fornisce un avvertimento (piuttosto che un errore comelibrary()
per impostazione predefinita) se il pacchetto non esiste. Entrambe le funzioni controllano e aggiornano l’elenco dei pacchetti attualmente caricati e non ricaricano un pacchetto che è già stato caricato. (Se si desidera ricaricare un pacchetto di questo tipo, richiamare prima lodetach(unload = TRUE)
ounloadNamespace
.) Se si desidera caricare un pacchetto senza inserirlo nell’elenco di ricerca, utilizzarerequireNamespace
.
La mia teoria iniziale sulla differenza era che la library
carica i pacchetti sia che sia già caricata o meno, cioè che potrebbe ricaricare un pacchetto già caricato, mentre require
semplicemente di controllare che sia caricato, o lo carica se non lo è (quindi l’uso in funzioni che si basano su un determinato pacchetto). Tuttavia, la documentazione lo confuta e afferma esplicitamente che nessuna funzione ricaricherà un pacchetto già caricato.
Qui sembra essere la differenza su un pacchetto già caricato. Mentre è vero che entrambi richiedono e la libreria non carica il pacchetto. La libreria fa un sacco di altre cose prima che controlli ed esca.
Vorrei raccomandare di rimuovere “require” dall’inizio di una funzione che esegue comunque 2mil time, ma se, per qualche motivo, dovevo tenerlo. richiedere è tecnicamente un controllo più veloce.
microbenchmark(req = require(microbenchmark), lib = library(microbenchmark),times = 100000) Unit: microseconds expr min lq mean median uq max neval req 3.676 5.181 6.596968 5.655 6.177 9456.006 1e+05 lib 17.192 19.887 27.302907 20.852 22.490 255665.881 1e+05
library
. Mai 1 uso require
. ( 1 Quasi mai, forse .)
In poche parole, questo è dovuto al fatto che, quando si utilizza require
, il proprio codice potrebbe produrre risultati errati diversi, senza segnalare un errore . Questo è raro ma non ipotetico! Considera questo codice, che produce risultati diversi a seconda che possa essere caricato {dplyr}:
require(dplyr) x = data.frame(y = seq(100)) y = 1 filter(x, y == 1)
Questo può portare a risultati leggermente sbagliati. Usare la library
invece di require
genera qui un errore, segnalando chiaramente che qualcosa non va. Questo è buono
Inoltre, rende più difficile il debug di tutti gli altri errori: se hai require
un pacchetto all’inizio dello script e utilizzi le sue esportazioni nella riga 500, riceverai un messaggio di errore “object ‘pippo’ non trovato” nella riga 500, anziché un errore “non c’è nessun pacchetto chiamato ‘bla'”.
L’unico caso di utilizzo accettabile è quando il suo valore di ritorno viene immediatamente controllato, come mostrano alcune delle altre risposte. Questo è un modello abbastanza comune ma anche in questi casi è meglio (e consigliato, vedi sotto) di separare invece il controllo dell’esistenza e il caricamento del pacchetto.
Più tecnicamente, require
effettivamente chiamate alla library
internamente (se il pacchetto non era già collegato – require
quindi di eseguire un controllo ridondante, poiché la library
controlla anche se il pacchetto è già stato caricato). Ecco una implementazione semplificata di require
per illustrare cosa fa:
require = function (package) { already_attached = paste('package:', package) %in% search() if (already_attached) return(TRUE) maybe_error = try(library(package, character.only = TRUE)) success = ! inherits(maybe_error, 'try-error') if (! success) cat("Failed") success }
Yihui Xie , autore di {knitr}, {bookdown} e molti altri pacchetti dice :
Signore e signori, l’ho già detto prima: require () è il modo sbagliato per caricare un pacchetto R; usa invece la libreria ()
Hadley Wickham , autore di pacchetti R più popolari di chiunque altro, dice
Utilizzare la
library(x)
negli script di analisi dei dati. […] Non hai mai bisogno di usarerequire()
(requireNamespace()
è quasi sempre meglio)
require()
carica tutti i pacchetti aggiuntivi