ઈન્ટરનેટ પર R અથવા Python ને સર્ચ કરવાથી, તમને લાખો લેખો અને તે વિષય પર કિલોમીટરની ચર્ચાઓ મળશે જેમાંથી કોઈ ડેટા સાથે કામ કરવા માટે વધુ સારું, ઝડપી અને વધુ અનુકૂળ છે. પરંતુ કમનસીબે, આ બધા લેખો અને વિવાદો ખાસ ઉપયોગી નથી.

આ લેખનો હેતુ બંને ભાષાઓના સૌથી લોકપ્રિય પેકેજોમાં મૂળભૂત ડેટા પ્રોસેસિંગ તકનીકોની તુલના કરવાનો છે. અને વાચકોને તેઓ હજુ સુધી જાણતા ન હોય તેવી કોઈ બાબતમાં ઝડપથી નિપુણતા મેળવવામાં સહાય કરો. જેઓ પાયથોનમાં લખે છે, તેઓ માટે R માં સમાન વસ્તુ કેવી રીતે કરવી તે શોધો, અને ઊલટું.

લેખ દરમિયાન અમે R માં સૌથી વધુ લોકપ્રિય પેકેજોના વાક્યરચનાનું વિશ્લેષણ કરીશું. આ પુસ્તકાલયમાં સમાવિષ્ટ પેકેજો છે. tidyverseઅને પેકેજ પણ data.table. અને તેમની વાક્યરચના સાથે સરખામણી કરો pandas, Python માં સૌથી લોકપ્રિય ડેટા વિશ્લેષણ પેકેજ.

અમે પાયથોન અને આરનો ઉપયોગ કરીને તેને લોડ કરવાથી લઈને વિશ્લેષણાત્મક વિન્ડો ફંક્શન કરવા સુધીના ડેટા પૃથ્થકરણના સમગ્ર પાથમાં તબક્કાવાર જઈશું.

અનુક્રમણિકા

આ લેખનો ઉપયોગ ચીટ શીટ તરીકે થઈ શકે છે જો તમે વિચારણા હેઠળના પેકેજોમાંથી કોઈ એકમાં ડેટા પ્રોસેસિંગ કામગીરી કેવી રીતે કરવી તે ભૂલી ગયા હોવ.

1. R અને Python વચ્ચે મુખ્ય વાક્યરચના તફાવતો
   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. તમે કયા પેકેજનો ઉપયોગ કરો છો તેના વિશે ટૂંકું સર્વેક્ષણ

જો તમે ડેટા વિશ્લેષણમાં રસ ધરાવો છો, તો તમે મારા શોધી શકો છો ટેલિગ્રામ и યુ ટ્યુબ ચેનલો મોટાભાગની સામગ્રી R ભાષાને સમર્પિત છે.

R અને Python વચ્ચે મુખ્ય વાક્યરચના તફાવતો

તમારા માટે Python થી 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] Python માં j એલિમેન્ટનો સમાવેશ થશે નહીં.

આર નોટેશનમાં નકારાત્મક અનુક્રમણિકામાં પણ તફાવત છે x[-1] છેલ્લા એક સિવાય વેક્ટરના તમામ ઘટકો પરત કરશે. પાયથોનમાં, સમાન સંકેત માત્ર છેલ્લું તત્વ પરત કરશે.

પદ્ધતિઓ અને OOP

આર તેની પોતાની રીતે OOP ને લાગુ કરે છે, મેં આ વિશે લેખમાં લખ્યું છે "આર ભાષામાં OOP (ભાગ 1): S3 વર્ગો". સામાન્ય રીતે, R એ કાર્યાત્મક ભાષા છે, અને તેમાંની દરેક વસ્તુ કાર્યો પર બનેલી છે. તેથી, ઉદાહરણ તરીકે, એક્સેલ વપરાશકર્તાઓ માટે, પર જાઓ tydiverse તે કરતાં વધુ સરળ હશે pandas. જો કે આ મારો વ્યક્તિલક્ષી અભિપ્રાય હોઈ શકે છે.

