लुभावने पैकेज की जाँच करने और उन्हें स्थापित करने का सुरुचिपूर्ण तरीका?

336

मुझे लगता है कि इन दिनों बहुत से कोड सहकर्मी साझा कर रहे हैं। उनमें से कई नौसिखिए / मध्यवर्ती आर उपयोगकर्ता हैं और उन्हें यह महसूस नहीं होता है कि उन्हें उन पैकेजों को स्थापित करना होगा जो उनके पास पहले से नहीं हैं।

क्या कॉल करने का एक सुरुचिपूर्ण तरीका है installed.packages(), जिसकी तुलना मैं कर रहा हूँ और अगर लापता है तो स्थापित कर रहा हूँ?

r  packages  r-faq 
— Maiasaura
स्रोत
1
@krlmlr स्वीकृत उत्तर के बारे में क्या है और संशोधन की आवश्यकता है? यह मेरे (कुछ त्वरित परीक्षणों के लिए) के तहत काम करता है R version 3.0.2 (2013-09-25) x86_64-w64-mingw32/x64 (64-bit)।
— ब्रायन डिग्स
1
@BrianDiggs: कम से कम तीन पैकेज दिखाई दिए हैं जो इस समस्या का समाधान करते हैं, केवल एक को नीचे संदर्भित किया गया है। वहाँ और भी है - यह सवाल है।
— 22
2
@krlmlr पैकेज को उपयोग करने के बारे में (अन्य) आवश्यक पैकेज सुनिश्चित करने के बारे में एक विडंबना चिकन और अंडे की समस्या का एक सा प्रतीत होता है। लेकिन निश्चित रूप से किसी ऐसे व्यक्ति के बारे में जो उनके बारे में जानता है, एक उत्तर लिखता है।
— ब्रायन डिग्स
2
@BrianDiggs: इस इंस्टॉलेशन-चेकिंग पैकेज को बूटस्ट्रैप करना एक आवश्यक उपद्रव है, लेकिन एक छोटा सा। जब तक, निश्चित रूप से, कार्यक्षमता अपना रास्ता ढूंढ base
— लेती है

जवाबों:

304

हाँ। यदि आपके पास अपने पैकेज की सूची है, तो इसे आउटपुट से तुलना करें installed.packages()[,"Package"]और लापता पैकेज स्थापित करें। कुछ इस तरह:

list.of.packages <- c("ggplot2", "Rcpp")
new.packages <- list.of.packages[!(list.of.packages %in% installed.packages()[,"Package"])]
if(length(new.packages)) install.packages(new.packages)

अन्यथा:

यदि आप एक पैकेज में अपना कोड डालते हैं और उन्हें निर्भरता बनाते हैं, तो वे अपने पैकेज को स्थापित करते समय स्वचालित रूप से इंस्टॉल हो जाएंगे।

— शेन
स्रोत
11
मुझे लगता है कि उचित वाक्यविन्यास है: if(length(new.packages)>0) {install.packages(new.packages)}
5
@psql, शाइन सही है, क्योंकि "> 0" यदि "सशर्त" है, अगर इस शर्त के भीतर है। इसे सत्यापित करने के लिए इसे चलाएं:new.packages <- c(1,2) length(new.packages) if(length(new.packages)){print("hello!")}else{print("oh no!")}
— एंड्रिया सिरिलो
7
इंस्टॉल किए गए डॉक्युमेंट्स का डॉक्यूमेंट बताता है: "यह तब धीमा हो सकता है जब हजारों पैकेज इंस्टॉल किए जाते हैं, इसलिए यह पता लगाने के लिए इसका उपयोग न करें कि क्या एक नामित पैकेज इंस्टॉल किया गया है (system.file या find.package का उपयोग करें) ..."
— थॉमस मेटरना
2
थॉमस से सहमत, यह requireजाँच के बजाय बेहतर प्रदर्शन होगाinstalled.packages
— मैथ्यू
1
packratइसके लिए बनाया गया था। यह एक प्रतिलिपि प्रस्तुत करने योग्य पैकेज प्रबंधन प्रणाली है। यह रास्ता इसके बारे में गलत तरीके से चल रहा है और किसी और के वातावरण के साथ खिलवाड़ करता है न कि प्रजनन योग्य। पैक्राट के पास साझा पुस्तकालयों के लिए स्वयं का फ़ोल्डर और वातावरण है। rstudio.github.io/packrat
— mtelesha 19
231

Dason लालकृष्ण और मैं pacman पैकेज है कि इस अच्छी तरह से कर सकते हैं। p_loadपैकेज में फ़ंक्शन यह करता है। पहली पंक्ति सिर्फ यह सुनिश्चित करने के लिए है कि पैक्मैन स्थापित है।

