ഇൻറർനെറ്റിൽ R അല്ലെങ്കിൽ Python എന്നതിനായി തിരയുന്നതിലൂടെ, ഡാറ്റയുമായി പ്രവർത്തിക്കാൻ ഏറ്റവും മികച്ചതും വേഗതയേറിയതും കൂടുതൽ സൗകര്യപ്രദവുമായ വിഷയത്തെക്കുറിച്ചുള്ള ദശലക്ഷക്കണക്കിന് ലേഖനങ്ങളും കിലോമീറ്ററുകളോളം ചർച്ചകളും നിങ്ങൾ കണ്ടെത്തും. എന്നാൽ നിർഭാഗ്യവശാൽ, ഈ ലേഖനങ്ങളും തർക്കങ്ങളും പ്രത്യേകിച്ച് ഉപയോഗപ്രദമല്ല.

രണ്ട് ഭാഷകളിലെയും ഏറ്റവും ജനപ്രിയമായ പാക്കേജുകളിലെ അടിസ്ഥാന ഡാറ്റ പ്രോസസ്സിംഗ് ടെക്നിക്കുകൾ താരതമ്യം ചെയ്യുക എന്നതാണ് ഈ ലേഖനത്തിന്റെ ഉദ്ദേശ്യം. കൂടാതെ ഇതുവരെ അറിയാത്ത എന്തെങ്കിലും വേഗത്തിൽ മാസ്റ്റർ ചെയ്യാൻ വായനക്കാരെ സഹായിക്കുക. പൈത്തണിൽ എഴുതുന്നവർക്ക്, R-ലും അതേ കാര്യം എങ്ങനെ ചെയ്യാമെന്ന് കണ്ടെത്തുക.

ലേഖനത്തിൽ R-ലെ ഏറ്റവും ജനപ്രിയമായ പാക്കേജുകളുടെ വാക്യഘടന ഞങ്ങൾ വിശകലനം ചെയ്യും. ലൈബ്രറിയിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പാക്കേജുകൾ ഇവയാണ് tidyverseകൂടാതെ പാക്കേജും data.table. അവരുടെ വാക്യഘടനയുമായി താരതമ്യം ചെയ്യുക pandas, പൈത്തണിലെ ഏറ്റവും ജനപ്രിയമായ ഡാറ്റ വിശകലന പാക്കേജ്.

ഡാറ്റാ വിശകലനം ലോഡുചെയ്യുന്നത് മുതൽ പൈത്തൺ, ആർ എന്നിവ ഉപയോഗിച്ച് അനലിറ്റിക്കൽ വിൻഡോ ഫംഗ്ഷനുകൾ നടത്തുന്നത് വരെയുള്ള മുഴുവൻ പാതയിലൂടെയും ഞങ്ങൾ ഘട്ടം ഘട്ടമായി പോകും.

ഉള്ളടക്കം

പരിഗണനയിലുള്ള പാക്കേജുകളിലൊന്നിൽ ചില ഡാറ്റ പ്രോസസ്സിംഗ് ഓപ്പറേഷൻ എങ്ങനെ നടത്തണമെന്ന് നിങ്ങൾ മറന്നുപോയെങ്കിൽ ഈ ലേഖനം ഒരു ചീറ്റ് ഷീറ്റായി ഉപയോഗിക്കാവുന്നതാണ്.

1. R ഉം പൈത്തണും തമ്മിലുള്ള പ്രധാന വാക്യഘടന വ്യത്യാസങ്ങൾ
   1.1. പാക്കേജ് പ്രവർത്തനങ്ങൾ ആക്സസ് ചെയ്യുന്നു
   1.2. അസൈൻമെന്റ്
   1.3. ഇൻഡെക്സിംഗ്
   1.4. രീതികളും OOP
   1.5. പൈപ്പ് ലൈനുകൾ
   1.6. ഡാറ്റ ഘടനകൾ
2. ഞങ്ങൾ ഉപയോഗിക്കുന്ന പാക്കേജുകളെക്കുറിച്ച് കുറച്ച് വാക്കുകൾ
   2.1. വൃത്തിയുള്ള
   2.2. ഡാറ്റ. പട്ടിക
   2.3. പാണ്ടകൾ
3. പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു
4. ഡാറ്റ ലോഡുചെയ്യുന്നു
5. ഡാറ്റ ഫ്രെയിമുകൾ സൃഷ്ടിക്കുന്നു
6. നിങ്ങൾക്ക് ആവശ്യമുള്ള നിരകൾ തിരഞ്ഞെടുക്കുന്നു
7. ഫിൽട്ടറിംഗ് വരികൾ
8. ഗ്രൂപ്പിംഗും കൂട്ടിച്ചേർക്കലും
9. പട്ടികകളുടെ ലംബമായ യൂണിയൻ (UNION)
10. പട്ടികകളുടെ തിരശ്ചീന ജോയിൻ (ജോയിൻ)
11. അടിസ്ഥാന വിൻഡോ പ്രവർത്തനങ്ങളും കണക്കാക്കിയ നിരകളും
12. R, Python എന്നിവയിലെ ഡാറ്റാ പ്രോസസ്സിംഗ് രീതികൾ തമ്മിലുള്ള കറസ്‌പോണ്ടൻസ് പട്ടിക
13. തീരുമാനം
14. നിങ്ങൾ ഏത് പാക്കേജാണ് ഉപയോഗിക്കുന്നത് എന്നതിനെക്കുറിച്ചുള്ള ഒരു ചെറിയ സർവേ

നിങ്ങൾക്ക് ഡാറ്റ വിശകലനത്തിൽ താൽപ്പര്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് എന്റെ കണ്ടെത്താം ടെലഗ്രാം и YouTube ചാനലുകൾ. ഉള്ളടക്കത്തിന്റെ ഭൂരിഭാഗവും R ഭാഷയ്‌ക്കായി സമർപ്പിച്ചിരിക്കുന്നു.

R ഉം പൈത്തണും തമ്മിലുള്ള പ്രധാന വാക്യഘടന വ്യത്യാസങ്ങൾ

പൈത്തണിൽ നിന്ന് R ലേക്ക് മാറുന്നത് നിങ്ങൾക്ക് എളുപ്പമാക്കുന്നതിന്, അല്ലെങ്കിൽ തിരിച്ചും, നിങ്ങൾ ശ്രദ്ധിക്കേണ്ട ചില പ്രധാന പോയിന്റുകൾ ഞാൻ നൽകും.

പാക്കേജ് പ്രവർത്തനങ്ങൾ ആക്സസ് ചെയ്യുന്നു

ഒരു പാക്കേജ് R-ലേക്ക് ലോഡ് ചെയ്തുകഴിഞ്ഞാൽ, അതിന്റെ ഫംഗ്‌ഷനുകൾ ആക്‌സസ് ചെയ്യുന്നതിന് നിങ്ങൾ പാക്കേജിന്റെ പേര് വ്യക്തമാക്കേണ്ടതില്ല. മിക്ക കേസുകളിലും ഇത് R-ൽ സാധാരണമല്ല, പക്ഷേ ഇത് സ്വീകാര്യമാണ്. നിങ്ങളുടെ കോഡിൽ അതിന്റെ ഫംഗ്‌ഷനുകളിൽ ഒന്ന് വേണമെങ്കിൽ നിങ്ങൾ ഒരു പാക്കേജ് ഇറക്കുമതി ചെയ്യേണ്ടതില്ല, എന്നാൽ പാക്കേജിന്റെ പേരും ഫംഗ്‌ഷന്റെ പേരും വ്യക്തമാക്കി അതിനെ വിളിക്കുക. R ലെ പാക്കേജിനും ഫംഗ്‌ഷൻ നാമങ്ങൾക്കും ഇടയിലുള്ള സെപ്പറേറ്റർ ഒരു ഇരട്ട കോളനാണ്. package_name::function_name().

പൈത്തണിൽ, നേരെമറിച്ച്, ഒരു പാക്കേജിന്റെ ഫംഗ്‌ഷനുകളെ അതിന്റെ പേര് വ്യക്തമായി പറഞ്ഞുകൊണ്ട് വിളിക്കുന്നത് ക്ലാസിക് ആയി കണക്കാക്കപ്പെടുന്നു. ഒരു പാക്കേജ് ഡൗൺലോഡ് ചെയ്യുമ്പോൾ, അത് സാധാരണയായി ചുരുക്കിയ ഒരു പേര് നൽകും, ഉദാ. pandas സാധാരണയായി ഒരു ഓമനപ്പേരാണ് ഉപയോഗിക്കുന്നത് pd. ഒരു പാക്കേജ് ഫംഗ്‌ഷൻ ഒരു ഡോട്ടിലൂടെ ആക്‌സസ് ചെയ്യുന്നു package_name.function_name().

അസൈൻമെന്റ്

R-ൽ, ഒരു വസ്തുവിന് ഒരു മൂല്യം നൽകുന്നതിന് ഒരു അമ്പടയാളം ഉപയോഗിക്കുന്നത് സാധാരണമാണ്. obj_name <- value, ഒരു സിംഗിൾ ഈക്വൽസ് സൈൻ അനുവദനീയമാണെങ്കിലും, ആർഗ്യുമെന്റുകൾ ഫംഗ്‌ഷൻ ചെയ്യുന്നതിനായി മൂല്യങ്ങൾ കൈമാറുന്നതിന് R-ലെ സിംഗിൾ ഈക്വൽസ് സൈൻ ഉപയോഗിക്കുന്നു.

പൈത്തണിൽ, അസൈൻമെന്റ് ചെയ്യുന്നത് ഒരൊറ്റ തുല്യ ചിഹ്നം ഉപയോഗിച്ചാണ് obj_name = value.

ഇൻഡെക്സിംഗ്

ഇവിടെയും കാര്യമായ വ്യത്യാസങ്ങളുണ്ട്. R-ൽ, ഇൻഡക്‌സിംഗ് ഒന്നിൽ ആരംഭിക്കുന്നു, ഫലമായുണ്ടാകുന്ന ശ്രേണിയിലെ എല്ലാ നിർദ്ദിഷ്ട ഘടകങ്ങളും ഉൾപ്പെടുന്നു,

