r - 如何从返回多个值的函数分配？

Question

仍在尝试进入 R 逻辑......从返回多个值的函数中解包（在 LHS 上）结果的“最佳”方法是什么？

我显然不能这样做：

R> functionReturningTwoValues <- function() { return(c(1, 2)) }
R> functionReturningTwoValues()
[1] 1 2
R> a, b <- functionReturningTwoValues()
Error: unexpected ',' in "a,"
R> c(a, b) <- functionReturningTwoValues()
Error in c(a, b) <- functionReturningTwoValues() : object 'a' not found

我真的必须做以下事情吗？

R> r <- functionReturningTwoValues()
R> a <- r[1]; b <- r[2]

或者 R 程序员会写更像这样的东西：

R> functionReturningTwoValues <- function() {return(list(first=1, second=2))}
R> r <- functionReturningTwoValues()
R> r$first
[1] 1
R> r$second
[1] 2

--- 编辑回答 Shane 的问题 ---

我真的不需要为结果值部分命名。我将一个聚合函数应用于第一个组件，另一个应用于第二个组件（min并且max. 如果两个组件的函数相同，我不需要拆分它们）。

score 211 · Accepted Answer

(1) list[...]<-十多年前我在r-help上发布了这个。从那时起，它已被添加到 gsubfn 包中。它不需要特殊的运算符，但确实需要使用如下方式编写左侧list[...]：

library(gsubfn)  # need 0.7-0 or later
list[a, b] <- functionReturningTwoValues()

如果您只需要第一个或第二个组件，这些都可以工作：

list[a] <- functionReturningTwoValues()
list[a, ] <- functionReturningTwoValues()
list[, b] <- functionReturningTwoValues()

（当然，如果您只需要一个值，那么functionReturningTwoValues()[[1]]或者functionReturningTwoValues()[[2]]就足够了。）

有关更多示例，请参阅引用的 r-help 线程。

(2) with 如果意图只是随后组合多个值并命名返回值，那么一个简单的替代方法是使用with：

myfun <- function() list(a = 1, b = 2)

list[a, b] <- myfun()
a + b

# same
with(myfun(), a + b)

(3) attach另一种选择是 attach：

attach(myfun())
a + b

添加：with和attach

score 71 · Accepted Answer

我不知何故在互联网上偶然发现了这个聪明的黑客......我不确定它是讨厌还是漂亮，但它可以让您创建一个“神奇”运算符，允许您将多个返回值解压缩到它们自己的变量中。该:=函数在此处定义，并包含在下面以供后代使用：

':=' <- 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)) 
}

有了它，你就可以做你想做的事：

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

我不知道我对此感觉如何。也许您会发现它在您的交互式工作区中很有帮助。使用它来构建（可重用）可使用的库（用于大规模消费）可能不是最好的主意，但我想这取决于你。

...您知道他们对责任和权力的看法...

score 59 · Accepted Answer

通常我将输出包装成一个非常灵活的列表（您可以在输出中包含数字、字符串、向量、矩阵、数组、列表、对象的任意组合）

就像：

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

score 21 · Accepted Answer

我整理了一个 R 包zeallot来解决这个问题。zeallot 包含一个多重赋值或解包赋值运算符，%<-%. 运算符的 LHS 是要分配的任意数量的变量，使用对的调用构建c()。运算符的 RHS 是向量、列表、数据框、日期对象或任何具有已实现destructure方法的自定义对象（请参阅参考资料?zeallot::destructure）。

以下是基于原始帖子的一些示例，

library(zeallot)

functionReturningTwoValues <- function() { 
  return(c(1, 2)) 
}

c(a, b) %<-% functionReturningTwoValues()
a  # 1
b  # 2

functionReturningListOfValues <- function() {
  return(list(1, 2, 3))
}

c(d, e, f) %<-% functionReturningListOfValues()
d  # 1
e  # 2
f  # 3

functionReturningNestedList <- function() {
  return(list(1, list(2, 3)))
}

c(f, c(g, h)) %<-% functionReturningNestedList()
f  # 1
g  # 2
h  # 3

functionReturningTooManyValues <- function() {
  return(as.list(1:20))
}

c(i, j, ...rest) %<-% functionReturningTooManyValues()
i     # 1
j     # 2
rest  # list(3, 4, 5, ..)

