Dplyr beitreten auf durch=(a = b), wo a und b sind Variablen mit strings?

Ich versuche, führen Sie eine inner join zwei Tabellen mit dplyr, und ich glaube, ich bin immer ausgelöst durch nicht-standard-Bewertung Regeln. Bei der Verwendung der durch=("a" = "b") - argument, funktioniert alles wie erwartet, wenn "a" und "b" sind die tatsächlichen Zeichenfolgen. Hier ist ein Spielzeug-Beispiel, das funktioniert:

library(dplyr)
data(iris)

inner_join(iris, iris, by=c("Sepal.Length" = "Sepal.Width"))

Aber sagen wir, ich war putting inner_join in einer Funktion:

library(dplyr)
data(iris)

myfn <- function(xname, yname) {
    data(iris)
    inner_join(iris, iris, by=c(xname = yname))
}

myfn("Sepal.Length", "Sepal.Width")

Dieser gibt die folgende Fehlermeldung zurück:

Error: cannot join on columns 'xname' x 'Sepal.Width': index out of bounds

Ich vermute, es wird einige Phantasie-Ausdruck, deparsing, zitieren, oder unquoting, dass ich tun konnte, um diese Arbeit zu machen, aber ich bin ein bisschen trübe auf diese details.

  • Hadley nennt dies "nicht-standard-Auswertung" (NSE)
  • Scheint nicht so viel NSE wie die Bereitstellung der "durch.x" und "durch.y" - Spalte mit den Namen in einer anderen Art und Weise. Die by-argument wird c("Sepal.Length" = "Sepal.Width") und was wäre also die by.x argument merge zu einem echten R-Namen. In der Tat, es ist fast das Gegenteil von NSE als ich es sehen.
InformationsquelleAutor Peter | 2015-02-08
  1. 30

    Können Sie 

    myfn <- function(xname, yname) {
    data(iris)
    inner_join(iris, iris, by=setNames(yname, xname))
}

    Den vorgeschlagenen syntax in der ?inner_join Dokumentation von 

    by = c("a"="b")   # same as by = c(a="b")

    ist etwas irreführend, da beide diese Werte sind nicht das richtige Zeichen Werte. Sie sind tatsächlich erstellt eine benannte Zeichen-Vektor. Dynamisch setzen Sie die Werte auf der linken Seite der Gleichheitszeichen ist Verschieden von denen auf der rechten Seite. Sie können setNames() um die Namen der vector dynamisch.

    • Beachten Sie, dass durch setNames die Reihenfolge der Argumente ist Umgekehrt mit Bezug auf die ursprüngliche Verwendung in inner_join. Die gleiche Reihenfolge der Argumente, D. H. zuerst xname dann yname könnten Sie by=setNames(nm=xname, yname).
    InformationsquelleAutor MrFlick
  2. 2

    Ich weiß, ich bin spät zur party, aber wie wäre es mit:

    myfn <- function(byvar) {
  data(iris)
  inner_join(iris, iris, by=byvar)
}

    Diese Weise können Sie machen, was du willst:

    myfn(c("Sepal.Length"="Sepal.Width"))
    • Ich glaube nicht, dass da wesentlich anders als die MrFlick Antwort.
    • Sie sind sich sehr ähnlich. Der einzige Unterschied ist, wenn Sie sich durch mehrere Dimensionen. Ich denke, es ist übersichtlicher zu tun myfn(c("a" = "b", "c" = "d")) als myfn(c("a", "c"), c("b", "d")), aber es ist eine Frage des Geschmacks, denke ich.
    • Ja. Ich sehe Ihren Punkt. Sie sind mit redundanten Anführungszeichen aber. Sie nennen könnte Ihre mit myfn(c(a = "b", c = "d")), und in meinen Augen wäre das sogar noch deutlicher, da es das übliche Eintragung der Namen, nicht zu erwähnen, weniger Zeichen, die eine shift-Taste.
    InformationsquelleAutor Felipe Gerard
  3. 0

    Stand ich vor einer fast identischen Herausforderung, da @Peter, aber musste passieren mehrere verschiedene Sätze von by = join-Parameter gleichzeitig. Ich entschied mich für die Verwendung der map() Funktion aus der tidyverse Paket purrr.

    Dies ist die Teilmenge der tidyverse, die ich verwendet.

    library(magrittr)
library(dplyr)
library(rlang)
library(purrr)

    Erste, die ich angepasst myfn zu verwenden map() für den Fall gepostet von Peter. 42 Kommentar und Felipe Gerard die Antwort klar gemacht, dass die by argument nehmen kann, eine benannte Vektor. map() benötigt eine Liste, über die iteriert werden.

        myfn_2 <- function(xname, yname) {
      by_names <- list(setNames(nm = xname, yname ))

      data(iris)

      # map() returns a single-element list. We index to retrieve dataframe.

      map( .x = by_names, 
           .f = ~inner_join(x = iris, 
                            y = iris, 
                            by = .x)) %>% 
        `[[`(1)
    }

myfn_2("Sepal.Length", "Sepal.Width")

    Fand ich, dass ich nicht brauchen quo_name() /!! im Gebäude die Funktion.

    Dann, ich angepasst, die Funktion zu nutzen, die eine Liste von by Parameter. Für jede by_i im by_grps wir erweitern konnte x und y zum hinzufügen benannter Werte, auf denen beitreten.

    by_grps <- list(  by_1 = list(x = c("Sepal.Length"), y = c("Sepal.Width")), 
                  by_2 = list(x = c("Sepal.Width"), y = c("Petal.Width"))
                )

myfn_3 <- function(by_grps_list, nm_dataset) {
  by_named_vectors_list <- lapply(by_grps_list, 
                                  function(by_grp) setNames(object = by_grp$y,
                                                            nm = by_grp$x))
  map(.x = by_named_vectors_list, 
      .f = ~inner_join(nm_dataset, nm_dataset, by = .x))
}

myfn_3(by_grps, iris)
    InformationsquelleAutor SoFarther
  4. 0

    Ich mag MrFlick Antwort und fber den Nachtrag, aber ich bevorzuge structure. Für mich setNames fühlt sich wie etwas am Ende eines Rohres, nicht als on-the-fly-Konstruktor. Auf einer anderen Anmerkung, beide setNames und structure ermöglichen die Verwendung von Variablen in den Funktionsaufruf.

    myfn <- function(xnames, ynames) {
  data(iris)
  inner_join(iris, iris, by = structure(names = xnames, .Data = ynames))
}

x <- "Sepal.Length"

myfn(x, "Sepal.Width")

    Eine benannte Vektor-argument würde Probleme hier:

    myfn <- function(byvars) {
  data(iris)
  inner_join(iris, iris, by = byvars)
}

x <- "Sepal.Length"

myfn(c(x = "Sepal.Width"))

    Könnte man lösen, dass, obwohl, indem Sie mit setNames oder structure im Funktionsaufruf.

    InformationsquelleAutor deSKase
Schreibe einen Kommentar