La numérotation des lignes à l'intérieur de groupes dans un bloc de données

De travail avec une trame de données similaire à ceci:

set.seed(100)  
df <- data.frame(cat = c(rep("aaa", 5), rep("bbb", 5), rep("ccc", 5)), val = runif(15))             
df <- df[order(df$cat, df$val), ]  
df  

   cat        val  
1  aaa 0.05638315  
2  aaa 0.25767250  
3  aaa 0.30776611  
4  aaa 0.46854928  
5  aaa 0.55232243  
6  bbb 0.17026205  
7  bbb 0.37032054  
8  bbb 0.48377074  
9  bbb 0.54655860  
10 bbb 0.81240262  
11 ccc 0.28035384  
12 ccc 0.39848790  
13 ccc 0.62499648  
14 ccc 0.76255108  
15 ccc 0.88216552

Je suis en train d'ajouter une colonne avec la numérotation à l'intérieur de chaque groupe. Cette façon de faire n'est évidemment pas en utilisant les pouvoirs de R:

 df$num <- 1  
 for (i in 2:(length(df[,1]))) {  
   if (df[i,"cat"]==df[(i-1),"cat"]) {  
     df[i,"num"]<-df[i-1,"num"]+1  
     }  
 }  
 df  

   cat        val num  
1  aaa 0.05638315   1  
2  aaa 0.25767250   2  
3  aaa 0.30776611   3  
4  aaa 0.46854928   4  
5  aaa 0.55232243   5  
6  bbb 0.17026205   1  
7  bbb 0.37032054   2  
8  bbb 0.48377074   3  
9  bbb 0.54655860   4  
10 bbb 0.81240262   5  
11 ccc 0.28035384   1  
12 ccc 0.39848790   2  
13 ccc 0.62499648   3  
14 ccc 0.76255108   4  
15 ccc 0.88216552   5

Ce serait une bonne façon de le faire?

InformationsquelleAutor eli-k | 2012-10-16

dataframe r r-faq

217

