ដោយការស្វែងរក R ឬ Python នៅលើអ៊ីនធឺណិត អ្នកនឹងឃើញអត្ថបទរាប់លាន និងគីឡូម៉ែត្រនៃការពិភាក្សាលើប្រធានបទដែលមួយណាល្អជាង លឿន និងងាយស្រួលជាងសម្រាប់ធ្វើការជាមួយទិន្នន័យ។ ប៉ុន្តែជាអកុសល អត្ថបទ និងជម្លោះទាំងអស់នេះមិនមានប្រយោជន៍ជាពិសេសនោះទេ។

គោលបំណងនៃអត្ថបទនេះគឺដើម្បីប្រៀបធៀបបច្ចេកទេសដំណើរការទិន្នន័យជាមូលដ្ឋាននៅក្នុងកញ្ចប់ពេញនិយមបំផុតនៃភាសាទាំងពីរ។ ហើយ​ជួយ​អ្នក​អាន​ឱ្យ​ឆាប់​យល់​ពី​អ្វី​ដែល​ពួកគេ​មិន​ទាន់​ដឹង។ សម្រាប់អ្នកដែលសរសេរក្នុង Python ស្វែងយល់ពីរបៀបធ្វើដូចគ្នានៅក្នុង R និងច្រាសមកវិញ។

ក្នុងអំឡុងពេលអត្ថបទ យើងនឹងវិភាគវាក្យសម្ព័ន្ធនៃកញ្ចប់ដែលពេញនិយមបំផុតនៅក្នុង R. ទាំងនេះគឺជាកញ្ចប់ដែលរួមបញ្ចូលនៅក្នុងបណ្ណាល័យ tidyverseនិងកញ្ចប់ផងដែរ។ data.table. ហើយប្រៀបធៀបវាក្យសម្ព័ន្ធរបស់ពួកគេជាមួយ pandasដែលជាកញ្ចប់វិភាគទិន្នន័យពេញនិយមបំផុតនៅក្នុង Python ។

យើងនឹងទៅមួយជំហានម្តងៗតាមរយៈផ្លូវទាំងមូលនៃការវិភាគទិន្នន័យពីការផ្ទុកវាទៅការអនុវត្តមុខងារបង្អួចវិភាគដោយប្រើ Python និង R ។

មាតិកា

អត្ថបទនេះអាចត្រូវបានប្រើជាសន្លឹកបន្លំ ប្រសិនបើអ្នកភ្លេចពីរបៀបធ្វើប្រតិបត្តិការដំណើរការទិន្នន័យមួយចំនួននៅក្នុងកញ្ចប់មួយក្នុងចំណោមកញ្ចប់ដែលកំពុងពិចារណា។

1. ភាពខុសគ្នាសំខាន់រវាង R និង Python
   1.1. ការចូលប្រើមុខងារកញ្ចប់
   1.2. កិច្ចការ
   1.3. ការធ្វើលិបិក្រម
   1.4. វិធីសាស្រ្តនិង OOP
   1.5. បំពង់
   1.6. រចនាសម្ព័ន្ធទិន្នន័យ
2. ពាក្យពីរបីអំពីកញ្ចប់ដែលយើងនឹងប្រើ
   2.1. tidyverse
   2.2. តារាងទិន្នន័យ
   2.3. ខ្លាឃ្មុំផេនដា
3. ការដំឡើងកញ្ចប់
4. កំពុងផ្ទុកទិន្នន័យ
5. ការបង្កើតស៊ុមទិន្នន័យ
6. ការជ្រើសរើសជួរឈរដែលអ្នកត្រូវការ
7. ត្រងជួរ
8. ការដាក់ជាក្រុម និងការប្រមូលផ្តុំ
9. ការរួបរួមនៃតារាងបញ្ឈរ (UNION)
10. ការភ្ជាប់តារាងផ្ដេក (ចូលរួម)
11. មុខងារបង្អួចមូលដ្ឋាន និងជួរឈរគណនា
12. តារាងឆ្លើយឆ្លងរវាងវិធីសាស្ត្រដំណើរការទិន្នន័យក្នុង R និង Python
13. សេចក្តីសន្និដ្ឋាន
14. ការស្ទង់មតិខ្លីអំពីកញ្ចប់មួយណាដែលអ្នកប្រើ

ប្រសិនបើអ្នកចាប់អារម្មណ៍លើការវិភាគទិន្នន័យ អ្នកអាចស្វែងរករបស់ខ្ញុំ ទូរលេខ и YouTube ឆានែល។ មាតិកាភាគច្រើនត្រូវបានឧទ្ទិសដល់ភាសា R ។