if (!require("pacman")) install.packages("pacman")
pacman::p_load(package1, package2, package_n)
— टायलर रिंकर
स्रोत
1
पैकेज की स्थिति क्या है? मैं सी-रैन में नहीं देख सकता।
— MERose
4
@ मेरा पेसमैन अब क्रैन क्रान पर है ।r- project.org
— टायलर
6
अब स्थापित किया है और अद्भुत काम करता है; आधार का हिस्सा होना चाहिए!
— एंडीएफ
3
एकमात्र तरीका यह बेहतर होगा यदि इसे चेक किया जाए /और, यदि स्वचालित रूप से गिथब से स्थापित / लोड हो, तो।
— हवाई
4
@NealBarsch अगर आपका मतलब है कि if (!require("pacman")) install.packages("pacman")pacman में एक फंक्शन है, p_boot()जो कि इस लाइन को आपके लिए ऑटोमैटिकली बना देता है और इसे क्लिपबोर्ड पर कॉपी कर देता है।
— टायलर रिंकर
72

आप केवल इसके वापसी मूल्य का उपयोग कर सकते हैं require:

if(!require(somepackage)){
    install.packages("somepackage")
    library(somepackage)
}

मैं libraryइंस्टॉल के बाद उपयोग करता हूं क्योंकि यह एक अपवाद को फेंक देगा यदि इंस्टॉल सफल नहीं हुआ या पैकेज को किसी अन्य कारण से लोड नहीं किया जा सकता है। आप इसे और अधिक मजबूत और पुन: प्रयोज्य बनाते हैं:

dynamic_require <- function(package){
  if(eval(parse(text=paste("require(",package,")")))) return True

  install.packages(package)
  return eval(parse(text=paste("require(",package,")")))
}

इस विधि के लिए नकारात्मक पक्ष यह है कि आपको उद्धरण में पैकेज का नाम पास करना होगा, जो आप वास्तविक के लिए नहीं करते हैं require।

— Livius
स्रोत
4
आप का उपयोग करके अपने जीवन में बहुत कुछ सरल बना सकते हैं character.only = TRUEमें requireहै, लेकिन फिर मुझे लगता है कि मेरा अपना उत्तर अंतर करने के लिए कोई बात नहीं है।
— साइमन ओ'हलान
यह अच्छा लग रहा है, लेकिन यह मेरे लिए कम से कम काम नहीं करता है। जब मैंने इसके मजबूत संस्करण की कोशिश की, तो मुझे दो त्रुटि संदेश मिले क्योंकि आर को पता नहीं है कि किसी कारण के लिए "रिटर्न ट्रू" और "वापसी eval" को कैसे संभालना है। तो मैं वास्तव में इस तरह के एक फ़ंक्शन को पसंद करता हूं जो मेरे पुस्तकालय में मौजूद होने पर पैकेज को लोड करता है और अन्यथा पैकेज को स्थापित करता है (और बाद में लोड करता है)। आदर्श रूप में मैं इसे संकुल लोड करने के लिए एक डिफ़ॉल्ट के रूप में उपयोग करूंगा। कम से कम ऐसा लगता है कि यह ऐसा करने के लिए समझ में आता है और कुछ समय बचाएगा।
— फाबियन हैबरसैक
23 
if (!require('ggplot2')) install.packages('ggplot2'); library('ggplot2')

"ggplot2" पैकेज है। यह देखने के लिए जांचता है कि क्या पैकेज स्थापित किया गया है, अगर यह स्थापित नहीं है। यह तब पैकेज को लोड करता है, चाहे वह किस शाखा में लिया गया हो।

— user6784955
स्रोत
21

यह समाधान पैकेज नामों के एक चरित्र वेक्टर को ले जाएगा और लोडिंग विफल होने पर उन्हें लोड करने या स्थापित करने का प्रयास करेगा। यह ऐसा करने के रिटर्न व्यवहार पर निर्भर करता है requireक्योंकि ...

require रिटर्न (अदृश्य रूप से) एक तार्किक संकेत है कि क्या आवश्यक पैकेज उपलब्ध है

इसलिए हम केवल यह देख सकते हैं कि क्या हम आवश्यक पैकेज को लोड करने में सक्षम थे और यदि नहीं, तो निर्भरता के साथ इसे स्थापित करें। तो पैकेज के एक चरित्र वेक्टर दिया जिसे आप लोड करना चाहते हैं ...

foo <- function(x){
  for( i in x ){
    #  require returns TRUE invisibly if it was able to load package
    if( ! require( i , character.only = TRUE ) ){
      #  If package was not able to be loaded then re-install
      install.packages( i , dependencies = TRUE )
      #  Load package after installing
      require( i , character.only = TRUE )
    }
  }
}

