Filtre à bloc de données par le personnage de nom de colonne (en dplyr)

J'ai un bloc de données et souhaitez filtrer dans un de deux façons, soit par la colonne "ce" ou la colonne "que". Je voudrais être en mesure de se référer à la colonne nom de la variable. Comment (dans dplyr, si cela fait une différence) dois-je consulter un nom de colonne par une variable?

library(dplyr)
df <- data.frame(this = c(1, 2, 2), that = c(1, 1, 2))
df
#   this that
# 1    1    1
# 2    2    1
# 3    2    2
df %>% filter(this == 1)
#   this that
# 1    1    1

Mais dire que je veux utiliser la variable column de tenir "ceci" ou "cela", et d'un filtre à quelle que soit la valeur de column est. Les deux as.symbol et get travail dans d'autres contextes, mais pas cette:

column <- "this"
df %>% filter(as.symbol(column) == 1)
# [1] this that
# <0 rows> (or 0-length row.names)
df %>% filter(get(column) == 1)
# Error in get("this") : object 'this' not found

Comment puis-je tourner la valeur de column dans un nom de colonne?

Pourquoi voulez-vous faire cela? Essayer de paramétrer le choix de la variable?
J'ai un jeu de données avec deux types de choses, et des colonnes différentes pour chaque. Je souhaite aborder les choses de cette façon parce que je suis une utilisation Brillante de faire une visualisation interactive, et je veux laisser les gens choisir le type de chose à regarder, mais alors utiliser le même code pour extraire les données, en passant le nom de la colonne en fonction de leur choix.
Près de posté ma question et trouvé ceci 🙂

InformationsquelleAutor William Denton | 2014-11-29

dplyr r

27

De l'actuel dplyr fichier d'aide (accent mis par moi):

dplyr utilisé pour offrir des jumeaux versions de chaque verbe suffixé par un trait de soulignement. Ces versions eu d'évaluation standard (SE) de la sémantique: plutôt que de prendre les arguments avancés par le code, comme NSE verbes, ils ont pris des arguments par valeur. Leur but était de rendre possible le programme avec dplyr. Cependant, dplyr utilise maintenant bien rangé évaluation de la sémantique. NSE verbes encore la capture de leurs arguments, mais vous pouvez maintenant vulgaire parties de ces arguments. Cette offre complète de programmabilité avec NSE verbes. Ainsi, l'souligné versions sont maintenant inutiles.

Ce unquoting signifie exactement peut être appris dans la vignette Programmation avec dplyr. Il est réalisé par la fonction UQ() ou sucre syntaxique par !!. Maintenant il y a des situations comme la vôtre, où seuls les anciens correctement fonctionne parce que !! peuvent entrer en collision avec la seule !.

Appliqué à votre exemple:
```
library(dplyr)
df <- data.frame(this = c(1, 2, 2),
                 that = c(1, 1, 2))
column <- "this"

df %>% filter(UQ(as.name(column)) == 1)
#   this that
# 1    1    1
```
Mais pas:
```
df %>% filter(!!as.name(column) == 1)
# [1] this that
# <0 Zeilen> (oder row.names mit Länge 0)
```
Le sucre syntaxique !! fonctionne de nouveau comme le suppose si vous ajoutez quelques extra parenthèses (grâce à Martijn vd Voort pour la suggestion):
```
df %>% filter((!!as.name(column)) == 1)
#   this that
# 1    1    1
```
Ou si vous venez d'échange de la comparaison de deux opérandes (grâce à voitureet pour l'astuce):
```
df %>% filter(1 == !!as.name(column))
#   this that
# 1    1    1
```
- Pour le dernier cas, vous pouvez utiliser quelques extra parenthèses df %>% filter((!!as.name(column)) == 1)
InformationsquelleAutor Salim B
24

Je orienter clairement de l'utilisation de get() tous ensemble. Il me semble qu'il serait très dangereux dans cette situation, en particulier si vous êtes à la programmation. Vous pouvez utiliser soit un non évaluée appel ou un collé chaîne de caractères, mais vous aurez besoin d'utiliser filter_() au lieu de filter().
```
df <- data.frame(this = c(1, 2, 2), that = c(1, 1, 2))
column <- "this"
```
Option 1 - non évaluée à l'aide d'un appel:

Vous pouvez coder en dur y comme 1, mais ici, j'ai montrer que y pour illustrer comment vous pouvez modifier l'expression des valeurs facilement.
```
expr <- lazyeval::interp(quote(x == y), x = as.name(column), y = 1)
## or 
## expr <- substitute(x == y, list(x = as.name(column), y = 1))
df %>% filter_(expr)
#   this that
# 1    1    1
```
Option 2 - à l'aide de paste() (et évidemment plus facile):
```
df %>% filter_(paste(column, "==", 1))
#   this that
# 1    1    1
```
La principale chose à propos de ces deux options, c'est que nous avons besoin d'utiliser filter_() au lieu de filter(). En fait, de ce que j'ai lu, si vous êtes à la programmation avec dplyr vous devriez toujours utiliser la *_() fonctions.

J'ai utilisé ce post comme un document de référence utile: chaîne de caractères comme argument de fonction de r, et je suis en utilisant dplyr version 0.3.0.2.
- L'Option 1 est une solution robuste comme recommandé par @hadley en plusieurs posts sur SI et dans la vignette("nse"). Cependant, il semble que cela va à l'encontre de hadley style élégant appels de fonction. Ne peut-il pas être emballés et présentés d'une manière simple?
- pourquoi est-get() considérés comme dangereux?
- C'est une bonne réponse pour les anciennes versions de dpylr mais le trait de soulignement fonctions sont obsolètes donc @Salim B-réponse ci-dessous est mieux aller de l'avant.
InformationsquelleAutor Rich Scriven
7

Concernant Richard la solution, je veux juste ajouter que si vous la colonne, c'est le caractère. Vous pouvez ajouter shQuote à filtrer par les valeurs de caractère.

Par exemple, vous pouvez utiliser
```
df %>% filter_(paste(column, "==", shQuote("a")))
```
Si vous disposez de plusieurs filtres, vous pouvez spécifier collapse = "&" dans paste.
```
df %>$ filter_(paste(c("column1","column2"), "==", shQuote(c("a","b")), collapse = "&"))
```
InformationsquelleAutor StatCC
0

Comme Salim B expliqué ci-dessus, mais avec une modification mineure:
```
df %>% filter(1 == !!as.name(column))
```
c'est à dire juste inverser la condition, parce que !! se comporte de façon
comme
```
!!(as.name(column)==1)
```
InformationsquelleAutor carand

Voici une autre solution pour la dernière dplyr version:

df <- data.frame(this = c(1, 2, 2),
                 that = c(1, 1, 2))
column <- "this"

df %>% filter(.[[column]] == 1)

#  this that
#1    1    1

InformationsquelleAutor paul_dg

Vous devez vous connecter pour publier un commentaire.