Halimbawa 1: Pag-uuri ng DataFrame Gamit ang Order() Method sa R
Ang order() function sa R ay ginagamit upang pagbukud-bukurin ang DataFrames sa pamamagitan ng isa o maraming column. Nakukuha ng function ng order ang mga indeks ng mga pinagsunod-sunod na row upang muling ayusin ang mga row ng DataFrame.
emp = datos. frame ( mga pangalan = c ( 'Andy' , 'Marka' , 'Bonnie' , 'Caroline' , 'John' ) ,edad = c ( dalawampu't isa , 23 , 29 , 25 , 32 ) ,
suweldo = c ( 2000 , 1000 , 1500 , 3000 , 2500 ) )
pusa ( ' \n \n Pinagbukud-bukod ng Dataframe ayon sa Mga Pangalan sa Pataas na Pagkakasunud-sunod \n ' )
sorted_asc = emp [ kasama ( emp , utos ( mga pangalan ) ) , ]
print ( sorted_asc )
Dito, tinukoy namin ang 'emp' DataFrame na may tatlong column na naglalaman ng iba't ibang value. Ang cat() function ay naka-deploy upang i-print ang pahayag upang ipahiwatig na ang 'emp' DataFrame sa pamamagitan ng column na 'mga pangalan' sa pataas na pagkakasunud-sunod ay pag-uuri-uriin. Para dito, ginagamit namin ang order() function sa R na nagbabalik ng mga posisyon ng index ng mga halaga sa isang vector na pinagsunod-sunod sa pataas na pagkakasunud-sunod. Sa kasong ito, ang with() function ay tumutukoy na ang column na 'mga pangalan' ay dapat na pagbukud-bukurin. Ang pinagsunod-sunod na DataFrame ay naka-imbak sa variable na 'sorted_asc' na ipinapasa bilang argumento sa print() function upang i-print ang mga pinagsunod-sunod na resulta.
Samakatuwid, ang mga pinagsunod-sunod na resulta ng DataFrame ayon sa column na 'mga pangalan' sa pataas na pagkakasunud-sunod ay ipinapakita sa sumusunod. Upang makuha ang pagpapatakbo ng pag-uuri sa pababang pagkakasunud-sunod, maaari lamang nating tukuyin ang negatibong sign na may pangalan ng column sa nakaraang function na order() :
Halimbawa 2: Pag-uuri ng DataFrame Gamit ang Order() Method Parameters sa R
Bukod dito, ang order() function ay tumatagal ng mga bumababa na argumento upang pag-uri-uriin ang DataFrame. Sa sumusunod na halimbawa, tinukoy namin ang order() function na may argumentong pag-uri-uriin sa pagtaas o pagbaba ng pagkakasunud-sunod:
df = datos. frame (
id = c ( 1 , 3 , 4 , 5 , 2 ) ,
kurso = c ( 'Python' , 'Java' , 'C++' , 'MongoDB' , 'R' ) )
print ( 'Inayos ayon sa Bumababang pagkakasunud-sunod ayon sa ID' )
print ( df [ utos ( df$id , bumababa = TOTOO ) , ] )
Dito, una naming idineklara ang variable na 'df' kung saan ang data.frame() function ay tinukoy na may tatlong magkakaibang column. Susunod, ginagamit namin ang function na print() kung saan kami nagpi-print ng mensahe upang ipahiwatig na ang DataFrame ay pag-uuri-uriin sa bumababang pagkakasunod-sunod batay sa column na 'id'. Pagkatapos nito, i-deploy namin muli ang print() function upang isagawa ang pagpapatakbo ng pag-uuri at i-print ang mga resultang iyon. Sa loob ng print() function, tinatawag namin ang function na 'order' para pagbukud-bukurin ang 'df' DataFrame batay sa column na 'course'. Ang argumento na 'pababa' ay nakatakda sa TRUE upang pagbukud-bukurin sa bumababa na pagkakasunud-sunod.
Sa sumusunod na paglalarawan, ang column na 'id' ng DataFrame ay nakaayos sa pababang pagkakasunud-sunod:
Gayunpaman, upang makuha ang mga resulta ng pag-uuri sa pataas na pagkakasunud-sunod, kailangan nating itakda ang nagpapababang argumento ng order() function na may FALSE tulad ng ipinapakita sa sumusunod:
print ( 'Inuri-uri ayon sa Tumataas na pagkakasunud-sunod ayon sa ID' )print ( df [ utos ( df$id , bumababa = MALI ) , ] )
Doon, nakukuha namin ang output ng uri ng operasyon ng DataFrame sa pamamagitan ng column na 'id' sa pataas na pagkakasunud-sunod.
Halimbawa 3: Pag-uuri ng DataFrame Gamit ang Arrange() Method sa R
Bukod pa rito, maaari rin nating gamitin ang paraan ng arrange() upang pagbukud-bukurin ang isang DataFrame ayon sa mga column. Maaari din nating pag-uri-uriin sa pataas o pababang pagkakasunud-sunod. Ang sumusunod na ibinigay na R code ay gumagamit ng arrange() function:
aklatan ( 'dplyr' )mag-aaral = datos. frame (
Id = c ( 3 , 5 , 2 , 4 , 1 ) ,
mga marka = c ( 70 , 90 , 75 , 88 , 92 ) )
print ( 'Pagtaas ng Order Sorting ayon sa Id ' )
print ( ayusin ( mag-aaral , Id ) )
Dito, nilo-load namin ang 'dplyr' package ng R para ma-access ang arrange() method para sa pag-uuri. Pagkatapos, mayroon kaming data.frame() function na naglalaman ng dalawang column at itakda ang DataFrame sa variable na 'estudyante'. Susunod, i-deploy namin ang arrange() function mula sa package na 'dplyr' sa print() function upang pag-uri-uriin ang ibinigay na DataFrame. Kinukuha ng arrange() function ang 'estudyante' na DataFrame bilang unang argumento nito, na sinusundan ng 'Id' ng mga column na pag-uuri-uriin. Ang print() function sa dulo ay nagpi-print ng pinagsunod-sunod na DataFrame sa console.
Makikita natin kung saan nakaayos ang column na 'Id' sa isang sequence sa sumusunod na output:
Halimbawa 4: Pag-uuri ng DataFrame ayon sa Petsa sa R
Ang DataFrame sa R ay maaari ding pagbukud-bukurin ayon sa mga halaga ng petsa. Para dito, dapat na tukuyin ang pinagsunod-sunod na function kasama ang function na as.date() upang ma-format ang mga petsa.
petsa_kaganapan = datos. frame ( kaganapan = c ( '3/4/2023' , '2/2/2023' ,'10/1/2023' , '3/29/2023' ) ,
singil = c ( 3100 , 2200 , 1000 , 2900 ) )
petsa_kaganapan [ utos ( bilang . Petsa ( event_date$event , pormat = '%d/%m/%Y' ) ) , ]
Dito, mayroon kaming DataFrame na 'event_date' na naglalaman ng column na 'event' na may mga string ng petsa sa format na 'buwan/araw/taon'. Kailangan nating ayusin ang mga string ng petsa na ito sa pataas na pagkakasunud-sunod. Ginagamit namin ang order() function na nag-uuri ng DataFrame ayon sa column na 'kaganapan' sa pataas na pagkakasunud-sunod. Nagagawa namin ito sa pamamagitan ng pag-convert ng mga string ng petsa sa column na 'kaganapan' sa mga aktwal na petsa gamit ang function na 'as.Date' at pagtukoy sa format ng mga string ng petsa gamit ang parameter na 'format'.
Kaya, kinakatawan namin ang data na pinagsunod-sunod ayon sa column ng petsa ng 'kaganapan' sa pataas na pagkakasunud-sunod.
Halimbawa 5: Pag-uuri ng DataFrame Gamit ang Setorder() Method sa R
Katulad nito, ang setorder() ay isa ring paraan upang pag-uri-uriin ang DataFrame. Inuuri nito ang DataFrame sa pamamagitan ng pagkuha ng argumento tulad ng arrange() method. Ang R code para sa setorder() na pamamaraan ay ibinibigay bilang mga sumusunod:
aklatan ( 'talaan ng mga impormasyon' )d1 = datos. frame ( orderId = c ( 1 , 4 , 2 , 5 , 3 ) ,
orderItem = c ( 'mansanas' , 'orange' , 'kiwi' , 'mangga' , 'saging' ) )
print ( itakda ang pagkakasunud-sunod ( d1 , orderItem ) )
Dito, itinakda muna namin ang data.table library dahil ang setorder() ang function ng package na ito. Pagkatapos, ginagamit namin ang data.frame() function para gawin ang DataFrame. Tinukoy ang DataFrame na may dalawang column lang na ginagamit namin para pagbukud-bukurin. Pagkatapos nito, itinakda namin ang setorder() function sa loob ng print() function. Kinukuha ng function na setorder() ang “d1” DataFrame bilang unang parameter at ang column na “orderId” bilang pangalawang parameter kung saan pinagbubukod-bukod ang DataFrame. Inaayos ng function na 'setorder' ang mga row ng talahanayan ng data sa pataas na pagkakasunud-sunod batay sa mga halaga sa column na 'orderId.'
Ang pinagsunod-sunod na DataFrame ay ang output sa sumusunod na console ng R:
Halimbawa 6: Pag-uuri ng DataFrame Gamit ang Row.Names() Method sa R
Ang row.names() method ay isa ring paraan para pagbukud-bukurin ang DataFrame sa R. Ang row.names() ay pag-uri-uriin ang DataFrames ayon sa tinukoy na row.
df < - data. frame ( pangkat = c ( 'X' , 'X' , 'AT' , 'AT' , 'SA' ) ,puntos = c ( 91 , 80 , 86 , 83 , 95 ) )
hilera. mga pangalan ( df ) < - c ( 'A' , 'D' , 'C' , 'AT' , 'B' )
df [ utos ( hilera. mga pangalan ( df ) ) , ]
Dito, itinatag ang data.frame() function sa loob ng variable na 'df' kung saan tinukoy ang mga column kasama ng mga value. Pagkatapos, ang mga pangalan ng row ng DataFrame ay tinukoy gamit ang row.names() function. Pagkatapos nito, tinatawagan namin ang order() function upang pagbukud-bukurin ang DataFrame ayon sa mga pangalan ng row. Ibinabalik ng function na order() ang mga indeks ng mga pinagsunod-sunod na row na ginagamit upang muling ayusin ang mga row ng DataFrame.
Ipinapakita ng output ang pinagsunod-sunod na DataFrame ayon sa mga hilera ayon sa alpabeto:
Konklusyon
Nakita namin ang iba't ibang mga function upang pag-uri-uriin ang DataFrames sa R. Ang bawat isa sa mga pamamaraan ay may kalamangan at nangangailangan ng operasyon ng pag-uuri. Maaaring may higit pang mga pamamaraan o paraan upang pag-uri-uriin ang DataFrame sa wikang R ngunit ang mga pamamaraan ng order(), arrange(), at setorder() ay ang pinakamahalaga at madaling gamitin para sa pag-uuri.