בחיפוש R או Python באינטרנט, תמצא מיליוני מאמרים וקילומטרים של דיונים בנושא איזה מהם עדיף, מהיר ונוח יותר לעבודה עם נתונים. אך למרבה הצער, כל המאמרים והמחלוקות הללו אינם שימושיים במיוחד.

מטרת מאמר זה היא להשוות את טכניקות עיבוד הנתונים הבסיסיות בחבילות הפופולריות ביותר של שתי השפות. ועזור לקוראים לשלוט במהירות במשהו שהם עדיין לא יודעים. למי שכותב ב-Python, גלה כיצד לעשות את אותו הדבר ב-R, ולהיפך.

במהלך המאמר ננתח את התחביר של החבילות הפופולריות ביותר ב-R. אלו החבילות הכלולות בספרייה tidyverseוגם החבילה data.table. ולהשוות את התחביר שלהם עם pandas, חבילת ניתוח הנתונים הפופולרית ביותר ב-Python.

נעבור צעד אחר צעד לאורך כל הנתיב של ניתוח הנתונים מטעינתם ועד לביצוע פונקציות חלון אנליטיות באמצעות Python ו-R.

תוכן

מאמר זה יכול לשמש כדף רמייה אם שכחת כיצד לבצע פעולת עיבוד נתונים כלשהי באחת החבילות הנבדקות.

1. הבדלי תחביר עיקריים בין R לפייתון
   1.1. גישה לפונקציות החבילה
   1.2. מְשִׁימָה
   1.3. אינדקס
   1.4. שיטות ו-OOP
   1.5. צינורות
   1.6. מבני מידע
2. כמה מילים על החבילות בהן נשתמש
   2.1. מסודר
   2.2. טבלת נתונים
   2.3. דובי פנדה
3. התקנת חבילות
4. טוען נתונים
5. יצירת מסגרות נתונים
6. בחירת העמודות שאתה צריך
7. סינון שורות
8. קיבוץ ואגרגציה
9. איחוד אנכי של טבלאות (UNION)
10. צירוף אופקי של טבלאות (JOIN)
11. פונקציות בסיסיות של חלון ועמודות מחושבות
12. טבלת התאמה בין שיטות עיבוד נתונים ב-R וב-Python
13. מסקנה
14. סקר קצר על איזו חבילה אתה משתמש

אם אתה מעוניין בניתוח נתונים, אולי תמצא את שלי מברק и YouTube ערוצים. רוב התוכן מוקדש לשפת R.

הבדלי תחביר עיקריים בין R לפייתון

כדי להקל עליכם את המעבר מ-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 פעולות ברצף, והתוצאה של כל אחת נשמרה באובייקט נפרד. אבל למעשה, אנחנו לא צריכים את חפצי הביניים האלה.

או אפילו יותר גרוע, אבל יותר מוכר למשתמשי אקסל.

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 דומים, אך יש להם שמות שונים.

תיאור
שם ב-R
שם בפייתון/פנדות

מבנה השולחן
data.frame, data.table, tibble
DataFrame

רשימת ערכים חד מימדית
וקטור
סדרה בפנדות או רשימה בפייתון טהור

מבנה רב מפלסי שאינו טבלאי
רשימה
מילון (דיקט)

נסתכל על כמה תכונות אחרות והבדלים בתחביר להלן.

כמה מילים על החבילות בהן נשתמש

ראשית, אספר לכם מעט על החבילות שתכירו במהלך מאמר זה.

מסודר

אתר רשמי: tidyverse.org

הספרייה tidyverse נכתב על ידי Hedley Wickham, מדען מחקר בכיר ב-RStudio. tidyverse מורכב מסט מרשים של חבילות המפשטות את עיבוד הנתונים, 5 מהן כלולות בעשרת ההורדות המובילות ממאגר CRAN.

ליבת הספרייה מורכבת מהחבילות הבאות: ggplot2, dplyr, tidyr, readr, purrr, tibble, stringr, forcats. כל אחת מהחבילות הללו נועדה לפתור בעיה ספציפית. לדוגמה dplyr נוצר עבור מניפולציה של נתונים, tidyr להביא את הנתונים לצורה מסודרת, stringr מפשט את העבודה עם מחרוזות, ו ggplot2 הוא אחד הכלים הפופולריים ביותר להדמיית נתונים.

היתרון tidyverse הוא תחביר הפשטות והקל לקריאה, שדומה במובנים רבים לשפת השאילתות של SQL.

טבלת נתונים

אתר רשמי: r-datatable.com

מְחַבֵּר data.table הוא מאט דול מ-H2O.ai.

