在一行中为 LHS 分配多个新变量

Question

我想在 R 中的一行中分配多个变量。是否可以执行这样的操作？

values # initialize some vector of values
(a, b) = values[c(2,4)] # assign a and b to values at 2 and 4 indices of 'values'

通常我想在一行中分配大约 5-6 个变量，而不是多行。还有其他选择吗？

Answer 1

我整理了一个 R 包 zeallot 来解决这个问题。 zeallot 包含一个用于解包、多重和解构赋值的运算符 (%<-%)。赋值表达式的 LHS 是通过调用 c() 构建的。分配表达式的RHS可以是任何返回或返回或为向量，列表，嵌套列表，数据框架，字符串，日期对象或自定义对象的表达式（假设有destruct 实现）。

这是使用 zeallot（最新版本，0.0.5）重新设计的初始问题。

library(zeallot)

values <- c(1, 2, 3, 4)     # initialize a vector of values
c(a, b) %<-% values[c(2, 4)]  # assign `a` and `b`
a
#[1] 2
b
#[1] 4

有关更多示例和信息，可以查看包 vignette。

Answer 2

关于挣扎有一个很好的答案通过问题博客

这是从那里获取的，做了很小的修改。

使用以下三个功能
（加一以允许不同大小的列表）

# Generic form
'%=%' = function(l, r, ...) UseMethod('%=%')

# Binary Operator
'%=%.lbunch' = function(l, r, ...) {
  Envir = as.environment(-1)

  if (length(r) > length(l))
    warning("RHS has more args than LHS. Only first", length(l), "used.")

  if (length(l) > length(r))  {
    warning("LHS has more args than RHS. RHS will be repeated.")
    r <- extendToMatch(r, l)
  }

  for (II in 1:length(l)) {
    do.call('<-', list(l[[II]], r[[II]]), envir=Envir)
  }
}

# Used if LHS is larger than RHS
extendToMatch <- function(source, destin) {
  s <- length(source)
  d <- length(destin)

  # Assume that destin is a length when it is a single number and source is not
  if(d==1 && s>1 && !is.null(as.numeric(destin)))
    d <- destin

  dif <- d - s
  if (dif > 0) {
    source <- rep(source, ceiling(d/s))[1:d]
  }
  return (source)
}

# Grouping the left hand side
g = function(...) {
  List = as.list(substitute(list(...)))[-1L]
  class(List) = 'lbunch'
  return(List)
}

然后执行：

使用新函数g()对左侧进行分组
右侧应该是向量或列表
使用新创建的二元运算符%=%

# Example Call;  Note the use of g()  AND  `%=%`
#     Right-hand side can be a list or vector
g(a, b, c)  %=%  list("hello", 123, list("apples, oranges"))

g(d, e, f) %=%  101:103

# Results: 
> a
[1] "hello"
> b
[1] 123
> c
[[1]]
[1] "apples, oranges"

> d
[1] 101
> e
[1] 102
> f
[1] 103

---

使用不同大小的列表的示例：

较长的左侧

g(x, y, z) %=% list("first", "second")
#   Warning message:
#   In `%=%.lbunch`(g(x, y, z), list("first", "second")) :
#     LHS has more args than RHS. RHS will be repeated.
> x
[1] "first"
> y
[1] "second"
> z
[1] "first"

较长的右侧

g(j, k) %=% list("first", "second", "third")
#   Warning message:
#   In `%=%.lbunch`(g(j, k), list("first", "second", "third")) :
#     RHS has more args than LHS. Only first2used.
> j
[1] "first"
> k
[1] "second"

Answer 3

考虑使用基础 R 中包含的功能。