#  Then try/install packages...
foo( c("ggplot2" , "reshape2" , "data.table" ) )
— साइमन ओ'हलान
स्रोत
क्या आप requireस्थापित करने के बाद फिर से कॉल नहीं करना चाहेंगे ?
— krlmlr
@krlmlr नहींं, क्योंकि ifबयान का मूल्यांकन करने के लिए इसे पहले मूल्यांकन करना चाहिए require, इसके साइड-इफेक्ट पैकेज को लोड कर रहा है यदि यह उपलब्ध है!
— साइमन ओ'हलान 2
1
SimonO101: मुझे लगता है कि कॉल में krlmlr का अर्थ है, कॉल करने के बाद install.packages, क्योंकि यह वास्तव में उस पैकेज को लोड नहीं करेगा। लेकिन (@krlmlr को) मुझे इस आशय का संदेह है कि यह कोड टुकड़ा केवल एक बार कहा जाएगा; जब भी आपको पैकेज की आवश्यकता होती है आप इसे हर बार नहीं लिखेंगे। इसके बजाय आप इसे समय से पहले एक बार चलाएंगे और फिर requireहमेशा की तरह कॉल करेंगे।
— हारून ने
@ ऐरॉन आह हां ठीक है, मैं देख रहा हूं कि आपका क्या मतलब है, और हां आपकी व्याख्या सही है। मैं इसे स्थापित करने के बाद लोड करने के बारे में अधिक स्पष्ट होने के लिए इसे थोड़ा संपादित करूँगा।
— साइमन ओ'हलान 2
1
यह बेहतर होगा कि दूसरी requireकॉल न करें libraryताकि यह किसी भी तरह से विफल न हो अगर यह अभी भी किसी कारण से पैकेज को संलग्न करने में असमर्थ है?
— काबदुल्ला
18

ऊपर दिए गए बहुत सारे उत्तर (और इस प्रश्न के डुप्लिकेट पर) इस बात पर भरोसा करते हैं कि installed.packagesकौन सा फॉर्म खराब है। प्रलेखन से:

हजारों पैकेज स्थापित होने पर यह धीमा हो सकता है, इसलिए यह पता लगाने के लिए इसका उपयोग न करें कि क्या एक नामित पैकेज स्थापित किया गया है (सिस्टम का उपयोग करें। ढूँढें या find.package) और न ही यह पता लगाने के लिए कि क्या पैकेज उपयोग करने योग्य है (कॉल की आवश्यकता है और जांचें) कम मूल्य (न ही पैकेज की एक छोटी संख्या का विवरण खोजने के लिए) और पैकेज का उपयोग करें। इसे प्रति स्थापित पैकेज में कई फाइलें पढ़ने की जरूरत है, जो विंडोज पर और कुछ नेटवर्क-माउंटेड फाइल सिस्टम पर धीमी होगी।

तो, एक बेहतर तरीका यह है requireकि लोडिंग विफल होने पर पैकेज का उपयोग करके और लोड करने का प्रयास करें (लोड नहीं होने पर requireवापस आ जाएगा FALSE)। मैं इस कार्यान्वयन को प्राथमिकता देता हूं:

using<-function(...) {
    libs<-unlist(list(...))
    req<-unlist(lapply(libs,require,character.only=TRUE))
    need<-libs[req==FALSE]
    if(length(need)>0){ 
        install.packages(need)
        lapply(need,require,character.only=TRUE)
    }
}

जिसका उपयोग इस तरह किया जा सकता है: 

using("RCurl","ggplot2","jsonlite","magrittr")

इस तरह यह सभी पैकेजों को लोड करता है, फिर वापस जाता है और सभी लापता पैकेजों को स्थापित करता है (यदि आप चाहें, तो यह पूछने के लिए संकेत डालने के लिए एक आसान स्थान है कि क्या उपयोगकर्ता पैकेजों को स्थापित करना चाहता है)। install.packagesप्रत्येक पैकेज के लिए अलग से कॉल करने के बजाय यह सिर्फ एक बार अनइंस्टॉल किए गए पैकेजों के पूरे वेक्टर को पास करता है।

यहां एक ही फ़ंक्शन है लेकिन एक विंडोज़ संवाद के साथ जो पूछता है कि क्या उपयोगकर्ता लापता पैकेजों को स्थापित करना चाहता है 

