Komut satırı parametrelerini bir R komut dosyasından nasıl okuyabilirim?

Birkaç komut satırı parametreleri (kodun kendisinde sabit kod parametre değerleri yerine) sağlamak mümkün olan bir R komut dosyası var. Komut dosyası Windows'ta çalışır.

Komut satırında sağlanan parametreleri R komut dosyama okuma hakkında bilgi bulamıyorum. Yapılmazsa şaşırırdım, bu yüzden belki de Google aramamdaki en iyi anahtar kelimeleri kullanmıyorum ...

Herhangi bir işaretçi veya öneriniz var mı?

Dirk'ün cevabı burada ihtiyacınız olan her şey. İşte minimal tekrarlanabilir bir örnek.

İki dosya yaptım: exmpl.batve 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

  Alternatif olarak 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)

Her iki dosyayı da aynı dizine kaydedin ve başlatın exmpl.bat. Sonuçta:

• example.png biraz komplo ile
• exmpl.batch yapılan her şeyle

Ayrıca bir ortam değişkeni de ekleyebilirsiniz %R_Script%:

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

ve toplu komut dosyalarınızda şu şekilde kullanın: %R_Script% <filename.r> <arguments>

Arasındaki farklar RScriptve Rterm:

• Rscript daha basit sözdizimi var
• Rscriptx64 üzerinde otomatik olarak mimariyi seçer (ayrıntılar için bkz. R Kurulum ve Yönetim, 2.6 Alt mimariler )
• Rscriptihtiyacı options(echo=TRUE)çıktı dosyası komutları yazmak isterseniz .R dosyasında

Birkaç nokta:

1. Komut satırı parametrelerine şu yoldan erişilebilir commandArgs(), bu yüzden help(commandArgs)genel bakış için bkz .

2. Rscript.exeWindows dahil tüm platformlarda kullanabilirsiniz . Destekleyecek commandArgs(). littler Windows'a taşınabilir, ancak şu anda yalnızca OS X ve Linux'ta yaşıyor.

3. CRAN üzerinde getopt ve optparse olmak üzere ikisi de komut satırı ayrıştırma için yazılmış iki eklenti paketi vardır .

Kasım 2015'te düzenleyin : Yeni alternatifler ortaya çıktı ve ben gönülden doktora tavsiye ediyorum .

Bunu betiğinizin üstüne ekleyin:

args<-commandArgs(TRUE)

Ardından args[1], args[2]vb. Olarak iletilen bağımsız değişkenlere başvurabilirsiniz .

O zaman koş

Rscript myscript.R arg1 arg2 arg3

Argleriniz içinde boşluk olan dizelerse, çift tırnak içine alın.

Eğer daha güzel şeyler istiyorsanız ... kütüphane (getopt) deneyin. Örneğin:

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();
}

littler'a ihtiyacınız var ('küçük r' olarak telaffuz edilir)

Dirk yaklaşık 15 dakika içinde detaylandırılacak;)

Yana optparsecevaplarda birkaç kez söz ve komut satırı işleme için kapsamlı bir kit sağlar edilmiştir, burada giriş dosya var varsayarak, bunu nasıl kullanabileceğinizi kısa bir basitleştirilmiş bir örnek:

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 satırlı keyfi bir dosya verildi .

Komut satırında:

Rscript script.R -h çıktılar

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 çıktılar [1] "69"

Rscript script.R -n -f 5 blah.txt çıktılar [1] "115"

Bash'de aşağıdaki gibi bir komut satırı oluşturabilirsiniz:

$ 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
$

Değişkenin $zbash kabuğu ile "10" ile değiştirildiğini ve bu değerin toplandığını commandArgsve içine beslendiğini args[2]ve x=1:10R tarafından başarıyla çalıştırılan aralık komutu vb. Görebilirsiniz.

FYI: R işlevlerinin bağımsız değişkenlerini alan, args adlı bağımsız değişkenlerin bir vektörüyle karıştırılmayacak bir args () işlevi var

Bayraklı seçenekler belirtmeniz gerekiyorsa (-h, --help, --number = 42 vb.) R paket optparse (Python'dan esinlenerek) kullanabilirsiniz: http://cran.r-project.org /web/packages/optparse/vignettes/optparse.pdf .

Sorunuzu en azından bu şekilde anlıyorum, çünkü bash getopt veya perl Getopt veya python argparse ve optparse'ın eşdeğerini ararken bu yazıyı buldum.

Bu anahtarlama davranışını oluşturmak için güzel bir veri yapısı ve işleme zinciri oluşturdum, kütüphaneye gerek yok. Ben defalarca uygulanmış olacak eminim ve örnekler için bu konu geldi - ben çip düşündüm.

Yaptığım bile özellikle ihtiyaç bayrakları (Buradaki tek bayrak Bir alt fonksiyonu başlayan bir koşulu olarak kontrol bir değişkeni oluştururken, bir hata ayıklama modu if (!exists(debug.mode)) {...} else {print(variables)})kontrol bayrak. lapplyÜretmek aşağıda ifadeleri aynı:

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

argskomut satırı bağımsız değişkenlerinden okunan değişken nerede ( c('--debug','--help')örneğin bunları sağladığınız zamana eşdeğer bir karakter vektörü )

Diğer bayraklar için yeniden kullanılabilir ve tüm tekrarlardan kaçınırsınız ve kitaplık yoktur, bu nedenle bağımlılık yoktur:

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))

Not o flag.detailsburada komutlar dizeleri olarak depolanır, daha sonra değerlendirildi eval(parse(text = '...')). Optparse, herhangi bir ciddi komut dosyası için açıkça arzu edilir, ancak minimal işlevsellik kodu bazen de iyidir.

Örnek çıktı:

$ Rscript check_mail.Rscript --help
--debug XYZ işlevini yürütmek yerine değişkenleri yazdırın ...

-h --help Bayrak tanımlarını görüntüle