Weisen Sie LHS mehrere neue Variablen in einer einzigen Zeile zu

Ich möchte in R mehrere Variablen in einer einzigen Zeile zuweisen. Ist es möglich, so etwas zu tun?

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'

Normalerweise möchte ich ungefähr 5-6 Variablen in einer einzelnen Zeile zuweisen, anstatt mehrere Zeilen zu haben. Gibt es eine Alternative?

Auf dem Blog "Durch Probleme kämpfen" gibt es eine großartige Antwort

Dies wird von dort mit sehr geringfügigen Änderungen übernommen.

VERWENDUNG DER FOLGENDEN DREI FUNKTIONEN (Plus eine zum Zulassen von Listen unterschiedlicher Größe)

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

Dann ausführen:

Gruppieren Sie die linke Seite mit der neuen Funktion. g() Die rechte Seite sollte ein Vektor oder eine Liste sein. Verwenden Sie den neu erstellten Binäroperator%=%

# 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

Beispiel mit Listen unterschiedlicher Größe:

Längere linke Seite

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"

Längere rechte Seite

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"

Ich habe einen Zeallot für ein R-Paket zusammengestellt , um genau dieses Problem anzugehen. zeallot enthält einen Operator ( %<-%) zum Entpacken, Mehrfach- und Destrukturieren. Die LHS des Zuweisungsausdrucks wird mithilfe von Aufrufen an erstellt c(). Die RHS des Zuweisungsausdrucks kann ein beliebiger Ausdruck sein, der einen Vektor, eine Liste, eine verschachtelte Liste, einen Datenrahmen, eine Zeichenfolge, ein Datumsobjekt oder benutzerdefinierte Objekte zurückgibt oder ist (vorausgesetzt, es gibt eine destructureImplementierung).

Hier ist die erste Frage, die mit zeallot (neueste Version, 0.0.5) überarbeitet wurde.

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

Weitere Beispiele und Informationen finden Sie in der Paketvignette .

Erwägen Sie die Verwendung der in Basis R enthaltenen Funktionen.

Erstellen Sie beispielsweise einen 1-zeiligen Datenrahmen (z. B. V) und initialisieren Sie Ihre Variablen darin. Jetzt können Sie mehreren Variablen gleichzeitig zuweisen V[,c("a", "b")] <- values[c(2, 4)], jede mit name ( V$a) aufrufen oder viele gleichzeitig verwenden ( values[c(5, 6)] <- V[,c("a", "b")]).

Wenn Sie faul werden und keine Variablen aus dem Datenrahmen aufrufen möchten, können Sie dies attach(V)(obwohl ich es persönlich nie tue).

# 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

Hier ist meine Idee. Wahrscheinlich ist die Syntax recht einfach:

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

gibt so:

> 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

Dies ist jedoch nicht gut getestet.

Eine potenziell gefährliche assignOption (sofern die Verwendung riskant ist) wäre Vectorize assign:

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

Oder ich nehme an, Sie könnten es selbst manuell mit Ihrer eigenen Funktion vektorisieren, indem Sie mapplymöglicherweise einen sinnvollen Standard für das envirArgument verwenden. Gibt beispielsweise Vectorizeeine Funktion mit denselben Umgebungseigenschaften zurück assign, wie in diesem Fall namespace:base, oder Sie können sie einfach festlegen envir = parent.env(environment(assignVec)).

Wie andere erklärt haben, scheint nichts eingebaut zu sein. ... aber Sie können eine vassignFunktion wie folgt entwerfen :

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

Eine zu berücksichtigende Sache ist jedoch, wie mit den Fällen umgegangen werden soll, in denen Sie z. B. 3 Variablen und 5 Werte angeben oder umgekehrt. Hier wiederhole (oder schneide) ich einfach die Werte, um die gleiche Länge wie die Variablen zu haben. Vielleicht wäre eine Warnung umsichtig. Aber es erlaubt Folgendes:

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

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

Erfüllte meinen Zweck, dh fünf Zwei in die ersten fünf Buchstaben zuzuweisen.

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
        )

Hatte kürzlich ein ähnliches Problem und hier war mein Versuch mit purrr::walk2

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

Wenn Sie nur eine einzige Codezeile benötigen, wie wäre es dann mit:

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

Ich befürchte, dass es c(a, b) = c(2, 4)leider keine elegante Lösung gibt, nach der Sie (wie ) suchen . Aber gib nicht auf, ich bin mir nicht sicher! Die nächste Lösung, die ich mir vorstellen kann, ist diese:

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

oder wenn Sie mit Warnungen belästigt sind, schalten Sie sie aus:

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

Aber ich nehme an, Sie sind mit dieser Lösung nicht zufrieden, ich wäre es auch nicht ...

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

Eine andere Version mit Rekursion:

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

Beispiel:

> 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

Meine Version:

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

Beispiel:

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

Wenn Sie einige der hier gegebenen Antworten + ein wenig Salz kombinieren, wie wäre es mit dieser Lösung:

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

Ich habe dies verwendet, um den R-Abschnitt hier hinzuzufügen: http://rosettacode.org/wiki/Sort_three_variables#R

Vorsichtsmaßnahme: Es funktioniert nur zum Zuweisen globaler Variablen (wie <<-). Wenn es eine bessere, allgemeinere Lösung gibt, pls. Sag es mir in den Kommentaren.