ટૂંકમાં, R માં ઑબ્જેક્ટ્સમાં પદ્ધતિઓ નથી (જો આપણે S3 વર્ગો વિશે વાત કરીએ, પરંતુ અન્ય OOP અમલીકરણો છે જે ખૂબ ઓછા સામાન્ય છે). ત્યાં માત્ર સામાન્યકૃત કાર્યો છે જે ઑબ્જેક્ટના વર્ગના આધારે અલગ રીતે પ્રક્રિયા કરે છે.

પાઇપલાઇન્સ

કદાચ આ માટેનું નામ છે pandas તે સંપૂર્ણ રીતે સાચું નહીં હોય, પરંતુ હું તેનો અર્થ સમજાવવાનો પ્રયત્ન કરીશ.

મધ્યવર્તી ગણતરીઓ બચાવવા અને કાર્યકારી વાતાવરણમાં બિનજરૂરી વસ્તુઓનું નિર્માણ ન કરવા માટે, તમે એક પ્રકારની પાઇપલાઇનનો ઉપયોગ કરી શકો છો. તે. ગણતરીના પરિણામને એક ફંક્શનથી બીજા ફંક્શનમાં પાસ કરો અને મધ્યવર્તી પરિણામોને સાચવશો નહીં.

ચાલો નીચેના કોડનું ઉદાહરણ લઈએ, જ્યાં આપણે અલગ ઑબ્જેક્ટમાં મધ્યવર્તી ગણતરીઓ સંગ્રહિત કરીએ છીએ:

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

અમે ક્રમશઃ 3 ઑપરેશન કર્યા, અને દરેકનું પરિણામ અલગ ઑબ્જેક્ટમાં સાચવવામાં આવ્યું. પરંતુ હકીકતમાં, આપણને આ મધ્યવર્તી વસ્તુઓની જરૂર નથી.

અથવા વધુ ખરાબ, પરંતુ એક્સેલ વપરાશકર્તાઓ માટે વધુ પરિચિત.

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(). પરિણામી પરિણામ ઑબ્જેક્ટમાં સાચવવામાં આવે છે obj .

ડેટા સ્ટ્રક્ચર્સ

R અને Python માં ડેટા સ્ટ્રક્ચર્સ સમાન છે, પરંતુ નામો અલગ છે.

વર્ણન
આર.માં નામ
Python/pandas માં નામ

ટેબલ માળખું
data.frame, data.table, tibble
ડેટાફ્રેમ

મૂલ્યોની એક-પરિમાણીય સૂચિ
વેક્ટર
પાંડામાં શ્રેણી અથવા શુદ્ધ પાયથોનમાં સૂચિ

મલ્ટી-લેવલ નોન-ટેબ્યુલર માળખું
યાદી
શબ્દકોશ (ડિક્શનરી)

અમે નીચે સિન્ટેક્સમાં કેટલીક અન્ય સુવિધાઓ અને તફાવતો જોઈશું.

અમે ઉપયોગ કરીશું તે પેકેજો વિશે થોડાક શબ્દો

પ્રથમ, હું તમને પેકેજો વિશે થોડું કહીશ કે જેનાથી તમે આ લેખ દરમિયાન પરિચિત થશો.

વ્યવસ્થિત

સત્તાવાર વેબસાઇટ: tidyverse.org

પુસ્તકાલય tidyverse હેડલી વિકહામ દ્વારા લખાયેલ, આરસ્ટુડિયોના વરિષ્ઠ સંશોધન વૈજ્ઞાનિક. 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 જરૂરી નથી.

આર માં પેકેજો સ્થાપિત કરી રહ્યા છીએ

જો તમે 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. ટાઇટેનિક પેસેન્જર ડેટાસેટ.

