R ट्यूटोरियल में dplyr: उदाहरणों सहित डेटा को मर्ज और जॉइन करना
एवलिन क्लार्क
⚡ स्मार्ट सारांश
R में dplyr चार क्रियाओं (left_join(), right_join(), inner_join() और full_join()) का उपयोग करके डेटा फ़्रेमों को मर्ज और जॉइन करता है। इसका सहयोगी पैकेज tidyr फिर gather(), spread(), separate() और unite() का उपयोग करके जॉइन किए गए परिणाम को रीशेप करता है।
डेटा विश्लेषण का परिचय
किसी भी सदस्यता या पुनर्साझाकरण से पहलेping क्रिया का अर्थ स्पष्ट है, इससे यह समझने में मदद मिलती है कि डेटा हेरफेर कहाँ फिट बैठता है। डेटा विश्लेषण इसे तीन भागों में विभाजित किया जा सकता है:
- Extracउत्पादनसबसे पहले, हमें कई स्रोतों से डेटा एकत्र करना होगा और उन्हें संयोजित करना होगा।
- बदालना: इस चरण में डेटा हेरफेर शामिल है। एक बार जब हम डेटा के सभी स्रोतों को समेकित कर लेते हैं, तो हम डेटा को साफ करना शुरू कर सकते हैं।
- कल्पनाअंतिम कदम अनियमितता की जांच के लिए हमारे डेटा को दृश्यमान करना है।
नीचे दिया गया चित्र दर्शाता है कि तीनों चरण आपस में कैसे जुड़े हुए हैं।
डेटा वैज्ञानिकों के सामने आने वाली सबसे महत्वपूर्ण चुनौतियों में से एक है डेटा का हेरफेर। डेटा कभी भी वांछित प्रारूप में उपलब्ध नहीं होता है। डेटा वैज्ञानिकों को अपने समय का कम से कम आधा हिस्सा डेटा को साफ करने और उसमें हेरफेर करने में व्यतीत करना पड़ता है। यह उनके पेशे के सबसे महत्वपूर्ण कार्यों में से एक है। यदि डेटा हेरफेर प्रक्रिया पूर्ण, सटीक और सुव्यवस्थित नहीं है, तो मॉडल सही ढंग से काम नहीं करेगा।
आर डीपीएलवाईआर
R में dplyr नामक एक पैकेज है जो डेटा रूपांतरण का कार्य करता है। यह कुछ मुख्य क्रियाओं — filter(), select(), arrange(), mutate() और summarise() — और कई join फ़ंक्शनों पर आधारित है। डेटा के रूपांतरण के बाद, ggplot2 इसे प्रदर्शित कर सकता है।
हम सीखेंगे कि dplyr पैकेज का उपयोग करके किसी ऑब्जेक्ट में हेरफेर कैसे किया जाता है। डेटा ढांचायदि R अभी तक स्थापित नहीं है, तो निम्नलिखित चरणों का पालन करें। R और RStudio सेटअप करने के चरणफिर install.packages(“dplyr”) चलाएँ।
dplyr का उपयोग करके डेटा मर्ज करें
dplyr डेटासेट को संयोजित करने का एक अच्छा और सुविधाजनक तरीका प्रदान करता है। हमारे पास इनपुट डेटा के कई स्रोत हो सकते हैं, और किसी बिंदु पर, हमें उन्हें संयोजित करने की आवश्यकता होती है। dplyr के साथ जुड़ने से मूल डेटासेट के दाईं ओर चर जुड़ जाते हैं।
dplyr जॉइन
dplyr में दो डेटासेट को मर्ज करने के लिए उपयोग किए जाने वाले चार महत्वपूर्ण प्रकार के जॉइन निम्नलिखित हैं। ये चारों समान आर्गुमेंट लेते हैं — दो टेबल और कुंजी — और केवल इस बात में भिन्न होते हैं कि कौन सी बेमेल पंक्तियाँ शेष रहती हैं:
| समारोह | उद्देश्य | तर्क | एकाधिक कुंजी |
|---|---|---|---|
| बाँया जोड़() | दो डेटासेट मर्ज करें। मूल तालिका से सभी अवलोकन रखें | x, y, by = “आईडी” | x, y, by = c(“ID”, “ID2”) |
| दायाँ_जुड़ना() | दो डेटासेट मर्ज करें। गंतव्य तालिका से सभी अवलोकन रखें | x, y, by = “आईडी” | x, y, by = c(“ID”, “ID2”) |
| आंतरिक रूप से जुड़ा() | दो डेटासेट को मर्ज करें। सभी बेमेल पंक्तियों को हटा दें। | x, y, by = “आईडी” | x, y, by = c(“ID”, “ID2”) |
| पूर्ण_ज्वाइन() | दो डेटासेट को मर्ज करें। सभी अवलोकन सुरक्षित रखें। | x, y, by = “आईडी” | x, y, by = c(“ID”, “ID2”) |
ये चार क्रियाएँ क्रमशः LEFT, RIGHT, INNER और FULL OUTER के जोड़ से मेल खाती हैं। एसक्यूएलबेस R, all, all.x और all.y तर्कों के माध्यम से समान परिणाम प्राप्त करता है। मर्ज ().
हम एक सरल उदाहरण के माध्यम से सभी प्रकार के जॉइन का अध्ययन करेंगे।
सबसे पहले, हम दो डेटासेट बनाते हैं। तालिका 1 में दो चर, ID और y हैं, जबकि तालिका 2 में ID और z शामिल हैं। प्रत्येक स्थिति में, हमें एक कुंजी-जोड़ी चर। हमारे मामले में, आईडी हमारा है कुंजी यह फ़ंक्शन दोनों तालिकाओं में समान मानों की खोज करेगा और प्राप्त मानों को तालिका 1 के दाईं ओर जोड़ देगा। नीचे दिए गए चित्र में दोनों तालिकाओं को साथ-साथ दिखाया गया है।
library(dplyr) df_primary <- tribble( ~ID, ~y, "A", 5, "B", 5, "C", 8, "D", 0, "F", 9) df_secondary <- tribble( ~ID, ~z, "A", 30, "B", 21, "C", 22, "D", 25, "E", 29)
dplyr left_join()
दो डेटासेट को मर्ज करने का सबसे आम तरीका left_join() फ़ंक्शन का उपयोग करना है। नीचे दिए गए चित्र में दिखाया गया है कि कुंजी-जोड़ी पंक्तियों A, B, C और D से मेल खाती है, जबकि E और F शेष रह जाती हैं। left_join() का उपयोग करके, हम मूल तालिका की सभी पंक्तियों को रखते हैं और गंतव्य तालिका में उन पंक्तियों को अनदेखा करते हैं जिनमें कोई कुंजी-जोड़ी नहीं होती है। हमारे उदाहरण में, तालिका 1 में मान E मौजूद नहीं है, इसलिए उस पंक्ति को हटा दिया जाता है। मान F मूल तालिका से आता है, इसलिए left_join() के बाद इसे रखा जाता है और कॉलम z में NA मान प्राप्त होता है।
dplyr left_join() का उदाहरण
नीचे दिया गया आरेख दर्शाता है कि left_join() के दौरान क्या होता है।
left_join(df_primary, df_secondary, by ='ID')
आउटपुट:
## # A tibble: 5 x 3 ## ID y.x y.y ## <chr> <dbl> <dbl> ## 1 A 5 30 ## 2 B 5 21 ## 3 C 8 22 ## 4 D 0 25 ## 5 F 9 NA
ध्यान दें कि जब दोनों तालिकाओं में एक ही नाम का कॉलम होता है, तो dplyr उन्हें ऊपर दिखाए गए .x और .y प्रत्ययों के साथ अलग करता है।
dplyr right_join()
right_join() फ़ंक्शन बिल्कुल left_join() की तरह काम करता है। एकमात्र अंतर यह है कि पंक्ति हटा दी गई है। गंतव्य डेटा फ़्रेम में उपलब्ध मान E, नई तालिका में मौजूद है और कॉलम y के लिए मान NA लेता है।
dplyr right_join() का उदाहरण
नीचे दिया गया चित्र दर्पण प्रतिबिंब को दर्शाता है।
right_join(df_primary, df_secondary, by = 'ID')
आउटपुट:
## # A tibble: 5 x 3 ## ID y.x y.y ## <chr> <dbl> <dbl> ## 1 A 5 30 ## 2 B 5 21 ## 3 C 8 22 ## 4 D 0 25 ## 5 E NA 29
dplyr inner_join()
जब बेमेल अवलोकन बिल्कुल भी उपयोगी नहीं होते हैं, तो हम वापस लौट सकते हैं। केवल वे पंक्तियाँ जो मौजूद हैं के छात्रों डेटासेट। यह तब सही विकल्प है जब हमें एक पूर्ण डेटासेट की आवश्यकता होती है और हम माध्य या माध्यिका के साथ लुप्त मानों को भरना नहीं चाहते हैं।
यहां inner_join() फ़ंक्शन काम आता है। यह दोनों तरफ की बेमेल पंक्तियों को हटा देता है।
dplyr inner_join() का उदाहरण
नीचे दिया गया आरेख उन चार आईडी को दर्शाता है जो जॉइन प्रक्रिया के बाद भी बनी रहती हैं।
inner_join(df_primary, df_secondary, by ='ID')
आउटपुट:
## # A tibble: 4 x 3 ## ID y.x y.y ## <chr> <dbl> <dbl> ## 1 A 5 30 ## 2 B 5 21 ## 3 C 8 22 ## 4 D 0 25
dplyr full_join()
अंत में, full_join() फ़ंक्शन सभी ऑब्ज़र्वेशन को रखता है और मिसिंग वैल्यू को NA से बदल देता है।
dplyr full_join() का उदाहरण
नीचे दिया गया आरेख दोनों तालिकाओं के उन सभी आईडी को दर्शाता है जो जॉइन प्रक्रिया में बचे रहते हैं।
full_join(df_primary, df_secondary, by = 'ID')
आउटपुट:
## # A tibble: 6 x 3 ## ID y.x y.y ## <chr> <dbl> <dbl> ## 1 A 5 30 ## 2 B 5 21 ## 3 C 8 22 ## 4 D 0 25 ## 5 F 9 NA ## 6 E NA 29
एकाधिक कुंजी जोड़े
अंत में, हमारे डेटासेट में कई कुंजियाँ हो सकती हैं। निम्नलिखित डेटासेट पर विचार करें जहाँ हमारे पास वर्ष और ग्राहक द्वारा खरीदे गए उत्पादों की सूची है। नीचे दिया गया स्क्रीनशॉट दो तालिकाओं और आईडी और वर्ष कॉलम को दर्शाता है जो मिलकर एक पंक्ति की पहचान करते हैं।
यदि हम दोनों तालिकाओं को केवल ID के आधार पर जोड़ते हैं, तो प्रत्येक वर्ष का मिलान प्रत्येक वर्ष से हो जाता है और पंक्तियों की संख्या बहुत बढ़ जाती है। इस समस्या को दूर करने के लिए, हम दो कुंजी-जोड़ी चर (की-पेयर) पास कर सकते हैं: ID और वर्ष, जो दोनों डेटासेट में मौजूद हैं। तालिका 1 और तालिका 2 को मर्ज करने के लिए हम निम्नलिखित कोड का उपयोग कर सकते हैं:
df_primary <- tribble( ~ID, ~year, ~items, "A", 2015,3, "A", 2016,7, "A", 2017,6, "B", 2015,4, "B", 2016,8, "B", 2017,7, "C", 2015,4, "C", 2016,6, "C", 2017,6) df_secondary <- tribble( ~ID, ~year, ~prices, "A", 2015,9, "A", 2016,8, "A", 2017,12, "B", 2015,13, "B", 2016,14, "B", 2017,6, "C", 2015,15, "C", 2016,15, "C", 2017,13) left_join(df_primary, df_secondary, by = c('ID', 'year'))
आउटपुट:
## # A tibble: 9 x 4 ## ID year items prices ## <chr> <dbl> <dbl> <dbl> ## 1 A 2015 3 9 ## 2 A 2016 7 8 ## 3 A 2017 6 12 ## 4 B 2015 4 13 ## 5 B 2016 8 14 ## 6 B 2017 7 6 ## 7 C 2015 4 15 ## 8 C 2016 6 15 ## 9 C 2017 6 13
dplyr 1.1.0 (जनवरी 2023) के बाद से, एक ही कुंजी को join_by(ID, year) के रूप में लिखा जा सकता है, और dplyr अब अप्रत्याशित कई-से-कई मिलानों के बारे में चेतावनी देता है, क्योंकि dplyr 1.1.0 की घोषणा जारी की गई बताते हैं।
आर में डेटा क्लीनिंग फ़ंक्शन
विलय करने से समस्या का केवल आधा समाधान होता है, क्योंकि संयुक्त तालिका को अभी भी पुनर्व्यवस्थित करना पड़ता है। डेटा को व्यवस्थित (साफ़) करने के लिए निम्नलिखित चार महत्वपूर्ण कार्य हैं:
| समारोह | उद्देश्य | तर्क |
|---|---|---|
| इकट्ठा करना() | डेटा को चौड़े से लंबे में बदलें | (डेटा, कुंजी, मान, na.rm = गलत) |
| फैलाना() | डेटा को लंबे से चौड़े में बदलें | (डेटा, कुंजी, मान) |
| अलग करना() | एक चर को दो भागों में विभाजित करें | (डेटा, कॉलम, में, पृथक्करण = "", हटाएं = TRUE) |
| एकजुट() | दो चरों को एक में मिलाएँ | (डेटा, कॉलम, कॉन्सेंट्रेशन, सेपरेट = "", रिमूव = TRUE) |
संस्करण नोट: tidyr 1.0.0 में gather() और spread() को pivot_longer() और pivot_wider() द्वारा प्रतिस्थापित कर दिया गया था, और tidyr 1.3.0 में separate() को separate_wider_delim() परिवार द्वारा प्रतिस्थापित कर दिया गया था। प्रतिस्थापित किए गए फ़ंक्शन अभी भी चलते हैं, इसलिए नीचे दिए गए सभी उदाहरण काम करते हैं, लेकिन नए कोड को नए परिवारों को प्राथमिकता देनी चाहिए जो चित्र में दिखाए गए हैं। टाइडीआर पिवोटिंग विग्नेट. unite() वर्तमान बना हुआ है।
हम डेटा को संभालने, साफ़ करने और विज़ुअलाइज़ करने के लिए टाइडिवर्स संग्रह के हिस्से टाइडिर पैकेज का उपयोग करते हैं। यदि आर को एनाकोंडा के साथ स्थापित किया गया था, तो पैकेज पहले से ही उपलब्ध है। https://anaconda.org/r/r-tidyr.
यदि यह पहले से स्थापित नहीं है, तो tidyr को स्थापित करने के लिए निम्नलिखित कमांड दर्ज करें:
install.packages("tidyr")
इकट्ठा करना()
gather() फ़ंक्शन का उद्देश्य डेटा को वाइड से लॉन्ग में बदलना है।
वाक्य - विन्यास
gather(data, key, value, na.rm = FALSE) Arguments: -data: The data frame used to reshape the dataset -key: Name of the new column created -value: Select the columns used to fill the key column -na.rm: Remove missing values. FALSE by default
उदाहरण
नीचे, हम रेशम की अवधारणा को देख सकते हैं।ping चौड़ाई से लंबाई में रूपांतरण। हम 'विकास' नामक एक एकल स्तंभ बनाना चाहते हैं, जिसमें तिमाही चरों की पंक्तियाँ भरी जाएँ। नीचे दिए गए चित्र में बाईं ओर चौड़ी तालिका और दाईं ओर पुनर्गठित लंबी तालिका दिखाई गई है।
library(tidyr) # Create a messy dataset messy <- data.frame( country = c("A", "B", "C"), q1_2017 = c(0.03, 0.05, 0.01), q2_2017 = c(0.05, 0.07, 0.02), q3_2017 = c(0.04, 0.05, 0.01), q4_2017 = c(0.03, 0.02, 0.04)) messy
आउटपुट:
## country q1_2017 q2_2017 q3_2017 q4_2017 ## 1 A 0.03 0.05 0.04 0.03 ## 2 B 0.05 0.07 0.05 0.02 ## 3 C 0.01 0.02 0.01 0.04
# Reshape the data
tidier <-messy %>%
gather(quarter, growth, q1_2017:q4_2017)
tidier
आउटपुट:
## country quarter growth ## 1 A q1_2017 0.03 ## 2 B q1_2017 0.05 ## 3 C q1_2017 0.01 ## 4 A q2_2017 0.05 ## 5 B q2_2017 0.07 ## 6 C q2_2017 0.02 ## 7 A q3_2017 0.04 ## 8 B q3_2017 0.05 ## 9 C q3_2017 0.01 ## 10 A q4_2017 0.03 ## 11 B q4_2017 0.02 ## 12 C q4_2017 0.04
gather() फ़ंक्शन में, हम दो नए वैरिएबल, quarter और growth बनाते हैं, क्योंकि हमारे मूल डेटासेट में एक ग्रुप वैरिएबल, country, और key-value जोड़े हैं। tidyr 1.0.0 और उसके बाद के संस्करणों में, इसी रीशेप को pivot_longer(messy, cols = q1_2017:q4_2017, names_to = “quarter”, values_to = “growth”) के रूप में लिखा जाता है।
फैलाना()
spread() फ़ंक्शन gather() फ़ंक्शन के विपरीत कार्य करता है।
वाक्य - विन्यास
spread(data, key, value) arguments: data: The data frame used to reshape the dataset key: Column to reshape long to wide value: Rows used to fill the new column
उदाहरण
हम spread() फ़ंक्शन का उपयोग करके सुव्यवस्थित डेटासेट को वापस अव्यवस्थित बना सकते हैं।
# Reshape the data
messy_1 <- tidier %>%
spread(quarter, growth)
messy_1
आउटपुट:
## country q1_2017 q2_2017 q3_2017 q4_2017 ## 1 A 0.03 0.05 0.04 0.03 ## 2 B 0.05 0.07 0.05 0.02 ## 3 C 0.01 0.02 0.01 0.04
इसका आधुनिक समकक्ष pivot_wider(tidier, names_from = quarter, values_from = growth) है।
अलग करना()
separate() फ़ंक्शन एक कॉलम को विभाजक के आधार पर दो भागों में विभाजित करता है। यह फ़ंक्शन उन स्थितियों में उपयोगी है जहाँ चर एक तिथि है। हमारे विश्लेषण में महीने और वर्ष पर ध्यान केंद्रित करना आवश्यक हो सकता है, और हम कॉलम को दो नए चरों में अलग करना चाहते हैं।
वाक्य - विन्यास
separate(data, col, into, sep= "", remove = TRUE) arguments: -data: The data frame used to reshape the dataset -col: The column to split -into: The name of the new variables -sep: Indicates the symbol used that separates the variable, i.e.: "-", "_", "&" -remove: Remove the old column. By default sets to TRUE.
उदाहरण
हम separate() फ़ंक्शन को लागू करके वर्ष से तिमाही को अधिक सुव्यवस्थित डेटासेट में विभाजित कर सकते हैं।
separate_tidier <-tidier %>% separate(quarter, c("Qrt", "year"), sep ="_") head(separate_tidier)
आउटपुट:
## country Qrt year growth ## 1 A q1 2017 0.03 ## 2 B q1 2017 0.05 ## 3 C q1 2017 0.01 ## 4 A q2 2017 0.05 ## 5 B q2 2017 0.07 ## 6 C q2 2017 0.02
एकजुट()
unite() फ़ंक्शन दो कॉलम को एक में जोड़ता है।
वाक्य - विन्यास
unite(data, col, conc ,sep= "", remove = TRUE) arguments: -data: The data frame used to reshape the dataset -col: Name of the new column -conc: Name of the columns to concatenate -sep: Indicates the symbol used that unites the variable, i.e: "-", "_", "&" -remove: Remove the old columns. By default, sets to TRUE
उदाहरण
ऊपर दिए गए उदाहरण में, हमने तिमाही को वर्ष से अलग किया है। अगर हम इन्हें मर्ज करना चाहें तो क्या होगा? इसके लिए हम निम्नलिखित कोड का उपयोग करेंगे:
unit_tidier <- separate_tidier %>%
unite(Quarter, Qrt, year, sep ="_")
head(unit_tidier)
आउटपुट:
## country Quarter growth ## 1 A q1_2017 0.03 ## 2 B q1_2017 0.05 ## 3 C q1_2017 0.01 ## 4 A q2_2017 0.05 ## 5 B q2_2017 0.07 ## 6 C q2_2017 0.02
पुनर्गठित डेटा फ्रेम अब मॉडलिंग चरणों के लिए तैयार है, जिनका वर्णन शेष भाग में किया गया है। आर ट्यूटोरियल श्रृंखला.