ភាពខុសគ្នាសំខាន់រវាង R និង Python

ដើម្បីធ្វើឱ្យវាកាន់តែងាយស្រួលសម្រាប់អ្នកក្នុងការប្តូរពី Python ទៅ R ឬផ្ទុយមកវិញ ខ្ញុំនឹងផ្តល់ចំណុចសំខាន់ៗមួយចំនួនដែលអ្នកត្រូវយកចិត្តទុកដាក់។

ការចូលប្រើមុខងារកញ្ចប់

នៅពេលដែលកញ្ចប់មួយត្រូវបានផ្ទុកទៅក្នុង R អ្នកមិនចាំបាច់បញ្ជាក់ឈ្មោះកញ្ចប់ដើម្បីចូលប្រើមុខងាររបស់វានោះទេ។ ក្នុងករណីភាគច្រើន នេះមិនមែនជារឿងធម្មតាទេនៅក្នុង R ប៉ុន្តែវាអាចទទួលយកបាន។ អ្នកមិនចាំបាច់នាំចូលកញ្ចប់អ្វីទាំងអស់ ប្រសិនបើអ្នកត្រូវការមុខងារណាមួយរបស់វានៅក្នុងកូដរបស់អ្នក ប៉ុន្តែគ្រាន់តែហៅវាដោយបញ្ជាក់ឈ្មោះកញ្ចប់ និងឈ្មោះមុខងារ។ សញ្ញាបំបែករវាងឈ្មោះកញ្ចប់ និងមុខងារក្នុង R គឺជាសញ្ញាពីរ។ package_name::function_name().

នៅក្នុង Python ផ្ទុយទៅវិញ វាត្រូវបានគេចាត់ទុកថាជាបុរាណដើម្បីហៅមុខងារនៃកញ្ចប់ដោយបញ្ជាក់យ៉ាងច្បាស់ពីឈ្មោះរបស់វា។ នៅពេលដែលកញ្ចប់មួយត្រូវបានទាញយក ជាធម្មតាវាត្រូវបានផ្តល់ឈ្មោះខ្លី ឧ. pandas ជា​ធម្មតា​ឈ្មោះ​ក្លែងក្លាយ​ត្រូវ​បាន​ប្រើ pd. មុខងារកញ្ចប់ត្រូវបានចូលប្រើតាមរយៈចំនុច package_name.function_name().

កិច្ចការ

នៅក្នុង R វាជារឿងធម្មតាក្នុងការប្រើព្រួញដើម្បីផ្តល់តម្លៃទៅវត្ថុមួយ។ obj_name <- valueទោះបីជាសញ្ញាស្មើតែមួយត្រូវបានអនុញ្ញាតក៏ដោយ សញ្ញាស្មើគ្នាតែមួយនៅក្នុង R ត្រូវបានប្រើជាចម្បងដើម្បីបញ្ជូនតម្លៃទៅអាគុយម៉ង់មុខងារ។

នៅក្នុង Python កិច្ចការត្រូវបានបញ្ចប់ទាំងស្រុងដោយសញ្ញាស្មើតែមួយ obj_name = value.

ការធ្វើលិបិក្រម

វាក៏មានភាពខុសគ្នាខ្លាំងនៅទីនេះផងដែរ។ នៅក្នុង R ការបង្កើតលិបិក្រមចាប់ផ្តើមនៅមួយ ហើយរួមបញ្ចូលធាតុដែលបានបញ្ជាក់ទាំងអស់នៅក្នុងជួរលទ្ធផល។

នៅក្នុង Python ការបង្កើតលិបិក្រមចាប់ផ្តើមពីសូន្យ ហើយជួរដែលបានជ្រើសរើសមិនរួមបញ្ចូលធាតុចុងក្រោយដែលបានបញ្ជាក់នៅក្នុងលិបិក្រមនោះទេ។ ដូច្នេះការរចនា x[i:j] នៅក្នុង Python នឹងមិនរួមបញ្ចូលធាតុ j ទេ។

វាក៏មានភាពខុសប្លែកគ្នាក្នុងការធ្វើលិបិក្រមអវិជ្ជមាននៅក្នុងសញ្ញា R x[-1] នឹងត្រឡប់ធាតុទាំងអស់នៃវ៉ិចទ័រ លើកលែងតែធាតុចុងក្រោយ។ នៅក្នុង Python សញ្ញាស្រដៀងគ្នានឹងត្រឡប់តែធាតុចុងក្រោយប៉ុណ្ណោះ។

