Hitung jumlah kemunculan untuk setiap nilai unik


145

Katakanlah saya punya:

v = rep(c(1,2, 2, 2), 25)

Sekarang, saya ingin menghitung berapa kali setiap nilai unik muncul. unique(v) mengembalikan nilai uniknya, tetapi bukan berapa jumlahnya.

> unique(v)
[1] 1 2

Saya ingin sesuatu yang memberi saya

length(v[v==1])
[1] 25
length(v[v==2])
[1] 75

tetapi sebagai satu baris yang lebih umum :) Sesuatu yang dekat (tetapi tidak cukup) seperti ini:

#<doesn't work right> length(v[v==unique(v)])

Jawaban:


183

Mungkin meja adalah apa yang Anda cari?

dummyData = rep(c(1,2, 2, 2), 25)

table(dummyData)
# dummyData
#  1  2 
# 25 75

## or another presentation of the same data
as.data.frame(table(dummyData))
#    dummyData Freq
#  1         1   25
#  2         2   75

7
Ah, ya, saya bisa menggunakan ini, dengan sedikit modifikasi: t (as.data.frame (table (v)) [, 2]) persis seperti yang saya butuhkan, terima kasih
gakera

1
Saya biasa melakukan ini dengan canggung hist. tabletampaknya sedikit lebih lambat dari hist. Kenapa ya. Adakah yang bisa mengkonfirmasi?
Museful

2
Chase, ada kesempatan untuk memesan berdasarkan frekuensi? Saya memiliki masalah yang persis sama, tetapi tabel saya memiliki sekitar 20.000 entri dan saya ingin tahu seberapa sering entri yang paling umum.
Torvon

5
@Torvon - tentu, gunakan saja order()hasil. yaitux <- as.data.frame(table(dummyData)); x[order(x$Freq, decreasing = TRUE), ]
Mengejar

Metode ini tidak baik, hanya cocok untuk data yang sangat sedikit dengan banyak pengulangan, tidak akan cocok untuk banyak data berkelanjutan dengan sedikit rekaman duplikat.
Jauh Utara

29

Jika Anda memiliki beberapa faktor (= bingkai data multi-dimensi), Anda dapat menggunakan dplyrpaket untuk menghitung nilai unik di setiap kombinasi faktor:

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

Ini menggunakan operator pipa %>%untuk memanggil metode rantai pada bingkai data data.


Atau, dan sedikit lebih pendek:data %>% count(factor1, factor2)
David

21

Ini adalah pendekatan satu baris dengan menggunakan aggregate.

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

  value count
1     1    25
2     2    75

11

table () fungsi adalah cara yang baik untuk pergi, seperti yang disarankan Chase . Jika Anda menganalisis kumpulan data yang besar, cara alternatifnya adalah dengan menggunakan fungsi .N dalam paket dataTable.

Pastikan Anda menginstal paket tabel data dengan

install.packages("data.table")

Kode:

# 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]

8

Untuk mendapatkan vektor bilangan bulat tak berdimensi yang berisi jumlah nilai unik, gunakan 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"

Ini mungkin berguna jika Anda perlu memasukkan jumlah nilai unik ke fungsi lain, dan lebih pendek dan lebih idiomatis daripada yang t(as.data.frame(table(dummyData))[,2]diposting dalam komentar untuk jawaban Chase. Terima kasih kepada Ricardo Saporta yang menunjukkan hal ini kepada saya di sini .


7

Ini berhasil untuk saya. Ambil vektor Andav

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

Komentar: setel makssum agar cukup besar untuk menangkap jumlah nilai unik

atau dengan magrittrpaketnya

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


4

Jika Anda perlu memiliki jumlah nilai unik sebagai kolom tambahan dalam bingkai data yang berisi nilai Anda (kolom yang mungkin mewakili ukuran sampel misalnya), plyr menyediakan cara yang rapi:

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

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

3
atau ddply(data_frame, .(v), count). Juga patut diperjelas bahwa Anda memerlukan library("plyr")panggilan untuk membuatnya ddplybekerja.
Brian Diggs

Tampaknya aneh untuk digunakan transformdaripada mutatesaat menggunakan plyr.
Gregor Thomas

3

Juga membuat nilai-nilai kategoris dan memanggil summary()akan berhasil.

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

3

Anda juga dapat mencoba a tidyverse

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

0

Jika Anda ingin menjalankan unique pada data.frame (mis., Train.data), dan juga mendapatkan jumlah (yang dapat digunakan sebagai bobot dalam pengklasifikasi), Anda dapat melakukan hal berikut:

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

0

Saya tahu ada banyak jawaban lain, tetapi berikut adalah cara lain untuk melakukannya dengan menggunakan sortdan rle. Fungsi ini rleadalah singkatan dari Run Length Encoding . Ini dapat digunakan untuk menghitung jumlah angka (lihat dokumen R man rle), tetapi juga dapat diterapkan di sini.

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

Jika Anda menangkap hasilnya, Anda dapat mengakses panjang dan nilai sebagai berikut:

## 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

0

length(unique(df$col)) adalah cara paling sederhana yang bisa saya lihat.


R mungkin telah banyak berkembang dalam 10 tahun terakhir, sejak saya menanyakan pertanyaan ini.
gakera

-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")
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.