તમામ ડેટા મારા પર છે GitHub csv અને tsv ફાઇલોના સ્વરૂપમાં. અમે તેમને ક્યાંથી વિનંતી કરીશું?

R માં ડેટા લોડ કરી રહ્યું છે: tidyverse, vroom, readr

લાઇબ્રેરીમાં ડેટા લોડ કરવા માટે tidyverse ત્યાં બે પેકેજો છે: vroom, readr. vroom વધુ આધુનિક, પરંતુ ભવિષ્યમાં પેકેજો સંયુક્ત થઈ શકે છે.

માંથી અવતરણ સત્તાવાર દસ્તાવેજીકરણ vroom.

વરૂમ વિ રીડર
ના પ્રકાશન શું કરે છે vroom માટે અર્થ readr? હમણાં માટે અમે બે પેકેજોને અલગથી વિકસિત થવા દેવાની યોજના બનાવીએ છીએ, પરંતુ સંભવ છે કે અમે ભવિષ્યમાં પેકેજોને એકીકૃત કરીશું. વરૂમના આળસુ વાંચનનો એક ગેરલાભ એ છે કે કેટલીક ડેટા સમસ્યાઓ સામે જાણ કરી શકાતી નથી, તેથી તેમને કેવી રીતે શ્રેષ્ઠ રીતે એકીકૃત કરવા તે માટે થોડો વિચાર કરવાની જરૂર છે.

vroom વિ રીડર
પ્રકાશનનો અર્થ શું છે? 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: readr માં ડેટા લોડ કરી રહ્યું છે

# 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")

Python: pandas માં ડેટા લોડ કરી રહ્યું છે

જો આપણે R પેકેજો સાથે સરખામણી કરીએ, તો આ કિસ્સામાં સિન્ટેક્સ સૌથી નજીક છે pandas હશે readr, કારણ કે pandas ગમે ત્યાંથી ડેટાની વિનંતી કરી શકે છે, અને આ પેકેજમાં ફંક્શનનો સંપૂર્ણ પરિવાર છે read_*().

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

અને અન્ય ઘણા કાર્યો વિવિધ ફોર્મેટમાંથી ડેટા વાંચવા માટે રચાયેલ છે. પરંતુ અમારા હેતુઓ માટે તે પૂરતું છે read_table() અથવા read_csv() દલીલનો ઉપયોગ કરીને Sep કૉલમ વિભાજક સ્પષ્ટ કરવા માટે.

Python: pandas માં ડેટા લોડ કરી રહ્યું છે

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"))

Python: pandas માં ડેટાફ્રેમ બનાવવી

В pandas ફ્રેમનું નિર્માણ ઘણા તબક્કામાં કરવામાં આવે છે, પહેલા આપણે શબ્દકોશ બનાવીએ છીએ, અને પછી આપણે શબ્દકોશને ડેટાફ્રેમમાં રૂપાંતરિત કરીએ છીએ.

Python: 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 તમને જોઈતી કૉલમના નામ ફિલ્ટર કરવા માટે નિયમિત અભિવ્યક્તિઓ અથવા અન્ય કાર્યોનો ઉપયોગ કરીને જરૂરી કૉલમ ફિલ્ટર કરો.

Python, pandas માં કૉલમ પસંદ કરી રહ્યા છીએ

માં નામ દ્વારા કૉલમ પસંદ કરવા pandas તેમના નામોની યાદી આપવા માટે તે પૂરતું છે. અને નિયમિત અભિવ્યક્તિઓનો ઉપયોગ કરીને નામ દ્વારા કૉલમ પસંદ કરવા અથવા બાકાત કરવા માટે, તમારે કાર્યોનો ઉપયોગ કરવાની જરૂર છે drop() и filter(), અને દલીલ ધરી=1, જેની સાથે તમે સૂચવો છો કે પંક્તિઓને બદલે કૉલમ પર પ્રક્રિયા કરવી જરૂરી છે.