using<-function(...) {
    libs<-unlist(list(...))
    req<-unlist(lapply(libs,require,character.only=TRUE))
    need<-libs[req==FALSE]
    n<-length(need)
    if(n>0){
        libsmsg<-if(n>2) paste(paste(need[1:(n-1)],collapse=", "),",",sep="") else need[1]
        print(libsmsg)
        if(n>1){
            libsmsg<-paste(libsmsg," and ", need[n],sep="")
        }
        libsmsg<-paste("The following packages could not be found: ",libsmsg,"\n\r\n\rInstall missing packages?",collapse="")
        if(winDialog(type = c("yesno"), libsmsg)=="YES"){       
            install.packages(need)
            lapply(need,require,character.only=TRUE)
        }
    }
}
— मैथ्यू
स्रोत
यह एक बहुत सुंदर तरीका है, स्वीकार किए जाते हैं की तुलना में बेहतर है। मैं इसे अपनी निजी लाइब्रेरी में शामिल करूँगा। धन्यवाद।
— बिंग
15

हालांकि शेन के जवाब है, वास्तव में अच्छा है अपने प्रोजेक्ट में से एक के लिए मैं ouput संदेश, चेतावनी को हटाने और पैकेज इंस्टॉल करने की जरूरत स्वतः । मैं आखिरकार इस स्क्रिप्ट को पाने में कामयाब रहा:

InstalledPackage <- function(package) 
{
    available <- suppressMessages(suppressWarnings(sapply(package, require, quietly = TRUE, character.only = TRUE, warn.conflicts = FALSE)))
    missing <- package[!available]
    if (length(missing) > 0) return(FALSE)
    return(TRUE)
}

CRANChoosen <- function()
{
    return(getOption("repos")["CRAN"] != "@CRAN@")
}

UsePackage <- function(package, defaultCRANmirror = "http://cran.at.r-project.org") 
{
    if(!InstalledPackage(package))
    {
        if(!CRANChoosen())
        {       
            chooseCRANmirror()
            if(!CRANChoosen())
            {
                options(repos = c(CRAN = defaultCRANmirror))
            }
        }

        suppressMessages(suppressWarnings(install.packages(package)))
        if(!InstalledPackage(package)) return(FALSE)
    }
    return(TRUE)
}

उपयोग:

libraries <- c("ReadImages", "ggplot2")
for(library in libraries) 
{ 
    if(!UsePackage(library))
    {
        stop("Error!", library)
    }
}
— जुआन एंटोनियो कैनो
स्रोत
9 
# List of packages for session
.packages = c("ggplot2", "plyr", "rms")

# Install CRAN packages (if not already installed)
.inst <- .packages %in% installed.packages()
if(length(.packages[!.inst]) > 0) install.packages(.packages[!.inst])

# Load packages into session 
lapply(.packages, require, character.only=TRUE)
— ब्रायन स्पिरिंग
स्रोत
6

यह rbundler पैकेज का उद्देश्य है : विशिष्ट प्रोजेक्ट के लिए स्थापित पैकेजों को नियंत्रित करने का एक तरीका प्रदान करना। अभी पैकेज आपके प्रोजेक्ट की डायरेक्टरी में पैकेज स्थापित करने के लिए devtools कार्यक्षमता के साथ काम करता है। कार्यक्षमता रूबी के बंडल के समान है ।

यदि आपका प्रोजेक्ट एक पैकेज (अनुशंसित) है तो आपको बस इतना करना है कि rbundler को लोड करें और पैकेजों को बंडल करें। bundleसमारोह अपने पैकेज के देखेंगे DESCRIPTIONफ़ाइल निर्धारित करने के लिए जो पैकेज बंडल करने।

library(rbundler)
bundle('.', repos="http://cran.us.r-project.org")

अब संकुल .Rbundle निर्देशिका में स्थापित किया जाएगा।

यदि आपकी परियोजना पैकेज नहीं है, तो आप DESCRIPTIONअपनी परियोजना के रूट डायरेक्टरी में एक फाइल बनाकर इसे नकली बना सकते हैं, जो डिपेंड्स फील्ड के साथ उन पैकेजों को सूचीबद्ध करता है जिन्हें आप इंस्टॉल करना चाहते हैं (वैकल्पिक संस्करण जानकारी के साथ):

Depends: ggplot2 (>= 0.9.2), arm, glmnet

यदि आप योगदान करने में रुचि रखते हैं, तो इस परियोजना के लिए जीथब रेपो यहां है: आरबंडलर ।

— एरिक शिल्ट्स
स्रोत
5

ज़रूर।

आपको need इंस्टॉल पैकेज ’की तुलना packages वांछित पैकेज’ से करनी होगी। यह बहुत ही करीब है कि मैं CRANberries के साथ क्या करता हूं क्योंकि मुझे नए और / या अपडेट किए गए पैकेजों को निर्धारित करने के लिए 'वर्तमान में ज्ञात पैकेजों' के साथ 'संग्रहीत ज्ञात पैकेज' की तुलना करने की आवश्यकता है।