查看包小插图以获取更多信息和示例。

score 16 · Accepted Answer

functionReturningTwoValues <- function() { 
  results <- list()
  results$first <- 1
  results$second <-2
  return(results) 
}
a <- functionReturningTwoValues()

我认为这行得通。

score 10 · Accepted Answer

这个问题没有正确答案。我真的取决于你对数据做了什么。在上面的简单示例中，我强烈建议：

让事情尽可能简单。
在可能的情况下，保持函数矢量化是最佳实践。从长远来看，这提供了最大的灵活性和速度。

上面的值 1 和 2 有名称重要吗？换句话说，为什么在这个例子中将 1 和 2 命名为 a 和 b 而不仅仅是 r[1] 和 r[2] 很重要？在这种情况下要理解的一件重要的事情是 a 和 b也是长度为 1 的向量。因此，在进行该分配的过程中，您并没有真正改变任何东西，除了有 2 个不需要下标的新向量被引用：

> r <- c(1,2)
> a <- r[1]
> b <- r[2]
> class(r)
[1] "numeric"
> class(a)
[1] "numeric"
> a
[1] 1
> a[1]
[1] 1

如果您宁愿引用字母而不是索引，也可以将名称分配给原始向量：

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

[编辑]鉴于您将分别对每个向量应用 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

score 6 · Accepted Answer

列表似乎非常适合此目的。例如，在您将拥有的功能中

x = desired_return_value_1 # (vector, matrix, etc)

y = desired_return_value_2 # (vector, matrix, etc)

returnlist = list(x,y...)

}  # end of function

主程序

x = returnlist[[1]]

y = returnlist[[2]]

score 6 · Accepted Answer

如果要将函数的输出返回到全局环境，可以使用list2env，如下例所示：

myfun <- function(x) { a <- 1:x
                       b <- 5:x
                       df <- data.frame(a=a, b=b)

                       newList <- list("my_obj1" = a, "my_obj2" = b, "myDF"=df)
                       list2env(newList ,.GlobalEnv)
                       }
    myfun(3)

此函数将在您的全局环境中创建三个对象：

> my_obj1
  [1] 1 2 3

> my_obj2
  [1] 5 4 3

> myDF
    a b
  1 1 5
  2 2 4
  3 3 3

score 4 · Accepted Answer

是的，你的第二个和第三个问题 - 这就是你需要做的，因为你不能在作业的左侧有多个“左值”。

score 3 · Accepted Answer

使用分配怎么样？

functionReturningTwoValues <- function(a, b) {
  assign(a, 1, pos=1)
  assign(b, 2, pos=1)
}

您可以通过引用传递要传递的变量的名称。

> functionReturningTwoValues('a', 'b')
> a
[1] 1
> b
[1] 2

如果您需要访问现有值，则相反的assign是get。

score 1 · Accepted Answer

[A] 如果 foo 和 bar 都是一个数字，那么 c(foo,bar); 没有问题。您还可以命名组件：c(Foo=foo,Bar=bar)。因此，您可以将结果“res”的组件访问为 res[1], res[2]; 或者，在命名的情况下，作为 res["Foo"], res["BAR"]。

[B] 如果 foo 和 bar 是相同类型和长度的向量，那么返回 cbind(foo,bar) 或 rbind(foo,bar); 也没有问题。同样可命名。在 'cbind' 的情况下，您可以访问 foo 和 bar 作为 res[,1]、res[,2] 或 res[,"Foo"]、res[,"Bar"]。您可能还更喜欢返回数据框而不是矩阵：

data.frame(Foo=foo,Bar=bar)

并以 res$Foo、res$Bar 的形式访问它们。如果 foo 和 bar 的长度相同但类型不同（例如 foo 是数字向量， bar 是字符串向量），这也会很好地工作。

[C] 如果 foo 和 bar 完全不同，不能像上面那样方便地组合，那么你肯定应该返回一个列表。

例如，您的函数可能适合线性模型并计算预测值，因此您可以

LM<-lm(....) ; foo<-summary(LM); bar<-LM$fit

然后你会return list(Foo=foo,Bar=bar)然后以 res$Foo 的形式访问摘要，以 res$Bar 的形式访问预测值