ההוצאה הראשונה של הספרייה התרחשה ב-2006.

תחביר החבילה אינו נוח כמו ב tidyverse ומזכיר יותר מסגרות נתונים קלאסיות ב-R, אך במקביל מורחבת משמעותית בפונקציונליות.

כל המניפולציות עם הטבלה בחבילה זו מתוארות בסוגריים מרובעים, ואם אתה מתרגם את התחביר data.table ב-SQL אתה מקבל משהו כזה: data.table[ WHERE, SELECT, GROUP BY ]

החוזק של חבילה זו הוא מהירות העיבוד של כמויות גדולות של נתונים.

דובי פנדה

אתר רשמי: pandas.pydata.org

שמה של הספרייה מגיע מהמונח האקונומטרי "נתוני פאנל", המשמש לתיאור קבוצות מובנות רב-ממדיות של מידע.

מְחַבֵּר pandas הוא האמריקאי ווס מקיני.

כשזה מגיע לניתוח נתונים ב-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 טהור, אז pandas אתה צריך להתקין אותו ידנית. פתח שורת פקודה, או מסוף, בהתאם למערכת ההפעלה שלך והזן את הפקודה הבאה.

pip install pandas

לאחר מכן נחזור לפייתון ונייבא את החבילה המותקנת עם הפקודה import.

import pandas as pd

טוען נתונים

כריית נתונים היא אחד השלבים החשובים ביותר בניתוח נתונים. גם Python וגם R, אם תרצה, מספקים לך הזדמנויות נרחבות להשיג נתונים מכל מקורות: קבצים מקומיים, קבצים מהאינטרנט, אתרי אינטרנט, כל מיני מסדי נתונים.

לאורך המאמר נשתמש במספר מערכי נתונים:

1. שתי הורדות מגוגל אנליטיקס.
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")

טוען נתונים בפייתון: פנדות

אם נשווה עם חבילות R, אז במקרה זה התחביר הוא הקרוב ביותר pandas רצון readr, כי pandas יכול לבקש נתונים מכל מקום, ויש משפחה שלמה של פונקציות בחבילה הזו read_*().

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

ועוד פונקציות רבות שנועדו לקרוא נתונים מפורמטים שונים. אבל לענייננו זה מספיק read_table() או read_csv() באמצעות טיעון ספטמבר כדי לציין את מפריד העמודות.

טוען נתונים בפייתון: פנדות

import pandas as pd

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

יצירת מסגרות נתונים

בטבלה כביר, אשר העמסנו, יש שדה מִין, המאחסן את מזהה המגדר של הנוסע.

אבל להצגה נוחה יותר של נתונים במונחים של מגדר הנוסע, כדאי להשתמש בשם ולא בקוד המגדר.

לשם כך, ניצור ספרייה קטנה, טבלה שבה יהיו רק 2 עמודות (קוד ושם מגדר) ו-2 שורות, בהתאמה.

יצירת מסגרת נתונים ב-R: tidyverse, dplyr

בדוגמה של הקוד שלהלן, אנו יוצרים את מסגרת הנתונים הרצויה באמצעות הפונקציה tibble() .

יצירת מסגרת נתונים ב-R: dplyr

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

יצירת מסגרת נתונים ב-R: data.table

יצירת מסגרת נתונים ב-R: data.table

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

יצירת מסגרת נתונים ב-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]

איפה:
אני - איפה, כלומר. סינון לפי שורות
j - בחר|עדכן|עשה, כלומר. בחירת עמודות והמרתן
לפי - קיבוץ נתונים

בחירת עמודות ב-R: data.table

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

משתנה .SD מאפשר לך לגשת לכל העמודות, ו .SDcols לסנן את העמודות הנדרשות באמצעות ביטויים רגולריים, או פונקציות אחרות כדי לסנן את שמות העמודות הדרושים לך.

בחירת עמודות בפייתון, פנדות

כדי לבחור עמודות לפי שם ב pandas מספיק לספק רשימה של שמותיהם. וכדי לבחור או לא לכלול עמודות לפי שם באמצעות ביטויים רגולריים, עליך להשתמש בפונקציות drop() и filter(), וטיעון ציר=1, שבאמצעותו אתה מציין שיש צורך לעבד עמודות ולא שורות.

כדי לבחור שדה לפי סוג נתונים, השתמש בפונקציה select_dtypes(), ולתוך ויכוחים לכלול או להוציא להעביר רשימה של סוגי נתונים התואמים לאילו שדות עליך לבחור.

בחירת עמודות בפייתון: פנדות

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

סינון שורות

