Kaip rūšiuoti duomenis keliais stulpeliais?

Noriu rūšiuoti duomenis. Pvz., Žemiau esančiame duomenų.framo numeryje norėčiau surūšiuoti pagal stulpelį z (mažėjančia tvarka), tada pagal stulpelį b (didėjančia tvarka):

 dd <- data.frame(b = factor(c("Hi", "Med", "Hi", "Low"), levels = c("Low", "Med", "Hi"), ordered = TRUE), x = c("A", "D", "A", "C"), y = c(8, 3, 9, 9), z = c(1, 1, 1, 2)) dd bxyz 1 Hi A 8 1 2 Med D 3 1 3 Hi A 9 1 4 Low C 9 2 
1183
19 авг. nustatė Christopher DuBois 19 rug. 2009-08-19 00:33 '09 ne 0:33 2009-08-19 00:33
@ 19 atsakymų

order() funkciją galite naudoti tiesiogiai, nenaudodami papildomų įrankių - peržiūrėkite šį paprastesnį atsakymą, kuris naudoja triuką dešinėje example(order) kodo example(order) viršuje:

 R> dd[with(dd, order(-z, b)), ] bxyz 4 Low C 9 2 2 Med D 3 1 1 Hi A 8 1 3 Hi A 9 1 

Po kelių metų redaguokite 2+: tiesiog paklauskite, kaip tai padaryti pagal stulpelio indeksą. Atsakymas yra tiesiog perduoti reikalingas rūšiavimo stulpelius į order() funkciją:

 R> dd[order(-dd[,4], dd[,1]), ] bxyz 4 Low C 9 2 2 Med D 3 1 1 Hi A 8 1 3 Hi A 9 1 R> 

vietoj stulpelio pavadinimo (ir with() paprastesnei / tiesioginei prieigai).

1477
19 авг. Dirk Eddelbuettel atsakymas rugpjūčio 19 d 2009-08-19 00:51 '09 ne 0:51 2009-08-19 00:51

Jūsų pasirinkimas

  • orderbase
  • arrangedplyr
  • setorder ir setordervdata.table
  • arrange plyr
  • sorttaRifx
  • orderBydoBy
  • sortData iš „ Deducer

Daugeliu atvejų turėtumėte naudoti „ dplyr arba „ data.table sprendimus, jei svarbios ne priklausomybės, ir šiuo atveju naudokite base::order .


Neseniai pridėjau „sort.data.frame“ į CRAN paketą, todėl jis yra suderinamas su klase, kaip aprašyta čia: Geriausias būdas sukurti universalius / nuoseklius metodus sort.data.frame?

Todėl, atsižvelgiant į data.frame dd, galite rūšiuoti:

 dd <- data.frame(b = factor(c("Hi", "Med", "Hi", "Low"), levels = c("Low", "Med", "Hi"), ordered = TRUE), x = c("A", "D", "A", "C"), y = c(8, 3, 9, 9), z = c(1, 1, 1, 2)) library(taRifx) sort(dd, f= ~ -z + b ) 

Jei esate vienas iš šios funkcijos autorių, susisiekite su manimi. Viešos prieigos diskusija yra čia: http://chat.stackoverflow.com/transcript/message/1094290#1094290


Taip pat galite naudoti „ plyr arrange() funkciją, kaip nurodė Hadley aukščiau pateiktame sraute:

 library(plyr) arrange(dd,desc(z),b) 

Lyginamieji standartai. Atkreipkite dėmesį, kad atsisiunčiau kiekvieną paketą į naują sesiją R, nes buvo daug konfliktų. „DoBy“ paketo įkėlimas sukelia „ sort “. „Šie objektai yra užmaskuoti iš„ x “(17 padėtis):: b, x, y, z“ ir pakrovimo „Deducer“ paketas perrašo sort.data.frame iš Kevin Wright arba taRifx paketo.

 #Load each time dd <- data.frame(b = factor(c("Hi", "Med", "Hi", "Low"), levels = c("Low", "Med", "Hi"), ordered = TRUE), x = c("A", "D", "A", "C"), y = c(8, 3, 9, 9), z = c(1, 1, 1, 2)) library(microbenchmark) # Reload R between benchmarks microbenchmark(dd[with(dd, order(-z, b)), ] , dd[order(-dd$z, dd$b),], times=1000 ) 