പൈത്തണിൽ, ഇൻഡക്‌സിംഗ് പൂജ്യത്തിൽ നിന്നാണ് ആരംഭിക്കുന്നത്, തിരഞ്ഞെടുത്ത ശ്രേണിയിൽ സൂചികയിൽ വ്യക്തമാക്കിയ അവസാന ഘടകം ഉൾപ്പെടുന്നില്ല. അതിനാൽ ഡിസൈൻ ചെയ്യുക x[i:j] പൈത്തണിൽ j ഘടകം ഉൾപ്പെടില്ല.

R നൊട്ടേഷനിൽ നെഗറ്റീവ് ഇൻഡക്‌സിംഗിലും വ്യത്യാസങ്ങളുണ്ട് x[-1] അവസാനത്തേത് ഒഴികെ വെക്റ്ററിന്റെ എല്ലാ ഘടകങ്ങളും തിരികെ നൽകും. പൈത്തണിൽ, സമാനമായ ഒരു നൊട്ടേഷൻ അവസാനത്തെ ഘടകം മാത്രം നൽകും.

രീതികളും OOP

R അതിന്റേതായ രീതിയിൽ OOP നടപ്പിലാക്കുന്നു, ഞാൻ ഇതിനെക്കുറിച്ച് ലേഖനത്തിൽ എഴുതി "R ഭാഷയിൽ OOP (ഭാഗം 1): S3 ക്ലാസുകൾ". പൊതുവേ, R ഒരു ഫങ്ഷണൽ ഭാഷയാണ്, അതിലെ എല്ലാം ഫംഗ്ഷനുകളിൽ നിർമ്മിച്ചതാണ്. അതിനാൽ, ഉദാഹരണത്തിന്, Excel ഉപയോക്താക്കൾക്കായി, പോകുക tydiverse അതിനെക്കാൾ എളുപ്പമായിരിക്കും pandas. ഇത് എന്റെ ആത്മനിഷ്ഠമായ അഭിപ്രായമാണെങ്കിലും.

ചുരുക്കത്തിൽ, R ലെ ഒബ്‌ജക്റ്റുകൾക്ക് രീതികൾ ഇല്ല (നമ്മൾ S3 ക്ലാസുകളെക്കുറിച്ച് സംസാരിക്കുകയാണെങ്കിൽ, എന്നാൽ മറ്റ് OOP നടപ്പിലാക്കലുകൾ വളരെ കുറവാണ്). ഒബ്ജക്റ്റിന്റെ ക്ലാസിനെ ആശ്രയിച്ച് അവയെ വ്യത്യസ്തമായി പ്രോസസ്സ് ചെയ്യുന്ന സാമാന്യവൽക്കരിച്ച ഫംഗ്ഷനുകൾ മാത്രമേയുള്ളൂ.

പൈപ്പ് ലൈനുകൾ

ഒരുപക്ഷേ ഇത് അതിന്റെ പേരായിരിക്കാം pandas ഇത് പൂർണ്ണമായും ശരിയാകില്ല, പക്ഷേ ഞാൻ അർത്ഥം വിശദീകരിക്കാൻ ശ്രമിക്കും.

ഇന്റർമീഡിയറ്റ് കണക്കുകൂട്ടലുകൾ സംരക്ഷിക്കാതിരിക്കാനും ജോലി ചെയ്യുന്ന അന്തരീക്ഷത്തിൽ അനാവശ്യ വസ്തുക്കൾ നിർമ്മിക്കാതിരിക്കാനും, നിങ്ങൾക്ക് ഒരുതരം പൈപ്പ്ലൈൻ ഉപയോഗിക്കാം. ആ. ഒരു ഫംഗ്ഷനിൽ നിന്ന് അടുത്തതിലേക്ക് ഒരു കണക്കുകൂട്ടലിന്റെ ഫലം കൈമാറുക, കൂടാതെ ഇന്റർമീഡിയറ്റ് ഫലങ്ങൾ സംരക്ഷിക്കരുത്.

ഇനിപ്പറയുന്ന കോഡ് ഉദാഹരണം എടുക്കാം, അതിൽ ഞങ്ങൾ ഇന്റർമീഡിയറ്റ് കണക്കുകൂട്ടലുകൾ പ്രത്യേക ഒബ്‌ജക്റ്റുകളിൽ സംഭരിക്കുന്നു:

temp_object <- func1()
temp_object2 <- func2(temp_object )
obj <- func3(temp_object2 )

ഞങ്ങൾ തുടർച്ചയായി 3 പ്രവർത്തനങ്ങൾ നടത്തി, ഓരോന്നിന്റെയും ഫലം ഒരു പ്രത്യേക ഒബ്ജക്റ്റിൽ സംരക്ഷിച്ചു. എന്നാൽ വാസ്തവത്തിൽ, നമുക്ക് ഈ ഇന്റർമീഡിയറ്റ് ഒബ്ജക്റ്റുകൾ ആവശ്യമില്ല.

അല്ലെങ്കിൽ അതിലും മോശമാണ്, എന്നാൽ Excel ഉപയോക്താക്കൾക്ക് കൂടുതൽ പരിചിതമാണ്.

obj  <- func3(func2(func1()))

ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ ഇന്റർമീഡിയറ്റ് കണക്കുകൂട്ടൽ ഫലങ്ങൾ സംരക്ഷിച്ചില്ല, പക്ഷേ നെസ്റ്റഡ് ഫംഗ്ഷനുകളുള്ള കോഡ് വായിക്കുന്നത് വളരെ അസൗകര്യമാണ്.

R-ൽ ഡാറ്റ പ്രോസസ്സിംഗിനുള്ള നിരവധി സമീപനങ്ങൾ ഞങ്ങൾ പരിശോധിക്കും, അവ വ്യത്യസ്ത രീതികളിൽ സമാന പ്രവർത്തനങ്ങൾ നടത്തുന്നു.

ലൈബ്രറിയിലെ പൈപ്പ് ലൈനുകൾ tidyverse ഓപ്പറേറ്റർ നടപ്പിലാക്കിയത് %>%.

obj <- func1() %>% 
            func2() %>%
            func3()

അങ്ങനെ ഞങ്ങൾ ജോലിയുടെ ഫലം എടുക്കുന്നു func1() എന്നതിലേക്കുള്ള ആദ്യ വാദമായി അത് പാസാക്കുക func2(), അപ്പോൾ ഈ കണക്കുകൂട്ടലിന്റെ ഫലം ആദ്യ ആർഗ്യുമെന്റായി ഞങ്ങൾ കൈമാറുന്നു func3(). അവസാനം, ഒബ്‌ജക്റ്റിലേക്ക് നടത്തിയ എല്ലാ കണക്കുകൂട്ടലുകളും ഞങ്ങൾ എഴുതുന്നു obj <-.

മേൽപ്പറഞ്ഞവയെല്ലാം ഈ മെമ്മിലൂടെ വാക്കുകളേക്കാൾ നന്നായി ചിത്രീകരിച്ചിരിക്കുന്നു:

В data.table ചങ്ങലകൾ സമാനമായ രീതിയിൽ ഉപയോഗിക്കുന്നു.

newDT <- DT[where, select|update|do, by][where, select|update|do, by][where, select|update|do, by]

ഓരോ സ്ക്വയർ ബ്രാക്കറ്റുകളിലും നിങ്ങൾക്ക് മുമ്പത്തെ പ്രവർത്തനത്തിന്റെ ഫലം ഉപയോഗിക്കാം.

В pandas അത്തരം പ്രവർത്തനങ്ങൾ ഒരു ഡോട്ട് കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു.

obj = df.fun1().fun2().fun3()

ആ. ഞങ്ങൾ ഞങ്ങളുടെ മേശ എടുക്കുന്നു df അവളുടെ രീതി ഉപയോഗിക്കുക fun1(), തുടർന്ന് ലഭിച്ച ഫലത്തിലേക്ക് ഞങ്ങൾ രീതി പ്രയോഗിക്കുന്നു fun2()ശേഷം fun3(). തത്ഫലമായുണ്ടാകുന്ന ഫലം ഒരു വസ്തുവായി സംരക്ഷിക്കപ്പെടുന്നു ഒബ്ജക്റ്റ് .

ഡാറ്റ ഘടനകൾ

R, Python എന്നിവയിലെ ഡാറ്റാ ഘടനകൾ സമാനമാണ്, എന്നാൽ വ്യത്യസ്ത പേരുകളുണ്ട്.

വിവരണം
R ലെ ശീർഷകം
പൈത്തൺ/പാണ്ടകളിൽ പേര്

പട്ടിക ഘടന
data.frame, data.table, tibble
ഡാറ്റാഫ്രെയിം

മൂല്യങ്ങളുടെ ഏകമാന ലിസ്റ്റ്
വെക്റ്റർ
പാണ്ടകളിലെ സീരീസ് അല്ലെങ്കിൽ ശുദ്ധമായ പൈത്തണിലെ ലിസ്റ്റ്

മൾട്ടി-ലെവൽ നോൺ-ടേബിൾ ഘടന
ലിസ്റ്റ്
നിഘണ്ടു (ഡിക്‌റ്റ്)

വാക്യഘടനയിലെ മറ്റ് ചില സവിശേഷതകളും വ്യത്യാസങ്ങളും ഞങ്ങൾ ചുവടെ പരിശോധിക്കും.

ഞങ്ങൾ ഉപയോഗിക്കുന്ന പാക്കേജുകളെക്കുറിച്ച് കുറച്ച് വാക്കുകൾ

ആദ്യം, ഈ ലേഖനത്തിൽ നിങ്ങൾക്ക് പരിചിതമാകുന്ന പാക്കേജുകളെക്കുറിച്ച് ഞാൻ നിങ്ങളോട് കുറച്ച് പറയും.

വൃത്തിയുള്ള

ഔദ്യോഗിക വെബ്സൈറ്റ്: tidyverse.org

ലൈബ്രറി tidyverse RStudio-യിലെ സീനിയർ റിസർച്ച് സയന്റിസ്റ്റ് ഹെഡ്‌ലി വിക്കാം എഴുതിയത്. tidyverse ഡാറ്റാ പ്രോസസ്സിംഗ് ലളിതമാക്കുന്ന ആകർഷകമായ ഒരു കൂട്ടം പാക്കേജുകൾ ഉൾക്കൊള്ളുന്നു, അവയിൽ 5 എണ്ണം CRAN റിപ്പോസിറ്ററിയിൽ നിന്നുള്ള മികച്ച 10 ഡൗൺലോഡുകളിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.

