ინტერნეტში R-ის ან Python-ის ძიებით თქვენ იპოვით მილიონობით სტატიას და კილომეტრიან დისკუსიას, თუ რომელია უკეთესი, სწრაფი და მოსახერხებელი მონაცემებით მუშაობისთვის. მაგრამ სამწუხაროდ, ყველა ეს სტატია და დავა არ არის განსაკუთრებით სასარგებლო.

ამ სტატიის მიზანია მონაცემთა დამუშავების ძირითადი ტექნიკის შედარება ორივე ენის ყველაზე პოპულარულ პაკეტებში. და დაეხმარეთ მკითხველს სწრაფად დაეუფლონ იმას, რაც ჯერ არ იციან. მათთვის, ვინც პითონში წერს, გაარკვიეთ, როგორ გააკეთოს იგივე R-ში და პირიქით.

სტატიის განმავლობაში გავაანალიზებთ R-ში ყველაზე პოპულარული პაკეტების სინტაქსს. ეს არის ბიბლიოთეკაში შემავალი პაკეტები. tidyverseდა ასევე პაკეტი data.table. და შეადარეთ მათი სინტაქსი pandas, ყველაზე პოპულარული მონაცემთა ანალიზის პაკეტი Python-ში.

ჩვენ ეტაპობრივად გავივლით მონაცემთა ანალიზის მთელ გზას მისი ჩატვირთვიდან ანალიტიკური ფანჯრის ფუნქციების შესრულებამდე Python-ისა და R-ის გამოყენებით.

ინფორმაციის

ეს სტატია შეიძლება გამოყენებულ იქნას როგორც მოტყუების ფურცელი, თუ დაგავიწყდათ როგორ შეასრულოთ მონაცემთა დამუშავების რამდენიმე ოპერაცია განსახილველ პაკეტში.

მთავარი სინტაქსის განსხვავებები R-სა და Python-ს შორის
1.1. პაკეტის ფუნქციებზე წვდომა
1.2. დავალება
1.3. ინდექსირება
1.4. მეთოდები და OOP
1.5. მილსადენები
1.6. მონაცემთა სტრუქტურები
რამდენიმე სიტყვა პაკეტების შესახებ, რომლებსაც ჩვენ გამოვიყენებთ
2.1. მოწესრიგებული
2.2. მონაცემები. მაგიდა
2.3. pandas
პაკეტების ინსტალაცია
იტვირთება მონაცემები
მონაცემთა ჩარჩოების შექმნა
თქვენთვის საჭირო სვეტების შერჩევა
სტრიქონების გაფილტვრა
დაჯგუფება და აგრეგაცია
ცხრილების ვერტიკალური გაერთიანება (UNION)
ცხრილების ჰორიზონტალური შეერთება (JOIN)
ფანჯრის ძირითადი ფუნქციები და გამოთვლილი სვეტები
შესაბამისობის ცხრილი მონაცემთა დამუშავების მეთოდებს შორის R-სა და Python-ში
დასკვნა
მოკლე გამოკითხვა იმის შესახებ, თუ რომელ პაკეტს იყენებთ

თუ თქვენ დაინტერესებული ხართ მონაცემთა ანალიზით, შეგიძლიათ იპოვოთ ჩემი დეპეშა и youtube არხები. შინაარსის უმეტესი ნაწილი ეძღვნება 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] პითონში არ შედის j ელემენტი.

ასევე არსებობს განსხვავებები უარყოფით ინდექსირებაში, R ნოტაციაში x[-1] დააბრუნებს ვექტორის ყველა ელემენტს, გარდა უკანასკნელისა. პითონში, მსგავსი აღნიშვნა დააბრუნებს მხოლოდ ბოლო ელემენტს.

მეთოდები და 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 <-.

ყოველივე ზემოთქმული სიტყვებზე უკეთ არის ილუსტრირებული ამ მემით:

В 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-ში მსგავსია, მაგრამ განსხვავებული სახელები აქვთ.

აღწერა
სახელი რ
სახელი პითონში/პანდაში

მაგიდის სტრუქტურა
data.frame, data.table, tibble
DataFrame

მნიშვნელობების ერთგანზომილებიანი სია
Vector
სერიები პანდაებში ან სია სუფთა პითონში