Vidutinis laikas:

dd[with(dd, order(-z, b)), ] 778

dd[order(-dd$z, dd$b),] 788

 library(taRifx) microbenchmark(sort(dd, f= ~-z+b ),times=1000) 

Vidutinis laikas: 1,567

 library(plyr) microbenchmark(arrange(dd,desc(z),b),times=1000) 

Vidutinis laikas: 862

 library(doBy) microbenchmark(orderBy(~-z+b, data=dd),times=1000) 

Vidutinis laikas: 1,694

Atminkite, kad „doBy“ užtrunka šiek tiek laiko atsisiųsti paketą.

 library(Deducer) microbenchmark(sortData(dd,c("z","b"),increasing= c(FALSE,TRUE)),times=1000) 

Nepavyko įkelti „Deducer“. Reikalingas JGR konsolės.

 esort <- function(x, sortvar, ...) { attach(x) x <- x[with(x,order(sortvar,...)),] return(x) detach(x) } microbenchmark(esort(dd, -z, b),times=1000) 

Atrodo, kad jis nesuderinamas su mikro ženklu dėl prikabinimo / atskyrimo.


 m <- microbenchmark( arrange(dd,desc(z),b), sort(dd, f= ~-z+b ), dd[with(dd, order(-z, b)), ] , dd[order(-dd$z, dd$b),], times=1000 ) uq <- function(x) { fivenum(x)[4]} lq <- function(x) { fivenum(x)[2]} y_min <- 0 # min(by(m$time,m$expr,lq)) y_max <- max(by(m$time,m$expr,uq)) * 1.05 p <- ggplot(m,aes(x=expr,y=time)) + coord_cartesian(ylim = c( y_min , y_max )) p + stat_summary(fun.y=median,fun.ymin = lq, fun.ymax = uq, aes(fill=expr)) 

2019

409
29 июля '11 в 13:48 2011-07-29 13:48 atsakymą pateikė Ari B. Friedman, liepos 29 d. 11, 13:48 2011-07-29 13:48

Atsakymas į Dirką yra puikus. Ji taip pat pabrėžia pagrindinį skirtumą tarp sintaksės, naudojamos indeksuojant data.frame ir data.table s:

 ## The data.frame way dd[with(dd, order(-z, b)), ] ## The data.table way: (7 fewer characters, but that not the important bit) dd[order(-z, b)] 

Skirtumas tarp dviejų skambučių yra mažas, tačiau gali turėti svarbių pasekmių. Ypač jei rašote gamybos kodą ir (arba) esate teisingi savo tyrimuose, geriau vengti nereikalingo kintamųjų pavadinimų kartojimo. data.table padės jums tai padaryti.

Čia pateikiamas pavyzdys, kaip kintantys kintamųjų pavadinimai gali sukelti problemų:

Pakeiskite kontekstą nuo Dirko atsakymo ir pasakykite, kad tai yra didesnio projekto, kuriame yra daug objektų pavadinimų, dalis ir jie yra ilgi ir reikšmingi; vietoj dd tai vadinama quarterlyreport . Tai bus:

 quarterlyreport[with(quarterlyreport,order(-z,b)),] 

Geras, puikus. Nėra nieko blogo. Tada jūsų viršininkas paprašys įtraukti ataskaitą į paskutinį ataskaitos ketvirtį. Jūs peržiūrite savo kodą pridedant paskutinio lastquarterlyreport objektą skirtingose ​​vietose ir kažkaip (kaip ant žemės?) Galų gale:

 quarterlyreport[with(lastquarterlyreport,order(-z,b)),] 