វិធីសាស្រ្តនិង OOP

R អនុវត្ត OOP នៅក្នុងវិធីផ្ទាល់ខ្លួនរបស់ខ្ញុំខ្ញុំបានសរសេរអំពីរឿងនេះនៅក្នុងអត្ថបទ "OOP ជាភាសា R (ផ្នែកទី 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 <-.

ទាំង​អស់​ខាង​លើ​ត្រូវ​បាន​បង្ហាញ​យ៉ាង​ល្អ​ជាង​ពាក្យ​ដោយ meme នេះ៖

В 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 គឺស្រដៀងគ្នា ប៉ុន្តែមានឈ្មោះផ្សេងគ្នា។

បរិយាយ
ឈ្មោះនៅក្នុង R
ឈ្មោះនៅក្នុង Python/pandas

រចនាសម្ព័ន្ធតារាង
data.frame, data.table, tibble
DataFrame

បញ្ជីតម្លៃមួយវិមាត្រ
វ៉ិចទ័រ
ស៊េរីនៅក្នុងផេនដា ឬបញ្ជីនៅក្នុង Python សុទ្ធ

រចនាសម្ព័ន្ធមិនមែនតារាងពហុកម្រិត
បញ្ជី
វចនានុក្រម (វចនានុក្រម)

យើងនឹងពិនិត្យមើលលក្ខណៈពិសេស និងភាពខុសគ្នាមួយចំនួនផ្សេងទៀតនៅក្នុងវាក្យសម្ព័ន្ធខាងក្រោម។

ពាក្យពីរបីអំពីកញ្ចប់ដែលយើងនឹងប្រើ

ជាដំបូង ខ្ញុំនឹងប្រាប់អ្នកបន្តិចអំពីកញ្ចប់ដែលអ្នកនឹងស្គាល់ក្នុងអំឡុងពេលអត្ថបទនេះ។

tidyverse

វេបសាយផ្លូវការ: tidyverse.org

បណ្ណាល័យ tidyverse សរសេរដោយ Hedley Wickham អ្នកស្រាវជ្រាវជាន់ខ្ពស់នៅ RStudio ។ tidyverse មានសំណុំកញ្ចប់ដ៏គួរឱ្យចាប់អារម្មណ៍ដែលសម្រួលដំណើរការទិន្នន័យ 5 ដែលត្រូវបានរួមបញ្ចូលនៅក្នុងការទាញយកកំពូលទាំង 10 ពីឃ្លាំង CRAN ។

ស្នូលនៃបណ្ណាល័យមានកញ្ចប់ដូចខាងក្រោមៈ ggplot2, dplyr, tidyr, readr, purrr, tibble, stringr, forcats. កញ្ចប់នីមួយៗទាំងនេះមានគោលបំណងដោះស្រាយបញ្ហាជាក់លាក់មួយ។ ឧទាហរណ៍ dplyr បង្កើតឡើងសម្រាប់ការគ្រប់គ្រងទិន្នន័យ, tidyr ដើម្បីនាំយកទិន្នន័យទៅជាទម្រង់ស្អាត stringr សម្រួលការធ្វើការជាមួយខ្សែអក្សរ និង ggplot2 គឺជាឧបករណ៍មើលឃើញទិន្នន័យដ៏ពេញនិយមបំផុតមួយ។

គុណប្រយោជន៍ tidyverse វាក្យសម្ពន្ធភាពសាមញ្ញ និងងាយស្រួលអាន ដែលមានលក្ខណៈស្រដៀងនឹងភាសាសំណួរ SQL ។

តារាងទិន្នន័យ

វេបសាយផ្លូវការ: r-datatable.com

ដោយ data.table គឺ Matt Dole នៃ H2O.ai ។

ការចេញផ្សាយបណ្ណាល័យដំបូងបានធ្វើឡើងនៅឆ្នាំ 2006 ។

វាក្យសម្ព័ន្ធកញ្ចប់មិនងាយស្រួលដូចនៅក្នុង tidyverse ហើយ​មាន​ការ​ចងចាំ​ច្រើន​ជាង​នៃ​ស៊ុម​ទិន្នន័យ​បុរាណ​ក្នុង R ប៉ុន្តែ​នៅ​ពេល​ជាមួយ​គ្នា​នេះ​បាន​ពង្រីក​យ៉ាង​ខ្លាំង​ក្នុង​មុខងារ។

