Compter le nombre de lignes à l'intérieur de chaque groupe

J'ai un dataframe et je voudrais compter le nombre de lignes à l'intérieur de chaque groupe. J'ai regulièrement utiliser le aggregate fonction de la somme des données comme suit:

df2 <- aggregate(x ~ Year + Month, data = df1, sum)

Maintenant, je voudrais compter les observations, mais n'arrive pas à trouver le bon argument pour FUN. Intuitivement, je pensais que ce serait comme suit:

df2 <- aggregate(x ~ Year + Month, data = df1, count)

Mais, pas de chance.

Des idées?

D'un jouet de données:

set.seed(2)
df1 <- data.frame(x = 1:20,
                  Year = sample(2012:2014, 20, replace = TRUE),
                  Month = sample(month.abb[1:3], 20, replace = TRUE))

nrow, NROW, length...
Je lis ce qu'on leur demande pour une façon amusante de compter les choses (contrairement aux nombreux n'était pas marrante façons, je suppose).
nrow n'a pas fonctionné pour moi, mais NROW et lengtha bien fonctionné. +1

InformationsquelleAutor MikeTP | 2012-03-21

55

Les meilleures pratiques actuelles (tidyverse) est:
```
require(dplyr)
df1 %>% count(Year, Month)
```
- Est-il un moyen de regrouper une variable et ne comptant aussi (comme les 2 fonctions d'agrégation: moyenne + nombre)? J'ai besoin d'obtenir la moyenne d'une colonne et le nombre de lignes pour la même valeur dans la colonne autre
- J'avais cbind les résultats de aggregate(Sepal.Length ~ Species, iris, mean) et aggregate(Sepal.Length ~ Species, iris, length)
- Je l'ai fait, mais il semble que je reçois 2 fois chaque colonne à l'exception de la agrégées; donc, j'ai fait une fusion sur eux et il semble être ok
- Je ne sais pas, mais cela pourrait être utile... df %>% group_by(group, variable) %>% mutate(count = n())
- Oui dplyr est la meilleure pratique maintenant.
InformationsquelleAutor geotheory
58

Suivant @Joshua suggestion, voici une façon de compter le nombre d'observations dans votre df dataframe où Year = 2007 et Month = Nov (en supposant qu'ils sont des colonnes):
```
nrow(df[,df$YEAR == 2007 & df$Month == "Nov"])
```
et avec aggregate, à la suite de @GregSnow:
```
aggregate(x ~ Year + Month, data = df, FUN = length)
```
InformationsquelleAutor Ben

dplyr paquet fait avec count/tally commandes, ou la n() fonction:

D'abord, quelques données:

df <- data.frame(x = rep(1:6, rep(c(1, 2, 3), 2)), year = 1993:2004, month = c(1, 1:11))

Maintenant le comte:

library(dplyr)
count(df, year, month)
#piping
df %>% count(year, month)

On peut aussi utiliser un peu plus de la version avec la tuyauterie et de la n() fonction:

df %>% 
  group_by(year, month) %>%
  summarise(number = n())

ou la tally fonction:

df %>% 
  group_by(year, month) %>%
  tally()

InformationsquelleAutor jeremycg

34

Une vieille question sans data.table solution. Alors voilà...

À l'aide de .N
```
library(data.table)
DT <- data.table(df)
DT[, .N, by = list(year, month)]
```
- la norme de nos jours d'utiliser .() au lieu de list() et setDT() convertir des données.trame de données.table. Donc, en une seule étape setDT(df)[, .N, by = .(year, month)].
InformationsquelleAutor mnel
22

L'option simple à utiliser avec aggregate est le length fonction qui va vous donner la longueur du vecteur dans le sous-ensemble. Parfois un peu plus robuste consiste à utiliser function(x) sum( !is.na(x) ).

InformationsquelleAutor Greg Snow
16

Une alternative à la aggregate() fonction dans ce cas serait table() avec as.data.frame(), qui indique également les combinaisons de l'Année et le Mois sont associés à zéro occurrences
```
df<-data.frame(x=rep(1:6,rep(c(1,2,3),2)),year=1993:2004,month=c(1,1:11))

myAns<-as.data.frame(table(df[,c("year","month")]))
```
Et sans le zéro-produisent des combinaisons
```
myAns[which(myAns$Freq>0),]
```
InformationsquelleAutor BenBarnes
16

Créer une nouvelle variable Count avec une valeur de 1 pour chaque ligne:
```
df1["Count"] <-1
```
Ensuite regrouper dataframe, résumant par la Count colonne:
```
df2 <- aggregate(df1[c("Count")], by=list(Year=df1$Year, Month=df1$Month), FUN=sum, na.rm=TRUE)
```
- Juste à noter que si vous utilisez la valeur par défaut, non-méthode de la formule pour aggregate, il n'est pas nécessaire de renommer chaque variable dans by= comme list(year=df1$year) etc. Un data.frame est un list déjà si aggregate(df1[c("Count")], by=df1[c("Year", "Month")], FUN=sum, na.rm=TRUE) fonctionne.
InformationsquelleAutor Leroy Tyrone