Tai ne tai, ką turėjote omenyje, bet jūs to nepastebėjote, nes jūs tai padarėte greitai ir jis buvo paskelbtas panašaus kodo puslapyje. Kodas nepatenka (be įspėjimo ir be klaidų), nes R mano, kad tai yra tai, ką turėjote omenyje. Jūs tikėjotės, kad kažkas, kas skaito jūsų pranešimą, jį pavadintų, bet galbūt ne. Jei dirbate daug su programavimo kalbomis, ši situacija gali būti pažįstama. Jūs sakote klaidą. Aš ištaisysiu „typo“, kurį pasakysite savo viršininkui.

data.table esame susirūpinę dėl tokių mažų detalių. Taigi, mes padarėme kažką paprasto, kad du kartus nebūtų įvedami kintamieji pavadinimai. Kažkas labai paprasta. i yra įvertintas dd jau automatiškai. Jums nereikia with() .

Vietoj

 dd[with(dd, order(-z, b)), ] 

tiesiog

 dd[order(-z, b)] 

Ir vietoj to

 quarterlyreport[with(lastquarterlyreport,order(-z,b)),] 

tiesiog

 quarterlyreport[order(-z,b)] 

Tai labai mažas skirtumas, bet vieną dieną ji gali tiesiog išgelbėti kaklą. Sverdami skirtingus atsakymus į šį klausimą, apsvarstykite kintamųjų pavadinimų pasikartojimą kaip vieną iš jūsų kriterijų priimant sprendimą. Kai kurie atsakymai turi daug pasikartojimų, kiti - ne.

131
25 мая '12 в 19:25 2012-05-25 19:25 atsakymą pateikė Matt Dowle gegužės 25 d., 12 val. 19:25 2012-05-25 19:25

Čia yra daug puikių atsakymų, tačiau dplyr pateikia vieną sintaksę, kurią galiu greitai ir lengvai prisiminti (ir todėl dabar labai dažnai jį naudoju):

 library(dplyr) # sort mtcars by mpg, ascending... use desc(mpg) for descending arrange(mtcars, mpg) # sort mtcars first by mpg, then by cyl, then by wt) arrange(mtcars , mpg, cyl, wt) 

Už OP užduotį:

 arrange(dd, desc(z), b) bxyz 1 Low C 9 2 2 Med D 3 1 3 Hi A 8 1 4 Hi A 9 1 
109
19 февр. Atsakymą pateikė Ben vasario 19 d 2014-02-19 00:29 '14 at 0:29 2014-02-19 00:29

„R data.table užtikrina greitą ir efektyvų duomenų saugojimą. Tiesioginės sintaksės lentelės (kai kurios iš jų Matt yra gana geros, norėdamos pabrėžti jo atsakymą ). Nuo to laiko buvo padaryta daug patobulinimų, taip pat ir nauja „ setorder() funkcija. Nuo v1.9.5+ , setorder() taip pat veikia su data.frames.

Pirmiausia sukursime pakankamai didelį duomenų rinkinį ir palyginsime įvairius metodus, paminėtus kituose atsakymuose, ir tada mes išvardinsime data.table savybes.

Duomenys:

 require(plyr) require(doBy) require(data.table) require(dplyr) require(taRifx) set.seed(45L) dat = data.frame(b = as.factor(sample(c("Hi", "Med", "Low"), 1e8, TRUE)), x = sample(c("A", "D", "C"), 1e8, TRUE), y = sample(100, 1e8, TRUE), z = sample(5, 1e8, TRUE), stringsAsFactors = FALSE) 

Orientyrai:

Ataskaitos pateikiamos kaip šių funkcijų sistemos pradžios system.time(...) pradžia. Laikas rodomas žemiau (mažiausio greičio tvarka).

 orderBy( ~ -z + b, data = dat) ## doBy plyr::arrange(dat, desc(z), b) ## plyr arrange(dat, desc(z), b) ## dplyr sort(dat, f = ~ -z + b) ## taRifx dat[with(dat, order(-z, b)), ] ## base R # convert to data.table, by reference setDT(dat) dat[order(-z, b)] ## data.table, base R like syntax setorder(dat, -z, b) ## data.table, using setorder() ## setorder() now also works with data.frames # R-session memory usage (BEFORE) = ~2GB (size of 'dat') # ------------------------------------------------------------ # Package function Time (s) Peak memory Memory used # ------------------------------------------------------------ # doBy orderBy 409.7 6.7 GB 4.7 GB # taRifx sort 400.8 6.7 GB 4.7 GB # plyr arrange 318.8 5.6 GB 3.6 GB # base R order 299.0 5.6 GB 3.6 GB # dplyr arrange 62.7 4.2 GB 2.2 GB # ------------------------------------------------------------ # data.table order 6.2 4.2 GB 2.2 GB # data.table setorder 4.5 2.4 GB 0.4 GB # ------------------------------------------------------------ 
  • data.table DT[order(...)] sintaksė buvo ~ 10 kartų greitesnė nei greičiausia iš kitų metodų ( dplyr ), suvartojanti tą patį kiekį atminties kaip ir dplyr .

  • data.table setorder() buvo ~ 14x greičiau nei greičiausias iš kitų metodų ( dplyr ), tik 0,4 GB papildomos atminties . dat dabar yra tokia tvarka, kokia mums reikia (nes ji atnaujinama pagal nuorodą).

data.table funkcijos:

Greitis:

  • data.table yra užsakoma labai greitai, nes ji įgyvendina spindulio užsakymą .

  • DT[order(...)] sintaksė yra optimizuota viduje, kad būtų naudojamas ir greitas duomenų užsakymas. Galite toliau naudoti pažįstamas pagrindines R sintakses, bet paspartinti procesą (ir naudoti mažiau atminties).

Atmintis:

  • Daugeliu atvejų nereikia originalios duomenų.frame arba data.table bylos po pertvarkymo. Tai yra, mes paprastai priskiriame rezultatą atgal į tą patį objektą, pavyzdžiui:

     DF <- DF[order(...)] 

    Problema ta, kad tam reikia bent du kartus (2x) pirminio objekto atminties. Norėdami efektyviai dirbti su atmintimi, data.table taip pat suteikia funkciją „ setorder() .

    setorder() redaguoja duomenų lenteles by reference (vietoje) be jokių papildomų kopijų. Jis naudoja tik papildomą atmintį, lygią vieno stulpelio dydžiui.

Kitos funkcijos:

  • Jis palaiko integer , logical , numeric , character ir net bit64::integer64 .

    Atkreipkite dėmesį, kad factor , Date , POSIXct ir kt. klasės - visi integer / numeric tipai pagal neprivalomus požymius ir todėl palaikomi.

  • R bazėje mes negalime naudoti - už simbolių vektorių rūšiavimui pagal šią stulpą mažėjančia tvarka. Vietoj to turėtume naudoti -xtfrm(.) .

    Tačiau data.table mes galime tiesiog padaryti, pavyzdžiui, dat[order(-x)] arba setorder(dat, -x) .

71
29 марта '15 в 18:52 2015-03-29 18:52 atsakymas pateikiamas Arun kovo 29 d., 15 val. 18:52 2015-03-29 18:52

Su šia (labai naudinga) „Kevin Wright“ funkcija , esanti „R wiki“ patarimų skyriuje, lengvai pasiekiama.

 sort(dd,by = ~ -z + b) # bxyz # 4 Low C 9 2 # 2 Med D 3 1 # 1 Hi A 8 1 # 3 Hi A 9 1 
61
19 авг. Atsakymas, kurį pateikė Christopher DuBois 19 rug. 2009-08-19 00:37 '09 ne 0:37 2009-08-19 00:37

arba galite naudoti doBy paketą

 library(doBy) dd <- orderBy(~-z+b, data=dd) 
33
19 янв. atsakymą pateikė George Dontas 19 sausis 2010-01-19 23:44 '10, 23:44 PM 2010-01-19 23:44

Tarkime, kad turite data.frame A ir norite surūšiuoti ją naudodami stulpelį, pavadintą x , mažėjančia tvarka. Skambučių rūšiavimas data.frame newdata

 newdata <- A[order(-A$x),] 

Jei norite pakilti, pakeiskite "-" nieko. Jums gali būti kažkas panašaus

 newdata <- A[order(-A$x, A$y, -A$z),] 