来源：http ://r.789695.n4.nabble.com/How-to-return-multiple-values-in-a-function-td858528.html

score 0 · Accepted Answer

我将发布一个通过向量返回多个对象的函数：

Median <- function(X){
  X_Sort <- sort(X)
  if (length(X)%%2==0){
    Median <- (X_Sort[(length(X)/2)]+X_Sort[(length(X)/2)+1])/2
  } else{
    Median <- X_Sort[(length(X)+1)/2]
  }
  return(Median)
}

那是我创建的用于计算中位数的函数。我知道在 R 中有一个内置函数被调用median()，但是我编写了它来构建其他函数，使用Median()我刚刚编写的函数来计算数字数据集的四分位数。该Median()函数的工作原理如下：

如果数值向量X具有偶数个元素（即），则通过对元素和length(X)%%2==0求平均值来计算中位数。sort(X)[length(X)/2]sort(X)[(length(X)/2+1)]
如果X没有偶数个元素，则中位数为sort(X)[(length(X)+1)/2]。

到QuartilesFunction()：

QuartilesFunction <- function(X){
X_Sort <- sort(X) # Data is sorted in ascending order

if (length(X)%%2==0){
  
  # Data number is even
  
  HalfDN <- X_Sort[1:(length(X)/2)] 
  HalfUP <- X_Sort[((length(X)/2)+1):length(X)]
  
  QL <- Median(HalfDN)
  QU <- Median(HalfUP)
  
  QL1 <- QL
  QL2 <- QL
  QU1 <- QU
  QU2 <- QU
  QL3 <- QL
  QU3 <- QU
  
  Quartiles <- c(QL1,QU1,QL2,QU2,QL3,QU3)
  names(Quartiles) = c("QL (1)", "QU (1)", "QL (2)", "QU (2)","QL (3)", "QU (3)")
  
} else{ # Data number is odd
  
  # Including the median
  
  Half1DN <- X_Sort[1:((length(X)+1)/2)] 
  Half1UP <- X_Sort[(((length(X)+1)/2)):length(X)]
  
  QL1 <- Median(Half1DN)
  QU1 <- Median(Half1UP)
  
  # Not including the median
  
  Half2DN <- X_Sort[1:(((length(X)+1)/2)-1)] 
  Half2UP <- X_Sort[(((length(X)+1)/2)+1):length(X)]
  
  QL2 <- Median(Half2DN)
  QU2 <- Median(Half2UP)
  
  # Methods (1) and (2) averaged
  
  QL3 <- (QL1+QL2)/2
  QU3 <- (QU1+QU2)/2
  
  Quartiles <- c(QL1,QU1,QL2,QU2,QL3,QU3)
  names(Quartiles) = c("QL (1)", "QU (1)", "QL (2)", "QU (2)","QL (3)", "QU (3)") 
}
return(Quartiles)
}

此函数使用三种方法返回数值向量的四分位数：

X当数值向量的元素个数为奇数时，放弃计算四分位数的中位数。
当数值向量的元素数X为奇数时，保留中位数以计算四分位数。
平均使用方法 1 和 2 获得的结果。

当数值向量中的元素个数X为偶数时，三种方法重合。

的结果QuartilesFunction()是一个向量，该向量描述了使用概述的三种方法计算的第一和第三四分位数。

score 0 · Accepted Answer

2021 年，这是我经常使用的东西。

tidyversepackage 有一个调用函数lst，它在创建列表时为列表元素分配名称。list2env()我用来分配变量或直接使用列表的帖子

library(tidyverse)
fun <- function(){
  a<-1
  b<-2
  lst(a,b)
}
list2env(fun(), envir=.GlobalEnv)#unpacks list key-values to variable-values into the current environment

score -1 · Accepted Answer

使用 R 3.6.1，我可以执行以下操作

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

score -2 · Accepted Answer

要从函数获取多个输出并将它们保持为所需的格式，您可以从函数内部将输出保存到硬盘（在工作目录中），然后从函数外部加载它们：

myfun <- function(x) {
                      df1 <- ...
                      df2 <- ...
                      save(df1, file = "myfile1")
                      save(df2, file = "myfile2")
}
load("myfile1")
load("myfile2")

r - 如何从返回多个值的函数分配？

15 回答 15

主程序

Related

Reference