तो कुछ ऐसा करें 

AP <- available.packages(contrib.url(repos[i,"url"]))   # available t repos[i]

सभी ज्ञात पैकेजों को प्राप्त करने के लिए, वर्तमान में स्थापित पैकेजों के लिए सिमुलर कॉल करें और किसी दिए गए लक्ष्य पैकेजों की तुलना करें।

— डिर्क एडल्डबुलेट
स्रोत
5

उपयोग करें packratताकि साझा लाइब्रेरी बिल्कुल समान हों और दूसरे का वातावरण न बदल रहे हों।

लालित्य और सर्वोत्तम अभ्यास के संदर्भ में, मुझे लगता है कि आप मूल रूप से इसके बारे में गलत तरीके से जा रहे हैं। packratइन मुद्दों के लिए पैकेज तैयार किया गया था। यह हेडली विकम द्वारा RStudio द्वारा विकसित किया गया है। उनके बजाय निर्भरताएं स्थापित करने और संभवतः किसी की पर्यावरण प्रणाली packratको गड़बड़ाने के लिए , अपनी स्वयं की निर्देशिका का उपयोग करता है और वहां आपके कार्यक्रमों के लिए सभी निर्भरताएं स्थापित करता है और किसी के पर्यावरण को नहीं छूता है।

पैकराट आर के लिए एक निर्भरता प्रबंधन प्रणाली है।

पैकेज निर्भरता निराशा हो सकती है। क्या आपको कभी किसी और के कोड को काम करने के लिए आपको कौन से R संकुल को स्थापित करने की आवश्यकता है, यह जानने के लिए परीक्षण-और-त्रुटि का उपयोग करना पड़ा और फिर उन पैकेजों के साथ छोड़ दिया गया जो विश्व स्तर पर हमेशा के लिए स्थापित हैं, क्योंकि अब आप सुनिश्चित नहीं हैं कि आपको उनकी आवश्यकता है या नहीं ? क्या आपने कभी अपने किसी प्रोजेक्ट में काम करने के लिए कोड प्राप्त करने के लिए एक पैकेज को अपडेट किया है, केवल यह पता लगाने के लिए कि अपडेट किया गया पैकेज किसी अन्य प्रोजेक्ट में कोड को काम करना बंद कर देता है?

हमने इन समस्याओं को हल करने के लिए पैकरैट का निर्माण किया। अपने आर प्रोजेक्ट्स को और अधिक बनाने के लिए पैकट्रैट का उपयोग करें:

  • पृथक: एक परियोजना के लिए एक नया या अद्यतन पैकेज स्थापित करने से आपके अन्य प्रोजेक्ट नहीं टूटेंगे, और इसके विपरीत। ऐसा इसलिए है क्योंकि packrat प्रत्येक परियोजना को अपनी निजी पैकेज लाइब्रेरी देता है।
  • पोर्टेबल: आसानी से अपनी परियोजनाओं को एक कंप्यूटर से दूसरे में, यहां तक ​​कि विभिन्न प्लेटफार्मों पर भी परिवहन करें। पैकर्ट आपके प्रोजेक्ट पर निर्भर पैकेजों को स्थापित करना आसान बनाता है।
  • Reproducible: Packrat आपके द्वारा निर्भर किए गए सटीक पैकेज संस्करणों को रिकॉर्ड करता है, और उन सटीक संस्करणों को सुनिश्चित करता है जो आप जहां भी जाते हैं स्थापित हो जाते हैं।

https://rstudio.github.io/packrat/

— mtelesha
स्रोत
4

निम्नलिखित सरल कार्य एक आकर्षण की तरह काम करता है: 

  usePackage<-function(p){
      # load a package if installed, else load after installation.
      # Args:
      #   p: package name in quotes

      if (!is.element(p, installed.packages()[,1])){
        print(paste('Package:',p,'Not found, Installing Now...'))
        install.packages(p, dep = TRUE)}
      print(paste('Loading Package :',p))
      require(p, character.only = TRUE)  
    }

(मेरा नहीं, कुछ समय पहले वेब पर यह पाया गया था और तब से इसका उपयोग कर रहा था। मूल स्रोत के बारे में सुनिश्चित नहीं है)

— अनीश सुगाथन
स्रोत
4

अगर require("<package>")पैकेज में त्रुटि नहीं पाई जाती है तो मैं पैकेज को स्थापित करने के लिए निम्नलिखित फंक्शन का उपयोग करता हूं । यह लापता पैकेज के लिए दोनों - CRAN और BioconSTR रिपॉजिटरी को क्वेरी करेगा।