ડેટા પ્રકાર દ્વારા ફીલ્ડ પસંદ કરવા માટે, ફંક્શનનો ઉપયોગ કરો select_dtypes(), અને દલીલોમાં સમાવેશ થાય છે અથવા બાકાત તમારે કયા ક્ષેત્રોને પસંદ કરવાની જરૂર છે તેને અનુરૂપ ડેટા પ્રકારોની સૂચિ પસાર કરો.

Python: pandas માં કૉલમ પસંદ કરી રહ્યા છીએ

# Выбор полей по названию
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]

Python: pandas માં ફિલ્ટરિંગ સ્ટ્રીંગ્સ

માં પંક્તિઓ દ્વારા ફિલ્ટર કરો pandas માં ફિલ્ટર કરવા જેવું જ data.table, અને ચોરસ કૌંસમાં કરવામાં આવે છે.

આ કિસ્સામાં, ડેટાફ્રેમનું નામ સૂચવીને કૉલમ્સની ઍક્સેસ આવશ્યકપણે હાથ ધરવામાં આવે છે; પછી કૉલમનું નામ ચોરસ કૌંસમાં અવતરણ ચિહ્નોમાં પણ સૂચવી શકાય છે (ઉદાહરણ df['col_name']), અથવા સમયગાળા પછી અવતરણ વિના (ઉદાહરણ df.col_name).

જો તમારે ડેટાફ્રેમને ઘણી શરતો દ્વારા ફિલ્ટર કરવાની જરૂર હોય, તો દરેક શરત કૌંસમાં મૂકવી આવશ્યક છે. તાર્કિક પરિસ્થિતિઓ ઓપરેટરો દ્વારા એકબીજા સાથે જોડાયેલ છે & и |.

Python: pandas માં ફિલ્ટરિંગ સ્ટ્રીંગ્સ

# Фильтрация строк таблицы
### фильтрация строк по одному условию
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() અમે પ્રથમ દલીલ તરીકે કોષ્ટક પસાર કર્યું રાક્ષસી, અને પછી ક્ષેત્ર સૂચવ્યું Pclass, જેના દ્વારા અમે અમારા ટેબલને જૂથબદ્ધ કરીશું. ઓપરેટરનો ઉપયોગ કરીને આ કામગીરીનું પરિણામ %>% ફંક્શન માટે પ્રથમ દલીલ તરીકે પસાર થયું 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)

Python: pandas માં કોષ્ટકોને વર્ટિકલી જોડાવું

В pandas ફંક્શનનો ઉપયોગ કોષ્ટકોને જોડવા માટે થાય છે concat(), જેમાં તમારે તેમને જોડવા માટે ફ્રેમ્સની સૂચિ પસાર કરવાની જરૂર છે.

Python: pandas માં ફિલ્ટરિંગ સ્ટ્રીંગ્સ

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

કોષ્ટકોનું આડું જોડવું

એક ઑપરેશન જેમાં બીજામાંથી કૉલમ કી દ્વારા પ્રથમ કોષ્ટકમાં ઉમેરવામાં આવે છે. હકીકત કોષ્ટક (ઉદાહરણ તરીકે, વેચાણ ડેટા સાથેનું ટેબલ) ને કેટલાક સંદર્ભ ડેટા (ઉદાહરણ તરીકે, ઉત્પાદનની કિંમત) સાથે સમૃદ્ધ બનાવતી વખતે તેનો ઉપયોગ ઘણીવાર થાય છે.

જોડાણના ઘણા પ્રકારો છે:

અગાઉ લોડ કરેલ કોષ્ટકમાં રાક્ષસી અમારી પાસે એક કૉલમ છે સેક્સ, જે પેસેન્જરના લિંગ કોડને અનુરૂપ છે:

1 - સ્ત્રી
2 - પુરુષ