Utilisation ave, ddply, dplyr ou data.table:
```
df$num <- ave(df$val, df$cat, FUN = seq_along)
```
ou:
```
library(plyr)
ddply(df, .(cat), mutate, id = seq_along(val))
```
ou:
```
library(dplyr)
df %>% group_by(cat) %>% mutate(id = row_number())
```
ou (le plus efficace en terme de mémoire, qu'il attribue par référence dans DT):
```
library(data.table)
DT <- data.table(df)

DT[, id := seq_len(.N), by = cat]
DT[, id := rowid(cat)]
```
- Il pourrait être utile de mentionner que ave donne un flotteur à la place d'un int ici. Alternativement, pourrait changer df$val à seq_len(nrow(df)). Je viens de tomber sur ce cours ici: stackoverflow.com/questions/42796857/...
- Il est intéressant de cette data.table solution semble être plus rapide que d'utiliser frank: library(microbenchmark); microbenchmark(a = DT[, .(val ,num = frank(val)), by = list(cat)] ,b =DT[, .(val , id = seq_len(.N)), by = list(cat)] , times = 1000L)
- Merci! Le dplyr solution est bonne. Mais si, comme moi, vous avez continué à obtenir bizarre des erreurs lorsque vous essayez cette approche, assurez-vous que vous êtes de ne pas obtenir les conflits entre plyr et dplyr comme expliqué ce post Elle peut être évitée en appelant explicitement dplyr::mutate(...)
- un autre data.table méthode est setDT(df)[, id:=rleid(val), by=.(cat)]
- Comment modifier library(plyr) et library(dplyr) réponses pour faire le classement val de colonne dans l'ordre décroissant?
- J'ai essayé d'utiliser le plyr méthode et ai une erreur: "Erreur dans le unique.par défaut(x) : unique() ne s'applique qu'à des vecteurs" - quelqu'un a vu arriver?
- Vous pouvez il suffit de trier le jeu de données entier à l'avance. df <- df[order(df$val),]
- data.table était le moste de manière efficace, il ne le prit pas une seconde pour calculer environ 17000 lignes. À l'aide de ddply il était en cours d'exécution pour toujours, donc j'ai dû tuer le processus.
InformationsquelleAutor mnel

Pour la fabrication de ce r-faq question plus complète, une base de R alternative avec sequence et rle:

df$num <- sequence(rle(df$cat)$lengths)

qui donne le résultat escompté:

> df
   cat        val num
4  aaa 0.05638315   1
2  aaa 0.25767250   2
1  aaa 0.30776611   3
5  aaa 0.46854928   4
3  aaa 0.55232243   5
10 bbb 0.17026205   1
8  bbb 0.37032054   2
6  bbb 0.48377074   3
9  bbb 0.54655860   4
7  bbb 0.81240262   5
13 ccc 0.28035384   1
14 ccc 0.39848790   2
11 ccc 0.62499648   3
15 ccc 0.76255108   4
12 ccc 0.88216552   5

Si df$cat est un facteur variable, vous devez envelopper dans as.character première:

df$num <- sequence(rle(as.character(df$cat))$lengths)

Juste remarqué, ces solutions nécessite cat de la colonne à trier?
oui, sauf si vous voulez nombre par les événements consécutifs de cat

InformationsquelleAutor Jaap

8

Ici est une option à l'aide d'un for boucle par des groupes plutôt par des lignes (comme OP n')
```
for (i in unique(df$cat)) df$num[df$cat == i] <- seq_len(sum(df$cat == i))
```
InformationsquelleAutor alittleboy

Voici une petite amélioration truc qui permet de tri 'val' à l'intérieur de l'groupes:

# 1. Data set
set.seed(100)
df <- data.frame(
  cat = c(rep("aaa", 5), rep("ccc", 5), rep("bbb", 5)), 
  val = runif(15))             

# 2. 'dplyr' approach
df %>% 
  arrange(cat, val) %>% 
  group_by(cat) %>% 
  mutate(id = row_number())

Pouvez-vous ne pas trier après la group_by?

InformationsquelleAutor andrii

Je voudrais ajouter un data.table variante en utilisant le rank() fonction qui offre la possibilité de modifier l'ordre et donc la rend un peu plus souple que le seq_len() solution et est assez similaire à la fonction row_number fonctions dans les SGBDR.

# Variant with ascending ordering
library(data.table)
dt <- data.table(df)
dt[, .( val
   , num = rank(val))
    , by = list(cat)][order(cat, num),]

    cat        val num
 1: aaa 0.05638315   1
 2: aaa 0.25767250   2
 3: aaa 0.30776611   3
 4: aaa 0.46854928   4
 5: aaa 0.55232243   5
 6: bbb 0.17026205   1
 7: bbb 0.37032054   2
 8: bbb 0.48377074   3
 9: bbb 0.54655860   4
10: bbb 0.81240262   5
11: ccc 0.28035384   1
12: ccc 0.39848790   2
13: ccc 0.62499648   3
14: ccc 0.76255108   4

# Variant with descending ordering
dt[, .( val
   , num = rank(-val))
    , by = list(cat)][order(cat, num),]

InformationsquelleAutor hannes101

Un autre dplyr possibilité pourrait être:

df %>%
 group_by(cat) %>%
 mutate(num = 1:n())

   cat      val   num
   <fct>  <dbl> <int>
 1 aaa   0.0564     1
 2 aaa   0.258      2
 3 aaa   0.308      3
 4 aaa   0.469      4
 5 aaa   0.552      5
 6 bbb   0.170      1
 7 bbb   0.370      2
 8 bbb   0.484      3
 9 bbb   0.547      4
10 bbb   0.812      5
11 ccc   0.280      1
12 ccc   0.398      2
13 ccc   0.625      3
14 ccc   0.763      4
15 ccc   0.882      5

Dans certains cas, au lieu de 1:n() à l'aide de seq_len(n()) est plus sûr, dans le cas où dans votre séquence d'opérations que vous avez une situation où n() pourrait revenir 0, parce que 1:0 vous donne une longueur de deux vecteurs alors que seq_len(0) donne une longueur d'un vecteur nul, donc d'éviter une longueur d'erreur d'incompatibilité avec mutate().

InformationsquelleAutor tmfmnk

Vous devez vous connecter pour publier un commentaire.