Dplyr joindre par=(a = b), où a et b sont des variables contenant des chaînes de caractères?

Je suis en train d'effectuer une jointure de deux tables à l'aide de dplyr, et je pense que je suis fauché par des non-standard des règles d'évaluation. Lors de l'utilisation de la par=("a" = "b") argument, tout fonctionne comme prévu lorsque "a" et "b" sont des chaînes de caractères. Voici un exemple jouet qui fonctionne:

library(dplyr)
data(iris)

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

Mais disons que je met inner_join dans une fonction:

library(dplyr)
data(iris)

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

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

Renvoie le message d'erreur suivant:

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

Je soupçonne qu'il ya un peu de fantaisie expression, deparsing, citant, ou unquoting que je pourrais faire pour faire ce travail, mais je suis un peu trouble sur ces détails.

Hadley appelle cette "non-standard d'évaluation" (NSE)
Semble pas tellement NSE que la prestation de la "en.x" et "par.y" les noms de colonne dans une manière différente. Le by-argument devient c("Sepal.Length" = "Sepal.Width") et donc ce serait la by.x argument merge devient un réel R nom. En fait, c'est presque à l'opposé du NSE comme je l'ai vue il.

InformationsquelleAutor Peter | 2015-02-08

dplyr r

30

Vous pouvez utiliser
```
myfn <- function(xname, yname) {
    data(iris)
    inner_join(iris, iris, by=setNames(yname, xname))
}
```
L'a suggéré la syntaxe dans le ?inner_join documentation de
```
by = c("a"="b")   # same as by = c(a="b")
```
est un peu trompeur parce que ces deux valeurs ne sont pas des valeurs de caractère. Vous êtes en train de créé un personnage nommé vecteur. Pour définir dynamiquement les valeurs de la gauche du signe égal est différent de ceux de droite. Vous pouvez utiliser setNames() pour définir les noms du vecteur dynamique.
- Notez qu'en utilisant setNames, l'ordre des arguments est inversé par rapport à l'original une utilisation dans inner_join. Pour avoir le même ordre de l'argumentation, c'est à dire d'abord xname puis yname, vous pouvez utiliser by=setNames(nm=xname, yname).
InformationsquelleAutor MrFlick
2

Je sais je suis en retard à la fête, mais que diriez-vous:
```
myfn <- function(byvar) {
  data(iris)
  inner_join(iris, iris, by=byvar)
}
```
De cette façon, vous pouvez faire ce que vous voulez avec:
```
myfn(c("Sepal.Length"="Sepal.Width"))
```
- Je n'ai pas que sensiblement différent de celui MrFlick réponse.
- Ils sont très similaires. La seule différence, c'est quand vous vous joignez à par de multiples dimensions. Je pense que c'est plus clair pour faire myfn(c("a" = "b", "c" = "d")) que myfn(c("a", "c"), c("b", "d")), mais c'est une question de goût j'imagine.
- Ouais. Je peux voir votre point de vue. Vous utilisez redondant citations bien. Vous pourriez appeler la vôtre avec myfn(c(a = "b", c = "d")), et à mes yeux ce serait encore plus clair car il utilise l'habitude de saisie des noms, pour ne pas mentionner moins de caractères qui ont besoin d'un changement de clé.
InformationsquelleAutor Felipe Gerard

J'ai fait face à presque le même défi que @Peter, mais il faut passer plusieurs ensembles différents de by = rejoindre paramètres en une seule fois. J'ai choisi d'utiliser le map() fonction de la tidyverse paquet, purrr.

C'est le sous-ensemble de la tidyverse que j'ai utilisé.

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

Tout d'abord, j'ai adapté myfn à utiliser map() pour le cas publié par Pierre. 42 commentaire et Felipe Gerard réponse il est clair que la by argument peut prendre un nom de vecteur. map() nécessite une liste sur laquelle l'itération.

    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")

J'ai constaté que je n'avais pas besoin de quo_name() /!! dans la construction de la fonction.

Puis, je me suis adapté à la fonction de prendre une liste de by paramètres. Pour chaque by_i dans by_grps, nous pourrions étendre x et y pour ajouter des valeurs nommées sur pour rejoindre.

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

0

J'aime MrFlick la réponse de fber additif, mais je préfère structure. Pour moi setNames se sent comme quelque chose à la fin d'une pipe, pas comme à la volée constructeur. Sur une autre note, à la fois setNames et structure permettre l'utilisation de variables dans l'appel de fonction.
```
myfn <- function(xnames, ynames) {
  data(iris)
  inner_join(iris, iris, by = structure(names = xnames, .Data = ynames))
}

x <- "Sepal.Length"

myfn(x, "Sepal.Width")
```
Un nommé vecteur argument serait confronté à des problèmes ici:
```
myfn <- function(byvars) {
  data(iris)
  inner_join(iris, iris, by = byvars)
}

x <- "Sepal.Length"

myfn(c(x = "Sepal.Width"))
```
Vous pourriez résoudre, même si, en utilisant setNames ou structure dans l'appel de fonction.

InformationsquelleAutor deSKase

Vous devez vous connecter pour publier un commentaire.