ലൈബ്രറിയുടെ കാതൽ ഇനിപ്പറയുന്ന പാക്കേജുകൾ ഉൾക്കൊള്ളുന്നു: ggplot2, dplyr, tidyr, readr, purrr, tibble, stringr, forcats. ഈ പാക്കേജുകൾ ഓരോന്നും ഒരു പ്രത്യേക പ്രശ്നം പരിഹരിക്കാൻ ലക്ഷ്യമിടുന്നു. ഉദാഹരണത്തിന് dplyr ഡാറ്റ കൃത്രിമത്വത്തിനായി സൃഷ്ടിച്ചത്, tidyr ഡാറ്റ ഒരു വൃത്തിയുള്ള രൂപത്തിലേക്ക് കൊണ്ടുവരാൻ, stringr സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് ലളിതമാക്കുന്നു, കൂടാതെ ggplot2 ഏറ്റവും ജനപ്രിയമായ ഡാറ്റ വിഷ്വലൈസേഷൻ ടൂളുകളിൽ ഒന്നാണ്.

നേട്ടം tidyverse ലളിതവും വായിക്കാൻ എളുപ്പമുള്ളതുമായ വാക്യഘടനയാണ്, ഇത് SQL അന്വേഷണ ഭാഷയ്ക്ക് സമാനമാണ്.

ഡാറ്റ. പട്ടിക

ഔദ്യോഗിക വെബ്സൈറ്റ്: r-datatable.com

എഴുതിയത് data.table H2O.ai യുടെ മാറ്റ് ഡോൾ ആണ്.

2006ലാണ് ലൈബ്രറിയുടെ ആദ്യ പ്രകാശനം നടന്നത്.

പാക്കേജ് സിന്റാക്സ് ഉള്ളതുപോലെ സൗകര്യപ്രദമല്ല tidyverse കൂടാതെ R ലെ ക്ലാസിക് ഡാറ്റാഫ്രെയിമുകളെ കൂടുതൽ അനുസ്മരിപ്പിക്കുന്നു, എന്നാൽ അതേ സമയം പ്രവർത്തനക്ഷമതയിൽ ഗണ്യമായി വികസിച്ചു.

ഈ പാക്കേജിലെ പട്ടികയിലുള്ള എല്ലാ കൃത്രിമത്വങ്ങളും ചതുര ബ്രാക്കറ്റുകളിൽ വിവരിച്ചിരിക്കുന്നു, നിങ്ങൾ വാക്യഘടന വിവർത്തനം ചെയ്യുകയാണെങ്കിൽ data.table SQL-ൽ, നിങ്ങൾക്ക് ഇതുപോലൊന്ന് ലഭിക്കും: data.table[ WHERE, SELECT, GROUP BY ]

വലിയ അളവിലുള്ള ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്ന വേഗതയാണ് ഈ പാക്കേജിന്റെ ശക്തി.

പാണ്ടകൾ

ഔദ്യോഗിക വെബ്സൈറ്റ്: pandas.pydata.org

"പാനൽ ഡാറ്റ" എന്ന ഇക്കണോമെട്രിക് പദത്തിൽ നിന്നാണ് ലൈബ്രറിയുടെ പേര് വന്നത്, ഇത് മൾട്ടി-ഡൈമൻഷണൽ ഘടനാപരമായ വിവരങ്ങൾ വിവരിക്കാൻ ഉപയോഗിക്കുന്നു.

എഴുതിയത് pandas അമേരിക്കൻ വെസ് മക്കിന്നി ആണ്.

പൈത്തണിലെ ഡാറ്റ വിശകലനം വരുമ്പോൾ, തുല്യമാണ് pandas ഇല്ല. ഏത് ഉറവിടങ്ങളിൽ നിന്നും ഡാറ്റ ലോഡുചെയ്യുന്നത് മുതൽ ദൃശ്യവൽക്കരിക്കുന്നത് വരെ ഡാറ്റ ഉപയോഗിച്ച് ഏത് കൃത്രിമത്വവും നടത്താൻ നിങ്ങളെ അനുവദിക്കുന്ന വളരെ മൾട്ടിഫങ്ഷണൽ, ഉയർന്ന തലത്തിലുള്ള പാക്കേജ്.

അധിക പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു

ഈ ലേഖനത്തിൽ ചർച്ച ചെയ്തിരിക്കുന്ന പാക്കേജുകൾ അടിസ്ഥാന R, Python വിതരണങ്ങളിൽ ഉൾപ്പെടുത്തിയിട്ടില്ല. ഒരു ചെറിയ മുന്നറിയിപ്പ് ഉണ്ടെങ്കിലും, നിങ്ങൾ അനക്കോണ്ട ഡിസ്ട്രിബ്യൂഷൻ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെങ്കിൽ, അധികമായി ഇൻസ്റ്റാൾ ചെയ്യുക pandas ആവശ്യമില്ല.

R-ൽ പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു

നിങ്ങൾ ഒരിക്കലെങ്കിലും RStudio ഡവലപ്‌മെന്റ് എൻവയോൺമെന്റ് തുറന്നിട്ടുണ്ടെങ്കിൽ, R-ൽ ആവശ്യമായ പാക്കേജ് എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യണമെന്ന് നിങ്ങൾക്കറിയാം. പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ, സ്റ്റാൻഡേർഡ് കമാൻഡ് ഉപയോഗിക്കുക. install.packages() R-ൽ തന്നെ നേരിട്ട് പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ.

# установка пакетов
install.packages("vroom")
install.packages("readr")
install.packages("dplyr")
install.packages("data.table")

ഇൻസ്റ്റാളേഷന് ശേഷം, പാക്കേജുകൾ ബന്ധിപ്പിക്കേണ്ടതുണ്ട്, മിക്ക കേസുകളിലും കമാൻഡ് ഉപയോഗിക്കുന്നു library().

# подключение или импорт пакетов в рабочее окружение
library(vroom)
library(readr)
library(dplyr)
library(data.table)

പൈത്തണിൽ പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു

അതിനാൽ, നിങ്ങൾ ശുദ്ധമായ പൈത്തൺ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെങ്കിൽ, പിന്നെ pandas നിങ്ങൾ ഇത് സ്വമേധയാ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്. നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തെ ആശ്രയിച്ച് ഒരു കമാൻഡ് ലൈൻ അല്ലെങ്കിൽ ടെർമിനൽ തുറന്ന് ഇനിപ്പറയുന്ന കമാൻഡ് നൽകുക.

pip install pandas

തുടർന്ന് നമ്മൾ പൈത്തണിലേക്ക് മടങ്ങുകയും കമാൻഡ് ഉപയോഗിച്ച് ഇൻസ്റ്റാൾ ചെയ്ത പാക്കേജ് ഇറക്കുമതി ചെയ്യുകയും ചെയ്യുന്നു import.

import pandas as pd

ഡാറ്റ ലോഡുചെയ്യുന്നു

ഡാറ്റാ വിശകലനത്തിലെ ഏറ്റവും പ്രധാനപ്പെട്ട ഘട്ടങ്ങളിലൊന്നാണ് ഡാറ്റ മൈനിംഗ്. Python ഉം R ഉം, ആവശ്യമെങ്കിൽ, ഏത് ഉറവിടങ്ങളിൽ നിന്നും ഡാറ്റ നേടുന്നതിനുള്ള വിപുലമായ അവസരങ്ങൾ നിങ്ങൾക്ക് നൽകുന്നു: പ്രാദേശിക ഫയലുകൾ, ഇന്റർനെറ്റിൽ നിന്നുള്ള ഫയലുകൾ, വെബ്സൈറ്റുകൾ, എല്ലാത്തരം ഡാറ്റാബേസുകളും.

ലേഖനത്തിലുടനീളം ഞങ്ങൾ നിരവധി ഡാറ്റാസെറ്റുകൾ ഉപയോഗിക്കും:

1. Google Analytics-ൽ നിന്ന് രണ്ട് ഡൗൺലോഡുകൾ.
2. ടൈറ്റാനിക് പാസഞ്ചർ ഡാറ്റാസെറ്റ്.

എല്ലാ ഡാറ്റയും എന്റെ പക്കലുണ്ട് സാമൂഹികം csv, tsv ഫയലുകളുടെ രൂപത്തിൽ. ഞങ്ങൾ അവരോട് എവിടെ നിന്ന് അഭ്യർത്ഥിക്കും?

R-ലേക്ക് ഡാറ്റ ലോഡുചെയ്യുന്നു: ടൈഡൈവേഴ്സ്, വ്റൂം, റീഡർ

ഒരു ലൈബ്രറിയിലേക്ക് ഡാറ്റ ലോഡ് ചെയ്യാൻ tidyverse രണ്ട് പാക്കേജുകൾ ഉണ്ട്: vroom, readr. vroom കൂടുതൽ ആധുനികമാണ്, എന്നാൽ ഭാവിയിൽ പാക്കേജുകൾ സംയോജിപ്പിച്ചേക്കാം.

ഉദ്ധരണി ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ vroom.

vroom vs റീഡർ
എന്താണ് റിലീസ് ചെയ്യുന്നത് vroom അർത്ഥമാക്കുന്നത് readr? ഇപ്പോൾ രണ്ട് പാക്കേജുകളും വെവ്വേറെ വികസിപ്പിക്കാൻ ഞങ്ങൾ പദ്ധതിയിടുന്നു, എന്നാൽ ഭാവിയിൽ ഞങ്ങൾ പാക്കേജുകൾ ഒന്നിപ്പിക്കും. Vroom-ന്റെ അലസമായ വായനയുടെ ഒരു പോരായ്മ, ചില ഡാറ്റാ പ്രശ്‌നങ്ങൾ മുൻകൂട്ടി റിപ്പോർട്ട് ചെയ്യാൻ കഴിയില്ല എന്നതാണ്, അതിനാൽ അവയെ എങ്ങനെ ഏകീകരിക്കാം എന്നതിനെക്കുറിച്ച് കുറച്ച് ചിന്തിക്കേണ്ടതുണ്ട്.