ឧបាយកលទាំងអស់ជាមួយតារាងក្នុងកញ្ចប់នេះត្រូវបានពិពណ៌នាក្នុងតង្កៀបការ៉េ ហើយប្រសិនបើអ្នកបកប្រែវាក្យសម្ព័ន្ធ data.table នៅក្នុង SQL អ្នកទទួលបានអ្វីមួយដូចនេះ៖ data.table[ WHERE, SELECT, GROUP BY ]

ភាពខ្លាំងនៃកញ្ចប់នេះគឺល្បឿននៃដំណើរការទិន្នន័យដ៏ធំ។

ខ្លាឃ្មុំផេនដា

វេបសាយផ្លូវការ: pandas.pydata.org

ឈ្មោះបណ្ណាល័យបានមកពីពាក្យសេដ្ឋកិច្ច "ទិន្នន័យបន្ទះ" ដែលត្រូវបានប្រើដើម្បីពិពណ៌នាអំពីសំណុំព័ត៌មានដែលមានរចនាសម្ព័ន្ធពហុវិមាត្រ។

ដោយ pandas គឺជនជាតិអាមេរិក Wes McKinney ។

នៅពេលដែលវាមកដល់ការវិភាគទិន្នន័យនៅក្នុង Python ស្មើ pandas ទេ កញ្ចប់ពហុមុខងារកម្រិតខ្ពស់ដែលអនុញ្ញាតឱ្យអ្នកអនុវត្តការចាត់ចែងណាមួយជាមួយទិន្នន័យ ចាប់ពីការផ្ទុកទិន្នន័យពីប្រភពណាមួយរហូតដល់ការមើលឃើញវា។

ការដំឡើងកញ្ចប់បន្ថែម

កញ្ចប់ដែលបានពិភាក្សានៅក្នុងអត្ថបទនេះមិនត្រូវបានរួមបញ្ចូលនៅក្នុងការចែកចាយ R និង Python មូលដ្ឋានទេ។ ទោះបីជាមានការព្រមានតូចមួយក៏ដោយប្រសិនបើអ្នកបានដំឡើងការចែកចាយ Anaconda បន្ទាប់មកដំឡើងបន្ថែម 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)

ការដំឡើងកញ្ចប់នៅក្នុង Python

ដូច្នេះប្រសិនបើអ្នកបានដំឡើង Python សុទ្ធនោះ អញ្ចឹង pandas អ្នកត្រូវដំឡើងវាដោយដៃ។ បើកបន្ទាត់ពាក្យបញ្ជា ឬស្ថានីយ អាស្រ័យលើប្រព័ន្ធប្រតិបត្តិការរបស់អ្នក ហើយបញ្ចូលពាក្យបញ្ជាខាងក្រោម។

pip install pandas

បន្ទាប់មកយើងត្រលប់ទៅ Python ហើយនាំចូលកញ្ចប់ដែលបានដំឡើងដោយប្រើពាក្យបញ្ជា import.

import pandas as pd

កំពុងផ្ទុកទិន្នន័យ

ការជីកយករ៉ែទិន្នន័យគឺជាជំហានដ៏សំខាន់បំផុតមួយក្នុងការវិភាគទិន្នន័យ។ ទាំង Python និង R ប្រសិនបើចង់បាន ផ្តល់ឱ្យអ្នកនូវឱកាសយ៉ាងទូលំទូលាយក្នុងការទទួលបានទិន្នន័យពីប្រភពណាមួយ៖ ឯកសារក្នុងស្រុក ឯកសារពីអ៊ីនធឺណិត គេហទំព័រ គ្រប់ប្រភេទនៃមូលដ្ឋានទិន្នន័យ។

ពេញមួយអត្ថបទ យើងនឹងប្រើសំណុំទិន្នន័យជាច្រើន៖

1. ការទាញយកពីរពី Google Analytics ។
2. សំណុំទិន្នន័យអ្នកដំណើរទីតានិច។

ទិន្នន័យទាំងអស់គឺនៅលើរបស់ខ្ញុំ GitHub ក្នុងទម្រង់ជាឯកសារ csv និង tsv ។ តើយើងនឹងស្នើសុំពួកគេពីណា?

កំពុងផ្ទុកទិន្នន័យទៅក្នុង R: tidyverse, vroom, readr

ដើម្បីផ្ទុកទិន្នន័យទៅក្នុងបណ្ណាល័យ tidyverse មានពីរកញ្ចប់៖ vroom, readr. vroom ទំនើបជាងមុន ប៉ុន្តែនៅពេលអនាគត កញ្ចប់អាចនឹងត្រូវបានបញ្ចូលគ្នា។