ઉપરાંત, અમે એક ટેબલ બનાવ્યું છે - એક સંદર્ભ પુસ્તક લિંગ. મુસાફરોના લિંગ પરના ડેટાની વધુ અનુકૂળ રજૂઆત માટે, અમારે ડિરેક્ટરીમાંથી લિંગનું નામ ઉમેરવાની જરૂર છે. લિંગ ટેબલ પર રાક્ષસી.

આડું કોષ્ટક R માં જોડો: વ્યવસ્થિત, 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.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)

આડું ટેબલ Python: pandas માં જોડાય છે

તેમજ માં data.tableમાં pandas ફંક્શનનો ઉપયોગ કોષ્ટકોને જોડવા માટે થાય છે merge().

પાંડામાં મર્જ() ફંક્શનની દલીલો

• કેવી રીતે - કનેક્શન પ્રકાર: ડાબે, જમણે, બાહ્ય, આંતરિક
• on — કૉલમ કે જે કી છે જો તેનું નામ બંને કોષ્ટકોમાં સમાન હોય
• લેફ્ટ_ઓન, રાઇટ_ઓન — કી કૉલમ્સના નામ, જો તેઓ કોષ્ટકોમાં અલગ-અલગ નામો ધરાવે છે

આડું ટેબલ Python: pandas માં જોડાય છે

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

મૂળભૂત વિન્ડો કાર્યો અને ગણતરી કરેલ કૉલમ

વિન્ડો ફંક્શન એગ્રીગેશન ફંક્શનના અર્થમાં સમાન છે, અને ઘણીવાર ડેટા વિશ્લેષણમાં પણ વપરાય છે. પરંતુ એકત્રીકરણ કાર્યોથી વિપરીત, વિન્ડો ફંક્શન્સ આઉટગોઇંગ ડેટાફ્રેમની પંક્તિઓની સંખ્યામાં ફેરફાર કરતા નથી.

આવશ્યકપણે, વિન્ડો ફંક્શનનો ઉપયોગ કરીને, અમે ઇનકમિંગ ડેટાફ્રેમને અમુક માપદંડ અનુસાર ભાગોમાં વિભાજિત કરીએ છીએ, એટલે કે. ક્ષેત્રના મૂલ્ય દ્વારા, અથવા ઘણા ક્ષેત્રો દ્વારા. અને અમે દરેક વિન્ડો પર અંકગણિત કામગીરી કરીએ છીએ. આ કામગીરીનું પરિણામ દરેક લાઇનમાં પરત કરવામાં આવશે, એટલે કે. કોષ્ટકમાં પંક્તિઓની કુલ સંખ્યા બદલ્યા વિના.

ઉદાહરણ તરીકે, ચાલો ટેબલ લઈએ રાક્ષસી. અમે ગણતરી કરી શકીએ છીએ કે દરેક ટિકિટની કિંમત તેના કેબિન વર્ગમાં કેટલા ટકા હતી.

આ કરવા માટે, અમારે દરેક લાઇનમાં વર્તમાન કેબિન વર્ગની ટિકિટની કુલ કિંમત મેળવવાની જરૂર છે કે જેની ટિકિટ આ લાઇનની છે, પછી દરેક ટિકિટની કિંમતને સમાન કેબિન વર્ગની તમામ ટિકિટોની કુલ કિંમત દ્વારા વિભાજિત કરો. .

R માં વિન્ડો ફંક્શન્સ: tidyverse, dplyr

પંક્તિ જૂથનો ઉપયોગ કર્યા વિના, નવી કૉલમ ઉમેરવા માટે, માં dplyr કાર્ય કરે છે mutate().

તમે ફીલ્ડ દ્વારા ડેટાને જૂથબદ્ધ કરીને ઉપર વર્ણવેલ સમસ્યાને હલ કરી શકો છો Pclass અને નવી કૉલમમાં ફીલ્ડનો સારાંશ ભાડું. આગળ, કોષ્ટકને અનગ્રુપ કરો અને ફીલ્ડના મૂલ્યોને વિભાજીત કરો ભાડું અગાઉના પગલામાં શું થયું હતું.

