command line - मैं आर स्क्रिप्ट से कमांड लाइन पैरामीटर कैसे पढ़ सकता हूं?




command-line r (7)

मुझे एक आर स्क्रिप्ट मिली है जिसके लिए मैं कई कमांड लाइन पैरामीटर (कोड में हार्डकोड पैरामीटर मानों की बजाय) की आपूर्ति करने में सक्षम होना चाहता हूं। लिपि विंडोज पर चलती है।

मुझे मेरी आर स्क्रिप्ट में कमांड लाइन पर दिए गए पैरामीटर को पढ़ने के तरीके के बारे में जानकारी नहीं मिल रही है। मुझे आश्चर्य होगा अगर यह नहीं किया जा सकता है, तो शायद मैं अपनी Google खोज में सबसे अच्छे कीवर्ड का उपयोग नहीं कर रहा हूं ...

कोई संकेतक या सिफारिशें?


आपको littler की आवश्यकता है (उच्चारण 'थोड़ा आर')

विस्तृत करने के लिए लगभग 15 मिनट में डिर्क होगा;)


इसे अपनी स्क्रिप्ट के शीर्ष पर जोड़ें:

args<-commandArgs(TRUE)

फिर आप तर्क args[1] रूप में पारित तर्कों का उल्लेख कर सकते हैं, तर्क args[2] आदि

तो भागो

Rscript myscript.R arg1 arg2 arg3

यदि आपके तर्क उनमें रिक्त स्थान के साथ तार हैं, तो डबल कोट्स के भीतर संलग्न करें।


कुछ बिंदु:

  1. कमांड लाइन पैरामीटर commandArgs() माध्यम से सुलभ हैं, इसलिए एक सिंहावलोकन के लिए help(commandArgs) देखें।

  2. आप Windows सहित सभी प्लेटफ़ॉर्म पर Rscript.exe उपयोग कर सकते हैं। यह commandArgs() समर्थन करेगा। littler को विंडोज़ पर पोर्ट किया जा सकता है लेकिन अभी ओएस एक्स और लिनक्स पर ही रहता है।

  3. सीआरएएन - optparse और optparse पर दो एड-ऑन पैकेज हैं - जो दोनों कमांड लाइन पार्सिंग के लिए लिखे गए थे।

नवंबर 2015 में संपादित करें: नए विकल्प सामने आए हैं और मैं पूरी तरह से docopt की सिफारिश करता docopt


चूंकि optparse का उत्तर में दो बार उल्लेख किया गया है, और यह कमांड लाइन प्रसंस्करण के लिए एक व्यापक किट प्रदान करता है, यहां इनपुट फ़ाइल मौजूद है, यह मानते हुए कि आप इसका उपयोग कैसे कर सकते हैं इसका एक संक्षिप्त सरलीकृत उदाहरण है:

script.R:

library(optparse)

option_list <- list(
  make_option(c("-n", "--count_lines"), action="store_true", default=FALSE,
    help="Count the line numbers [default]"),
  make_option(c("-f", "--factor"), type="integer", default=3,
    help="Multiply output by this number [default %default]")
)

parser <- OptionParser(usage="%prog [options] file", option_list=option_list)

args <- parse_args(parser, positional_arguments = 1)
opt <- args$options
file <- args$args

if(opt$count_lines) {
  print(paste(length(readLines(file)) * opt$factor))
}

23 लाइनों के साथ एक मनमानी फ़ाइल blah.txt गया।

कमांड लाइन पर:

Rscript script.R -h आउटपुट

Usage: script.R [options] file


Options:
        -n, --count_lines
                Count the line numbers [default]

        -f FACTOR, --factor=FACTOR
                Multiply output by this number [default 3]

        -h, --help
                Show this help message and exit

Rscript script.R -n blah.txt आउटपुट [1] "69"

Rscript script.R -n -f 5 blah.txt आउटपुट [1] "115"


मैंने इस स्विचिंग व्यवहार को उत्पन्न करने के लिए एक अच्छी डेटा संरचना और प्रसंस्करण श्रृंखला को एक साथ रखा है, कोई पुस्तकालय आवश्यक नहीं है। मुझे यकीन है कि इसे कई बार लागू किया जाएगा, और इस धागे में उदाहरणों की तलाश में आया - सोचा कि मैं चिपकूँगा।

मुझे विशेष रूप से झंडे की भी आवश्यकता नहीं थी (यहां एकमात्र ध्वज एक डीबग मोड है, जो एक चर बनाने वाला है जिसे मैं डाउनस्ट्रीम फ़ंक्शन शुरू करने की शर्त के रूप में if (!exists(debug.mode)) {...} else {print(variables)}) । फ्लैग चेकिंग lapply बयान नीचे दिए गए हैं:

if ("--debug" %in% args) debug.mode <- T
if ("-h" %in% args || "--help" %in% args) 

जहां तर्क कमांड लाइन तर्कों (एक चरित्र वेक्टर, c('--debug','--help') बराबर होता है जब आप उदाहरण के लिए इन्हें आपूर्ति करते हैं)