მრავალდონიანი არატაბულური სტრუქტურა
სია
ლექსიკონი (დიქტატი)

ქვემოთ განვიხილავთ სინტაქსის სხვა მახასიათებლებსა და განსხვავებებს.

რამდენიმე სიტყვა პაკეტების შესახებ, რომლებსაც ჩვენ გამოვიყენებთ

პირველ რიგში, ცოტას გეტყვით იმ პაკეტების შესახებ, რომლებსაც ამ სტატიის განმავლობაში გაეცნობით.

მოწესრიგებული

Официальный сайт: tidyverse.org

ბიბლიოთეკა tidyverse დაწერილი ჰედლი ვიკჰემის მიერ, უფროსი მკვლევარი RStudio-ში. tidyverse შედგება პაკეტების შთამბეჭდავი ნაკრებისგან, რომელიც ამარტივებს მონაცემთა დამუშავებას, რომელთაგან 5 შედის CRAN საცავიდან ჩამოტვირთვების ტოპ 10-ში.

ბიბლიოთეკის ბირთვი შედგება შემდეგი პაკეტებისგან: ggplot2, dplyr, tidyr, readr, purrr, tibble, stringr, forcats. თითოეული ეს პაკეტი მიზნად ისახავს კონკრეტული პრობლემის გადაჭრას. Მაგალითად dplyr შექმნილია მონაცემების მანიპულირებისთვის, tidyr მონაცემების მოწესრიგებულ ფორმაში მოყვანა, stringr ამარტივებს სტრინგებთან მუშაობას და ggplot2 მონაცემთა ვიზუალიზაციის ერთ-ერთი ყველაზე პოპულარული ინსტრუმენტია.

Უპირატესობა tidyverse არის სიმარტივე და ადვილად წასაკითხი სინტაქსი, რომელიც მრავალი თვალსაზრისით ჰგავს SQL შეკითხვის ენას.

მონაცემები. მაგიდა

Официальный сайт: r-datatable.com

ავტორი data.table არის მეთ დოლი H2O.ai-დან.

ბიბლიოთეკის პირველი გამოშვება შედგა 2006 წელს.

პაკეტის სინტაქსი არ არის ისეთი მოსახერხებელი, როგორც აქ tidyverse და უფრო მოგვაგონებს კლასიკურ მონაცემთა ჩარჩოებს R-ში, მაგრამ ამავე დროს მნიშვნელოვნად გაფართოვდა ფუნქციონალურობით.

ამ პაკეტის ცხრილით ყველა მანიპულაცია აღწერილია კვადრატულ ფრჩხილებში და თუ თარგმნით სინტაქსს data.table SQL-ში მიიღებთ მსგავს რაღაცას: data.table[ WHERE, SELECT, GROUP BY ]

ამ პაკეტის სიძლიერე არის დიდი რაოდენობით მონაცემების დამუშავების სიჩქარე.

pandas

Официальный сайт: pandas.pydata.org

ბიბლიოთეკის სახელწოდება მომდინარეობს ეკონომეტრიული ტერმინიდან „პანელის მონაცემები“, რომელიც გამოიყენება ინფორმაციის მრავალგანზომილებიანი სტრუქტურირებული ნაკრების აღსაწერად.

ავტორი pandas არის ამერიკელი უეს მაკკინი.

რაც შეეხება პითონში მონაცემთა ანალიზს, თანაბარი 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)

პაკეტების დაყენება პითონში

ასე რომ, თუ თქვენ გაქვთ სუფთა პითონი დაინსტალირებული, მაშინ pandas თქვენ უნდა დააინსტალიროთ ხელით. გახსენით ბრძანების ხაზი, ან ტერმინალი, თქვენი ოპერაციული სისტემის მიხედვით და შეიყვანეთ შემდეგი ბრძანება.

pip install pandas

შემდეგ ვუბრუნდებით Python-ს და დაინსტალირებული პაკეტის იმპორტს ბრძანებით import.

import pandas as pd

იტვირთება მონაცემები

