Ինտերնետում որոնելով R կամ Python-ը, դուք կգտնեք միլիոնավոր հոդվածներ և կիլոմետրերով քննարկումներ այն թեմայի շուրջ, թե որն է ավելի լավ, արագ և հարմար տվյալների հետ աշխատելու համար: Բայց, ցավոք, այս բոլոր հոդվածներն ու վեճերը առանձնապես օգտակար չեն։
Այս հոդվածի նպատակն է համեմատել տվյալների մշակման հիմնական տեխնիկան երկու լեզուների ամենատարածված փաթեթներում: Եվ օգնեք ընթերցողներին արագ տիրապետել մի բանի, որը նրանք դեռ չգիտեն: Նրանց համար, ովքեր գրում են Python-ով, իմացեք, թե ինչպես անել նույնը R-ում և հակառակը:
Հոդվածի ընթացքում մենք կվերլուծենք R-ի ամենատարածված փաթեթների շարահյուսությունը: Սրանք գրադարանում ներառված փաթեթներն են: tidyverseև նաև փաթեթը data.table. Եվ համեմատեք դրանց շարահյուսությունը pandas, Python-ում տվյալների վերլուծության ամենատարածված փաթեթը:
Մենք քայլ առ քայլ կանցնենք տվյալների վերլուծության ողջ ուղով` դրանք բեռնելուց մինչև Python-ի և R-ի միջոցով վերլուծական պատուհանի գործառույթների կատարումը:
Պարունակություն
Այս հոդվածը կարող է օգտագործվել որպես խաբեության թերթիկ, եթե դուք մոռացել եք, թե ինչպես կատարել տվյալների մշակման որոշ գործողություններ քննարկվող փաթեթներից մեկում:
1.1:
1.2:
1.3:
1.4:
1.5:
1.6:
2.1:
2.2:
2.3:
Եթե դուք հետաքրքրված եք տվյալների վերլուծությամբ, կարող եք գտնել իմ и ալիքներ. Բովանդակության մեծ մասը նվիրված է 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-ն իր ձևով, ես այս մասին գրել եմ հոդվածում . Ընդհանրապես 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(). Ստացված արդյունքը պահվում է օբյեկտի մեջ OBJ .
Տվյալների կառուցվածքներ
R-ի և Python-ի տվյալների կառուցվածքները նման են, բայց ունեն տարբեր անուններ:
Նկարագրություն
Անունը Ռ
Անունը Python/pandas-ում
Սեղանի կառուցվածքը
data.frame, data.table, tibble
DataFrame
Արժեքների միաչափ ցանկ
Վեկտոր
Պանդաների շարք կամ ցուցակ մաքուր Python-ում
Բազմաստիճան ոչ աղյուսակային կառուցվածք
Ցուցակ
Բառարան (թելադրանք)
Ստորև մենք կդիտարկենք շարահյուսության որոշ այլ առանձնահատկություններ և տարբերություններ:
Մի քանի խոսք այն փաթեթների մասին, որոնք մենք կօգտագործենք
Նախ, ես ձեզ մի փոքր կպատմեմ այն փաթեթների մասին, որոնց դուք կծանոթանաք այս հոդվածի ընթացքում:
կոկիկ
Официальный сайт:
գրադարան tidyverse գրել է Հեդլի Ուիքհեմը՝ RStudio-ի ավագ գիտաշխատող: tidyverse բաղկացած է տպավորիչ փաթեթներից, որոնք հեշտացնում են տվյալների մշակումը, որոնցից 5-ը ներառված են CRAN պահոցից ներբեռնումների լավագույն 10-ում:
Գրադարանի առանցքը բաղկացած է հետևյալ փաթեթներից. ggplot2, dplyr, tidyr, readr, purrr, tibble, stringr, forcats. Այս փաթեթներից յուրաքանչյուրն ուղղված է կոնկրետ խնդրի լուծմանը։ Օրինակ dplyr ստեղծված տվյալների մանիպուլյացիայի համար, tidyr տվյալները մաքուր ձևի բերելու համար, stringr հեշտացնում է լարերի հետ աշխատանքը, և ggplot2 տվյալների վիզուալիզացիայի ամենահայտնի գործիքներից մեկն է:
առավելություն tidyverse պարզությունն է և հեշտ ընթերցվող շարահյուսությունը, որը շատ առումներով նման է SQL հարցումների լեզվին:
տվյալներ.աղյուսակ
Официальный сайт:
Հեղինակի կողմից data.table Մեթ Դոլն է H2O.ai-ից:
Գրադարանի առաջին թողարկումը տեղի է ունեցել 2006թ.
Փաթեթի շարահյուսությունը այնքան էլ հարմար չէ, որքան tidyverse և ավելի շատ հիշեցնում է R-ի դասական տվյալների շրջանակները, բայց միևնույն ժամանակ զգալիորեն ընդլայնվել է ֆունկցիոնալությամբ:
Այս փաթեթի աղյուսակի հետ բոլոր մանիպուլյացիաները նկարագրված են քառակուսի փակագծերում, և եթե թարգմանեք շարահյուսությունը data.table SQL-ում դուք ստանում եք այսպիսի բան. data.table[ WHERE, SELECT, GROUP BY ]
Այս փաթեթի ուժը մեծ քանակությամբ տվյալների մշակման արագությունն է:
pandas
Официальный сайт:
Գրադարանի անվանումը գալիս է «պանելային տվյալներ» էկոնոմետրիկ տերմինից, որն օգտագործվում է տեղեկատվության բազմաչափ կառուցվածքային հավաքածուներ նկարագրելու համար:
Հեղինակի կողմից pandas ամերիկացի Ուես ՄաքՔինին է։
Երբ խոսքը վերաբերում է Python-ում տվյալների վերլուծությանը, հավասար է pandas Ոչ Շատ բազմաֆունկցիոնալ, բարձր մակարդակի փաթեթ, որը թույլ է տալիս կատարել ցանկացած մանիպուլյացիա տվյալների հետ՝ ցանկացած աղբյուրից տվյալների բեռնումից մինչև դրանք վիզուալացնելը:
Լրացուցիչ փաթեթների տեղադրում
Այս հոդվածում քննարկված փաթեթները ներառված չեն հիմնական R և Python բաշխումների մեջ: Չնայած կա մի փոքր նախազգուշացում, եթե դուք տեղադրել եք Anaconda բաշխումը, ապա տեղադրեք լրացուցիչ 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)Փաթեթների տեղադրում Python-ում
Այսպիսով, եթե դուք ունեք մաքուր Python տեղադրված, ապա pandas անհրաժեշտ է այն ձեռքով տեղադրել: Բացեք հրամանի տող կամ տերմինալ՝ կախված ձեր օպերացիոն համակարգից և մուտքագրեք հետևյալ հրամանը.
pip install pandasԱյնուհետև վերադառնում ենք Python և հրամանով ներմուծում ենք տեղադրված փաթեթը import.
import pandas as pdՏվյալների բեռնում
Տվյալների արդյունահանումը տվյալների վերլուծության ամենակարևոր քայլերից մեկն է: Ե՛վ Python-ը, և՛ R-ը, ցանկության դեպքում, ձեզ լայն հնարավորություններ են տալիս ցանկացած աղբյուրից տվյալներ ստանալու համար՝ տեղական ֆայլեր, ֆայլեր ինտերնետից, կայքերից, բոլոր տեսակի տվյալների բազաներից:
Հոդվածի ընթացքում մենք կօգտագործենք մի քանի տվյալների հավաքածու.
- Երկու ներբեռնում Google Analytics-ից:
- Տիտանիկի ուղևորների տվյալների հավաքածու.
Բոլոր տվյալները իմ վրա են csv և tsv ֆայլերի տեսքով: Որտեղի՞ց կխնդրենք դրանք:
Տվյալների բեռնում R-ում. tidyverse, vroom, reader
Տվյալները գրադարան բեռնելու համար 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: reader-ում
# 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 Շրջանակների ստեղծումն իրականացվում է մի քանի փուլով, սկզբում ստեղծում ենք բառարան, իսկ հետո բառարանը վերածում տվյալների շրջանակի։
Python-ում տվյալների շրջանակի ստեղծում՝ պանդաներ
# создаём дата фрейм
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 բավական է տրամադրել նրանց անունների ցանկը։ Իսկ կանոնավոր արտահայտությունների միջոցով սյունակները անուններով ընտրելու կամ բացառելու համար անհրաժեշտ է օգտագործել ֆունկցիաները drop() и filter(), և փաստարկ առանցք=1, որով դուք նշում եք, որ անհրաժեշտ է մշակել սյունակներ, քան տողեր։
Տվյալների տիպով դաշտ ընտրելու համար օգտագործեք գործառույթը select_dtypes(), և փաստարկների մեջ ներառում են կամ բացառել փոխանցեք տվյալների տեսակների ցանկը, որը համապատասխանում է այն դաշտերին, որոնք դուք պետք է ընտրեք:
Python-ում սյունակների ընտրություն՝ պանդաներ
# Выбор полей по названию
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 & and | օպերատորների միջոցով:
Տողերի զտում R-ում՝ data.table
## data.table
### фильтрация строк по одному условию
ga_nov[source == "google"]
### фильтр по двум условиям соединённым логическим и
ga_nov[source == "google" & sessions >= 10]
### фильтр по двум условиям соединённым логическим или
ga_nov[source == "google" | sessions >= 10]Զտել տողերը Python-ում՝ պանդաներ
Զտել ըստ տողերի pandas նման է զտմանը data.table, և արված է քառակուսի փակագծերում։
Այս դեպքում սյունակների մուտքն իրականացվում է պարտադիր կերպով՝ նշելով տվյալների շրջանակի անվանումը, այնուհետև սյունակի անվանումը կարող է նշվել նաև չակերտների մեջ՝ քառակուսի փակագծերում (օրինակ df['col_name']), կամ առանց չակերտների ժամանակաշրջանից հետո (օրինակ df.col_name).
Եթե Ձեզ անհրաժեշտ է տվյալների շրջանակը զտել մի քանի պայմաններով, յուրաքանչյուր պայման պետք է տեղադրվի փակագծերում: Տրամաբանական պայմանները միմյանց հետ կապված են օպերատորների կողմից & и |.
Զտել տողերը Python-ում՝ պանդաներ
# Фильтрация строк таблицы
### фильтрация строк по одному условию
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 փաստարկն օգտագործվում է ագրեգացիայի համար j որն ունի երկրորդ դիրքը քառակուսի փակագծերում և խմբավորման համար by կամ keyby, որոնք զբաղեցնում են երրորդ հորիզոնականը։
Այս դեպքում ագրեգացիոն գործառույթների ցանկը նույնական է, ինչ նկարագրված է dplyr, որովհետեւ սրանք գործառույթներ են հիմնական R շարահյուսությունից:
Խմբավորում և համախմբում R-ում.տվյալներ.աղյուսակ
## data.table
### фильтрация строк по одному условию
titanic[, .(passangers = length(PassengerId),
avg_price = mean(Fare)),
by = Pclass]Տվյալների խմբավորում և համախմբում Python-ում. պանդաներ
Խմբավորում pandas նման dplyr, բայց ագրեգացումը նման չէ dplyr ընդհանրապես data.table.
Խմբավորելու համար օգտագործեք մեթոդը groupby(), որի մեջ դուք պետք է փոխանցեք սյունակների ցանկը, որով խմբավորվելու է տվյալների շրջանակը:
Համախմբման համար կարող եք օգտագործել մեթոդը agg()որն ընդունում է բառարան. Բառարանի ստեղները այն սյունակներն են, որոնց վրա դուք կկիրառեք ագրեգացիոն ֆունկցիաները, իսկ արժեքները՝ ագրեգացիոն ֆունկցիաների անուններն են:
Ագրեգացման գործառույթներ.
sum()- ամփոփումmin()/max()- նվազագույն և առավելագույն արժեքըmean()- միջինmedian()- միջինcount()- քանակ
Ֆունկցիա reset_index() ստորև բերված օրինակում այն օգտագործվում է զրոյացնել ներդիր ինդեքսները, որոնք pandas կանխադրված է տվյալների համախմբումից հետո:
Խորհրդանիշ թույլ է տալիս անցնել հաջորդ տող:
Խմբավորում և համախմբում Python-ում. պանդաներ
# группировка и агрегация данных
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 ֆունկցիան օգտագործվում է աղյուսակները միացնելու համար concat(), որոնց մեջ դուք պետք է փոխանցեք շրջանակների ցանկը դրանք համատեղելու համար:
Զտել տողերը Python-ում՝ պանդաներ
# вертикальное объединение таблиц
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 Դուք պետք է միացնեք աղյուսակները ստեղնով, օգտագործելով գործառույթը merge().
Arguments to merge() ֆունկցիան data.table-ում
- x, y — Աղյուսակներ միացման համար
- ըստ — Սյունակ, որը միանալու բանալին է, եթե այն ունի նույն անունը երկու աղյուսակներում
- by.x, by.y — Սյունակների անունները, որոնք պետք է միավորվեն, եթե դրանք տարբեր անուններ ունեն աղյուսակներում
- all, all.x, all.y — Join type, all-ը կվերադարձնի բոլոր տողերը երկու աղյուսակներից, all.x-ը համապատասխանում է LEFT JOIN գործողությանը (կթողնի առաջին աղյուսակի բոլոր տողերը), all.y-ը համապատասխանում է RIGHT JOIN գործողություն (կթողնի երկրորդ աղյուսակի բոլոր տողերը):
Աղյուսակների հորիզոնական միացում R-ում.տվյալներ.աղյուսակ
# объединяем таблицы
merge(titanic, gender, by.x = "Sex", by.y = "id", all.x = T)Հորիզոնական սեղանի միացում Python-ում. պանդաներ
Ինչպես նաև ներս data.tableՄեջ pandas ֆունկցիան օգտագործվում է աղյուսակները միացնելու համար merge().
Պանդաներում merge() ֆունկցիայի փաստարկները
- ինչպես — Միացման տեսակը՝ ձախ, աջ, արտաքին, ներքին
- on — Սյունակ, որը բանալի է, եթե այն ունի նույն անունը երկու աղյուսակներում
- left_on, right_on — Հիմնական սյունակների անունները, եթե դրանք տարբեր անուններ ունեն աղյուսակներում
Հորիզոնական սեղանի միացում Python-ում. պանդաներ
# объединяем по ключу
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 - օգտագործել գործառույթը assign(). Տոմսերի արժեքը ըստ տնակային դասերի ամփոփելու համար՝ առանց տողերի խմբավորման, մենք կօգտագործենք ֆունկցիան transform().
Ստորև բերված է լուծման օրինակ, որում մենք ավելացնում ենք աղյուսակը տիտանական նույն 2 սյունակները:
Պատուհանների գործառույթները Python-ում` պանդաներ
titanic.assign(Pclass_cost = titanic.groupby('Pclass').Fare.transform(sum),
ticket_fare_rate = lambda x: x['Fare'] / x['Pclass_cost'])Գործառույթների և մեթոդների համապատասխանության աղյուսակ
Ստորև ներկայացված է մեր դիտարկած փաթեթների տվյալների հետ տարբեր գործողություններ կատարելու մեթոդների համապատասխանության աղյուսակը:
Նկարագրություն
կոկիկ
տվյալներ.աղյուսակ
pandas
Տվյալների բեռնում
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()
Աղյուսակների հորիզոնական միացում (JOIN)
left_join() / *_join()
merge()
merge()
Հիմնական պատուհանի գործառույթները և հաշվարկված սյունակների ավելացումը
group_by() + mutate()
փաստարկ j օգտագործելով օպերատորը := + փաստարկ by
transform() + assign()
Ամփոփում
Թերևս հոդվածում ես նկարագրեցի տվյալների մշակման ոչ ամենաօպտիմալ իրականացումները, այնպես որ ես ուրախ կլինեմ, եթե մեկնաբանություններում ուղղեք իմ սխալները կամ պարզապես լրացնեք հոդվածում տրված տեղեկատվությունը R / Python-ում տվյալների հետ աշխատելու այլ տեխնիկայով:
Ինչպես վերևում գրեցի, հոդվածի նպատակը ոչ թե սեփական կարծիքը պարտադրելն էր, թե որ լեզուն է ավելի լավը, այլ պարզեցնել երկու լեզուներ սովորելու կամ, անհրաժեշտության դեպքում, նրանց միջև գաղթելու հնարավորությունը:
Եթե ձեզ դուր եկավ հոդվածը, ես ուրախ կլինեմ ունենալ իմ նոր բաժանորդներ и ալիքներ.
Опрос
Հետևյալ փաթեթներից ո՞րն եք օգտագործում ձեր աշխատանքում:
Մեկնաբանություններում կարող եք գրել ձեր ընտրության պատճառը։
Հարցմանը կարող են մասնակցել միայն գրանցված օգտվողները։ , խնդրում եմ:
Տվյալների մշակման ո՞ր փաթեթն եք օգտագործում (կարող եք ընտրել մի քանի տարբերակ)
-
45,2%կոկիկ աշխարհ19
-
33,3%տվյալներ.աղյուսակ14
-
54,8%պանդաներ23
Քվեարկել է 42 օգտատեր։ 9 օգտատեր ձեռնպահ է մնացել։
Source: www.habr.com