Policz liczbę wystąpień dla każdej unikalnej wartości

Jeśli masz wiele czynników (=wielowymiarowa ramka danych), możesz użyć pakietu dplyr, aby zliczyć unikalne wartości w każdej kombinacji czynników:

library("dplyr")
data %>% group_by(factor1, factor2) %>% summarize(count=n())

Używa operatora rury %>% do łańcuchowania wywołań metod na ramce danych data.

Jest to podejście Jednowierszowe za pomocą aggregate.

> aggregate(data.frame(count = v), list(value = v), length)

  value count
1     1    25
2     2    75

Funkcja Table() jest dobrym rozwiązaniem, jak zasugerował Chase. Jeśli analizujesz duży zbiór danych, alternatywnym sposobem jest użycie .Funkcja n w pakiecie datatable.

Upewnij się, że zainstalowałeś pakiet tabel danych przez

install.packages("data.table")

Kod:

# Import the data.table package
library(data.table)

# Generate a data table object, which draws a number 10^7 times  
# from 1 to 10 with replacement
DT<-data.table(x=sample(1:10,1E7,TRUE))

# Count Frequency of each factor level
DT[,.N,by=x]

Aby uzyskać nie wymiarowany wektor całkowity zawierający liczbę unikalnych wartości, użyj c().

dummyData = rep(c(1, 2, 2, 2), 25) # Chase's reproducible data
c(table(dummyData)) # get un-dimensioned integer vector
 1  2 
25 75

str(c(table(dummyData)) ) # confirm structure
 Named int [1:2] 25 75
 - attr(*, "names")= chr [1:2] "1" "2"

Może się to przydać, jeśli trzeba wprowadzić liczby unikalnych wartości do innej funkcji, i jest krótszy i bardziej idiomatyczny niż t(as.data.frame(table(dummyData))[,2] opublikowany w komentarzu do odpowiedzi Chase ' a. Dzięki Ricardo Saporcie, który zwrócił mi to uwagę tutaj .

To mi pasuje. Weź swój wektor v

length(summary(as.factor(v),maxsum=50000))

Komentarz: Ustaw maxsum, aby było wystarczająco duże, aby uchwycić liczbę unikalnych wartości

Lub z magrittr pakietem

v %>% as.factor %>% summary(maxsum=50000) %>% length

Jeśli chcesz mieć liczbę unikalnych wartości jako dodatkową kolumnę w ramce danych zawierającej twoje wartości (kolumna, która może reprezentować na przykład rozmiar próbki), plyr zapewnia schludny sposób:

data_frame <- data.frame(v = rep(c(1,2, 2, 2), 25))

library("plyr")
data_frame <- ddply(data_frame, .(v), transform, n = length(v))

Również nadanie wartości kategorycznych i wywołanie summary() zadziałałoby.

> v = rep(as.factor(c(1,2, 2, 2)), 25)
> summary(v)
 1  2 
25 75 

Możesz spróbować również tidyverse

library(tidyverse) 
dummyData %>% 
    as.tibble() %>% 
    count(value)
# A tibble: 2 x 2
  value     n
  <dbl> <int>
1     1    25
2     2    75

length(unique(df$col)) to najprostszy sposób, jaki widzę.

Jeśli chcesz uruchomić unique na danych.rama (np. pociąg.dane), a także uzyskać zliczenia (które mogą być używane jako waga w klasyfikatorach), można wykonać następujące czynności:

unique.count = function(train.data, all.numeric=FALSE) {                                                                                                                                                                                                 
  # first convert each row in the data.frame to a string                                                                                                                                                                              
  train.data.str = apply(train.data, 1, function(x) paste(x, collapse=','))                                                                                                                                                           
  # use table to index and count the strings                                                                                                                                                                                          
  train.data.str.t = table(train.data.str)                                                                                                                                                                                            
  # get the unique data string from the row.names                                                                                                                                                                                     
  train.data.str.uniq = row.names(train.data.str.t)                                                                                                                                                                                   
  weight = as.numeric(train.data.str.t)                                                                                                                                                                                               
  # convert the unique data string to data.frame
  if (all.numeric) {
    train.data.uniq = as.data.frame(t(apply(cbind(train.data.str.uniq), 1, 
      function(x) as.numeric(unlist(strsplit(x, split=","))))))                                                                                                    
  } else {
    train.data.uniq = as.data.frame(t(apply(cbind(train.data.str.uniq), 1, 
      function(x) unlist(strsplit(x, split=",")))))                                                                                                    
  }
  names(train.data.uniq) = names(train.data)                                                                                                                                                                                          
  list(data=train.data.uniq, weight=weight)                                                                                                                                                                                           
}  

Wiem, że jest wiele innych odpowiedzi, ale tutaj jest inny sposób, aby to zrobić za pomocą funkcji sort i rle. Funkcja rle oznacza Run Length Encoding . Może być używany do zliczania przebiegów liczb (Zobacz dokumenty r man na rle), ale może być również stosowany tutaj.

test.data = rep(c(1, 2, 2, 2), 25)
rle(sort(test.data))
## Run Length Encoding
##   lengths: int [1:2] 25 75
##   values : num [1:2] 1 2

Jeśli przechwycisz wynik, możesz uzyskać dostęp do długości i wartości w następujący sposób:

## rle returns a list with two items.
result.counts <- rle(sort(test.data))
result.counts$lengths
## [1] 25 75
result.counts$values
## [1] 1 2

count_unique_words <-function(wlist) {
ucountlist = list()
unamelist = c()
for (i in wlist)
{
if (is.element(i, unamelist))
    ucountlist[[i]] <- ucountlist[[i]] +1
else
    {
    listlen <- length(ucountlist)
    ucountlist[[i]] <- 1
    unamelist <- c(unamelist, i)
    }
}
ucountlist
}

expt_counts <- count_unique_words(population)
for(i in names(expt_counts))
    cat(i, expt_counts[[i]], "\n")