მონაცემთა მოპოვება მონაცემთა ანალიზის ერთ-ერთი ყველაზე მნიშვნელოვანი ნაბიჯია. ორივე Python და R, თუ სასურველია, გაძლევთ ფართო შესაძლებლობებს, მიიღოთ მონაცემები ნებისმიერი წყაროდან: ადგილობრივი ფაილები, ფაილები ინტერნეტიდან, ვებსაიტები, ყველა სახის მონაცემთა ბაზა.

სტატიის განმავლობაში ჩვენ გამოვიყენებთ რამდენიმე მონაცემთა ნაკრებს:

ორი ჩამოტვირთვა Google Analytics-დან.
ტიტანიკის მგზავრთა მონაცემთა ნაკრები.

ყველა მონაცემი ჩემზეა GitHub csv და tsv ფაილების სახით. საიდან მოვითხოვთ მათ?

მონაცემთა ჩატვირთვა R-ში: tidyverse, vroom, reader

მონაცემთა ბიბლიოთეკაში ჩატვირთვა 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: 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")

პაკეტში vroomcsv / 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")

მონაცემთა ჩარჩოების შექმნა

მაგიდა Titanic, რომელიც ჩავტვირთეთ, არის ველი Sex, რომელიც ინახავს მგზავრის სქესის იდენტიფიკატორს.

მაგრამ მგზავრების სქესის მიხედვით მონაცემების უფრო მოსახერხებელი წარმოდგენისთვის, თქვენ უნდა გამოიყენოთ სახელი და არა გენდერული კოდი.

ამისათვის ჩვენ შევქმნით პატარა დირექტორიას, ცხრილს, რომელშიც იქნება მხოლოდ 2 სვეტი (კოდი და სქესის სახელი) და 2 სტრიქონი, შესაბამისად.

მონაცემთა ჩარჩოს შექმნა R-ში: tidyverse, dplyr

ქვემოთ მოცემულ კოდის მაგალითში ჩვენ ვქმნით სასურველ მონაცემთა ჩარჩოს ფუნქციის გამოყენებით tibble() .

მონაცემთა ჩარჩოს შექმნა R: dplyr-ში

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

მონაცემთა ჩარჩოს შექმნა R-ში: data.table

მონაცემთა ჩარჩოს შექმნა R-ში: data.table

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

პითონში მონაცემთა ჩარჩოს შექმნა: პანდები

В pandas ფრეიმების შექმნა რამდენიმე ეტაპად მიმდინარეობს, ჯერ ვქმნით ლექსიკონს, შემდეგ კი ლექსიკონს ვაქცევთ მონაცემთა ფრეიმში.

პითონში მონაცემთა ჩარჩოს შექმნა: პანდები

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

სვეტების შერჩევა

ცხრილები, რომლებთანაც მუშაობთ, შეიძლება შეიცავდეს მონაცემთა ათეულობით ან თუნდაც ასობით სვეტს. მაგრამ ანალიზის ჩასატარებლად, როგორც წესი, არ გჭირდებათ ყველა სვეტი, რომელიც ხელმისაწვდომია წყაროს ცხრილში.

ამიტომ, ერთ-ერთი პირველი ოპერაცია, რომელსაც თქვენ შეასრულებთ წყაროს ცხრილით, არის მისი გასუფთავება არასაჭირო ინფორმაციისგან და მეხსიერების განთავისუფლება, რომელსაც ეს ინფორმაცია იკავებს.

სვეტების შერჩევა R-ში: tidyverse, dplyr

სინტაქსი dplyr ძალიან ჰგავს SQL შეკითხვის ენას, თუ კარგად იცნობთ, სწრაფად დაეუფლებით ამ პაკეტს.

სვეტების ასარჩევად გამოიყენეთ ფუნქცია select().

ქვემოთ მოცემულია კოდის მაგალითები, რომლითაც შეგიძლიათ აირჩიოთ სვეტები შემდეგი გზებით:

საჭირო სვეტების სახელების ჩამოთვლა
მიმართეთ სვეტების სახელებს რეგულარული გამონათქვამების გამოყენებით
მონაცემთა ტიპის მიხედვით ან სვეტში მოცემული მონაცემების სხვა თვისებით

სვეტების შერჩევა R-ში: dplyr

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

სვეტების შერჩევა R-ში: data.table

იგივე ოპერაციები data.table შესრულებულია ოდნავ განსხვავებულად, სტატიის დასაწყისში მე მივიღე აღწერა, თუ რა არგუმენტებია კვადრატულ ფრჩხილებში data.table.