kur x ir z yra kai kurios duomenų stulpeliai. Tai reiškia, kad reikia data.frame A data.frame mažėjančia tvarka x , y didėjančia tvarka ir z mažėjančia tvarka.

32
25 янв. atsakymas pateikiamas Khayelihle sausio 25 d 2011-01-25 16:10 '11, 16:10, 2011-01-25 16:10

jei SQL ateina pas jus natūraliu būdu, sqldf tvarko ORDER BY kaip Codd.

25
09 марта '10 в 2:30 2010-03-09 02:30 atsakymas pateikiamas malecki, kovo 10 d., 10.30 val. 2010-03-09 02:30

Arba galite naudoti „Deducer“ paketą

 library(Deducer) dd<- sortData(dd,c("z","b"),increasing= c(FALSE,TRUE)) 
25
20 авг. Atsakyti į Ian Fellows , rugpjūčio 20 d 2009-08-20 22:43 '09, 10:43 val. 2009-08-20 22:43

Su order sužinojau sekančiu pavyzdžiu, kuris mane ilgai supainiojo:

 set.seed(1234) ID = 1:10 Age = round(rnorm(10, 50, 1)) diag = c("Depression", "Bipolar") Diagnosis = sample(diag, 10, replace=TRUE) data = data.frame(ID, Age, Diagnosis) databyAge = data[order(Age),] databyAge 

Vienintelė priežastis, kodėl šis pavyzdys veikia, yra tai, kad order suskirstomas pagal vector Age , o ne duomenų stulpelio data frame data skiltyje „ Age “.

Norėdami tai pamatyti, sukurkite identišką duomenų rėmelį, naudodami read.table su šiek tiek skirtingais stulpelių pavadinimais ir nenaudodami jokių pirmiau išvardytų vektorių:

 my.data <- read.table(text = ' id age diagnosis 1 49 Depression 2 50 Depression 3 51 Depression 4 48 Depression 5 50 Depression 6 51 Bipolar 7 49 Bipolar 8 49 Bipolar 9 49 Bipolar 10 49 Depression ', header = TRUE) 

Pirmiau nurodyta eilės struktūra order nebeveikia, nes nėra vektoriaus, pavadinto „ Age :

 databyage = my.data[order(age),] 

Kitoje eilutėje veikia, nes order rūšiuojamas pagal Age stulpelį my.data .

 databyage = my.data[order(my.data$age),] 

Maniau, kad verta pasakyti, kaip ilgą laiką buvau siaubingas dėl šio pavyzdžio. Jei šis pranešimas nėra tinkamas srautui, galiu jį ištrinti.

EDIT: 2014 m. Gegužės 13 d

Toliau pateikiamas apibendrintas kiekvienos stulpelio duomenų rėmo rūšiavimo būdas, nenurodant stulpelių pavadinimų. Toliau pateikiamas kodas rodo, kaip rūšiuoti iš kairės į dešinę arba į dešinę į kairę. Tai veikia, jei kiekviena skiltis yra skaitmeninė. Aš ne bandžiau naudoti simbolių stulpelį.

Radau kodą „ do.call mėnesį ar du do.call kitoje svetainėje, bet tik po išsamios ir sudėtingos paieškos. Nesu tikras, kad dabar galiu perkelti šį įrašą. Šis srautas yra pirmasis paspaudimas, skirtas užsakyti duomenų data.frame R Taigi, aš maniau, kad mano išplėstinė šio šaltinio kodo do.call gali būti naudinga.

 set.seed(1234) v1 <- c(0,0,0,0, 0,0,0,0, 1,1,1,1, 1,1,1,1) v2 <- c(0,0,0,0, 1,1,1,1, 0,0,0,0, 1,1,1,1) v3 <- c(0,0,1,1, 0,0,1,1, 0,0,1,1, 0,0,1,1) v4 <- c(0,1,0,1, 0,1,0,1, 0,1,0,1, 0,1,0,1) df.1 <- data.frame(v1, v2, v3, v4) df.1 rdf.1 <- df.1[sample(nrow(df.1), nrow(df.1), replace = FALSE),] rdf.1 order.rdf.1 <- rdf.1[do.call(order, as.list(rdf.1)),] order.rdf.1 order.rdf.2 <- rdf.1[do.call(order, rev(as.list(rdf.1))),] order.rdf.2 rdf.3 <- data.frame(rdf.1$v2, rdf.1$v4, rdf.1$v3, rdf.1$v1) rdf.3 order.rdf.3 <- rdf.1[do.call(order, as.list(rdf.3)),] order.rdf.3 