R માં વિન્ડો ફંક્શન્સ: dplyr

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

R માં વિન્ડો ફંક્શન્સ: data.table

સોલ્યુશન એલ્ગોરિધમ માં જેવું જ રહે છે dplyr, આપણે ટેબલને ક્ષેત્ર દ્વારા વિન્ડોઝમાં વિભાજીત કરવાની જરૂર છે Pclass. દરેક પંક્તિને અનુરૂપ જૂથ માટેની રકમ નવી કૉલમમાં આઉટપુટ કરો અને એક કૉલમ ઉમેરો જેમાં અમે તેના જૂથમાં દરેક ટિકિટની કિંમતના હિસ્સાની ગણતરી કરીએ છીએ.

માં નવી કૉલમ ઉમેરવા માટે data.table ઓપરેટર હાજર :=. નીચે પેકેજનો ઉપયોગ કરીને સમસ્યા હલ કરવાનું ઉદાહરણ છે data.table

R માં વિન્ડો ફંક્શન્સ: data.table

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

Python માં વિન્ડો ફંક્શન્સ: pandas

નવી કૉલમ ઉમેરવાની એક રીત pandas - કાર્યનો ઉપયોગ કરો assign(). પંક્તિઓનું જૂથ બનાવ્યા વિના, કેબિન વર્ગ દ્વારા ટિકિટની કિંમતનો સારાંશ આપવા માટે, અમે ફંક્શનનો ઉપયોગ કરીશું transform().

નીચે એક ઉકેલનું ઉદાહરણ છે જેમાં આપણે કોષ્ટકમાં ઉમેરીએ છીએ રાક્ષસી સમાન 2 કૉલમ.

Python માં વિન્ડો ફંક્શન્સ: pandas

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()

નિષ્કર્ષ

કદાચ લેખમાં મેં ડેટા પ્રોસેસિંગના સૌથી શ્રેષ્ઠ અમલીકરણોનું વર્ણન કર્યું નથી, તેથી જો તમે ટિપ્પણીઓમાં મારી ભૂલો સુધારશો અથવા R / Python માં ડેટા સાથે કામ કરવા માટેની અન્ય તકનીકો સાથે લેખમાં આપેલી માહિતીને ફક્ત પૂરક કરશો તો મને આનંદ થશે.

મેં ઉપર લખ્યું તેમ, લેખનો હેતુ કઈ ભાષા વધુ સારી છે તેના પર કોઈનો અભિપ્રાય લાદવાનો ન હતો, પરંતુ બંને ભાષાઓ શીખવાની તકને સરળ બનાવવાનો હતો, અથવા, જો જરૂરી હોય તો, તેમની વચ્ચે સ્થાનાંતરિત કરવાનો હતો.

જો તમને લેખ ગમ્યો હોય, તો મને મારા નવા સબ્સ્ક્રાઇબર્સ મળવાથી આનંદ થશે યુ ટ્યુબ и ટેલિગ્રામ ચેનલો

મતદાન

તમે તમારા કામમાં નીચેનામાંથી કયા પેકેજનો ઉપયોગ કરો છો?

ટિપ્પણીઓમાં તમે તમારી પસંદગીનું કારણ લખી શકો છો.

ફક્ત નોંધાયેલા વપરાશકર્તાઓ જ સર્વેમાં ભાગ લઈ શકે છે. સાઇન ઇન કરો, મહેરબાની કરીને.

તમે કયા ડેટા પ્રોસેસિંગ પેકેજનો ઉપયોગ કરો છો (તમે ઘણા વિકલ્પો પસંદ કરી શકો છો)

• 45,2%વ્યવસ્થિત 19

• 33,3%data.table14

• 54,8%પાંડા23

42 વપરાશકર્તાઓએ મત ​​આપ્યો. 9 વપરાશકર્તાઓ દૂર રહ્યા.

સોર્સ: www.habr.com