Jak mogę odczytać parametry wiersza poleceń ze skryptu R.

Mam skrypt R, dla którego chciałbym móc podać kilka parametrów wiersza polecenia (zamiast wartości parametrów kodu twardego w samym kodzie). Skrypt działa w systemie Windows.

Nie mogę znaleźć informacji o tym, jak odczytać parametry podane w wierszu polecenia w moim skrypcie R. Byłbym zaskoczony, gdyby nie można tego zrobić, więc może po prostu nie używam najlepszych słów kluczowych w mojej wyszukiwarce Google ...

Wszelkie wskazówki lub rekomendacje?

Odpowiedź Dirka tutaj jest wszystkim, czego potrzebujesz. Oto minimalny, powtarzalny przykład.

Zrobiłem dwa pliki: exmpl.bati 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

  Alternatywnie, używając 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)

Zapisz oba pliki w tym samym katalogu i uruchom exmpl.bat. W rezultacie otrzymasz:

• example.png z jakąś fabułą
• exmpl.batch z tym wszystkim, co zostało zrobione

Możesz także dodać zmienną środowiskową %R_Script%:

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

i użyj go w skryptach wsadowych jako %R_Script% <filename.r> <arguments>

Różnice między RScripti Rterm:

• Rscript ma prostszą składnię
• Rscriptautomatycznie wybiera architekturę na x64 (szczegóły w R Instalacja i administracja, 2.6 Sub-architektury )
• Rscriptpotrzebuje options(echo=TRUE)w pliku .R, jeśli chcesz zapisać polecenia w pliku wyjściowym

Kilka punktów:

1. Parametry wiersza polecenia są dostępne przez commandArgs(), więc zobacz help(commandArgs)przegląd.

2. Możesz używać Rscript.exena wszystkich platformach, w tym Windows. Będzie wspierać commandArgs(). littler może być przeniesiony do systemu Windows, ale teraz działa tylko w systemie OS X i Linux.

3. Istnieją dwa dodatkowe pakiety w CRAN - getopt i optparse - które zostały napisane do analizowania z wiersza poleceń.

Edytuj w listopadzie 2015: Pojawiły się nowe alternatywy i szczerze polecam docopt .

Dodaj to na początku skryptu:

args<-commandArgs(TRUE)

Następnie można odnieść się do argumentów przekazanych jako args[1], args[2]etc.

Następnie uruchomić

Rscript myscript.R arg1 arg2 arg3

Jeśli argumentami są ciągi znaków ze spacjami, należy je ująć w podwójny cudzysłów.

Spróbuj biblioteki (getopt) ... jeśli chcesz, żeby było lepiej. Na przykład:

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

potrzebujesz littler (wymawiane „little r”)

Dirk przyjedzie za około 15 minut na opracowanie;)

Ponieważ optparsekilka razy wspomniano w odpowiedziach i stanowi on kompletny zestaw do przetwarzania w wierszu poleceń, oto krótki uproszczony przykład tego, jak można go używać, zakładając, że plik wejściowy istnieje:

skrypt.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))
}

Biorąc pod uwagę dowolny plik blah.txtz 23 liniami.

W wierszu poleceń:

Rscript script.R -h wyjścia

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 wyjścia [1] "69"

Rscript script.R -n -f 5 blah.txt wyjścia [1] "115"

W bash możesz zbudować wiersz poleceń taki jak poniżej:

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

Widać, że zmienna $zjest zastąpiona powłoką bash przez „10”, a ta wartość jest pobierana commandArgsi wprowadzana args[2], a komenda zasięgu x=1:10wykonywana przez R pomyślnie itp. Itd.

FYI: istnieje funkcja args (), która pobiera argumenty funkcji R, których nie należy mylić z wektorem argumentów o nazwie args

Jeśli musisz podać opcje z flagami (np. -H, --help, --number = 42 itd.), Możesz użyć pakietu optparse pakietu R (inspirowanego Pythonem): http://cran.r-project.org /web/packages/optparse/vignettes/optparse.pdf .

Przynajmniej tak rozumiem twoje pytanie, ponieważ znalazłem ten post, gdy szukam odpowiednika bash getopt, perl Getopt lub python argparse i optparse.

Właśnie połączyłem ładną strukturę danych i łańcuch przetwarzania, aby wygenerować to zachowanie przełączania, bez bibliotek. Jestem pewien, że będzie zaimplementowany wiele razy i natknąłem się na ten wątek, szukając przykładów - pomyślałem, że się w to włożę.

Nie potrzebowałem nawet szczególnie flag (jedyną flagą tutaj jest tryb debugowania, tworzenie zmiennej, którą sprawdzam jako warunek uruchomienia funkcji podrzędnej if (!exists(debug.mode)) {...} else {print(variables)}). Poniższe lapplyinstrukcje sprawdzające flagę dają to samo, co:

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

gdzie argszmienna jest wczytywana z argumentów wiersza poleceń (wektor znakowy, równoważny zc('--debug','--help') wtedy, gdy je podajesz)

Jest wielokrotnego użytku dla każdej innej flagi i unikasz wszystkich powtórzeń, bez bibliotek, więc żadnych zależności:

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

Zauważ, że flag.detailstutaj polecenia są przechowywane jako ciągi znaków, a następnie analizowane za pomocą eval(parse(text = '...')). Optparse jest oczywiście pożądane dla każdego poważnego skryptu, ale kod minimalnej funkcjonalności jest czasem zbyt dobry.

Przykładowe dane wyjściowe:

$ Rscript check_mail.Rscript --help
- debug Drukuj zmienne zamiast wykonywać funkcję XYZ ...

-h --help Wyświetl definicje flag