DT[i,j,by]

სად:
მე - სად, ე.ი. ფილტრაცია რიგების მიხედვით
j - აირჩიეთ|განახლება|გააკეთე, ე.ი. სვეტების შერჩევა და მათი კონვერტაცია
მიერ - მონაცემთა დაჯგუფება

სვეტების შერჩევა R-ში: data.table

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

ცვალებადი .SD საშუალებას გაძლევთ შეხვიდეთ ყველა სვეტზე და .SDcols გაფილტრეთ საჭირო სვეტები რეგულარული გამონათქვამების ან სხვა ფუნქციების გამოყენებით თქვენთვის საჭირო სვეტების სახელების გასაფილტრად.

სვეტების შერჩევა პითონში, პანდაებში

სვეტების სახელის მიხედვით შესარჩევად pandas საკმარისია მოგვაწოდოთ მათი სახელების სია. და იმისათვის, რომ აირჩიოთ ან გამორიცხოთ სვეტები სახელით რეგულარული გამონათქვამების გამოყენებით, თქვენ უნდა გამოიყენოთ ფუნქციები drop() и filter()და არგუმენტი ღერძი=1, რომლითაც მიუთითებთ, რომ აუცილებელია სვეტების დამუშავება და არა რიგები.

მონაცემთა ტიპის მიხედვით ველის შესარჩევად გამოიყენეთ ფუნქცია select_dtypes()და არგუმენტებში მოიცავს ან გამორიცხავს გაიარეთ მონაცემთა ტიპების სია, რომელიც შეესაბამება ველებს, რომლებიც უნდა აირჩიოთ.

პითონში სვეტების შერჩევა: პანდები

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

სტრიქონების გაფილტვრა

მაგალითად, წყაროს ცხრილი შეიძლება შეიცავდეს რამდენიმე წლის მონაცემს, მაგრამ საჭიროა მხოლოდ გასული თვის ანალიზი. კიდევ ერთხელ, დამატებითი ხაზები ანელებს მონაცემთა დამუშავების პროცესს და დაბლოკავს კომპიუტერის მეხსიერებას.

რიგების გაფილტვრა R-ში: tydyverse, dplyr

В dplyr ფუნქცია გამოიყენება რიგების გასაფილტრად filter(). ის იღებს მონაცემთა ჩარჩოს, როგორც პირველ არგუმენტს, შემდეგ ჩამოთვლით ფილტრაციის პირობებს.

ცხრილის გასაფილტრად ლოგიკური გამონათქვამების დაწერისას, ამ შემთხვევაში, მიუთითეთ სვეტების სახელები ბრჭყალების გარეშე და ცხრილის სახელის გამოცხადების გარეშე.

ფილტრისთვის მრავალი ლოგიკური გამონათქვამის გამოყენებისას გამოიყენეთ შემდეგი ოპერატორები:

& ან მძიმე - ლოგიკური და
| - ლოგიკური ან

რიგების გაფილტვრა 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, რომელსაც აქვს პირველი პოზიცია კვადრატულ ფრჩხილებში.

სვეტებზე წვდომა ხდება ლოგიკურ გამონათქვამებში ბრჭყალების გარეშე და ცხრილის სახელის მითითების გარეშე.

ლოგიკური გამონათქვამები ერთმანეთთან დაკავშირებულია ისევე, როგორც ში dplyr & და | ოპერატორების მეშვეობით.

რიგების გაფილტვრა R-ში: data.table

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

სტრიქონების გაფილტვრა პითონში: პანდები

გაფილტვრა რიგების მიხედვით pandas ფილტრაციის მსგავსი data.table, და შესრულებულია კვადრატულ ფრჩხილებში.

ამ შემთხვევაში, სვეტებზე წვდომა აუცილებლად ხორციელდება მონაცემთა ჩარჩოს სახელის მითითებით; შემდეგ სვეტის სახელი ასევე შეიძლება მიეთითოს ბრჭყალებში კვადრატულ ფრჩხილებში (მაგალითად df['col_name']), ან ციტატების გარეშე პერიოდის შემდეგ (მაგალითად df.col_name).