vroom vs റീഡർ
റിലീസ് എന്താണ് അർത്ഥമാക്കുന്നത്? vroom വേണ്ടി readr? ഇപ്പോൾ രണ്ട് പാക്കേജുകളും വെവ്വേറെ വികസിപ്പിക്കാൻ ഞങ്ങൾ പദ്ധതിയിടുന്നു, പക്ഷേ ഭാവിയിൽ ഞങ്ങൾ അവ സംയോജിപ്പിച്ചേക്കാം. അലസമായ വായനയുടെ പോരായ്മകളിൽ ഒന്ന് vroom ചില ഡാറ്റ പ്രശ്നങ്ങൾ മുൻകൂട്ടി റിപ്പോർട്ട് ചെയ്യാൻ കഴിയില്ല, അതിനാൽ അവ എങ്ങനെ മികച്ച രീതിയിൽ സംയോജിപ്പിക്കാമെന്ന് നിങ്ങൾ ചിന്തിക്കേണ്ടതുണ്ട്.

ഈ ലേഖനത്തിൽ ഞങ്ങൾ രണ്ട് ഡാറ്റ ലോഡിംഗ് പാക്കേജുകളും നോക്കും:

R: vroom പാക്കേജിലേക്ക് ഡാറ്റ ലോഡുചെയ്യുന്നു

# install.packages("vroom")
library(vroom)

# Чтение данных
## vroom
ga_nov  <- vroom("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_nowember.csv")
ga_dec  <- vroom("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_december.csv")
titanic <- vroom("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/titanic.csv")

R: റീഡറിലേക്ക് ഡാറ്റ ലോഡുചെയ്യുന്നു

# install.packages("readr")
library(readr)

# Чтение данных
## readr
ga_nov  <- read_tsv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_nowember.csv")
ga_dec  <- read_tsv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_december.csv")
titanic <- read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/titanic.csv")

പാക്കേജിൽ vroom, csv / tsv ഡാറ്റ ഫോർമാറ്റ് പരിഗണിക്കാതെ തന്നെ, അതേ പേരിന്റെ പ്രവർത്തനത്തിലൂടെയാണ് ലോഡ് ചെയ്യുന്നത് vroom(), പാക്കേജിൽ readr ഓരോ ഫോർമാറ്റിനും ഞങ്ങൾ വ്യത്യസ്ത ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു read_tsv() и read_csv().

R-ലേക്ക് ഡാറ്റ ലോഡ് ചെയ്യുന്നു: data.table

В data.table ഡാറ്റ ലോഡുചെയ്യുന്നതിന് ഒരു ഫംഗ്ഷൻ ഉണ്ട് fread().

R-ലേക്ക് ഡാറ്റ ലോഡ് ചെയ്യുന്നു: data.table പാക്കേജ്

# install.packages("data.table")
library(data.table)

## data.table
ga_nov  <- fread("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_nowember.csv")
ga_dec  <- fread("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_december.csv")
titanic <- fread("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/titanic.csv")

പൈത്തണിൽ ഡാറ്റ ലോഡുചെയ്യുന്നു: പാണ്ടകൾ

നമ്മൾ R പാക്കേജുകളുമായി താരതമ്യം ചെയ്താൽ, ഈ സാഹചര്യത്തിൽ വാക്യഘടന ഏറ്റവും അടുത്താണ് pandas ആയിരിക്കും readr, കാരണം pandas എവിടെനിന്നും ഡാറ്റ അഭ്യർത്ഥിക്കാൻ കഴിയും, കൂടാതെ ഈ പാക്കേജിൽ ഫംഗ്‌ഷനുകളുടെ ഒരു കുടുംബം മുഴുവനും ഉണ്ട് read_*().

• read_csv()
• read_excel()
• read_sql()
• read_json()
• read_html()

വിവിധ ഫോർമാറ്റുകളിൽ നിന്നുള്ള ഡാറ്റ വായിക്കാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ള മറ്റ് നിരവധി ഫംഗ്ഷനുകളും. എന്നാൽ ഞങ്ങളുടെ ആവശ്യങ്ങൾക്ക് ഇത് മതിയാകും read_table() അഥവാ read_csv() വാദം ഉപയോഗിച്ച് സെപ്റ്റംബർ കോളം സെപ്പറേറ്റർ വ്യക്തമാക്കാൻ.

പൈത്തണിൽ ഡാറ്റ ലോഡുചെയ്യുന്നു: പാണ്ടകൾ

import pandas as pd

ga_nov  = pd.read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/russian_text_in_r/ga_nowember.csv", sep = "t")
ga_dec  = pd.read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/russian_text_in_r/ga_december.csv", sep = "t")
titanic = pd.read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/russian_text_in_r/titanic.csv")

ഡാറ്റ ഫ്രെയിമുകൾ സൃഷ്ടിക്കുന്നു

മേശ ടൈറ്റാനിക്, ഞങ്ങൾ ലോഡ് ചെയ്ത, ഒരു ഫീൽഡ് ഉണ്ട് സെക്സ്, ഇത് യാത്രക്കാരന്റെ ലിംഗ ഐഡന്റിഫയർ സംഭരിക്കുന്നു.

എന്നാൽ യാത്രക്കാരുടെ ലിംഗഭേദം അനുസരിച്ച് ഡാറ്റയുടെ കൂടുതൽ സൗകര്യപ്രദമായ അവതരണത്തിന്, നിങ്ങൾ ലിംഗ കോഡിനേക്കാൾ പേര് ഉപയോഗിക്കണം.

ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ ഒരു ചെറിയ ഡയറക്ടറി സൃഷ്ടിക്കും, അതിൽ യഥാക്രമം 2 നിരകളും (കോഡും ലിംഗ നാമവും) 2 വരികളും മാത്രമുള്ള ഒരു പട്ടിക.

R: tidyverse, dplyr-ൽ ഒരു ഡാറ്റഫ്രെയിം സൃഷ്ടിക്കുന്നു

ചുവടെയുള്ള കോഡ് ഉദാഹരണത്തിൽ, ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഞങ്ങൾ ആവശ്യമുള്ള ഡാറ്റാഫ്രെയിം സൃഷ്ടിക്കുന്നു tibble() .

R: dplyr-ൽ ഒരു ഡാറ്റാഫ്രെയിം ഉണ്ടാക്കുന്നു

## dplyr
### создаём справочник
gender <- tibble(id = c(1, 2),
                 gender = c("female", "male"))

R-ൽ ഒരു ഡാറ്റഫ്രെയിം സൃഷ്ടിക്കുന്നു: data.table

R-ൽ ഒരു ഡാറ്റഫ്രെയിം സൃഷ്ടിക്കുന്നു: data.table

## data.table
### создаём справочник
gender <- data.table(id = c(1, 2),
                    gender = c("female", "male"))

പൈത്തണിൽ ഒരു ഡാറ്റഫ്രെയിം സൃഷ്ടിക്കുന്നു: പാണ്ടകൾ

В pandas ഫ്രെയിമുകളുടെ നിർമ്മാണം പല ഘട്ടങ്ങളിലായാണ് നടത്തുന്നത്, ആദ്യം ഞങ്ങൾ ഒരു നിഘണ്ടു സൃഷ്ടിക്കുന്നു, തുടർന്ന് ഞങ്ങൾ നിഘണ്ടുവിനെ ഒരു ഡാറ്റാഫ്രെയിമാക്കി മാറ്റുന്നു.

പൈത്തണിൽ ഒരു ഡാറ്റഫ്രെയിം സൃഷ്ടിക്കുന്നു: പാണ്ടകൾ

# создаём дата фрейм
gender_dict = {'id': [1, 2],
               'gender': ["female", "male"]}
# преобразуем словарь в датафрейм
gender = pd.DataFrame.from_dict(gender_dict)

നിരകൾ തിരഞ്ഞെടുക്കുന്നു

നിങ്ങൾ പ്രവർത്തിക്കുന്ന ടേബിളുകളിൽ ഡസൻ അല്ലെങ്കിൽ നൂറുകണക്കിന് കോളങ്ങൾ ഡാറ്റ അടങ്ങിയിരിക്കാം. എന്നാൽ വിശകലനം നടത്താൻ, ഒരു ചട്ടം പോലെ, ഉറവിട പട്ടികയിൽ ലഭ്യമായ എല്ലാ നിരകളും നിങ്ങൾക്ക് ആവശ്യമില്ല.

അതിനാൽ, സോഴ്‌സ് ടേബിൾ ഉപയോഗിച്ച് നിങ്ങൾ ചെയ്യുന്ന ആദ്യ പ്രവർത്തനങ്ങളിലൊന്ന് അനാവശ്യമായ വിവരങ്ങൾ മായ്‌ക്കുകയും ഈ വിവരങ്ങൾ ഉൾക്കൊള്ളുന്ന മെമ്മറി സ്വതന്ത്രമാക്കുകയും ചെയ്യുക എന്നതാണ്.

R ലെ നിരകൾ തിരഞ്ഞെടുക്കുന്നു: tidyverse, dplyr

വാക്യഘടന dplyr SQL അന്വേഷണ ഭാഷയുമായി വളരെ സാമ്യമുള്ളതാണ്, നിങ്ങൾക്ക് ഇത് പരിചിതമാണെങ്കിൽ, ഈ പാക്കേജ് നിങ്ങൾക്ക് വേഗത്തിൽ മാസ്റ്റർ ചെയ്യും.

നിരകൾ തിരഞ്ഞെടുക്കുന്നതിന്, ഫംഗ്ഷൻ ഉപയോഗിക്കുക select().

ഇനിപ്പറയുന്ന രീതികളിൽ നിങ്ങൾക്ക് കോളങ്ങൾ തിരഞ്ഞെടുക്കാൻ കഴിയുന്ന കോഡിന്റെ ഉദാഹരണങ്ങൾ ചുവടെയുണ്ട്:

• ആവശ്യമായ നിരകളുടെ പേരുകൾ ലിസ്റ്റുചെയ്യുന്നു
• സാധാരണ പദപ്രയോഗങ്ങൾ ഉപയോഗിച്ച് നിരയുടെ പേരുകൾ കാണുക
• ഡാറ്റ തരം അല്ലെങ്കിൽ കോളത്തിൽ അടങ്ങിയിരിക്കുന്ന ഡാറ്റയുടെ മറ്റേതെങ്കിലും പ്രോപ്പർട്ടി പ്രകാരം