14
02 сент. Atsakymas, kurį pateikė Mark Miller 02 Sep 2013-09-02 22:28 '13, 22:28 2013-09-02 22:28

Atsakymas į Dirką yra geras, bet jei jums reikia išsaugoti rūšiavimą, norite taikyti rūšiavimą atgal į šio duomenų rėmelio pavadinimą. Pavyzdinio kodo naudojimas:

 dd <- dd[with(dd, order(-z, b)), ] 
13
26 мая '11 в 18:08 2011-05-26 18:08 atsakymas Andriejui pateiktas gegužės 26 d. 11 d. 18:08 2011-05-26 18:08

Atsakant į komentarą, pridėtą prie OP, kaip tvarkyti programiškai:

Naudojant dplyr ir data.table

 library(dplyr) library(data.table) 

dplyr

Paprasčiausiai naudokite arrange_ , kuri yra standartinė kainos nustatymo versija.

 df1 <- tbl_df(iris) #using strings or formula arrange_(df1, c('Petal.Length', 'Petal.Width')) arrange_(df1, ~Petal.Length, ~Petal.Width) Source: local data frame [150 x 5] Sepal.Length Sepal.Width Petal.Length Petal.Width Species (dbl) (dbl) (dbl) (dbl) (fctr) 1 4.6 3.6 1.0 0.2 setosa 2 4.3 3.0 1.1 0.1 setosa 3 5.8 4.0 1.2 0.2 setosa 4 5.0 3.2 1.2 0.2 setosa 5 4.7 3.2 1.3 0.2 setosa 6 5.4 3.9 1.3 0.4 setosa 7 5.5 3.5 1.3 0.2 setosa 8 4.4 3.0 1.3 0.2 setosa 9 5.0 3.5 1.3 0.3 setosa 10 4.5 2.3 1.3 0.3 setosa .. ... ... ... ... ... #Or using a variable sortBy <- c('Petal.Length', 'Petal.Width') arrange_(df1, .dots = sortBy) Source: local data frame [150 x 5] Sepal.Length Sepal.Width Petal.Length Petal.Width Species (dbl) (dbl) (dbl) (dbl) (fctr) 1 4.6 3.6 1.0 0.2 setosa 2 4.3 3.0 1.1 0.1 setosa 3 5.8 4.0 1.2 0.2 setosa 4 5.0 3.2 1.2 0.2 setosa 5 4.7 3.2 1.3 0.2 setosa 6 5.5 3.5 1.3 0.2 setosa 7 4.4 3.0 1.3 0.2 setosa 8 4.4 3.2 1.3 0.2 setosa 9 5.0 3.5 1.3 0.3 setosa 10 4.5 2.3 1.3 0.3 setosa .. ... ... ... ... ... #Doing the same operation except sorting Petal.Length in descending order sortByDesc <- c('desc(Petal.Length)', 'Petal.Width') arrange_(df1, .dots = sortByDesc) 

daugiau informacijos čia: https://cran.r-project.org/web/packages/dplyr/vignettes/nse.html

Geriau naudoti formulę, nes ji taip pat užfiksuoja terpę išraiškos vertinimui

data.table

 dt1 <- data.table(iris) #not really required, as you can work directly on your data.frame sortBy <- c('Petal.Length', 'Petal.Width') sortType <- c(-1, 1) setorderv(dt1, sortBy, sortType) dt1 Sepal.Length Sepal.Width Petal.Length Petal.Width Species 1: 7.7 2.6 6.9 2.3 virginica 2: 7.7 2.8 6.7 2.0 virginica 3: 7.7 3.8 6.7 2.2 virginica 4: 7.6 3.0 6.6 2.1 virginica 5: 7.9 3.8 6.4 2.0 virginica --- 146: 5.4 3.9 1.3 0.4 setosa 147: 5.8 4.0 1.2 0.2 setosa 148: 5.0 3.2 1.2 0.2 setosa 149: 4.3 3.0 1.1 0.1 setosa 150: 4.6 3.6 1.0 0.2 setosa 