თუ თქვენ გჭირდებათ მონაცემთა ჩარჩოს გაფილტვრა რამდენიმე პირობით, თითოეული პირობა უნდა განთავსდეს ფრჩხილებში. ლოგიკური პირობები ერთმანეთთან დაკავშირებულია ოპერატორების მიერ & и |.

სტრიქონების გაფილტვრა პითონში: პანდები

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

მონაცემთა დაჯგუფება და აგრეგაცია

მონაცემთა ანალიზის ერთ-ერთი ყველაზე ხშირად გამოყენებული ოპერაცია არის დაჯგუფება და აგრეგაცია.

ამ ოპერაციების შესრულების სინტაქსი მიმოფანტულია ყველა პაკეტში, რომელსაც ჩვენ განვიხილავთ.

ამ შემთხვევაში, ჩვენ ავიღოთ მონაცემთა ჩარჩო, როგორც მაგალითი Titanicდა გამოთვალეთ ბილეთების რაოდენობა და საშუალო ღირებულება სალონის კლასის მიხედვით.

მონაცემთა დაჯგუფება და აგრეგაცია 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() პირველ არგუმენტად ცხრილი გადავიტანეთ Titanic, და შემდეგ მიუთითა ველი პკლასი, რომლითაც დავაჯგუფებთ ჩვენს ცხრილს. ამ ოპერაციის შედეგი ოპერატორის გამოყენებით %>% გადაეცა ფუნქციის პირველ არგუმენტად 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]

მონაცემთა დაჯგუფება და აგრეგაცია პითონში: პანდები

დაჯგუფება pandas მსგავსია dplyr, მაგრამ აგრეგაცია არ არის მსგავსი dplyr არა data.table.

დაჯგუფებისთვის გამოიყენეთ მეთოდი groupby(), რომელშიც უნდა გადაიტანოთ სვეტების სია, რომლითაც დაჯგუფდება მონაცემთა ჩარჩო.

აგრეგაციისთვის შეგიძლიათ გამოიყენოთ მეთოდი agg()რომელიც იღებს ლექსიკონს. ლექსიკონის კლავიშები არის სვეტები, რომლებზეც გამოიყენებთ აგრეგაციის ფუნქციებს, ხოლო მნიშვნელობები არის აგრეგაციის ფუნქციების სახელები.

აგრეგაციის ფუნქციები:

sum() - შეჯამება
min() / max() - მინიმალური და მაქსიმალური მნიშვნელობა
mean() - საშუალო
median() - მედიანა
count() - რაოდენობა

ფუნქცია reset_index() ქვემოთ მოყვანილ მაგალითში ის გამოიყენება ჩადგმული ინდექსების გადატვირთვისთვის pandas ნაგულისხმევია მონაცემების შეკრების შემდეგ.

სტრატეგია საშუალებას გაძლევთ გადახვიდეთ შემდეგ ხაზზე.

დაჯგუფება და აგრეგაცია პითონში: პანდები

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

ცხრილების ვერტიკალური შეერთება

ოპერაცია, რომელშიც თქვენ უერთდებით ერთი და იგივე სტრუქტურის ორ ან მეტ ცხრილს. ჩვენ მიერ ჩატვირთული მონაცემები შეიცავს ცხრილებს ga_nov и ga_dec. ეს ცხრილები სტრუქტურით იდენტურია, ე.ი. აქვს იგივე სვეტები და მონაცემთა ტიპები ამ სვეტებში.

ეს არის Google Analytics-ის ატვირთვა ნოემბრისა და დეკემბრის თვისთვის, ამ განყოფილებაში ჩვენ გავაერთიანებთ ამ მონაცემებს ერთ ცხრილში.

ცხრილების ვერტიკალურად შეერთება R-ში: tidyverse, dplyr

В dplyr ფუნქციის გამოყენებით შეგიძლიათ დააკავშიროთ 2 ცხრილი ერთში bind_rows(), ცხრილების გადაცემა მის არგუმენტებად.

რიგების გაფილტვრა R-ში: dplyr

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

ცხრილების ვერტიკალურად შეერთება R-ში: data.table

ეს ასევე არაფერია რთული, მოდით გამოვიყენოთ rbind().

რიგების გაფილტვრა R-ში: data.table

