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

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

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

我组装了一个R包热机来解决这个问题。Zeallot包含一个多重赋值或解包赋值操作符%<-%。运算符的LHS是要赋值的任意数量的变量，通过调用c()构建。操作符的RHS是一个向量、列表、数据帧、日期对象或任何具有已实现的解构方法的自定义对象(参见?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, ..)

有关更多信息和示例，请查看软件包插图。

这只是为了完整，而不是因为我个人喜欢它。你可以用管道%>%输出结果，用花括号{}求值，用双箭头<<-将变量写入父环境。

library(tidyverse)
functionReturningTwoValues() %>% {a <<- .[1]; b <<- .[2]}

更新: 您还可以使用zeallot包中的多重赋值操作符::%<-%

c(a, b) %<-% list(0, 1)

这个问题没有正确答案。这取决于你如何处理数据。在上面的简单例子中，我强烈建议:

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

上面的值1和2有名字很重要吗?换句话说，为什么在这个例子中，1和2被命名为a和b很重要，而不是r[1]和r[2]?在这种情况下需要理解的一件重要的事情是a和b也是长度为1的向量。所以在赋值的过程中你并没有改变任何东西，除了有两个不需要下标引用的新向量:

> 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

我将发布一个函数，以向量的方式返回多个对象:

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()的结果是一个向量，它描述了使用上述三种方法计算出的第一和第三个四分位数。