R: dplyr-ൽ നിരകൾ തിരഞ്ഞെടുക്കുന്നു

# Выбор нужных столбцов
## dplyr
### выбрать по названию столбцов
select(ga_nov, date, source, sessions)
### исключь по названию столбцов
select(ga_nov, -medium, -bounces)
### выбрать по регулярному выражению, стобцы имена которых заканчиваются на s
select(ga_nov, matches("s$"))
### выбрать по условию, выбираем только целочисленные столбцы
select_if(ga_nov, is.integer)

R ലെ നിരകൾ തിരഞ്ഞെടുക്കുന്നു: data.table

ഇതേ പ്രവർത്തനങ്ങൾ data.table കുറച്ച് വ്യത്യസ്തമായി നടപ്പിലാക്കുന്നു, ലേഖനത്തിന്റെ തുടക്കത്തിൽ ചതുര ബ്രാക്കറ്റുകൾക്കുള്ളിലെ ആർഗ്യുമെന്റുകൾ എന്താണെന്ന് ഞാൻ ഒരു വിവരണം നൽകി data.table.

DT[i,j,by]

എവിടെയാണ്:
ഞാൻ - എവിടെ, അതായത്. വരികൾ വഴി ഫിൽട്ടറിംഗ്
j - തിരഞ്ഞെടുക്കുക|അപ്ഡേറ്റ്|ചെയ്യുക, അതായത്. നിരകൾ തിരഞ്ഞെടുത്ത് അവയെ പരിവർത്തനം ചെയ്യുന്നു
പ്രകാരം - ഡാറ്റ ഗ്രൂപ്പിംഗ്

R ലെ നിരകൾ തിരഞ്ഞെടുക്കുന്നു: data.table

## data.table
### выбрать по названию столбцов
ga_nov[ , .(date, source, sessions) ]
### исключь по названию столбцов
ga_nov[ , .SD, .SDcols = ! names(ga_nov) %like% "medium|bounces" ]
### выбрать по регулярному выражению
ga_nov[, .SD, .SDcols = patterns("s$")]

വേരിയബിൾ .SD എല്ലാ കോളങ്ങളും ആക്സസ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു, കൂടാതെ .SDcols നിങ്ങൾക്ക് ആവശ്യമുള്ള നിരകളുടെ പേരുകൾ ഫിൽട്ടർ ചെയ്യുന്നതിന് റെഗുലർ എക്സ്പ്രഷനുകൾ അല്ലെങ്കിൽ മറ്റ് ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച് ആവശ്യമായ നിരകൾ ഫിൽട്ടർ ചെയ്യുക.

പൈത്തണിലെ നിരകൾ തിരഞ്ഞെടുക്കുന്നു, പാണ്ടകൾ

പേര് പ്രകാരം കോളങ്ങൾ തിരഞ്ഞെടുക്കാൻ pandas അവരുടെ പേരുകളുടെ ഒരു ലിസ്റ്റ് നൽകിയാൽ മതിയാകും. സാധാരണ എക്‌സ്‌പ്രഷനുകൾ ഉപയോഗിച്ച് കോളങ്ങൾ തിരഞ്ഞെടുക്കാനോ ഒഴിവാക്കാനോ, നിങ്ങൾ ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കേണ്ടതുണ്ട് drop() и filter(), വാദം അക്ഷം = 1, നിരകളേക്കാൾ നിരകൾ പ്രോസസ്സ് ചെയ്യേണ്ടത് ആവശ്യമാണെന്ന് നിങ്ങൾ സൂചിപ്പിക്കുന്നു.

ഡാറ്റ തരം അനുസരിച്ച് ഒരു ഫീൽഡ് തിരഞ്ഞെടുക്കാൻ, ഫംഗ്ഷൻ ഉപയോഗിക്കുക select_dtypes(), ഒപ്പം വാദപ്രതിവാദങ്ങളിലേക്കും ഉൾപ്പെടുന്നു അഥവാ പെടുത്തിയിട്ടില്ല നിങ്ങൾ തിരഞ്ഞെടുക്കേണ്ട ഫീൽഡുകളുമായി ബന്ധപ്പെട്ട ഡാറ്റ തരങ്ങളുടെ ഒരു ലിസ്റ്റ് കൈമാറുക.

പൈത്തണിലെ നിരകൾ തിരഞ്ഞെടുക്കുന്നു: പാണ്ടകൾ

# Выбор полей по названию
ga_nov[['date', 'source', 'sessions']]
# Исключить по названию
ga_nov.drop(['medium', 'bounces'], axis=1)
# Выбрать по регулярному выражению
ga_nov.filter(regex="s$", axis=1)
# Выбрать числовые поля
ga_nov.select_dtypes(include=['number'])
# Выбрать текстовые поля
ga_nov.select_dtypes(include=['object'])

ഫിൽട്ടറിംഗ് വരികൾ

ഉദാഹരണത്തിന്, ഉറവിട പട്ടികയിൽ നിരവധി വർഷത്തെ ഡാറ്റ അടങ്ങിയിരിക്കാം, എന്നാൽ നിങ്ങൾ കഴിഞ്ഞ മാസം മാത്രം വിശകലനം ചെയ്യേണ്ടതുണ്ട്. വീണ്ടും, അധിക ലൈനുകൾ ഡാറ്റ പ്രോസസ്സിംഗ് പ്രക്രിയയെ മന്ദഗതിയിലാക്കുകയും പിസി മെമ്മറി തടസ്സപ്പെടുത്തുകയും ചെയ്യും.

R-ൽ വരികൾ ഫിൽട്ടർ ചെയ്യുന്നു: tydyverse, dplyr

В dplyr വരികൾ ഫിൽട്ടർ ചെയ്യാൻ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു filter(). ഇത് ആദ്യത്തെ ആർഗ്യുമെന്റായി ഒരു ഡാറ്റഫ്രെയിം എടുക്കുന്നു, തുടർന്ന് നിങ്ങൾ ഫിൽട്ടറിംഗ് വ്യവസ്ഥകൾ ലിസ്റ്റ് ചെയ്യുന്നു.

ഒരു പട്ടിക ഫിൽട്ടർ ചെയ്യുന്നതിന് ലോജിക്കൽ എക്സ്പ്രഷനുകൾ എഴുതുമ്പോൾ, ഈ സാഹചര്യത്തിൽ, ഉദ്ധരണികളില്ലാതെയും പട്ടികയുടെ പേര് പ്രഖ്യാപിക്കാതെയും നിരയുടെ പേരുകൾ വ്യക്തമാക്കുക.

ഫിൽട്ടർ ചെയ്യുന്നതിന് ഒന്നിലധികം ലോജിക്കൽ എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കുമ്പോൾ, ഇനിപ്പറയുന്ന ഓപ്പറേറ്റർമാരെ ഉപയോഗിക്കുക:

• & അല്ലെങ്കിൽ കോമ - ലോജിക്കൽ AND
• | - ലോജിക്കൽ അല്ലെങ്കിൽ

R: dplyr-ൽ വരികൾ ഫിൽട്ടർ ചെയ്യുന്നു

# фильтрация строк
## dplyr
### фильтрация строк по одному условию
filter(ga_nov, source == "google")
### фильтр по двум условиям соединённым логическим и
filter(ga_nov, source == "google" & sessions >= 10)
### фильтр по двум условиям соединённым логическим или
filter(ga_nov, source == "google" | sessions >= 10)

R-ൽ വരികൾ ഫിൽട്ടർ ചെയ്യുന്നു: data.table

ഞാൻ ഇതിനകം മുകളിൽ എഴുതിയതുപോലെ, ഇൻ data.table ഡാറ്റാ പരിവർത്തന വാക്യഘടന ചതുര ബ്രാക്കറ്റുകളിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.

DT[i,j,by]

എവിടെയാണ്:
ഞാൻ - എവിടെ, അതായത്. വരികൾ വഴി ഫിൽട്ടറിംഗ്
j - തിരഞ്ഞെടുക്കുക|അപ്ഡേറ്റ്|ചെയ്യുക, അതായത്. നിരകൾ തിരഞ്ഞെടുത്ത് അവയെ പരിവർത്തനം ചെയ്യുന്നു
പ്രകാരം - ഡാറ്റ ഗ്രൂപ്പിംഗ്

വരികൾ ഫിൽട്ടർ ചെയ്യാൻ ആർഗ്യുമെന്റ് ഉപയോഗിക്കുന്നു i, സ്ക്വയർ ബ്രാക്കറ്റുകളിൽ ഒന്നാം സ്ഥാനമുള്ളത്.

ഉദ്ധരണി ചിഹ്നങ്ങൾ ഇല്ലാതെയും പട്ടികയുടെ പേര് വ്യക്തമാക്കാതെയും ലോജിക്കൽ എക്സ്പ്രഷനുകളിൽ നിരകൾ ആക്സസ് ചെയ്യപ്പെടുന്നു.

ലോജിക്കൽ എക്സ്പ്രഷനുകൾ പരസ്പരം ബന്ധപ്പെട്ടിരിക്കുന്നതുപോലെ തന്നെ dplyr ഓപ്പറേറ്റർമാർ വഴി.

R-ൽ വരികൾ ഫിൽട്ടർ ചെയ്യുന്നു: data.table

## data.table
### фильтрация строк по одному условию
ga_nov[source == "google"]
### фильтр по двум условиям соединённым логическим и
ga_nov[source == "google" & sessions >= 10]
### фильтр по двум условиям соединённым логическим или
ga_nov[source == "google" | sessions >= 10]

പൈത്തണിലെ സ്ട്രിംഗുകൾ ഫിൽട്ടറിംഗ്: പാണ്ടകൾ

വരികൾ അനുസരിച്ച് ഫിൽട്ടർ ചെയ്യുക pandas ഫിൽട്ടർ ചെയ്യുന്നതിന് സമാനമാണ് data.table, സ്ക്വയർ ബ്രാക്കറ്റുകളിൽ ചെയ്യുന്നു.