## data.table
rbind(ga_nov, ga_dec)

პითონში ცხრილების ვერტიკალურად შეერთება: პანდები

В pandas ფუნქცია გამოიყენება ცხრილების შესაერთებლად concat(), რომელშიც თქვენ უნდა გაიაროთ ჩარჩოების სია, რომ დააკავშიროთ ისინი.

სტრიქონების გაფილტვრა პითონში: პანდები

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

ცხრილების ჰორიზონტალური შეერთება

ოპერაცია, რომლის დროსაც სვეტები მეორედან ემატება პირველ ცხრილს გასაღებით. ის ხშირად გამოიყენება ფაქტების ცხრილის (მაგალითად, ცხრილის გაყიდვების მონაცემებით) გამდიდრებისას ზოგიერთი საცნობარო მონაცემებით (მაგალითად, პროდუქტის ღირებულება).

არსებობს რამდენიმე სახის შეერთება:

ადრე დატვირთულ ცხრილში Titanic ჩვენ გვაქვს სვეტი Sex, რომელიც შეესაბამება მგზავრის სქესის კოდს:

1 - ქალი
2 - მამრობითი

ასევე, შევქმენით ცხრილი - საცნობარო წიგნი სქესი. მგზავრების სქესის შესახებ მონაცემების უფრო მოსახერხებელი წარმოდგენისთვის, ჩვენ უნდა დავამატოთ სქესის სახელი დირექტორიადან სქესი მაგიდასთან Titanic.

ჰორიზონტალური ცხრილის შეერთება 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().

არგუმენტები merge() ფუნქციონირებს data.table-ში

x, y - მაგიდები შესაერთებლად
მიერ - სვეტი, რომელიც არის შეერთების გასაღები, თუ მას ერთი და იგივე სახელი აქვს ორივე ცხრილში
by.x, by.y - სვეტების სახელები, რომლებიც უნდა გაერთიანდეს, თუ მათ ცხრილებში განსხვავებული სახელები აქვთ
all, all.x, all.y — შეერთების ტიპი, ყველა დააბრუნებს ყველა რიგს ორივე ცხრილიდან, all.x შეესაბამება LEFT JOIN ოპერაციას (დატოვებს პირველი ცხრილის ყველა სტრიქონს), all.y - შეესაბამება ოპერაცია RIGHT JOIN (დატოვებს მეორე ცხრილის ყველა მწკრივს).

ცხრილების ჰორიზონტალური შეერთება R-ში: მონაცემები.ცხრილი

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

ჰორიზონტალური მაგიდის შეერთება პითონში: პანდები

ისევე როგორც ში data.tableIn pandas ფუნქცია გამოიყენება ცხრილების შესაერთებლად merge().

merge() ფუნქციის არგუმენტები პანდაებში

როგორ — კავშირის ტიპი: მარცხენა, მარჯვენა, გარე, შიდა
on — სვეტი, რომელიც არის გასაღები, თუ მას ერთი და იგივე სახელი აქვს ორივე ცხრილში
left_on, right_on — საკვანძო სვეტების სახელები, თუ მათ აქვთ სხვადასხვა სახელები ცხრილებში

ჰორიზონტალური მაგიდის შეერთება პითონში: პანდები

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

ფანჯრის ძირითადი ფუნქციები და გამოთვლილი სვეტები

ფანჯრის ფუნქციები მსგავსია აგრეგაციის ფუნქციების მნიშვნელობით და ასევე ხშირად გამოიყენება მონაცემთა ანალიზში. მაგრამ აგრეგაციის ფუნქციებისგან განსხვავებით, ფანჯრის ფუნქციები არ ცვლის გამავალი მონაცემთა ჩარჩოს რიგების რაოდენობას.

არსებითად, ფანჯრის ფუნქციის გამოყენებით, ჩვენ ვყოფთ შემომავალ მონაცემთა ჩარჩოს ნაწილებად გარკვეული კრიტერიუმის მიხედვით, ე.ი. ველის ან რამდენიმე ველის მნიშვნელობით. და ჩვენ ვასრულებთ არითმეტიკულ მოქმედებებს თითოეულ ფანჯარაზე. ამ ოპერაციების შედეგი დაბრუნდება თითოეულ სტრიქონში, ე.ი. ცხრილის რიგების მთლიანი რაოდენობის შეცვლის გარეშე.