לדוגמה, טבלת המקור עשויה להכיל מספר שנים של נתונים, אך עליך לנתח רק את החודש האחרון. שוב, קווים נוספים יאטו את תהליך עיבוד הנתונים ויסתמו את זיכרון המחשב.

סינון שורות ב-R: tydyverse, dplyr

В dplyr הפונקציה משמשת לסינון שורות filter(). זה לוקח מסגרת נתונים בתור הארגומנט הראשון, ואז אתה מפרט את תנאי הסינון.

בעת כתיבת ביטויים לוגיים לסינון טבלה, במקרה זה, ציין את שמות העמודות ללא מרכאות ומבלי להכריז על שם הטבלה.

בעת שימוש במספר ביטויים לוגיים לסינון, השתמש באופרטורים הבאים:

• & או פסיק - הגיוני AND
• | - 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]

איפה:
אני - איפה, כלומר. סינון לפי שורות
j - בחר|עדכן|עשה, כלומר. בחירת עמודות והמרתן
לפי - קיבוץ נתונים

הארגומנט משמש לסינון שורות i, בעל המיקום הראשון בסוגריים מרובעים.

הגישה לעמודות היא בביטויים לוגיים ללא מרכאות וללא ציון שם הטבלה.

ביטויים לוגיים קשורים זה לזה באותו אופן כמו ב dplyr באמצעות המפעילים & ו-|.

סינון שורות ב-R: data.table

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

מיתרי סינון בפייתון: פנדות

סנן לפי שורות ב pandas דומה לסינון פנימה data.table, והוא נעשה בסוגריים מרובעים.

במקרה זה, הגישה לעמודות מתבצעת בהכרח על ידי ציון שם מסגרת הנתונים; אז ניתן לציין את שם העמודה גם במרכאות בסוגריים מרובעים (דוגמה df['col_name']), או ללא מרכאות לאחר התקופה (דוגמה df.col_name).

אם אתה צריך לסנן מסגרת נתונים לפי מספר תנאים, כל תנאי חייב להיות ממוקם בסוגריים. תנאים לוגיים קשורים זה לזה על ידי מפעילים & и |.

מיתרי סינון בפייתון: פנדות

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

קיבוץ וצבירה של נתונים

אחת הפעולות הנפוצות ביותר בניתוח נתונים היא קיבוץ ואגרגציה.

התחביר לביצוע פעולות אלו מפוזר על פני כל החבילות שאנו בודקים.

במקרה זה, ניקח מסגרת נתונים כדוגמה כביר, וחשב את המספר והעלות הממוצעת של כרטיסים בהתאם למחלקת הבקתה.

קיבוץ וצבירת נתונים ב-R: tidyverse, dplyr

В dplyr הפונקציה משמשת לקיבוץ group_by(), ולצבירה summarise(). למעשה, dplyr יש משפחה שלמה של פונקציות summarise_*(), אבל מטרת המאמר הזה היא להשוות את התחביר הבסיסי, אז לא ניכנס לג'ונגל כזה.

פונקציות צבירה בסיסיות:

• sum() - סיכום
• min() / max() - ערך מינימום ומקסימום
• mean() - ממוצע
• median() - חציון
• length() - כמות

קיבוץ וצבירה בר': דפליר

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

לתפקד group_by() העברנו את הטבלה כטיעון הראשון כביר, ולאחר מכן ציין את השדה Pclass, שלפיו נקבץ את השולחן שלנו. התוצאה של פעולה זו באמצעות האופרטור %>% הועבר כארגומנט הראשון לפונקציה summarise(), והוסיפו עוד 2 שדות: נוסעים и avg_price. בראשון, באמצעות הפונקציה length() חישב את מספר הכרטיסים, ובשני באמצעות הפונקציה mean() קיבל את מחיר הכרטיס הממוצע.

קיבוץ וצבירת נתונים ב-R: data.table

В data.table הארגומנט משמש לצבירה j שיש לו מיקום שני בסוגריים מרובעים, ולקיבוץ by או keyby, שיש להם את המיקום השלישי.

רשימת פונקציות הצבירה במקרה זה זהה לזו המתוארת ב dplyr, כי אלו הן פונקציות מתחביר R הבסיסי.

קיבוץ וצבירה ב-R: data.table

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

קיבוץ וצבירת נתונים בפייתון: פנדות

מקבץ פנימה pandas דומה ל dplyr, אבל הצבירה לא דומה ל dplyr לא על data.table.

כדי לקבץ, השתמש בשיטה groupby(), שאליו אתה צריך להעביר רשימה של עמודות שלפיהן תקובץ מסגרת הנתונים.

