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

Question

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

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

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

Comments

आपको निष्पादन योग्य का स्थान निर्धारित करने की आवश्यकता है

Answer 1

डिर्क का जवाब यहां आपकी जरूरत की हर चीज है। यहाँ एक न्यूनतम प्रजनन योग्य उदाहरण है।

मैंने दो फाइलें बनाईं: 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। परिणाम में आपको मिलेगा:

• example.png कुछ साजिश के साथ
• 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 उप-आर्किटेक्चर )
• Rscriptoptions(echo=TRUE)अगर आप आउटपुट फाइल में कमांड लिखना चाहते हैं तो .R फाइल में जरूरत है

Answer 2

कुछ बिंदु:

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

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

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

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

Comments

और वहाँ argparse है

— gkcn

Answer 3

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

args<-commandArgs(TRUE)

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

फिर भागो

Rscript myscript.R arg1 arg2 arg3

यदि आपके आर्ग्स उन स्थानों के साथ तार हैं, तो दोहरे उद्धरण चिह्नों के भीतर संलग्न करें।

Comments

यह केवल तभी काम करता है जब मैंने args का इस्तेमाल किया <-commandArgs (TRUE) (नोट अपरकेस A)।

— एंडी वेस्ट

क्या आप की जरूरत है - arg1 से पहले?

— दार्शनिकोवन

@philcolbourn नहीं

— Chris_Rands

Answer 4

पुस्तकालय (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();
}

Answer 5

आपको लिटलर की आवश्यकता है ('थोड़ा r')

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

Answer 6

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

blah.txt23 लाइनों के साथ एक मनमानी फ़ाइल को देखते हुए ।

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

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"

Answer 7

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

$ 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और खिलाया गया है args[2], और x=1:10आर कमांड को सफलतापूर्वक निष्पादित किया गया है, आदि आदि।

Answer 8

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

Comments

यह लगभग निश्चित रूप से ऐसा नहीं है। केवल कार्यों के कार्यों को मुखौटा कर सकते हैं। फ़ंक्शन के समान नाम के साथ एक वैरिएबल बनाना फ़ंक्शन को मास्क नहीं करता है। इस सवाल का जवाब दें और जवाब दें: stackoverflow.com/q/6135868/602276

— एंड्री

सच है, यह यह मुखौटा नहीं है। सामान्य तौर पर, मैं नामकरण कार्यों और चर नाम से बचने की कोशिश करता हूं जो पहले से ही आर में मौजूद हैं

— टिम

Answer 9

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

कम से कम यह कि मैं आपके प्रश्न को कैसे समझता हूं, क्योंकि मुझे यह पद तब मिला जब बैश गेटटॉप, या पर्ल गेटटॉप, या पाइथन अरगपर्स और ऑप्टपर्स के बराबर की तलाश में।

Answer 10

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

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

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

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 = '...'))। ऑप्टपर्स स्पष्ट रूप से किसी भी गंभीर स्क्रिप्ट के लिए वांछनीय है, लेकिन न्यूनतम-कार्यक्षमता कोड भी कभी-कभी अच्छा होता है।

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

$ Rscript check_mail.Rscript --help
-debug फ़ंक्शन XYZ निष्पादित करने के बजाय प्रिंट वैरिएबल ...

-h --help प्रदर्शन ध्वज परिभाषाएँ