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




command-line r (8)

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

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

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


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

मुझे विशेष रूप से झंडे की भी आवश्यकता नहीं थी (यहां एकमात्र ध्वज एक डीबग मोड है, जो एक चर बनाने वाला है जिसे मैं डाउनस्ट्रीम फ़ंक्शन शुरू करने की शर्त के रूप में 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

एफवाईआई: एक फ़ंक्शन तर्क () है, जो आर कार्यों के तर्कों को पुनर्प्राप्त करता है, तर्कों के वेक्टर के साथ भ्रमित नहीं होना चाहिए


बैश में, आप निम्न की तरह कमांड लाइन बना सकते हैं:

$ z=10
$ echo $z
10
$ Rscript -e "args<-commandArgs(TRUE);x=args[1]:args[2];x;mean(x);sd(x)" 1 $z
 [1]  1  2  3  4  5  6  7  8  9 10
[1] 5.5
[1] 3.027650
$

आप देख सकते हैं कि परिवर्तनीय $z को "10" के साथ बैश खोल द्वारा प्रतिस्थापित किया गया है और यह मान commandArgs द्वारा उठाया गया है और commandArgs args[2] में खिलाया गया है, और रेंज कमांड x=1:10 सफलतापूर्वक आर द्वारा निष्पादित किया गया है आदि।


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

मैंने दो फाइलें बनाई: 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) । फ़ाइल

चूंकि 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"


लाइब्रेरी (getopt) आज़माएं ... यदि आप चीजों को अच्छे बनाना चाहते हैं। उदाहरण के लिए:

spec <- matrix(c(
        'in'     , 'i', 1, "character", "file from fastq-stats -x (required)",
        'gc'     , 'g', 1, "character", "input gc content file (optional)",
        'out'    , 'o', 1, "character", "output filename (optional)",
        'help'   , 'h', 0, "logical",   "this help"
),ncol=5,byrow=T)

opt = getopt(spec);

if (!is.null(opt$help) || is.null(opt$in)) {
    cat(paste(getopt(spec, usage=T),"\n"));
    q();
}

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

args<-commandArgs(TRUE)

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

तो भागो

Rscript myscript.R arg1 arg2 arg3

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


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

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





parameters