ដកស្រង់ពី ឯកសារផ្លូវការ vroom.

vroom ទល់នឹងអ្នកអាន
តើការចេញផ្សាយអ្វី vroom មានន័យសម្រាប់ readr? សម្រាប់ពេលនេះ យើងមានគម្រោងអនុញ្ញាតឱ្យកញ្ចប់ទាំងពីរវិវឌ្ឍន៍ដោយឡែកពីគ្នា ប៉ុន្តែទំនងជាយើងនឹងបង្រួបបង្រួមកញ្ចប់នាពេលអនាគត។ គុណវិបត្តិមួយចំពោះការអានដ៏ខ្ជិលរបស់ vroom គឺបញ្ហាទិន្នន័យមួយចំនួនមិនអាចរាយការណ៍ជាមុនបានទេ ដូច្នេះវិធីដែលល្អបំផុតក្នុងការបង្រួបបង្រួមពួកវាតម្រូវឱ្យមានការគិតខ្លះៗ។

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() ដោយប្រើអាគុយម៉ង់ កញ្ញា ដើម្បីបញ្ជាក់សញ្ញាបំបែកជួរឈរ។

កំពុងផ្ទុកទិន្នន័យនៅក្នុង 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 ជួររៀងគ្នា។

ការបង្កើត dataframe ក្នុង R: tidyverse, dplyr

ក្នុងឧទាហរណ៍កូដខាងក្រោម យើងបង្កើត dataframe ដែលចង់បានដោយប្រើមុខងារ tibble() .

ការបង្កើត Dataframe ក្នុង R: dplyr

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

ការបង្កើត dataframe ក្នុង R: data.table

ការបង្កើត dataframe ក្នុង R: data.table

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

ការបង្កើត Dataframe នៅក្នុង Python: pandas

В pandas ការបង្កើតស៊ុមត្រូវបានអនុវត្តក្នុងដំណាក់កាលជាច្រើន ដោយដំបូងយើងបង្កើតវចនានុក្រម ហើយបន្ទាប់មកយើងបម្លែងវចនានុក្រមទៅជាស៊ុមទិន្នន័យ។

ការបង្កើត Dataframe នៅក្នុង 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]

នៅទីណា:
ខ្ញុំ - កន្លែងណា, i.e. ត្រងតាមជួរ
j - ជ្រើសរើស|ធ្វើបច្ចុប្បន្នភាព|ធ្វើ, i.e. ជ្រើសរើសជួរឈរនិងបំប្លែងពួកវា
ដោយ - ក្រុមទិន្នន័យ

ការជ្រើសរើសជួរឈរក្នុង 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
• | - ឡូជីខល OR

តម្រងជួរក្នុង 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]

នៅទីណា:
ខ្ញុំ - កន្លែងណា, i.e. ត្រងតាមជួរ
j - ជ្រើសរើស|ធ្វើបច្ចុប្បន្នភាព|ធ្វើ, i.e. ជ្រើសរើសជួរឈរនិងបំប្លែងពួកវា
ដោយ - ក្រុមទិន្នន័យ

អាគុយម៉ង់ត្រូវបានប្រើដើម្បីត្រងជួរ 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ហើយត្រូវបានធ្វើក្នុងតង្កៀបការ៉េ។

ក្នុង​ករណី​នេះ ការ​ចូល​ទៅ​កាន់​ជួរ​ឈរ​ត្រូវ​បាន​អនុវត្ត​ជា​ចាំបាច់​ដោយ​ការ​បង្ហាញ​ឈ្មោះ​នៃ dataframe បន្ទាប់​មក​ឈ្មោះ​ជួរ​ឈរ​ក៏​អាច​ត្រូវ​បាន​បង្ហាញ​ក្នុង​សញ្ញា​សម្រង់​ក្នុង​តង្កៀប​ការ៉េ (ឧទាហរណ៍ df['col_name']) ឬដោយគ្មានសម្រង់បន្ទាប់ពីរយៈពេល (ឧទាហរណ៍ df.col_name).

ប្រសិនបើអ្នកត្រូវការត្រង dataframe ដោយលក្ខខណ្ឌជាច្រើន លក្ខខណ្ឌនីមួយៗត្រូវតែដាក់ក្នុងវង់ក្រចក។ លក្ខខណ្ឌឡូជីខលត្រូវបានភ្ជាប់គ្នាទៅវិញទៅមកដោយប្រតិបត្តិករ & и |.