जोशुआ विली, http://r.789695.n4.nabble.com/Install-package-automatically-if-not-there-td2267532.html द्वारा मूल काम से अनुकूलित 

install.packages.auto <- function(x) { 
  x <- as.character(substitute(x)) 
  if(isTRUE(x %in% .packages(all.available=TRUE))) { 
    eval(parse(text = sprintf("require(\"%s\")", x)))
  } else { 
    #update.packages(ask= FALSE) #update installed packages.
    eval(parse(text = sprintf("install.packages(\"%s\", dependencies = TRUE)", x)))
  }
  if(isTRUE(x %in% .packages(all.available=TRUE))) { 
    eval(parse(text = sprintf("require(\"%s\")", x)))
  } else {
    source("http://bioconductor.org/biocLite.R")
    #biocLite(character(), ask=FALSE) #update installed packages.
    eval(parse(text = sprintf("biocLite(\"%s\")", x)))
    eval(parse(text = sprintf("require(\"%s\")", x)))
  }
}

उदाहरण:

install.packages.auto(qvalue) # from bioconductor
install.packages.auto(rNMF) # from CRAN

पुनश्च: update.packages(ask = FALSE)& biocLite(character(), ask=FALSE)सिस्टम पर सभी स्थापित संकुल को अद्यतन करेगा। यह एक लंबा समय ले सकता है और इसे पूर्ण आर अपग्रेड के रूप में माना जा सकता है जो कि हर समय वारंट नहीं हो सकता है!

— समीर
स्रोत
यह जाँच कर सुधार किया जा सकता है कि क्या पैकेज वास्तव में क्रेन या बीसी पर उपलब्ध हैं। यदि स्थापना विफल हुई या कोई पैकेज मौजूद नहीं है, तो भी उसे किसी त्रुटि को फेंकने के लिए लाइब्रेरी का उपयोग करना चाहिए। मेरी उन्नत संस्करण कहा जाता देखें loadpack()पर raw.githubusercontent.com/holgerbrandl/datautils/master/R/...
— होल्गर ब्रैंडिल
4

आप केवल setdiffउन पैकेजों को प्राप्त करने के लिए फ़ंक्शन का उपयोग कर सकते हैं जो स्थापित नहीं हैं और फिर उन्हें स्थापित करें। नीचे दिए गए नमूने में, हम जाँचते हैं कि क्या ggplot2और Rcppसंकुल को स्थापित करने से पहले स्थापित किया गया है।

unavailable <- setdiff(c("ggplot2", "Rcpp"), rownames(installed.packages()))
install.packages(unavailable)

एक पंक्ति में, ऊपर लिखा जा सकता है:

install.packages(setdiff(c("ggplot2", "Rcpp"), rownames(installed.packages())))
— एलेक्स Essilfie
स्रोत
मैं उसी दृष्टिकोण का उपयोग करता हूं। हम यह भी उपयोग कर सकते हैं installed.packages()[,'Package']के बजाय rownames(installed.packages())।
— स्कडेल्लेटी
3

मैंने आवश्यक आर संकुल को चुपचाप स्थापित करने और लोड करने के लिए फ़ंक्शन को लागू किया है। आशा है कि मदद कर सकते हैं। यहाँ कोड है:

# Function to Install and Load R Packages
Install_And_Load <- function(Required_Packages)
{
    Remaining_Packages <- Required_Packages[!(Required_Packages %in% installed.packages()[,"Package"])];

    if(length(Remaining_Packages)) 
    {
        install.packages(Remaining_Packages);
    }
    for(package_name in Required_Packages)
    {
        library(package_name,character.only=TRUE,quietly=TRUE);
    }
}

# Specify the list of required packages to be installed and load    
Required_Packages=c("ggplot2", "Rcpp");

# Call the Function
Install_And_Load(Required_Packages);
— प्रतीक पाटिल
स्रोत
3

RStudio (1.2) के आने वाले संस्करण, पहले से ही पूर्वावलोकन के रूप में उपलब्ध हैं, इसमें कॉल library()और require()कॉल में लापता पैकेज का पता लगाने और उन्हें स्थापित करने के लिए उपयोगकर्ता को संकेत देने की सुविधा शामिल होगी :

लापता आर संकुल का पता लगाएं