Si vous souhaitez inclure 0 compte pour le mois en années, qui sont manquantes dans les données, vous pouvez utiliser un peu de table de la magie.

data.frame(with(df1, table(Year, Month)))

Par exemple, le jeu de données.cadre dans la question, df1, ne contient pas d'observations de janvier 2014.

df1
    x Year Month
1   1 2012   Feb
2   2 2014   Feb
3   3 2013   Mar
4   4 2012   Jan
5   5 2014   Feb
6   6 2014   Feb
7   7 2012   Jan
8   8 2014   Feb
9   9 2013   Mar
10 10 2013   Jan
11 11 2013   Jan
12 12 2012   Jan
13 13 2014   Mar
14 14 2012   Mar
15 15 2013   Feb
16 16 2014   Feb
17 17 2014   Mar
18 18 2012   Jan
19 19 2013   Mar
20 20 2012   Jan

La base de R aggregate fonction ne renvoie pas à une observation de janvier 2014.

aggregate(x ~ Year + Month, data = df1, FUN = length)
  Year Month x
1 2012   Feb 1
2 2013   Feb 1
3 2014   Feb 5
4 2012   Jan 5
5 2013   Jan 2
6 2012   Mar 1
7 2013   Mar 3
8 2014   Mar 2

Si vous souhaitez une observation de ce mois-année, avec 0 comme le comte, puis le code ci-dessus sera de retour de données.cadre avec des comptes pour tous les mois de l'année combinaisons:

data.frame(with(df1, table(Year, Month)))
  Year Month Freq
1 2012   Feb    1
2 2013   Feb    1
3 2014   Feb    5
4 2012   Jan    5
5 2013   Jan    2
6 2014   Jan    0
7 2012   Mar    1
8 2013   Mar    3
9 2014   Mar    2

Pourquoi avez-vous supprimer ce? C'est une bonne réponse.

InformationsquelleAutor lmo

Pour mon agrégations j'ai l'habitude de envie de voir la moyenne et "quelle est la taille de ce groupe" (un.k.un. la longueur).
Donc, c'est ma pratique extrait de code pour ces occasions;

agg.mean <- aggregate(columnToMean ~ columnToAggregateOn1*columnToAggregateOn2, yourDataFrame, FUN="mean")
agg.count <- aggregate(columnToMean ~ columnToAggregateOn1*columnToAggregateOn2, yourDataFrame, FUN="length")
aggcount <- agg.count$columnToMean
agg <- cbind(aggcount, agg.mean)

InformationsquelleAutor maze

Un sql la solution à l'aide de sqldf package:

library(sqldf)
sqldf("SELECT Year, Month, COUNT(*) as Freq
       FROM df1
       GROUP BY Year, Month")

InformationsquelleAutor M--

1

Considérant @Ben réponse, R renvoie une erreur si df1 ne contient pas de x colonne. Mais il peut être résolu avec élégance avec paste:
```
aggregate(paste(Year, Month) ~ Year + Month, data = df1, FUN = NROW)
```
De même, il peut être généralisée si plus de deux variables sont utilisées dans le groupement:
```
aggregate(paste(Year, Month, Day) ~ Year + Month + Day, data = df1, FUN = NROW)
```
InformationsquelleAutor paudan

Vous pouvez utiliser by fonctions comme by(df1$Year, df1$Month, count) qui va produire une liste d'agrégation.

La sortie ressemblera,

df1$Month: Feb
     x freq
1 2012    1
2 2013    1
3 2014    5
--------------------------------------------------------------- 
df1$Month: Jan
     x freq
1 2012    5
2 2013    2
--------------------------------------------------------------- 
df1$Month: Mar
     x freq
1 2012    1
2 2013    3
3 2014    2
>

InformationsquelleAutor helcode

0

Il ya beaucoup de merveilleuses réponses ici déjà, mais je voulais la jeter dans 1 option de plus pour ceux qui veulent ajouter une nouvelle colonne dans le jeu de données d'origine qui contient le nombre de fois que la ligne est répétée.
```
df1$counts <- sapply(X = paste(df1$Year, df1$Month), 
                     FUN = function(x) { sum(paste(df1$Year, df1$Month) == x) })
```
La même chose peut être accompli par la combinaison d'aucune des réponses ci-dessus, avec la merge() fonction.

InformationsquelleAutor filups21

Vous devez vous connecter pour publier un commentaire.