Theory
એવી ભાષા જ્યાં data બહુવચનમાં હોય છે
Console પર તમારું પહેલું ખરેખરું R ટાઈપ કરો:
heights <- c(160, 168, 175, 162, 171)
mean(heights)
જવાબ: [1] 167.2. બે લીટી: પાંચ students સંઘરાયા, સરેરાશ ગણાઈ.
નોંધો કે તમે શું નથી લખ્યું: કોઈ loop નહીં, કોઈ import નહીં, ચોરસ કૌંસનો કોઈ વિધિ નહીં. R ની પાયાની રચનાની પસંદગી: data નો પાયાનો એકમ આખો સંગ્રહ છે, એક જ મૂલ્ય નહીં: કારણ કે આંકડાશાસ્ત્ર ક્યારેય એક જ સંખ્યાનો અભ્યાસ કરતું નથી.
Theory
તીર વસ્તુઓને ખાનામાં મૂકે છે
heights <- c(160, 168, 175) બરાબર એવું જ વંચાય છે જેવું દેખાય છે: મૂલ્યો તીરની દિશામાં વહીને heights નામના ખાનામાં જાય છે.
<- એ R નું assignment છે: દૃશ્યમાન "અંદર મૂકો". (સાદું = પણ મોટે ભાગે ચાલે છે, પણ <- એ સંમેલન છે જેની દરેક પાઠ્યપુસ્તક, પેપર અને પરીક્ષક અપેક્ષા રાખે છે: તીર જ લખો.)
અને c() એ combine નું function છે: R ની રીતે કહેવું કે "આ મૂલ્યો એક vector તરીકે સાથે પ્રવાસ કરે છે".
Theory
Vectors અને vectorised મહાશક્તિ
Vector એટલે એક જ પ્રકારનાં મૂલ્યોનો ક્રમબદ્ધ સંગ્રહ: R નો પાયાનો એકમ. x <- 5 પણ લંબાઈ 1 નું vector છે: અને એટલે જ દરેક output [1] થી શરૂ થાય છે: R ઘટકોને નંબર આપે છે.
મહાશક્તિ: ક્રિયાઓ દરેક ઘટક પર એકસાથે લાગુ પડે છે:
heights + 2→ દરેક ઊંચાઈ 2 વધી.heights > 165→ એક logical vector: FALSE TRUE TRUE FALSE TRUE.
જ્યાં Python ની સાદી lists ને loop જોઈએ, ત્યાં R ખાલી... કરી નાખે છે. એક આંકડાકીય વિચાર, એક લીટી.
At a glance
એ data ના પ્રકારો જેના પર આંકડાશાસ્ત્ર ચાલે છે
| પ્રકાર | ઉદાહરણ | નોંધ |
|---|---|---|
| numeric | 168, 3.14 | સંખ્યાઓ માટે default |
| integer | 60L | L નો પ્રત્યય integer બનાવે છે |
| character | "Surat" | અવતરણચિહ્નો જરૂરી |
| logical | TRUE, FALSE | મોટા અક્ષરે; સરખામણીમાંથી આવે છે |
| factor | factor(c("hostel","day")) | સ્તરો સાથેનો શ્રેણીગત data |
Practical
Survey ના R ની દસ લીટી
# assignment: the arrow puts values into names
heights <- c(160, 168, 175, 162, 171) # numeric vector
cities <- c("Surat", "Navsari", "Surat", "Bardoli", "Surat")
stay <- factor(c("hostel", "day", "hostel", "day", "day"))
mean(heights) # [1] 167.2 built in, no import
sd(heights) # [1] 6.058
length(heights) # [1] 5
heights > 165 # [1] FALSE TRUE TRUE FALSE TRUE (vectorised!)
class(cities) # [1] "character"
levels(stay) # [1] "day" "hostel" the factor's categories
Think first
ત્રણ જવાબ ધારો
heights <- c(160, 168, 175, 162, 171) સાથે, દરેક માટે R શું છાપશે એ કાઢો, પછી tap કરો:
1. heights * 2
2. heights > 170
3. mean(heights > 170)
Show the answer
1. 320 336 350 324 342: દરેક ઘટક બમણો (vectorised).
2. FALSE FALSE TRUE FALSE TRUE: એક logical vector.
3. 0.4: ચતુરાઈવાળો: TRUE એ 1 ગણાય, FALSE એ 0, એટલે logicals ની સરેરાશ = 170 થી ઉપરનું પ્રમાણ (5 માંથી 2).
એ ત્રીજી યુક્તિ (શરતની સરેરાશ = એને સંતોષતું પ્રમાણ) એ R નો પ્રિય રૂઢિપ્રયોગ અને પરીક્ષાનો પ્રિય પ્રશ્ન છે: એક લીટીમાં ટકાવારીની ગણતરી.
Quiz
એક student ટાઈપ કરે છે: marks <- c(78, 85, "absent", 91) અને પછી mean(marks) ભૂલ આપે છે. શું થયું?
- Vectors એકસમાન હોય છે: એ એક string એ ચૂપચાપ બધા ઘટકોને character માં ફેરવ્યા, એટલે mean() ને લખાણ મળ્યું
- c() ત્રણથી વધુ મૂલ્યો રાખી શકતું નથી
- absent શબ્દ મોટા અક્ષરે જોઈતો હતો
- mean() ને પહેલાં મૂલ્યો ક્રમમાં ગોઠવેલાં જોઈએ
Show the answer
Vectors એકસમાન હોય છે: એ એક string એ ચૂપચાપ બધા ઘટકોને character માં ફેરવ્યા, એટલે mean() ને લખાણ મળ્યું
R નાં vectors એક જ પ્રકાર રાખે છે. સંખ્યાઓ અને એક string સામે આવતાં, R ચૂપચાપ બધું સૌથી લવચીક પ્રકારમાં ફેરવે છે: character: "78" હવે લખાણ છે, અને mean() શબ્દોની સરેરાશ કાઢી શકતું નથી. આ ચૂપચાપ થતું રૂપાંતર એ R નો સૌથી છૂપો શરૂઆતનો ફાંદો છે ખાસ એટલા માટે કે c() ની લીટી પોતે કોઈ ભૂલ દેખાડતી નથી: class(marks) થી તપાસો. ખૂટતા મૂલ્યનો આંકડાકીય ઉકેલ NA છે, જે આગલા એકમનો વિષય છે.
Watch out
Syntax ની ચાર ઠોકરો
Case: mean() ચાલે છે, Mean() નહીં: R મોટા અક્ષર ક્યારેય માફ કરતું નથી (TRUE, true નહીં).
અવતરણચિહ્નો: અવતરણચિહ્નો વગરનું Surat એ variable નું નામ ગણાય છે અને ભૂલ આપે છે.
રૂપાંતર: એક string numeric vector ને ચૂપચાપ લખાણમાં ફેરવે છે.
તીર: પરીક્ષામાં <- લખો; પરીક્ષકો = ને ચાલતું હોય ત્યાં પણ પૂરું-R-નહીં તરીકે વાંચે છે.
Theory
Factors: એકમ 1નો શબ્દભંડોળ એક પ્રકાર બને છે
નોંધો કે factor() ચક્ર પૂરું કરે છે: એકમ 1 નાં શ્રેણીગત variables અહીં શબ્દશઃ એક data નો પ્રકાર છે: levels() શ્રેણીઓ યાદી કરે છે, અને R એમની સરેરાશ કાઢવાની ના પાડે છે (સાચી રીતે: અર્થહીન ગણિતનો ફાંદો યાદ કરો). Numeric vectors = એકમ 1 નાં આંકડાકીય variables. તમે હાથે શીખેલું વર્ગીકરણ ભાષા લાગુ કરાવે છે: આગલા પાઠમાં, આખી survey ની files read.csv દ્વારા આવે છે, પ્રકાર સાથે અને તૈયાર.
Summary
Key takeaways
- Assignment: name <- value (તીર એ પરીક્ષામાં અપેક્ષિત સ્વરૂપ છે); # થી comment શરૂ થાય છે.
- c() મૂલ્યોને VECTOR માં જોડે છે, R નો પાયાનો એકમ; એકલાં મૂલ્યો લંબાઈ 1 નાં vectors છે (એ [1]).
- ક્રિયાઓ vectorised છે: heights + 2 અને heights > 165 દરેક ઘટકને લાગે છે, કોઈ loops નહીં.
- પ્રકારો: numeric, integer (L), character (અવતરણચિહ્નમાં), logical (TRUE/FALSE), factor (સ્તરો સાથે શ્રેણીગત).
- Vectors એકસમાન છે: એક જ string બધું ચૂપચાપ character માં ફેરવે છે.
- mean(શરત) એ પ્રમાણ ગણે છે: TRUE = 1, FALSE = 0.
- Memory hook: તીર મૂલ્યોને ખાનામાં મૂકે છે; c() એમને સાથે પ્રવાસ કરાવે છે.