ഈ സാഹചര്യത്തിൽ, ഡാറ്റാഫ്രെയിമിന്റെ പേര് സൂചിപ്പിച്ചുകൊണ്ട് നിരകളിലേക്കുള്ള പ്രവേശനം അനിവാര്യമാണ്; തുടർന്ന് നിരയുടെ പേര് ചതുര ബ്രാക്കറ്റുകളിലെ ഉദ്ധരണി ചിഹ്നങ്ങളിലും സൂചിപ്പിക്കാം (ഉദാഹരണം df['col_name']), അല്ലെങ്കിൽ കാലയളവിന് ശേഷം ഉദ്ധരണികൾ ഇല്ലാതെ (ഉദാഹരണം df.col_name).

നിങ്ങൾക്ക് ഒരു ഡാറ്റാഫ്രെയിം നിരവധി വ്യവസ്ഥകൾ ഉപയോഗിച്ച് ഫിൽട്ടർ ചെയ്യണമെങ്കിൽ, ഓരോ വ്യവസ്ഥയും പരാൻതീസിസിൽ സ്ഥാപിക്കണം. ലോജിക്കൽ അവസ്ഥകൾ ഓപ്പറേറ്റർമാർ പരസ്പരം ബന്ധിപ്പിച്ചിരിക്കുന്നു & и |.

പൈത്തണിലെ സ്ട്രിംഗുകൾ ഫിൽട്ടറിംഗ്: പാണ്ടകൾ

# Фильтрация строк таблицы
### фильтрация строк по одному условию
ga_nov[ ga_nov['source'] == "google" ]
### фильтр по двум условиям соединённым логическим и
ga_nov[(ga_nov['source'] == "google") & (ga_nov['sessions'] >= 10)]
### фильтр по двум условиям соединённым логическим или
ga_nov[(ga_nov['source'] == "google") | (ga_nov['sessions'] >= 10)]

ഡാറ്റയുടെ ഗ്രൂപ്പിംഗും കൂട്ടിച്ചേർക്കലും

ഡാറ്റാ വിശകലനത്തിൽ ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന പ്രവർത്തനങ്ങളിലൊന്ന് ഗ്രൂപ്പിംഗും അഗ്രഗേഷനുമാണ്.

ഈ പ്രവർത്തനങ്ങൾ നടത്തുന്നതിനുള്ള വാക്യഘടന ഞങ്ങൾ അവലോകനം ചെയ്യുന്ന എല്ലാ പാക്കേജുകളിലും ചിതറിക്കിടക്കുന്നു.

ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ ഒരു ഡാറ്റഫ്രെയിം ഉദാഹരണമായി എടുക്കും ടൈറ്റാനിക്, ക്യാബിൻ ക്ലാസ് അനുസരിച്ച് ടിക്കറ്റുകളുടെ എണ്ണവും ശരാശരി വിലയും കണക്കാക്കുക.

R: tidyverse, dplyr എന്നതിലെ ഡാറ്റയുടെ ഗ്രൂപ്പിംഗും കൂട്ടിച്ചേർക്കലും

В dplyr ഫംഗ്ഷൻ ഗ്രൂപ്പിംഗിനായി ഉപയോഗിക്കുന്നു group_by(), ഒപ്പം കൂട്ടിച്ചേർക്കലിനും summarise(). സത്യത്തിൽ, dplyr ഫംഗ്‌ഷനുകളുടെ ഒരു കുടുംബം മുഴുവൻ ഉണ്ട് summarise_*(), എന്നാൽ ഈ ലേഖനത്തിന്റെ ഉദ്ദേശ്യം അടിസ്ഥാന വാക്യഘടന താരതമ്യം ചെയ്യുക എന്നതാണ്, അതിനാൽ ഞങ്ങൾ അത്തരം കാട്ടിലേക്ക് പോകില്ല.

അടിസ്ഥാന അഗ്രഗേഷൻ പ്രവർത്തനങ്ങൾ:

• sum() - സംഗ്രഹം
• min() / max() - ഏറ്റവും കുറഞ്ഞതും കൂടിയതുമായ മൂല്യം
• mean() - ശരാശരി
• median() - ഇടത്തരം
• length() - അളവ്

R: dplyr-ൽ ഗ്രൂപ്പിംഗും അഗ്രഗേഷനും

## dplyr
### группировка и агрегация строк
group_by(titanic, Pclass) %>%
  summarise(passangers = length(PassengerId),
            avg_price  = mean(Fare))

പ്രവർത്തിക്കാൻ group_by() ആദ്യത്തെ വാദമായി ഞങ്ങൾ മേശ കടന്നു ടൈറ്റാനിക്, തുടർന്ന് ഫീൽഡ് സൂചിപ്പിച്ചു പി ക്ലാസ്, അതിലൂടെ ഞങ്ങൾ ഞങ്ങളുടെ ടേബിൾ ഗ്രൂപ്പുചെയ്യും. ഓപ്പറേറ്റർ ഉപയോഗിച്ചുള്ള ഈ പ്രവർത്തനത്തിന്റെ ഫലം %>% ഫംഗ്‌ഷനിലേക്കുള്ള ആദ്യ ആർഗ്യുമെന്റായി പാസ്സായി summarise(), കൂടാതെ 2 ഫീൽഡുകൾ കൂടി ചേർത്തു: യാത്രക്കാർ и ശരാശരി_വില. ആദ്യത്തേതിൽ, ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു length() ടിക്കറ്റുകളുടെ എണ്ണം കണക്കാക്കി, രണ്ടാമത്തേതിൽ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു mean() ശരാശരി ടിക്കറ്റ് നിരക്ക് ലഭിച്ചു.

R-ലെ ഡാറ്റയുടെ ഗ്രൂപ്പിംഗും കൂട്ടിച്ചേർക്കലും: data.table

В data.table സംഗ്രഹത്തിനായി വാദം ഉപയോഗിക്കുന്നു j സ്ക്വയർ ബ്രാക്കറ്റുകളിലും ഗ്രൂപ്പിംഗിനും രണ്ടാം സ്ഥാനമുണ്ട് by അഥവാ keyby, അവയ്ക്ക് മൂന്നാം സ്ഥാനമുണ്ട്.

ഈ കേസിൽ അഗ്രഗേഷൻ ഫംഗ്‌ഷനുകളുടെ ലിസ്റ്റ് വിവരിച്ചതിന് സമാനമാണ് dplyr, കാരണം ഇവ അടിസ്ഥാന R വാക്യഘടനയിൽ നിന്നുള്ള പ്രവർത്തനങ്ങളാണ്.

R-ൽ ഗ്രൂപ്പിംഗും കൂട്ടിച്ചേർക്കലും: data.table

## data.table
### фильтрация строк по одному условию
titanic[, .(passangers = length(PassengerId),
            avg_price  = mean(Fare)),
        by = Pclass]

പൈത്തണിലെ ഡാറ്റയുടെ ഗ്രൂപ്പിംഗും കൂട്ടിച്ചേർക്കലും: പാണ്ടകൾ

ഗ്രൂപ്പുചെയ്യുന്നു pandas സമാനമായ dplyr, എന്നാൽ സമാഹരണം സമാനമല്ല dplyr ഒരിക്കലുമില്ല data.table.

ഗ്രൂപ്പുചെയ്യാൻ, രീതി ഉപയോഗിക്കുക groupby(), ഡാറ്റഫ്രെയിം ഗ്രൂപ്പുചെയ്യുന്ന നിരകളുടെ ഒരു ലിസ്റ്റ് നിങ്ങൾ കൈമാറേണ്ടതുണ്ട്.

സമാഹരണത്തിനായി നിങ്ങൾക്ക് രീതി ഉപയോഗിക്കാം agg()ഒരു നിഘണ്ടു സ്വീകരിക്കുന്നു. നിങ്ങൾ അഗ്രഗേഷൻ ഫംഗ്‌ഷനുകൾ പ്രയോഗിക്കുന്ന നിരകളാണ് നിഘണ്ടു കീകൾ, മൂല്യങ്ങൾ അഗ്രഗേഷൻ ഫംഗ്‌ഷനുകളുടെ പേരുകളാണ്.

അഗ്രഗേഷൻ പ്രവർത്തനങ്ങൾ:

• sum() - സംഗ്രഹം
• min() / max() - ഏറ്റവും കുറഞ്ഞതും കൂടിയതുമായ മൂല്യം
• mean() - ശരാശരി
• median() - ഇടത്തരം
• count() - അളവ്

ഫംഗ്ഷൻ reset_index() ചുവടെയുള്ള ഉദാഹരണത്തിൽ നെസ്റ്റഡ് സൂചികകൾ പുനഃസജ്ജമാക്കാൻ ഇത് ഉപയോഗിക്കുന്നു pandas ഡാറ്റ സമാഹരണത്തിന് ശേഷമുള്ള സ്ഥിരസ്ഥിതികൾ.

Символ അടുത്ത വരിയിലേക്ക് നീങ്ങാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

പൈത്തണിലെ ഗ്രൂപ്പിംഗും അഗ്രഗേഷനും: പാണ്ടകൾ

# группировка и агрегация данных
titanic.groupby(["Pclass"]).
    agg({'PassengerId': 'count', 'Fare': 'mean'}).
        reset_index()

പട്ടികകളുടെ ലംബമായ കൂട്ടിച്ചേർക്കൽ

ഒരേ ഘടനയിലുള്ള രണ്ടോ അതിലധികമോ പട്ടികകൾ നിങ്ങൾ ചേരുന്ന ഒരു പ്രവർത്തനം. ഞങ്ങൾ ലോഡ് ചെയ്ത ഡാറ്റയിൽ പട്ടികകൾ അടങ്ങിയിരിക്കുന്നു ga_nov и ga_dec. ഈ പട്ടികകൾ ഘടനയിൽ സമാനമാണ്, അതായത്. ഒരേ നിരകളും ഈ കോളങ്ങളിലെ ഡാറ്റ തരങ്ങളും ഉണ്ട്.

നവംബർ, ഡിസംബർ മാസങ്ങളിലെ Google Analytics-ൽ നിന്നുള്ള അപ്‌ലോഡാണിത്, ഈ വിഭാഗത്തിൽ ഞങ്ങൾ ഈ ഡാറ്റ ഒരു പട്ടികയിലേക്ക് സംയോജിപ്പിക്കും.

R-ൽ ലംബമായി ചേരുന്ന പട്ടികകൾ: tidyverse, dplyr