ត្រងខ្សែអក្សរនៅក្នុង 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)]

ការដាក់ជាក្រុម និងការប្រមូលផ្តុំទិន្នន័យ

ប្រតិបត្តិការមួយក្នុងចំណោមប្រតិបត្តិការដែលប្រើជាទូទៅបំផុតក្នុងការវិភាគទិន្នន័យគឺការដាក់ជាក្រុម និងការប្រមូលផ្តុំ។

វាក្យសម្ព័ន្ធសម្រាប់អនុវត្តប្រតិបត្តិការទាំងនេះត្រូវបានខ្ចាត់ខ្ចាយនៅទូទាំងកញ្ចប់ទាំងអស់ដែលយើងពិនិត្យមើល។

ក្នុងករណីនេះ យើងនឹងលើកយក dataframe ជាឧទាហរណ៍ ទិចនិកហើយគណនាចំនួន និងតម្លៃសំបុត្រជាមធ្យមអាស្រ័យលើថ្នាក់កាប៊ីន។

ការដាក់ជាក្រុម និងការប្រមូលផ្តុំទិន្នន័យក្នុង 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]

ការដាក់ជាក្រុម និងការប្រមូលផ្តុំទិន្នន័យនៅក្នុង Python: pandas

ការដាក់ជាក្រុម pandas ស្រដៀងទៅនឹង dplyrប៉ុន្តែការប្រមូលផ្តុំមិនស្រដៀងនឹង dplyr មិននៅលើ data.table.

ដើម្បីដាក់ជាក្រុម សូមប្រើវិធីសាស្ត្រ groupby()ដែលអ្នកចាំបាច់ត្រូវឆ្លងកាត់បញ្ជីជួរឈរដែលស៊ុមទិន្នន័យនឹងត្រូវបានដាក់ជាក្រុម។

សម្រាប់ការប្រមូលផ្តុំអ្នកអាចប្រើវិធីសាស្រ្ត agg()ដែលទទួលយកវចនានុក្រម។ គ្រាប់ចុចវចនានុក្រមគឺជាជួរឈរដែលអ្នកនឹងអនុវត្តមុខងារប្រមូលផ្តុំ ហើយតម្លៃគឺជាឈ្មោះនៃមុខងារប្រមូលផ្តុំ។

មុខងារប្រមូលផ្តុំ៖

• sum() - សង្ខេប
• min() / max() - តម្លៃអប្បបរមា និងអតិបរមា
• mean() - មធ្យម
• median() - មធ្យម
• count() - បរិមាណ

មុខងារ reset_index() ក្នុងឧទាហរណ៍ខាងក្រោមវាត្រូវបានប្រើដើម្បីកំណត់លិបិក្រមដែលបានដាក់ឡើងវិញនោះ។ pandas លំនាំដើមបន្ទាប់ពីការប្រមូលផ្តុំទិន្នន័យ។

ស៊ីម អនុញ្ញាតឱ្យអ្នកផ្លាស់ទីទៅបន្ទាត់បន្ទាប់។

ការដាក់ជាក្រុម និងការប្រមូលផ្តុំនៅក្នុង Python: pandas

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

ការភ្ជាប់បញ្ឈរនៃតារាង

ប្រតិបត្តិការដែលអ្នកចូលរួមតារាងពីរ ឬច្រើននៃរចនាសម្ព័ន្ធដូចគ្នា។ ទិន្នន័យដែលយើងផ្ទុកមានតារាង ga_nov и ga_dec. តារាងទាំងនេះគឺដូចគ្នាបេះបិទនៅក្នុងរចនាសម្ព័ន្ធ, i.e. មានជួរឈរដូចគ្នា និងប្រភេទទិន្នន័យនៅក្នុងជួរឈរទាំងនេះ។

នេះគឺជាការបង្ហោះពី 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])

ការភ្ជាប់ផ្ដេកនៃតារាង

ប្រតិបត្តិការដែលជួរឈរពីទីពីរត្រូវបានបន្ថែមទៅតារាងទីមួយដោយគ្រាប់ចុច។ វាត្រូវបានគេប្រើជាញឹកញាប់នៅពេលពង្រឹងតារាងការពិត (ឧទាហរណ៍តារាងដែលមានទិន្នន័យលក់) ជាមួយនឹងទិន្នន័យយោងមួយចំនួន (ឧទាហរណ៍ តម្លៃនៃផលិតផល)។

មានប្រភេទជាច្រើននៃការចូលរួម៖