12
06 февр. atsakymas pateikiamas info_seekeR 06 vasario mėn. 2016-02-06 00:11 '16 at 0:11 2016-02-06 00:11

Dėl išsamumo: galite naudoti ir sortByCol() :

 library(BBmisc) sortByCol(dd, c("z", "b"), asc = c(FALSE, TRUE)) bxyz 4 Low C 9 2 2 Med D 3 1 1 Hi A 8 1 3 Hi A 9 1 

Veiklos palyginimas:

 library(microbenchmark) microbenchmark(sortByCol(dd, c("z", "b"), asc = c(FALSE, TRUE)), times = 100000) median 202.878 library(plyr) microbenchmark(arrange(dd,desc(z),b),times=100000) median 148.758 microbenchmark(dd[with(dd, order(-z, b)), ], times = 100000) median 115.872 
4
07 авг. atsakymą pateikė Lars Kotthoff 07 rug. 2015-08-07 07:03 '15 at 7:03 2015-08-07 07:03

Mano mėgstamiausia parinktis yra organizavimas (). Naudokite vamzdžio operatorių ir pereikite iš mažiausiai svarbių prie svarbiausių aspektų.

 dd1 <- dd %>% arrange(z) %>% arrange(desc(x)) 
4
29 окт. atsakymas suteiktas Kaden Killpack 29 spalio. 2018-10-29 19:56 '18, 07:56 pm 2018-10-29 19:56

Kaip mechaniniai kortelių rūšiuotojai jau seniai, pirmiausia surūšiuoti pagal mažiausiai svarbų raktą, tada kitą svarbiausią raktą ir tt Nėra reikalingos bibliotekos, dirba su bet kokiu skaičiumi raktų ir bet kokio didėjimo bei mažėjimo klavišų derinio.

  dd <- dd[order(dd$b, decreasing = FALSE),] 

Dabar esame pasiruošę padaryti svarbiausią raktą. Veislė yra stabili, ir bet kokios reikšmingiausios nuorodos jau išspręstos.

 dd <- dd[order(dd$z, decreasing = TRUE),] 

Tai gali būti ne greičiausias, bet tikrai paprastas ir patikimas.

3
15 янв. atsakymą pateikė Rick 15 sausis 2015-01-15 07:28 '15, 7:28 2015-01-15 07:28

Kita alternatyva naudojant „ rgr paketą:

 > library(rgr) > gx.sort.df(dd, ~ -z+b) bxyz 4 Low C 9 2 2 Med D 3 1 1 Hi A 8 1 3 Hi A 9 1 
2
01 мая '18 в 13:18 2018-05-01 13:18 atsakė Stéphane Laurent gegužės 1 d. 18 val. 18:18 2018-05-01 13:18

Kovojau su aukščiau pateiktais sprendimais, kai norėjau automatizuoti užsakymo procesą n stulpeliuose, kurių stulpelių pavadinimai gali būti skirtingi kiekvieną kartą. psych paketą psych labai naudingą funkciją, kad tai būtų paprasta:

 dfOrder(myDf, columnIndices) 

kur columnIndices yra vienos ar kelių stulpelių indeksai, pagal kuriuos norite juos rūšiuoti. Daugiau informacijos rasite čia:

DfOrder funkcija iš psichikos paketo

0
25 окт. AHegde atsakymas, pateiktas spalio 25 d. 2018-10-25 01:32 '18 ne 1:32 2018-10-25 01:32

Tai galite padaryti:

library(dplyr) data<-data %>% arrange(data,columname)

-3
05 дек. atsakymas duotas prajjwal jaiswal 05 dec. 2017-12-05 00:16 '17 at 0:16 2017-12-05 00:16

Kiti klausimai apie žymes arba Užduoti klausimą