Theory
ડીનને સૌથી ખરાબ પહેલાં જોઈએ છે
સાફ કરેલો survey તૈયાર છે, અને ડીનની આગલી માંગણી અહેવાલ લેખનની સૌથી જૂની માંગણી છે: "એ જ કોષ્ટક, પણ ક્રમમાં: સૌથી વધુ screen time પહેલાં."
SQL માં આ ORDER BY હતું. pandas માં, sort_values. R ની જોડણી પહેલી નજરે વધુ વિચિત્ર લાગે છે:
survey[order(-survey$screen), ]
"order" કેમ અને "sort" કેમ નહીં? કારણ કે R આ કામને બે જુદાં functions માં વહેંચે છે, અને એમને ગૂંચવવો એ પાઠનો પ્રખ્યાત ફાંદો છે. એક મૂલ્યો આપે છે; બીજું સ્થાન આપે છે.
Theory
લોકોને ગોઠવવા સામે બેઠકના નંબર બોલવા
વર્ગને ઊંચાઈ પ્રમાણે ગોઠવવાની બે રીત:
- sort() ભૌતિક રીતે ઊંચાઈઓ ને હરોળમાં ગોઠવે છે: 150, 158, 163... ફક્ત સંખ્યાઓ, પોતાના માલિકોથી છૂટી પડેલી.
- order() બેઠકનાં સ્થાન બોલે છે: "પહેલાં બેઠક 7, પછી બેઠક 2, પછી બેઠક 9...": ફરી ગોઠવવાની એવી યોજના જેને આખો વર્ગ (દરેક ખાનું!) અનુસરી શકે.
Data frame ને ગોઠવવા તમને યોજના જોઈએ, ખાલી મૂલ્યો નહીં: હરોળ સાથે ખસવી જોઈએ, નહીં તો marks પોતાના roll numbers થી છૂટા પડી જાય.
Practical
order() કોષ્ટક ગોઠવે છે; sort() vectors ગોઠવે છે
survey <- read.csv("survey_clean.csv") # roll, city, stay, screen
# sort a LONE VECTOR: sort() returns the values, ascending
sort(survey$screen) # 60 90 120 150 240 ...
sort(survey$screen, decreasing = TRUE)
# sort the DATA FRAME: order() returns row positions, brackets apply them
survey[order(survey$screen), ] # ascending
survey[order(survey$screen, decreasing = TRUE), ] # descending
survey[order(-survey$screen), ] # minus: same, numerics only
# multiple keys: city A-Z, then screen high-to-low within city
survey[order(survey$city, -survey$screen), ]
# what order() actually returns: a permutation of row numbers
order(c(300, 100, 200)) # [1] 2 3 1 (2nd smallest first...)
# reorder COLUMNS: plain subsetting
survey <- survey[, c("roll", "screen", "city", "stay")]
Theory
Reshaping: પહોળું સામે લાંબું
ક્રમમાં ગોઠવવું હરોળ ફરી ગોઠવે છે; reshaping કોષ્ટકની આખી રચના ફરી ગોઠવે છે.
પહોળું: દરેક student દીઠ એક હરોળ, દરેક કસોટી દીઠ એક ખાનું:
roll test1 test2 test3
લાંબું: દરેક student-કસોટીની જોડી દીઠ એક હરોળ:
roll test score
પહોળું સરસ વંચાય છે; લાંબું સરસ ગણાય છે (કસોટી પ્રમાણે જૂથ, કસોટી પ્રમાણે આલેખ: દરેક ઓજાર એને પસંદ કરે છે). Base R નું reshape() એમની વચ્ચે બદલે છે પણ એ પ્રખ્યાત રીતે અઘરું છે; આધુનિક ઓજારો tidyr નાં pivot_longer()/pivot_wider() છે (નામ જાણવા જેવાં). પરીક્ષા માટે: બે આકાર, એમની આપ-લે, અને રૂપાંતરનાં ઓજારો છે એટલું જાણો.
Quiz
એક student survey$screen <- sort(survey$screen) થી survey ગોઠવે છે અને આગળ વધે છે. ચૂપચાપ શું તૂટ્યું?
- ફક્ત screen નું ખાનું ગોઠવાયું: દરેક મૂલ્ય હવે ખોટા roll number ની બાજુમાં બેઠું છે: હરોળની ગોઠવણ નાશ પામી
- કશું નહીં: એક ખાનું ગોઠવવાથી આખો data frame ગોઠવાય છે
- R એ ભૂલ આપી, એટલે કોઈ નુકસાન નથી
- ખાનું કાઢી નખાયું
Show the answer
ફક્ત screen નું ખાનું ગોઠવાયું: દરેક મૂલ્ય હવે ખોટા roll number ની બાજુમાં બેઠું છે: હરોળની ગોઠવણ નાશ પામી
sort() એ ખાલી મૂલ્યો પાછાં આપ્યાં અને assignment એ ખાના પર જગ્યાએ જ લખી નાખ્યું: screen times હવે ચઢતા ક્રમમાં છે જ્યારે roll, city અને stay એ પોતાનો જૂનો ક્રમ રાખ્યો: student 101 કોઈ બીજાનો screen time પહેરે છે, ચેતવવા કોઈ ભૂલ વગર. આ ચૂપ ખોટી ગોઠવણ જ કારણ છે કે data frames df[order(df$col), ] થી ગોઠવાય છે: order() ની યોજના દરેક ખાનાને સાથે ખસેડે છે. શરૂઆત કરનાર ચલાવી શકે એવી કદાચ સૌથી જોખમી એક જ લીટી.
Think first
ક્રમની યોજના વાંચો
rolls 101, 102, 103 માટે screen <- c(300, 100, 200). કાઢો: (1) order(screen) શું આપે છે, (2) survey[order(screen), ] માં કયો roll પહેલો આવે છે, (3) sort(screen) શું આપત. પછી tap કરો.
Show the answer
1. order(screen) = 2 3 1: "હરોળ 2 સૌથી નાની, પછી હરોળ 3, પછી હરોળ 1".
2. હરોળ 2 આગળ આવે છે, એટલે roll 102 (screen 100) પહેલો આવે છે: default માં ચઢતો ક્રમ.
3. sort(screen) = 100 200 300: ફક્ત મૂલ્યો, માલિકો પાછળ રહી ગયા.
જો તમે "2 3 1" ને મૂલ્યોને બદલે બેઠકની યોજના તરીકે વાંચી શકો, તો order() સમજાઈ ગયું: કૌંસનું લખાણ df[યોજના, ] ખાલી દરેક ખાનાને એ યોજના પ્રમાણે બેસાડે છે.
Watch out
ક્રમની ત્રણ લપસણ
df[...] ની અંદર sort(): ગોઠવણ તોડે છે કે ભૂલ આપે છે: data frames order() લે છે.
ખૂટતો અલ્પવિરામ: df[order(df$screen), ]: ઉપસમૂહના પાઠનો હરોળના ખાનાનો અલ્પવિરામ હજી રાજ કરે છે.
ઊતરતા ક્રમ માટે ઓછાનું ચિહ્ન ફક્ત numeric ચાવીઓ પર ચાલે છે: લખાણ કે મિશ્ર ચાવીઓ માટે decreasing = TRUE વાપરો (બધી ચાવીઓને લાગુ પડે) કે ચાવીઓને એ પ્રમાણે વીંટાળો.
Theory
ત્રીજી ભાષા, એ જ ORDER BY
SQL: ORDER BY screen DESC. pandas: sort_values('screen', ascending=False). R: df[order(-df$screen), ]. એક વિચાર, ત્રણ લહેકા: અને ત્રણેયમાં, અનેક ચાવીનું ગોઠવવું (city, પછી screen) એ ખાલી ચાવીઓને અગ્રતાના ક્રમમાં યાદી કરવાનું છે. આગલા પાઠમાં survey ને બીજું કોષ્ટક મળે છે: merge(), R નું JOIN, અને તમારી BCA303ની join ની સમજ સીધી કામે લાગે છે.
Summary
Key takeaways
- order(x) એ હરોળના સ્થાનની યોજના આપે છે જે x ને ગોઠવે; df[order(x), ] એને દરેક ખાના પર લાગુ કરે છે.
- sort(x) એકલા vector નાં ગોઠવાયેલાં મૂલ્યો આપે છે: data frame ના ખાનાને જગ્યાએ ગોઠવવા એ ક્યારેય ન વાપરો.
- ઊતરતો ક્રમ: decreasing = TRUE, કે numeric ચાવીઓ પર ઓછાનું ચિહ્ન; અનેક ચાવી: order(key1, key2).
- નામોના vector થી ઉપસમૂહ લઈને ખાનાં ફરી ગોઠવો.
- પહોળું (દરેક માપ દીઠ એક ખાનું) સામે લાંબું (દરેક નિરીક્ષણ દીઠ એક હરોળ): લાંબું વધુ સારી રીતે ગણાય અને દોરાય છે.
- reshape() base R માં છે; tidyr નાં pivot_longer/pivot_wider એ આધુનિક નામ છે.
- Memory hook: sort ઊંચાઈઓ હરોળમાં ગોઠવે છે; order બેઠકના નંબર બોલે છે.