В dplyr ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് 2 പട്ടികകൾ ഒന്നായി സംയോജിപ്പിക്കാം bind_rows(), ടേബിളുകൾ അതിന്റെ ആർഗ്യുമെന്റുകളായി കടന്നുപോകുന്നു.

R: dplyr-ൽ വരികൾ ഫിൽട്ടർ ചെയ്യുന്നു

# Вертикальное объединение таблиц
## dplyr
bind_rows(ga_nov, ga_dec)

R-ൽ പട്ടികകൾ ലംബമായി ചേരുന്നു: data.table

ഇത് സങ്കീർണ്ണമായ ഒന്നുമല്ല, നമുക്ക് ഉപയോഗിക്കാം rbind().

R-ൽ വരികൾ ഫിൽട്ടർ ചെയ്യുന്നു: data.table

## data.table
rbind(ga_nov, ga_dec)

പൈത്തണിൽ ലംബമായി ചേരുന്ന പട്ടികകൾ: പാണ്ടകൾ

В pandas ടേബിളിൽ ചേരാൻ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു concat(), അവ സംയോജിപ്പിക്കുന്നതിന് നിങ്ങൾ ഫ്രെയിമുകളുടെ ഒരു ലിസ്റ്റ് കൈമാറേണ്ടതുണ്ട്.

പൈത്തണിലെ സ്ട്രിംഗുകൾ ഫിൽട്ടറിംഗ്: പാണ്ടകൾ

# вертикальное объединение таблиц
pd.concat([ga_nov, ga_dec])

പട്ടികകളുടെ തിരശ്ചീന ജോയിൻ

രണ്ടാമത്തേതിൽ നിന്നുള്ള നിരകൾ കീ ഉപയോഗിച്ച് ആദ്യ പട്ടികയിലേക്ക് ചേർക്കുന്ന ഒരു പ്രവർത്തനം. ചില റഫറൻസ് ഡാറ്റ (ഉദാഹരണത്തിന്, ഒരു ഉൽപ്പന്നത്തിന്റെ വില) ഉപയോഗിച്ച് ഒരു വസ്തുത പട്ടിക (ഉദാഹരണത്തിന്, വിൽപ്പന ഡാറ്റയുള്ള ഒരു പട്ടിക) സമ്പുഷ്ടമാക്കുമ്പോൾ ഇത് പലപ്പോഴും ഉപയോഗിക്കാറുണ്ട്.

നിരവധി തരം ചേരലുകൾ ഉണ്ട്:

മുമ്പ് ലോഡ് ചെയ്ത പട്ടികയിൽ ടൈറ്റാനിക് ഞങ്ങൾക്ക് ഒരു കോളം ഉണ്ട് സെക്സ്, ഇത് യാത്രക്കാരന്റെ ലിംഗ കോഡുമായി യോജിക്കുന്നു:

1 - സ്ത്രീ
2 - പുരുഷൻ

കൂടാതെ, ഞങ്ങൾ ഒരു പട്ടിക സൃഷ്ടിച്ചു - ഒരു റഫറൻസ് പുസ്തകം ലിംഗഭേദം. യാത്രക്കാരുടെ ലിംഗഭേദത്തെക്കുറിച്ചുള്ള ഡാറ്റയുടെ കൂടുതൽ സൗകര്യപ്രദമായ അവതരണത്തിന്, ഞങ്ങൾ ഡയറക്ടറിയിൽ നിന്ന് ലിംഗത്തിന്റെ പേര് ചേർക്കേണ്ടതുണ്ട് ലിംഗഭേദം മേശയിലേക്ക് ടൈറ്റാനിക്.

തിരശ്ചീനമായ പട്ടിക R-ൽ ചേരുന്നു: tidyverse, dplyr

В dplyr തിരശ്ചീനമായി ചേരുന്നതിനുള്ള ഫംഗ്‌ഷനുകളുടെ ഒരു കുടുംബം മുഴുവനും ഉണ്ട്:

• inner_join()
• left_join()
• right_join()
• full_join()
• semi_join()
• nest_join()
• anti_join()

എന്റെ പരിശീലനത്തിൽ ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്നത് left_join().

ആദ്യത്തെ രണ്ട് ആർഗ്യുമെന്റുകൾ പോലെ, മുകളിൽ ലിസ്റ്റ് ചെയ്തിരിക്കുന്ന ഫംഗ്‌ഷനുകൾ ചേരുന്നതിന് രണ്ട് ടേബിളുകൾ എടുക്കുന്നു, കൂടാതെ മൂന്നാമത്തെ ആർഗ്യുമെന്റായി by ചേരുന്നതിനുള്ള നിരകൾ നിങ്ങൾ വ്യക്തമാക്കണം.

R: dplyr-ൽ തിരശ്ചീന പട്ടിക ചേരുക

# объединяем таблицы
left_join(titanic, gender,
          by = c("Sex" = "id"))

R-ലെ പട്ടികകളുടെ തിരശ്ചീന ജോയിൻ: data.table

В data.table ഫംഗ്ഷൻ ഉപയോഗിച്ച് കീ ഉപയോഗിച്ച് നിങ്ങൾ പട്ടികകളിൽ ചേരേണ്ടതുണ്ട് merge().

data.table-ൽ ലയിപ്പിക്കാനുള്ള () ഫംഗ്‌ഷനുള്ള ആർഗ്യുമെന്റുകൾ

• x, y - ചേരുന്നതിനുള്ള പട്ടികകൾ
• by — രണ്ട് പട്ടികകളിലും ഒരേ പേരുണ്ടെങ്കിൽ ചേരുന്നതിനുള്ള താക്കോലാണ് കോളം
• by.x, by.y — പട്ടികകളിൽ വ്യത്യസ്ത പേരുകളുണ്ടെങ്കിൽ കോളം പേരുകൾ ലയിപ്പിക്കും
• all, all.x, all.y — ജോയിൻ ടൈപ്പ്, എല്ലാം രണ്ട് ടേബിളുകളിൽ നിന്നും എല്ലാ വരികളും തിരികെ നൽകും, all.x ലെഫ്റ്റ് ജോയിൻ ഓപ്പറേഷനുമായി യോജിക്കുന്നു (ആദ്യത്തെ പട്ടികയുടെ എല്ലാ വരികളും വിടും), all.y — റൈറ്റ് ജോയിൻ ഓപ്പറേഷൻ (രണ്ടാമത്തെ പട്ടികയുടെ എല്ലാ വരികളും ഉപേക്ഷിക്കും).

R-ലെ പട്ടികകളുടെ തിരശ്ചീന ജോയിൻ: data.table

# объединяем таблицы
merge(titanic, gender, by.x = "Sex", by.y = "id", all.x = T)

പൈത്തണിൽ തിരശ്ചീന പട്ടിക ചേരുന്നു: പാണ്ടകൾ

അതുപോലെ അകത്തും data.tableഅകത്ത് pandas ടേബിളിൽ ചേരാൻ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു merge().

പാണ്ടകളിൽ ലയനം() ഫംഗ്‌ഷന്റെ ആർഗ്യുമെന്റുകൾ

• എങ്ങനെ - കണക്ഷൻ തരം: ഇടത്, വലത്, പുറം, അകം
• on — രണ്ട് പട്ടികകളിലും ഒരേ പേരുണ്ടെങ്കിൽ അത് ഒരു കീയാണ് കോളം
• left_on, right_on — പട്ടികകളിൽ വ്യത്യസ്ത പേരുകളുണ്ടെങ്കിൽ കീ കോളങ്ങളുടെ പേരുകൾ

പൈത്തണിൽ തിരശ്ചീന പട്ടിക ചേരുന്നു: പാണ്ടകൾ

# объединяем по ключу
titanic.merge(gender, how = "left", left_on = "Sex", right_on = "id")

അടിസ്ഥാന വിൻഡോ പ്രവർത്തനങ്ങളും കണക്കാക്കിയ നിരകളും

വിൻഡോ ഫംഗ്‌ഷനുകൾ അഗ്രഗേഷൻ ഫംഗ്‌ഷനുകൾക്ക് സമാനമാണ്, മാത്രമല്ല ഡാറ്റ വിശകലനത്തിലും പലപ്പോഴും ഉപയോഗിക്കാറുണ്ട്. എന്നാൽ അഗ്രഗേഷൻ ഫംഗ്‌ഷനുകളിൽ നിന്ന് വ്യത്യസ്തമായി, വിൻഡോ ഫംഗ്‌ഷനുകൾ ഔട്ട്‌ഗോയിംഗ് ഡാറ്റാഫ്രെയിമിന്റെ വരികളുടെ എണ്ണം മാറ്റില്ല.

അടിസ്ഥാനപരമായി, വിൻഡോ ഫംഗ്ഷൻ ഉപയോഗിച്ച്, ഞങ്ങൾ ഇൻകമിംഗ് ഡാറ്റാഫ്രെയിമിനെ ചില മാനദണ്ഡങ്ങൾക്കനുസരിച്ച് ഭാഗങ്ങളായി വിഭജിക്കുന്നു, അതായത്. ഒരു ഫീൽഡിന്റെ മൂല്യം അല്ലെങ്കിൽ നിരവധി ഫീൽഡുകൾ പ്രകാരം. ഓരോ വിൻഡോയിലും ഞങ്ങൾ ഗണിത പ്രവർത്തനങ്ങൾ നടത്തുന്നു. ഈ പ്രവർത്തനങ്ങളുടെ ഫലം ഓരോ വരിയിലും തിരികെ നൽകും, അതായത്. പട്ടികയിലെ മൊത്തം വരികളുടെ എണ്ണം മാറ്റാതെ.

ഉദാഹരണത്തിന്, നമുക്ക് പട്ടിക എടുക്കാം ടൈറ്റാനിക്. ഓരോ ടിക്കറ്റിനും അതിന്റെ ക്യാബിൻ ക്ലാസിനുള്ളിൽ എത്ര ശതമാനം വിലയുണ്ടെന്ന് നമുക്ക് കണക്കാക്കാം.