לצבירה ניתן להשתמש בשיטה agg()שמקבל מילון. מפתחות המילון הם העמודות שעליהן תחיל את פונקציות הצבירה, והערכים הם שמות פונקציות הצבירה.

פונקציות צבירה:

• sum() - סיכום
• min() / max() - ערך מינימום ומקסימום
• mean() - ממוצע
• median() - חציון
• count() - כמות

פונקציה reset_index() בדוגמה למטה הוא משמש לאיפוס אינדקסים מקוננים ש pandas ברירת המחדל היא לאחר צבירת נתונים.

סמל מאפשר לך לעבור לשורה הבאה.

קיבוץ וצבירה בפייתון: פנדות

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

צירוף אנכי של טבלאות

פעולה שבה אתה מצטרף לשתי טבלאות או יותר מאותו מבנה. הנתונים שהעלינו מכילים טבלאות ga_nov и ga_dec. טבלאות אלו זהות במבנה, כלומר. יש את אותן עמודות, ואת סוגי הנתונים בעמודות אלו.

זוהי העלאה מגוגל אנליטיקס לחודשים נובמבר ודצמבר, בחלק זה נשלב את הנתונים הללו לטבלה אחת.

חיבור אנכי של טבלאות ב-R: tidyverse, dplyr

В dplyr ניתן לשלב 2 טבלאות לאחת באמצעות הפונקציה bind_rows(), העברת טבלאות כטיעונים שלה.

מסנן שורות ב-R: dplyr

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

צירוף אנכי של טבלאות ב-R: data.table

זה גם לא מסובך, בואו נשתמש rbind().

סינון שורות ב-R: data.table

## data.table
rbind(ga_nov, ga_dec)

חיבור אנכי של טבלאות בפייתון: פנדות

В pandas הפונקציה משמשת לצירוף טבלאות concat(), שאליו אתה צריך להעביר רשימה של מסגרות כדי לשלב אותם.

מיתרי סינון בפייתון: פנדות

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

צירוף אופקי של שולחנות

פעולה שבה עמודות מהשנייה מתווספות לטבלה הראשונה על ידי מפתח. הוא משמש לעתים קרובות כאשר מעשירים טבלת עובדות (לדוגמה, טבלה עם נתוני מכירות) בכמה נתוני התייחסות (לדוגמה, עלות מוצר).

ישנם מספר סוגי הצטרפות:

בטבלה שנטענה קודם לכן כביר יש לנו עמודה מִין, המתאים לקוד המגדר של הנוסע:

1 - נקבה
2 - זכר

כמו כן, יצרנו טבלה - ספר עיון מין. להצגה נוחה יותר של נתונים על מין הנוסעים, עלינו להוסיף את שם המגדר מהספרייה מין לשולחן כביר.

טבלה אופקית מצטרפת ב-R: tidyverse, dplyr

В dplyr יש משפחה שלמה של פונקציות להצטרפות אופקית:

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

הנפוץ ביותר בתרגול שלי הוא left_join().

בתור שני הארגומנטים הראשונים, לפונקציות המפורטות למעלה נדרשות שתי טבלאות כדי להצטרף, וכארגומנט השלישי by עליך לציין את העמודות להצטרפות.

שולחן אופקי מצטרפים ב-R: dplyr

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

צירוף אופקי של טבלאות ב-R: data.table

В data.table עליך להצטרף לטבלאות באמצעות מקש באמצעות הפונקציה merge().

הפונקציה ארגומנטים למיזוג() ב-data.table

• x, y - טבלאות להצטרפות
• by — עמודה שהיא המפתח להצטרפות אם יש לה אותו שם בשתי הטבלאות
• by.x, by.y - שמות עמודות שיש למזג, אם יש להן שמות שונים בטבלאות
• all, all.x, all.y — סוג החיבור, all יחזיר את כל השורות משתי הטבלאות, all.x מתאים לפעולת LEFT JOIN (יעזוב את כל השורות של הטבלה הראשונה), all.y — מתאים ל- פעולת RIGHT JOIN (תשאיר את כל השורות של הטבלה השנייה).

צירוף אופקי של טבלאות ב-R: data.table

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

הצטרפות שולחן אופקי לפייתון: פנדות

כמו גם ב data.tableבתוך pandas הפונקציה משמשת לצירוף טבלאות merge().

טיעונים של פונקציית המיזוג() בפנדות

• איך - סוג חיבור: שמאל, ימין, חיצוני, פנימי
• on - עמודה שהיא מפתח אם יש לה אותו שם בשתי הטבלאות
• left_on, right_on - שמות של עמודות מפתח, אם יש להן שמות שונים בטבלאות

הצטרפות שולחן אופקי לפייתון: פנדות

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