នៅក្នុងតារាងដែលបានផ្ទុកពីមុន ទិចនិក យើងមានជួរឈរមួយ។ ការរួមភេទដែលត្រូវនឹងលេខកូដភេទរបស់អ្នកដំណើរ៖

១-ស្រី
២-​បុរស

ដូចគ្នានេះផងដែរយើងបានបង្កើតតារាងមួយ - សៀវភៅយោង យែនឌ័រ. សម្រាប់ការបង្ហាញកាន់តែងាយស្រួលនៃទិន្នន័យស្តីពីភេទរបស់អ្នកដំណើរ យើងត្រូវបន្ថែមឈ្មោះភេទពីថត យែនឌ័រ ទៅតុ ទិចនិក.

តារាងផ្ដេកចូលរួមនៅក្នុង 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 — ប្រភេទ Join ទាំងអស់នឹងត្រឡប់ជួរទាំងអស់ពីតារាងទាំងពីរ all.x ត្រូវគ្នាទៅនឹងប្រតិបត្តិការ LEFT JOIN (នឹងទុកជួរទាំងអស់នៃតារាងទីមួយ) all.y — ត្រូវគ្នាទៅនឹង ប្រតិបត្តិការ RIGHT JOIN (នឹងទុកជួរទាំងអស់នៃតារាងទីពីរ)។

ការភ្ជាប់ផ្ដេកនៃតារាងក្នុង R: data.table

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

តារាងផ្ដេកចូលរួមនៅក្នុង Python: pandas

ក៏ដូចជានៅក្នុង data.tableនៅ pandas មុខងារត្រូវបានប្រើដើម្បីភ្ជាប់តារាង merge().

អាគុយម៉ង់នៃមុខងារបញ្ចូលគ្នា () នៅក្នុងផេនដា

• របៀប - ប្រភេទការតភ្ជាប់៖ ឆ្វេង ស្ដាំ ខាងក្រៅ ខាងក្នុង
• លើ — ជួរ​ឈរ​ដែល​ជា​កូនសោ​ប្រសិន​បើ​វា​មាន​ឈ្មោះ​ដូចគ្នា​ក្នុង​តារាង​ទាំងពីរ
• left_on, right_on — ឈ្មោះ​ជួរ​ឈរ​គន្លឹះ ប្រសិនបើ​ពួកគេ​មាន​ឈ្មោះ​ខុស​គ្នា​ក្នុង​តារាង

តារាងផ្ដេកចូលរួមនៅក្នុង Python: pandas

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

មុខងារបង្អួចមូលដ្ឋាន និងជួរឈរគណនា

មុខងារ Window មានអត្ថន័យស្រដៀងគ្នាទៅនឹងមុខងារប្រមូលផ្តុំ ហើយក៏ត្រូវបានគេប្រើជាញឹកញាប់ក្នុងការវិភាគទិន្នន័យផងដែរ។ ប៉ុន្តែមិនដូចមុខងារប្រមូលផ្តុំទេ មុខងារបង្អួចមិនផ្លាស់ប្តូរចំនួនជួរដេកនៃស៊ុមទិន្នន័យដែលចេញនោះទេ។

ជាសំខាន់ ដោយប្រើមុខងារបង្អួច យើងបំបែកស៊ុមទិន្នន័យចូលជាផ្នែកៗតាមលក្ខណៈវិនិច្ឆ័យមួយចំនួន ពោលគឺឧ។ ដោយតម្លៃនៃវាលមួយ ឬវាលជាច្រើន។ ហើយយើងធ្វើប្រតិបត្តិការនព្វន្ធនៅលើបង្អួចនីមួយៗ។ លទ្ធផលនៃប្រតិបត្តិការទាំងនេះនឹងត្រលប់មកវិញក្នុងបន្ទាត់នីមួយៗ i.e. ដោយមិនផ្លាស់ប្តូរចំនួនជួរដេកសរុបក្នុងតារាង។

ជាឧទាហរណ៍ ចូរយើងយកតារាង ទិចនិក. យើងអាចគណនាបានថាតើតម្លៃសំបុត្រនីមួយៗមានប៉ុន្មានភាគរយនៅក្នុងថ្នាក់កាប៊ីនរបស់វា។

ដើម្បីធ្វើដូច្នេះ យើងត្រូវទទួលបានក្នុងមួយជួរនីមួយៗនូវតម្លៃសំបុត្រសរុបសម្រាប់ថ្នាក់កាប៊ីនបច្ចុប្បន្ន ដែលសំបុត្រក្នុងជួរនេះជាកម្មសិទ្ធិ បន្ទាប់មកបែងចែកថ្លៃសំបុត្រនីមួយៗដោយតម្លៃសរុបនៃសំបុត្រទាំងអស់នៃថ្នាក់កាប៊ីនដូចគ្នា .