ഇത് ചെയ്യുന്നതിന്, ഓരോ ലൈനിലും ഈ ലൈനിലെ ടിക്കറ്റ് ഉൾപ്പെടുന്ന നിലവിലെ ക്യാബിൻ ക്ലാസിന്റെ ടിക്കറ്റിന്റെ ആകെ വില നമുക്ക് ലഭിക്കേണ്ടതുണ്ട്, തുടർന്ന് ഓരോ ടിക്കറ്റിന്റെയും വില അതേ ക്യാബിൻ ക്ലാസിലെ എല്ലാ ടിക്കറ്റുകളുടെയും ആകെ വില കൊണ്ട് ഹരിക്കുക .

R-ൽ വിൻഡോ ഫംഗ്‌ഷനുകൾ: tidyverse, dplyr

പുതിയ നിരകൾ ചേർക്കുന്നതിന്, വരി ഗ്രൂപ്പിംഗ് ഉപയോഗിക്കാതെ, ഇൻ dplyr പ്രവർത്തനം നൽകുന്നു mutate().

ഫീൽഡ് അനുസരിച്ച് ഡാറ്റ ഗ്രൂപ്പുചെയ്യുന്നതിലൂടെ മുകളിൽ വിവരിച്ച പ്രശ്നം നിങ്ങൾക്ക് പരിഹരിക്കാനാകും പി ക്ലാസ് ഒരു പുതിയ കോളത്തിൽ ഫീൽഡ് സംഗ്രഹിക്കുകയും ചെയ്യുന്നു കൂലി. അടുത്തതായി, പട്ടിക അൺഗ്രൂപ്പ് ചെയ്ത് ഫീൽഡ് മൂല്യങ്ങൾ വിഭജിക്കുക കൂലി മുമ്പത്തെ ഘട്ടത്തിൽ എന്താണ് സംഭവിച്ചതെന്ന്.

R: dplyr-ൽ വിൻഡോ പ്രവർത്തനങ്ങൾ

group_by(titanic, Pclass) %>%
  mutate(Pclass_cost = sum(Fare)) %>%
  ungroup() %>%
  mutate(ticket_fare_rate = Fare / Pclass_cost)

R ലെ വിൻഡോ ഫംഗ്‌ഷനുകൾ: data.table

പരിഹാര അൽഗോരിതം ഉള്ളതുപോലെ തന്നെ തുടരുന്നു dplyr, ഞങ്ങൾ ഫീൽഡ് പ്രകാരം വിൻഡോകളായി പട്ടിക വിഭജിക്കേണ്ടതുണ്ട് പി ക്ലാസ്. ഓരോ വരിയുമായി ബന്ധപ്പെട്ട ഗ്രൂപ്പിനുള്ള തുക ഒരു പുതിയ കോളത്തിൽ ഔട്ട്പുട്ട് ചെയ്യുക, കൂടാതെ അതിന്റെ ഗ്രൂപ്പിലെ ഓരോ ടിക്കറ്റിന്റെയും വിലയുടെ വിഹിതം ഞങ്ങൾ കണക്കാക്കുന്ന ഒരു കോളം ചേർക്കുക.

ഇതിലേക്ക് പുതിയ കോളങ്ങൾ ചേർക്കാൻ data.table ഓപ്പറേറ്റർ ഉണ്ട് :=. പാക്കേജ് ഉപയോഗിച്ച് ഒരു പ്രശ്നം പരിഹരിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ചുവടെയുണ്ട് data.table

R ലെ വിൻഡോ ഫംഗ്‌ഷനുകൾ: data.table

titanic[,c("Pclass_cost","ticket_fare_rate") := .(sum(Fare), Fare / Pclass_cost), 
        by = Pclass]

പൈത്തണിലെ വിൻഡോ പ്രവർത്തനങ്ങൾ: പാണ്ടകൾ

ഒരു പുതിയ കോളം ചേർക്കുന്നതിനുള്ള ഒരു വഴി pandas - ഫംഗ്ഷൻ ഉപയോഗിക്കുക assign(). ക്യാബിൻ ക്ലാസ് പ്രകാരം ടിക്കറ്റുകളുടെ വില സംഗ്രഹിക്കാൻ, വരികൾ ഗ്രൂപ്പുചെയ്യാതെ, ഞങ്ങൾ ഫംഗ്ഷൻ ഉപയോഗിക്കും transform().

ഞങ്ങൾ പട്ടികയിലേക്ക് ചേർക്കുന്ന ഒരു പരിഹാരത്തിന്റെ ഒരു ഉദാഹരണം ചുവടെയുണ്ട് ടൈറ്റാനിക് അതേ 2 നിരകൾ.

പൈത്തണിലെ വിൻഡോ പ്രവർത്തനങ്ങൾ: പാണ്ടകൾ

titanic.assign(Pclass_cost      =  titanic.groupby('Pclass').Fare.transform(sum),
               ticket_fare_rate = lambda x: x['Fare'] / x['Pclass_cost'])

പ്രവർത്തനങ്ങളും രീതികളും കത്തിടപാടുകൾ പട്ടിക

ഞങ്ങൾ പരിഗണിച്ച പാക്കേജുകളിലെ ഡാറ്റ ഉപയോഗിച്ച് വിവിധ പ്രവർത്തനങ്ങൾ നടത്തുന്നതിനുള്ള രീതികൾ തമ്മിലുള്ള കത്തിടപാടുകളുടെ ഒരു പട്ടിക ചുവടെയുണ്ട്.

വിവരണം
വൃത്തിയുള്ള
ഡാറ്റ. പട്ടിക
പാണ്ടകൾ

ഡാറ്റ ലോഡുചെയ്യുന്നു
vroom()/ readr::read_csv() / readr::read_tsv()
fread()
read_csv()

ഡാറ്റ ഫ്രെയിമുകൾ സൃഷ്ടിക്കുന്നു
tibble()
data.table()
dict() + from_dict()

നിരകൾ തിരഞ്ഞെടുക്കുന്നു
select()
വാദം j, ചതുര ബ്രാക്കറ്റുകളിൽ രണ്ടാം സ്ഥാനം
ആവശ്യമായ നിരകളുടെ ലിസ്റ്റ് ഞങ്ങൾ ചതുര ബ്രാക്കറ്റുകളിൽ കൈമാറുന്നു / drop() / filter() / select_dtypes()

ഫിൽട്ടറിംഗ് വരികൾ
filter()
വാദം i, ചതുര ബ്രാക്കറ്റുകളിൽ ഒന്നാം സ്ഥാനം
ഞങ്ങൾ ചതുര ബ്രാക്കറ്റുകളിൽ ഫിൽട്ടറിംഗ് വ്യവസ്ഥകൾ ലിസ്റ്റ് ചെയ്യുന്നു / filter()

ഗ്രൂപ്പിംഗും കൂട്ടിച്ചേർക്കലും
group_by() + summarise()
ആർഗ്യുമെന്റുകൾ j + by
groupby() + agg()

പട്ടികകളുടെ ലംബമായ യൂണിയൻ (UNION)
bind_rows()
rbind()
concat()

പട്ടികകളുടെ തിരശ്ചീന ജോയിൻ (ജോയിൻ)
left_join() / *_join()
merge()
merge()

അടിസ്ഥാന വിൻഡോ ഫംഗ്‌ഷനുകളും കണക്കാക്കിയ നിരകൾ ചേർക്കലും
group_by() + mutate()
വാദം j ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നു := + വാദം by
transform() + assign()

തീരുമാനം

ഒരുപക്ഷേ ലേഖനത്തിൽ ഞാൻ വിവരിച്ചിരിക്കുന്നത് ഡാറ്റാ പ്രോസസ്സിംഗിന്റെ ഏറ്റവും ഒപ്റ്റിമൽ നടപ്പാക്കലുകളല്ല, അതിനാൽ അഭിപ്രായങ്ങളിലെ എന്റെ തെറ്റുകൾ നിങ്ങൾ തിരുത്തുകയോ അല്ലെങ്കിൽ ആർ / പൈത്തണിലെ ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നതിനുള്ള മറ്റ് സാങ്കേതിക വിദ്യകളുമായി ലേഖനത്തിൽ നൽകിയിരിക്കുന്ന വിവരങ്ങൾ അനുബന്ധമായി നൽകുകയോ ചെയ്താൽ ഞാൻ സന്തോഷിക്കും.

ഞാൻ മുകളിൽ എഴുതിയതുപോലെ, ലേഖനത്തിന്റെ ഉദ്ദേശം, ഏത് ഭാഷയാണ് മികച്ചതെന്ന് ഒരാളുടെ അഭിപ്രായം അടിച്ചേൽപ്പിക്കുകയല്ല, മറിച്ച് രണ്ട് ഭാഷകളും പഠിക്കാനുള്ള അവസരം ലളിതമാക്കുക, അല്ലെങ്കിൽ ആവശ്യമെങ്കിൽ അവയ്ക്കിടയിൽ കുടിയേറുക.

നിങ്ങൾക്ക് ലേഖനം ഇഷ്ടപ്പെട്ടെങ്കിൽ, എന്റെ പുതിയ സബ്‌സ്‌ക്രൈബർമാരെ ലഭിച്ചതിൽ ഞാൻ സന്തുഷ്ടനാണ് YouTube и ടെലഗ്രാം ചാനലുകൾ.

വോട്ട്നേടൽ

ഇനിപ്പറയുന്ന പാക്കേജുകളിൽ ഏതാണ് നിങ്ങളുടെ ജോലിയിൽ ഉപയോഗിക്കുന്നത്?

അഭിപ്രായങ്ങളിൽ നിങ്ങളുടെ തിരഞ്ഞെടുപ്പിന്റെ കാരണം എഴുതാം.

രജിസ്റ്റർ ചെയ്ത ഉപയോക്താക്കൾക്ക് മാത്രമേ സർവേയിൽ പങ്കെടുക്കാൻ കഴിയൂ. സൈൻ ഇൻദയവായി.

ഏത് ഡാറ്റാ പ്രോസസ്സിംഗ് പാക്കേജാണ് നിങ്ങൾ ഉപയോഗിക്കുന്നത് (നിങ്ങൾക്ക് നിരവധി ഓപ്ഷനുകൾ തിരഞ്ഞെടുക്കാം)

• 45,2%ക്രമം19

• 33,3%data.table14

• 54,8%പാണ്ടകൾ23

42 ഉപയോക്താക്കൾ വോട്ട് ചെയ്തു. 9 ഉപയോക്താക്കൾ വിട്ടുനിന്നു.

അവലംബം: www.habr.com