פונקציות בסיסיות של חלון ועמודות מחושבות

פונקציות חלון דומות במשמעותן לפונקציות צבירה, והן משמשות לעתים קרובות גם בניתוח נתונים. אבל בניגוד לפונקציות צבירה, פונקציות חלון אינן משנות את מספר השורות של מסגרת הנתונים היוצאת.

בעיקרו של דבר, באמצעות פונקציית החלון, אנו מפצלים את מסגרת הנתונים הנכנסת לחלקים לפי קריטריון כלשהו, ​​כלומר. לפי הערך של שדה, או מספר שדות. ואנחנו מבצעים פעולות אריתמטיות בכל חלון. התוצאה של פעולות אלו תוחזר בכל שורה, כלומר. מבלי לשנות את המספר הכולל של שורות בטבלה.

לדוגמה, בואו ניקח את הטבלה כביר. אנו יכולים לחשב כמה אחוזים עלות כל כרטיס הייתה במסגרת מחלקת הבקתה שלו.

לשם כך, עלינו לקבל בכל קו את העלות הכוללת של כרטיס למחלקת הקבינה הנוכחית אליה שייך הכרטיס בקו זה, ואז לחלק את העלות של כל כרטיס בעלות הכוללת של כל הכרטיסים של אותה מחלקת תא נוסעים. .

פונקציות חלון ב-R: tidyverse, dplyr

כדי להוסיף עמודות חדשות, מבלי להשתמש בקיבוץ שורות, ב dplyr משרת פונקציה mutate().

אתה יכול לפתור את הבעיה שתוארה לעיל על ידי קיבוץ נתונים לפי שדה 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]

פונקציות חלון בפייתון: פנדות

דרך אחת להוסיף לה עמודה חדשה pandas - השתמש בפונקציה assign(). לסיכום עלות הכרטיסים לפי כיתת בקתה, ללא קיבוץ שורות, נשתמש בפונקציה transform().

להלן דוגמה לפתרון בו נוסיף לטבלה כביר אותן 2 עמודות.

פונקציות חלון בפייתון: פנדות

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

טבלת התאמת פונקציות ושיטות

להלן טבלת התאמה בין שיטות לביצוע פעולות שונות עם נתונים בחבילות בהן שקלנו.

תיאור
מסודר
טבלת נתונים
דובי פנדה

טוען נתונים
vroom()/ readr::read_csv() / readr::read_tsv()
fread()
read_csv()

יצירת מסגרות נתונים
tibble()
data.table()
dict() + from_dict()

בחירת עמודות
select()
ויכוח j, מיקום שני בסוגריים מרובעים
אנו מעבירים את רשימת העמודות הנדרשות בסוגריים מרובעים / drop() / filter() / select_dtypes()

סינון שורות
filter()
ויכוח i, מיקום ראשון בסוגריים מרובעים
אנו מפרטים את תנאי הסינון בסוגריים מרובעים / filter()

קיבוץ ואגרגציה
group_by() + summarise()
ארגומנטים j + by
groupby() + agg()

איחוד אנכי של טבלאות (UNION)
bind_rows()
rbind()
concat()

צירוף אופקי של טבלאות (JOIN)
left_join() / *_join()
merge()
merge()

פונקציות בסיסיות של חלון והוספת עמודות מחושבות
group_by() + mutate()
ויכוח j באמצעות המפעיל := + טיעון by
transform() + assign()

מסקנה

אולי במאמר תיארתי לא את המימושים האופטימליים ביותר של עיבוד נתונים, אז אני אשמח אם תתקן את הטעויות שלי בהערות, או פשוט תשלים את המידע שניתן במאמר עם טכניקות אחרות לעבודה עם נתונים ב- R / Python.

כפי שכתבתי למעלה, מטרת המאמר לא הייתה לכפות את דעתו על איזו שפה עדיפה, אלא לפשט את ההזדמנות ללמוד את שתי השפות, או, במידת הצורך, לנדוד ביניהן.

אם אהבתם את המאמר, אשמח לקבל מנויים חדשים אצלי YouTube и מִברָק ערוצים.

ראיון

באילו מהחבילות הבאות אתה משתמש בעבודה שלך?

בתגובות תוכלו לכתוב את הסיבה לבחירתכם.

רק משתמשים רשומים יכולים להשתתף בסקר. להתחברבבקשה.

באיזו חבילת עיבוד נתונים אתה משתמש (תוכל לבחור מספר אפשרויות)

• 45,2%מסודר19

• 33,3%data.table14

• 54,8%פנדות23

42 משתמשים הצביעו. 9 משתמשים נמנעו.

מקור: www.habr.com