მაგალითად, ავიღოთ ცხრილი Titanic. ჩვენ შეგვიძლია გამოვთვალოთ რამდენი პროცენტი იყო თითოეული ბილეთის ღირებულება მის სალონში.

ამისათვის, თითოეულ ხაზში უნდა მივიღოთ ბილეთის ჯამური ღირებულება სალონის მიმდინარე კლასისთვის, რომელსაც ეკუთვნის ამ ხაზის ბილეთი, შემდეგ გავყოთ თითოეული ბილეთის ღირებულება იმავე კლასის ყველა ბილეთის ჯამურ ღირებულებაზე. .

ფანჯრის ფუნქციები R-ში: tidyverse, dplyr

ახალი სვეტების დასამატებლად, მწკრივების დაჯგუფების გამოყენების გარეშე, in dplyr ემსახურება ფუნქციას mutate().

თქვენ შეგიძლიათ მოაგვაროთ ზემოთ აღწერილი პრობლემა მონაცემების ველების მიხედვით დაჯგუფებით პკლასი და ველის შეჯამება ახალ სვეტში გამოფენა. შემდეგი, გააუქმეთ ცხრილი და გაყავით ველის მნიშვნელობები გამოფენა რაც მოხდა წინა ეტაპზე.

ფანჯრის ფუნქციები R: dplyr

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

ფანჯრის ფუნქციები R-ში: data.table

ამოხსნის ალგორითმი იგივე რჩება, რაც აქ dplyr, ცხრილი უნდა გავყოთ ფანჯრებად ველების მიხედვით პკლასი. ახალ სვეტში გამოიტანეთ თანხა თითოეული მწკრივის შესაბამისი ჯგუფისთვის და დაამატეთ სვეტი, რომელშიც ვიანგარიშებთ თითოეული ბილეთის ღირებულების წილს მის ჯგუფში.

ახალი სვეტების დასამატებლად data.table ოპერატორი იმყოფება :=. ქვემოთ მოცემულია პაკეტის გამოყენებით პრობლემის გადაჭრის მაგალითი data.table

ფანჯრის ფუნქციები R-ში: data.table

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

ფანჯრის ფუნქციები პითონში: პანდები

ახალი სვეტის დამატების ერთი გზა pandas - გამოიყენეთ ფუნქცია assign(). ბილეთების ღირებულების შესაჯამებლად სალონის კლასის მიხედვით, რიგების დაჯგუფების გარეშე, გამოვიყენებთ ფუნქციას transform().

ქვემოთ მოცემულია გამოსავლის მაგალითი, რომელშიც ვამატებთ ცხრილს Titanic იგივე 2 სვეტი.

ფანჯრის ფუნქციები პითონში: პანდები

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-ში მონაცემებთან მუშაობის სხვა ტექნიკით.

როგორც ზემოთ დავწერე, სტატიის მიზანი იყო არა საკუთარი აზრის დაწესება იმაზე, თუ რომელი ენა ჯობია, არამედ გამარტივებულიყო ორივე ენის შესწავლის, ან საჭიროების შემთხვევაში მათ შორის მიგრაციის შესაძლებლობა.

თუ მოგეწონათ სტატია, მოხარული ვიქნები, რომ მეყოლება ჩემი ახალი აბონენტები youtube и ტელეგრამა არხები.

ინტერვიუ

ქვემოთ ჩამოთვლილთაგან რომელს იყენებთ თქვენს საქმიანობაში?

კომენტარებში შეგიძლიათ დაწეროთ თქვენი არჩევანის მიზეზი.

გამოკითხვაში მონაწილეობა შეუძლიათ მხოლოდ დარეგისტრირებულ მომხმარებლებს. Შებრძანდითგთხოვთ

მონაცემთა დამუშავების რომელ პაკეტს იყენებთ (შეგიძლიათ აირჩიოთ რამდენიმე ვარიანტი)

45,2%დალაგებული სამყარო19
33,3%მონაცემები.ცხრილი14
54,8%პანდები23

მისცა ხმა 42 მომხმარებელმა. 9 მომხმარებელმა თავი შეიკავა.

წყარო: www.habr.com