निष्पादित करने के लिए उन पैकेजों को कॉल करने library()और require()उन्हें लोड करने के लिए कई आर स्क्रिप्ट खुलती हैं । यदि आप एक R स्क्रिप्ट खोलते हैं जो उन पैकेजों का संदर्भ देता है जिन्हें आपने इंस्टॉल नहीं किया है, तो RStudio अब एक क्लिक में सभी आवश्यक पैकेजों को स्थापित करने की पेशकश करेगा। install.packages()त्रुटियों के चले जाने तक बार-बार टाइप करना नहीं !
https://blog.rstudio.com/2018/11/19/rstudio-1-2-preview-the-little-things/

यह ओपी की मूल चिंता को अच्छी तरह से संबोधित करता है:

उनमें से कई नौसिखिए / मध्यवर्ती आर उपयोगकर्ता हैं और उन्हें यह महसूस नहीं होता है कि उन्हें उन पैकेजों को स्थापित करना होगा जो उनके पास पहले से नहीं हैं।

— Aurèle
स्रोत
2

अपने मुख्य उद्देश्य के बारे में "उन पुस्तकालयों को स्थापित करने के लिए जो उनके पास पहले से नहीं हैं।" और "instllaed.packages ()" का उपयोग किए बिना। निम्नलिखित फ़ंक्शन आवश्यकता के मूल कार्य को मुखौटा करता है। यह नामित पैकेज "x" को लोड करने और जांचने की कोशिश करता है, अगर यह स्थापित नहीं है, तो इसे सीधे निर्भरता सहित स्थापित करें; और अंत में इसे सामान्य रूप से लोड करें। आप अखंडता को बनाए रखने के लिए फ़ंक्शन का नाम 'आवश्यकता' से 'लाइब्रेरी' तक रखते हैं। केवल सीमा संकुल नाम हैं जिन्हें उद्धृत किया जाना चाहिए।

require <- function(x) { 
  if (!base::require(x, character.only = TRUE)) {
  install.packages(x, dep = TRUE) ; 
  base::require(x, character.only = TRUE)
  } 
}

तो आप आर के पुराने फैशन तरीके को लोड और इंस्टॉल कर सकते हैं। आवश्यकता होती है ("ggplot2") की आवश्यकता होती है ("Rcpp")

— GeoObserver
स्रोत
यदि आपको अपना उत्तर पसंद नहीं है, तो इसे बर्बरता न करें - बस इसे हटा दें।
— माइकल पेट्रोत्ता
खैर, मैंने कोशिश की, लेकिन मैं नहीं कर सका। मुझे लगता है कि FF का मेरा NoScript एक्सटेंशन इसे अक्षम कर रहा है या मेरे पास अपने स्वयं के उत्तर को हटाने के अधिकार और क्रेडिट नहीं हैं। एलओएल हालांकि, मुझे लगता है कि लिवियस मेरे जवाब के काफी करीब है, बिना मास्किंग के। धन्यवाद माइकल पेट्रोत्ता। अधिसूचना के लिए।
— जियोऑब्जर्वर
आपको deleteइन टिप्पणियों के ऊपर एक लिंक देखना चाहिए । यदि आप नहीं करते हैं, और आप अभी भी हटाना चाहते हैं, तो flagलिंक का उपयोग करें, "अन्य" का चयन करें, और एक मॉडरेटर को समझाएं कि आप हटाए गए उत्तर को पसंद करेंगे।
— माइकल पेट्रोत्ता
2

काफी बुनियादी। 

pkgs = c("pacman","data.table")
if(length(new.pkgs <- setdiff(pkgs, rownames(installed.packages())))) install.packages(new.pkgs)
— jangorecki
स्रोत
2

सोचा था कि मैं जिस एक का उपयोग करूंगा:

testin <- function(package){if (!package %in% installed.packages())    
install.packages(package)}
testin("packagename")
— बेन
स्रोत
2

Lapply परिवार और अनाम फ़ंक्शन दृष्टिकोण का उपयोग करना:

  1. सभी सूचीबद्ध पैकेजों को संलग्न करने का प्रयास करें।
  2. केवल लापता ( ||आलसी मूल्यांकन का उपयोग करके ) स्थापित करें ।
  3. फिर से संलग्न करने का प्रयास करें जो चरण 1 में गायब थे और चरण 2 में स्थापित थे।

  4. प्रत्येक पैकेज को अंतिम लोड स्थिति ( TRUE/ FALSE) प्रिंट करें ।

    req <- substitute(require(x, character.only = TRUE))
lbs <- c("plyr", "psych", "tm")
sapply(lbs, function(x) eval(req) || {install.packages(x); eval(req)})

plyr psych    tm 
TRUE  TRUE  TRUE
— जॉर्जी शिमानोव्स्की
स्रोत
1

मैं निम्नलिखित का उपयोग करता हूं जो जांच करेगा कि क्या पैकेज स्थापित है और अगर निर्भरता अपडेट की जाती है, तो पैकेज लोड करता है।