例如，创建一个 1 行数据框（例如 V）并初始化其中的变量。现在您可以一次分配给多个变量V[,c("a", "b")] <-values[c(2, 4)]，按名称调用每个变量 (< code>V$a)，或同时使用其中多个 (values[c(5, 6)] <- V[,c("a", "b")] ）。

如果你很懒并且不想从数据帧中调用变量，你可以attach(V)（尽管我个人从来不这样做）。

# Initialize values
values <- 1:100

# V for variables
V <- data.frame(a=NA, b=NA, c=NA, d=NA, e=NA)

# Assign elements from a vector
V[, c("a", "b", "e")] = values[c(2,4, 8)]

# Also other class
V[, "d"] <- "R"

# Use your variables
V$a
V$b
V$c  # OOps, NA
V$d
V$e

Answer 4

这是我的想法。语法可能非常简单：

`%tin%` <- function(x, y) {
    mapply(assign, as.character(substitute(x)[-1]), y,
      MoreArgs = list(envir = parent.frame()))
    invisible()
}

c(a, b) %tin% c(1, 2)

如下所示：

> a
Error: object 'a' not found
> b
Error: object 'b' not found
> c(a, b) %tin% c(1, 2)
> a
[1] 1
> b
[1] 2

但这还没有经过充分测试。

Answer 5

一个潜在的危险（与使用分配一样有风险）选项是<代码>矢量化<代码>分配：

assignVec <- Vectorize("assign",c("x","value"))
#.GlobalEnv is probably not what one wants in general; see below.
assignVec(c('a','b'),c(0,4),envir = .GlobalEnv)
a b 
0 4 
> b
[1] 4
> a
[1] 0

或者我想你可以自己手动对其进行矢量化使用您自己的函数使用maply，它可能为envir参数使用合理的默认值。例如，Vectorize 将返回一个与 assign 具有相同环境属性的函数，在本例中为 namespace:base，或者您可以只设置envir =parent.env(environment(assignVec))。

Answer 6

list2env(setNames(as.list(rep(2,5)), letters[1:5]), .GlobalEnv)

达到了我的目的，即将五个 2 分配给前五个字母。

Answer 7

正如其他人所解释的，似乎没有任何内置内容。...但是您可以设计一个 vassign 函数，如下所示：

vassign <- function(..., values, envir=parent.frame()) {
  vars <- as.character(substitute(...()))
  values <- rep(values, length.out=length(vars))
  for(i in seq_along(vars)) {
    assign(vars[[i]], values[[i]], envir)
  }
}

# Then test it
vals <- 11:14
vassign(aa,bb,cc,dd, values=vals)
cc # 13

需要考虑的一件事是如何处理您指定的情况3 个变量和 5 个值，反之亦然。在这里，我只是重复（或截断）这些值，使其与变量的长度相同。也许警告是谨慎的做法。但它允许以下操作：

vassign(aa,bb,cc,dd, values=0)
cc # 0

Answer 8

最近遇到了类似的问题，这是我使用 purrr::walk2 的尝试

purrr::walk2(letters,1:26,assign,envir =parent.frame()) 

Answer 9

https://stat.ethz.ch/R -manual/R-devel/library/base/html/list2env.html：

list2env(
        list(
            a=1,
            b=2:4,
            c=rpois(10,10),
            d=gl(3,4,LETTERS[9:11])
            ),
        envir=.GlobalEnv
        )

Answer 10

如果您唯一的要求是一行代码，那么：

> a<-values[2]; b<-values[4]

Answer 11

对于命名列表，使用

list2env(mylist, environment())

For example:

mylist <- list(foo = 1, bar = 2)
list2env(mylist, environment())

会将 foo = 1, bar = 2 添加到当前环境，并覆盖具有这些名称的任何对象。这相当于

mylist <- list(foo = 1, bar = 2)
foo <- mylist$foo
bar <- mylist$bar

This 也适用于函数：

f <- function(mylist) {
  list2env(mylist, environment())
  foo * bar
}
mylist <- list(foo = 1, bar = 2) 
f(mylist)

但是，最好对要包含在当前环境中的元素进行命名，以免覆盖另一个对象...所以最好这样写

list2env(mylist[c("foo", "bar")], environment())

最后，如果您想要不同的名称对于新导入的对象，写：

list2env(`names<-`(mylist[c"foo", "bar"]), c("foo2", "bar2")), environment())

相当于

foo2 <- mylist$foo
bar2 <- mylist$bar

Answer 12

不幸的是，恐怕您正在寻找的优雅解决方案（例如 c(a, b) = c(2, 4)）并不存在。 但不要放弃，我不确定！我能想到的最接近的解决方案是这个：

attach(data.frame(a = 2, b = 4))

或者如果您对警告感到烦恼，请将其关闭：

attach(data.frame(a = 2, b = 4), warn = F)

但我想您不是对这个解决方案感到满意，我也不会......

Answer 13

R> values = c(1,2,3,4)
R> a <- values[2]; b <- values[3]; c <- values[4]
R> a
[1] 2
R> b
[1] 3
R> c
[1] 4

Answer 14

结合这里给出的一些答案+一点点盐，这个解决方案怎么样：

assignVec <- Vectorize("assign", c("x", "value"))
`%<<-%` <- function(x, value) invisible(assignVec(x, value, envir = .GlobalEnv))

c("a", "b") %<<-% c(2, 4)
a
## [1] 2
b
## [1] 4

我用它在这里添加 R 部分： http://rosettacode.org/wiki/Sort_third_variables#R

警告：它仅适用于分配全局变量（例如<代码><<-）。如果有更好、更通用的解决方案，请。在评论中告诉我。

Answer 15

另一个带有递归的版本：

let <- function(..., env = parent.frame()) {
    f <- function(x, ..., i = 1) {
        if(is.null(substitute(...))){
            if(length(x) == 1)
                x <- rep(x, i - 1);
            stopifnot(length(x) == i - 1)
            return(x);
        }
        val <- f(..., i = i + 1);
        assign(deparse(substitute(x)), val[[i]], env = env);
        return(val)
    }
    f(...)
}

示例：

> let(a, b, 4:10)
[1]  4  5  6  7  8  9 10
> a
[1] 4
> b
[1] 5
> let(c, d, e, f, c(4, 3, 2, 1))
[1] 4 3 2 1
> c
[1] 4
> f
[1] 1

我的版本：

let <- function(x, value) {
    mapply(
        assign,
        as.character(substitute(x)[-1]),
        value,
        MoreArgs = list(envir = parent.frame()))
    invisible()
}

示例：

> let(c(x, y), 1:2 + 3)
> x
[1] 4
> y
[1]