यह किसी अन्य ध्वज के लिए पुन: प्रयोज्य है और आप सभी पुनरावृत्ति से बचते हैं, और कोई पुस्तकालय नहीं, इसलिए कोई निर्भरता नहीं है:

args <- commandArgs(TRUE)

flag.details <- list(
"debug" = list(
  def = "Print variables rather than executing function XYZ...",
  flag = "--debug",
  output = "debug.mode <- T"),
"help" = list(
  def = "Display flag definitions",
  flag = c("-h","--help"),
  output = "cat(help.prompt)") )

flag.conditions <- lapply(flag.details, function(x) {
  paste0(paste0('"',x$flag,'"'), sep = " %in% args", collapse = " || ")
})
flag.truth.table <- unlist(lapply(flag.conditions, function(x) {
  if (eval(parse(text = x))) {
    return(T)
  } else return(F)
}))

help.prompts <- lapply(names(flag.truth.table), function(x){
# joins 2-space-separatated flags with a tab-space to the flag description
  paste0(c(paste0(flag.details[x][[1]][['flag']], collapse="  "),
  flag.details[x][[1]][['def']]), collapse="\t")
} )

help.prompt <- paste(c(unlist(help.prompts),''),collapse="\n\n")

# The following lines handle the flags, running the corresponding 'output' entry in flag.details for any supplied
flag.output <- unlist(lapply(names(flag.truth.table), function(x){
  if (flag.truth.table[x]) return(flag.details[x][[1]][['output']])
}))
eval(parse(text = flag.output))

ध्यान दें कि flag.details में आदेशों को स्ट्रिंग के रूप में संग्रहीत किया जाता है, फिर eval(parse(text = '...')) साथ मूल्यांकन किया जाता है eval(parse(text = '...')) । Optparse किसी भी गंभीर लिपि के लिए स्पष्ट रूप से वांछनीय है, लेकिन कभी-कभी कम-कार्यक्षमता कोड भी अच्छा होता है।

नमूना उत्पादन:

$ Rscript check_mail.Rscript --help
--debug Print  variables rather than executing function XYZ...

-h  --help  Display flag definitions

यदि आपको झंडे के साथ विकल्प निर्दिष्ट करने की आवश्यकता है, (जैसे -h, --help, --number = 42, आदि) आप आर पैकेज ऑप्टपरसे (पायथन से प्रेरित) का उपयोग कर सकते हैं: http://cran.r-project.org/web/packages/optparse/vignettes/optparse.pdf

कम से कम यह मैं आपके प्रश्न को कैसे समझता हूं, क्योंकि मुझे बैश गेटोपेट, या पर्ल गेटोपेट, या पायथन Argparse और optparse के बराबर की तलाश में यह पोस्ट मिला।


यहां डिर्क का जवाब वह सब कुछ है जो आपको चाहिए। यहां एक न्यूनतम प्रतिलिपि उदाहरण है।

मैंने दो फाइलें बनाई: exmpl.bat और exmpl.R

  • exmpl.bat :

    set R_Script="C:\Program Files\R-3.0.2\bin\RScript.exe"
    %R_Script% exmpl.R 2010-01-28 example 100 > exmpl.batch 2>&1
    

    वैकल्पिक रूप से, Rterm.exe का उपयोग कर:

    set R_TERM="C:\Program Files\R-3.0.2\bin\i386\Rterm.exe"
    %R_TERM% --no-restore --no-save --args 2010-01-28 example 100 < exmpl.R > exmpl.batch 2>&1
    
  • exmpl.R :

    options(echo=TRUE) # if you want see commands in output file
    args <- commandArgs(trailingOnly = TRUE)
    print(args)
    # trailingOnly=TRUE means that only your arguments are returned, check:
    # print(commandArgs(trailingOnly=FALSE))
    
    start_date <- as.Date(args[1])
    name <- args[2]
    n <- as.integer(args[3])
    rm(args)
    
    # Some computations:
    x <- rnorm(n)
    png(paste(name,".png",sep=""))
    plot(start_date+(1L:n), x)
    dev.off()
    
    summary(x)
    

दोनों फ़ाइलों को एक ही निर्देशिका में सहेजें और exmpl.bat शुरू exmpl.bat । नतीजतन आप पाएंगे:

  • कुछ साजिश के साथ example.png
  • जो कुछ किया गया था exmpl.batch साथ exmpl.batch

आप एक पर्यावरण चर %R_Script% भी जोड़ सकते हैं:

"C:\Program Files\R-3.0.2\bin\RScript.exe"

और इसे अपने बैच स्क्रिप्ट में %R_Script% <filename.r> <arguments>

RScript और Rterm बीच मतभेद:

  • Rscript में सरल वाक्यविन्यास है
  • Rscript स्वचालित रूप से x64 पर आर्किटेक्चर चुनता है (विवरण के लिए आर स्थापना और प्रशासन, 2.6 उप-आर्किटेक्चर देखें)
  • यदि आप आउटपुट फ़ाइल में कमांड लिखना चाहते हैं तो Rscript options(echo=TRUE) आवश्यकता है options(echo=TRUE) । फ़ाइल




parameters