p<-c('ggplot2','Rcpp')
install_package<-function(pack)
{if(!(pack %in% row.names(installed.packages())))
{
  update.packages(ask=F)
  install.packages(pack,dependencies=T)
}
 require(pack,character.only=TRUE)
}
for(pack in p) {install_package(pack)}

completeFun <- function(data, desiredCols) {
  completeVec <- complete.cases(data[, desiredCols])
  return(data[completeVec, ])
}
— metasequoia
स्रोत
1

यहाँ इसके लिए मेरा कोड है:

packages <- c("dplyr", "gridBase", "gridExtra")
package_loader <- function(x){
    for (i in 1:length(x)){
        if (!identical((x[i], installed.packages()[x[i],1])){
            install.packages(x[i], dep = TRUE)
        } else {
            require(x[i], character.only = TRUE)
        }
    }
}
package_loader(packages)
— एडवर्ड टायलर
स्रोत
1 
 48 lapply_install_and_load <- function (package1, ...)
 49 {
 50     #
 51     # convert arguments to vector
 52     #
 53     packages <- c(package1, ...)
 54     #
 55     # check if loaded and installed
 56     #
 57     loaded        <- packages %in% (.packages())
 58     names(loaded) <- packages
 59     #
 60     installed        <- packages %in% rownames(installed.packages())
 61     names(installed) <- packages
 62     #
 63     # start loop to determine if each package is installed
 64     #
 65     load_it <- function (p, loaded, installed)
 66     {
 67         if (loaded[p])
 68         {
 69             print(paste(p, "loaded"))
 70         }
 71         else
 72         {
 73             print(paste(p, "not loaded"))
 74             if (installed[p])
 75             {
 76                 print(paste(p, "installed"))
 77                 do.call("library", list(p))
 78             }
 79             else
 80             {
 81                 print(paste(p, "not installed"))
 82                 install.packages(p)
 83                 do.call("library", list(p))
 84             }
 85         }
 86     }
 87     #
 88     lapply(packages, load_it, loaded, installed)
 89 }
— ruemorgue
स्रोत
1 
library <- function(x){
  x = toString(substitute(x))
if(!require(x,character.only=TRUE)){
  install.packages(x)
  base::library(x,character.only=TRUE)
}}

यह निर्विवाद पैकेज नामों के साथ काम करता है और काफी सुरुचिपूर्ण है (cf. GeoObserver का उत्तर)

— एस.एन.
स्रोत
1

मेरे मामले में, मुझे एक लाइनर चाहिए था जिसे मैं कमांडलाइन (वास्तव में मेकफाइल के माध्यम से) से चला सकता था। यदि वे पहले से स्थापित नहीं हैं, तो यहां "VGAM" और "पंख" स्थापित करना एक उदाहरण है:

R -e 'for (p in c("VGAM", "feather")) if (!require(p, character.only=TRUE)) install.packages(p, repos="http://cran.us.r-project.org")'

R के भीतर से यह बस होगा:

for (p in c("VGAM", "feather")) if (!require(p, character.only=TRUE)) install.packages(p, repos="http://cran.us.r-project.org")

इसके अलावा पिछले समाधानों से परे यहां कुछ भी नहीं है:

  • मैं इसे एक ही पंक्ति में रखता हूं
  • मैं reposपैरामीटर को हार्ड कोड देता हूं (दर्पण के उपयोग के बारे में पूछने वाले किसी भी पॉपअप से बचने के लिए)
  • मैं अन्यत्र उपयोग किए जाने वाले किसी फ़ंक्शन को परिभाषित करने के लिए परेशान नहीं करता

इसके अलावा महत्वपूर्ण पर ध्यान दें character.only=TRUE( इसके बिना, requireपैकेज को लोड करने की कोशिश करेगा p)।

— user3780389
स्रोत
0 
  packages_installed <- function(pkg_list){
        pkgs <- unlist(pkg_list)
        req <- unlist(lapply(pkgs, require, character.only = TRUE))
        not_installed <- pkgs[req == FALSE]
        lapply(not_installed, install.packages, 
               repos = "http://cran.r-project.org")# add lib.loc if needed
        lapply(pkgs, library, character.only = TRUE)
}
— KVemuri
स्रोत
0

मुझे थोड़ा पागलपन साझा करें:

c("ggplot2","ggsci", "hrbrthemes", "gghighlight", "dplyr") %>%  # What will you need to load for this script?
  (function (x) ifelse(t =!(x %in% installed.packages()), 
    install.packages(x[t]),
    lapply(x, require)))
— lf_araujo
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.