Как присвоиться от функции, которая возвращает больше чем одно значение?

С R 3.6.1, я могу сделать следующий

fr2v <- function() { c(5,3) }
a_b <- fr2v()
(a_b[[1]]) # prints "5"
(a_b[[2]]) # prints "3"

Да на второй и третий вопросы - это то, что вам нужно сделать, поскольку у вас не может быть несколько «lvalues» слева от задания.

На этот вопрос нет правильного ответа. Я действительно зависит от того, что вы делаете с данными. В простом примере, приведенном выше, я настоятельно рекомендую:

1. Делайте вещи как можно проще.
2. По возможности, лучше всего держать ваши функции векторизованными. Это обеспечивает максимальную гибкость и скорость в долгосрочной перспективе.

Важно ли, чтобы значения 1 и 2, указанные выше, имели имена? Другими словами, почему в этом примере важно, чтобы 1 и 2 назывались a и b, а не просто r [1] и r [2]? В этом контексте важно понимать, что a и b также оба вектора длины 1. Таким образом, вы на самом деле ничего не меняете в процессе выполнения этого назначения, кроме двух новых векторов, которые не нужно ссылаться на индексы:

> names(r) <- c("a","b")
> names(r)
[1] "a" "b"
> r["a"]
a 
1 

[Edit] Учитывая, что вы будете применять min и max к каждому вектору отдельно, я бы предложил либо использовать матрицу (если a и b будут одинаковой длины и одного типа данных), либо фрейм данных (если a и b будут иметь одинаковую длину, но могут быть разными типами данных) или используйте список, как в вашем последнем примере (если они могут иметь разную длину и типы данных).

> r <- data.frame(a=1:4, b=5:8)
> r
  a b
1 1 5
2 2 6
3 3 7
4 4 8
> min(r$a)
[1] 1
> max(r$b)
[1] 8

Обычно я помещаю вывод в список, который очень гибкий (вы можете иметь любую комбинацию чисел, строк, векторов, матриц, массивов, списков, объектов в выводе)

примерно так:

func2<-function(input) {
   a<-input+1
   b<-input+2
   output<-list(a,b)
   return(output)
}

output<-func2(5)

for (i in output) {
   print(i)
}

[1] 6
[1] 7

I somehow stumbled on this clever hack on the internet ... I'm not sure if it's nasty or beautiful, but it lets you create a "magical" operator that allows you to unpack multiple return values into their own variable. The := function is defined here, and included below for posterity:

':=' <- function(lhs, rhs) {
  frame <- parent.frame()
  lhs <- as.list(substitute(lhs))
  if (length(lhs) > 1)
    lhs <- lhs[-1]
  if (length(lhs) == 1) {
    do.call(`=`, list(lhs[[1]], rhs), envir=frame)
    return(invisible(NULL)) 
  }
  if (is.function(rhs) || is(rhs, 'formula'))
    rhs <- list(rhs)
  if (length(lhs) > length(rhs))
    rhs <- c(rhs, rep(list(NULL), length(lhs) - length(rhs)))
  for (i in 1:length(lhs))
    do.call(`=`, list(lhs[[i]], rhs[[i]]), envir=frame)
  return(invisible(NULL)) 
}

With that in hand, you can do what you're after:

functionReturningTwoValues <- function() {
  return(list(1, matrix(0, 2, 2)))
}
c(a, b) := functionReturningTwoValues()
a
#[1] 1
b
#     [,1] [,2]
# [1,]    0    0
# [2,]    0    0

I don't know how I feel about that. Perhaps you might find it helpful in your interactive workspace. Using it to build (re-)usable libraries (for mass consumption) might not be the best idea, but I guess that's up to you.

... you know what they say about responsibility and power ...