មុខងារបង្អួចនៅក្នុង 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)

មុខងារ Window ក្នុង R: data.table

ក្បួនដោះស្រាយដំណោះស្រាយនៅតែដដែលដូចនៅក្នុង dplyrយើងត្រូវបំបែកតារាងទៅជា windows តាមវាល Pclass. បញ្ចូលក្នុងជួរឈរថ្មីនូវចំនួនសម្រាប់ក្រុមដែលត្រូវគ្នានឹងជួរនីមួយៗ ហើយបន្ថែមជួរឈរដែលយើងគណនាចំណែកនៃថ្លៃសំបុត្រនីមួយៗនៅក្នុងក្រុមរបស់វា។

ដើម្បីបន្ថែមជួរឈរថ្មីទៅ data.table ប្រតិបត្តិករមានវត្តមាន :=. ខាងក្រោមនេះជាឧទាហរណ៍នៃការដោះស្រាយបញ្ហាដោយប្រើកញ្ចប់ data.table

មុខងារ Window ក្នុង R: data.table

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

មុខងារ Window នៅក្នុង Python: pandas

វិធីមួយដើម្បីបន្ថែមជួរឈរថ្មីទៅ pandas - ប្រើមុខងារ assign(). ដើម្បីសង្ខេបតម្លៃសំបុត្រតាមថ្នាក់កាប៊ីន ដោយមិនបាច់ដាក់ជួរ យើងនឹងប្រើមុខងារ transform().

ខាងក្រោមនេះជាឧទាហរណ៍នៃដំណោះស្រាយដែលយើងបន្ថែមទៅក្នុងតារាង ទិចនិក ដូចគ្នា 2 ជួរ។

មុខងារ Window នៅក្នុង Python: pandas

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

មុខងារ និងវិធីសាស្រ្ត តារាងឆ្លើយឆ្លង

ខាងក្រោមនេះគឺជាតារាងនៃការឆ្លើយឆ្លងរវាងវិធីសាស្រ្តសម្រាប់អនុវត្តប្រតិបត្តិការផ្សេងៗជាមួយនឹងទិន្នន័យនៅក្នុងកញ្ចប់ដែលយើងបានពិចារណា។

បរិយាយ
tidyverse
តារាងទិន្នន័យ
ខ្លាឃ្មុំផេនដា

កំពុងផ្ទុកទិន្នន័យ
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 ។

ដូចដែលខ្ញុំបានសរសេរខាងលើ គោលបំណងនៃអត្ថបទគឺមិនមែនដើម្បីដាក់គំនិតរបស់មនុស្សម្នាក់ថាភាសាមួយណាល្អជាងនោះទេ ប៉ុន្តែដើម្បីសម្រួលដល់ឱកាសក្នុងការរៀនភាសាទាំងពីរ ឬបើចាំបាច់ ផ្លាស់ប្តូររវាងពួកវា។

ប្រសិនបើអ្នកចូលចិត្តអត្ថបទ ខ្ញុំនឹងរីករាយដែលមានអ្នកជាវថ្មីរបស់ខ្ញុំ YouTube и ទូរលេខ ឆានែល។

ការស្ទង់មតិ

តើកញ្ចប់ខាងក្រោមមួយណាដែលអ្នកប្រើក្នុងការងាររបស់អ្នក?

នៅក្នុងមតិយោបល់ អ្នកអាចសរសេរហេតុផលសម្រាប់ជម្រើសរបស់អ្នក។

មានតែអ្នកប្រើប្រាស់ដែលបានចុះឈ្មោះប៉ុណ្ណោះដែលអាចចូលរួមក្នុងការស្ទង់មតិនេះ។ ចូលសូម។

តើកញ្ចប់ដំណើរការទិន្នន័យណាដែលអ្នកប្រើ (អ្នកអាចជ្រើសរើសជម្រើសជាច្រើន)

• 45,2%ភាពស្អាតស្អំ ១៩

• 33,3%data.table14

• 54,8%ខ្លាឃ្មុំផេនដា ២៣

អ្នកប្រើប្រាស់ 42 នាក់បានបោះឆ្នោត។ អ្នកប្រើប្រាស់ ៧៨ នាក់ត្រូវបានហាមឃាត់។

ប្រភព: www.habr.com